简述
 
复制构造函数是一种特殊构造函数，在生成一个实例时，一般会同时生成一个默认的复制构造函数，复制构造函数完成一些基于同一类的其他对象的构建及初始化工作。
 
特点
 
复制构造函数名与类名同名，因为它是一种构造函数，并且函数不指定返回类型。
该函数只有一个参数，并且是某个对象的引用。
每个类都必须有一个复制构造函数。如果程序员没有显式地定义一个复制构造函数，C++编译器会自动生成一个缺省的复制构造函数。
复制构造函数需要考虑深拷贝和浅拷贝的问题，默认构造函数只进行浅拷贝，当我们的类私有数据成员中含有指着类型时，需要进行深拷贝，即显式地定义复制构造函数。
 
#include<iostream>

using namespace std;

class A {
public:
    A(int val) :a(val) {
        p = new int(a);
    }
    A(const A& it) {
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  //0051C0B8
        cout << p << endl;     //0051C0E8
    }
    int get() {
        return *p;
    }
private:
    int a;
    int *p;
};

int main(int argc, char* argv[]) {
    A A1(10);
    A A2(A1);
    cout << A2.get() << endl;  //10
    getchar();
    return 0;
}
 
复制构造函数和赋值运算符的区别
 
复制构造函数生成新的类对象，而赋值运算符不能。
当类中有指针类型的成员变量时，一定要重写复制构造函数和赋值运算符，不能使用默认的。
当进行一个类的实例初始化时，也就是构造时，调用的是构造函数，但如果用其他实例来初始化，则调用的是复制构造函数，非初始化时这个实例进行赋值调用的是赋值运算符。（重要！！！）
 
#include<iostream>

using namespace std;

class A {
public:
    A(int val) :a(val) {
        p = new int(a);
    }
    A(const A& it) {
        cout << "复制构造函数" << endl;
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  
        cout << p << endl;     
    }
    A& operator=(const A& it) {
        cout << "赋值运算符" << endl;
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  
        cout << p << endl;    
        return *this;
    }
    int get() {
        return *p;
    }
private:
    int a;
    int *p;
};

int main(int argc, char* argv[]) {
    A A1(10);
    A A3(30);
    A A2 = A1;
    A2 = A3;
    cout << A2.get() << endl; 
    getchar();
    return 0;
}
 
 
扩展：空类默认产生哪些成员函数
 
默认构造函数
复制构造函数
析构函数
赋值运算符重载函数
取址运算符重载函数
const取址运算符重载函数
 
class A {
public:
    A();
    ~A(){}
    A(const A&);
    A& operator=(const A&);
    A* operator&();
    const A* operator&() const;
};

 
文章目录
 
默认构造函数和复制构造函数
1 定义默认构造函数
2 隐式类类型转换
3 复制构造函数与合成复制构造函数
3.1 复制构造函数
3.2 合成复制构造函数
   
4 深复制与浅复制
 

 
默认构造函数和复制构造函数
 
1 定义默认构造函数
 
默认构造函数就是在没有显式提供初始化式时调用的构造函数，它是一个不带参数的构造函数。如果定义某个类的对象时没有提供初始化式就会使用默认构造函数。
 
定义默认构造函数（default constructor）的一般形式为：
 
类名() 
{ 
	函数体 
}
 
它由不带参数的构造函数，或者所有形参均是默认参数的构造函数定义。与默认构造函数相对应的对象定义形式为：
 
类名 对象名;    //对象名后可以没有参数
 
任何一个类有且只有一个默认构造函数。如果定义的类中没有显式定义任何构造函数，编译器会自动为该类生成默认构造函数，称为合成默认构造函数（synthesized default constructor）。
 
一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。换言之，如果为类定义了一个带参数的构造函数，还想要无参数的构造函数，就必须自己定义它。
 
一般地，任何一个类都应定义一个默认构造函数。因为，在很多情况下，默认构造函数是由编译器隐式调用的。
 
2 隐式类类型转换
 
为了实现其他类型到类类型的隐式转换，需要定义合适的构造函数。 可以用单个实参调用的构造函数（称为转换构造函数）定义从形参类型到该类类型的隐式转换。
 
隐式类类型转换举例：
 
 
改变对象a的默认参数str
 
