boost – 算譜とドリア

[boost]サイト上のシリアライズデータをダウンロードせずにデシリアライズする[C++Builder]

boost::serializatioでシリアライズしたデータがweb上(例えば自分のサイト)にあり、PC上のプログラムから利用したい場合、一時的にダウンロードしてデシリアライズすれば簡単なのだが、後で一時ファイルを削除する手間が生じる。

以下、ダウンロードしないまま利用する方法をメモ。

手順は以下の３ステップ。
(1)UrlからデータをTStreamに読み込む
(2)TStreamからバイト列(char配列)に書き込む
(3)バイト列からデシリアライズ(boost::iostreamsを使う)

#include <System.Net.HttpClient.hpp> // THTTPClient:
#include <memory>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>
// シリアライズ対象のクラス
#include "test_serialize_class.h"

int _tmain(int argc, _TCHAR* argv[])
{
    // 指定urlからファイルをTStreamに読み込む
    // ------------------------------------------------
    // サイト上にあるシリアライズデータのurl
    String Url( L"https://www.xxxxxxxx.com/xxxxxxxx/xxxxxxx.dat" );

    std::unique_ptr<THTTPClient> HttpClient( THTTPClient::Create() );
    auto Response = HttpClient->Get( Url ); // _di_IHTTPResponse型

        // Response->StatusCodeで"404"等のStatusCodeが取れる(ここでは省略)

    // TStreamからchar配列に書き込み
    // ------------------------------------------------
    const auto size = Response->ContentStream->Size; // Response->ContentStreamでTStream*が取れる
    char* buffer = new char[size];
    Response->ContentStream->Read( buffer, size );

    // char配列からデシリアライズ
    // ------------------------------------------------
    boost::iostreams::basic_array_source<char> sr( buffer, size );
    boost::iostreams::stream<boost::iostreams::basic_array_source<char>> source( sr );
    boost::archive::binary_iarchive ia( source );
    delete [] buffer;   // 後始末

    // デシリアライズ対象のクラス
    test_serialize test_class;
    try{
        ia >> test_class; // デシリアライズ
    }catch(...){
        return 0; // 何かエラー処理
    }
    return 0;
}

#include <System.Net.HttpClient.hpp> // THTTPClient:

#include <memory>

#include <boost/archive/binary_iarchive.hpp>

#include <boost/iostreams/device/array.hpp>

#include <boost/iostreams/stream.hpp>

// シリアライズ対象のクラス

#include "test_serialize_class.h"

int _tmain(int argc, _TCHAR* argv[])

{

// 指定urlからファイルをTStreamに読み込む

// ------------------------------------------------

// サイト上にあるシリアライズデータのurl

String Url( L"https://www.xxxxxxxx.com/xxxxxxxx/xxxxxxx.dat" );

std::unique_ptr<THTTPClient> HttpClient( THTTPClient::Create() );

auto Response = HttpClient->Get( Url ); // _di_IHTTPResponse型

// Response->StatusCodeで"404"等のStatusCodeが取れる(ここでは省略)

// TStreamからchar配列に書き込み

// ------------------------------------------------

const auto size = Response->ContentStream->Size; // Response->ContentStreamでTStream*が取れる

char* buffer = new char[size];

Response->ContentStream->Read( buffer, size );

// char配列からデシリアライズ

// ------------------------------------------------

boost::iostreams::basic_array_source<char> sr( buffer, size );

boost::iostreams::stream<boost::iostreams::basic_array_source<char>> source( sr );

boost::archive::binary_iarchive ia( source );

delete [] buffer; // 後始末

// デシリアライズ対象のクラス

test_serialize test_class;

try{

ia >> test_class; // デシリアライズ

}catch(...){

return 0; // 何かエラー処理

}

return 0;

}

C++Builder10.2.3 (Boost1.55.0) / Windows10(22H2)で確認。

続・Compositeパターンをshared_ptrで実装する…Clone/Assignの追加

Compositeパターンをshared_ptrで実装するの続き。

