C++虚模板函数替代方案咨询：属性处理器实现疑问

首先是你提供的原始代码（补全属性类定义以保证可编译性）：

struct FooProperties {};
struct BarProperties {};
struct BazProperties {};

class Foo
{
private:
    FooProperties m_prop;
};

class Bar
{
private:
    BarProperties m_prop;
};

class Baz
{
private:
    BazProperties m_prop;
};

class PropertiesHandler
{
};

class FooPropertiesHandler : public PropertiesHandler
{
};

class BarPropertiesHandler : public PropertiesHandler
{
};

class BazPropertiesHandler : 
public PropertiesHandler
{
};

你的需求是：让PropertiesHandler子类实现对应Foo/Bar/Baz的专属Setter，同时通过虚函数ApplyProperties()将属性应用到目标对象，但C++不支持虚模板函数，以下是可行的替代方案，同时解答你的疑问：

核心疑问解答：仅用模板Setter + 虚ApplyProperties()完全可行 #

这种思路可以实现，核心是用模板函数处理对象的类型绑定，用虚函数触发类型特定的属性应用逻辑，下面是具体实现和优化方案：

方案1：模板Setter + 类型擦除存储（最直接匹配需求） #

基类用模板SetObject()存储目标对象的指针（通过void*做类型擦除），子类实现虚ApplyProperties()时，将指针转换为对应类型并应用属性：

#include <type_traits>

// 补全对象类的属性设置接口
class Foo
{
private:
    FooProperties m_prop;
public:
    void setProperties(const FooProperties& prop) { m_prop = prop; }
};

class Bar
{
private:
    BarProperties m_prop;
public:
    void setProperties(const BarProperties& prop) { m_prop = prop; }
};

class Baz
{
private:
    BazProperties m_prop;
public:
    void setProperties(const BazProperties& prop) { m_prop = prop; }
};

class PropertiesHandler
{
protected:
    void* m_target = nullptr;
public:
    // 模板Setter，绑定任意类型的目标对象
    template<typename T>
    void SetObject(T& obj) {
        m_target = &obj;
    }

    // 纯虚函数，子类实现具体属性应用逻辑
    virtual void ApplyProperties() = 0;
    virtual ~PropertiesHandler() = default;
};

class FooPropertiesHandler : public PropertiesHandler
{
private:
    FooProperties m_handlerProp; // 处理器持有的属性数据
public:
    // 设置处理器要应用的属性
    void setHandlerProperties(const FooProperties& prop) {
        m_handlerProp = prop;
    }

    void ApplyProperties() override {
        // 安全转换，可添加静态断言强化类型安全
        if (auto* foo = static_cast<Foo*>(m_target)) {
            foo->setProperties(m_handlerProp);
        }
    }
};

class BarPropertiesHandler : public PropertiesHandler
{
private:
    BarProperties m_handlerProp;
public:
    void setHandlerProperties(const BarProperties& prop) {
        m_handlerProp = prop;
    }

    void ApplyProperties() override {
        if (auto* bar = static_cast<Bar*>(m_target)) {
            bar->setProperties(m_handlerProp);
        }
    }
};

class BazPropertiesHandler : public PropertiesHandler
{
private:
    BazProperties m_handlerProp;
public:
    void setHandlerProperties(const BazProperties& prop) {
        m_handlerProp = prop;
    }

    void ApplyProperties() override {
        if (auto* baz = static_cast<Baz*>(m_target)) {
            baz->setProperties(m_handlerProp);
        }
    }
};

类型安全优化：可以在子类的ApplyProperties()中添加静态断言，确保SetObject()传入的类型正确，比如在FooPropertiesHandler中：

static_assert(std::is_same_v<std::decay_t<decltype(*m_target)>, Foo>, "Target object type mismatch for FooPropertiesHandler");

方案2：CRTP（奇异递归模板模式）强化类型安全 #

如果不想用void*做类型擦除，可以用CRTP封装类型绑定逻辑，避免重复的类型转换代码，同时保证类型安全：

