在之前的文章裡，我們出初步瞭解了，什麼是類，類如何定義，類的大小怎麼計算等

一個空類裡面什麼也沒有，但是它並非是什麼也沒有，只要是類，它就有6個預設的成員函式：

1.建構函式

2.解構函式

3.拷貝建構函式

4.賦值操作符過載

5.取地址操作符過載

6.const修飾的取地址操作符過載

類的建構函式：

class Date{
public:
    void Display()
    {
        cout<<_year<<"_"<<_month<<"_"<<_day<<endl;
    }
    void SetDate(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year; //年
    int _month; //月
    int _day;  //日
};

int main()
{
    Date firstDate,secondDate;
    firstDate.SetDate(2018,8,15);
    secondDate.SetDate(2018,8,14);
    firstDate.Display();
    secondDate.Display();
    return 0;
}
 

日期的成員的變數是私有的，我們是怎麼初始化這些變數的？

其實這就是建構函式的功勞，它是一種隨著物件建立而被自動呼叫的公有成員函式，有且僅在定義物件時自動執行一次，它的主要用途是用來作物件的初始化

建構函式是特殊的成員函式，特徵有：

1.函式名與類名相同

2.無返回值

3.物件構造時系統自動呼叫對應的建構函式

4.建構函式可以過載

5.建構函式可以在類中定義，也可以在類外定義

6.如果類定義中沒有給出建構函式，則C++編譯器會自動產生一個預設的建構函式，但只要我們定義了一個建構函式，系統就不會自動生成預設的建構函式。

7.無參的建構函式和全預設值得建構函式都認為是預設建構函式，並且預設的建構函式只能有一個

無參建構函式

class Date
{
public:
    //1.無參建構函式
    Date()
    {}
    //2.帶參建構函式
    Date(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

void TestDate()
{
    Date date1; //呼叫無參建構函式
    Date date2(2018,8,15); //呼叫帶參的建構函式
    Date date3(); //注意這裡沒有呼叫date3的建構函式定義出 date3
}
 

帶預設參的建構函式

class Date
{
public:
    //3.預設引數的建構函式
    Date(int year=2000,int month=1.int day=1)
    {
        _year = year;    
        _minth = month;
        _day = day;
    }
    //4.半預設引數的建構函式(不推薦）
    Date(int year,int month=1)
    {
        _year = year;
        _month = month;
        _day = 1;
    }
private:
    int _year;
    int _month;
    int _day;
};

void Test()
{
    Date date1; //呼叫預設建構函式
    Date date2(2015,1,2); //呼叫預設建構函式
}

解構函式

當一個物件的生命週期結束的時候，C++編譯系統會自動呼叫一個成員函式，這個成員函式即解構函式

特徵：

1.解構函式名是在類名前加上字元 ~；

2.無引數無返回值；

3.一個類有且只有一個解構函式（說明解構函式不能過載）；（若未顯示定義，系統會自動生成預設的解構函式）

4.物件生命週期結束時，C++編譯系統自動呼叫解構函式；

class Date
{
public:
    //解構函式
    ~Date()
private:
    int _year;
    int _month;
    int _day;
};

解構函式內部不是刪除物件，而是做一些刪除物件前的清理工作

class MyVector
{
public:
    MyVector(int size)
    {
        _ptr = (int *)malloc(size*sizeof(int));
    }
    //這裡解構函式需要完成清(shi)理(fang)工(kong)作(jian).
    ~MyVector()
    {
        if(_ptr)
        {
            free(_ptr); //釋放堆上的空間
            _ptr = 0;   //將指標置空
        }
    }
private:
    int *_ptr;
};

類的拷貝建構函式

建立物件時使用同類物件來進行初始化，這時所使用的建構函式稱為拷貝建構函式

特徵：

1.拷貝建構函式是建構函式的一個過載

2.拷貝建構函式的引數只有一個且必須使用引用傳參，使用傳值會引發無窮遞迴

3.若未顯示定義，系統會預設生成預設的拷貝建構函式。預設的拷貝建構函式會按照成員的宣告順序依次拷貝類成員進行初始化

class Date
{
public:
    Date()
    {}
    //拷貝建構函式
    Date(const Date &d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};

void TestDate1()
{
    Date date1;
    //下面兩種用法都是呼叫拷貝建構函式，是等價的
    Date date2(date1);  //呼叫拷貝建構函式
    Date date3 = date1;  //呼叫拷貝建構函式
}

問題來了，為什麼拷貝建構函式的引數使用傳值會引發無窮遞迴？

問題是這樣，我們傳值進去的候，會先拷貝出一個臨時變數，來進行初始化，而這個過程就是拷貝建構函式的過程，所以會一直在呼叫拷貝建構函式，引發無窮遞迴

運算子過載

為了增強程式的可讀性，C++支援運算子過載

特徵：

1.operator+合成的運算子 構成函式名（operator<）

2.過載運算子以後，不能改變預算符的優先順序/結合性/運算元個數

class Date
{
public:
    //建構函式
    Date()
    {}
    //拷貝建構函式
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    // == 操作符的過載
    bool operator == (const Date& d)
    {
        return _year == d._year;
            && _month = d._month;
            && _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};

void Test()
{
    Date date1;
    Date date2 = date1;  //呼叫拷貝建構函式
    date2 == date1;      // 呼叫 == 運算子過載
}

這個地方我們要注意，在寫操作符過載函式的時候，引數中我們可以傳值，但為什麼要傳引用，因為傳值進去的話，在函式體內會先拷貝一份臨時變數，但是傳引用就不需要，省去了這個步驟，因為傳引用基本上就和傳地址是類似的，但是，我們得保證傳進去的形參不改變實參的具體內容，所以得加上 const 修飾

另外，我們看看編譯器對 == 操作符的過載處理過程：

我們在使用 ==操作符過載時，編譯器實際上幫我們加了一個引數，就是this指標，我們前面說過，this指標是隱式指標，我們看不見，但是我們要清楚，它一直指著物件。==操作符過載，我們需要兩個運算元，但是實際上我們只需要寫出一個，因為編譯器會幫我們把this指標加上。

另外，C++中有5個不能過載的操作符：

類的賦值操作符過載

1.賦值運算子的過載是對一個已存在的物件進行拷貝賦值

2.當程式沒有顯示地提供一個以本類或本類的引用為引數的賦值運算子過載函式時，編譯器會自動生成這樣一個賦值運算子過載函式

class Date
{
public:
    Date()
    {}
    //拷貝建構函式
    Date (const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    //賦值操作符過載
    Date& operator = (const Date& d)
    {
        if(this != &d)
        {
            this->_year = d._year;
            this->_month = d._month;
            this->_day = d._day;
        }
           return this;
    }
private:
    int _year;
    int _month;
    int _day;
};

void Test()
{
    Date date1;
    Date date2 = date1;  //呼叫拷貝建構函式
    Date date3;
    date3 = date1;  //呼叫賦值運算子過載
}

賦值操作符過載為什麼要返回一個引用呢？

為了進行連續賦值，即 x = y = z

1、賦值返回引用

x = y = z  先執行y = z，返回y的引用，執行x = y

2、賦值不返回引用

x = y = z  先執行y = z，返回用y初始化的臨時物件（注意臨時物件都是常物件），再執行x = y的臨時物件，返回用x初始化的臨時物件。

還有一點，if判斷不可少，這裡的判斷就是為了防止，將值賦給自己

類的const成員函式

const修飾普通變數

在C++中，const修飾的變數已經為一個常量，具有巨集的屬性，即在編譯的時候，編譯器會將const所修飾的常量進行替換

const修飾類成員

1.const修飾類成員變數時，該成員變數必須在建構函式的初始化列表中初始化、

2.const修飾類成員函式時，實際修飾該成員隱含的this指標，該成員函式不能對類的任何成員進行修改

void TestFunc()
{
    const int a = 10;
    int* pa = (int *)&a;

    *pa = 100;
    
    cout<<a<<endl;
    cout<<*pa<<endl;
}

在這段程式碼中，打印出a的值是 10 ，*pa 是 100

因為，a是一個常量10，在被const修飾的時候就具有了巨集的屬性，編譯的時候，我們就可以認為它是這樣：cout<<10<<endl;

下來我們看看編譯器對const修飾的成員函式的處理

有些時候，在const修飾的成員函式可能需要對類的某個成員變數進行修改，該成員變數只需被mutable關鍵字修飾即可

幾個問題：

const物件可以呼叫非const成員函式和const成員函式嗎？

非const物件可以呼叫非const成員函式和const成員函式嗎？

const成員函式內可以呼叫其他的const成員函式和非const成員函式嗎？

非const成員函式內可以呼叫其他的const成員函式和非const成員函式嗎？

我們只需要記住一點，const修飾的 我們可以理解為 小作用域 而非const修飾的 我們可以理解為大作用域

大作用域可以呼叫小作用域，而小作用域不能呼叫大作用域

類的取地址操作符過載 和 const修飾的取地址操作符過載

這兩個預設的成員函式一般不用重新定義，編譯器會預設生成

class Date
{
public:
    Date* operator &()
    {
        return this;
    }
    const Date* operator() const
    {
        return this;
    }
private:
    int _year;
    int _month;
    int _day;
};

只有在一種情況下，才需要你自己過載這兩個操作符，那就是你只想讓別人獲取到你指定的內容。