DeepCopyを作る”Clone”メソッドや、他のComponentから内容をコピーする”Assign”メソッドもあると便利。

Compositeもメンバ変数を保持することも想定して実装してみる。
もっとスマートなやり方もありそうだが、とりあえず、Compositeとその子クラスに非公開のデフォルトコンストラクタを実装する方式で。
(前回同様、c++11の機能を使っているが、c++11以前でもboost利用で同様の実装が可能。また行数省略のためすべてheaderに実装している。)

1.Componentクラス
Clone/Assign用の純粋仮想関数を追加する。

class Component
{

・・・・・・(省略)・・・・・・・

//------------------------------------
// Clone / Assign:
//____________________________________
public:
	virtual std::shared_ptr<Component> Clone()const = 0;
	virtual void Assign( const std::shared_ptr<const Component>& src )	= 0;
};

class Component

{

・・・・・・(省略)・・・・・・・

//------------------------------------

// Clone / Assign:

//____________________________________

public:

virtual std::shared_ptr<Component> Clone()const = 0;

virtual void Assign( const std::shared_ptr<const Component>& src ) = 0;

};

2.Compositeクラス
Clone/Assignメソッドを実装する。
Compositeの派生クラス用の純粋仮想関数doClone/doAssignも追加。
デフォルトConstructorはprotectedとする。
メンバ変数”name_”も追加、

#include <vector>
#include <algorithm>
#include <string>
//---------------------------------------------------------------------------
#include "Component.h"
//---------------------------------------------------------------------------
class Composite : public Component,public std::enable_shared_from_this<Composite>
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	std::vector<std::shared_ptr<Component>>
					childs_;
	std::string     name_;

//--------------------------------
//  Constructor:
//________________________________
public:
	explicit Composite( const std::string& name )
		: Component(),
		  childs_(),
		  name_(name)
		{}
protected:
	// Clone/Assign用のコンストラクタ。公開の必要はなし。子クラスのみからアクセスできればOK
	Composite()
		: Component(),
		  childs_(),
		  name_()
		{}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void Add( const std::shared_ptr<Component>& compo )
	{
		if( std::find( childs_.begin(), childs_.end(), compo ) == childs_.end() )
		{
			childs_.push_back( compo );
			compo->setParent( shared_from_this() );
		}
	}
	virtual void Remove( const std::shared_ptr<Component>& compo )
	{
		childs_.erase( remove( childs_.begin(), childs_.end(), compo ),
					   childs_.end() );
	}
	//
	virtual void Execute( int depth )
	{
		for( int i = 0; i < depth; ++i )
			std::cout << "　";
		std::cout << "name:" << name_ << "/";
		doExecute();
		for( size_t i = 0; i < childs_.size(); ++i )
		{
			childs_[i]->Execute( depth + 1 );
		}
	}
//------------------------------------
// Clone / Assign:
//____________________________________
protected
	virtual std::shared_ptr<Component> doClone()const	= 0;
	virtual bool doAssign( const Component* const src )	= 0;
public:
	virtual std::shared_ptr<Component> Clone()const
	{
		std::shared_ptr<Component> clone = doClone();
		clone->Assign( shared_from_this() );
		return clone;
	}
	virtual void Assign( const std::shared_ptr<const Component>& src )
	{
		if( doAssign( src.get() ) )
		{
			std::shared_ptr<const Composite> obj = std::dynamic_pointer_cast<const Composite>( src );
			// 子クラスの処理
			childs_.clear();
			for( size_t i = 0; i < obj->childs_.size(); ++i )
			{
				Add( obj->childs_[i]->Clone() );
			}
			// Compositeクラスのメンバの処理
			name_ = obj->name_;
		}
	}
};

#include <vector>

#include <algorithm>

#include <string>

//---------------------------------------------------------------------------

#include "Component.h"

//---------------------------------------------------------------------------

class Composite : public Component,public std::enable_shared_from_this<Composite>

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

std::vector<std::shared_ptr<Component>>

childs_;

std::string name_;

