c++ - C++ 中 getter 和 setter 方法的包装器

Question

我有几个类有一对代表“setter”和“getter”方法的方法，例如:

class ClassA
{
    void SetSomeProperty(const int& value) { ... }
    int GetSomeProperty() { ... }

    void SetAnotherProperty(const Vec3& value) { ... }
    Vec3 GetAnotherProperty() { ... }
};

class ClassB
{
    void SetColor(const Vec4& value) { ... }
    Vec4 GetColor() { ... }
}

我想创建一个名为 PropertyAccess 的类，它可以包装任何类的每对 setter 和 getter。这将允许我将此 PropertyAccess 传递给其他对象，该对象将能够调用这些 setter 和 getter 而无需任何关于 ClassA 或 ClassB 的知识。

这是我的实现:

class PropertyAccess
{
public:
    template <typename TClass, typename TType> using SetterPointer = void (TClass::*)(const TType&);
    template <typename TClass, typename TType> using GetterPointer = TType(TClass::*)();

    template <typename TClass, typename TType>
    PropertyAccess(
        TClass* object,
        SetterPointer<TClass, TType> setter,
        GetterPointer<TClass, TType> getter)
    {
        using std::placeholders::_1;
        m_setter = new Setter<TType>(std::bind(setter, object, _1));
        m_getter = new Getter<TType>(std::bind(getter, object));
    }

    ~PropertyAccess()
    {
        delete m_setter;
        delete m_getter;
    }

    template <typename T>
    void Set(const T& value)
    {
        ((Setter<T>*)m_setter)->m_setter(value);
    }

    template <typename T>
    T Get()
    {
        return ((Getter<T>*)m_getter)->m_getter();
    }

private:
    struct Base
    {
        virtual ~Base() {}
    };

    template <typename TType>
    struct Setter : public Base
    {
        Setter(std::function < void(const TType&) > setter) { m_setter = setter; }

        std::function < void(const TType&) > m_setter;
    };

    template <typename TType>
    struct Getter : public Base
    {
        Getter(std::function < TType() > getter) { m_getter = getter; }

        std::function < TType() > m_getter;
    };

    Base* m_setter;
    Base* m_getter;
};

我是这样使用的:

ClassA a;
PropertyAccess p(&a, &ClassA::SetSomeProperty, &ClassA::GetSomeProperty);
p.Set<int>(10);
int v = p.Get<int>();

一切正常，但这是极其缓慢的方法。通过 PropertAccess 调用 setter 比直接调用它们慢大约 18 倍。速度在这里很重要，因为我需要在动画库中使用该机制(Animator 将在不知道源对象的情况下设置属性)。

所以我的问题是:如何加速这个机制？是否有任何“行业标准”方法？也许我应该使用经典方法指针而不是 std::function？

Answer 1

您可以采用 Anton Slavin 的解决方案并引入一个接口(interface)来删除对象类型。这将使访问器的生命周期管理更加复杂(你必须使用引用/指针/智能指针并管理生命周期，因为你将无法复制访问器)并且会在运行时花费，因为虚拟方法调用不会内联所以我将衡量它是否比您的原始解决方案更快。

template<typename TType>
struct PropertyAccess
{
    virtual void Set(const TType& value) = 0;
    virtual TType Get() = 0;
};

template <typename TClass, typename TType>
class PropertyAccessT : public PropertyAccess<TType>
{
public:
    using SetterPointer = void (TClass::*)(const TType&);
    using GetterPointer = TType(TClass::*)();

    PropertyAccessT(TClass* object, SetterPointer setter, GetterPointer getter)
        : m_object(object), m_setter(setter), m_getter(getter)
    {
    }

    void Set(const TType& value) {
        (m_object->*m_setter)(value);
    }

    TType Get() {
        return (m_object->*m_getter)();
    }

private:

    TClass* m_object;
    SetterPointer m_setter;
    GetterPointer m_getter;
};