一、构造函数

是为了让我们自己去规定 ， 我们定义对象的初始化。
这里给出一段程序，作用是按格式输出 输入的时间。

#include <iostream>
using std::cin;
using std::cout;
using std::endl;
class Clock{ 
    public:
    	void setTime(int newS = 0, int newM = 0, int newH = 0){
    	//这一步如果想要输出默认值，应该把主函数里的setTime函数中的参数删除。
            second = newS;
            minute = newM;
            hour = newH; 
        }
    	void showTime();
    private:
        int second, minute, hour;
};
void Clock::showTime(){
   cout << hour << ":" << minute << ":" << second <<endl;
}
int main(){
    Clock MyClock;
    int second, minute, hour;
    cin >> second >> minute >> hour;
    MyClock.setTime(second, minute, hour);
    MyClock.showTime();
    return 0;
}

构造函数的性质：
● 不能定义返回值类型，也不能写return语句
●可以有形参，也可以没有形参，可以带有默认参数
●函数名必须和类名完全相同
●可以重载

当我们没有写构造函数时，系统会为我们自动生成一个默认构造函数，这个默认构造函数的参数列表和内容都是空的，所以他什么都不会做！

现在 我们需要创建一个默认构造函数，让对象早初始化的时候把所有的时间全部设置为0。

//在类内定义构造函数时，不能有返回值类型，且构造函数的名字要和类一样，可以有形参也可以没有形参，这里的第一种定义是没有形参的类型：
class Clock{
public:
    Clock(){
        second = 0;
        minute = 0;
        hour = 0;
    }
//如果不写构造函数，那么系统自动生成的构造函数 就是
    Clock(){}
//函数里没有任何内容，所以也不会有操作

第二种定义类型是有参数的形式：

Class Clock{
public:
	Clock(int newS, int newM, int newH){
    second = newS;
    minute = newM;
    hour = newH;
}
}

//或者在类外实现构造函数
Class Clock{
public:
	Clock(int newS, int newM, int newH);
	}
Clock::Clock(int newS, int newM, int newH){
    second = newS;
    minute = newM;
    hour = newH;
}
这里在类外实现构造函数时，函数名前面仍然不要写函数的返回值类型 ，
实现类外构造函数 ： 在类内对函数定义，然后在类外 用 
 类名 :: 函数名 ( 参数 ) { 函数体 }   的形式在类外实现构造函数。 

而在类外实现普通函数时，也是在类内先对函数进行定义，然后在类外 用
返回值类型 类名 :: 函数名 ( 参数 ) { 函数体 } 实现，这里需要在类
名前面加上返回值类型

调用带参数的构造函数时，是在对象创建时被调用的：