#include <type_traits>

// 对象类定义同方案1
class Foo { /* ... */ };
class Bar { /* ... */ };
class Baz { /* ... */ };

class PropertiesHandler
{
public:
    virtual void ApplyProperties() = 0;
    virtual ~PropertiesHandler() = default;
};

// CRTP基类，绑定目标对象类型
template<typename Derived, typename TargetObj>
class PropertiesHandlerCRTP : public PropertiesHandler
{
protected:
    TargetObj* m_target = nullptr;
public:
    // 类型安全的Setter，只能绑定TargetObj类型的对象
    void SetObject(TargetObj& obj) {
        m_target = &obj;
    }

    // 子类需要实现的具体属性应用逻辑
    virtual void ApplyPropertiesImpl() = 0;

    // 最终的虚函数，调用子类的实现
    void ApplyProperties() final {
        if (m_target) {
            static_cast<Derived*>(this)->ApplyPropertiesImpl();
        }
    }
};

class FooPropertiesHandler : public PropertiesHandlerCRTP<FooPropertiesHandler, Foo>
{
private:
    FooProperties m_handlerProp;
public:
    void setHandlerProperties(const FooProperties& prop) {
        m_handlerProp = prop;
    }

    void ApplyPropertiesImpl() override {
        m_target->setProperties(m_handlerProp);
    }
};

// Bar和Baz的处理器同理
class BarPropertiesHandler : public PropertiesHandlerCRTP<BarPropertiesHandler, Bar>
{
private:
    BarProperties m_handlerProp;
public:
    void setHandlerProperties(const BarProperties& prop) {
        m_handlerProp = prop;
    }

    void ApplyPropertiesImpl() override {
        m_target->setProperties(m_handlerProp);
    }
};

这种方案完全避免了void*的类型转换，类型安全更高，子类代码更简洁。

方案3：访问者模式（适合多对象共享属性场景） #

如果Foo/Bar/Baz存在共享属性，或者需要统一处理不同对象的属性应用，可以用访问者模式，让处理器作为访问者匹配不同对象类型：

#include <type_traits>

// 前向声明访问者基类
class PropertiesVisitor;

// 对象类添加accept方法
class Foo
{
private:
    FooProperties m_prop;
public:
    void accept(PropertiesVisitor& visitor);
    void setProperties(const FooProperties& prop) { m_prop = prop; }
};

class Bar
{
private:
    BarProperties m_prop;
public:
    void accept(PropertiesVisitor& visitor);
    void setProperties(const BarProperties& prop) { m_prop = prop; }
};

class Baz
{
private:
    BazProperties m_prop;
public:
    void accept(PropertiesVisitor& visitor);
    void setProperties(const BazProperties& prop) { m_prop = prop; }
};

// 访问者基类，定义访问不同对象的接口
class PropertiesVisitor
{
public:
    virtual void visit(Foo& foo) = 0;
    virtual void visit(Bar& bar) = 0;
    virtual void visit(Baz& baz) = 0;
    virtual ~PropertiesVisitor() = default;
};

// 实现accept方法
void Foo::accept(PropertiesVisitor& visitor) { visitor.visit(*this); }
void Bar::accept(PropertiesVisitor& visitor) { visitor.visit(*this); }
void Baz::accept(PropertiesVisitor& visitor) { visitor.visit(*this); }

// 具体处理器
class FooPropertiesHandler : public PropertiesVisitor
{
private:
    FooProperties m_handlerProp;
public:
    void setHandlerProperties(const FooProperties& prop) {
        m_handlerProp = prop;
    }

    void visit(Foo& foo) override {
        foo.setProperties(m_handlerProp);
    }

    // 不需要处理的对象可以留空或抛出异常
    void visit(Bar&) override {}
    void visit(Baz&) override {}
};

这种模式不需要存储对象指针，调用时直接让对象accept处理器即可，适合对象类型固定的场景。

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