C++ 类（class）

C++ 类（class）

C++中的类（Class）是一种用户定义的数据类型，它封装了数据（成员变量）和操作这些数据的函数（成员函数）。类可以被看作是创建对象的蓝图，它定义了对象的属性和行为。

访问修饰符

在C++中，访问修饰符用于控制类成员（包括变量和函数）的可见性和可访问性。

主要有三种访问修饰符：public、protected和private。

• public、protected和private是C++中的三个访问修饰符，它们控制着类成员的可见性和可访问性。
• public成员是类的公共接口，可以被任何代码访问，包括类的实例和外部代码。
• protected成员是类和其派生类的接口，只能被类本身和其派生类访问。
• private成员是类的内部实现细节，只能被类本身访问，完全封装，不允许外部代码访问。
• 在继承中，基类的public和protected成员会传递给派生类，而private成员则不会传递，派生类无法访问基类的private成员。
• 访问修饰符是实现封装和数据隐藏的重要机制，有助于保护数据的完整性和安全性。

#include <iostream>
#include <string>

// 声明一个类Person
class Person {
    // 私有成员变量，只能在类的内部访问
private:
    std::string name;

    // 受保护成员变量，可以在类的内部以及派生类中访问
protected:
    int age;

    // 公有成员变量，可以在任何地方访问
public:
    double height;

    // 私有成员函数，只能在类的内部调用
private:
    void privateFunction() {
        std::cout << "Private function called" << std::endl;
    }

    // 受保护成员函数，可以在类的内部以及派生类中调用
protected:
    void protectedFunction() {
        std::cout << "Protected function called" << std::endl;
    }

    // 公有成员函数，可以在任何地方调用
public:
    void publicFunction() {
        std::cout << "Public function called" << std::endl;
    }

    // 构造函数
public:
    Person(const std::string& nm, int ag, double ht) : name(nm), age(ag), height(ht) {}

    // 公有成员函数，用于外部访问私有成员变量
    std::string getName() const {
        return name;
    }

    // 公有成员函数，用于外部调用私有成员函数
    void callPrivateFunction() {
        privateFunction();
    }
};

// 派生类
class Employee : public Person {
public:
    Employee(const std::string& nm, int ag, double ht) : Person(nm, ag, ht) {}

    // 可以访问基类的受保护成员
    void printAge() {
        std::cout << "Age: " << age << std::endl;
    }

    // 可以调用基类的受保护成员函数
    void printProtectedFunction() {
        protectedFunction();
    }
};

int main() {
    // 创建Employee对象
    Employee emp("John Doe", 30, 175.5);

    // 访问公有成员函数和变量
    emp.publicFunction();
    std::cout << "Height: " << emp.height << std::endl;

    // 通过公有接口访问私有成员变量和私有成员函数
    std::cout << "Name: " << emp.getName() << std::endl;
    emp.callPrivateFunction();

    // 访问受保护成员变量和函数（通过派生类）
    emp.printAge();
    emp.printProtectedFunction();

    return 0;
}

Person类有三个访问修饰符定义的成员变量和成员函数，分别展示了private、protected和public访问级别。Employee类继承自Person类，并可以访问Person类的protected成员。

• private成员变量name和成员函数privateFunction只能在Person类内部访问。
• protected成员变量age和成员函数protectedFunction可以在Person类及其派生类Employee中访问。
• public成员变量height和成员函数publicFunction可以在任何地方访问。

main函数中创建了一个Employee对象，并展示了如何访问不同访问级别的成员。通过Employee对象，我们可以访问Person类的公有成员和受保护成员，但不能直接访问私有成员。私有成员只能通过Person类提供的公有接口（如getName和callPrivateFunction）来访问。

成员变量

在C++中，类的成员变量是定义在类内部的变量，它们代表了类的状态。

• 非静态成员变量：每个对象实例都有自己的拷贝，因此它们不是线程安全的，除非通过外部同步机制来保护。
• 静态成员变量：所有对象共享同一份拷贝，因此它们也不是线程安全的，除非通过外部同步机制来保护。
• 常量成员变量：由于它们是不可变的，因此是线程安全的。
• 互斥锁成员变量：虽然std::mutex本身是线程安全的，但需要正确使用（例如避免死锁）来保证线程安全。
• 条件变量：std::condition_variable是线程安全的，但需要与互斥锁结合使用，并正确管理条件变量的唤醒和等待。
• 原子变量：std::atomic类型提供了基本的线程安全操作，适用于简单的同步需求。
• 线程局部存储变量：thread_local变量是线程安全的，因为每个线程都有自己的独立拷贝。

成员函数

在C++中，类的成员函数是定义在类内部的函数，它们可以访问类的私有和保护成员。

