c++派生出带有嵌套结构的纯抽象
c++ derive pure abstract w/ nested struct
我正在尝试建立一个类似于c#属性概念的语法糖。
我读过这篇文章：原生C++中类似C#的属性？。它很有用，但缺少我想要的设计。我也很尊重地不同意其中的一些断言，即属性概念是糟糕的oo形式，因为我看不出一组名为get_id（）和set_id（，还将公共实现与私有设计脱钩。
然而，我（受该链接的启发）编写的代码确实很粗糙，很难维护。我想知道是否有人对清理这件事有任何建议，或者更重要的是，知道更好的方法。
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将有效地成为数据的接口（所需的方法非常少，大量的数据应该是相对透明的）。它将在可执行文件将链接的静态库中定义。"derivedClass将有效地是一个外部实现，在动态加载的dll中实现。这样做的原因是；热交换"；的dll与另一个实现不同文件后端的dll进行比较。我们计划使用插件系统来加载xml、sqlite和mysql存储后端。
因此，基本上，我需要一种设计，允许someClass成为derivedClass继承的虚拟接口，该接口通过工厂方法加载，通过插件系统传递，最终由consumerClass使用。
所以基本上，我需要一个允许someClass成为虚拟接口
如果我理解正确的话，这个意图与你提出的解决方案相矛盾。虚拟继承只涉及虚拟成员函数。并没有办法动态继承嵌套结构，因为它是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的数据协定。然后定义数据合约：
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;
创建一个必须作为要添加属性的类的成员安装的属性助手类是个坏主意，因为您将承担该类所有实例的属性成员的成本。
一个提供类似于其他语言所提供的"属性"机制的解决方案可以在C++中使用，就像我稍后描述的那样。
唯一的限制是您使用访问该物业
instance.properties（）；//获取
和
instance.property（）=42；//设置
#include <iostream>
#include <string>
using namespace std;
// ------------------------------------------------------------------
#define PROPERTY_GET_SET(CLASS, NAME, TYPE) GetSetProperty<CLASS, TYPE> NAME() { return GetSetProperty<CLASS, TYPE>(this, &CLASS::get_##NAME, &CLASS::set_##NAME); }
#define PROPERTY_GET(CLASS, NAME, TYPE) GetProperty<CLASS, TYPE> NAME() { return GetProperty<CLASS, TYPE>(this, &CLASS::get_##NAME); }
#define PROPERTY_SET(CLASS, NAME, TYPE) SetProperty<CLASS, TYPE> NAME() { return SetProperty<CLASS, TYPE>(this, &CLASS::set_##NAME); }
template <typename CLASS, typename TYPE>
struct GetSetProperty {
typedef TYPE (CLASS::*Getter_t)() const;
typedef void (CLASS::*Setter_t)(TYPE);
GetSetProperty(CLASS* instance, Getter_t getter, Setter_t setter) : m_instance(instance), m_getter(getter), m_setter(setter) {}
operator TYPE() const { return (this->m_instance->*this->m_getter)(); }
GetSetProperty<CLASS, TYPE>& operator=(TYPE value) { (this->m_instance->*this->m_setter)(value); return *this; }
CLASS* const m_instance;
const Getter_t m_getter;
const Setter_t m_setter;
};
template <typename CLASS, typename TYPE>
struct GetProperty {
typedef TYPE (CLASS::*Getter_t)() const;
GetProperty(CLASS* instance, Getter_t getter) : m_instance(instance), m_getter(getter) {}
operator TYPE() const { return (this->m_instance->*this->m_getter)(); }
CLASS* const m_instance;
const Getter_t m_getter;
};
template <typename CLASS, typename TYPE>
struct SetProperty {
typedef void (CLASS::*Setter_t)(TYPE);
SetProperty(CLASS* instance, Setter_t setter) : m_instance(instance), m_setter(setter) {}
SetProperty<CLASS, TYPE>& operator=(TYPE value) { (this->m_instance->*this->m_setter)(value); return *this; }
CLASS* const m_instance;
const Setter_t m_setter;
};
template <typename CLASS, typename TYPE>
ostream& operator<<(ostream& ostr, const GetSetProperty<CLASS, TYPE>& p) { ostr << (p.m_instance->*p.m_getter)(); return ostr; }
template <typename CLASS, typename TYPE>
ostream& operator<<(ostream& ostr, const GetProperty<CLASS, TYPE>& p) { ostr << (p.m_instance->*p.m_getter)(); return ostr; }
// ------------------------------------------------------------------
class Dummy
{
public:
Dummy() : m_value1(42) {}
PROPERTY_GET_SET(Dummy, Value1, int);
PROPERTY_GET_SET(Dummy, Value2, const string&);
protected:
virtual int get_Value1() const { return this->m_value1; }
virtual void set_Value1(int value) { this->m_value1 = value; }
virtual const string& get_Value2() const { return this->m_value2; }
virtual void set_Value2(const string& value) { this->m_value2 = value; }
private:
int m_value1;
string m_value2;
};
int main(int argc, char* argv[]) {
Dummy d;
cout << d.Value1() << endl;
d.Value1() = 3;
cout << d.Value1() << endl;
cout << d.Value2() << endl;
d.Value2() = "test";
cout << d.Value2() << endl;
return 0;
}
// ------------------------------------------------------------------
相关文章：
- 如何循环打印顶点结构
- 通过方法访问结构
- 使用不带参数的函数访问结构元素
- 预处理器:插入结构名称中的前一个行号
- 为什么在没有显式默认构造函数的情况下，将另一个结构封装在联合中作为成员的结构不能编译
- 孤立代码块在结构中引发异常
- 有什么方法可以遍历结构吗
- 让编译器告诉什么确切的纯虚拟方法使结构抽象?
- 抽象工厂结构的差异
- 如何在 C++ 中创建抽象类的对象或数据结构?
- C++中的抽象语法树:类与结构
- 抽象数据类型(ADT）和数据结构之间有什么区别
- 抽象基类和层次结构-C++
- 将抽象C++结构返回到C#
- c++派生出带有嵌套结构的纯抽象
- 面向对象的C++抽象体系结构
- 结构，并引用抽象类类型
- 在抽象类层次结构中操作符=的复杂继承
- 为什么我在抽象类中使用结构时遇到问题
- 抽象类层次结构和访问冲突