使用单个参数的构造函数来进行类类型转换的方法可以总结如下：
 （1）先声明一个类；
 （2）在这个类中定义一个只有一个参数的构造函数，参数的类型 是需要转换的数据类型，即转换构造函数的一般形式为：
 
类名(const 指定数据类型& obj)
 
（3）采用转换构造函数定义对象时即进行类型转换，一般形式为：
 
类名(指定数据类型的数据对象)
 
可以禁止由构造函数定义的隐式转换，方法是通过将构造函数声明为explicit，来防止在需要隐式转换的上下文中使用构造函数。
 
C++关键字explicit用来修饰类的构造函数，指明该构造函数是显式 的。explicit关键字只能用于类内部的构造函数声明上，在类定义外部不能重复它。
 
一般地，除非有明显的理由想要定义隐式转换，否则，单形参构造 函数应该为explicit。将构造函数设置为explicit可以避免错误，如果 真需要转换，可以显式地构造对象。
 
3 复制构造函数与合成复制构造函数
 
3.1 复制构造函数
 
复制构造函数又称为拷贝构造函数，它是一种特殊的构造函数。它 的作用就是用一个已经生成的对象来初始化另一个同类的对象。
 变量的初始化：
 
int a=10;   int b=a; 
 
对象的初始化：
 
Point pt1(10,20);   Point pt2=pt1;  
 
达成上面的初始化形式，就要用到复制构造函数，其定义的一般形式为：
 
类名(const 类名& obj) 
{ 
	函数体 
}
 

 复制构造函数有且只有一个本类类型对象的引用形参，通常使用 const限定。因为复制构造函数只是复制对象，没有必要改变传递来的对象的值。
 
复制构造函数的功能是利用一个已知的对象来初始化一个被创建的同类的对象。
 
与复制构造函数对应的对象的定义形式为：
 
类名 对象名1(类另一个对象1), 对象名2(类另一个对象2),......;
 
对象赋值和对象复制的区别：
 对象的赋值是对一个已经存在的对象赋值，因此必须先定义被赋值的对象，才能进行赋值。
 对象的复制则是从无到有地建立一个新对象，并使它与一个已有的对象完全相同（包括对象的结构和成员的值）。
 
3.2 合成复制构造函数
 
每个类必须有一个复制构造函数。如果类没有定义复制构造函数， 编译器就会自动合成一个，称为合成复制构造函数（synthesized copy constructor）。
 
与合成默认构造函数不同，即使定义了其他构造函数，编译器也会合成复制构造函数。
 
合成复制构造函数的操作是：执行逐个成员初始化，将新对象初始化为原对象的副本。
 
所谓“逐个成员”，指的是编译器将现对象的每个非静态数据成员， 依次复制到正创建的对象中。每个成员的类型决定了复制该成员的含义：
 
内置类型成员直接复制其值；
类类型成员使用该类的复制构造函数进行复制；
如果一个类具有数组成员，则合成复制构造函数将复制数组，即 复制数组的每一个元素到新对象中。
 
逐个成员初始化可以这样理解：将合成复制构造函数看作是每个数 据成员在构造函数初始化列表中进行初始化的构造函数。
 
以下3种情况会使用复制构造函数。
 （1）用一个对象显式或隐式初始化另一个对象。
 C++支持两种初始化形式：复制初始化和直接初始化。复制初始化 使用等号（=），而直接初始化将初始化式放在圆括号中。
 
复制初始化和直接初始化是有区别的：直接初始化会调用与实参匹配的构造函数；而复制初始化总是调用复制构造函数。
 
Point pt1(10,20); 
Point pt2=pt1;  //复制初始化 
Point pt3(pt1); //直接初始化
 
（2）函数参数按值传递对象时或函数返回对象时。
 
当函数形参为对象类型，而非指针和引用类型时，函数调用按值传递对象，即编译器调用复制构造函数产生一个实参对象副本传递到函数中。
 
类似地，以对象类型作为返回值时，编译器调用复制构造函数产生一个return语句中的值的副本返回到调用函数。
 （3）根据元素初始化式列表初始化数组元素时。
 如果没有为类类型数组提供元素初始化式，则将用默认构造函数初 始化每个元素。然而，如果使用常规的大括号的数组初值列表形式 来初始化数组时，则使用复制初始化来初始化每个元素。
 
