c++ 构造函数详解

构造函数是干什么的

• 该类对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作，故：构造函数的作用：初始化对象的数据成员

构造函数的分类

• 无参构造函数
• 带默认值的构造函数
• 有参（无默认值）的构造函数
• 复制构造函数（拷贝构造函数）
  • 一种特殊的构造函数，当对象之间复制时会自动调用拷贝构造函数
  • 若类中没有显示定义拷贝构造函数，则系统会自动生成默认拷贝构造函数

	#include <iostream>
	using namespace std;
	
	class Coordinate
	{
	public:
		// 无参构造函数
		// 如果创建一个类你没有写任何构造函数，则系统自动生成默认的构造函数，函数为空，什么都不干
		// 如果自己显示定义了一个构造函数，则不会调用系统的构造函数
		Coordinate()
		{
			c_x = 0;
			c_y = 0;
		}     
	
		// 一般构造函数
		Coordinate(double x, double y):c_x(x), c_y(y){}   //列表初始化
		// 一般构造函数可以有多个，创建对象时根据传入的参数不同调用不同的构造函数
	
		Coordinate(const Coordinate& c)
		{
			// 复制对象c中的数据成员
			c_x = c.c_x;
			c_y = c.c_y;
		}
	
		// 等号运算符重载
		Coordinate& operator= (const Coordinate& rhs)
		{
			// 首先检测等号右边的是否就是等号左边的对象本身，如果是，直接返回即可
			if(this == &rhs)
				return* this;
			// 复制等号右边的成员到左边的对象中
			this->c_x = rhs.c_x;
			this->c_y = rhs.c_y;
			return* this;
		}
	
		double get_x()
		{
			return c_x;
		}
	
		double get_y()
		{
			return c_y;
		}
	
	private:
		double c_x;
		double c_y;
	};
	
	int main()
	{
		// 调用无参构造函数，c1 = 0，c2 = 0
		Coordinate c1, c2;
		// 调用一般构造函数，调用显示定义构造函数
		Coordinate c3(1.0, 2.0);
		c1 = c3;    //将c3的值赋值给c1，调用"="重载
		Coordinate c5(c2);
		Coordinate c4 = c2;    // 调用浅拷贝函数，参数为c2
		cout<<"c1 = "<<"("<<c1.get_x()<<", "<<c1.get_y()<<")"<<endl
			<<"c2 = "<<"("<<c2.get_x()<<", "<<c2.get_y()<<")"<<endl
			<<"c3 = "<<"("<<c3.get_x()<<", "<<c3.get_y()<<")"<<endl
			<<"c4 = "<<"("<<c4.get_x()<<", "<<c4.get_y()<<")"<<endl
			<<"c5 = "<<"("<<c5.get_x()<<", "<<c5.get_y()<<")"<<endl;
		return 0;
	}

	c1 = (1, 2)
	c2 = (0, 0)
	c3 = (1, 2)
	c4 = (0, 0)
	c5 = (0, 0)
	请按任意键继续. . .

拷贝构造函数

• 拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类型的引用。当定义一个新对象并用同一类型的对象都它进行初始化时，将显示使用拷贝构造函数，当该类型的对象传递给函数返回该类型的对象时，将隐式调用拷贝构造函数
• 当类中有一个数据成员是指针时，或者有成员表示在构造函数中分配的其他资源，必须显示定义拷贝构造函数
• 构造函数的使用情况
  • 一个对象以值传递的方式传入函数体
  • 一个对象以值传递的方式从函数体返回
  • 一个对象需要通过另一个对象进行初始化

	#include <iostream>
	using namespace std;
	
	class Test
	{
	public:
		// 构造函数
		Test(int a):t_a(a){
		cout<<"creat: "<<t_a<<endl;
		}
	
		// 拷贝构造函数
		Test(const Test& T)
		{
			t_a = T.t_a;
			cout<<"copy"<<endl;
		}
	
		// 析构函数
		~Test()
		{
			cout<<"delete: "<<t_a<<endl;
		}
	
		// 显示函数
		void show()
		{
			cout<<t_a<<endl; 
		}
	
	private:
		int t_a;
	};
	
	// 全局函数，传入的是对象
	void fun(Test C)
	{
		cout<<"test"<<endl;
	}
	
	int main()
	{
		Test t(1);
		// 函数中传入对象
		fun(t);
		return 0;
	}

	creat: 1
	copy
	test
	delete: 1
	delete: 1
	请按任意键继续. . .