//--------------------------------

// Constructor:

//________________________________

public:

explicit Composite( const std::string& name )

: Component(),

childs_(),

name_(name)

{}

protected:

// Clone/Assign用のコンストラクタ。公開の必要はなし。子クラスのみからアクセスできればOK

Composite()

: Component(),

childs_(),

name_()

{}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void Add( const std::shared_ptr<Component>& compo )

{

if( std::find( childs_.begin(), childs_.end(), compo ) == childs_.end() )

{

childs_.push_back( compo );

compo->setParent( shared_from_this() );

}

virtual void Remove( const std::shared_ptr<Component>& compo )

{

childs_.erase( remove( childs_.begin(), childs_.end(), compo ),

childs_.end() );

}

virtual void Execute( int depth )

{

for( int i = 0; i < depth; ++i )

std::cout << "　";

std::cout << "name:" << name_ << "/";

doExecute();

for( size_t i = 0; i < childs_.size(); ++i )

{

childs_[i]->Execute( depth + 1 );

}

//------------------------------------

// Clone / Assign:

//____________________________________

protected

virtual std::shared_ptr<Component> doClone()const = 0;

virtual bool doAssign( const Component* const src ) = 0;

public:

virtual std::shared_ptr<Component> Clone()const

{

std::shared_ptr<Component> clone = doClone();

clone->Assign( shared_from_this() );

return clone;

}

virtual void Assign( const std::shared_ptr<const Component>& src )

{

if( doAssign( src.get() ) )

{

std::shared_ptr<const Composite> obj = std::dynamic_pointer_cast<const Composite>( src );

// 子クラスの処理

childs_.clear();

for( size_t i = 0; i < obj->childs_.size(); ++i )

{

Add( obj->childs_[i]->Clone() );

}

// Compositeクラスのメンバの処理

name_ = obj->name_;

}

};

3.ConcreteCompositeクラス
doClone/doAssignメソッドを実装する。非公開のコンストラクタも追加。
doCloneは非公開のデフォルトコンストラクタで作成したshared_ptrを返すだけ。

#include "Composite.h"
//---------------------------------------------------------------------------
class ConcreteCompositeA : public Composite
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	int val_;

//--------------------------------
//  Constructor:
//________________________________
public:
	ConcreteCompositeA( const std::string& name, int val )
		: Composite(name),
		  val_(val)
		{}
private:
	// doClone用のコンストラクタ。公開の必要なし
	ConcreteCompositeA()
		: Composite(),
		  val_()
		{}

//--------------------------------
//  Destructor:
//________________________________
public:
	~ConcreteCompositeA(){}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void doExecute()
	{
		std::cout << "A: val == " << val_ << std::endl;
	}
//------------------------------------
// Clone / Assign:
//____________________________________
protected:
	virtual std::shared_ptr<Component> doClone()const
	{
		return std::shared_ptr<Component>( new ConcreteCompositeA() );
	}
	virtual bool doAssign( const Component* const src )
	{
		const ConcreteCompositeA* from = dynamic_cast<const ConcreteCompositeA*>( src );
		if( from == nullptr )	return false;
		// このクラスの値を代入
		val_ = from->val_;
		return true;
	}
};

#include "Composite.h"

//---------------------------------------------------------------------------

class ConcreteCompositeA : public Composite

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

int val_;

//--------------------------------

// Constructor:

//________________________________

public:

ConcreteCompositeA( const std::string& name, int val )

: Composite(name),

val_(val)

{}

private:

// doClone用のコンストラクタ。公開の必要なし

ConcreteCompositeA()

: Composite(),

val_()

{}

//--------------------------------

// Destructor:

//________________________________

public:

~ConcreteCompositeA(){}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void doExecute()

{

std::cout << "A: val == " << val_ << std::endl;

}

//------------------------------------

// Clone / Assign:

//____________________________________

protected:

virtual std::shared_ptr<Component> doClone()const

{

return std::shared_ptr<Component>( new ConcreteCompositeA() );

}

virtual bool doAssign( const Component* const src )

{

const ConcreteCompositeA* from = dynamic_cast<const ConcreteCompositeA*>( src );

if( from == nullptr ) return false;

// このクラスの値を代入

val_ = from->val_;

return true;

}

};

