Question

复制构造函数,求详解啊

Answer 1

int a=5;
fun(int b) {
...................

}
fun(a)；
函数中b怎么按照a复制的？其实就是将a的值赋给b。

class X；
X a;
fun(int b) {
...................
}
fun(a);
函数中b怎么按照a复制的？其实就是调用b的构造函数将a传进去构造对象b。

这个简单的例子能不能明白？

追问

cbook(const cbook&book)
:m_price(book.m_price)
{
m_chapternum=book.m_chapternum;
strcpy(m_bookname,book.m_bookname);
printf("复制构造函数被调用\n");
}

}帮我解释一下这个构造函数，求详解

追答

// const表示传入的对象是常量， cbook& 表示引用传入（如果不是引用传入，岂不是又有触发复制拷贝？）引用白话来说就是直接使用函数调用传入的那个对象。
cbook(const cbook&book)
:m_price(book.m_price) //构造过程中，m_price是自己的成员变量，等于传入的对象的成员变量m_price.
{
// 自己的m_chapternum等于传入的book对象的m_chapternum。也可以象m_price那么写。
m_chapternum=book.m_chapternum;

// 自己的m_bookname等于传入的book对象的m_bookname。不能象m_price那么写。深度复制。
strcpy(m_bookname,book.m_bookname);
printf("复制构造函数被调用\n");
}

例如：
cbook a;
cbook b(a); //也是拷贝构造
b的复制拷贝函数调用，a就是上面函数的那个参数。
结果：b的m_price，m_chapternum，m_bookname都从a那里拷贝过来。

Answer 2

