C++构造函数中调用虚函数的陷阱与解决方案

1次阅读

共计 2017 个字符，预计需要花费 6 分钟才能阅读完成。

在 C ++ 中，对象的构造遵循严格的顺序（ISO C++ 标准 [class.base.init]/13）：

基类构造（按继承顺序）
成员变量初始化（按声明顺序）
执行构造函数体

关键点 ：虚函数表指针(vptr) 的初始化发生在当前类构造的最初阶段（基类构造前）。这意味着在构造函数执行期间：

如果调用虚函数，实际调用的是当前类版本的函数（而非派生类重写版本）
动态类型识别 (dynamic_cast/typeid) 会返回当前构造中的类型

class Base {
public:
    Base() { foo(); }  // 危险！调用的是 Base::foo()
    virtual void foo() { cout << "Base" << endl;}
};

class Derived : public Base {
public:
    void foo() override { cout << "Derived" << endl;}
};
// 输出 "Base" 而非预期的 "Derived"

class Logger {
public:
    Logger() { log("Object created"); } // 假设派生类实现了不同日志方式
    virtual void log(const string&) = 0;
};
// 直接导致纯虚函数调用崩溃

class Device {
public:
    Device() { initialize(); } // 派生类可能重写初始化逻辑
    virtual void initialize() {fd = open("/dev/xxx"); // 基类打开资源
    }
    // 若派生类初始化失败，基类资源泄漏
};

原理：将构造与初始化分离，通过静态方法创建对象

class SafeBase {
protected:
    SafeBase() = default; // 禁止直接构造
    virtual void postInit() {} // 供派生类重写

public:
    template<typename T, typename... Args>
    static std::unique_ptr<T> create(Args&&... args) {auto obj = std::make_unique<T>(std::forward<Args>(args)...);
        obj->postInit(); // 安全调用虚函数
        return obj;
    }
};

// 使用示例
class SafeDerived : public SafeBase {
protected:
    void postInit() override { /* 安全的多态逻辑 */}
};
auto obj = SafeBase::create<SafeDerived>();

原理：显式分离对象构造与初始化

class TwoPhase {
public:
    TwoPhase() = default;

    // 必须显式调用的初始化方法
    bool initialize() {return doInitialize(); // 安全调用虚函数
    }

protected:
    virtual bool doInitialize() { return true;}
};

// 使用示例
class Resource : public TwoPhase {
protected:
    bool doInitialize() override {
        // 实现资源初始化
        return true;
    }
};

auto res = std::make_unique<Resource>();
if (!res->initialize()) {/* 错误处理 */}

原理：用非虚函数包裹虚函数调用

class NVI {
public:
    NVI() {
        // 调用非虚函数
        safeOperation();}

    void safeOperation() {
        // 可能包含前置 / 后置处理
        doOperation(); // 实际虚调用}

protected:
    virtual void doOperation() = 0;};

方案	内存开销	CPU 开销	适用场景
工厂方法	1 次额外分配	间接调用成本	需要严格安全控制
两阶段初始化	无	额外调用开销	资源密集型对象
NVI 模式	无	虚函数表查找	简单逻辑封装