Re: property in C++
On 27/07/10 16:51, theambient wrote:
hi,
I want make property
(http://en.wikipedia.org/wiki/Property_(programming)) in C++.
In the wiki article explained how to make property in C++ using
template mechanism
this looks like
========================================================================
========================================================================
template<typename T> class property {
T value;
public:
T& operator = (const T&i) {
::std::cout<< i<< ::std::endl;
return value = i;
}
// This template class member function template serves the
purpose to make
// typing more strict. Assignment to this is only possible with
exact identical
// types.
template<typename T2> T2& operator = (const T2&i) {
::std::cout<< "T2: "<< i<< ::std::endl;
T2&guard = value;
throw guard; // Never reached.
}
operator T const& () const {
return value;
}
};
========================================================================
========================================================================
everything is clear (except never reached throw, aprreciate if anybody
explain it to me)
i wish to extend functionality of this property to get addaptable
setting and getting (mechanism) passed to property as template
arguments.
I see it as pointers to member functions.
so i've implemented something:
========================================================================
========================================================================
#include<iostream>
template<typename T, typename C>
class property {
typedef void(C::*PMANIP)( T& i ) ;
mutable T value;
PMANIP _set;
PMANIP _get;
C& _c;
public:
property( C& c, PMANIP set, PMANIP get ): _set(set), _get(get),
_c(c){}
T& operator = (const T&i) {
value = i;
(_c.*_set)(value);
return value;
}
operator T const& () const {
(_c.*_get)(value);
return value;
}
};
struct Foo {
void set( int&i ){ std::cout<< "setting "<< i<< std::endl; }
void get( int&i ){ std::cout<< "getting "<< i<< std::endl; }
property<int, Foo> val;
Foo():val( *this,&Foo::set,&Foo::get ){}
};
int main(int argc, char** argv )
{
Foo foo;
std::cout<< "foo.val = "<< foo.val<< std::endl;
foo.val = 10;
std::cout<< "foo.val = "<< foo.val<< std::endl;
return 0;
}
========================================================================
========================================================================
really nasty cause we need initialize property in !!!EACH!!!
constructor with class instance reference (*this) and pointers to
setter and getter functions.
As far as i understand pointers to setter and getter can be passed as
template parameters.
How to do it?
You can do without having to store any extra data in you property
objects. Because object's members are stored at a constant offset from
the beginning of an object you can calculate object's address from the
property address (this) using offsetof() macro from <stddef.h>. (beware,
it does not work with virtual base classes).
Here is how to make a class to support properties:
struct X : with_properties<X>
{
// property tags
struct A {};
struct B {};
// the properties
property<Tag<A>, int> a_;
property<Tag<B>, int> b_;
// helpers, one per property
static size_t getOffset(Tag<A>) { return offsetof(X, a_); }
static size_t getOffset(Tag<B>) { return offsetof(X, b_); }
void set(property<Tag<A>, int>& a, int v)
{
assert(&a == &a_);
a.value = v;
}
void set(property<Tag<B>, int>& b, int v)
{
assert(&b == &b_);
b.value = v;
}
template<class TAG, class T>
T get(property<Tag<TAG>, T> const& p)
{
return p.value;
}
};
In the above, the class needs to do the following to have properties:
1) Derive from with_properties<>.
2) Declare a tag type for every property (A and B here).
3) Declare property members, using property<> template, as above.
4) Implement static helper functions that return the property member
offset. Property tag is passed in that function, so that there can be
one overload of it per property member.
5) Implement get and set functions. These are functions overloaded again
on the tag type, can be templates.
Usage:
int main(int ac, char** av)
{
X x;
x.a_ = 1;
x.b_ = x.a_ + 1;
}
Complete code:
#include <iostream>
#include <cassert>
#include <stdint.h>
#include <stddef.h>
template<class Tag, class T>
struct property
{
T value;
property(T v = T()) : value(v) {}
property& operator=(T v) { set(*this, v); return *this; }
operator T() const { return get(*this); }
};
template<class Derived>
struct with_properties
{
template<class T> struct Tag {};
template<class TAG, class T>
friend void set(property<Tag<TAG>, T>& p, T v)
{
static_cast<Derived&>(*reinterpret_cast<with_properties*>(reinterpret_cast<uintptr_t>(&p)
- Derived::getOffset(Tag<TAG>()))).set(p, v);
}
template<class TAG, class T>
friend T get(property<Tag<TAG>, T> const& p)
{
return
static_cast<Derived&>(*reinterpret_cast<with_properties*>(reinterpret_cast<uintptr_t>(&p)
- Derived::getOffset(Tag<TAG>()))).get(p);
}
};
struct X : with_properties<X>
{
// property tags
struct A {};
struct B {};
// the properties
property<Tag<A>, int> a_;
property<Tag<B>, int> b_;
// helpers, one per property
static size_t getOffset(Tag<A>) { return offsetof(X, a_); }
static size_t getOffset(Tag<B>) { return offsetof(X, b_); }
void set(property<Tag<A>, int>& a, int v)
{
assert(&a == &a_);
a.value = v;
}
void set(property<Tag<B>, int>& b, int v)
{
assert(&b == &b_);
b.value = v;
}
template<class TAG, class T>
T get(property<Tag<TAG>, T> const& p)
{
return p.value;
}
};
int main(int ac, char** av)
{
X x;
x.a_ = 1;
x.b_ = x.a_ + 1;
}
--
Max