 Clock MyClock2(1,2,3);

二、复制构造函数

用一个已有的对象，来执行一个新的对象的构造
●复制构造函数具有一般构造函数的所有特性，它的形参是本类的一个对象的引用，作用是用一个已经存在的对象（函数的参数）来初始化一个新的对象。
●复制构造函数的的使用方式 就是引用传参。

引用就是 给一个已经存在的变量起一个别名，所以用它的变量名或者别名都可以操作该变量, 复制构造函数就是给已经存在的构造函数起一个别名。

因为：值传递就是当函数发生调用的时候，给形参分配内存空间，然后用实参的值来初始化形参，但是如果参数是一个对象，值传递“初始化形参”这个过程就会造成很多额外的时间开销，浪费系统资源，如果使用引用就不会有这样的问题。

复制构造函数能实现同类对象之间数据成员的传递。 当我们没有定义类的构造韩函数时，系统就会在必要的时候自动生成一个隐含的复制构造函数，他的作用是把初始对象的每一个数据成员的值都复制到新建的对象中，这就完成了同类对象的复制。
复制构造函数的具体声明方式 ：

class 类名{
public:
	类名(类名& 对象名){
	//实现
	}
};

实例：
先有一个point类，表示屏幕上的一个点——它包括两个 int 类的私有成员 x , y, 表示这个点的坐标。

class Point {
public:
	Point(Point &p);
private:
	int x,y;
};

//以下代码可实现复制构造函数
Point::Point(Point &p){
	x = p.x;
	y = p.y;
}
//这里复制构造函数访问了Point类的实例对象p的两个私有成员变量 x,y 。我们需要注意的是 ———— private 与 public 的区别是对类来说的，而不是对对象来说。 拷贝构造函数是Point类的成员函数————所以它可以访问类的私有成员变量，这跟具体的对象无关。

复制构造函数被调用主要的三种情况：
●当用类的一个对象去初始化该类的另一个对象的时候：

Point a(1,2);
Point b(a);//用对象a初始化对象b,复制构造函数被调用
Point c = b;//用对象b给对象c赋值，复制构造函数被调用

●当函数的形参是类的对象，调用函数是进行形式结合的时候：

void f(Point p){
    //函数体
}
int main(){
    Point a(1,2);
    f(a);
    return 0;
}

●当函数返回值是类的对象，函数执行完成返回调用者的时候：

Point g(){
    Point a(1,2);
    return a;
}
/*定义在函数中的变量都是局部变量，当函数返回值的时候这些局部变量
都被销毁了。同样，在函数中创建的对象也相同。 return a 这一步返
回的并不是 a 这个对象本身，而是通过复制构造函数，在主调函数中用a
重新构造的对象。在函数调用返回的时候，原来的临时对象 a 的使命已
经完成，随着整个函数中的其他临时变量一起被销毁了。*/

对于复制构造函数，我们还可以自己实现一些有选择、有变化的复制：

Point (point &p){
    x = p.x+10;
    p=p.y;
}

这个函数就会把每一个由复制构造得到的Point对象，横坐标+10.

前言

如果真的想明白，为什么你写的函数的返回值是对象时，有的时候调用了复制构造函数，而有的时候，没有调用复制构造函数。需要明白一件事：函数的返回值是对象时，什么情况下，函数的返回是return by value，即生成了临时对象。这两个问题是等价的，因为按照道理来讲，对象作为函数的返回值时，就应该生成临时对象，调用复制构造函数，初始化这个临时对象，但是，现在的编译器，对于return by value有优化。有时候，不生产临时对象。编译器总是将栈里面的 结果对象 直接给调用者，避免了多一次的析构和构造。即使在关闭编译器优化的时候，它依然给你做了这个动作。
现在的我，还不明白具体什么情况下，生成临时对象。什么情况下，不生成临时对象。
留给以后解决
可以参考的文章参考1、参考2。

三种用法

我们知道，类、struct结构体的 复制构造函数 在三种情况下会被调用，分别是：

1、创建对象a时，使用对象b去初始化对象a
2、函数fun( )的形参是对象时，传递参数时，形参 是用 复制构造函数 初始化的
3、函数的返回值是对象时，生成的临时对象，是用 复制构造函数初始化的

接下来依次看一下这三种情况。

首先是类的定义

class node {
    public:
        int x, y;
        
        node () {} // 默认构造函数
        node (int _x, int _y) : x(_x), y(_y) {} // 自定义的构造函数

