C++访问类成员时触发段错误问题排查

问题本质 #

你遇到的段错误并非对象切片，而是基类构造阶段非法使用dynamic_cast导致的无效引用捕获，属于未定义行为的典型表现。

具体分析 #

1. 构造顺序与dynamic_cast的无效性
   C++对象构造遵循「基类→成员变量→派生类」的顺序：当Parent<Child>的构造函数执行时，Child对象的派生类部分还未初始化，此时this指针仅指向Parent子对象，动态类型为Parent<Child>而非Child。
   此时调用dynamic_cast<Child*>(this)会返回nullptr——dynamic_cast要求对象动态类型与目标类型匹配，而构造中的基类对象还不属于完整的派生类对象。
   解引用nullptr得到的Child&是完全无效的引用，CallbackRegistry的构造函数捕获了这个无效引用，为后续崩溃埋下隐患。

2. 为什么访问成员变量才触发崩溃？
   未访问anotherNumber时，doSomething和doSomethingElse都是非虚成员函数，调用时可能恰好未触发内存访问错误（但依然是未定义行为）。
   一旦访问anotherNumber，需要通过无效引用对应的this指针访问成员变量，此时无效指针的非法内存访问直接触发段错误。

修复方案 #

方案1：改用虚函数回调，避免依赖派生类引用

将回调逻辑抽象为基类虚函数，CallbackRegistry直接绑定基类对象，无需在构造阶段依赖派生类：

#include <cstdlib>
#include <iostream>
#include <optional>
#include <functional>
#include <vector>

template<typename Base>
struct CallbackRegistry
{
    CallbackRegistry(Base& base)
    {
        registerCallback([&](auto value){ base.onCallback(value); });
    }

    void callCallback(int value)
    {
        if (callback_)
        {
            callback_->operator()(value);
        }
    }

private:
    std::optional<std::function<void(int)>> callback_{};

    void registerCallback(std::function<void(int)> callback)
    {
        callback_ = std::move(callback);
    }
};

struct GrandParent
{
    GrandParent() = default;
    virtual ~GrandParent() = default;
    virtual void receiveMessage(int value) = 0;
    virtual void onCallback(int value) = 0; // 新增虚函数
};

template<typename Child>
struct Parent : public GrandParent
{
    Parent() : GrandParent{}, callbackRegistry_(*this) {}

    ~Parent() override = default;

    void receiveMessage(int value) override
    {
        callbackRegistry_.callCallback(value);
    }

protected:
    void doSomething(int value)
    {
        std::cout << "your number is " << value << '\n';
        std::cout << "your other number is " << anotherNumber << '\n';
    }

private:
    int anotherNumber{777};
    CallbackRegistry<GrandParent> callbackRegistry_;
};

struct Child : Parent<Child>
{
    ~Child() override = default;

    void onCallback(int value) override // 实现虚函数
    {
        doSomething(value);
    }
};

int main()
{
    auto child = Child{};
    child.receiveMessage(666);
    return EXIT_SUCCESS;
}

方案2：延迟初始化CallbackRegistry到派生类构造

将CallbackRegistry的初始化移到Child构造函数中，此时Child对象已完全构造，this可以安全转换：

#include <cstdlib>
#include <iostream>
#include <optional>
#include <functional>
#include <vector>

template<typename Child>
struct CallbackRegistry
{
    CallbackRegistry(Child& child)
    {
        registerCallback([&](auto value){ child.doSomethingElse(value); });
    }

    void callCallback(int value)
    {
        if (callback_)
        {
            callback_->operator()(value);
        }
    }

private:
    std::optional<std::function<void(int)>> callback_{};

    void registerCallback(std::function<void(int)> callback)
    {
        callback_ = std::move(callback);
    }
};

struct GrandParent
{
    GrandParent() = default;
    virtual ~GrandParent() = default;
    virtual void receiveMessage(int value) = 0;
};

template<typename Child>
struct Parent : public GrandParent
{
    Parent() : GrandParent{} {}

    ~Parent() override = default;

    void receiveMessage(int value) override
    {
        callbackRegistry_->callCallback(value);
    }

    void initCallback(Child& child)
    {
        callbackRegistry_.emplace(child);
    }

protected:
    void doSomething(int value)
    {
        std::cout << "your number is " << value << '\n';
        std::cout << "your other number is " << anotherNumber << '\n';
    }

private:
    int anotherNumber{777};
    std::optional<CallbackRegistry<Child>> callbackRegistry_{};
};

struct Child : Parent<Child>
{
    Child()
    {
        initCallback(*this);
    }

    ~Child() override = default;

    void doSomethingElse(int value)
    {
        doSomething(value);
    }
};

int main()
{
    auto child = Child{};
    child.receiveMessage(666);
    return EXIT_SUCCESS;
}

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