#include "Composite.h"
//---------------------------------------------------------------------------
class ConcreteCompositeB : public Composite
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	std::string	str_;
public:
// ---- set ----
// ---- get ----

//--------------------------------
//  Constructor:
//________________________________
public:
	ConcreteCompositeB( const std::string& name, const std::string& str )
		: Composite(name),
		  str_(str)
		{}
private:
	// doClone用のコンストラクタ。公開の必要なし
	ConcreteCompositeB()
		: Composite(),
		  str_()
		{}

//--------------------------------
//  Destructor:
//________________________________
public:
	~ConcreteCompositeB(){}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void doExecute()
	{
		std::cout << "B: str == " << str_ << std::endl;
	}
//------------------------------------
// Clone / Assign:
//____________________________________
protected:
	virtual std::shared_ptr<Component> doClone()const
	{
		return std::shared_ptr<Component>( new ConcreteCompositeB() );
	}
	virtual bool doAssign( const Component* const src )
	{
		const ConcreteCompositeB* from = dynamic_cast<const ConcreteCompositeB*>( src );
		if( from == nullptr )	return false;
		// このクラスの値を代入
		str_ = from->str_;
		return true;
	}
};

#include "Composite.h"

//---------------------------------------------------------------------------

class ConcreteCompositeB : public Composite

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

std::string str_;

public:

// ---- set ----

// ---- get ----

//--------------------------------

// Constructor:

//________________________________

public:

ConcreteCompositeB( const std::string& name, const std::string& str )

: Composite(name),

str_(str)

{}

private:

// doClone用のコンストラクタ。公開の必要なし

ConcreteCompositeB()

: Composite(),

str_()

{}

//--------------------------------

// Destructor:

//________________________________

public:

~ConcreteCompositeB(){}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void doExecute()

{

std::cout << "B: str == " << str_ << std::endl;

}

//------------------------------------

// Clone / Assign:

//____________________________________

protected:

virtual std::shared_ptr<Component> doClone()const

{

return std::shared_ptr<Component>( new ConcreteCompositeB() );

}

virtual bool doAssign( const Component* const src )

{

const ConcreteCompositeB* from = dynamic_cast<const ConcreteCompositeB*>( src );

if( from == nullptr ) return false;

// このクラスの値を代入

str_ = from->str_;

return true;

}

};

(不正なAssignの対応は何もしていないが、本来は例外を投げるなどのエラー処理が必要かも)

4.テストコード
適当に親子関係を作成した後、CloneとAssignを実行する。

#include <stdio.h>
#include <conio.h>

#include "ConcreteCompositeA.h"
#include "ConcreteCompositeB.h"

 int _tmain(int argc, _TCHAR* argv[])
{
	std::shared_ptr<Component> c1 = std::make_shared<ConcreteCompositeA>( "c1", 3 );
	std::shared_ptr<Component> c2 = std::make_shared<ConcreteCompositeB>( "c2", "child" );
	std::shared_ptr<Component> c3 = std::make_shared<ConcreteCompositeB>( "c3", "child of child" );
	std::shared_ptr<Component> c4 = std::make_shared<ConcreteCompositeA>( "c4", 107 );
	std::shared_ptr<Component> c5 = std::make_shared<ConcreteCompositeB>( "c5", "other child" );

	c3->Add( c4 );
	c2->Add( c3 );
	c1->Add( c2 );
	c1->Add( c5 );

	c1->Execute( 0 );

	// Clone:
	std::cout << "--Clone--" << std::endl;

	std::shared_ptr<Component> cloned_compo = c1->Clone();
	cloned_compo->Execute( 0 );

	// Assign:
	std::cout << "--Before Assign--" << std::endl;
	std::shared_ptr<Component> assigned_compo = std::make_shared<ConcreteCompositeA>( "assigned_compo", 0 );
	assigned_compo->Execute( 0 );
	std::cout << "--After Assign--" << std::endl;
	assigned_compo->Assign( c1 );
	assigned_compo->Execute( 0 );

	getch();
	return 0;
}

