封装，这是面向对象编程的核心概念，也是程序员最容易误解的概念。许多人以为封装就是把数据藏起来，这是根本性的误解。

封装不是隐藏数据，而是隐藏实现细节。封装的目的是提供稳定的接口，而不是保护数据。

封装体现了"关注点分离"的设计哲学。它要求我们将"做什么"（接口）与"怎么做"（实现）分离，让使用者只关心接口，不关心实现。

真正的封装是行为的封装，不是数据的封装。好的封装让接口稳定，实现可变。

封装的本质

许多人把封装理解为"数据隐藏"，这是错误的。封装的核心是"实现隐藏"，而不是"数据隐藏"。

David Parnas在1972年提出的信息隐藏理论是封装的基石。它要求我们隐藏模块的实现细节，只暴露必要的接口。

封装减少了认知负荷。使用者不需要了解内部实现，只需要知道如何使用接口。这符合人类的认知特点。

// 没有封装，就像没有门锁的房子
class BankAccount {
public:
    double balance;  // 谁都能改
    void withdraw(double amount) {
        balance -= amount;  // 没有检查，想取多少取多少
    }
};

// 有封装，就像有门锁的房子
class BankAccount {
private:
    double balance;  // 锁起来
public:
    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;  // 有检查，安全
        }
    }
    double getBalance() const { return balance; }
};

访问控制：public、private、protected

访问控制不是权限管理，而是接口设计。它定义了类的边界，决定了哪些是稳定的接口，哪些是可变的实现。

• public：稳定的接口，承诺不会轻易改变
• private：实现细节，可以随时改变
• protected：继承接口，介于稳定和可变之间

C++20的concepts让我们可以更准确地表达接口约束，但访问控制依旧是基础。

class House {
public:
    void welcome() {  // 客厅，客人可以来
        std::cout << "Welcome to my house!" << std::endl;
    }
    
protected:
    void study() {  // 书房，家人可以进
        std::cout << "I'm studying" << std::endl;
    }
    
private:
    void sleep() {  // 卧室，只有自己能进
        std::cout << "I'm sleeping" << std::endl;
    }
};

class FamilyMember : public House {
public:
    void doSomething() {
        welcome();  // 可以调用
        study();    // 可以调用
        // sleep(); // 不能调用，编译错误
    }
};

接口设计：简单就是美

接口设计是软件架构的核心。一个糟糕的接口会传播到整个系统，影响所有使用者。

好的接口应该符合人类的认知模式。它应该让使用者能够基于已有的知识来理解新的接口。

1. 最小惊讶原则：接口的行为应该符合直觉
2. 一致性原则：类似的接口应该有类似的行为
3. 简洁性原则：接口应该尽可能简单

// 糟糕的接口，像迷宫
class DataProcessor {
public:
    void process(int type, const std::string& data, bool flag1, bool flag2, 
                int mode, double threshold, const std::string& output);
    // 7个参数，鬼知道怎么用
};

// 好的接口，像门把手
class DataProcessor {
public:
    void processText(const std::string& text);
    void processNumber(double number);
    void processWithOptions(const DataOptions& options);
};

const正确性：不变的承诺

const不是性能优化，而是语义表达。它告知编译器和使用者，某个值在某个范围内不会改变。

const是类型系统的一部分，它提供了编译时的保证。没有const，类型系统就不完整。

const体现了"最小权限原则"。默认情况下，所有东西都应该是const的，只有在需要修改时才去掉const。

class String {
private:
    char* data;
    size_t size;
public:
    // const函数，承诺不修改对象
    size_t length() const {
        return size;  // 只读，不修改
    }
    
    char at(size_t index) const {
        return data[index];  // 只读，不修改
    }
    
    // 非const函数，可以修改对象
    void append(char c) {
        // 修改对象状态
        data[size++] = c;
    }
};

const String str("hello");
size_t len = str.length();  // 可以调用
char c = str.at(0);         // 可以调用
// str.append('!');         // 不能调用，编译错误

友元：特殊的朋友

友元破坏了封装，但它有时是必要的。关键在于理解什么时候使用友元是合理的。

友元应该用于表达"实现细节的共享"，而不是"权限的授予"。它应该用于优化性能或简化实现，而不是绕过封装。

1. private static成员函数：用于内部实现
2. namespace内部函数：用于相关功能的组织
3. concepts：用于类型约束

class BankAccount {
private:
    double balance;
public:
    BankAccount(double initial) : balance(initial) {}
    
    // 只有BankManager才能直接访问balance
    friend class BankManager;
};

class BankManager {
public:
    void audit(BankAccount& account) {
        std::cout << "Balance: " << account.balance << std::endl;  // 可以直接访问
    }
};

现代C++的封装：智能指针

智能指针不是指针的替代品，而是所有权的表达。它明确地表达了资源的所有权关系。

智能指针是RAII原则的完美体现。它将资源的生命周期与对象的生命周期绑定，确保资源的正确释放。

所有权语义：

• std::unique_ptr：独占所有权，不可复制
• std::shared_ptr：共享所有权，引用计数
• std::weak_ptr：弱引用，不参与所有权管理

class Resource {
private:
    std::unique_ptr<int[]> data;  // 自动管理内存
    size_t size;
public:
    Resource(size_t s) : data(std::make_unique<int[]>(s)), size(s) {}
    // 不需要析构函数，智能指针自动清理
    
    int& operator[](size_t index) {
        return data[index];
    }
};

封装的设计原则

封装的设计原则不是技术问题，而是认知问题。它要求我们重新思考什么是必要的，什么是不必要的。

只暴露必要的接口，隐藏所有实现细节。这个原则的核心是减少认知负荷。

1. 单一职责：每个接口只做一件事
2. 最小惊讶：接口的行为应该符合直觉
3. 一致性：类似的接口应该有类似的行为

class Stack {
private:
    std::vector<int> data;
public:
    void push(int value) { data.push_back(value); }
    void pop() { data.pop_back(); }
    int top() const { return data.back(); }
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
    // 只暴露必要的接口，内部实现完全隐藏
};

常见陷阱

过度封装是封装的反面。它增加了复杂性，但没有提供任何价值。

1. Anemic Domain Model：只有数据没有行为的类
2. God Object：承担太多职责的类
3. Feature Envy：过度依赖其他类的数据

封装应该基于行为，而不是基于数据。如果一个类只有getter/setter，它可能不需要存在。

// 过度封装
class Point {
private:
    int x, y;
public:
    void setX(int x) { this->x = x; }
    void setY(int y) { this->y = y; }
    int getX() const { return x; }
    int getY() const { return y; }
};

// 简单封装
class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
};

性能思考

封装与性能不是对立的。好的封装实际上有助于性能优化。

现代编译器会进行内联优化，小函数调用没有性能损失。

1. 内联函数：小函数自动内联
2. constexpr：编译时计算
3. 模板特化：针对特定类型的优化

class Point {
private:
    int x, y;
public:
    int getX() const { return x; }  // 自动内联
    int getY() const { return y; }  // 自动内联
};

写在最后

封装不是隐藏数据，而是隐藏实现细节。封装的目的是提供稳定的接口，而不是保护数据。

1. 关注点分离：将"做什么"与"怎么做"分离
2. 最小权限原则：只暴露必要的接口
3. 稳定性优先：接口应该稳定，实现可以变化

• 智能指针表达所有权语义
• const提供类型安全保证
• concepts提供类型约束
• RAII确保资源安全

好的封装不是技术问题，而是设计问题。它要求我们重新思考什么是必要的，什么是不必要的。

好了，今天就聊到这里。下次我们聊聊继承，看看怎么建立类之间的层次关系。