开始课程：P7 2_2. 构造函数
课程链接：程序设计与算法（三）C++面向对象程序设计 北京大学 郭炜
课程PPT：github提供的对应课程PPT

1、构造函数（constructor）

1.1、基本概念

1、成员函数的一种

• 名字与类名相同，可以有参数，不能有返回值（void 也不行）
• 作用是对对象进行初始化，如给成员变量赋初值
• 如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数
• • 默认构造函数无参数，不做任何操作
• 如果定义了构造韩素，则编译器不生成默认的无参数的构造函数
• 对象生成时，构造函数自动调用。对象一旦生成，就再也不能在其上执行构造函数
• 一个类可以有多个构造函数

2、为什么需要构造函数

• 构造函数执行必要的初始化工作，有了构造函数，就不必再写初始化函数，也不用担心忘记调用初始化函数。
• 有时对象没被初始化就使用，会导致程序出错。

例1:

// 类中没有写构造函数
class Complex{private:double real, imag;public:void Set(double r, double i);
};  // 编译器自动生成默认构造函数Complex c1； // 默认构造函数被调用
Complex * pc = new Complex； // 默认构造函数被调用

例2:

class Complex{private:double real, imag;pubilc:Complex(double r, double i = 0);  // 构造函数
}
Complex::Complex(double r, double i){real = r; imag = i;
}Complex c1;  //error,缺少构造函数的参数
Complex * pc = new Complex；  // error，没有参数
Complex c1(2);  // OK
Complex c1(2,4), c2(3,5);
Complex * pc = new Complex(3,4);

例3:可以有多个构造函数，参数个数或类型不同

class Complex{private:double real, imag;pubilc:// 函数重载Complex(double r, double i = 0);  // 构造函数Complex(double r, double i);Complex(double r);Complex(Complex c1, Complex c2);
}
Complex::Complex(double r){real = r; imag = 0;
}
Complex::Complex(double r, double i){real = r; imag = i;
}
Complex::Complex(Complex c1, Complex c2){real = c1.real + c2.real;imag = c1.imag + c2.imag;
}// 构造函数初始化
Complex c1(3), c2(1,0), c3(c1,c2);
// c1 = {3, 0}, c2 = {1, 0}, c3 = {4, 0};

例4-1:构造函数在数组中的使用

#include<iostream>class CSample
{int x;public:CSample(){std::cout << "Constructor  1 Called" << std::endl;}CSample(int n){x = n;std::cout << "x = " << x << std::endl;std::cout << "Constructor 2 Called" << std::endl;std::cout << "====================" << std::endl;}
};int main()
{CSample array1[2];   // 无参数构造函数会被调用两次std::cout << "step1" << std::endl;CSample array2[2] = {4, 5};std::cout << "step2" << std::endl;CSample array3[2] = {3};  // array3[0]:用的是有参构造函数初始化；array3[1]:用的是无参构造函数初始化；std::cout << "step3" << std::endl;CSample * array4 = new CSample[2];delete []array4;return 0;
}
// OUT
Constructor  1 Called
Constructor  1 Called
step1
x = 4
Constructor 2 Called
x = 5
Constructor 2 Called
step2
x = 3
Constructor 2 Called
Constructor  1 Called
step3
Constructor  1 Called
Constructor  1 Called
zhangbushi@zhangbushideair beida_lesson % g++ 04.cpp -o 04
zhangbushi@zhangbushideair beida_lesson % ./04            
Constructor  1 Called
Constructor  1 Called
step1
x = 4
Constructor 2 Called
====================
x = 5
Constructor 2 Called
====================
step2
x = 3
Constructor 2 Called
====================
Constructor  1 Called
step3
Constructor  1 Called
Constructor  1 Called

例4-2:构造函数在数组中的使用

class Test
{public:Test(int n) {}          //(1)Test(int n, int m) {}   //(2)Test() {}               //(3)             
};Test array1[3] = {1, Test(1,2)};
// 三个元素分别（1），（2），（3）初始化Test array2[3] = {Test(2,3), Test(1,2), 1};
// 三个元素分别用（2），（2），（1）初始化Test * pArray[3] = {new Test(4), new Test(1,2)};  // new的返回值是指针类型
//两个元素分别用（1），（2）初始化

