C++中跨平台类的设计方法

1.引言

2.具体实现

2.1.单一继承实现

2.2.桥接方式实现

3.总结

1.引言

进行C++代码的跨平台设计，主要目标是确保编写的代码能够在不同的操作系统（如Windows、Linux、macOS等）和硬件架构（如x86、ARM等）上无缝运行。

要做到这一点，我们需要从以下几个方面进行考虑和设计：

平台抽象层：在进行C++跨平台设计时，首先需要考虑的是建立平台抽象层。这意味着我们需要对不同平台的差异进行清晰的抽象和封装，以便在客户端代码中隐藏这些差异。可以通过使用宏定义、条件编译以及设计模式等技术来实现平台抽象层，从而使得代码在不同平台上都能够进行编译和运行。

标准库和第三方库：在进行跨平台设计时，我们需要尽量避免使用平台相关的标准库和第三方库。尽量选择标准C++标准库或者跨平台的第三方库，以保证代码能够在不同平台上进行编译和运行。此外，我们也需要注意对于不同平台的特性进行兼容性处理，以确保代码的可移植性。

运行时环境：在进行跨平台设计时，我们需要了解不同平台的运行时环境差异，比如文件系统路径分隔符、换行符、字符编码等。必须保证代码能够正确处理这些差异，以确保在不同平台下的兼容性。同时，还需要考虑到跨平台的错误处理、日志输出等功能，要能够正确地适配不同平台的特性。

测试和调试：跨平台设计并不只是简单地代码编写，还需要充分测试和调试。在进行跨平台设计时，我们需要建立完善的测试体系，覆盖不同平台和设备的测试用例。同时，我们需要利用各种调试工具和技术，及时发现和解决跨平台问题，保障代码的质量和稳定性。

2.具体实现

2.1.单一继承实现

接口与实现分离：通过接口（纯虚类）定义类的行为，而将平台特定的实现细节封装在派生类中。
工厂模式：使用工厂模式或依赖注入等技术来创建平台特定的对象实例，从而隐藏平台依赖。

示例如下：

#include <iostream>
#include <string>
 
// 定义一个基类，用于跨平台操作
class PlatformSpecificClass {
public:
    virtual ~PlatformSpecificClass() {}
    virtual void Show() = 0;
};
 
// 定义Windows平台的子类
class WindowsSpecific : public PlatformSpecificClass {
public:
    void Show() override {
        std::cout << "显示Windows特定的内容" << std::endl;
    }
};
 
// 定义Linux平台的子类
class LinuxSpecific : public PlatformSpecificClass {
public:
    void Show() override {
        std::cout << "显示Linux特定的内容" << std::endl;
    }
};
 
// 定义一个工厂方法，用于根据平台创建对象
PlatformSpecificClass* CreatePlatformSpecificObject() {
#ifdef _WIN32
    return new WindowsSpecific();
#else
    return new LinuxSpecific();
#endif
}
 
int main() {
    PlatformSpecificClass* obj = CreatePlatformSpecificObject();
    obj->Show();
    delete obj;
    return 0;
}

这个简单的例子展示了如何使用基类指针和工厂方法来创建特定平台的对象，并调用它们的Show方法。在Windows平台上，它会创建一个WindowsSpecific对象，在Linux平台上，它会创建一个LinuxSpecific对象。这种方法使得在不修改源代码的情况下，根据编译平台创建不同的对象成为可能。

实际案例：QWaitCondition

Qt之条件变量QWaitCondition详解(从使用到原理分析全)-CSDN博客

Qt中的条件变量QWaitCondition实现就是采用这种方式，主要实现步骤：

1）在QWaitCondition声明了主要是对外接口

2）在windows平台下封装了QWaitConditionPrivate，实现了自己的QWaitCondition

3）在linux平台下也封装了QWaitConditionPrivate，实现了自己的QWaitCondition

平时在使用的时候根本感觉不到平台的差异，写出的代码有很好的平台移植性。

2.2.桥接方式实现

它的实现基础就是桥接设计模式：

设计模式之桥接模式-CSDN博客

桥接模式（Bridge Pattern）是一个非常有用的设计模式，它能够将类的抽象部分与它的实现部分分离，使它们都可以独立地变化。这在处理不同操作系统或平台下的具体实现时特别有用，因为它允许我们编写不依赖于具体实现的代码。

假设我们需要设计一个图形系统，该系统需要在Windows和Linux平台上工作，而图形系统中有多种形状（如圆形、矩形等）。我们可以使用桥接模式来设计这个系统。

1）定义实现化接口（Implementor）

class DrawAPI {  
public:  
    virtual ~DrawAPI() {}  
    virtual void drawCircle(double radius, double x, double y) = 0;  
    // 可以添加更多绘制函数  
};

2）定义具体实现化（Concrete Implementor）

//windows实现
class WinDrawAPI : public DrawAPI {  
public:  
    void drawCircle(double radius, double x, double y) override {  
        // Windows平台下的绘制圆代码  
        std::cout << "Drawing Circle[Windows]: " << radius << ", " << x << ", " << y << std::endl;  
    }  
};  
  