复制构造函数　　复制构造函数（直接初始化、复制初始化、赋值、临时对象）
　　使用复制构造函数前应弄清的几个问题：何时调用复制构造函数，复制构造函数有何功能，为什么要定义自已的复制构造函数。
　　1．复制构造函数：当用户没有定义自已的复制构造函数时系统将生成一个默认的复制构造函数。当按值传递对象时，就会创建一个形参的临时对象，然后调用复制构造函数把临时对象的值复制给实参。
　　2．默认复制构造函数的功能：将一个对象的非静态成员的值逐个复制给另一个对象，注意复制的是成员的值，这种复制方式也称为浅复制。因为静态成员属于整个类，而不属于某个对象，所以调用复制构造函数时静态成员不会受到影响。
　　3．何时生成临时对象：
　　情形1：按值传递对象，注意是按值传递对象，按值传递意味着会创建一个原始对象的副本，
　　情形2：函数返回对象时。
　　情形3：用一个对象初始化另一个对象时，即复制初始化。语句hyong x=y和hyong x=hyong(y)这里y是hyong类型的对象，都将调用复制构造函数。但有可能创建临时对象，也有可能不创建临时对象而用复制构造函数直接初始化对象，这取决于编译器。
　　4．临时对象如何产生：临时对象是由复制构造函数创建的，当临时对象消失时会调用相应的析构函数。也就是说，只要创建了临时对象就会多调用一次析构函数。
　　5．何时使用复制构造函数：按值传递对象，函数返回对象，用一个对象初始化另一个对象（即复制初始化），根据元素初始化列表初始化数组元素，这四种情况都将调用复制构造函数。记住：复制构造函数只能用于初始化，不能用于赋值，赋值时不会调用复制构造函数，而是使用赋值操作符。
　　6．直接初始化：直接初始化，是把初始化式放在圆括号中的。对于类类型来说，直接初始化总是调用与实参匹配的构造函数来初始化的。
　　7．复制初始化与复制构造函数：复制初始化使用=等于符号来初始化，复制初始化也是创建一个新对象，并且其初值来自于另一个已存在的对象，复制初始化总是调用复制构造函数来初始化的。复制初始化时，首先使用指定的构造函数创建一个临时对象，然后用复制构造函数将临时对象的每个非static成员依次的复制到新创建的对象，复制构造函数执行的是逐个成员初始化。注意，这里是用一个已存在的对象创建另一个新对象，与用构造函数直接创建一个新对象不一样，使用构造函数初始化时不会使用另一个对象。比如有类hyong，则语句hyong m(1,2)调用构造函数直接初始化，而语句hyong n=m则是用已存在的对象m去初始化一个新对象n，属于复制初始化。
　　8．理解赋值与复制初始化的区别(重点)：赋值是在两个已存在的对象间进行的，也就是用一个已存在的对象去改变另一个已存在对象的值。赋值将调用赋值操作符对对象进行操作，赋值操作符将在操作符重载中讲解。比如有类hyong，有语句hyong x(1)；hyong y(1,2)则x=y；这就是赋值，因为对象x和y是已经存在的对象，而语句hyong x=y;则是复制初始化，是用一个已存在的对象y去创建一个新对象x，所以是复制初始化。
　　9．复制初始化和赋值是在两个对象之间进行的操作，而直接初始化则不是。
　　10．注意：使用复制构造函数不一定创建临时对象，就如语句hyong x=hyong(y)，其中y是hyong类型的对象，就有可能不创建临时对象，这取决于编译器。这里如果创建了临时对象，则当临时对象消亡时将调用一次析构函数；而如果没有调用，而是直接用复制构造函数初始化对象的，就不会调用析构函数。
　　11．复制构造函数的形式：hyong(const hyong & obj);它接受一个指向类对象的常量引用作为参数。定义为const是必须的，因为复制构造函数只是复制对象，所以没必要改变传递来的对象的值，声明为引用可以节省时间，如果是按值传递的话就会生成对象的副本，会浪费资源，而引用就不会。
　　12．为什么需要定义自己的复制构造函数：如果类只包含类类型成员和内置类型的成员，则可以不用显示定义复制构造函数。但如果类中包含有指针或者有分配其他类型资源时，就必须重新定义复制构造函数。因为类中有指针成员，当把用一个对象初始化另一个对象时，这时两个对象中的指针都指向同一段内存，这时如果其中一个对象被消毁了，这时对象中指针所指向的内存也同样被消毁，但另一个对象确不知道这种情况，这时就会出现问题。比如hyong类中含有一个成员指针p，当声明了hyong x=y其中y也是hyong类的对象，这时对象x和y中的指针成员p都指向同一段内存，而如果y被消毁，但x还没被消毁时就会出问题，这时y中对象的成员指针p已经释放了该内存资源，而x中的成员指针p还不知道已经释放了该资源，这时就会出问题。因为对象x和y中的成员指针共享同一段内存，所以对y中的成员指针p的修改就会影响到对象x中的成员指针。所有这些情况都需要重定义复制构造函数来显示的初始化成员的值，这种初始化方式也被称为深度复制。
　　13．如果显式定义了复制构造函数，则调用显式复制构造函数来直接初始化对象；如果没有显式定义复制构造函数，则调用默认的复制构造函数直接初始化对象。
　　14．注意：1．在VC++中语句hyong n=m不生成临时对象。但如果显式定义了复制构造函数，则调用显式复制构造函数来直接初始化对象n，如果没有显式定义复制构造函数，则调用默认的复制构造函数直接初始化对象n。2．在VC++中语句hyong m1=hyong(m)有可能生成临时对象，也有可能不生成临时对象。如果显式定义了复制构造函数，则用复制构造函数直接初始化对象m1，不生成临时对象；如果没有显式定义复制构造函数，则复制构造函数将创造临时对象，初始化对象m1。
　　15．C++自动提供的成员函数：默认构造函数，复制构造函数，默认析构函数，赋值操作符，地址操作符即this指针，这五种函数如果用户没有定义，则系统会自动创建一个。
　　16．直接调用类中的构造函数：可以在类中的函数、类外的独立函数，即main()函数中，直接调用某一个类的构造函数。比如在main函数中可以有语句n=A(4);这里n是类A的对象，这里就是直接调用类A的构造函数创建一个类A的临时对象，然后把该临时对象的值赋给类A的对象n。在类中的函数和在类外的函数调用类的构造函数的方法和这里类似。注意语句n.A(4)是错误的语句，不能由对象调用类中的构造函数。
　　例：复制构造函数的使用
　　class hyong
　　{
　　public:
　　hyong();
　　hyong(int i);
　　hyong(const hyong& obj);
　　~hyong();
　　void h(hyong k);
　　hyong f();
　　int a,b,c;
　　};
　　hyong::hyong()
　　{
　　a=b=c=0;
　　cout<<"构造函数"<<"\n";
　　}
　　hyong::hyong(int i)
　　{
　　a=b=c=i;
　　cout<<"构造函数2"<<"\n";
　　}
　　hyong::~hyong()
　　{
　　cout<<"析构函数"<<"\n";
　　}
　　//复制构造函数
　　hyong::hyong(const hyong &obj)
　　{
　　a=obj.a;
　　b=obj.b;
　　c=obj.c;
　　cout<<"复制构造函数"<<"\n";
　　}
　　//按值传递对象
　　void hyong::h(hyong k)
　　{
　　cout<<"按值传递对象"<<k.a<<k.b<<"\n";
　　}
　　//返回值为对象
　　hyong hyong::f()
　　{
　　hyong kk(5);
　　return kk;
　　}
　　//以下为几种复制初始化的方式。
　　int main()
　　{
　　hyong m(1);
　　// hyong n=m和hyong m1=hyong(m)是否生成临时对象依编译器而定
　　hyong n=m; //在VC++中此语句不生成临时对象，调用显式定义的复制构造函数初始化对象
　　cout<<m.a<<m.b<<"\n";
　　cout<<n.a<<n.b<<"\n";
　　hyong m1=hyong(m); //此语句有可能生成临时对象，也有可能不生成临时对象。
　　cout<<m1.a<<m1.b<<"\n"; //此语句不生成临时对象，调用显式定义的复制构造函数初始化对象m1。如果没有显式定义复制构造函数，则会生成临时对象，临时对象撤消时会调用析构函数。
　　hyong m2(m); cout<<m2.a<<m2.b<<"\n"; //调用复制构造函数初始化对象m2，因此不会生成临时对象
　　hyong *p=new hyong(m); cout<<p->a<<p->b<<"\n"; //不生成临时对象，直接调用构造函数初始化。
　　//按值传递和返回对象的例子。
　　h(m); cout<<"kkk"<<"\n"; //按值传递对象m，当调用函数h时就会使用复制构造函数生成一个临时对象，然后把这个临时对象复制给实参，当函数调用完毕时就会撤消临时对象，此时会调用一个析构函数，析构函数在h函数的作用域消失时才调用，也就是说在执行了h的函数体后才会调用析构函数。
　　hyong m4=f(); cout<<m4.a<<m4.b<<"\n"; //用返回的对象初始化对象m4，此语句没有生成临时对象，原因还不清楚，待考证，可能与语句是复制初始化有关。
　　hyong m5; m5=f(); //此语句调用函数f，f返回一个对象，在返回时会调用复制构造函数生成一个临时对象，并把这个临时对象作为默认赋值操作符的一个参数，因此这里不但调用了复制构造函数还调用了赋值操作符。
　　cout<<m5.a<<m5.b<<"\n";
　　hyong m6; m6=m; //把m的值赋给m6，注意这里不会调用复制构造函数，也不会生成临时对象，因为这里会把m当成是默赋值操作符的一个参数，调用的是默认赋值操作符。
　　}
　　例：直接调用类中的构造函数
　　class A {public: int a; A(){a=0;} A(int i){a=i;} ~A(){cout<<"xi"<<"\n";}
　　A f(){return A(3);} }; //在类中调用类的构造函数，当该函数被对象调用时反回由构造函数A构造的一个临时对象。
　　A g() {return A(5);} //类外的函数调用类的构造函数的方法，注意，这里是直接使用函数名的。
　　int main()
　　{ A m(1); A n(2); n=m.f(); cout<<n.a<<"\n"; //输出3,调用类中的f函数，f函数用构造函数反回一个临时对象。
　　n=g(); cout<<n.a<<"\n"; //输出5，调用类外的函数g
　　n=A(6); cout<<n.a; //在main函数中直接调用构造函数创造一个临时对象，然后把这个临时对象的值赋给对象n。
　　//n.A(7); //错误，不能用类的对象来调用构造函数。
　　} http://baike.baidu.com/view/2329038.htm

Answer 3

百度百科连接：http://baike.baidu.com/view/2329038.htm
你应该看一下谭浩强主编的《C++程序设计》。