What does the explicit keyword mean

Question

What does the explicit keyword mean in C

User · Answer

The explicit keyword makes a conversion constructor to non-conversion constructor  As a result  the code is less error prone

User · Answer

This answer is about object creation with without an explicit constructor since it is not covered in the other answers   Consider the following class without an explicit constructor   class Foo   public      Foo int x    m x x               private      int m x       Objects of class Foo can be created in 2 ways   Foo bar1 10    Foo bar2   20    Depending upon the implementation  the second manner of instantiating class Foo may be confusing  or not what the programmer intended  Prefixing the explicit keyword to the constructor would generate a compiler error at Foo bar2   20    It is usually good practice to declare single-argument constructors as explicit  unless your implementation specifically prohibits it   Note also that constructors with   default arguments for all parameters  or default arguments for the second parameter onwards   can both be used as single-argument constructors  So you may want to make these also explicit   An example when you would deliberately not want to make your single-argument constructor explicit is if you re creating a functor  look at the  add x  struct declared in this answer   In such a case  creating an object as add x add30   30  would probably make sense   Here is a good write-up on explicit constructors

User · Answer

Constructors append implicit conversion  To suppress this implicit conversion it is required to declare a constructor with a parameter explicit   In C  11 you can also specify an  operator type    with such keyword http   en cppreference com w cpp language explicit With such specification you can use operator in terms of explicit conversions  and direct initialization of object   P S  When using transformations defined BY USER  via constructors and type conversion operator  it is allowed only one level of implicit conversions used  But you can combine this conversions with other language conversions   up integral ranks  char to int  float to double    standart conversions  int to double    convert pointers of objects to base class and to void

User · Answer

The compiler is allowed to make one implicit conversion to resolve the parameters to a function  What this means is that the compiler can use constructors callable with a single parameter to convert from one type to another in order to get the right type for a parameter  Here s an example class with a constructor that can be used for implicit conversions  class Foo   public       single parameter constructor  can be used as an implicit conversion   Foo  int foo    m foo  foo              int GetFoo      return m foo     private    int m foo      Here s a simple function that takes a Foo object  void DoBar  Foo foo      int i   foo GetFoo        and here s where the DoBar function is called  int main        DoBar  42      The argument is not a Foo object  but an int  However  there exists a constructor for Foo that takes an int so this constructor can be used to convert the parameter to the correct type  The compiler is allowed to do this once for each parameter  Prefixing the explicit keyword to the constructor prevents the compiler from using that constructor for implicit conversions  Adding it to the above class will create a compiler error at the function call DoBar  42    It is now necessary to call for conversion explicitly with  DoBar  Foo  42   The reason you might want to do this is to avoid accidental construction that can hide bugs  Contrived example   You have a MyString int size  class with a constructor that constructs a string of the given size   You have a function print const MyString amp    and you call print 3   when you actually intended to call print  quot 3 quot      You expect it to print  quot 3 quot   but it prints an empty string of length 3 instead

User · Answer

Cpp Reference is always helpful    Details about explicit specifier can be found here   You may need to look at implicit conversions and copy-initialization too   Quick look     The explicit specifier specifies that a constructor or conversion function  since C  11  doesn t allow implicit conversions or copy-initialization     Example as follows   struct A       A int              converting constructor     A int  int         converting constructor  C  11      operator bool   const   return true        struct B       explicit B int          explicit B int  int          explicit operator bool   const   return true        int main         A a1   1          OK  copy-initialization selects A  A int      A a2 2            OK  direct-initialization selects A  A int      A a3  4  5        OK  direct-list-initialization selects A  A int  int      A a4    4  5      OK  copy-list-initialization selects A  A int  int      A a5    A 1       OK  explicit cast performs static cast     if  a1  cout  lt  lt   true   lt  lt  endl     OK  A  operator bool       bool na1   a1     OK  copy-initialization selects A  operator bool       bool na2   static cast lt bool gt  a1      OK  static cast performs direct-initialization      B b1   1          error  copy-initialization does not consider B  B int      B b2 2            OK  direct-initialization selects B  B int      B b3  4  5        OK  direct-list-initialization selects B  B int  int      B b4    4  5      error  copy-list-initialization does not consider B  B int int      B b5    B 1       OK  explicit cast performs static cast     if  b5  cout  lt  lt   true   lt  lt  endl     OK  B  operator bool       bool nb1   b2     error  copy-initialization does not consider B  operator bool       bool nb2   static cast lt bool gt  b2      OK  static cast performs direct-initialization

User · Answer

It is always a good coding practice to make your one argument constructors  including those with default values for arg2 arg3      as already stated   Like always with C    if you don t - you ll wish you did     Another good practice for classes is to make copy construction and assignment private  a k a  disable it  unless you really need to implement it  This avoids having eventual copies of pointers when using the methods that C   will create for you by default  An other way to do this is derive from boost  noncopyable

User · Answer

The keyword explicit accompanies either   a constructor of class X that cannot be used to implicitly convert the first  any only  parameter to type X      C    class conv ctor       1  A constructor declared without the function-specifier explicit specifies a conversion from the types of its parameters to the type of its class  Such a constructor is called a converting constructor       2  An explicit constructor constructs objects just like non-explicit constructors  but does so only where the direct-initialization syntax  8 5  or where casts  5 2 9  5 4  are explicitly used  A default constructor may be an explicit constructor  such a constructor will be used to perform default-initialization or valueinitialization    8 5      or a conversion function that is only considered for direct initialization and explicit conversion       C    class conv fct       2  A conversion function may be explicit  7 1 2   in which case it is only considered as a user-defined conversion for direct-initialization  8 5   Otherwise  user-defined conversions are not restricted to use in assignments   and initializations    Overview  Explicit conversion functions and constructors can only be used for explicit conversions  direct initialization or explicit cast operation  while non-explicit constructors and conversion functions can be used for implicit as well as explicit conversions                                       explicit conversion          implicit conversion   explicit constructor                    yes                          no   constructor                             yes                          yes   explicit conversion function            yes                          no   conversion function                     yes                          yes       Example using structures X  Y  Z and functions foo  bar  baz   Let s look at a small setup of structures and functions to see the difference between explicit and non-explicit conversions   struct Z       struct X      explicit X int a      X can be constructed from int explicitly   explicit operator Z        X can be converted to Z explicitly     struct Y    Y int a      int can be implicitly converted to Y   operator Z        Y can be implicitly converted to Z     void foo X x      void bar Y y      void baz Z z        Examples regarding constructor   Conversion of a function argument   foo 2                          error  no implicit conversion int to X possible foo X 2                        OK  direct initialization  explicit conversion foo static cast lt X gt  2           OK  explicit conversion  bar 2                          OK  implicit conversion via Y int   bar Y 2                        OK  direct initialization bar static cast lt Y gt  2           OK  explicit conversion   Object initialization   X x2   2                       error  no implicit conversion int to X possible X x3 2                         OK  direct initialization X x4   X 2                     OK  direct initialization X x5   static cast lt X gt  2        OK  explicit conversion   Y y2   2                       OK  implicit conversion via Y int  Y y3 2                         OK  direct initialization Y y4   Y 2                     OK  direct initialization Y y5   static cast lt Y gt  2        OK  explicit conversion   Examples regarding conversion functions   X x1  0    Y y1  0      Conversion of a function argument   baz x1                         error  X not implicitly convertible to Z baz Z x1                       OK  explicit initialization baz static cast lt Z gt  x1          OK  explicit conversion  baz y1                         OK  implicit conversion via Y  operator Z   baz Z y1                       OK  direct initialization baz static cast lt Z gt  y1          OK  explicit conversion   Object initialization   Z z1   x1                      error  X not implicitly convertible to Z Z z2 x1                        OK  explicit initialization Z z3   Z x1                    OK  explicit initialization Z z4   static cast lt Z gt  x1       OK  explicit conversion  Z z1   y1                      OK  implicit conversion via Y  operator Z   Z z2 y1                        OK  direct initialization Z z3   Z y1                    OK  direct initialization Z z4   static cast lt Z gt  y1       OK  explicit conversion   Why use explicit conversion functions or constructors   Conversion constructors and non-explicit conversion functions may introduce ambiguity   Consider a structure V  convertible to int  a structure U implicitly constructible from V and a function f overloaded for U and bool respectively   struct V     operator bool   const   return true        struct U   U V          void f U      void f bool         A call to f is ambiguous if passing an object of type V   V x  f x       error  call of overloaded  f V amp    is ambiguous   The compiler does not know wether to use the constructor of U or the conversion function to convert the V object into a type for passing to f    If either the constructor of U or the conversion function of V would be explicit  there would be no ambiguity since only the non-explicit conversion would be considered  If both are explicit the call to f using an object of type V would have to be done using an explicit conversion or cast operation   Conversion constructors and non-explicit conversion functions may lead to unexpected behaviour   Consider a function printing some vector   void print intvector std  vector lt int gt  const  amp v    for  int x   v  std  cout  lt  lt  x  lt  lt    n       If the size-constructor of the vector would not be explicit it would be possible to call the function like this   print intvector 3     What would one expect from such a call  One line containing 3 or three lines containing 0   Where the second one is what happens    Using the explicit keyword in a class interface enforces the user of the interface to be explicit about a desired conversion   As Bjarne Stroustrup  puts it  in  The C   Programming Language   4th Ed   35 2 1  pp  1011  on the question why std  duration cannot be implicitly constructed from a plain number      If you know what you mean  be explicit about it

