2017C++基础——网课笔记（32到35）

三十二. 构造和析构

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

class Test
{
public:
    //构造函数是可以被重载的
    //这是test类的构造函数
    //当对象被创建的时候，用来初始化对象的函数

    //无参数的构造函数
    Test()
    {
        m_x = 0;
        m_y = 0;
        name = (char *) malloc(sizeof(char) *100);
        strcpy(name, "Hello world!");
    }

    Test(int x, int y)
    {
        m_x = x;
        m_y = y;
        name = (char *) malloc(sizeof(char) *100);
        strcpy(name, "Hello world!");
    }

    Test(int x)
    {
        m_x = x;
        m_y = 0;
        name = (char *) malloc(sizeof(char) *100);
        strcpy(name, "Hello world!");
    }

    //析构函数和构造函数都没有返回值
    //析构函数没有形参
    //析构函数一般由程序自动触发，不应去手动去调用
    //析构函数的意义，并不是处理对象本身，而是对象所创建的垃圾。
    ~Test()
    {
        cout<<"~Test()..."<<endl;
        if(name != NULL)
        {
            free(name);
            cout<<" free() succeeded!"<<endl;
        }
    }

    void printTetst()
    {
        cout<<"x = "<<m_x<<"  y = "<<m_y<<endl;
    }
private:
    int m_x;
    int m_y;
    char * name;
};


int main()
{
    Test t1(10,20);
    t1.printTetst();

    Test t2(100);
    t2.printTetst();

    Test t3; //这里就是调用类的无参数构造函数
    t3.printTetst();


    return 0;
}

三十三. 默认的无参构造函数和析构函数

构造函数可以重载

析构函数不能重载

这两者，如果不写，则是默认的，无参的构造函数，无参的析构函数。但是只要去显式的写了，则系统不会有自动的构造函数or析构函数了

三十四. 拷贝构造函数

1. 拷贝构造函数，会将值一五一十的赋给新的类

2. 对于以下两种情况，其实调用的都是t3的拷贝构造函数，这两种写法是等价的

//这里当然调用的是t3的拷贝构造函数
Test t3(t1);
//这里调用的也是t3的拷贝构造函数，因为是初始化时候。而不是像有些人想的“赋值操作符函数”
Test t3 = t1;

而如果是以下这种情况，调用的就不是t3的拷贝构造函数，而是t3的操作符函数

Test t3;
t3 = t1;//这里调用的，不是拷贝构造函数，而是t3的赋值操作符函数。t3的拷贝构造函数，在上一行，已经调用，并初始化过t3了

#include <iostream>

using namespace std;

class Test
{
public:
    Test()
    {
        m_x = 0;
        m_y = 0;
    }

    Test(int x,int y)
    {
        m_x = x;
        m_y = y;
    }

    void printT()
    {
        cout<<"x= "<< m_x<<",y= "<< m_y<<endl;
    }

    //显示的拷贝构造函数
    Test(const Test &another)
    {
        cout<<"Test(const Test &another)..."<<endl;
        m_x = another.m_x;
        m_y = another.m_y;
    }

private:
    int m_x;
    int m_y;
};
int main()
{
    Test t1(100,200);

    Test t2(t1);

    t2.printT();

    //构造函数在对象初始化的时候调用
    Test t3 = t1; //依然是初始化t3时候调用t3的构造函数

    t3 = t1; //此时调用的不是t3的拷贝构造函数，而是t3的赋值操作符
    return 0;
}

三十五. 类中默认函数的隐藏条件

1.类中，有默认的无参构造函数的条件：

没有任何显式的构造函数（显式的无参构造函数，显式的有参构造函数，显式的拷贝构造函数），默认的无参构造函数就会自动生成。

2.类中，有默认的拷贝构造函数的条件：

当没有“显式的拷贝构造函数”时，默认的拷贝构造就会自动生成。

（换言之，即使存在“ 显式的无参构造函数”，或者“ 显式的有参构造函数”，只要没有“显式的拷贝构造函数”，默认的拷贝构造函数，就能生成）

3.类中，有默认的析构函数的条件：

当没有“显式的析构函数”的时候，默认的析构函数就会出现

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        m_a = 0;
        m_b = 0;
    }
private:
    int m_a;
    int m_b;
} ;

//类中，会有默认的无参构造函数
//当没有任何显示的构造函数（包括，显示的无参构造函数，显示有参，显示拷贝构造函数）的时候。默认无参构造函数就会起作用
//当没有显式的拷贝构造函数时，则会默认拷贝构造函数
int main()
{
    A a;
    return 0;
}