我知道如果在无参数构造函数的初始化列表中省略了成员，那么该成员的默认构造函数将被调用。
那么复制构造函数是否也会调用成员的复制构造函数，还是也会调用默认构造函数？
class myClass {
private:
someClass a;
someOtherClass b;
public:
myClass() : a(DEFAULT_A) {} //implied is b()
myClass(const myClass& mc) : a(mc.a) {} //implied is b(mc.b)??? or is it b()?
}
显式定义的复制构造函数不会调用成员的复制构造函数。
当您进入构造函数的主体时，该类的每个成员都将被初始化。也就是说，一旦您到达 { ，则可以保证所有成员都已经被初始化。
除非另有规定，否则成员按它们出现在类中的顺序进行默认初始化。 （如果不能这样做，则程序无效。）因此，如果您定义自己的复制构造函数，现在就需要您根据需要调用任何成员复制构造函数。
以下是一个小程序，您可以将其复制粘贴到某个地方并随意更改：
#include <iostream>
class Foo {
public:
Foo() {
std::cout << "In Foo::Foo()" << std::endl;
}
Foo(const Foo& rhs) {
std::cout << "In Foo::Foo(const Foo&)" << std::endl;
}
};
class Bar {
public:
Bar() {
std::cout << "In Bar::Bar()" << std::endl;
}
Bar(const Bar& rhs) {
std::cout << "In Bar::Bar(const Bar&)" << std::endl;
}
};
class Baz {
public:
Foo foo;
Bar bar;
Baz() {
std::cout << "In Baz::Baz()" << std::endl;
}
Baz(const Baz& rhs) {
std::cout << "In Baz::Baz(const Baz&)" << std::endl;
}
};
int main() {
Baz baz1;
std::cout << "Copying..." << std::endl;
Baz baz2(baz1);
}
原样输出如下：
In Foo::Foo() In Bar::Bar() In Baz::Baz() Copying... In Foo::Foo() In Bar::Bar() In Baz::Baz(const Baz&)
请注意，这里是默认初始化了Baz的成员。
如果注释掉显式复制构造函数，如下所示：
/*
Baz(const Baz& rhs) {
std::cout << "In Baz::Baz(const Baz&)" << std::endl;
}
*/
在 Foo::Foo() 中 在 Bar::Bar() 中 在 Baz::Baz() 中 复制…… 在 Foo::Foo(const Foo&) 中 在 Bar::Bar(const Bar&) 中它会调用两个对象的复制构造函数。
Baz 的复制构造函数并显式复制单个成员：Baz(const Baz& rhs) :
foo(rhs.foo)
{
std::cout << "In Baz::Baz(const Baz&)" << std::endl;
}
在 Foo::Foo() 在 Bar::Bar() 在 Baz::Baz() 复制... 在 Foo::Foo(const Foo&) 在 Bar::Bar() 在 Baz::Baz(const Baz&)如你所见，一旦你显式声明了一个复制构造函数，你就要负责复制所有类成员；现在是你的构造函数。
对于任何具有默认构造函数的成员变量，如果您未在初始化列表中显式添加任何其他构造函数调用，则将调用该默认构造函数。
该句话涉及到IT技术相关内容。struct ABC{
int a;
ABC() : a(0) { printf("Default Constructor Called %d\n", a); };
ABC(ABC & other )
{
a=other.a;
printf("Copy constructor Called %d \n" , a ) ;
};
};
struct ABCDaddy{
ABC abcchild;
};
你可以进行以下测试：
printf("\n\nTest two, where ABC is a member of another structure\n" );
ABCDaddy aD;
aD.abcchild.a=2;
printf( "\n Test: ABCDaddy bD=aD; \n" );
ABCDaddy bD=aD; // Does call the copy constructor of the members of the structure ABCDaddy ( ie. the copy constructor of ABC is called)
printf( "\n Test: ABCDaddy cD(aD); \n" );
ABCDaddy cD(aD); // Does call the copy constructor of the members of the structure ABCDaddy ( ie. the copy constructor of ABC is called)
printf( "\n Test: ABCDaddy eD; eD=aD; \n" );
ABCDaddy eD;
eD=aD; // Does NOT call the copy constructor of the members of the structure ABCDaddy ( ie. the copy constructor of ABC is not called)
输出：
Default Constructor Called 0
Test: ABCDaddy bD=aD;
Copy constructor Called 2
Test: ABCDaddy cD(aD);
Copy constructor Called 2
Test: ABCDaddy eD; eD=aD;
Default Constructor Called 0
享受。
不在VC9中。其他的我不确定。
// compiled as: cl /EHsc contest.cpp
//
// Output was:
// Child1()
// -----
// Child1()
// Child2()
// Parent()
// -----
// Child1(Child1&)
// Child2()
// Parent(Parent&)
#include <cstdio>
class Child1 {
int x;
public:
static Child1 DEFAULT;
Child1(){
x = 0;
printf("Child1()\n");
}
Child1(Child1 &other){
x = other.x;
printf("Child1(Child1&)\n");
}
};
Child1 Child1::DEFAULT;
class Child2 {
int x;
public:
Child2(){
x = 0;
printf("Child2()\n");
}
Child2(Child2 &other){
x = other.x;
printf("Child2(Child2&)\n");
}
};
class Parent {
int x;
Child1 c1;
Child2 c2;
public:
Parent(){
printf("Parent()\n");
}
Parent(Parent &other) : c1(Child1::DEFAULT) {
printf("Parent(Parent&)\n");
}
};
int main(){
printf("-----\n");
Parent p1;
printf("-----\n");
Parent p2(p1);
return 0;
}
是的。构造函数就是构造函数。
当编译器提供默认的复制构造函数时，您认为编译器会为成员变量做什么？它会进行复制构造。
同样地，如果复制构造函数是用户定义的，并且如果省略了某些成员，则这些成员不能保持未初始化状态。类不变式在构造期间被建立并且必须不断维护。所以，编译器会替您完成这些工作。
拷贝构造函数并没有什么神奇的地方，除了编译器在需要时会自动添加它。但实际运行时，没有什么特别之处 - 如果您没有明确指定“使用这样那样的构造函数”，它将使用默认值。