#include <stdio.h>

#include <conio.h>

#include "ConcreteCompositeA.h"

#include "ConcreteCompositeB.h"

int _tmain(int argc, _TCHAR* argv[])

{

std::shared_ptr<Component> c1 = std::make_shared<ConcreteCompositeA>( "c1", 3 );

std::shared_ptr<Component> c2 = std::make_shared<ConcreteCompositeB>( "c2", "child" );

std::shared_ptr<Component> c3 = std::make_shared<ConcreteCompositeB>( "c3", "child of child" );

std::shared_ptr<Component> c4 = std::make_shared<ConcreteCompositeA>( "c4", 107 );

std::shared_ptr<Component> c5 = std::make_shared<ConcreteCompositeB>( "c5", "other child" );

c3->Add( c4 );

c2->Add( c3 );

c1->Add( c2 );

c1->Add( c5 );

c1->Execute( 0 );

// Clone:

std::cout << "--Clone--" << std::endl;

std::shared_ptr<Component> cloned_compo = c1->Clone();

cloned_compo->Execute( 0 );

// Assign:

std::cout << "--Before Assign--" << std::endl;

std::shared_ptr<Component> assigned_compo = std::make_shared<ConcreteCompositeA>( "assigned_compo", 0 );

assigned_compo->Execute( 0 );

std::cout << "--After Assign--" << std::endl;

assigned_compo->Assign( c1 );

assigned_compo->Execute( 0 );

getch();

return 0;

}

実行結果
————————
name:c1/A: val == 3
　name:c2/B: str == child
　　name:c3/B: str == child of child
　　　name:c4/A: val == 107
　name:c5/B: str == other child
–Clone–
name:c1/A: val == 3
　name:c2/B: str == child
　　name:c3/B: str == child of child
　　　name:c4/A: val == 107
　name:c5/B: str == other child
–Before Assign–
name:assigned_compo/A: val == 0
–After Assign–
name:c1/A: val == 3
　name:c2/B: str == child
　　name:c3/B: str == child of child
　　　name:c4/A: val == 107
　name:c5/B: str == other child
————————

ConcreteCompositeのメンバを追加・変更した場合、doAssignメソッドのみを書き換えればOK。

Compositeパターンをshared_ptrで実装する

かつて情報をネットで探したときに、断片的な情報はあるものの、分かりやすいサンプルが見付からなかったのでメモ。
Compositeパターンをshared_ptrで実装するのは、単にポインタをshared_ptrに置き換えるだけだと、循環参照が発生する。

ポイントは２つ。
　1.親(Parent)のポインタはshared_ptrでなくweak_ptrに置き換える
　2.shared_from_thisを使う

以下のコードはc++11以降のstl版だが、c++11以前でもboostで同様の実装が可能。必要なヘッダをincludeすれば”std::”を”boost::”に置き換えるだけでＯＫ。
(説明を短くするために全てheaderに入れている)

まずComponentクラス。
メンバ”parent_”をweak_ptrで保持する。

#include <memory>
#include <iostream> // 動作確認用:
//---------------------------------------------------------------------------
class Component
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	std::weak_ptr<Component>  parent_;
public:
// ---- get ----
	std::shared_ptr<Component>
			getParent()const{ return parent_.lock(); }
	bool 	hasParent()const{ return parent_.lock().get() != nullptr; }
// ---- set ----
	void    setParent( const std::shared_ptr<Component>& compo ){ parent_ = compo; }

//--------------------------------
//  Constructor:
//________________________________
public:
	Component()
		: parent_()
		{}

//--------------------------------
//  Destructor:
//________________________________
public:
	virtual ~Component(){}

