【C++】类的概念与基本使用介绍

C++类是面向对象编程（OOP）的基础，它允许我们将数据（属性）和行为（方法）封装在一起，形成一个自定义的数据类型。以下是C++类的基本概念、特点、特性以及使用注意事项，最后会提供一个简单的代码示例。

1. 类的基本概念

1. 类（Class）：类是一个用户定义的数据类型，它包含数据成员（属性）和成员函数（方法）。
2. 对象（Object）：对象是类的实例，可以创建多个对象。
3. 封装（Encapsulation）：将数据和对数据的操作封装在一起，只对外暴露必要的接口。
4. 继承（Inheritance）：允许一个类继承另一个类的属性和方法。
5. 多态（Polymorphism）：允许不同类的对象对同一消息做出响应。

2. 类的特点

1. 抽象：类提供了一种抽象手段，可以隐藏内部实现细节。
2. 封装：类将数据和操作数据的方法封装在一起，提高了代码的可维护性和安全性。
3. 继承：类可以继承其他类的特性，实现代码复用。
4. 多态：类可以通过虚函数实现多态，使得同一操作可以作用于不同类型的对象。

3. 类的特性

1. 数据成员：类中定义的数据变量。
2. 成员函数：类中定义的函数。
3. 构造函数：用于初始化对象。
4. 析构函数：用于清理对象。
5. 访问修饰符：public、private、protected，用于控制成员的访问权限。

在C++中，public、private 和 protected 是三种访问修饰符，它们用于控制类成员（包括数据成员和成员函数）的访问权限。以下是这三种访问修饰符的区别：

3.1 public

• public成员可以被类的外部访问，无论这些外部访问是通过对象还是通过类的继承关系。
• public成员是类的公共接口的一部分，通常用于提供对类外部的方法和数据的访问。

3.2 private

• private成员只能被类内部的成员函数（包括构造函数、析构函数和友元函数）访问。
• private成员用于实现类的内部工作细节，隐藏实现细节，防止类外部直接访问和修改，保证了类的封装性。
• private成员不能被派生类（子类）访问，即使是派生类中定义的成员函数也不能直接访问基类的private成员。

3.3 protected

• protected成员与private成员类似，但它们可以被派生类访问。
• protected成员通常用于那些需要在派生类中直接访问，但在类外部不应该被访问的数据和行为。
• 与private成员一样，protected成员不能被类的外部访问，但它们可以被派生类的成员函数访问，无论是直接访问还是通过继承链。

下面是一个简单的例子来说明这三种访问修饰符的区别：

class Base {
public:
    int publicVar;  // 公共变量，可以被外部访问
    void publicFunc() { // 公共函数，可以被外部调用
        // 可以访问public, private, protected成员
    }
    
private:
    int privateVar;  // 私有变量，只能在类内部访问
    void privateFunc() { // 私有函数，只能在类内部调用
        // 可以访问public, private, protected成员
    }
    
protected:
    int protectedVar;  // 保护变量，可以在类内部和派生类中访问
    void protectedFunc() { // 保护函数，可以在类内部和派生类中调用
        // 可以访问public, private, protected成员
    }
};

class Derived : public Base {
public:
    void accessBaseMembers() {
        publicVar = 10; // 可以访问基类的public成员
        // privateVar = 20; // 错误：不能访问基类的private成员
        protectedVar = 30; // 可以访问基类的protected成员
        publicFunc(); // 可以调用基类的public成员函数
        // privateFunc(); // 错误：不能调用基类的private成员函数
        protectedFunc(); // 可以调用基类的protected成员函数
    }
};

int main() {
    Base base;
    base.publicVar = 10; // 正确：可以访问public成员
    // base.privateVar = 20; // 错误：不能访问private成员
    // base.protectedVar = 30; // 错误：不能访问protected成员
    base.publicFunc(); // 正确：可以调用public成员函数
    // base.privateFunc(); // 错误：不能调用private成员函数
    // base.protectedFunc(); // 错误：不能调用protected成员函数
    return 0;
}

在这个例子中，Base 类定义了public、private和protected成员。Derived 类继承自 Base 类，并尝试访问基类成员。通过例子可以看出，public成员可以被任何地方访问，private成员只能被类内部访问，而protected成员可以被类内部和派生类访问。

4. 使用注意事项

1. 合理使用访问修饰符：保护类的内部状态，只暴露必要的接口。
2. 初始化和清理：正确使用构造函数和析构函数。
3. 避免过度封装：适当的封装可以提高代码的可读性和可维护性，但过度封装可能导致代码复杂度增加。
4. 继承和组合的选择：根据实际情况选择继承或组合。

5. 代码示例

以下是一个简单的 C++ 类示例，用于表示一个矩形：

// 矩形类定义
class Rectangle {
private:
    float length; // 矩形的长
    float width;  // 矩形的宽
    
public:
    // 构造函数
    Rectangle(float l, float w) {
        length = l;
        width = w;
    }
    
    // 计算面积的方法
    float area() {
        return length * width;
    }
    
    // 计算周长的方法
    float perimeter() {
        return 2 * (length + width);
    }
    
    // 析构函数
    ~Rectangle() {
        // 可以在这里进行清理工作
    }
};

int main() {
    // 创建矩形对象
    Rectangle rect(10.0, 5.0);
    // 计算并输出面积
    std::cout << "面积: " << rect.area() << std::endl;
    // 计算并输出周长
    std::cout << "周长: " << rect.perimeter() << std::endl;
    return 0;
}

5.1 代码讲解

1. 类定义：class Rectangle 定义了一个名为 Rectangle 的类。
2. 私有成员：private 下的 length 和 width 是矩形的属性，只能在类内部访问。
3. 构造函数：Rectangle(float l, float w) 是一个构造函数，用于初始化矩形的长和宽。
4. 成员函数：area() 和 perimeter() 是成员函数，分别用于计算矩形的面积和周长。
5. 析构函数：~Rectangle() 是析构函数，用于对象销毁前的清理工作。
6. 创建对象：Rectangle rect(10.0, 5.0); 创建了一个 Rectangle 类的对象 rect。
7. 调用成员函数：通过 rect.area() 和 rect.perimeter() 调用对象的成员函数，计算并输出面积和周长。