总的来说，正是有了复制构造函数，函数才可以传递对象和返回对象，对象数组才能用初值列表的形式初始化。
 
4 深复制与浅复制
 
如果一个拥有资源（如用new得到的动态内存）的类对象发生复制的时候，若对象数据与资源内容一起复制，称为深复制，如图所示：指针p指向动态内存区
 
 
若复制对象但未复制资源内容称为浅复制，如图所示。
 

 
 
 
 
 
C++程序设计-西北工业大学-魏英、姜学锋、刘君瑞
 

 
文章目录
 
一、构造函数
1.1 构造函数是什么？
1.2 为什么要有构造函数？
1.3 如何使用构造函数？
1.4 构造函数的实现
  
二、复制构造函数
2.1 什么是复制构造函数？
2.2 为什么要有复制构造函数？
2.3 复制构造函数的功能
  
三、析构函数
什么是析构函数？
 

 
一、构造函数
 
在程序执行的过程中，当遇到与对声明语句时，程序会向操作系统申请一定的内存空间用于存放新建的对象。但是与普通变量相比，类的对象特别复杂，编译器不知如何产生代码去初始化对象，这便引出了构造函数。
 
1.1 构造函数是什么？
 
C++中，构造函数是一种特殊的成员函数，在每次创建一个类的时候编译器都会默认调用构造函数进行初始化。
 
1.2 为什么要有构造函数？
 
构造函数的作用就是在对象被创建的时候，利用特定的值构造对象，将对象初始化为一个特定的状态。
 
1.3 如何使用构造函数？
 
要学会如何使用构造函数，首先需要了解构造函数的一些特殊性质：构造函数的函数名与类名相同，而且没有返回值；构造函数通常被声明为公有函数。
 
Notes：只要类中有了构造函数，编译器就会在创建新对象的地方自动插入对构造函数调用的代码。所以构造函数在对象被创建的时候将会被自动调用。
 
下面分别介绍常见的几种构造函数：
 
默认构造函数：
 
class Clock
{
public:
    Clock()   //编译器自动生成的隐含的默认构造函数;
    {
        
    }
    ....
};
 
默认构造函数调用时无须提供参数。如果类中没有写构造函数，那么编译器会自动生成一个隐含的默认构造参数，该构造函数的参数列表和函数体都为空，这个构造函数不做任何事情。
 
Notes: 无参数的构造函数与全缺省的构造函数都称为默认构造函数。
 
Q：既然默认构造函数不做任何事情，那么为什么还要生成这个构造函数？
 
答：因为在建立对象时自动调用构造函数时C++必然要做的事情。上述例子中，默认构造函数什么都没有做，但是有些函数体为空的构造函数并非什么都不做，因为它还要负责基类的构造和成员对象的构造。
 
有参数的构造函数和无参数的构造函数
 
class Clock
{
public:
    Clock(int NewH,int NewM,int NewS);  //有参数的构造函数
    Clock()   //无参数的构造函数
    {
        hour = 0;
        minute = 0;
        second = 0;
    }
    void SetTime(int NewH,int NewM,int NewS);
    void ShowTime();

private:
    int hour,minute,second;
};

int main()
{
    Clock(0,0,0); //调用有参数的构造函数
    Clock my_clock;  //调用无参数的构造函数
    return 0;
}

 
上述例子中出现了两种重载的构造函数的形式：有参数的和无参数的（即默认构造函数）
 
1.4 构造函数的实现
 

Clock::Clock(int NewH, int NewM, int NewS) 
{
    hour = NewH;
    minute = NewM;
    second = NewS;
}
 
二、复制构造函数
 
生成一个对象的副本有两种途径，第一种途径是建立一个新的对象，然后将原始对象的数据成员取出来，赋值给新对象。这样做显然太繁琐了，所以为了使得一个类具有自行复制本类对象的能力，复制构造函数被引出。
 
2.1 什么是复制构造函数？
 
复制构造函数是一种特殊的构造函数，其具有一般构造函数的所有特性，其形参是本类对象的引用。
 
2.2 为什么要有复制构造函数？
 
