C++中常见的类特性

一、构造函数：初始化类成员

class MyClass {
public:
    MyClass(int value):m_value(value) {}
private:
    int m_value;
};

MyClass myObject(5);

构造函数用于初始化类的成员变量，在对象被创建时被自动调用。在上面的例子中，MyClass类的构造函数需要一个int类型的参数，并将它存储在m_value成员变量中。当调用MyClass myObject(5)时，将创建一个名为myObject的MyClass类对象，其m_value成员变量的值为5。

二、析构函数：释放类资源

class MyClass {
public:
    ~MyClass() { cout<<"Destructor called"<<endl; }
};

MyClass* myObject = new MyClass(); //创建对象
delete myObject;                   //释放对象

析构函数用于释放类所占用的资源，在对象被销毁时自动调用。在上面的例子中，MyClass类的析构函数没有参数，且没有任何实际作用，只是输出一行信息。当使用new运算符创建一个MyClass类对象时，将为该对象分配内存，当使用delete运算符释放该对象时，将自动调用MyClass类的析构函数来释放该对象占用的内存。

三、访问器函数：获取私有成员变量的值

class MyClass {
public:
    int getValue() const { return m_value; }
private:
    int m_value;
};

MyClass myObject;
int value = myObject.getValue(); //获取m_value的值

访问器函数也称为getter函数，用于获取类中私有成员变量的值。在上面的例子中，MyClass类定义了一个名为getValue的访问器函数，该函数返回m_value成员变量的值。当调用myObject.getValue()时，将返回myObject对象的m_value成员变量的值。注意，该访问器函数使用const关键字来表明它不修改对象。

四、修改器函数：修改私有成员变量的值

class MyClass {
public:
    void setValue(int value) { m_value = value; }
private:
    int m_value;
};

MyClass myObject;
myObject.setValue(10); //将m_value的值设置为10

修改器函数也称为setter函数，用于修改类中私有成员变量的值。在上面的例子中，MyClass类定义了一个名为setValue的修改器函数，该函数将传入的参数设置为m_value成员变量的值。当调用myObject.setValue(10)时，将设置myObject对象的m_value成员变量的值为10。

五、静态成员变量：类级别的变量

class MyClass {
public:
    static int s_value;
};

int MyClass::s_value = 0;

MyClass myObject1;
MyClass myObject2;
myObject1.s_value = 5; //设置s_value的值为5
cout<<myObject2.s_value; //输出5

静态成员变量是属于整个类的，所有该类的对象共享一个静态成员变量。如上例中，MyClass类定义了一个静态成员变量s_value，类内部没有初始化它的值，需要在类外部进行初始化。当声明多个MyClass类对象时，这些对象共享该静态成员变量，可以通过任何一个对象对其进行修改，其他对象均会受到影响。

六、友元函数：访问类的私有成员

class MyClass {
public:
    friend int getPrivateValue(MyClass obj); //声明友元函数
private:
    int m_value;
};

int getPrivateValue(MyClass obj) { return obj.m_value; } //定义友元函数

MyClass myObject;
myObject.m_value = 10; //无法直接访问m_value
int value = getPrivateValue(myObject); //使用友元函数获取m_value的值

友元函数不是类成员函数，但是可以访问类的私有成员。在上例中，MyClass类定义了一个名为getPrivateValue的友元函数，在函数内部可以访问MyClass类的私有成员变量m_value。当需要访问该成员变量时，可以通过调用getPrivateValue函数来实现。

七、常量成员函数：不修改成员变量的函数

class MyClass {
public:
    int getValue() const { return m_value; } //常量成员函数
private:
    int m_value;
};

MyClass myObject;
int value = myObject.getValue(); //调用常量成员函数

常量成员函数表示它不会修改类的任何成员变量，因此它被认为是一个“安全”函数。通过在函数末尾使用const关键字，可以将该函数声明为常量成员函数。在上例中，MyClass类定义了一个名为getValue的常量成员函数，该函数不修改m_value成员变量的值。常量成员函数与访问器函数的语法非常相似，它们都不允许修改类的成员变量。

八、虚函数：用于多态性的实现

class Animal {
public:
    virtual void speak() { cout<<"Animal"<<endl; } //虚函数
};

class Cat : public Animal {
public:
    void speak() { cout<<"Meow"<<endl; }
};

class Dog : public Animal {
public:
    void speak() { cout<<"Woof"<speak(); //输出“Meow”

虚函数用于实现多态性，它可以让程序在运行时动态调用适当的子类函数。在上例中，定义了一个虚函数speak，它是Animal类的成员函数，并在Cat和Dog子类中进行了重写。当使用Animal*类型的指针指向Cat对象时，可以调用speak函数来输出“Meow”，因为该对象是Cat类型的。

九、纯虚函数：没有实现的虚函数，需要由子类实现

class Animal {
public:
    virtual void speak() = 0; //纯虚函数
};

class Cat : public Animal {
public:
    void speak() { cout<<"Meow"<speak(); //输出“Meow”

纯虚函数是一种虚函数，它没有实现，需要由其子类进行实现。在Animal类中，定义了一个名为speak的纯虚函数，它没有任何实际的代码实现。当创建一个子类，并从Animal类中继承时，需要实现speak函数。在上面的例子中，Cat子类实现了speak函数，并可以被Animal类指针调用。

十、继承：子类继承父类的特性

class Animal {
public:
    void eat() { cout<<"I am eating"<<endl; }
};

class Cat : public Animal {
public:
    void meow() { cout<<"Meow"<<endl; }
};

Cat myCat;
myCat.eat();  // 输出"I am eating"
myCat.meow(); // 输出"Meow"

继承允许子类继承父类的特性，包括成员变量和成员函数。在上例中，Cat子类继承了Animal父类的成员函数eat。当创建一个myCat对象时，可以调用它继承的eat函数。

十一、多重继承：子类继承多个父类的特性

class Animal {
public:
    void eat() { cout<<"I am eating"<<endl; }
};

class Vehicle {
public:
    void drive() { cout<<"I am driving"<<endl; }
};

class CatBus : public Animal, public Vehicle {
public:
    void meow() { cout<<"Meow"<<endl; }
};

CatBus myCatBus;
myCatBus.eat();   // 输出"I am eating"
myCatBus.drive(); // 输出"I am driving"
myCatBus.meow();  // 输出"Meow"

多重继承允许子类同时继承多个父类的特性。在上例中，CatBus子类同时继承了Animal和Vehicle两个父类的特性。当创建一个myCatBus对象时，可以调用它继承的eat和drive函数。