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

封装（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;
}


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