What is a converting constructor in C++ ? What is it for?

by

The definition for a converting constructor is different between C++03 and C++11. In both cases it must be a non-explicit constructor (otherwise it wouldn’t be involved in implicit conversions), but for C++03 it must also be callable with a single argument. That is:

struct foo
{
  foo(int x);              // 1
  foo(char* s, int x = 0); // 2
  foo(float f, int x);     // 3
  explicit foo(char x);    // 4
};

Constructors 1 and 2 are both converting constructors in C++03 and C++11. Constructor 3, which must take two arguments, is only a converting constructor in C++11. The last, constructor 4, is not a converting constructor because it is explicit.

  • C++03: §12.3.1

    A constructor declared without the function-specifier explicit that can be called with a single parameter specifies a conversion from the type of its first parameter to the type of its class. Such a constructor is called a converting constructor.

  • C++11: §12.3.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.

Why are constructors with more than a single parameter considered to be converting constructors in C++11? That is because the new standard provides us with some handy syntax for passing arguments and returning values using braced-init-lists. Consider the following example:

foo bar(foo f)
{
  return {1.0f, 5};
}

The ability to specify the return value as a braced-init-list is considered to be a conversion. This uses the converting constructor for foo that takes a float and an int. In addition, we can call this function by doing bar({2.5f, 10}). This is also a conversion. Since they are conversions, it makes sense for the constructors they use to be converting constructors.

It is important to note, therefore, that making the constructor of foo which takes a float and an int have the explicit function specifier would stop the above code from compiling. The above new syntax can only be used if there is a converting constructor available to do the job.

  • C++11: §6.6.3:

    A return statement with a braced-init-list initializes the object or reference to be returned from the function by copy-list-initialization (8.5.4) from the specified initializer list.

    §8.5:

    The initialization that occurs […] in argument passing […] is called copy-initialization.

    §12.3.1:

    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.

More Related Contents:

  1. Why should the copy constructor accept its parameter by reference in C++?
  2. Why copy constructor is not called in this case?
  3. The copy constructor and assignment operator
  4. What’s the most reliable way to prohibit a copy constructor in C++?
  5. constructor invocation mechanism
  6. Why aren’t copy constructors “chained” like default constructors and destructors?
  7. C++ copy-construct construct-and-assign question
  8. What does the explicit keyword mean?
  9. What is this weird colon-member (” : “) syntax in the constructor?
  10. Do built-in types have default constructors?
  11. How do I call the base class constructor?
  12. Conversion constructor vs. conversion operator: precedence
  13. C++: constructor initializer for arrays
  14. When do we have to use copy constructors?
  15. Scope of variables in if statements
  16. How can I initialize C++ object member variables in the constructor?
  17. How can i use member initialization list to initialize an array?
  18. Do I really need to implement user-provided constructor for const objects?
  19. Can class template constructors have a redundant template parameter list in c++20
  20. Will an ’empty’ constructor or destructor do the same thing as the generated one?
  21. What destructors are run when the constructor throws an exception?
  22. Struct Constructor in C++?
  23. Initializing a union with a non-trivial constructor
  24. Constructor initialization Vs assignment
  25. No matching function for call to Class Constructor
  26. Why am I not provided with a default copy constructor from a volatile?
  27. Default member values best practice
  28. Scope resolution operator being used twice
  29. Calling a constructor to re-initialize object
  30. C++ Constructor/Destructor inheritance

Leave a Comment