《封装、继承与多态》问题一：封装只有类能做吗？结构体如何封装？名空间、文件能实现封装吗？还有没有其他方式？

问题一：封装只有类能做吗？结构体如何封装？名空间、文件能实现封装吗？还有没有其他方式？

封装（Encapsulation）是面向对象编程的核心原则之一，它指将数据和操作封装在一起，使对象的内部状态只能通过定义的接口访问，从而保护数据完整性并提高代码的模块化和可维护性。

在实际开发中，封装不仅限于类，还可以通过结构体、命名空间、文件甚至其他设计方式实现。以下是详细的说明与举例：

1. 类实现封装

类是封装的最常用工具。通过使用访问修饰符（如 private、protected 和 public），类可以控制哪些成员对外部可见。

示例：

#include <iostream>
#include <string>

class Person {
private:  // 私有成员
    std::string name;
    int age;

public:   // 公有接口
    Person(const std::string& n, int a) : name(n), age(a) {}

    void setName(const std::string& n) { name = n; }
    std::string getName() const { return name; }

    void setAge(int a) { 
        if (a >= 0) age = a; 
    }
    int getAge() const { return age; }
};

int main() {
    Person person("Alice", 25);
    std::cout << person.getName() << " is " << person.getAge() << " years old.\n";

    person.setAge(30);
    std::cout << person.getName() << " is now " << person.getAge() << " years old.\n";
    return 0;
}

关键点：

• 私有数据保护：name 和 age 只能通过类提供的接口访问。
• 接口统一性：外部使用者不需要关心内部实现，接口约定了访问方式。

2. 结构体实现封装

在 C++ 中，struct 和 class 的主要区别是默认访问权限：struct 默认是 public，而 class 默认是 private。通过调整访问修饰符，结构体也能实现封装。

示例：

#include <iostream>

struct Point {
private:
    int x, y;

public:
    Point(int x, int y) : x(x), y(y) {}

    void setCoordinates(int newX, int newY) {
        x = newX;
        y = newY;
    }

    void printCoordinates() const {
        std::cout << "Point(" << x << ", " << y << ")\n";
    }
};

int main() {
    Point p(1, 2);
    p.printCoordinates();
    p.setCoordinates(3, 4);
    p.printCoordinates();
    return 0;
}

关键点：

• struct 和 class 都能通过访问修饰符实现封装。
• 对于简单的数据结构，struct 更直观。

3. 命名空间实现封装

命名空间通过逻辑分组实现封装，使代码模块化并避免命名冲突。

示例：

#include <iostream>

namespace MathUtils {
    namespace Details {
        int add(int a, int b) { return a + b; }
    }

    int sum(int a, int b) { 
        return Details::add(a, b);  // 内部实现隐藏在 Details 命名空间
    }
}

int main() {
    std::cout << "Sum: " << MathUtils::sum(3, 5) << "\n";
    // std::cout << MathUtils::Details::add(3, 5); // 不建议直接访问内部实现
    return 0;
}

关键点：

• 命名空间可以分层，隐藏实现细节。
• 尽量只对外暴露顶层接口，内部实现留在子命名空间中。

4. 文件实现封装

通过分离声明（头文件）和实现（源文件），可以隐藏实现细节，从而实现封装。

示例：

MathUtils.h

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

namespace MathUtils {
    int add(int a, int b);
}

#endif

MathUtils.cpp

#include "MathUtils.h"

namespace MathUtils {
    int add(int a, int b) {
        return a + b;
    }
}

main.cpp

#include <iostream>
#include "MathUtils.h"

int main() {
    std::cout << "Sum: " << MathUtils::add(2, 3) << "\n";
    return 0;
}

关键点：

• 外部只需要头文件，隐藏了实现细节。
• 源文件是实现细节的载体，对外不可见。

5. 其他实现封装的方式

5.1 模块化编程

在现代 C++（如 C++20）中，模块（Modules）是一种更高级的封装方式，取代了传统的头文件和源文件分离方式。

5.2 函数封装

函数本身也能起到封装的作用，特别是在只需要对外暴露功能，而隐藏具体实现的场景中。

示例：

double calculateArea(double radius) {
    return 3.14159 * radius * radius;  // 实现细节封装在函数中
}

5.3 访问控制模式

使用设计模式（如代理模式、门面模式）来实现逻辑层的封装，将复杂实现隐藏在接口后面。

示例：门面模式

#include <iostream>
#include <string>

class SubsystemA {
public:
    void operationA() { std::cout << "SubsystemA operation\n"; }
};

class SubsystemB {
public:
    void operationB() { std::cout << "SubsystemB operation\n"; }
};

class Facade {
private:
    SubsystemA a;
    SubsystemB b;

public:
    void unifiedOperation() {
        a.operationA();
        b.operationB();
    }
};

int main() {
    Facade facade;
    facade.unifiedOperation();
    return 0;
}

总结表格：封装实现方式对比