If you do not declare a copy constructor for a class A, the compiler will implicitly declare one for you, which will be an inline public member.
The following example demonstrates implicitly defined and user-defined copy constructors:
#include
using namespace std;
struct A {
int i;
A() : i(10) { }
};
struct B {
int j;
B() : j(20) {
cout << "Constructor B(), j = " << j << endl;
}
B(B& arg) : j(arg.j) {
cout << "Copy constructor B(B&), j = " << j << endl;
}
B(const B&, int val = 30) : j(val) {
cout << "Copy constructor B(const B&, int), j = " << j << endl;
}
};
struct C {
C() { }
C(C&) { }
};
int main() {
A a;
A a1(a);
B b;
const B b_const;
B b1(b);
B b2(b_const);
const C c_const;
// C c1(c_const);
}
The following is the output of the above example:
Constructor B(), j = 20
Constructor B(), j = 20
Copy constructor B(B&), j = 20
Copy constructor B(const B&, int), j = 30
The statement A a1(a) creates a new object from a with an implicitly defined copy constructor. The statement B b1(b) creates a new object from b with the user-defined copy constructor B::B(B&). The statement B b2(b_const) creates a new object with the copy constructor B::B(const B&, int). The compiler would not allow the statement C c1(c_const) because a copy constructor that takes as its first parameter an object of type const C& has not been defined.
The implicitly declared copy constructor of a class A will have the form A::A(const A&) if the following are true:
The direct and virtual bases of A have copy constructors whose first parameters have been qualified with const or const volatile
The nonstatic class type or array of class type data members of A have copy constructors whose first parameters have been qualified with const or const volatile
If the above are not true for a class A, the compiler will implicitly declare a copy constructor with the form A::A(A&).
The compiler cannot allow a program in which the compiler must implicitly define a copy constructor for a class A and one or more of the following are true:
Class A has a nonstatic data member of a type which has an inaccessible or ambiguous copy constructor.
Class A is derived from a class which has an inaccessible or ambiguous copy constructor.
The compiler will implicitly define an implicitly declared constructor of a class A if you initialize an object of type A or an object derived from class A.
An implicitly defined copy constructor will copy the bases and members of an object in the same order that a constructor would initialize the bases and members of the object.
