C++属性

DynamicCxxProperty.h

template <typename value_t>
class IProperty_Forward {
public:
 virtual ~IProperty_Forward() {}
 virtual const value_t& Read() = 0;
 virtual void Set(const value_t& value) = 0;
};

template <typename value_t, typename owner_t, typename getter_t, typename setter_t>
class TProperty_Forwarder: public IProperty_Forward<value_t>
{
private:
 owner_t* Owner;
 getter_t Getter;
 setter_t Setter;
public:
 TProperty_Forwarder(owner_t* owner, getter_t& getter, setter_t& setter)
 :Owner(owner), Getter(getter), Setter(setter)
 { }

 const value_t& Read()
 { return (Owner->*Getter)(); }

 void Set(const value_t& value)
 { (Owner->*Setter)(value); }
};

template <typename value_t>
class Property {
private:
 IProperty_Forward<value_t>* forward;
public:
 Property():forward(NULL) { }

 template <typename owner_t, typename getter_t, typename setter_t>
 Property(owner_t* owner, getter_t getter, setter_t setter)
 { Init(owner, getter, setter); }

 ~Property()
 { delete forward; }

 template <typename owner_t, typename getter_t, typename setter_t>
 void Init(owner_t* owner, getter_t getter, setter_t setter)
 {
 forward = new TProperty_Forwarder<value_t, owner_t, getter_t, setter_t>(owner, getter, setter);
 }

 Property& operator=(const value_t& value)
 {
 forward->Set(value);
 return *this;
 }

 const value_t* operator->()
 { return &forward->Read(); }

 const value_t& operator()()
 { return forward->Read(); }

 const value_t& operator()(const value_t& value)
 {
 forward->Set(value);
 return forward->Read();
 }

 operator const value_t&()
 { return forward->Read(); }
}; 

MSCxxProperty.h

// __declspec( property (put=setFunction, get=getFunction) ) data-type property-name; 
#define PROPERTY(t,n)  __declspec( property \
	( put = property__set_##n, get = property__get_##n ) ) t n;\
	typedef t property__tmp_type_##n
#define READONLY_PROPERTY(t,n) __declspec( property (get = property__get_##n) ) t n;\
	typedef t property__tmp_type_##n
#define WRITEONLY_PROPERTY(t,n) __declspec( property (put = property__set_##n) ) t n;\
	typedef t property__tmp_type_##n
#define GET(n) property__tmp_type_##n property__get_##n() 
#define SET(n) void property__set_##n(const property__tmp_type_##n& value)   

/*
private: 
	int _x; 
public:  
 	PROPERTY(int, x);
  	GET(x) 
 	{ 
 		return _x; 
	}
 	SET(x)
 	{
 		_x = value;
 	}   
*/

StaticCxxProperty.h

#pragma once

template <typename value_t, typename owner_t, const value_t& (owner_t::*Getter)(), void (owner_t::*Setter)(const value_t&)>
class Property {
private:
	owner_t* forward;

	const value_t& Read()
	{
		return (forward->*Getter)();
	}
	void Set(const value_t& v)
	{
		return (forward->*Setter)(v);
	}

public:
	explicit Property(owner_t* owner)
	{
		forward = owner;
	}

	Property& operator=(const value_t& value)
	{
		Set(value);
		return *this;
	}

	const value_t* operator->()
	{
		return &Read();
	}

	const value_t& operator()()
	{
		return Read();
	}

	const value_t& operator()(const value_t& value)
	{
		Set(value);
		return Read();
	}

	operator const value_t&()
	{
		return Read();
	}
};

template <typename value_t, typename owner_t, const value_t& (owner_t::*Getter)()>
class ReadonlyProperty {
private:
	owner_t* forward;

	const value_t& Read()
	{
		return (forward->*Getter)();
	}
	//void Set(const value_t& v)
	//{
	//	return (forward->*Setter)(v);
	//}

public:

	explicit ReadonlyProperty(owner_t* owner)
	{
		forward = owner;
	}

	const value_t* operator->()
	{
		return &Read();
	}

	const value_t& operator()()
	{
		return Read();
	}

	operator const value_t&()
	{
		return Read();
	}
};

template <typename value_t, typename owner_t, void (owner_t::*Setter)(const value_t&)>
class WriteonlyProperty {
private:
	owner_t* forward;

	//const value_t& Read()
	//{
	//	return (forward->*Getter)();
	//}
	void Set(const value_t& v)
	{
		return (forward->*Setter)(v);
	}

public:
	WriteonlyProperty() :forward(0) { }

	explicit WriteonlyProperty(owner_t* owner)
	{
		forward = owner;
	}


	WriteonlyProperty& operator=(const value_t& value)
	{
		Set(value);
		return *this;
	}

	WriteonlyProperty& operator()(const value_t& value)
	{
		Set(value);
		return *this;
	}
};