c++派生带有嵌套结构的纯抽象

Question

我正在尝试设置一个类似于 c# 属性概念的语法糖。

我读过这篇文章:C#-like properties in native c++? .它很有帮助，但缺乏我想要的设计。我也恭敬地不同意那里提出的一些断言，即属性概念是糟糕的 oo 形式，因为我看不出一组名为 get_id() 和 set_id() 的方法与公开相同概念的运算符重载之间的区别，允许代码在使用类时更清晰，并且通常不鼓励对私有(private)字段的公共(public)访问，同时将公共(public)实现与私有(private)设计分离。

但是，我提出的代码(受该链接启发)非常笨拙，而且很难维护。我想知道是否有人有任何建议来清理它，或者更重要的是，知道更好的方法来做到这一点。

class someClass
{
public:
    struct someProperty_struct{
        virtual someProperty_struct& operator=(const int&){return *this;}
        virtual operator int(){return 0;}
    }someProperty;
};

class derivedClass : someClass
{
    int i;
public:
    struct intProperty: someClass::someProperty_struct
    {
    protected:
        friend class derivedClass;
        derivedClass *outer;
    public:
        virtual someProperty_struct& operator=(const int& value){
            outer->i = value;
            return *this;}
        virtual operator int(){return outer->i;}
    };
    derivedClass()
    {
        intProperty p = intProperty();
        p.outer = this;
        someProperty = p;
    }
};

class consumerClass
{
public:
    someClass* data;
    consumerClass()
    {
        data = (someClass*)(new derivedClass());
    }
    void doSomething()
    {
        data->someProperty = 7;
        int x = data->someProperty;
    }
};

编辑 1:我突然想到我没有透露任何关于我的意图。它将用于调度程序，我们将对类中的所有数据进行大量比较和分配。 'someClass' 将有效地成为数据的接口(interface)(需要的方法很少，应该相对透明的大量数据)。它将在可执行文件链接的静态库中定义。 “derivedClass”实际上是一个外部实现，在动态加载的 dll 中实现。这样做的原因是为了启用 dll 与另一个实现不同文件后端的 dll 的“热交换”。我们计划使用插件系统加载它们来实现 xml、sqlite 和 mysql 存储后端。

所以基本上，我需要一个设计，让 someClass 成为一个虚拟接口(interface)，由 derivedClass 继承，由工厂方法加载，通过插件系统传递，最后由 consumerClass 使用。

Answer 1

So basically, I need a design that allows someClass to be a virtual interface

如果我对您的理解正确，这种意图与您提出的解决方案相矛盾。虚继承只涉及虚成员函数。而且您无法动态继承嵌套结构，因为它是 C++ 不支持的词法元编程的主题。

我的建议是仔细考虑是否可以使对象不可变。然后，对 Builder/Factory 设计模式进行一些调整将使您能够消除属性的使用。

您也可以考虑编写一个代码生成器。如果您选择了一个好的标记关键字，这可能很容易。

更新我添加了一些代码来阐明我的建议。

首先我们准备一些辅助对象。它们应该放在图书馆和客户都可以访问的头文件中。这些对象永远不会被修改。

GetSetProp <>----> IGetSetProp <----- PropFunctionAdapter

template<class _Ty>
struct __declspec(novtable) IGetSetProp
{
    typedef std::tr1::shared_ptr<IGetSetProp<_Ty>> ptr_t;
    virtual void set_Prop(_Ty const& val);
    virtual _Ty get_Prop() const;
};

template<typename _Ty>
class PropFunctionAdapter : public IGetSetProp<_Ty>
{
    std::function<_Ty(void)> getter;
    std::function<void(_Ty const&)> setter;
public:
    PropFunctionAdapter(std::function<_Ty(void)> _getter, std::function<void(_Ty const&)> _setter)
        : getter(_getter)
        , setter(_setter)
    {
         // One may want to verify that getter and setter are not empty
    }

    virtual ~PropFunctionAdapter() throw() {}

    inline static std::tr1::shared_ptr<typename PropFunctionAdapter<_Ty>> Create(std::function<_Ty(void)> _getter, std::function<void(_Ty const&)> _setter)
    {
        return std::make_shared<typename PropFunctionAdapter<_Ty>>(_getter, _setter);
    }

public:
    void set_Prop(_Ty const& val)
    {
        setter(val);
    }

    _Ty get_Prop() const
    {
        return getter();
    }
};

template<class _Owner, class _Ty>
typename IGetSetProp<_Ty>::ptr_t CreateAdapter(_Owner& source, _Ty(_Owner::*getter)() const, void(_Owner::*setter)(_Ty const&))
{
    return PropFunctionAdapter<_Ty>::Create(
        std::tr1::bind(std::mem_fn(getter), &source),
        std::tr1::bind(std::mem_fn(setter), &source, std::tr1::placeholders::_1));
}

template<class _Ty>
class GetSetProp
{
    typename IGetSetProp<_Ty>::ptr_t prop;
public:
    GetSetProp(typename IGetSetProp<_Ty>::ptr_t _prop)
        : prop(_prop)
    {
    }

    GetSetProp<_Ty>& operator= (_Ty const& val)
    {
        prop->set_Prop(val);
        return *this;
    }

    operator _Ty() const
    {
        return prop->get_Prop();
    }
};

同样，您可以定义 GetProperty 和 SetProperty。

假设您有一个包含两个字段 Pressure:int 和 Description:string 的数据契约(Contract)。然后定义数据协定:

class BaseClass
{
public:
    GetSetProp<int> Pressure;
    GetSetProp<std::string> Description;
protected:
    BaseClass(IGetSetProp<int>::ptr_t fieldA, IGetSetProp<std::string>::ptr_t fieldB)
        : Pressure(fieldA)
        , Description(fieldB)
    {
    }

    virtual ~BaseClass() throw() {}
};

及其在库中的实现:

class DerivedClass : public BaseClass
{
public:
    // Here you initialize fields assigning them correspondent setters and getters
    // You may define an ATL-like mapping in order to hide implementation details
    DerivedClass()
        : BaseClass(
            CreateAdapter(*this, &DerivedClass::get_Pressure, &DerivedClass::set_Pressure)
            , CreateAdapter(*this, &DerivedClass::get_Description, &DerivedClass::set_Description))
    {
    }

    virtual ~DerivedClass() throw() {}

private:
    void set_Pressure(int const& value)
    {
        val = value;
    }

    int get_Pressure() const
    {
        return val;
    }

    void set_Description(std::string const& description)
    {
        this->description = description;
    }

    std::string get_Description() const
    {
        return description;
    }

private:
    int val;
    std::string description;
};

// The client-side code
DerivedClass d;
BaseClass& b = d; 
b.Description = "Hello";
std::string descr = b.Description;
b.Pressure = 2;
int value = b.Pressure;