C++中的类是一种封装了数据和操作这些数据的函数的编程结构。类是面向对象编程的核心概念，它允许程序员创建自定义的数据类型，从而提高代码的可重用性和可维护性。以下是类的基本使用方法：

定义类

```cpp
class MyClass {
public:
    int myNum;
    string myString;

    void myFunction() {
        cout << "Hello World!" << endl;
    }
};
```

创建对象

```cpp
MyClass myObj;
```

访问成员变量和成员函数

```cpp
myObj.myNum = 15;
myObj.myString = "Some text";
myObj.myFunction();
```

构造函数和析构函数
构造函数用于初始化对象，析构函数用于销毁对象。

```cpp
class MyClass {
public:
    int myNum;
    string myString;

    MyClass() {
        myNum = 0;
        myString = "Default text";
    }

    ~MyClass() {
        cout << "Object destroyed!" << endl;
    }
};
```

类的继承
继承允许一个类（派生类）继承另一个类（基类）的属性和方法。

```cpp
class BaseClass {
public:
    string baseString;

    void baseFunction() {
        cout << "Base function called." << endl;
    }
};

class DerivedClass : public BaseClass {
public:
    string derivedString;

    void derivedFunction() {
        cout << "Derived function called." << endl;
    }
};
```

多态
多态允许派生类对象替换基类对象，从而实现动态绑定。

```cpp
class BaseClass {
public:
    virtual void baseFunction() {
        cout << "Base function called." << endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void baseFunction() override {
        cout << "Derived function called." << endl;
    }
};
```

类的封装
封装是将数据和操作数据的函数封装在一起，隐藏内部实现细节。

```cpp
class MyClass {
private:
    int myNum;
    string myString;

public:
    void setMyNum(int num) {
        myNum = num;
    }

    int getMyNum() {
        return myNum;
    }

    void setMyString(string str) {
        myString = str;
    }

    string getMyString() {
        return myString;
    }
};
```

类的友元
友元允许一个函数或类访问另一个类的私有和保护成员。

```cpp
class MyClass {
private:
    int myNum;

public:
    friend void myFriendFunction(MyClass &obj);
};

void myFriendFunction(MyClass &obj) {
    obj.myNum = 20;
}
```

类的模板
模板允许创建泛型类，从而提高代码的复用性。

```cpp
template <typename T>
class MyTemplateClass {
private:
    T myVar;

public:
    void setMyVar(T var) {
        myVar = var;
    }

    T getMyVar() {
        return myVar;
    }
};
```

类的静态成员
静态成员属于类本身，而不是类的对象。

```cpp
class MyClass {
public:
    static int myStaticNum;

    void myFunction() {
        myStaticNum++;
    }
};

int MyClass::myStaticNum = 0;
```

类的常量成员
常量成员在对象的生命周期内保持不变。

```cpp
class MyClass {
public:
    const int myConstNum;

    MyClass(int num) : myConstNum(num) {}
};
```

类的运算符重载
运算符重载允许自定义类的运算符行为。

```cpp
class MyClass {
private:
    int myNum;

public:
    MyClass(int num) : myNum(num) {}

    MyClass operator+(MyClass &obj) {
        return MyClass(myNum + obj.myNum);
    }
};
```

类的智能指针
智能指针用于自动管理动态分配的内存，防止内存泄漏。

```cpp
class MyClass {
public:
    int myNum;

    MyClass(int num) : myNum(num) {}
};

int main() {
    shared_ptr<MyClass> myPtr = make_shared<MyClass>(10);
    cout << myPtr->myNum << endl;
    return 0;
}
```

以上是C++中类的基本使用方法，通过类可以实现面向对象编程的三大特性：封装、继承和多态，从而提高代码的可读性、可维护性和可扩展性。