成员函数定义了类的行为。成员函数可以操作类的成员变量，并且可以被声明为public、protected或private，以控制它们的访问级别。

• 成员函数的访问级别（public/protected/private）决定了它们可以在类的哪个范围内被访问。
• 构造函数和析构函数是特殊的成员函数，它们在对象的生命周期开始和结束时自动被调用。
• 拷贝构造函数和拷贝赋值运算符用于对象的拷贝操作，移动构造函数和移动赋值运算符用于对象的移动操作。
• 虚函数和纯虚函数是实现多态性的关键，它们允许基类通过指针或引用调用派生类的函数。
• 静态成员函数和友元函数是特殊的成员函数，它们不依赖于对象实例，因此没有初始化列表和初始化顺序的概念。

在C++中，如果类没有显式定义某些成员函数，编译器会根据需要自动生成默认成员函数。这些默认成员函数包括：

1. 默认构造函数（Default Constructor）：
   如果类没有定义任何构造函数，编译器会生成一个默认构造函数。这个函数不接受任何参数，并默认初始化成员变量（对于基本数据类型成员变量，通常是零初始化）。

2. 默认析构函数（Default Destructor）：
   如果类没有定义析构函数，编译器会生成一个默认析构函数。这个函数不执行任何操作，除非类有基类或成员对象需要析构。

3. 默认拷贝构造函数（Default Copy Constructor）：
   如果类没有定义拷贝构造函数，并且没有成员函数被声明为const、volatile，没有虚函数，没有mutable成员，没有基类的自定义拷贝构造函数，编译器会生成一个默认拷贝构造函数。这个函数会逐个成员地拷贝对象。

4. 默认拷贝赋值运算符（Default Copy Assignment Operator）：
   如果类没有定义拷贝赋值运算符，并且没有成员函数被声明为const、volatile，没有虚函数，没有mutable成员，没有基类的自定义拷贝赋值运算符，编译器会生成一个默认拷贝赋值运算符。这个运算符会逐个成员地赋值对象。

5. 默认移动构造函数（Default Move Constructor）：
   C++11及以后版本，如果类没有定义移动构造函数，并且没有成员函数被声明为const或volatile，没有虚函数，没有mutable成员，没有基类的自定义移动构造函数，编译器会生成一个默认移动构造函数。这个函数会逐个成员地移动对象。

6. 默认移动赋值运算符（Default Move Assignment Operator）：
   C++11及以后版本，如果类没有定义移动赋值运算符，并且没有成员函数被声明为const或volatile，没有虚函数，没有mutable成员，没有基类的自定义移动赋值运算符，编译器会生成一个默认移动赋值运算符。这个运算符会逐个成员地移动赋值对象。

#include <iostream>

class SimpleClass {
public:
    int x;
    double y;

    // 默认构造函数
    SimpleClass() = default;

    // 默认析构函数
    ~SimpleClass() = default;

    // 默认拷贝构造函数
    SimpleClass(const SimpleClass& other) = default;

    // 默认拷贝赋值运算符
    SimpleClass& operator=(const SimpleClass& other) = default;

    // 默认移动构造函数
    SimpleClass(SimpleClass&& other) = default;

    // 默认移动赋值运算符
    SimpleClass& operator=(SimpleClass&& other) = default;
};

int main() {
    SimpleClass obj1; // 使用默认构造函数
    SimpleClass obj2 = obj1; // 使用默认拷贝构造函数
    SimpleClass obj3(std::move(obj1)); // 使用默认移动构造函数
    obj2 = obj3; // 使用默认拷贝赋值运算符
    obj3 = std::move(obj2); // 使用默认移动赋值运算符

    return 0;
}

SimpleClass显式地声明了所有默认成员函数，并使用default关键字告诉编译器生成默认实现。即使没有显式声明这些函数，编译器也会为这个类自动生成它们。

C++ 中 class 与 struct

在C++中，struct和class的区别主要在于默认访问权限和继承方式。除此之外，它们的功能和用法基本相同。

• class 和 struct 都可以用来定义自定义数据类型。
• class 的默认访问权限是私有（private），而 struct 的默认访问权限是公共（public）。
• class 的继承方式是私有继承（private inheritance），而 struct 的继承方式是公共继承（public inheritance）。
• class 和 struct 都可以有成员变量和成员函数，构造函数和析构函数，运算符重载，模板和异常处理。

选择使用类还是struct

• 如果需要定义一个具有私有成员变量和成员函数的类型，应该使用类。
• 如果需要定义一个具有公共成员变量和成员函数的类型，应该使用struct。
• 如果需要定义一个具有私有继承的类型，应该使用类。
• 如果需要定义一个具有公共继承的类型，应该使用struct。