//--------------------------------
//  Pure Virtual Method:
//________________________________
public:
	virtual void Add( const std::shared_ptr<Component>& compo ) = 0;
	virtual void Remove( const std::shared_ptr<Component>& compo ) = 0;
	//
	virtual void Execute( int depth )	= 0;
	virtual void doExecute()    = 0;
};

#include <memory>

#include <iostream> // 動作確認用:

//---------------------------------------------------------------------------

class Component

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

std::weak_ptr<Component> parent_;

public:

// ---- get ----

std::shared_ptr<Component>

getParent()const{ return parent_.lock(); }

bool hasParent()const{ return parent_.lock().get() != nullptr; }

// ---- set ----

void setParent( const std::shared_ptr<Component>& compo ){ parent_ = compo; }

//--------------------------------

// Constructor:

//________________________________

public:

Component()

: parent_()

{}

//--------------------------------

// Destructor:

//________________________________

public:

virtual ~Component(){}

//--------------------------------

// Pure Virtual Method:

//________________________________

public:

virtual void Add( const std::shared_ptr<Component>& compo ) = 0;

virtual void Remove( const std::shared_ptr<Component>& compo ) = 0;

virtual void Execute( int depth ) = 0;

virtual void doExecute() = 0;

};

(Executeは階層構造を出力するだけのテスト用Method)

つづいてCompositeクラス。
継承元に”std::enable_shared_from_this”を指定するのがポイント。
また”Add”で親をセットする際、”shared_from_this()”を使う。

#include <vector>
#include <algorithm>
//---------------------------------------------------------------------------
#include "Component.h"
//---------------------------------------------------------------------------
class Composite : public Component,public std::enable_shared_from_this<Composite>
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	std::vector<std::shared_ptr<Component>>
			childs_;

//--------------------------------
//  Constructor:
//________________________________
public:
	Composite()
		: Component(),
		  childs_()
		{}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void Add( const std::shared_ptr<Component>& compo )
	{
		if( std::find( childs_.begin(), childs_.end(), compo ) == childs_.end() )
		{
			childs_.push_back( compo );
			compo->setParent( shared_from_this() );
		}
	}
	virtual void Remove( const std::shared_ptr<Component>& compo )
	{
		childs_.erase( remove( childs_.begin(), childs_.end(), compo ), childs_.end() );
	}
	//
	virtual void Execute( int depth )
	{
		for( int i = 0; i < depth; ++i )
			std::cout << "　";
		doExecute();
		for( size_t i = 0; i < childs_.size(); ++i )
		{
			childs_[i]->Execute( depth + 1 );
		}
	}
};

#include <vector>

#include <algorithm>

//---------------------------------------------------------------------------

#include "Component.h"

//---------------------------------------------------------------------------

class Composite : public Component,public std::enable_shared_from_this<Composite>

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

std::vector<std::shared_ptr<Component>>

childs_;

//--------------------------------

// Constructor:

//________________________________

public:

Composite()

: Component(),

childs_()

{}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void Add( const std::shared_ptr<Component>& compo )

{

if( std::find( childs_.begin(), childs_.end(), compo ) == childs_.end() )

{

childs_.push_back( compo );

compo->setParent( shared_from_this() );

}

virtual void Remove( const std::shared_ptr<Component>& compo )

{

childs_.erase( remove( childs_.begin(), childs_.end(), compo ), childs_.end() );

}

virtual void Execute( int depth )

{

for( int i = 0; i < depth; ++i )

std::cout << "　";

doExecute();

for( size_t i = 0; i < childs_.size(); ++i )

{

childs_[i]->Execute( depth + 1 );

}

};

CompositeのConcreteクラスを２つ作ってみる。ひとつはstd::string, もう一つはintをメンバに持つことにする。

class ConcreteCompositeA : public Composite
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	int val_;

//--------------------------------
//  Constructor:
//________________________________
public:
	explicit ConcreteCompositeA( int val )
		: Composite(),
		  val_(val)
		{}

//--------------------------------
//  Destructor:
//________________________________
public:
	~ConcreteCompositeA(){}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void doExecute()
	{
		std::cout << "A: val == " << val_ << std::endl;
	}
};

