【C++】コンストラクタで仮想関数を呼んではいけない理由と解決策を解説

#include <iostream>
#include <string>

// 基本クラスの定義
class Base {
public:
    Base() {
        std::cout << "Base constructor start." << std::endl;
        // コンストラクタ内で仮想関数を呼び出す
        log(); 
    }

    virtual ~Base() {}

    // 仮想関数の定義
    virtual void log() const {
        std::cout << "Log: Called from Base class." << std::endl;
    }
};

// 派生クラスの定義
class Derived : public Base {
public:
    Derived() : m_data("Derived Data") {
        std::cout << "Derived constructor start." << std::endl;
    }

    // 仮想関数をオーバーライド
    void log() const override {
        std::cout << "Log: Called from Derived class. Data: " << m_data << std::endl;
    }

private:
    std::string m_data;
};

int main() {
    std::cout << "Creating Derived object..." << std::endl;
    Derived d;
    return 0;
}

#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() {}

    // オブジェクト構築後に明示的に呼ぶ関数
    void init() {
        log();
    }

    virtual void log() const {
        std::cout << "Base log" << std::endl;
    }
};

class Derived : public Base {
public:
    void log() const override {
        std::cout << "Derived log" << std::endl;
    }
};

int main() {
    auto d = std::make_unique<Derived>();
    // オブジェクトは完全に構築されているので、仮想関数が正しく動く
    d->init(); 
    return 0;
}

#include <iostream>
#include <memory>

class Base {
protected:
    // 直接生成させない
    Base() = default;

public:
    virtual ~Base() {}

    // 仮想関数
    virtual void log() const = 0;

    // ファクトリテンプレート
    template<typename T, typename... Args>
    static std::unique_ptr<T> create(Args&&... args) {
        auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
        // 構築完了後に仮想関数を伴う処理を行う
        ptr->log(); 
        return ptr;
    }
};

class Derived : public Base {
public:
    // Base::createからアクセスできるようにする
    Derived() : Base() {}

    void log() const override {
        std::cout << "Derived instance created and initialized safely." << std::endl;
    }
};

int main() {
    // 安全に生成
    auto d = Base::create<Derived>();
    return 0;
}

#include <iostream>
#include <string>

class Base {
public:
    // 仮想関数ではなく、コンストラクタ引数で情報を受け取る
    explicit Base(const std::string& message) {
        std::cout << "Base notification: " << message << std::endl;
    }
    virtual ~Base() {}
};

class Derived : public Base {
public:
    // 派生クラスから親へメッセージを投げる
    Derived() : Base("Message from Derived") {
        std::cout << "Derived constructor." << std::endl;
    }
};

int main() {
    Derived d;
    return 0;
}

#include <iostream>
#include <memory>

// 初期化時の振る舞いを定義するインターフェース
class Logger {
public:
    virtual ~Logger() = default;
    virtual void log() const = 0;
};

class Base {
public:
    // 外部から振る舞い(Logger)を受け取る
    explicit Base(std::unique_ptr<Logger> logger) : m_logger(std::move(logger)) {
        if (m_logger) {
            m_logger->log();
        }
    }
    virtual ~Base() {}

private:
    std::unique_ptr<Logger> m_logger;
};

class DerivedLogger : public Logger {
public:
    void log() const override {
        std::cout << "Specialized logging for Derived class." << std::endl;
    }
};

class Derived : public Base {
public:
    // 自身のコンストラクタ引数で、親に必要な部品を渡す
    Derived() : Base(std::make_unique<DerivedLogger>()) {}
};

int main() {
    Derived d;
    return 0;
}