實現一個C++類的成員函數

一、類的定義與聲明

在C++中，實現一個類需要定義和聲明兩個部分。聲明用於描述類的結構，包括類名、成員函數和成員變數等。而定義則是實現聲明中描述的成員函數的具體功能。

    class MyClass {
        private:
            int count_;
        public:
            MyClass();
            ~MyClass();
            void SetCount(int count);
            int GetCount();
    };

上述代碼定義了一個名為MyClass的類，包括一個私有變數count_ 和四個公有成員函數。其中，MyClass構造函數和析構函數用於對象的創建和釋放，SetCount函數用於給count_賦值，GetCount函數用於獲取count_的值。

二、成員函數的實現

對於成員函數的實現，可以在類的內部或外部實現。在類的內部實現將函數聲明為內聯函數，可以提高調用效率。而在類的外部實現，可以將函數定義和聲明分離開，方便代碼的維護。

1. 在類內部實現

    class MyClass {
        private:
            int count_;
        public:
            MyClass() {
                count_ = 0;
            }
            ~MyClass() {}
            void SetCount(int count) {
                count_ = count;
            }
            int GetCount() {
                return count_;
            }
    };

上述代碼中，構造函數和析構函數的實現為空，SetCount和GetCount函數的實現均在類的內部。這種方式優點在於代碼簡單明了，調用時效率較高。但如果函數實現比較複雜，會導致類的定義部分過於臃腫。

2. 在類外部實現

    class MyClass {
        private:
            int count_;
        public:
            MyClass();
            ~MyClass();
            void SetCount(int count);
            int GetCount();
    };
    MyClass::MyClass() {
        count_ = 0;
    }
    MyClass::~MyClass() {}
    void MyClass::SetCount(int count) {
        count_ = count;
    }
    int MyClass::GetCount() {
        return count_;
    }

上述代碼中，類的定義和聲明與之前相同，但實現部分移到了類的外部。此時，需要在類名前加上作用域限定符「::」，以表示屬於MyClass類的成員函數。這種方式可以有效的避免類的定義部分過於冗長，方便代碼的後期維護。

三、構造函數和析構函數

構造函數用於對象的創建，可以給成員變數設置初始值，為對象進行初始化操作。在C++中，如果沒有定義構造函數，編譯器會自動生成一個默認構造函數。析構函數用於對象的釋放，可以進行資源的釋放等清理工作。同樣，如果沒有定義析構函數，編譯器也會自動生成一個默認析構函數。

    class MyClass {
        private:
            int count_;
            int *p_;
        public:
            MyClass() {
                count_ = 0;
                p_ = new int;
            }
            MyClass(int count) {
                count_ = count;
                p_ = new int[count_];
            }
            ~MyClass() {
                delete p_;
            }
            void SetCount(int count) {
                count_ = count;
            }
            int GetCount() {
                return count_;
            }
    };

上述代碼中，MyClass類的構造函數中，給count_賦初值0，同時動態分配了一個int類型的指針p_。MyClass(int count)函數的實現中，給count_賦初值count，並動態分配了一個長度為count_的int數組。析構函數的實現中，釋放了p_指針指向的內存空間。這樣，在MyClass對象被銷毀時，p_所指向的內存空間也會被釋放，避免了出現內存泄漏的情況。

四、數據封裝和數據隱藏

在類的實現中，數據封裝和隱藏是非常重要的特性。數據封裝指的是將數據和處理數據的函數封裝在一起，確保私有成員變數不能被外部訪問。數據隱藏則是指隱藏了類的實現細節，防止外部程序員直接對類的實現進行修改。

    class MyClass {
        private:
            int count_;
        public:
            void SetCount(int count) {
                if (count  100) {
                    count_ = 100;
                } else {
                    count_ = count;
                }
            }
            int GetCount() {
                return count_;
            }
    };

上述代碼中，count_被聲明為私有變數，SetCount和GetCount函數被聲明為公有函數。SetCount函數中，對輸入的數值進行了判斷，當count小於0時，將count_賦值為0，當count大於100時，將count_賦值為100，否則將count_賦值給count_。這樣，防止了外部程序員直接對count_進行修改。

五、繼承和多態

繼承和多態是C++中重要的面向對象的特性。繼承是指一個類繼承另一個類的特性，從而可以更快速地創建一個新類。多態則是指同一種類型的數據在不同情況下可以表現出不同的狀態或行為。

    class Animal {
        public:
            virtual void Eat() {
                cout << "Animal eat." << endl;
            }
    };
    class Dog : public Animal {
        public:
            void Eat() {
                cout << "Dog eat bone." << endl;
            }
    };
    class Cat : public Animal {
        public:
            void Eat() {
                cout << "Cat eat fish." << endl;
            }
    };

上述代碼中，定義了一個父類Animal和兩個子類Dog和Cat。在Animal類的Eat函數聲明前添加了virtual關鍵字，表示該函數是一個虛函數。在子類Dog和Cat中重寫了虛函數Eat，並定義了不同的行為。

這樣在後續的函數調用中，可以通過父類的指針調用各個子類的方法，實現多態的特性。

    Animal *pAnimal = new Dog();
    pAnimal->Eat();
    pAnimal = new Cat();
    pAnimal->Eat();

上述代碼中，定義了一個Animal類的指針pAnimal，並分別指向了Dog和Cat對象。在調用pAnimal的Eat函數時，會根據對象真正的類型來調用對應的方法。

六、異常處理

在C++中，異常處理是一種處理程序在執行期間發生異常情況的機制。當程序運行時出現異常情況可以通過異常處理機制解決，以避免程序的崩潰。

    class MyClass {
        private:
            int count_;
        public:
            void SetCount(int count) {
                try {
                    if (count  100) {
                        throw "count larger than 100.";
                    } else {
                        count_ = count;
                    }
                } catch (const char *msg) {
                    cout << msg << endl;
                }
            }
            int GetCount() {
                return count_;
            }
    };

上述代碼中，SetCount函數中增加了異常處理部分。當輸入的count值小於0時，拋出一個字元串類型的異常「count less than zero.」。當輸入的count值大於100時，拋出一個字元串類型的異常「count larger than 100.」。在異常拋出後，需要在函數中添加相應的catch塊來對異常進行處理，防止程序崩潰。

七、總結

實現一個C++類的成員函數需要該類的定義和聲明，成員函數的實現可以在類的內部或外部實現。構造函數和析構函數用於對象的創建和釋放，數據封裝和隱藏可以保證類的安全性，繼承和多態可以讓類的使用更加靈活。異常處理可以有效避免程序的崩潰。