2、赋值构造函数

2.1、基本概念

 只有一个参数,即对同类对象的引用。
 形如 X::X( X& )或X::X(const X &)， 二者选一，后者能以常量对象作为参数
 如果没有定义复制构造函数，那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能。
 注意事项：无参构造函数不一定存在，但赋值构造函数一定存在；

例1:

class Complex
{private:double real, imag;
};
Complex c1; //调用缺省无参构造函数
Complex c2(c1);//调用缺省的复制构造函数,将 c2 初始化成和c1一样

如果定义的自己的复制构造函数，则默认的复制构造函数不存在。

class Complex {public :double real,imag;Complex(){ }Complex( const Complex & c ) {real = c.real;imag = c.imag;cout << “Copy Constructor called”;}
}; 
Complex c1; 
Complex c2(c1);//调用自己定义的复制构造函数，输出 Copy Constructor called

不允许有形如 X::X( X )的构造函数。（必须要加上引用）

class CSample {CSample( CSample c ) {} //错，不允许这样的构造函数
};

2.1、复制构造函数起作用的三种情况

• 1、当用一个对象去初始化同类的另一个对象时。

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

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

class A 
{public:A() { };A( A & a) { cout << "Copy constructor called" <<endl;}
};void Func(A a1){ }
int main(){A a2;      // 通过无参构造函数初始化Func(a2);  // 调用复制构造函数（复制构造函数，形参是实参的拷贝，不一定）return 0;
}
// 程序输出结果为: Copy constructor called

• 3、如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用:

# include <iostream>
class A 
{public:int v;A(int n) { v = n; };A( const A & a) { v = a.v;std::cout << "Copy constructor called" << std::endl;}
};A Func() 
{ A b(4);   // 调用A(int n) { v = n; };  v = 4return b; 
}
int main() 
{ std::cout << Func().v << std::endl; return 0; 
}// 输出结果：
Copy constructor called
4

• 4、注意：对象之间复制并不导致复制构造函数被调用

#include<iostream>class CMyclass 
{public:int n;CMyclass() {};CMyclass( CMyclass & c) { n = 2 * c.n ;}
};int main()
{CMyclass c1, c2;c1.n = 5; c2 = c1;   // 对象间赋值CMyclass c3(c1); // 调用复制构造函数std::cout << "c2.n = " << c2.n << ",";std::cout << "c3.n = " << c3.n << std::endl;return 0; 
}
// 输出
c2.n = 5,c3.n = 10

2.2、常引用参数的使用

void fun(CMyclass obj_). {cout << “fun” << endl; }

• 这样的函数，调用时生成形参会引发复制构造函数调用，开销比较大。
• 所以考虑使用CMyclass & 引用类型作为参数
• 如果希望确保实参的值在函数中不应该被改变，那么可以加上const关键字

3、类型转换构造函数

3.1、什么事类型转换构造函数

• 定义转换构造函数的目的是实现类型的自动转换。
• 只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。
• 当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象（或临时变量）。

实例：

#include<iostream>class Complex
{public:double real, imag;Complex( int i )   // （1）{std::cout << "IntConstructor called" << std::endl;real = i; imag = 0;}Complex(double r, double i) {real =r; imag = i;}    //（2）
};int main ()
{Complex c1(7, 8);Complex c2 = 12;c1 = 9;   // 解释如下/*c1 = 9; 解释如下1、首先9会被自动转化成一个临时Complex对象，即：Complex Linshi = 9；2、c1 = linshi；*/std::cout << c1.real << "," << c1.imag << std::endl;return 0;
}

4、析构函数

4.1、什么是析构函数

实例：

