StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<blockquote> <p>So basically, I need a design that allows someClass to be a virtual interface</p> </blockquote> <p>If I understand you correctly, this intention contradicts the solution you have came up with. The virtual inheritance concerns only virtual member functions. And there is no way you could dynamically inherit nested structs because it is a subject of the lexical meta-programming which is not supported in C++.</p> <p>My suggestion is to think carefully if you can make your object immutable. Then some adaptation of the Builder/Factory design pattern will allow you to eliminate the usage of properties.</p> <p>You may also consider to write a code generator. In case if you pick up a good markup keywords, it may be easy.</p> <p><strong>UPDATE</strong> I've added some code to clarify my suggestion. </p> <p>First of all we prepare some auxiliary objects. They should be put in a header file accessible for both the Library and the Client. These objects will never be modified.</p> <p>GetSetProp <>----> IGetSetProp <----- PropFunctionAdapter</p> <pre><code>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(); } }; </code></pre> <p>Similarly you may define GetProperty and SetProperty.</p> <p>Suppose you have a data contract containing two fields Pressure:int and Description:string. Then you define the data contract:</p> <pre><code>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() {} }; </code></pre> <p>And its implementation in the library:</p> <pre><code>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; </code></pre>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload