如何无需类型转换获取自定义Node体系中的指定模板结构体？

1. 封装类型转换的基类查询接口 #

在基类Node中封装类型转换逻辑，对外提供类型安全的模板查询方法，用户无需手动写static_cast/dynamic_cast：

#include <type_traits>
#include <stdexcept>

class Node {
public:
    virtual ~Node() = default;

    template<typename T>
    requires std::is_base_of_v<Node, T>
    T* get_as() {
        auto ptr = dynamic_cast<T*>(this);
        if (!ptr) throw std::bad_cast();
        return ptr;
    }

    template<typename T>
    requires std::is_base_of_v<Node, T>
    const T* get_as() const {
        auto ptr = dynamic_cast<const T*>(this);
        if (!ptr) throw std::bad_cast();
        return ptr;
    }
};

template<typename T>
class DataNode : public Node {
public:
    T data;
    explicit DataNode(T val) : data(val) {}
};

template<typename Func>
class FunctionNode : public Node {
private:
    Func func;
public:
    explicit FunctionNode(Func f) : func(std::move(f)) {}
    auto operator()(auto... args) {
        return func(args...);
    }
};

// 使用示例
Node* getNext(); // 假设这个函数返回某个Node子类指针
int main() {
    try {
        auto func_node = getNext()->get_as<FunctionNode<std::plus<int>>>();
        auto result = (*func_node)(2, 4); // 直接调用，无需手动转换
    } catch (const std::bad_cast&) {
        // 处理非FunctionNode的情况
    }
}

这个方案保留了原有继承体系，把转换逻辑封装在基类内部，用户只需要调用get_as<T>()就能安全获取目标类型指针。

2. 用std::variant替代继承体系 #

如果可以重构节点设计，放弃传统多态继承，改用std::variant存储不同类型节点，完全避免类型转换：

#include <variant>
#include <functional>

template<typename T>
struct DataNode {
    T data;
    explicit DataNode(T val) : data(val) {}
};

template<typename Func>
struct FunctionNode {
    Func func;
    explicit FunctionNode(Func f) : func(std::move(f)) {}
    auto operator()(auto... args) {
        return func(args...);
    }
};

// 定义Node为变体类型，包含所有可能的节点类型
using Node = std::variant<DataNode<int>, DataNode<std::string>, FunctionNode<std::plus<int>>, FunctionNode<std::multiplies<double>>>;

// 使用示例
Node getNext();
int main() {
    auto next_node = getNext();

    // 直接获取FunctionNode并调用
    if (auto* func_node = std::get_if<FunctionNode<std::plus<int>>>(&next_node)) {
        auto result = (*func_node)(2, 4);
    }

    // 或者用std::visit统一处理不同节点类型
    std::visit([](auto&& node) {
        using NodeType = std::decay_t<decltype(node)>;
        if constexpr (std::is_same_v<NodeType, FunctionNode<std::plus<int>>>) {
            auto result = node(2, 4);
            // 处理结果
        } else if constexpr (std::is_same_v<NodeType, DataNode<int>>) {
            // 处理整数数据节点
        }
    }, next_node);
}

这种方式更贴合C++20的现代风格，没有虚函数开销，通过变体的类型安全访问直接操作目标节点，完全不需要类型转换。

3. CRTP实现编译期类型自省 #

利用CRTP（奇异递归模板模式）让子类向基类注册自身类型，在编译期完成类型检查，运行期安全转换：

#include <typeinfo>
#include <stdexcept>

class Node {
public:
    virtual ~Node() = default;

    template<typename T>
    T* as() {
        static_assert(std::is_base_of_v<Node, T>, "T must be a Node subclass");
        if (matches_type<T>()) {
            return static_cast<T*>(this);
        }
        throw std::bad_cast();
    }

protected:
    virtual bool matches_type(const std::type_info& ti) const = 0;

    template<typename T>
    bool matches_type() const {
        return matches_type(typeid(T));
    }
};

template<typename Derived>
class NodeCRTP : public Node {
protected:
    bool matches_type(const std::type_info& ti) const override {
        return ti == typeid(Derived);
    }
};

template<typename T>
class DataNode : public NodeCRTP<DataNode<T>> {
public:
    T data;
    explicit DataNode(T val) : data(val) {}
};

template<typename Func>
class FunctionNode : public NodeCRTP<FunctionNode<Func>> {
private:
    Func func;
public:
    explicit FunctionNode(Func f) : func(std::move(f)) {}
    auto operator()(auto... args) {
        return func(args...);
    }
};

// 使用示例
Node* getNext();
int main() {
    try {
        auto func_node = getNext()->as<FunctionNode<std::plus<int>>>();
        auto result = (*func_node)(2, 4);
    } catch (const std::bad_cast&) {
        // 处理类型不匹配的情况
    }
}

这个方案把类型检查前置到编译期，运行期的类型判断由CRTP子类实现，static_cast是安全的，用户同样无需手动写转换代码。

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