浅拷贝与深拷贝

• 浅拷贝
  • 所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。也就是增加了一个指针，指向原来已经存在的内存。 正常情况下，“浅拷贝”已经能很好的工作，但是一旦对象存在动态成员，浅拷贝就会出问题。让我们考虑下面一段代码：

	#include <iostream>
	#include <assert.h>    
	using namespace std;
	
	class Test
	{
	public:
		Test(){
			p = new int(10);
		}
	
		~Test(){
			assert(p != NULL);     // assert()作用是如果他的条件返回错误，则终止程序执行 
			delete p;
		}
	private:
		int x;
		int y;
		int* p;
	};
	
	int main()
	{
		Test t1;
		Test t2(t1);    // 调用默认拷贝构造函数
		return 0;
	}

上述程序崩溃。在使用t1复制t2时，进行的是浅拷贝，只是将成员的值进行赋值。此时，t1.p = t2.p, 即两个指针指向了堆里的同一个空间。这样，析构函数会被调用两次，这就是错误出现的原因。此问题的解决方法是“深拷贝”。

• 深拷贝
  • 深拷贝就是对于对象中的动态成员，并不只是简单的赋值，而是重新分配空间，即资源重新分配。上述代码处理如下：

	#include <iostream>
	#include <assert.h>    
	using namespace std;
	
	class Test
	{
	public:
		Test(){
			x = 0;
			y = 0;
			p = new int(10);
		}
	
		Test(const Test& t)
		{
			x = t.x;
			y = t.y;
			p = new int(10);
			*p = *(t.p);
		}
	
		~Test(){
			assert(p != NULL);     // assert()作用是如果他的条件返回错误，则终止程序执行 
			delete p;
		}
	
		int get_x(){return x;}
		int get_y(){return y;}
	private:
		int x;
		int y;
		int* p;
	};
	
	int main()
	{
		Test t1;
		Test t2(t1);    // 调用默认拷贝构造函数
		cout<<"("<<t1.get_x()<<", "<<t1.get_y()<<")"<<endl
			<<"("<<t2.get_x()<<", "<<t2.get_y()<<")"<<endl;
		return 0;
	}

(0, 0)
(0, 0)
请按任意键继续. . .

此时t1与t2的p各自指向一段内存空间，但他们指向的内容相同，这就是“深拷贝”。

前言

最近在复习C++的基础知识，在复习的时候才发现，对C++构造函数这方面的内容一直没有很清晰的了解，所以在此稍作记录。

一、构造函数

类的构造函数是类的一种特殊的成员函数，其任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

二、构造函数分类

在C++当中，构造函数主要可以分为一下四类：

1.默认构造函数

Test();					//无参

2.初始化构造函数

Test(int x,int y);		//带参数，可初始化类内数据成员

3.复制(拷贝)构造函数

Test(const Test*temp);	//通过另一个类成员初始化该成员

其中若非自己单独声明，编译器都会给我们隐形构造这几类函数。

设有个Test类内有如下数据成员，之后的样例都基于此：

class Test{
private:
	int x;
	int y;
	int* p;
}

1.默认构造函数

因为此种构造函数无参，我们可以在其之后的内部进行赋值，当初始化语句如下时，将默认使用此构造函数：

//构造函数
Test() {
		x = 0;
		y = 0;
		p = new int(10);
		*p = 0;
}
//初始化方式
Test test1;

2.初始化构造函数

在这种构造函数当中，我们可以采用两种方式进行对类内成员的赋值，一种是列表初始化，而另一种是内部赋值，样例如下：

//构造函数（二者选一，不能共存）
Test(int a,int b) {
		x = 0;
		y = 0;
		
}
Test(int a, int b) :x(a), y(b) {}
//初始化方式
Test test1(10,20);

值得注意的是，C++规定，对象的成员变量的初始化动作发生在进入构造函数本体之前。也就是说采用初始化列表的话，构造函数本体实际上不需要有任何操作，因此效率更高。

同时凭借C++的重载特性，根据不同形参也可有多个构造函数。

3.复制(拷贝)构造函数

该构造函数主要是使用一个已有的对象去初始化另一个对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。样例如下：

//构造函数
Test(const Test& t)
{
		x = t.x;
		y = t.y;
		p = t.p;
}
//初始化方式
Test t1;
Test t2(t1);

但是运行此样例后我们会发现运行出错，其主要原因是浅拷贝，深拷贝问题。