复制构造函数的作用是使得一个已经存在的对象（由复制构造函数的参数指定），去初始化一个同类的一个新对象。如果程序没有定义类的复制构造函数，系统就会在必要时自动生成一个隐藏的复制构造函数。这个隐藏的复制构造函数的功能是，把初始值对象的每个数据成员复制到新建立的对象中去。这样得到的对象和原本的对象具有相同的数据成员和属性。
 
2.3 复制构造函数的功能
 
在说明复制构造函数的功能之前，我们先看一下声明和实现复制构造函数的一般方法：
 
class 类名
{
public:
    类名(形参); //构造函数
    类名(类名& 对象名); //复制构造函数
    ...
};

类名::类名(类名 &对象名) //复制构造函数的实现
{
    //函数体
}
 
前面我们知道，普通的构造函数在对象被创建的时候调用，而复制构造函数在下面3种情况下均会被调用：
 
例：
 
class Point
{
public:
    Point(int x = 0,int y = 0)
    {
        _x = x;
        _y = y;
    }
    Point(Point& p); //复制构造函数
    int GetX()
    {
        return _x;
    }
    int GetY()
    {
        return _y;
    }

private:
    int _x,_y;
};
 
当用类的一个对象去初始化另一个对象时：
 
int main()
{
    Point a(1,2);
    Point b(a); //用对象a初始化对象b时，复制构造函数被调用
    Point c = a; //用对象a初始化对象c时，复制构造函数被调用
    return 0;
}
 
Notes：上面对b和c的初始化都能够调用复制构造函数，两种写法是等价的，执行的操作完全相同。
 
如果函数的形参是类的对象，调用函数时，进行形参和实参结合时：
 
void Fun(Point p)
{
    //函数体
}

int main()
{
    Point a(1,2);
    Fun(a); //函数的形参为类的对象，当调用对象时，复制构造函数被调用.
    return  0;
}
 
Notes:只有把对象用值传递的时候，才会调用复制构造函数。如果传递的是引用，则不会调用复制构造函数。所以这也是传递引用会比传值的效率高的原因。
 
如果函数的返回值是类的对象，函数执行完成返回调用者时：
 
Point Fun()
{
    Point a(1,2);
    return a;  //函数Fun的返回值是类的对象，返回函数值的时候，调用复制构造函数
}

int main()
{
    Point b;
    b = Fun();
    return 0;
}
 
Q:为什么在这种情况下，返回函数值的时候会调用复制构造函数？
 
答：函数Fun()将a返回给了主函数，但是我们都知道a是Fun（）的局部变量，当Fun（）函数的生命周期结束的时候，a也就消亡了，不可能在返回主函数后继续生存。所以在这种情况下编译器会在主函数中创建一个无名的临时对象，该临时对象的生命周期仅仅在b = Fun（）中。当执行语句return a时，实际上是调用复制构造函数将a的值复制到无名临时对象中。当函数Fun()运行结束时，对象a消失，但是临时对象会存在于b = Fun（）中。当计算这个表达式后，临时对象也就完成了它的工作。
 
三、析构函数
 
我们刚讨论了当一个局部变量随着它的函数生命周期结束的时候，函数中的对象也会消失，那么在对象，要消失的时候（比如构造对象的时候，在函数中用malloc动态申请了空间）谁来做这些所谓的“善后”工作呢？这样我们就引出了析构函数。
 
什么是析构函数？
 
与构造函数一样，析构函数通常也是类的一个公有成员函数，它的名称是由类名前面加一个"~"构成，没有返回值。析构函数与构造函数不同的是，析构函数不接受任何参数！（参数可以是虚函数），如果我们不自行定义析构函数，则编译器同样会自动生成一个隐藏的析构函数，它的函数体为空。
 
下面我们看一下析构函数的声明：
 
class Clock
{
public:
    Clock(int NewH,int NewM,int NewS);  //有参数的构造函数
    Clock()   //无参数的构造函数
    {
        hour = 0;
        minute = 0;
        second = 0;
    }
    void SetTime(int NewH,int NewM,int NewS);
    void ShowTime();
    ~Clock(); //析构函数

private:
    int hour,minute,second;
};
 
Notes：函数体为空的析构函数并不是什么都不做。
 
Tips:
 类的构造顺序是按照语句的顺序进行构造
 类的析构函数调用完全按照构造函数调用的相反顺序进行调用
 1.全局对象先于局部对象进行构造
 2.静态对象先于普通对象进行构造

