C++之深入讨论构造函数

1、深拷贝与浅拷贝

浅拷贝：默认拷贝构造函数，系统提供

深拷贝：手动定义拷贝构造函数，具体复制动作由自己完成（涉及地址时必须用）

2、拷贝构造函数的使用

拷贝构造函数与普通构造函数的唯一不同点在于参数不同

DEMO类的拷贝构造函数为：DEMO（const DEMO &a）;

3、特殊情况：const

类成员中若有const修饰，必须在对象初始化时给const int m 赋值 ：Student类中Student::Student（）：m（v1）

类的成员函数中有const修饰，同上。

#include <iostream>
#include <cstring>

using namespace std;

class Stu
{
    private:
        int m_bir;
        char m_name[20];
        int m_num;
        int m_cla;
    public:
        Stu(int b,char *name);
        void show();
};

Stu::Stu(int b,char *name):m_bir(b),m_num(15),m_cla(2)
{
    strcpy(m_name,name);
}

void Stu::show()
{
    cout << "name : " << m_name << "  birthday : " << m_bir << endl;
    cout << "number : " << m_num << "  class : " << m_cla << endl;
}

int main()
{
    Stu a(123,"wenwanwan");
    a.show();
    return 0;
}

#include <iostream>
using namespace std;
class Test
{
    private:const int m_a; 
    public:Test(int a); 
           int GetA() const;
};
Test::Test(int a):m_a(a)
{ 
    //m_a = a;
}
int Test::GetA() const
{ 
     return m_a;
}
int main()
{ 
    Test t(1);
    cout << t.GetA() << endl;
    return 0;
}

4、成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关  

5、析构函数调用顺序与构造函数顺序相反

#include <iostream>
#include <cstring>

using namespace std;

class Test
{
    private:
        int m;
    public:
        Test(int n);
        ~Test();
};

Test::Test(int n)
{
    cout << "Test Constructor !" << endl;
    m = n;
}

Test::~Test()
{
    cout << "Test Destruct !" << endl;
}
class Bir
{
    private:
        int year;
        int mouth;
        int day;
    public:
        Bir(int _year,int _mouth,int _day);
        void print();
        ~Bir();
};

class Stu
{
    private:
        Test t;//此处调用不同类的顺序决定对应类构造函数调用的顺序
        Bir m_bir;//若34，35互换，则调用顺序变化
        char m_name[20];
        int m_num;
        int m_cla;
    public:
       // Stu(char *name);
        Stu(int year,int mouth,int day,char *name);
        void show();
        ~Stu();
};


Bir::Bir(int _year,int _mouth,int _day)
{
    cout << "Birthday constructor !" << endl;
    year = _year;
    mouth = _mouth;
    day = _day;
}
void Bir::print()
{
    cout << "year : " << year << " mouth : " << mouth << " day : " << day << endl;
}

Bir::~Bir()
{
    cout << "Birthday Destruct !" << endl;
}

//Stu::Stu(char *name):m_num(15),m_cla(2),m_bir(1997,5,27)
Stu::Stu(int year,int mouth,int day,char *name):m_num(15),m_cla(2),m_bir(year,mouth,day),t(2)
//此处初始化列表顺序与成员变量顺序无关
{
    cout << "Sturdent Constructor !" << endl;
    strcpy(m_name,name);
}

void Stu::show()
{
    cout << "name : " << m_name << endl;
    m_bir.print();
    cout << "number : " << m_num << "  class : " << m_cla << endl;
}

Stu::~Stu()
{
    cout << "Student Destruct !" << endl;
}
//析构函数与对应的构造函数的调用顺序相反
int main()
{
    //Stu a("wenwanwan");
    Stu a(1997,5,27,"wenwanwan");
    a.show();
    return 0;
}

运行结果：
Test Constructor !
Birthday constructor !
Sturdent Constructor !
name : wenwanwan
year : 1997 mouth : 5 day : 27
number : 15  class : 2
Student Destruct !
Birthday Destruct !
Test Destruct !

6、匿名对象

匿名对象生命周期短，调用完构造函数后，立即调用析构函数，只存在匿名对象所在行有效

注意：手动调用构造函数时，会产生一个匿名对象，构造中调用构造是危险行为！

#include <iostream>
using namespace std;
class Test
{
    private:int m_a;
    public:Test(int a);
           ~Test();
};
Test::Test(int a)
{ 
    cout << "Test Constructor !" << endl;
    m_a = a;
}
Test::~Test()
{ 
    cout << "Test Destruct !" << endl;
}
int main()
{ 
     Test(2);//匿名对象，生命周期只存在此行，调用构造函数后立即调用析构函数 
     Test a(1);//有名对象，对象结束后调用析构函数 
     Test b(3);
     return 0;
}
运行结果：
Test Constructor !
Test Destruct !
Test Constructor !
Test Constructor !
Test Destruct !
Test Destruct !

#include <iostream>
using namespace std;
class Test
{ 
    private:int m_a; 
            int m_b; 
            int m_c;
    public:Test(int a,int b,int c); 
           Test(int a,int b); 
           int Getc(); 
           ~Test();
};
Test::Test(int a,int b,int c)
{ 
    cout << "Test Constructor_3 !" << endl;
    m_a = a;
    m_b = b;
    m_c = c;
}
Test::Test(int a,int b)
{ 
    cout << "Test Constructor_2 !" << endl; 
    m_a = a; m_b = b; 
    Test(a,b,3); 
//在构造函数中调用构造函数是危险行为，会产生一个新的匿名对象 
//即用即释放，故c为垃圾值
}
int Test::Getc()
{ 
    cout << "c = " << m_c << endl;
}
Test::~Test()
{ 
     cout << "Test Destruct !" << endl;
}
int main()
{ 
    Test t(1,2); 
    t.Getc(); 
    return 0;
}
运行结果：
Test Constructor_2 !
Test Constructor_3 !
Test Destruct !
c = 13963252
Test Destruct !