C++构造函数与析构函数

语法规则在代码注释里，对照代码看哦，便于理解，可以直接将代码拷贝到你的IDE或者编辑器里。

#include <iostream>
using namespace std;

//构造函数(constructor)：函数名与类名相同，用于初始化成员变量，即初始化对象的内存空间 
//1.如果程序员没有写构造函数，编译器会自动生成无参数的构造函数，如果写了，就不会自动生成构造函数
//2.构造函数可以有多个，进行重载 
//3.在创建对象时，会自动调用某个构造函数进行初始化，对象一旦生成，就再也不会在其上执行构造函数 
class Complex{
	private:
		double real,imag; //私有成员变量，只能在成员函数内部进行访问
	public:
		Complex(double r);    //构造函数1 
		Complex(double r, double i); //构造函数2 
		Complex(Complex c1,Complex c2);  //构造函数3 
};
Complex::Complex(double r){
	cout << "构造函数1执行" << endl; 
	real = r;  //成员函数内部访问私有成员变量 
	imag = 0;
}
Complex::Complex(double r,double i){
	cout << "构造函数2执行" << endl; 
	real = r;
	imag = i; 
}
Complex::Complex(Complex c1,Complex c2){
	cout << "构造函数3执行" << endl; 
	real = c1.real + c2.real;
	imag = c1.imag + c2.imag;
}

int main()
{
	//Complex q;   //编译出错，没有无参构造函数进行调用 
	Complex c1(3); //调用构造函数1，括号里面写传递的实参
	
	Complex c2(1,2); //调用构造函数2 
	
	Complex c3(c1,c2); //调用构造函数3 
	
	Complex c4 = 7;   //调用构造函数1 
	
	return 0;
}

#include <iostream>
using namespace std;

//拷贝构造函数：函数名是本类名，只有一个参数，参数类型为本类的引用
//1.如果程序员不设计拷贝构造函数，编译器会自动生成复制构造函数，否则，则按照设计者的拷贝构造函数执行
//2.拷贝构造函数可以是const的引用，也可以是非常引用，推荐使用常引用 
class Complex{
	public:
		double real,imag;
		Complex(double r, double i){
			real = r;
			imag = i;
			cout << "Constructor called" << endl;
		}
		Complex(const Complex & c){
			real = c.real;
			imag = c.imag;
			cout << "Copy Constructor called" << endl;
		}
};

//拷贝构造函数被调用的三种情况 
//1.当用一个对象去初始化同类的另一个对象时
void case1(){
	Complex c1(1,1);
	Complex c2(c1);  //用对象c1初始化对象c2 
	cout << c2.real << "," << c2.imag << endl;
	
	Complex c3 = c1; //用对象c1初始化c3 
	cout << c3.real << "," << c3.imag << endl;
} 
//2.函数调用时，若形参是一个对象，也是调用拷贝构造函数进行形参的初始化，此时所调用的拷贝构造函数的参数，就是调用函数时所给的实参
void Func(Complex a){   
	cout << a.real << "," << a.imag << endl;
} 
void case2(){
	Complex b(2,2);
	Func(b); //对象b作为实参 
}
//3.函数的返回值是类的对象，函数返回值所生成的临时对象也是调用拷贝构造函数进行初始化，拷贝构造函数的参数为return 语句所返回的对象
Complex Func2(){
	Complex b(3,3);
	return b;    //返回一个对象 
} 
void case3(){
	cout << Func2().real << "," << Func2().imag << endl;
} 

//注意：赋值语句不会调用拷贝构造函数
void note(){
	Complex c1(4,4);
	Complex c2(6,6); //定义并初始化 
	c2 = c1;  //将c1赋值给c2，不是用c2对c1进行初始化 
	cout << c2.real << "," << c2.imag << endl;
} 

int main()
{
	case1();
	cout<<"\n";
	case2();
	cout<< "\n";
	case3();
	
	cout<< "\n";
	note();
	
	return 0;
}

#include <iostream>
using namespace std;

class Complex{
	public:
		double real,imag;
		Complex(double r, double i){
			real = r;
			imag = i;
			cout << "Constructor called" << endl;
		}
		Complex(int i){  //类型转换构造函数 
			real = i;
			imag = 0;
			cout << "IntConstructor called" << endl;
		}
		~Complex(){
			cout << "Destrutor called" << endl;
		}
};

int main()
{
	Complex c1(1.0,1.0);
	cout << c1.real << "," << c1.imag << endl;
	c1 = 520;  //520被自动转换为一个临时的对象，该对象用类型转换构造函数进行初始化，之后再将该对象赋值给c1;
	          //当这行语句执行结束，临时对象就会被析构，调用析构函数 
	cout << c1.real << "," << c1.imag << endl;
	
	Complex c2 = 12; //调用只有一个参数的类型转换构造函数 
	cout << c2.real << "," << c2.imag << endl;
	
	return 0;	
} 

#include <iostream>
using namespace std;

//1.拷贝构造函数在函数 
class Complex{
	int id;     //成员变量前面没有访问范围说明符，默认为私有成员，只能在成员函数内部进行访问
	public:
		Complex(int i){
			id = i;
			cout <<"id=" << id << ",Constructor called" << endl;
		} 
		Complex(const Complex & c){
			id = c.id;
			cout << "id=" << id << ",Copy Constructor called" << endl;
		}
		~Complex(){  //析构函数 
			cout << "id=" << id << ",Destructor called" << endl;
		}
		void print(){
			cout << "id=" << id << endl;
		}
};

Complex c1(1); //全局变量，先与main函数执行，调用构造函数初始化 

Complex Func(){
	static Complex c2(2); //静态变量调用构造函数初始化 
	cout << "\nTemporary Object start\n";
	return c2;  //对象做返回值，创建临时对象，调用拷贝构造函数初始化临时对象 
}

int main()
{
	cout << "main" << endl;
	Complex c3(3); //调用拷贝构造函数初始化 
	
	Func().print(); //函数执行完毕，会调用临时对象的析构函数 
	cout << "Temporary Object end\n\n"; 
	
	{
		Complex* c5 = new Complex(5);
		delete c5;
	}
	
	return 0;
}

//注：全局变量的生存期是程序的开始直到程序接束，静态局部变量的生存期为创建开始到程序接束