class String{private :char * p;public:String () {p = new char[10];   //动态分配的内存空间，需要释放，在析构函数中释放。}
~ String ();
};
String ::~ String() {
delete [] p;
}

4.2、析构函数和数组

对象数组生命结束时，对象数组的每个元素的析构函数都会被调用。

#include<iostream>class Ctest
{public:~Ctest()  {std::cout << "destructor called" << std::endl;}
};int main ()
{Ctest array[2];std::cout << "End Main" << std::endl;return 0;
}
// OUT
End Main
destructor called
destructor called

4.3、析构函数和运算符 delete

delete 运算导致析构函数调用
若new一个对象数组，那么用delete释放时应该写 []。否则只delete一个对象（调用一次析构函数）

Ctest * pTest;
pTest = new Ctest; //构造函数调用
delete pTest; //析构函数调用
------------------------------------------------------------------
pTest = new Ctest[3]; //构造函数调用3次
delete [] pTest; //析构函数调用3次

析构函数在对象作为函数返回值返回后被调用

/*
日期：2024.02.17
作者：源仔
*/#include<iostream>class CMyclass
{public:~CMyclass() {std::cout << "destructor" << std::endl;}
};CMyclass obj;   // 全局对象
CMyclass fun(CMyclass sobj)  
{return sobj;/*1、参数对象消亡也会导致析构函数被调用。2、函数调用返回时，生成临时对象返回*/
}int main()
{obj = fun(obj);   // 函数调用的返回值（临时对象）被return 0;         // 用过后，该临时对象析构函数被调用
}// OUT
destructor  //指的是CMyclass fun(CMyclass sobj)中的CMyclass sobj形参使用结束，调用析构函数
destructor  //指的是fun(obj)临时变量使用结束，调用析构函数
destructor  //指的是CMyclass obj;全局对象消完，调用析构函数

5、构造函数析构函数调用时机

#include<iostream>
class Demo
{int id;public:Demo(int i){id = i;std::cout << "id = " << id << " constructor " << std::endl;}~Demo(){std::cout << "id = " << " destructed " << std::endl;}
};Demo d1(1);   // 1、全局对象，在main函数之前就初始化了，就会引发构造函数，输出：id = 1 constructor
void Func()
{static Demo d2(2);  // 静态的局部变量，整个程序结束，静态变量才会消完Demo d3(3);std::cout << "func" << std::endl;
}int main()
{Demo d4(4);  // 2、输出：id = 4 constructord4 = 6;      // 3、调用类型转换构造函数，构建为6的临时构造函数，输出：id = 6 constructor，临时构造函数调用完就会直接销毁，引发析构函数调用，输出：id = destructedstd::cout << "main" << std::endl;  // 输出：main{Demo d5(5);   // 4、局部对象，输出：id = 5 constructor}  // 5、局部变量销毁，引发析构函数调用。输出：id = destructedFunc();  // 6、如下/*6、输出：id = 2 constructor7、输出：id = 3 constructor8、输出：Func9、静态的局部变量，整个程序结束，静态变量才会消完，所以不会先引发 static Demo d2(2)的析构函数10、先引发Demo d3(3);的析构函数，输出：id = destructed*/std::cout << "main ends" << std::endl;  // 11、输出：main ends/*12、引发d4 = 6;中d4的析构函数调用（注意：之前引发的析构函数是 6 创建临时构造函数引发的析构函数调用），输出：id = destructed13、引发static Demo d2(2);的析构函数调用，输出：id = destructed14、引发Demo d4(4);的析构函数调用，输出：id = destructed*/return 0;
}/*
id = 1 constructor 
id = 4 constructor 
id = 6 constructor 
id =  destructed 
main
id = 5 constructor 
id =  destructed 
id = 2 constructor 
id = 3 constructor 
func
id =  destructed 
main ends
id =  destructed 
id =  destructed 
id =  destructed 
*/

实例5:

假设A是一个类的名字，下面的程序片段会类A的调用析构函数几次？
答案：调用3次。
解释：new创建的动态变量，必须要释放，才能引发析构函数的调用。

int main()
{A * p = new A[2];A * p2 = new A;A a;delete [] p;
}