C++ 数据封装

在 C++ 中，数据封装（Encapsulation）是面向对象编程的基石之一，它通过将数据（成员变量）和对数据的操作（成员函数）组合在一起，并隐藏实现细节，只对外暴露必要的接口，从而达到以下目的：

• 隐藏实现，防止外部直接访问或篡改内部状态
• 维护不变式，通过受控接口保证对象状态始终有效
• 降低耦合，改动内部实现时不影响使用者

下面从语言机制和设计实践两方面详细阐述 C++ 中的数据封装。

---

1. 访问控制关键字

C++ 提供三种访问权限修饰符，用于控制成员对外的可见性：

关键字	对类内部	对派生类	对外部（所有其他）
public	可见	可见	可见
protected	可见	可见	不可见
private	可见	不可见	不可见

class Example {
public:
    void    pub();       // 公有：任何地方都能调用

protected:
    int     prot_;       // 受保护：派生类可访问

private:
    double  priv_;       // 私有：仅本类内部可访问
};

• public 用于对外接口
• private 隐藏实现细节
• protected 在需要让派生类访问但不希望完全公开时使用

---

2. 用 Getter/Setter 控制访问

直接将成员设为 private，再提供公有的访问函数，是最常见的封装手段：

class Person {
private:
    std::string name_;
    int         age_;

public:
    // 读取器 (getter)
    const std::string& getName() const { return name_; }
    int                 getAge()  const { return age_; }

    // 修改器 (setter)，可加入合法性检查
    void setName(const std::string& n) { 
        if (!n.empty()) name_ = n; 
    }
    void setAge(int a) {
        if (a >= 0 && a <= 150) age_ = a;
    }
};

• 优点
  • 可以在 setter 中验证参数合法性
  • 将来若内部存储方式变更（如从 std::string 换成 char*），只需修改方法体
• 注意
  • 不要提供“傻瓜式” setter/getter（即直接返回或设置所有细节）而失去封装意义
  • 当只需“只读”时，可只提供 const 的 getter，不提供 setter

---

3. friend：有选择地破坏封装

有时需要让特定函数或类访问私有成员，可使用 friend 关键字：

class Box {
    int secret_;

    // 让外部函数 openBox 能访问私有成员
    friend void openBox(const Box& b);

public:
    Box(int s): secret_(s) {}
};

void openBox(const Box& b) {
    std::cout << "秘密数字是 " << b.secret_ << "\n";
}

• 应用场景：
  • 重载 operator<<／operator== 等需要直接访问内部数据
  • 同一模块内紧密相关的类之间互访
• 原则：friend 会破坏封装性，慎用且只授予最小权限

---

4. PIMPL（指针隐藏实现）惯用法

当你想彻底隐藏类的实现细节（包括私有成员类型和头文件依赖）时，可用 PIMPL（Pointer to IMPLementation）模式：

// Foo.hpp
class Foo {
public:
    Foo();
    ~Foo();
    void doSomething();

private:
    struct Impl;
    Impl* pImpl;              // 仅暴露指针
};

// Foo.cpp
#include "Foo.hpp"

struct Foo::Impl {
    // 真正的成员
    std::vector<int> data;
    void helper() { /*…*/ }
};

Foo::Foo() : pImpl(new Impl{}) {}
Foo::~Foo() { delete pImpl; }
void Foo::doSomething() {
    pImpl->helper();
}

• 优点
  • 完全解耦接口与实现，修改 Impl 不会导致依赖它的代码重新编译
  • 隐藏第三方库依赖，减少头文件暴露
• 缺点
  • 额外的指针间接开销和内存管理
  • 实现代码更繁琐

---

5. 常量成员与不变式

将不该被修改的数据声明为 const，并在构造时初始化，可保证对象状态不可变：

class ImmutablePoint {
    const double x_;
    const double y_;
public:
    ImmutablePoint(double x, double y): x_(x), y_(y) {}
    double getX() const { return x_; }
    double getY() const { return y_; }
};

• 使用场景：几何坐标、配置参数等初始化后不可更改的属性
• 好处：编译期检查不可变性，逻辑更加健壮

---

6. 结合继承与封装

在基类中将成员设为 protected，允许派生类访问，但对外依然隐藏：

class Base {
protected:
    int state_;
public:
    virtual void doWork() = 0;
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void doWork() override {
        // 可以访问 state_
        state_ += 1;
    }
};

• 优点：派生类可使用基类核心数据，而不暴露给外部
• 注意：protected 成员仍是封装的折衷，外部无法访问，但派生层次越深，维护成本越高

---

7. 设计原则与最佳实践

1. 对外只暴露最小接口：能用 public、protected、private 三层就用，不要一律 public。
2. 隐式保证不变式：通过私有成员 + 公有接口来维护对象始终处于合法状态。
3. 尽量少用 friend：若实在需要，限定在少数专用函数/类上。
4. 考虑 PIMPL：当需要二进制兼容或大幅度隐藏实现时采用，但别过早优化。
5. 文档说明契约：在公有接口处注释前置条件、后置保证和异常安全性，帮助使用者正确调用。

---

通过以上机制和策略，C++ 能够在灵活表达业务逻辑的同时，有效地将实现细节封装在类的内部，为大型系统提供良好的模块化、可维护性和稳定性。