Question

Am I doing this right? This is a highly simplified version of my code:

class Logger {
   public:
      Logger(std::ostream) { /*...*/}
};

class Driver {
public:
   Driver() : m_logger(std::cout) {}
   Driver(Logger& logger) : m_logger(logger) {}
private
   Logger m_logger;
};

So my class Driver has a member of type Logger. When I call the argument-less constructor Driver(), the instance of Driver creates its own instance of Logger using std::cout.

When calling Driver(Logger) the instance shall use an already existing instance of Logger passed as a reference.

The above code compiles using g++. Although I understand what happens when calling Driver(), I don’t get what happens when calling Driver(Logger). Logger has no constructor which accepts a reference on Logger as argument (“copy constructor”). So what is executed when calling Driver(Logger)?

Answer 1

A trivial copy constructor for Logger is synthesised for you, unless you declare one yourself.

This is much the same as how a trivial default constructor is synthesised for you (if you don’t declare a default user-defined constructor).

---

[C++11: 12.8/7]: If the class definition does not explicitly declare a copy constructor, one is declared implicitly. If the class definition declares a move constructor or move assignment operator, the implicitly declared copy constructor
is defined as deleted; otherwise, it is defined as defaulted (8.4). The latter case is deprecated if the class has a user-declared copy assignment operator or a user-declared destructor. Thus, for the class definition

struct X {
   X(const X&, int);
};

a copy constructor is implicitly-declared. If the user-declared constructor is later defined as

X::X(const X& x, int i =0) { /* ... */ }

then any use of X’s copy constructor is ill-formed because of the ambiguity; no diagnostic is required.

[C++11: 12.8/8]: The implicitly-declared copy constructor for a class X will have the form

X::X(const X&)

if

• each direct or virtual base class B of X has a copy constructor whose first parameter is of type const B& or const volatile B&, and
• for all the non-static data members of X that are of a class type M (or array thereof), each such class type has a copy constructor whose first parameter is of type const M& or const volatile M&.

Otherwise, the implicitly-declared copy constructor will have the form

X::X(X&)