        node (const node& temp) { // 自定义的复制构造函数
            x = temp.x;
            y = temp.y;
            printf("复制构造函数被调用\n"); 
            // 打印语句，只要该复制构造函数被调用，就会有输出
        }
};

1、创建对象a时，使用别的对象b去初始化a

int main()
{
    node b(8, 10); 
    // 创建了node对象 b，并且调用了构造函数，初始化对象b
    node a(b); // 创建对象a， 并且使用对象b来初始化a
    // node a = b; 
    // 这样也可以，只要是创建对象同时，用其余对象初始化就可以。
    cout<< a.x << " " << a.y << endl;

    return 0;
}

运行结果

复制构造函数被调用
8 10

可以看到，先输出了"复制构造函数被调用"，之后又执行了打印a.x、a.y的语句。说明，在创建对象a时，使用对象b初始化对象a，是会调用复制构造函数的。调用了对象a的复制构造函数，复制构造函数的实参是对象 b。
但是下面的这种情况就不是创建对象的同时使用另一个对象初始化了。

int main()
{
    node b(8, 10);
    node a; // 先创建了对象 a，使用默认构造函数初始化了对象 a

    a = b; // 这是赋值，不是初始化
    
    cout << a.x << " " << a.y << endl;

    return 0;
}

运行结果

8 10

可见，首先定义一个对象a，之后再进行赋值，就不是初始化了。

2、函数fun( )的形参是对象时，传递参数时，形参 是用 复制构造函数 初始化的

void show(node temp) { // show()函数的参数是对象
    cout << temp.x << " " << temp.y << endl;
}

int main()
{
    node a(8, 10); 
    // 创建了node对象 a，并且调用了构造函数，初始化数据

    show(a);
    // 将对象a作为函数的实参传入

    return 0;
}

运行结果

复制构造函数被调用
8 10

可以看到，首先打印的是复制构造函数中的语句“复制构造函数被调用”，之后执行的是函数体里面的打印语句。所以，对象作为函数的参数时，传递参数时，是会调用复制构造函数的。即进行了值复制。形参temp是使用实参 a 初始化的。初始化形参temp时，调用了temp的复制构造函数，这个函数的参数是a。
更进一步，如果参数是引用：

void show(node& temp) { // show()函数的参数是 对象的引用
    cout << temp.x << " " << temp.y << endl;
}

int main()
{
    node a(8, 10); 
    // 创建了node对象 a，并且调用了构造函数，初始化数据

    show(a);
    // 将对象a作为函数的实参传入

    return 0;
}

此时函数的参数不是对象本身，而是对象的引用。再来看一下运行结果：

8 10

如果函数的参数是 对象的引用时，传入参数的时候，没有调用复制构造函数，没有输出复制构造函数中的打印语句“复制构造函数被调用”。
所以这种情况下，就没有复制这一步，因为传入的是实参的引用。如果大量数据要作为实参传入时，最好传入的是引用。速度快。

3、 函数的返回值是对象时，生成的临时对象，是用 复制构造函数 初始化的

我们知道，不同的函数，是在不同的内存空间中运行的，调用某个函数fun（）时，去往另一片内存空间运行，当该函数执行结束时，这一片内存空间要被释放，其中的变量要消亡。但是，如果该函数有返回值（无论是基本类型，还是对象），则该函数要生成一个临时的值temp，用于返回给调用函数的地方。因为该函数执行结束之后，该函数里面的任何局部变量都要消失。
重点就是，该临时值temp，如果是对象的话，就是使用复制构造函数进行初始化的。

node create_node() { // 函数的返回值是对象
    node temp(3, 5); // 创建一个对象
    return temp; // 返回对象
}

int main()
{
    node a = create_node();// a 用于接收函数返回值

    cout << a.x << " " << a.y << endl;

    return 0;
}

运行结果：

3 5

可以看到，并没有想象的那样输出“复制构造函数被调用”，也就是说明，此种情况下，并没有调用复制构造函数。
原因在于现在的编译器对于“对象作为函数的返回值”这种情况有所优化。返回值为对象时，有的情况下不再产生临时对象，因而不再调用复制构造函数。因此也就不存在临时对象被初始化。

有几种情况下，还是会调用复制构造函数。
全局对象 cur 作为函数返回值，对象 a 在接收 返回值 cur 时，调用复制构造函数。

#include <bits/stdc++.h>
using namespace std;

class node {
    public:
        int x, y;

        node() {}
        node(int _x, int _y) : x(_x), y(_y) {}