User · Answer

In C    a constructor with only one required parameter is considered an implicit conversion function   It converts the parameter type to the class type   Whether this is a good thing or not depends on the semantics of the constructor   For example  if you have a string class with constructor String const char  s   that s probably exactly what you want   You can pass a const char  to a function expecting a String  and the compiler will automatically construct a temporary String object for you   On the other hand  if you have a buffer class whose constructor Buffer int size  takes the size of the buffer in bytes  you probably don t want the compiler to quietly turn ints into Buffers   To prevent that  you declare the constructor with the explicit keyword   class Buffer   explicit Buffer int size           That way   void useBuffer Buffer amp  buf   useBuffer 4     becomes a compile-time error   If you want to pass a temporary Buffer object  you have to do so explicitly   useBuffer Buffer 4      In summary  if your single-parameter constructor converts the parameter into an object of your class  you probably don t want to use the explicit keyword   But if you have a constructor that simply happens to take a single parameter  you should declare it as explicit to prevent the compiler from surprising you with unexpected conversions

User · Answer

The explicit-keyword can be used to enforce a constructor to be called explicitly   class C  public      explicit C void    default      int main void       C c        return 0      the explicit-keyword in front of the constructor C void  tells the compiler that only explicit call to this constructor is allowed   The explicit-keyword can also be used in user-defined type cast operators   class C  public      explicit inline operator bool void  const          return true            int main void       C c      bool b   static cast lt bool gt  c       return 0      Here  explicit-keyword enforces only explicit casts to be valid  so bool b   c  would be an invalid cast in this case  In situations like these explicit-keyword can help programmer to avoid implicit  unintended casts  This usage has been standardized in C  11

User · Answer

Suppose  you have a class String   class String   public      String int n      allocate n bytes to the String object     String const char  p      initializes object with char  p      Now  if you try   String mystring    x     The character  x  will be implicitly converted to int and then the String int  constructor will be called  But  this is not what the user might have intended  So  to prevent such conditions  we shall define the constructor as explicit   class String   public      explicit String  int n     allocate n bytes     String const char  p      initialize sobject with string p

User · Answer

Explicit conversion constructors  C   only      The explicit function specifier controls unwanted implicit type   conversions  It can only be used in declarations of constructors   within a class declaration  For example  except for the default   constructor  the constructors in the following class are conversion   constructors    class A   public      A        A int       A const char   int   0        The following declarations are legal   A c   1  A d    Venditti     The first declaration is equivalent to A c   A  1      If you declare the constructor of the class as explicit  the previous declarations would be illegal   For example  if you declare the class as   class A   public      explicit A        explicit A int       explicit A const char   int   0        You can only assign values that match the values of the class type   For example  the following statements are legal     A a1    A a2   A 1     A a3 1     A a4   A  Venditti      A  p   new A 1     A a5    A 1    A a6   static cast lt A gt  1

[c++] What does the explicit keyword mean?

Examples related to c++

Examples related to constructor

Examples related to explicit

Examples related to c++-faq

Examples related to explicit-constructor