C++学习（十）——构造函数

• 要点：

  1. 构造函数的目的：对象初始化
  2. 它不分配存储空间，而是在已经分配空间之后做初始化的工作。
  3. 对象生成时一定会调用构造函数。
  4. 对象一定要初始化再使用。

• 构造函数具有如下几个特点

        1、名字与类名相同，可以有参数，但是不能有返回值（void也不行）

        2、作用是对对象进行初始化工作，如给成员变量赋值等。
        3、如果定义类时没有写构造函数，系统会生成一个默认的无参构造函数，默认构造函数没有参数，不做任何工作。
        4、如果定义了构造函数，系统不再生成默认的无参构造函数。
        5、对象生成时构造函数自动调用，对象一旦生成，不能在其上再次执行构造函数。
        6、一个类可以有多个构造函数，为重载关系。

• 为什么要有构造函数？

        1、不用专门写初始化函数，并且避免忘记调用自己写的初始化函数。

        2、对象没有初始化会导致程序出错。

        

• 构造函数例子

class Complex{
    private:
        double real,imag;
    public:
        Complex(double r,double i = 0);//有参构造函数，名字与类同名
    
};//不要忘了分号

Complex::Complex(double r,double i = 0)//构造函数无返回值，void也不行
{
    real = r;
    imag = i;
}

int main()
{
    //Complex c1;//error,没有给参数
    //Complex *p = new Complex;//error,没有给参数
    Complex c2(2);//OK,i默认为0
    Complex c3(2,5);//OK
    Complex *p2 = new Complex(3,4);//OK
}

• 构造函数重载

class Complex {
private:
	double real, imag;
public:
	//构造函数
	Complex(); 
	Complex(double r); 
	Complex(double r, double i); 
	Complex(Complex c1, Complex c2); 
};

//Complex()无参构造函数，real和imag都初始化为0
Complex::Complex() {
	real = 0;
	imag = 0;
}

//Complex(double r)将real初始化为r，imag初始化为0
Complex::Complex(double r) {
	real = r;
	imag = 0;
}

//Complex(double r, double i)将real初始化为r，imag初始化为i
Complex::Complex(double r, double i) {
	real = r;
	imag = i;
}

//Complex(Complex c1, Complex c2)将real初始化为c1.real+c2.real，imag初始化为c1.imag+c2.imag
Complex::Complex(Complex c1, Complex c2) {
	real = c1.real + c2.real;
	imag = c1.imag + c2.imag;
}


int main() {
	Complex c1;//调用Complex()构造函数
	Complex c2(2);//调用Complex(double r)构造函数
	Complex c3(2, 3);//调用Complex(double r, double i)构造函数
	Complex c4(c1, c2);//Complex(Complex c1, Complex c2)构造函数
	return 0;
}

• 构造函数在数组中使用

class PrintMyWord
{
    int n;
public:
    PrintMyWord(){
        cout<<"这是无参构造函数"<<endl;
    }
    
    PrintMyWord(int x){
        n = x;
        cout<<"这是有参构造函数"<<endl;
    }

};

int main()
{
    PrintMyWord pmw1[2];                //这是无参构造函数
                                        //这是无参构造函数
    
    cout<<"stop1"<<endl;                //stop1
    
    PrintMyWord pmw2[2] = {1,2};        //这是有参构造函数
                                        //这是有参构造函数
    
    cout<<"stop2"<<endl;                //stop2
    
    PrintMyWord pmw3[2] = {3};          //这是有参构造函数
                                        //这是无参构造函数
    
    cout<<"stop3"<<endl;                //stop3
    
    PrintMyWord *pmw4 = new PrintMyWord[2]; //这是无参构造函数
                                            //这是无参构造函数

    cout<<"stop4"<<endl;                    //stop4
    
    delete []pmw4;
    return 0;
}

*重点例子* 

#include <iostream>
using namespace std;

class Test
{
public:
	Test()
	{
		cout<<"无参"<<endl;
	}
	Test(int n)
	{
		cout<<"有一个参"<<endl;
	}
	Test(int n,int x)
	{
		cout<<"有两个参"<<endl;
	}
}; //!!!

int main()
{
    //最后一个为无参构造
	Test array1[3] = {1,Test(1,2)};
	cout<<"stop1"<<endl;
	Test array2[3] = {Test(2,3),Test(1),1};
	cout<<"stop2"<<endl;
    //最后一个参数由于是指针形式，不知道指向哪，因此对象并未生成
	Test *array3[3] = {new Test(4),new Test(1,2)}; 
}

/*输出*/

有一个参
有两个参
无参
stop1
有两个参
有一个参
有一个参
stop2
有一个参
有两个参