C++中的适配器模式

适配器模式（Adapter Pattern）

适配器模式是一种结构型设计模式，它使得原本由于接口不兼容而不能一起工作的类可以协同工作。适配器模式通过将一个类的接口转换成客户端希望的另一种接口，使得原本接口不兼容的类可以一起工作。适配器可以是对象适配器或类适配器，对象适配器使用组合，类适配器使用多重继承。

实际应用

图形渲染库适配器

假设我们有一个旧的图形渲染库和一个新的图形渲染接口，我们需要使旧的库适配新的接口。

1. #include <iostream>

3. // 旧的图形渲染库

4. class OldGraphicsRenderer {

5. public:

6. void drawCircle(float x, float y, float radius) {

7. std::cout << "Old Renderer: Drawing Circle at (" << x << ", " << y << ") with radius " << radius << "\n";

8. }

10. void drawRectangle(float x, float y, float width, float height) {

11. std::cout << "Old Renderer: Drawing Rectangle at (" << x << ", " << y << ") with width " << width << " and height " << height << "\n";

12. }

13. };

15. // 新的图形渲染接口

16. class NewGraphicsRenderer {

17. public:

18. virtual void renderCircle(float x, float y, float radius) = 0;

19. virtual void renderRectangle(float x, float y, float width, float height) = 0;

20. };

22. // 适配器类，将旧的渲染库适配到新的接口

23. class GraphicsRendererAdapter : public NewGraphicsRenderer {

24. private:

25. OldGraphicsRenderer* oldRenderer;

26. public:

27. GraphicsRendererAdapter(OldGraphicsRenderer* renderer) : oldRenderer(renderer) {}

29. void renderCircle(float x, float y, float radius) override {

30. oldRenderer->drawCircle(x, y, radius);

31. }

33. void renderRectangle(float x, float y, float width, float height) override {

34. oldRenderer->drawRectangle(x, y, width, height);

35. }

36. };

38. int main() {

39. OldGraphicsRenderer oldRenderer;

40. GraphicsRendererAdapter adapter(&oldRenderer);

42. adapter.renderCircle(10, 10, 5);

43. adapter.renderRectangle(20, 20, 10, 5);

45. return 0;

46. }

日志系统适配器

假设我们有一个旧的日志系统和一个新的日志系统接口，我们需要使旧的日志系统适配新的接口。

1. #include <iostream>

2. #include <string>

4. // 旧的日志系统

5. class OldLogger {

6. public:

7. void logMessage(const std::string& msg) {

8. std::cout << "Old Logger: " << msg << "\n";

9. }

10. };

12. // 新的日志系统接口

13. class NewLogger {

14. public:

15. virtual void info(const std::string& msg) = 0;

16. virtual void error(const std::string& msg) = 0;

17. };

19. // 适配器类，将旧的日志系统适配到新的接口

20. class LoggerAdapter : public NewLogger {

21. private:

22. OldLogger* oldLogger;

23. public:

24. LoggerAdapter(OldLogger* logger) : oldLogger(logger) {}

26. void info(const std::string& msg) override {

27. oldLogger->logMessage("INFO: " + msg);

28. }

30. void error(const std::string& msg) override {

31. oldLogger->logMessage("ERROR: " + msg);

32. }

33. };

35. int main() {

36. OldLogger oldLogger;

37. LoggerAdapter adapter(&oldLogger);

39. adapter.info("This is an info message");

40. adapter.error("This is an error message");

42. return 0;

43. }

支付系统适配器

假设我们有一个旧的支付系统和一个新的支付接口，我们需要使旧的支付系统适配新的接口。

1. #include <iostream>

2. #include <string>

4. // 旧的支付系统

5. class OldPaymentSystem {

6. public:

7. void makePayment(double amount, const std::string& currency) {

8. std::cout << "Old Payment System: Processing payment of " << amount << " " << currency << "\n";

9. }

10. };

12. // 新的支付接口

13. class NewPaymentInterface {

14. public:

15. virtual void pay(double amount) = 0;

16. };

18. // 适配器类，将旧的支付系统适配到新的接口

19. class PaymentAdapter : public NewPaymentInterface {

20. private:

21. OldPaymentSystem* oldPaymentSystem;

22. public:

23. PaymentAdapter(OldPaymentSystem* paymentSystem) : oldPaymentSystem(paymentSystem) {}

25. void pay(double amount) override {

26. oldPaymentSystem->makePayment(amount, "USD");

27. }

28. };

30. int main() {

31. OldPaymentSystem oldPaymentSystem;

32. PaymentAdapter adapter(&oldPaymentSystem);

34. adapter.pay(100.0);

36. return 0;

37. }

总结

适配器类通过包含或继承旧系统类，并实现新接口的方法，从而将旧系统的方法适配到新接口上。