        node(const node& temp) {
            x = temp.x, y = temp.y;
            printf("复制构造函数被调用\n");
        }
};

node cur(1, 2);

node fun() { // 函数的返回值是对象，并且是全局对象
    return cur;
}

int main()
{
    node a ; // a用于接收函数返回值
    a = fun(); // a 接收函数返回值
    cout << a.x << " " << a.y << endl;

    return 0;
}

运行结果

复制构造函数被调用
1 2

可以看到，当全局对象 cur 作为函数返回值时，对象 a 在接收 返回对象 cur时，调用了复制构造函数。

详细地分析一下这个例子。fun( ) 函数执行结束后，会生成一个临时对象，假设为temp，该对象是使用对象cur进行初始化的。在这个初始化过程中，调用了temp的复制构造函数，其实参是 return 语句中的 cur。在这之后，fun( )函数彻底消失，占用的内存被释放。
之后，在main( ) 函数中的 a = fun(); 语句，该临时对象temp，被赋值给 a， 这是一个赋值语句，并不是初始化语句。该语句执行结束之后，临时对象 temp 消亡。

此外，如果有一个函数，它的参数是对象，返回值也是对象，则，接收该函数的返回值时，调用了复制构造函数。

#include <bits/stdc++.h>
using namespace std;

class node {
    public:
        int x, y;

        node() {}
        node(int _x, int _y) : x(_x), y(_y) {}