什么是复制构造函数？
 
复制构造函数是一个成员函数，它使用同一个类的另一个对象初始化一个对象。函数原型如下：
 
ClassName(const ClassName &old_obj);
 
下面是一个复制构造函数的简单示例：
 
#include <iostream>
using std::cout;

class Point {
private:
    int x, y;
public:
    Point(int x1, int y1) { x = x1, y = y1; } //带参构造函数
    //复制构造函数
    Point(const Point& p) { x = p.x, y = p.y; }

    int getx() { return x; }
    int gety() { return y; }
};

int main()
{
    Point p1(10, 20);
    Point p2 = p1;
    cout << "\np2对象x和y的值分别是：\n" << p2.getx() << "  " << p2.gety();
    return 0;
}
 
**输出：**10，20
 
复制构造函数何时调用？
 
当类的对象按值返回时。（也就是把对象做为返回值，那接受对象的变量也必须是一个对象，所以会调用复制构造函数）
当类的对象通过值作为参数传递（传递给函数）时。因为函数按值传递是传副本。
根据同一个类的另一个对象构造一个对象时。
编译器生成临时对象时。
 
**但是，不能保证在所有这些情况都将调用复制构造函数，因为C++标准允许编译器在某些情况下优化复制，一个例子是返回值优化（有时称为RVO）。
 
什么时候需要用户定义的副本构造函数？
 
如果我们不定义自己的副本构造函数，则C++编译器会创建一个默认的，该类在对象之间进行成员级复制。编译器创建的复制构造函数通常可以正常工作。可当对象具有指针、文件句柄、网络连接等，才需要我们自己定义的复制构造函数。
 
默认构造函数仅执行浅复制
 
 
复制构造函数 与 赋值运算符
 下面两个语句中，哪个调用复制构造函数？
 
MyClass t1,t2;
MyClass t3 = t1;  //-----> (1)
t2 = t1;  // ------> (2)
 
从现有对象创建新对象作为现有对象的副本时，将调用复制构造函数。
 当以初始化的对象从另一个现有对象中分配新值时，将调用分配运算符。
 所以，上面第一句调用复制构造函数，第二句调用赋值运算符。
 
下面是一个完整的C++程序，此例必须使用复制构造函数
 
#include <iostream>
using namespace std;

class String {
private:
    char* s;
    int size;
public:
    String(const char* str = NULL); //构造函数
    ~String() { delete[]s; } //析构函数
    String(const String&); //复制构造函数
    void print() { cout << s << endl; } //输出字符串
    void change(const char*); //改变功能
};

String::String(const char* str) {
    size = strlen(str);
    s = new char[size + 1];
    strcpy_s(s, size + 1, str);
}

void String::change(const char* str) {
    delete[]s;
    size = strlen(str);
    s = new char[size + 1];
    strcpy_s(s, size + 1, str);
}

String::String(const String& old_str) {
    size = old_str.size;
    s = new char[size + 1];
    strcpy_s(s, size + 1, old_str.s);
}

int main()
{
    String str1("俺蔡文姬打野贼6...."); //对象初始化
    String str2 = str1; //对象复制，调用复制构造函数

    str1.print(); //输出
    str2.print(); //输出

    str2.change("一看战绩0—5  "); //修改类成员值

    str1.print();
    str2.print();
    return 0;
}
 
如果从上面代码中删除复制构造函数，会出现上面问题？
 无法获得预期的输出，对str2所做的修改也会反映在str1中
 
可以将复制构造函数设为私有吗？
 可以把构造函数设为私有，这样此类的对象将变为不可复制。
 
为什么必须将复制构造函数的参数作为引用传递？
 按值传递对象时，将调用复制构造函数。复制构造函数本身就是一个函数。因此，如果我们在复制构造函数中按值传递参数，则会对复制构造函数进行调用，以调用复制构造函数，这将成为一个无终止的调用链。所以，编译器不允许按值传递参数。
 
为什么复制构造函数的参数应该为 const ？
 当我们创建自己的副本构造函数时，我们通过引用传递对象，并且通常将其作为const引用传递。传递const引用的原因之一是，以免意外修改对象。这是用const的一个很好的理由，但还有更多原因。