在C++中的封装（Encapsulation）

在C++中，封装（Encapsulation） 是面向对象编程的核心概念之一，它通过类（Class）将数据（成员变量）和操作数据的函数（成员函数）捆绑在一起，并使用访问修饰符控制对这些成员的访问权限。以下是详细介绍：

1. 类的定义

类是一种用户自定义数据类型，封装了数据和行为。定义格式：

class ClassName {
    // 访问修饰符（public/protected/private）
    成员变量;
    成员函数;
};  // 注意分号

示例：

class Rectangle {
private:
    int width;   // 成员变量（私有）
    int height;  // 成员变量（私有）

public:
    // 构造函数
    Rectangle(int w, int h) : width(w), height(h) {}

    // 成员函数（公有）
    int getArea() { return width * height; }
    void setWidth(int w) { width = w; }
};

2. 成员变量与成员函数

成员变量（属性）

• 描述类的状态，存储对象的数据。
• 可在类内直接访问，外部需通过公有成员函数访问（封装特性）。

成员函数（方法）

• 定义在类内部或外部（需使用作用域解析运算符::）。
• 可访问和修改成员变量，实现类的行为。

示例：成员函数外部定义

class Rectangle {
private:
    int width, height;
public:
    Rectangle(int w, int h);  // 声明构造函数
    int getArea();           // 声明成员函数
};

// 构造函数的外部定义
Rectangle::Rectangle(int w, int h) : width(w), height(h) {}

// 成员函数的外部定义
int Rectangle::getArea() { return width * height; }

3. 访问修饰符

控制成员的访问权限，实现数据隐藏和封装。

private（私有成员）

• 特点：只能被类内部的成员函数访问，外部无法直接访问。
• 用途：隐藏实现细节，防止外部直接修改数据。

class Rectangle {
private:
    int width;  // 私有成员变量
    void validateDimensions() { /* ... */ }  // 私有工具函数
};

public（公有成员）

• 特点：可被类外部的任何代码访问。
• 用途：提供公共接口，允许外部与对象交互。

class Rectangle {
public:
    int getWidth() { return width; }  // 公有访问器
    void setWidth(int w) {            // 公有修改器
        if (w > 0) width = w;
    }
};

protected（保护成员）

• 特点：只能被类内部、子类（派生类）访问，外部无法访问。
• 用途：在继承体系中允许子类访问基类的特定成员。

class Shape {
protected:
    int color;  // 子类可访问，但外部不可访问
};

class Rectangle : public Shape {
public:
    void setColor(int c) { color = c; }  // 子类可访问保护成员
};

4. 封装的优势

1. 数据隐藏：防止外部直接修改内部数据，提高安全性。
2. 接口与实现分离：外部只需通过公有接口使用类，无需关心内部实现。
3. 可维护性：内部实现变化不会影响外部代码。

示例：安全的数据访问

class BankAccount {
private:
    double balance;  // 私有成员变量

public:
    // 公有接口控制数据访问
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    bool withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
};

5. 访问修饰符的继承规则

子类继承基类时，基类成员的访问权限可能被调整：

示例：

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class Derived : public Base {
public:
    void test() {
        pub = 1;    // 可访问（public）
        prot = 2;   // 可访问（protected）
        // priv = 3; // 不可访问（private）
    }
};

6. 友元函数与友元类

允许特定的外部函数或类访问私有/保护成员（破坏封装性，需谨慎使用）。

示例：友元函数

class Rectangle {
private:
    int width, height;
    friend int getPerimeter(Rectangle r);  // 友元声明
};

// 友元函数可访问私有成员
int getPerimeter(Rectangle r) {
    return 2 * (r.width + r.height);
}

总结

封装通过类和访问修饰符实现数据隐藏，使代码更安全、更易维护。合理设计公有接口和私有实现是面向对象编程的关键。