在c++中有6個預設的成員函式，分別是建構函式、拷貝建構函式、解構函式、賦值操作符過載、取地址操作符過載和const修飾的取地址操作符過載。在這篇文章中，我將通過實現複數類來對這幾個成員函式做一個簡單的說明。

1.建構函式
成員變數為私有的，要對它們進行初始化，必須用一個公有成員函式來進行。同時這個函式應該有且僅在定義物件時自動執行一次，這時呼叫的函式稱為建構函式 。

建構函式是特殊的成員函式，特徵如下：
1. 函式名與類名相同。
2. 無返回值。
3. 物件構造（物件例項化）時系統自動呼叫對應的建構函式。
4. 建構函式可以過載。
6. 如果類定義中沒有給出建構函式，則C++編譯器自動產生一個預設的建構函式，但只要我們定義了一個建構函式，系統就不會自動生成預設的建構函式。
7. 無參的建構函式和全預設值的建構函式都認為是預設建構函式，並且預設的建構函式只能有一個。

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

拷貝建構函式是特殊的建構函式，特徵如下：
1. 拷貝建構函式其實是一個建構函式的過載。
2. 拷貝建構函式的引數必須使用引用傳參，使用傳值方式會引發無窮遞迴呼叫。
3. 若未顯示定義，系統會預設預設的拷貝建構函式。預設的拷貝建構函式會，依次拷貝類成員進行初始化。

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

建構函式是特殊的成員函式，特徵如下：
1. 解構函式在類名加上字元~。
2. 解構函式無引數無返回值。
3. 一個類有且只有一個解構函式。若未顯示定義，系統會自動生成預設的解構函式。
4. 物件生命週期結束時，C++編譯系統系統自動呼叫解構函式。
5. 注意解構函式體內並不是刪除物件，而是做一些清理工作。

4.賦值操作符過載
拷貝建構函式是建立的物件，使用一個已有物件來初始化這個準備建立的物件。 賦值運算子的過載是對一個已存在的物件進行拷貝賦值。

下面來實現複數類：

#include<iostream>
using namespace std;

class Complex
{
public:
    Complex(double real = 0.0, double image = 0.0)  //建構函式
    {
        _real = real;
        _image = image;

    }

    Complex(const Complex& c)    //拷貝建構函式
 

    {
        _real = c._real;
        _image = c._image;
    }

    ~Complex()   //解構函式
    {
        //cout << "~Complex" << endl;
    }

    Complex operator =(const Complex& c)    //賦值函式
    {
        this->_real = c._real;
        this->_image = c._image;
        cout << "operator =" << endl;
    }

    bool operator==(const Complex& d)    //判斷相等
    {
        return((_real == d._real) && (_image == d._image));
    }

    Complex operator+(const Complex &d)  //兩個複數相加  
    {
        Complex tmp;
        tmp._real= _real + d._real;
        tmp._image = _image + d._image;
        return tmp;
    }

    Complex operator-(const Complex &d)  //兩個複數相減 
    {
        Complex tmp;
        tmp._real = _real - d._real;
        tmp._image = _image - d._image;
        return tmp;
    }

    Complex& operator+=(const Complex &d)  //複數物件+=d 
    {
        _real += d._real;
        _image += d._image;
        return *this;
    }

    Complex& operator-=(const Complex &d)  //複數物件-=d 
    {
        _real -= d._real;
        _image -= d._image;
        return *this;
    }

    Complex operator++()  //前置++ 
    {
        ++_real;
        ++_image;
        return *this;
    }

    Complex operator++(int)  //後置++  
    {
        Complex tmp = *this;
        _real++;
        _image++;
        return tmp;
    }

    Complex operator--()  //前置-- 
    {
        --_real;
        --_image;
        return *this;
    }

    Complex operator--(int)  //後置--  
    {
        Complex tmp = *this;
        --_real;
        --_image;
        return tmp;
    }


    void Display()  //顯示覆數的實部和虛部  
    {
        cout << _real << "+" << _image << "i" << endl;
    }

private:
    double _real;  //實部
    double _image; //虛部
};

下面是測試函式：

void Test1()
{
    Complex c1(1.0, 2.0);  //構造出的C1
    c1.Display();
    Complex c2(c1);   //拷貝構造出的C2
    c2.Display();
}

void Test2()    //==、+、-、+=、-=
{
    Complex c1(1.0, 2.0);
    c1.Display();
    Complex c2(2.0, 2.0);
    c2.Display();

    int ret=c1==c2;    //operator==
    if (ret == 0) cout << "c1!=c2" << endl;
    else  cout << "c1=c2" << endl;

    Complex c3 = c1+c2;   //operator+
    c3.Display();

    Complex c4 = c1-c2;   //operator-
    c4.Display();

    c1+=c2;   //operator+=
    c1.Display();

    c1.operator-=(c2);   //operator-=
    c1.Display();

}

void Test3()    //前置++、後置++、前置--、後置--
{
    Complex c1(1.0, 2.0);
    c1.Display();

    Complex c2 = ++c1;    //前置++ 
    c2.Display();

    Complex c3 = c1++;     //後置++
    c3.Display();
    c1.Display();

    Complex c4 = --c1;    //前置--
    c4.Display();

    Complex c5 = c1--;    //後置--
    c5.Display();
    c1.Display();
}

int main()
{
    Test1();
    Test2();
    Test3();
    system("pause");
}

程式碼部分如上，寫完整個程式碼其實對所謂的幾個成員函式有了更深一步的瞭解。C++是一個基於面向物件的語言，難度較C語言還是蠻大的，所以在日常學習中更要注重對基礎知識的積累，要多寫程式碼反覆理解。