目錄

• 1. 解構函式
• 2. 物件的構造與析構順序
  • 多個物件之間
  • 單個物件內部
• 3. const物件與const成員函式
  • const物件
  • const成員函式
• 4. 成員函式、成員變數與物件的關係
• 5. 程式碼實戰——陣列類IntArray
  • IntArray.h
  • IntArray.cpp
  • IntArray測試

1. 解構函式

• C++的類中可以定義一個特殊的清理函式，叫做解構函式，語法規則為~ClassName()
• 解構函式沒有引數，也沒有返回值型別宣告
• 解構函式在物件銷燬時自動被呼叫
• 當類中自定義了建構函式，並且建構函式中使用了系統資源（如：堆空間、檔案開啟，等），則需要自定義解構函式

2. 物件的構造與析構順序

多個物件之間

多個物件構造時：

• 棧物件的構造順序依賴於程式的執行流
• 堆物件的構造順序依賴於new的使用順序
• 全域性物件的構造順序是不確定的，不同的編譯器可能使用不同的規則

多個物件析構時：

• 棧物件和全域性物件的析構順序與構造順序相反
• 堆物件的析構發生取決於delete的使用順序

單個物件內部

單個物件建立時，物件內部建構函式的呼叫順序為：

• 先呼叫父類的建構函式
• 再呼叫成員變數的建構函式，呼叫順序與宣告順序相同
• 最後呼叫類自身的建構函式

單個物件內部的析構順序與構造順序相反。

3. const物件與const成員函式

const物件

• 由const關鍵字修飾的物件為只讀物件
• 只讀物件的成員變數不允許被改變
• 只讀屬性只在編譯階段有效，執行時無效

const成員函式

const成員函式的定義如下所示，需要注意的是，函式宣告和函式定義都必須帶const關鍵字。

Type ClassName :: func(Type para) const

關於const成員函式的使用，有下面幾條規則：

• const物件只能呼叫const成員函式
• const成員函式只能呼叫const成員函式
• const成員函式不能直接修改成員變數的值

#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i);
    void setMi(int i) const;
    int getMi() const;
    void printMi();
};

Test::Test(int i)
{
    mi = i;
}

void Test::setMi(int i) const
{
    mi = i;  //Error，const成員函式中不能直接修改成員變數的值
}

int Test::getMi() const
{
    return mi;
}

void Test::printMi()
{
    printf("printMi(): mi = %d\n", mi);
}

int main()
{
    const Test t1(1);

    t1.getMi();    //OK，const物件呼叫const成員函式
    t1.printMi();  //Error，const物件呼叫普通成員函式

    return 0;
}

4. 成員函式、成員變數與物件的關係

從面向物件的角度，物件由屬性（成員變數）和方法（成員函式）構成；
從程式執行的角度，物件由資料和函式構成，資料位於棧、堆或全域性資料區，函式位於程式碼段。

• 每一個物件都擁有自己獨立的屬性（成員變數）
• 所有的物件共享類的方法（成員函式）
• 方法能夠直接訪問物件的屬性
• 方法中的隱藏引數this指標用於值代當前物件

#include <stdio.h>

class Test
{
    int mi;
public:
    int mj;
    Test(int i);
    Test(const Test &t);
    int getMi();
    void print();
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test &t)
{
    mi = t.mi;  //成員函式可以直接訪問對應類物件的成員變數
}

int Test::getMi()
{
    return mi;
}

void Test::print()
{
    printf("this = %p\n", this);  //每個成員函式中隱藏了一個this指標，用於指向當前物件
}

int main()
{
    Test t1(1);
    Test t2(2);
    Test t3(3);

    printf("t1.getMi() = %d\n", t1.getMi());
    printf("&t1 = %p\n", &t1);
    t1.print();

    printf("t2.getMi() = %d\n", t2.getMi());
    printf("&t2 = %p\n", &t2);
    t2.print();

    printf("t3.getMi() = %d\n", t3.getMi());
    printf("&t3 = %p\n", &t3);
    t3.print();

    return 0;
}

5. 程式碼實戰——陣列類IntArray

IntArray.h

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int *m_pointer;
public:
    IntArray(int len);
    IntArray(const IntArray &obj);
    int length();
    bool get(int index, int &value);
    bool set(int index ,int value);
    ~IntArray();
};

#endif

IntArray.cpp

#include "IntArray.h"

IntArray::IntArray(int len)
{
    m_pointer = new int[len];

    for(int i=0; i<len; i++)
    {
        m_pointer[i] = 0;
    }

    m_length = len;
}

IntArray::IntArray(const IntArray &obj)
{
    m_length = obj.m_length;

    m_pointer = new int[obj.m_length];

    for(int i = 0; i < obj.m_length; i++)
    {
        m_pointer[i] = obj.m_pointer[i];
    }
}

int IntArray::length()
{
    return m_length;
}

bool IntArray::get(int index, int &value)
{
    bool ret = (0 <= index) && (index < length());

    if( ret )
    {
        value = m_pointer[index];
    }

    return ret;
}

bool IntArray::set(int index, int value)
{
    bool ret = (0 <= index) && (index < length());

    if( ret )
    {
        m_pointer[index] = value;
    }

    return ret;
}

IntArray::~IntArray()
{
    delete[] m_pointer;
}

IntArray測試

#include "IntArray.h"
#include <stdio.h>

int main()
{
    IntArray a(5);

    for(int i = 0; i < a.length(); i++)
    {
        a.set(i, i + 1);
    }

    for(int i = 0; i < a.length(); i++)
    {
        int value = 0;

        if( a.get(i, value) )
        {
            printf("a[%d] = %d\n", i, value);
        }
    }

    IntArray b = a;

    for(int i = 0; i < b.length(); i++)
    {
        int value = 0;

        if( b.get(i, value) )
        {
            printf("b[%d] = %d\n", i, value);
        }
    }

    return 0;
}

相關推薦