class ConcreteCompositeA : public Composite

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

int val_;

//--------------------------------

// Constructor:

//________________________________

public:

explicit ConcreteCompositeA( int val )

: Composite(),

val_(val)

{}

//--------------------------------

// Destructor:

//________________________________

public:

~ConcreteCompositeA(){}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void doExecute()

{

std::cout << "A: val == " << val_ << std::endl;

}

};

#include <string>
//---------------------------------------------------------------------------
#include "Composite.h"
//---------------------------------------------------------------------------
class ConcreteCompositeB : public Composite
{
//--------------------------------
//  Member and Accessor:
//________________________________
private:
	std::string	str_;
public:
// ---- set ----
// ---- get ----

//--------------------------------
//  Constructor:
//________________________________
public:
	explicit ConcreteCompositeB( const std::string& str )
		: Composite(),
		  str_(str)
		{}

//--------------------------------
//  Destructor:
//________________________________
public:
	~ConcreteCompositeB(){}

//--------------------------------
//  Override Method:
//________________________________
public:
	virtual void doExecute()
	{
		std::cout << "B: str == " << str_ << std::endl;
	}
};

#include <string>

//---------------------------------------------------------------------------

#include "Composite.h"

//---------------------------------------------------------------------------

class ConcreteCompositeB : public Composite

{

//--------------------------------

// Member and Accessor:

//________________________________

private:

std::string str_;

public:

// ---- set ----

// ---- get ----

//--------------------------------

// Constructor:

//________________________________

public:

explicit ConcreteCompositeB( const std::string& str )

: Composite(),

str_(str)

{}

//--------------------------------

// Destructor:

//________________________________

public:

~ConcreteCompositeB(){}

//--------------------------------

// Override Method:

//________________________________

public:

virtual void doExecute()

{

std::cout << "B: str == " << str_ << std::endl;

}

};

実行してみる。適当に親子関係を作り、出力。

#include <stdio.h>
#include <conio.h>

#include "ConcreteCompositeA.h"
#include "ConcreteCompositeB.h"

 int _tmain(int argc, _TCHAR* argv[])
{
	std::shared_ptr<Component> c1 = std::make_shared<ConcreteCompositeA>( 3 );
	std::shared_ptr<Component> c2 = std::make_shared<ConcreteCompositeB>( "child" );
	std::shared_ptr<Component> c3 = std::make_shared<ConcreteCompositeB>( "child of child" );
	std::shared_ptr<Component> c4 = std::make_shared<ConcreteCompositeA>( 107 );
	std::shared_ptr<Component> c5 = std::make_shared<ConcreteCompositeB>( "other child" );

	c3->Add( c4 );
	c2->Add( c3 );
	c1->Add( c2 );
	c1->Add( c5 );

	c1->Execute( 0 );

	getch();
	return 0;
}

#include <stdio.h>

#include <conio.h>

#include "ConcreteCompositeA.h"

#include "ConcreteCompositeB.h"

int _tmain(int argc, _TCHAR* argv[])

{

std::shared_ptr<Component> c1 = std::make_shared<ConcreteCompositeA>( 3 );

std::shared_ptr<Component> c2 = std::make_shared<ConcreteCompositeB>( "child" );

std::shared_ptr<Component> c3 = std::make_shared<ConcreteCompositeB>( "child of child" );

std::shared_ptr<Component> c4 = std::make_shared<ConcreteCompositeA>( 107 );

std::shared_ptr<Component> c5 = std::make_shared<ConcreteCompositeB>( "other child" );

c3->Add( c4 );

c2->Add( c3 );

c1->Add( c2 );

c1->Add( c5 );

c1->Execute( 0 );

getch();

return 0;

}

出力結果。
—————————————-
A: val == 3
　B: str == child
　　B: str == child of child
　　　A: val == 107
　B: str == other child
—————————————-

生ポインタを使うのと比べ、解放処理が不要で便利。