        node(const node& temp) {
            x = temp.x, y = temp.y;
            printf("复制构造函数被调用\n");
        }
};

node fun(node& temp) { // 此处是引用，否则调用两次赋值构造函数。
    return temp;
}

int main()
{
    node a(1, 2), b;
    b = fun(a);
    cout << a.x << " " << a.y << endl;

    return 0;
}

运行结果

复制构造函数被调用
1 2

可以看到，fun( ) 函数的参数是对象、返回值也是对象，此时，对象 b 接收 返回值时，就调用了复制构造函数。

总结

复制构造函数，只在对象被 初始化 时被调用。而初始化意味着某对象在创建的同时，被初始化。
具体就三种情况：
1、对象被创建时，被其余对象初始化
2、函数fun( ) 的形参是对象，则调用函数 fun（）时，形参会被初始化
3、函数的返回值是 对象，则生成的临时对象会被 return 语句中的数据初始化。

基本概念

复制构造函数(Copy constructor)是c++中的一个特殊构造函数，也称拷贝构造函数，它只有一个参数，参数类型为同类对象的引用。

如果没有定义复制构造函数，那么编译器将生成默认的复制构造函数。默认的复制构造函数完成复制的功能。

复制构造函数的参数为同类对象的引用，可以是常应用，也可以是非常引用。形如类名::类名(类名&)或类名::类名(const 类名&)

默认复制构造函数

class Complex {//复数类
public:
	double real, imag;//分别表示实部以及虚部
public:
	//构造函数
	Complex(double r,double i) {
		real = r;
		imag = i;
	}
};

对于上面的复数类，假设我们有如下的初始化：

int main() {
	Complex c1(5, 2);
	cout << "c1.real=" << c1.real << "\tc1.imag=" << c1.imag << endl;
	Complex c2(c1);//调用复制构造函数初始化c2
	cout << "c2.real=" << c2.real << "\tc2.imag=" << c2.imag << endl;
	return 0;
}

在上面的初始化工作中，我们调用构造函数对c1进行初始化工作，然后输出c1的实部以及虚部。然后用c1去初始化c2，此时将调用编译器自动生成的构造函数将c2初始化为和c1一样，然后输出c2的实部以及虚部。运行上面的程序，得到如下的输出：

c1.real=5       c1.imag=2
c2.real=5       c2.imag=2

可以看到此时c2被初始化为和c1相同。

编写复制构造函数

在上面的例子中，我们并没有编写复制构造函数，此时编译器将生成一个默认的复制构造函数完成复制工作。

当我们自己编写了复制构造函数之后，编译器将不再生成默认的复制构造函数。如下面的例子所示：

class Complex {//复数类
public:
	double real, imag;//分别表示实部以及虚部
	//构造函数
	Complex(double r,double i) {
		real = r;
		imag = i;
	}
	Complex(const Complex& c) {//复制构造函数
		real = c.real;
		imag = c.imag;
		cout << "调用复制构造函数！！" << endl;
	}
};

对于上面的类，在复制构造函数被调用的时候将完成复制的工作，并且向控制台输出调用复制构造函数！！，假设我们有如下的初始化：

int main() {
	Complex c1(5, 2);
	cout << "c1.real=" << c1.real << "\tc1.imag=" << c1.imag << endl;
	Complex c2(c1);//调用复制构造函数初始化c2
	cout << "c2.real=" << c2.real << "\tc2.imag=" << c2.imag << endl;
	return 0;
}

执行后可以得到如下的结果：

c1.real=5       c1.imag=2
调用复制构造函数！！
c2.real=5       c2.imag=2

可以看到，此时我们自己编写的复制构造函数被调用，并且向屏幕输出了调用复制构造函数！！。

错误用法

复制构造函数的参数一定要是对同类对象的引用，不能为其它的。

class Complex {
public:
	double real, imag;
	Complex(double r,double i) {
		real = r;
		imag = i;
	}
	Complex(Complex c) {//错误的写法
		real = c.real;
		imag = c.imag;
		cout << "调用复制构造函数！！" << endl;
	}
};

如上所示，我们错误的将参数Complex& c写为了Complex c，此时我们的编译将无法通过，在visual studio 2019中将得到以下的报错:

error C2652: “Complex”: 非法的复制构造函数: 第一个参数不应是“Complex”
message : 参见“Complex”的声明
error C2333: “Complex::Complex”: 函数声明中有错误；跳过函数体
error C2558: class“Complex”: 没有可用的复制构造函数或复制构造函数声明为“explicit”

总之，复制构造函数的参数一定要是同类对象的引用。

复制构造函数起作用的情况

用一个对象来初始化正在构造的对象变量

如上面编写复制构造函数小节中所展示的那样，当我们用同类的一个对象去初始化另一个对象时，会导致构造函数被调用。

需要注意的是：

Complex c1(5, 2);
Complex c2(c1);
Complex c3 = c1;//初始化语句，非赋值语句

上面的第三天语句为初始化语句，并非赋值语句。

函数参数作为对象传值

如果某函数有一个参数是类的对象，那么该函数被调用时，该类的复制构造函数将被调用。

class Complex {//复数类
public:
	Complex() {};
	Complex(const Complex& c) {//复制构造函数
		cout << "调用复制构造函数！！" << endl;
	}
};

对于上面的类，假设我们有如下调用：

void fun(Complex c){}
int main() {
	Complex c;
	fun(c);//调用fun(Complex c)
	return 0;
}

其中我们定义了一个函数fun(Complex c)，其参数为一个Complex对象，当我们在调用fun(Complex c)的时候，形参c将被初始化，此时将调用复制构造函数完成初始化工作，产生如下的输出：

调用复制构造函数！！

需要注意的是，如果函数的参数为对象的引用或常引用时，将不会导致构造函数被调用，如下所示：

void fun(Complex &c){}

函数返回一个对象

如果函数的返回值是某类的对象，则函数返回时，复制构造函数将被调用。

class Complex {//复数类
public:
	Complex() {};
	Complex(const Complex& c) {//复制构造函数
		cout << "调用复制构造函数！！" << endl;
	}
};

对于上面的类有如下调用：

Complex fun(){
	Complex c(2,3);
	return c;
}
int main() {
	cout << fun().real << endl;
	return 0;
}

函数fun()返回一个Complex类的对象，在调用fun()函数时会导致复制构造函数被调用。

注意事项

• 上述情形未必会调用复制构造函数。因为C++标准允许编译器实现做一些优化。例如：Class X b=X();

优化

当对象作为函数参数，在对函数进行调用时会调用复制构造函数对形参进行初始化工作，此时会产生额外的开销，我们可以将函数的参数写为对象的引用来避免额外的开销，如果担心对象的值在函数中会被改变，我们也可以用常引用的方式。

对于如下的写法：

Complex fun(Complex c){}

我们可以改写为：

Complex fun(Complex& c){}
Complex fun(const Complex& c) {}