C++继承中基类构造前调用派生类函数及适配模式代码优化

针对你遇到的C++适配器模式中基类构造顺序与派生类转换逻辑的冲突问题，这里提供几种可行的方案，核心思路是在基类构造前一次性完成转换计算，将结果传递给基类，同时避免重复调用转换函数。

方案一：委托构造+内部辅助结构体 #

利用C++11引入的委托构造特性，先通过内部结构体完成一次转换计算，再将结果传递给私有构造函数初始化基类和派生类成员，完美避免重复调用和构造顺序问题。

#include <cmath>
#include <cmath>

// 遗留接口基类
class LegacyInterface {
public:
    LegacyInterface(int width, int height) : _width(width), _height(height) {
        // 基类构造逻辑，此时width/height已完成转换
    }

private:
    int _width;
    int _height;
};

// 适配器派生类
class AdapterInterface : public LegacyInterface {
private:
    // 内部辅助结构体：封装转换逻辑，一次性计算宽高
    struct ConversionResult {
        int w;
        int h;
        explicit ConversionResult(int diagonal) {
            // 示例16:9比例的对角线转宽高逻辑，可替换为实际需求
            const float aspectRatio = 16.0f / 9.0f;
            float width = diagonal / sqrt(1 + 1/(aspectRatio*aspectRatio));
            float height = width / aspectRatio;
            w = static_cast<int>(round(width));
            h = static_cast<int>(round(height));
        }
    };

    // 私有构造函数：接收已计算的宽高，初始化基类和派生类成员
    AdapterInterface(const ConversionResult& res) 
        : LegacyInterface(res.w, res.h), _w(res.w), _h(res.h) {}

public:
    // 对外构造函数：委托给私有构造函数，仅需一次转换计算
    AdapterInterface(int diagonal) : AdapterInterface(ConversionResult(diagonal)) {}

private:
    int _w; // 派生类需存储的宽高（若基类已提供访问接口可省略）
    int _h;
};

优势 #

• 仅执行一次转换逻辑，无冗余计算
• 完全符合C++构造顺序规则：基类构造时已拿到最终转换结果
• 转换逻辑封装在类内部，不对外暴露实现细节

方案二：静态工厂函数 #

如果允许通过工厂方法创建对象而非直接调用构造函数，这种方式灵活性更高，尤其适合复杂初始化场景。

#include <cmath>
#include <utility>

class LegacyInterface {
public:
    LegacyInterface(int width, int height) : _width(width), _height(height) {}

private:
    int _width;
    int _height;
};

class AdapterInterface : public LegacyInterface {
private:
    // 私有构造函数，仅允许工厂函数调用
    AdapterInterface(int w, int h) : LegacyInterface(w, h), _w(w), _h(h) {}

public:
    // 静态工厂函数：先完成转换，再创建对象
    static AdapterInterface create(int diagonal) {
        auto [w, h] = diagToRectConverter(diagonal); // C++17结构化绑定
        return AdapterInterface(w, h);
    }

    // 静态转换函数：封装对角线转宽高逻辑
    static std::pair<int, int> diagToRectConverter(int diagonal) {
        const float aspectRatio = 16.0f / 9.0f;
        float width = diagonal / sqrt(1 + 1/(aspectRatio*aspectRatio));
        float height = width / aspectRatio;
        return {static_cast<int>(round(width)), static_cast<int>(round(height))};
    }

private:
    int _w;
    int _h;
};

// 使用示例
// auto adapter = AdapterInterface::create(100);

优势 #

• 转换逻辑与构造逻辑分离，代码可读性更好
• 可扩展支持更多初始化参数组合
• 避免构造函数中可能出现的顺序依赖问题

方案三：C++17+结构化绑定简化写法 #

如果项目支持C++17及以上版本，可以结合静态转换函数和委托构造，用结构化绑定简化代码，同样保证仅调用一次转换函数。

#include <cmath>
#include <utility>

class LegacyInterface {
public:
    LegacyInterface(int width, int height) : _width(width), _height(height) {}

private:
    int _width;
    int _height;
};

class AdapterInterface : public LegacyInterface {
private:
    AdapterInterface(int w, int h) : LegacyInterface(w, h), _w(w), _h(h) {}

    static std::pair<int, int> convertDiagonal(int diagonal) {
        const float aspectRatio = 16.0f / 9.0f;
        float width = diagonal / sqrt(1 + 1/(aspectRatio*aspectRatio));
        float height = width / aspectRatio;
        return {static_cast<int>(round(width)), static_cast<int>(round(height))};
    }

public:
    AdapterInterface(int diagonal) 
        : AdapterInterface(std::apply([](int w, int h) { return AdapterInterface(w, h); }, convertDiagonal(diagonal))) {}

private:
    int _w;
    int _h;
};

注意事项 #

• 借助std::apply确保转换函数仅调用一次，避免编译器优化不确定性
• 需确保项目支持C++17及以上标准

内容的提问来源于stack exchange，提问作者Jestin