如何让Event及其派生类调用Thing派生类的foo(false)且避免误用？

原代码与输出 #

原C++代码：

#include <iostream>

struct Thing {
    void foo(bool b = true) {
        std::cout << "Thing::foo() called with b = " << std::boolalpha << b << ".\n";
    }
};

struct Blob : Thing { };

struct Event {
    void execute(Thing& thing) { thing.foo(); }
};

int main() {
    Blob blob;
    Event event;
    event.execute(blob);
}

原输出：

Thing::foo() called with b = true.

需求说明 #

当调用场景为Event及其派生类，且调用对象是**Thing的任意派生类（如Blob）**时，foo的参数b自动为false；其他场景（非Event上下文、或Thing本身）保持默认true。

已知重载方案需适配所有派生类，扩展性差；新增虚函数存在误用普通foo()替代专用接口的风险，因此需要更优方案。

解决方案：上下文标签+模板重载 #

核心思路是通过专属标签类标记Event上下文，配合模板重载自动识别派生类，无需修改现有派生类，也不新增易误用的虚函数接口。

修改后的代码 #

#include <iostream>
#include <type_traits>

// 仅用于标记Event调用上下文的标签类，语义清晰且不污染其他逻辑
struct EventContextTag {};

struct Thing {
    // 保留原接口，非Event场景调用时默认b=true
    void foo(bool b = true) {
        std::cout << "Thing::foo() called with b = " << std::boolalpha << b << ".\n";
    }

    // 模板重载：匹配Thing的所有派生类，在Event上下文时自动传入b=false
    template<typename Derived>
    std::enable_if_t<std::is_base_of_v<Thing, Derived> && !std::is_same_v<Thing, Derived>>
    foo(EventContextTag, Derived&) {
        foo(false);
    }

    // 处理Thing本身的Event上下文调用（若需求为Thing本身在Event中仍用true，保留此实现）
    void foo(EventContextTag, Thing&) {
        foo(true);
    }
};

struct Blob : Thing {};
// 新增派生类无需任何修改，自动适配
struct Widget : Thing {};

struct Event {
    void execute(Thing& thing) {
        // 利用类型推导匹配对应重载，传递Event上下文标签
        auto& derived_ref = static_cast<decltype(thing)&>(thing);
        thing.foo(EventContextTag{}, derived_ref);
    }
};

// Event派生类无需修改，自动继承上下文逻辑
struct SpecialEvent : Event {};

int main() {
    Blob blob;
    Widget widget;
    Thing thing;
    Event event;
    SpecialEvent special_event;

    // 非Event场景调用：输出true
    blob.foo();
    widget.foo();
    thing.foo();

    std::cout << "--- Event context calls ---\n";
    // Event上下文调用派生类：输出false
    event.execute(blob);
    event.execute(widget);
    // Event上下文调用Thing本身：输出true（可根据需求调整）
    event.execute(thing);

    // Event派生类调用：同样输出false
    special_event.execute(blob);
}

输出结果 #

Thing::foo() called with b = true.
Thing::foo() called with b = true.
Thing::foo() called with b = true.
--- Event context calls ---
Thing::foo() called with b = false.
Thing::foo() called with b = false.
Thing::foo() called with b = true.
Thing::foo() called with b = false.

方案优势 #

1. 高扩展性：新增Thing派生类无需任何修改，自动适配Event上下文逻辑
2. 低误用风险：保留原foo()接口，无需新增易混淆的虚函数（如fooDuringEvent()）
3. 语义清晰：通过EventContextTag明确标记调用场景，代码可读性强
4. 精准控制：仅在Event及其派生类的调用上下文中触发b=false逻辑，其他场景不受影响

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