由于成员数据中含有指针，当我们简单的将指针等于另一个对象的指针后，当程序最后执行析构函数时，将对指针进行回收，但是由于两个指针都指向同一地址，而同一地址的两次析构，就会产生错误，所以正确样例如下：

Test(const Test& t)
{
		x = t.x;
		y = t.y;
		p = new int(10);
		*p=*(t.p);
}
//初始化方式
Test t1;
Test t2(t1);

在第二个样例中我们可以发现，对指针重新开辟了一块地址，而p=(t.p)这条语句成功将第二个对象指针所指内容赋值给第一个对象。
所以在这时，是有两个对象，两个指针指向不同地址，但其内容相同。
再次从输出直观体现这一差别：


一般在类成员数据中含有指针都要考虑深浅拷贝的问题。

特殊"构造"函数

在查找相关资料的时候，发现很多博文在构造函数中加入了一类为：赋值构造函数，主要声明方式如下：

//函数声明
Test& operator=(const Test& t)
{
		if (this == &t)
			return *this;
		delete p;
		x = t.x;
		y = t.y;
		p = new int;
		*p = *(t.p);
}
//初始化方式
Test t1(10,20);
Test t2;
t1=t2;

但自己总结后发现，这种操作只能称为赋值函数，而不是构造函数，因为当我们进行接下来的操作时：

Test t2=t1;

进行单步执行时发现，该语句只会执行上文的拷贝构造函数，而不是赋值函数。
但在构造函数的定义中，其是在类实例声明时即会调用，所以其并不能称为构造函数。
同时值得注意的是，在赋值函数中我们需要第一步首先判断是否是同一对象，防止循环引用，重复赋值等问题。

总结

在本文中，主要对C++中几类构造函数进行了介绍。
如文中出现纰漏，可在评论区和我交流。
同时指针操作需要记得释放内存，在此说明。

C++中有四类构造函数：默认构造函数、初始化构造函数、拷贝构造函数和移动构造函数。

当有了有参数的初始化构造函数，编译器就不会提供默认构造函数了。
只有当类没有声明任何构造函数时，编译器才会自动地生成默认构造函数。
所以如果我们定义了其他的构造函数，我们必须手动显示地定义一个默认构造函数。

1. 默认构造函数和初始化构造函数：

class Student
{
public:
    //默认构造函数
    Student()
    {
       num=1001;
       age=18;       
    }
    //初始化构造函数
    Student(int n,int a):num(n),age(a){}
private:
    int num;
    int age;
};
int main()
{
    //用默认构造函数初始化对象S1
    Student s1;
    //用初始化构造函数初始化对象S2
    Student s2(1002,18);
    return 0;
}

2. 拷贝构造函数

#include<iostream>
#include<string>
using namespace std;

class Student
{
    public:
        Student() {cout<<"调用默认构造函数"<<endl;}
        Student(string name,string no):stuname(name),stuno(no)
        {
            cout<<"调用初始化构造函数"<<endl;
        }

        Student(const Student &s)
        {
            cout<<"调用拷贝构造函数"<<endl;
            this->stuname=s.stuname;
            this->stuno=s.stuno;
        }
        ~Student() {cout<<"调用析构函数"<<endl;}

        void printinfo(Student sss)
        {
            cout<<" student.stuname: "<<sss.stuname<<" student.stuno: "<<sss.stuno<<endl;
        }

    private:
        string stuname;
        string stuno;
        
};

int main()
{
    string s1,s2;
    s1="CRP";
    s2="1906400038";
    Student st(s1,s2);
    st.printinfo(st);
    Student st2(st);
    st2.printinfo(st2);
    
    
    return 0;
}

3. 移动构造函数

#include <iostream>
using namespace std;
class demo{
public:
    demo():num(new int(0)){
        cout<<"construct!"<<endl;
    }
    demo(const demo &d):num(new int(*d.num)){
        cout<<"copy construct!"<<endl;
    }
    //添加移动构造函数
    demo(demo &&d):num(d.num){
        d.num = NULL;
        cout<<"move construct!"<<endl;
    }
    ~demo(){
        cout<<"class destruct!"<<endl;
    }
private:
    int *num;
};
demo get_demo(){
    return demo();
}
int main(){
    demo a = get_demo();
    return 0;
}

num指针变量采用的是浅拷贝的复制方式，同时在函数内部重置了d.num，有效避免了程序结束后，同一块堆空间被多次释放。