实现一个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