【设计模式：component pattern】

#include <list>
#include <algorithm>
#include <iostream>
#include <string>

class Component{
protected:
	Component *_Par;
	::std::string _Name;
public:
	Component( const ::std::string& n ) : _Name( n ) {}
	virtual void Operation( void ) {
		::std::cout << GetCRValName()
					<< ::std::endl;
	}
	void SetParent( Component * o){ _Par = o; }
	Component *GetParent( void ) const { return _Par; }
	virtual ~Component( void ) {}
	const ::std::string& GetCRValName( void ) const { return _Name; }
};

class IChildEdit{
public:
	virtual void Add( Component *) = 0;
	virtual void Remove( Component *) = 0;
	virtual Component *GetChild( int ) = 0;
	virtual ~IChildEdit( void ) {}
};

class Composite : public Component, public IChildEdit{
protected:
	::std::list< Component *> _Children;
public:
	Composite( const ::std::string& n ) : Component( n ) {}
	virtual void Operation( void ) override{
		puts("Component::Operation");
		Component::Operation();
		for( auto& pCompnt : _Children ) pCompnt->Operation();
	}
	virtual void Add( Component *pChild) override{
		_Children.push_back(pChild);
		pChild->SetParent( this );
	}
	
	virtual void Remove( Component *pChild){
		_Children.erase( ::std::find(_Children.begin(),
									_Children.end(),
									pChild) );
	}
	virtual Component *GetChild( int offset ){
		decltype( _Children.begin() ) p = _Children.begin();
		::std::advance(p, offset );
		return *p;
	}
};

class Leaf : public Component{
public:
	Leaf( const ::std::string& n ) : Component( n ) {}
	virtual void Operation( void ) override{
		puts("Leaf::Operation");
		Component::Operation();
	}
};

int main( void ){
	Composite root("root layer0");
	Composite A("A layer1");
	Leaf B("B layer1");
	Composite C("C layer2");
	Leaf D("D layer2");
	Leaf E("E layer3");
	
	root.Add( &A );
	root.Add( &B );
	A.Add( &C );
	A.Add( &D );
	C.Add( &E );
	
	root.Operation();
	return 0;
}