//linux实现
class LinuxDrawAPI : public DrawAPI {  
public:  
    void drawCircle(double radius, double x, double y) override {  
        // Linux平台下的绘制圆代码  
        std::cout << "Drawing Circle[Linux]: " << radius << ", " << x << ", " << y << std::endl;  
    }  
};

3）定义抽象化角色（Abstraction）

class Shape {  
protected:  
    std::unique_ptr<DrawAPI> drawAPI;  
  
public:  
    Shape(DrawAPI* drawAPI) : drawAPI(drawAPI) {}  
    virtual ~Shape() { delete drawAPI; }  
    virtual void draw() = 0;  
};

4）定义修正抽象化角色（Refined Abstraction）

class Circle : public Shape {  
private:  
    double radius;  
  
public:  
    Circle(double radius, DrawAPI* drawAPI) : Shape(drawAPI), radius(radius) {}  
  
    void draw() override {  
        drawAPI->drawCircle(radius, 0.0, 0.0);  
    }  
};

5）客户端代码

int main() {  
    std::unique_ptr<Shape> circleWindows(new Circle(5, new WinDrawAPI()));  
    std::unique_ptr<Shape> circleLinux(new Circle(5, new LinuxDrawAPI()));  
  
    circleWindows->draw();  
    circleLinux->draw();  
  
    return 0;  
}

通过这种方式，我们能够将图形系统的绘制逻辑与具体的操作系统平台解耦。如果需要支持更多的平台，我们只需要添加新的DrawAPI子类即可，而无需修改Shape和Circle类。这使得我们的代码更加灵活和易于维护。

实际案例：绘图系统中的桥接模式

在Qt的绘图系统中，QPaintDevice、QWidget、QPaintEngine和QRasterPaintEngine这些类的角色和关系，可以用桥接模式来描述。在这个模型中：

QPaintDevice可以看作是"抽象部分"（Abstraction）。它定义了一些公共接口，比如width(), height(), logicalDpiX()等，这些接口用于描述一个绘图设备的基本属性。值得注意的是，QPaintDevice有一个paintEngine方法，返回一个QPaintEngine指针。
QWidget是QPaintDevice的一个具体子类，它代表了一个可视的窗口。这里，QWidget就是"具体的抽象部分"（RefineAbstraction）。QWidget重写了QPaintDevice的paintEngine方法，并返回QRasterPaintEngine指针
QPaintEngine可以看作是"实现部分"（Implmentor）。它定义了一些低级别的绘图接口，比如drawPath(), drawImage()等，这些接口用于在具体的绘图设备上进行绘制。
QRasterPaintEngine是QPaintEngine的一个具体子类，它实现了在基于光栅的设备上进行绘制。这里，QRasterPaintEngine就是"具体的实现部分"（ConcreteImplmentor）。

这样一来，QPaintDevice和QPaintEngine就形成了一个桥接，使得绘图设备的抽象（比如QWidget）和具体的绘制操作（比如在光栅设备上绘制）能够独立地变化。

在这个桥接模式中，QPainter就扮演了一个"客户端"（Client）的角色（没有在UML类图中画出来，但会在后面的代码示例中体现），它使用QPaintDevice提供的抽象接口，并通过QPaintEngine来进行具体的绘制操作。

可以使用C++程序来描述这几个Qt类的关系。请注意，这只是笔者根据自己对Qt源代码的理解，进行的简单抽象，实际代码与程序实例有一定差异，省略了很多的细节。但用于描述Qt绘图系统如何使用桥接模式，应该是勉强足够的。

class QPaintDevice {
public:
    virtual QPaintEngine* paintEngine() const = 0;  // 纯虚函数
    // 其他方法...
};

class QWidget : public QPaintDevice {
public:
    QPaintEngine* paintEngine() const override {
        // 返回一个QRasterPaintEngine实例
        static QRasterPaintEngine instance;
        return &instance;
    }
    // 其他方法...
};

class QPaintEngine {
public:
    virtual void drawPath(const QPainterPath &path) = 0;  // 纯虚函数
    // 其他方法...
};

class QRasterPaintEngine : public QPaintEngine {
public:
    void drawPath(const QPainterPath &path) override {
        // 在光栅设备上绘制路径
        // 具体实现...
    }
    // 其他方法...
};

class QPainter {
public:
    QPainter(QPaintDevice *device) : device(device), engine(device->paintEngine()) {}
    void drawPath(const QPainterPath &path) {
        engine->drawPath(path);
    }
private:
    QPaintDevice *device;
    QPaintEngine *engine;
};

上面的代码示例中，QPainter是客户端代码，它接受一个QPaintDevice对象，并通过QPaintDevice的paintEngine方法获取对应的QPaintEngine对象。然后在需要绘图时，QPainter会通过QPaintEngine的drawPath方法进行绘制。这样，QPainter就能够在不同的设备上进行绘制，而不需要关心具体的绘制过程是如何实现的。这桥接模式的设计思想：将抽象（QPaintDevice）和实现（QPaintEngine）分离，使得二者可以独立地变化。