Adding higher-level features to C++ (evil macro advice please!)

	class Interface
	{
	public:
		virtual void SetDefalts() = 0;
		virtual void Save( stream& s ) = 0;
		virtual void Load( stream& s ) = 0;
		virtual void WriteDiff( stream& s, const Interface& o ) = 0;
	};

	class Thing : public Interface
	{
		int m_one, m_two;
	public:
		virtual void SetDefalts()
		{
			m_one = 1;
			m_two = 2;
		}
		virtual void Save( stream& s )
		{
			s << m_one;
			s << m_two;
		}
		virtual void Load( stream& s )
		{
			s >> m_one;
			s >> m_two;
		}
		virtual void WriteDiff( stream& s, const Interface& o )
		{
			Thing* pO = dynamic_cast<Thing*>( &o );
			assert( pO );
			if( m_one != o.m_one ) {
				s.write_bit(1);
				s << m_one;
			} else
				s.write_bit(0);

			if( m_two != o.m_two ) {
				s.write_bit(1);
				s << m_two;
			} else
				s.write_bit(0);
		}
	}

	class Base
	{
	public:
		void SetDefalts()
		{
			for each m_Vars as it
				it->SetDefalts( this->*data );
		}
		void Save( stream& s ) {
			for each m_Vars as it
				it->Save( this->*data, s );
		}
		void Load( stream& s ) {
			for each m_Vars as it
				it->Load( this->*data, s );
		}
		void WriteDiff( stream& s, const cname& o ) {
			for each m_Vars as it
				it->WriteDiff( this->*data, o.*data, s );
		}
	protected:
		struct VarInfo
		{
			pointer_to_member data;
			func_ptr SetDefault;
			func_ptr Save;
			func_ptr Load;
			func_ptr Diff;
		}
		std::vector< VarInfo > m_Vars;
	};

	class Thing : public Base
	{
		int m_one, m_two;
		SetDefaultFunctor<int> m_sdOne, m_sdTwo;
	public:
		Thing() : m_sdOne(1), m_sdTwo(2)
		{
			VarInfo infoOne = { &Thing::m_one, m_sdOne, &SaveInt, &DiffInt };
			VarInfo infoTwo = { &Thing::m_two, m_sdTwo, &SaveInt, &DiffInt };
			m_Vars.push_back( infoOne );
			m_Vars.push_back( infoTwo );
		}
	}

#define MAKE_VAR( type, name, val )	\ 
	type name;			//
#define ASSIGN_VAR( type, name, val )	\ 
	name = val;			//
#define STORE_VAR( type, name, val )	\ 
	s << name;			//
#define LOAD_VAR( type, name, val )	\ 
	s >> name;			//
#define DIFF_VAR( type, name, val )	\ 
	if( name != o.name ) {		\ 
		s.write_bit(1);		\ 
		s << name;		\ 
	} else				\ 
		s.write_bit(0);		//

#define DoMagic( cname, list )				\ 
	private:					\ 
	list( MAKE_VAR )				\ 
	void SetDefalts() {				\ 
	list( ASSIGN_VAR )				\ 
	}						\ 
	public:						\ 
	void Save( stream& s ) {			\ 
	list( STORE_VAR )				\ 
	}						\ 
	void Load( stream& s ) {			\ 
	list( LOAD_VAR )				\ 
	}						\ 
	void WriteDiff( stream& s, const cname& o ) {	\ 
	list( DIFF_VAR )				\ 
	}						//

	class Thing
	{
		#define Variables( Var )		\ 
			Var( int, m_one, 1 )		\ 
			Var( int, m_two, 2 )		//

		DoMagic( Thing, Variables )

		#undef Variables
	};