stl – 算譜とドリア

TStringListからvector / TStringDynArrayからvector[C++Builder]

C++Builder(およびDelphi)でよく使われるTStringListとかDynamicArrayを、std::vectorに変換したい場合がよくある。
この場合、いちいちループを回さなくても、STLライクなイテレータ操作が使える、ということを今さら公式ヘルプで知ったのでメモ。

TStringListからvector

TStringListからstd::vectorは以下のように一発で変換可能。

TStringList* SList = new TStringList;
//・・・(いろいろ追加)・・・・・・
std::vector strings( begin(SList), end(SList) );

TStringList* SList = new TStringList;

//・・・(いろいろ追加)・・・・・・

std::vector strings( begin(SList), end(SList) );

既存のvectorにはassignで代入。

std::vector v = { L"A", L"B" };
v.assign( begin(SList), end(SList) );

1 2	std::vector v = { L"A", L"B" }; v.assign( begin(SList), end(SList) );

スマートポインタでも問題ない。

std::shared_ptr<TStringList> SList( new TStringList );
std::vector v( begin(SList.get()), end(SList.get()) );

1 2	std::shared_ptr<TStringList> SList( new TStringList ); std::vector v( begin(SList.get()), end(SList.get()) );

文字列リストの基底クラスであるTStringsも同様。
おなじみのフォント一覧を取得するケース。

TStrings* Fonts = Screen->Fonts;
std::vector fontnames( begin(Fonts), end(Fonts) );

1 2	TStrings* Fonts = Screen->Fonts; std::vector fontnames( begin(Fonts), end(Fonts) );

ソートされた結果を最初から得たい場合は、std::setをいきなり初期化してもいい。

std::set s_set( begin(SList), end(SList) );

1	std::set s_set( begin(SList), end(SList) );

DynamicArrayからvector

Delphi動的配列型のDynamicArrayも似たような代入が可能。

DynamicArray i_darray;
i_darray.set_length( 3 );
i_darray[0] = 0;
i_darray[1] = 1;
i_darray[2] = 3;
std::vector v( i_darray.begin(), i_darray.end() );

DynamicArray i_darray;

i_darray.set_length( 3 );

i_darray[0] = 0;

i_darray[1] = 1;

i_darray[2] = 3;

std::vector v( i_darray.begin(), i_darray.end() );

IOUtilsのTDirectory::GetFilesはディレクトリ内の全ファイルを一発で取れる便利な関数だが、この返値TStringDynArrayはDynamicArray<String>のtypedefなので、同様にvector等に変換できる。

TStringDynArray Files = TDirectory::GetFiles( DirName );
std::vector files( Files.begin(), Files.end() );

1 2	TStringDynArray Files = TDirectory::GetFiles( DirName ); std::vector files( Files.begin(), Files.end() );

以上、C++Builder10.2.3 / Windows10(21H2)で確認。

vectorの重複要素をソートせずに削除する[c++]

vectorの重複要素の削除は、まずソートしてから std::unique / erase という定番手法があるが、現在の要素の順番を崩さないまま行いたい場合もある。

こうしたケース用に、何か定番の方法があるのかと調べたら、こちらのサイトを見ただけでも実にいろいろなやり方があるらしい。

とりあえず、要素の大きさとか重複率とか気にせず、速度や効率にこだわらなければ、結局 std::set を使うベタな方法が個人的には一番分かりやすかった。

std::vector<int> v = { 1, 78, 6, 3, 55, 41, 6, 3, 7, 1 };

std::set<int> found;
for( auto it = v.begin(); it != v.end(); )
{
    if( found.count( *it ) )
    {
        it = v.erase( it );
    }
    else
    {
        found.insert( *it );
        ++it;
    }
}

std::vector<int> v = { 1, 78, 6, 3, 55, 41, 6, 3, 7, 1 };

std::set<int> found;

for( auto it = v.begin(); it != v.end(); )

{

if( found.count( *it ) )

{

it = v.erase( it );

}

else

{

found.insert( *it );

++it;

}

なおstd::setのメンバ関数countは1か0を返すだけ。std::findを使うよりシンプルに書ける。

テンプレート関数を作っておくと、どんな型を突っ込んだvectorでもだいたい使えるので楽かもしれない。(というか自分用に作った)

template<typename T>
void unique_erase_nosort( std::vector<T>& v )
{
    std::set<T> found;
    auto it = v.begin();
    while( it != v.end() )
    {
        if( found.count( *it ) )
        {
            it = v.erase( it );
        }
        else
        {
            found.insert( *it );
            ++it;
        }
    }
}

template<typename T>

void unique_erase_nosort( std::vector<T>& v )

{

std::set<T> found;

auto it = v.begin();

while( it != v.end() )

{

if( found.count( *it ) )

{

it = v.erase( it );

}

else

{

found.insert( *it );

++it;

}

ついでに std::remove_if と c++11以降のラムダ式も使ったバージョン。std::deque版。

template<typename T>
void unique_erase_nosort( std::deque<T>& d )
{
    std::set<T> found;
    auto new_end = std::remove_if( d.begin(), d.end(),
                                   [&found]( const T& val )
                                    {
                                        if( found.count( val ) )
                                            return true;
                                        found.insert( val );
                                        return false;
                                    }
                                 );
    d.erase( new_end, d.end() );
}

template<typename T>

void unique_erase_nosort( std::deque<T>& d )

{

std::set<T> found;

auto new_end = std::remove_if( d.begin(), d.end(),

[&found]( const T& val )

{

if( found.count( val ) )

return true;

found.insert( val );

return false;

}

);

d.erase( new_end, d.end() );

}

これは、setのinsert関数の返値を使うともっとシンプルに書ける、とこちらのサイトで知った。

template<typename T>
void unique_erase_nosort( std::deque<T>& d )
{
    std::set<T> found;
    auto new_end = std::remove_if( d.begin(), d.end(),
                                   [&found]( const T& val )
                                    {
                                        return !found.insert( val ).second;
                                    }
                                 );
    d.erase( new_end, d.end() );
}

template<typename T>

void unique_erase_nosort( std::deque<T>& d )

{

std::set<T> found;

auto new_end = std::remove_if( d.begin(), d.end(),

[&found]( const T& val )

{

return !found.insert( val ).second;

}

);

d.erase( new_end, d.end() );

}

setのメンバ関数 insert は、引数１つのバージョンだと std::pair<iterator,bool>を返す。挿入に成功するとsecondにはtrueが入る。なるほど便利。

　　　
C++Builder10.2.3で確認。

[c++]文字列から１文字ずつ、サロゲートペアと異体字セレクタを考慮しつつ取り出す

Unicode文字列から「１文字ずつ」を取り出す場合、異体字セレクタやサロゲートペアを考慮に入れる必要がある。
以下、日本語環境での話(モンゴル文字の異体字セレクタ等は未対応)。

1.std::wstring(2バイト環境)の場合

以前の記事で書いたとおり、異体字セレクタは文字の末尾に4byte分の情報が付加される。(C++Builderで異体字セレクタを使う)

このため、wchar_tが2byteの場合、wstringの「１文字」が取り得るバイト数は以下の４通りになる。

「１文字」の４パターン	バイト数
基本文字(基本多言語面)	2byte
サロゲートペア	4byte
基本文字の異体字セレクタ付	6byte
サロゲートペアの異体字セレクタ付	8byte

以下、文字列から、１文字ずつをstd::vectorに格納するメソッド。

std::vector<std::wstring> create_wstring_vec( const std::wstring& wstr )const
{
    std::vector<std::wstring> ret_wstrings;

    for( size_t i = 0; i < wstr.length(); ++i )
    {
        const unsigned long c = static_cast<unsigned long>( wstr[i] );

        // 異体字セレクタの判定:
        if( c == 0xDB40 // IVSの上位バイト:
         && ( i + 1 ) < wstr.length()
         && ( 0xDD00 <=  wstr[i+1] && wstr[i+1] <= 0xDDEF )
         && !ret_wstrings.empty() )
        {
            // 直前に格納された文字に異体字情報を追加:
            ret_wstrings[ret_wstrings.size()-1] += wstr.substr( i, 2 );
            ++i;
        }
        // サロゲートペアの判定
        else if( 0xD800 <= c && c <= 0xDBFF )
        {
            std::wstring ws = wstr.substr( i, 2 );
            ret_wstrings.push_back( ws );
            ++i;
        }
        // その他
        else
        {
            std::wstring ws = wstr.substr( i, 1 );
            ret_wstrings.push_back( ws );
        }
    }
    return ret_wstrings;
}

std::vector<std::wstring> create_wstring_vec( const std::wstring& wstr )const

{

std::vector<std::wstring> ret_wstrings;

for( size_t i = 0; i < wstr.length(); ++i )

{

const unsigned long c = static_cast<unsigned long>( wstr[i] );

// 異体字セレクタの判定:

if( c == 0xDB40 // IVSの上位バイト:

&& ( i + 1 ) < wstr.length()

&& ( 0xDD00 <= wstr[i+1] && wstr[i+1] <= 0xDDEF )

&& !ret_wstrings.empty() )

{

// 直前に格納された文字に異体字情報を追加:

ret_wstrings[ret_wstrings.size()-1] += wstr.substr( i, 2 );

++i;

}

// サロゲートペアの判定

else if( 0xD800 <= c && c <= 0xDBFF )

{

std::wstring ws = wstr.substr( i, 2 );

ret_wstrings.push_back( ws );

++i;

}

// その他

else

{

std::wstring ws = wstr.substr( i, 1 );

ret_wstrings.push_back( ws );

}

return ret_wstrings;

}

(wchar_tが16bit/unsignedであることを前提にしたコード)

2.std::string(utf-8)の場合

utf-8文字列をstd::stringに突っ込んで使う場合もあるので(自分自身はやらないが)、ちょっと調べた。以下のような方法で取り出せる(たぶん)。

utf-8文字は、先頭バイトを見ると１文字分のバイト数が分かるので、サロゲートペア判定は特に必要ない。だが、そこで取れるバイト数には異体字セレクタ情報は反映されないので、自前で処理する必要がある。

文字に付加される異体字セレクタは計４byte分で、漢字用のIVSでは以下の範囲を取るようだ。

バイト順	値の範囲
１	0xF3　(固定)
２	0xA0　(固定)
３	0x84～0x87
４	0x80～0xBF (0x80～0xAF)

４バイト目は、３バイト目が0x87の時に限り最大で0xAF(たぶん)。

以下、utf-8文字列の格納されたstd::stringから１文字ずつ取り出すメソッド。
なお、IVS最初の0xF3は、単体でも1byteで文字を表現するので、まず2byte分を判定する必要がある。

std::vector<std::string> create_u8string_vec( const std::string& utf8str )const
{
    using uchar = unsigned char;

    std::vector<std::string> ret_strings;

    for( size_t i = 0; i < utf8str.length(); ++i )
    {
        // 先頭バイト
        uchar c( utf8str[i] );

        // 異体字セレクタ判定
        // -------------------
        // まず2byte分調べる
        if( c == 0xF3
         && i
         && ( i + 3 ) < utf8str.length()
         && static_cast<uchar>( utf8str[i+1] ) == 0xA0 )
        {
            // 残る2byteを調べる
            uchar c1 = static_cast<uchar>( utf8str[i+2] );
            uchar c2 = static_cast<uchar>( utf8str[i+3] );
            // ３番目の値が0x84～0x86で且つ４番目の値が0x80～0xBF
            // または
            // ３番目の値が0x87で且つ４番目の値が0x80～0xAF
            if( 0x84 <= c1 && 0x80 <= c2
            && (
                 ( c1 <= 0x86 && c2 <= 0xBF )
                 ||
                 ( c1 == 0x87 && c2 <= 0xAF )
               )
              )
            {
                // 直前に格納された文字に異体字情報を追加:
                ret_strings[ret_strings.size()-1] += utf8str.substr( i, 4 );
                i += 3;
            }
        }
        // それ以外ならバイト数を求めて格納
        else
        {
            unsigned int byte_count = 0;

            if( 0x00 <= c && c <= 0x7F )
                byte_count = 1;
            else if( 0xC0 <= c && c <= 0xDF )
                byte_count = 2;
            else if( 0xE0 <= c && c <= 0xEF )
                byte_count = 3;
            else if( 0xF0 <= c && c <= 0xF7 )
                byte_count = 4;
            else if( 0xF8 <= c && c <= 0xFB )
                byte_count = 5;
            else if( 0xFC <= c && c <= 0xFD )
                byte_count = 6;

            if( byte_count )
            {
                ret_strings.push_back( utf8str.substr( i, byte_count ) );
                i += byte_count - 1;
            }
        }
    }
    return ret_strings;
}

std::vector<std::string> create_u8string_vec( const std::string& utf8str )const

{

using uchar = unsigned char;

std::vector<std::string> ret_strings;

for( size_t i = 0; i < utf8str.length(); ++i )

{

// 先頭バイト

uchar c( utf8str[i] );

// 異体字セレクタ判定

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

// まず2byte分調べる

if( c == 0xF3

&& i

&& ( i + 3 ) < utf8str.length()

&& static_cast<uchar>( utf8str[i+1] ) == 0xA0 )

{

// 残る2byteを調べる

uchar c1 = static_cast<uchar>( utf8str[i+2] );

uchar c2 = static_cast<uchar>( utf8str[i+3] );

// ３番目の値が0x84～0x86で且つ４番目の値が0x80～0xBF

// または

// ３番目の値が0x87で且つ４番目の値が0x80～0xAF

if( 0x84 <= c1 && 0x80 <= c2

&& (

( c1 <= 0x86 && c2 <= 0xBF )

( c1 == 0x87 && c2 <= 0xAF )

)

{

// 直前に格納された文字に異体字情報を追加:

ret_strings[ret_strings.size()-1] += utf8str.substr( i, 4 );

i += 3;

}

// それ以外ならバイト数を求めて格納

else

{

unsigned int byte_count = 0;

if( 0x00 <= c && c <= 0x7F )

byte_count = 1;

else if( 0xC0 <= c && c <= 0xDF )

byte_count = 2;

else if( 0xE0 <= c && c <= 0xEF )

byte_count = 3;

else if( 0xF0 <= c && c <= 0xF7 )

byte_count = 4;

else if( 0xF8 <= c && c <= 0xFB )

byte_count = 5;

else if( 0xFC <= c && c <= 0xFD )

byte_count = 6;

if( byte_count )

{

ret_strings.push_back( utf8str.substr( i, byte_count ) );

i += byte_count - 1;

}

return ret_strings;

}

3.サンプルプログラム

C++Builderによるサンプルプログラム。

TFormにTEditとTMemoをひとつずつ、TButtonを２つ貼り付ける。
TEditとTMemoのフォントは游明朝、サイズを40にしておく。 TEditに以下の文字列を入れておく。

文字列の漢字部分は、最初の「辻」から順に
・基本文字
・異体字セレクタ
・基本文字
・サロゲートペア
・サロゲートペア
・サロゲートペアの異体字セレクタ付
英字は小文字のａが全角、大文字のAは半角。

3-1.std::wstringを使った例

Button1Clickを次のように実装。

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    const std::wstring wstr = Edit->Text.c_str();
    std::vector<std::wstring> wstring_vec = create_wstring_vec( wstr );
    for( const auto& s : wstring_vec )
    {
        Memo->Lines->Add( s.c_str() );
    }
}

void __fastcall TForm1::Button1Click(TObject *Sender)

{

const std::wstring wstr = Edit->Text.c_str();

std::vector<std::wstring> wstring_vec = create_wstring_vec( wstr );

for( const auto& s : wstring_vec )

{

Memo->Lines->Add( s.c_str() );

}

結果：

3-2.std::stringを使った例

C++BuilderにはUTF8String型があるので、変換にはそれを使っている。
Button2Clickを以下のように実装。

void __fastcall TForm1::Button2Click(TObject *Sender)
{
    UTF8String U8Str = Edit->Text;
    const std::string u8str = U8Str.c_str();

    std::vector<std::string> string_vec = create_u8string_vec( u8str );

    for( const auto& s : string_vec )
    {
        UTF8String U8Str = s.c_str();
        Memo->Lines->Add( U8Str );
    }
}

void __fastcall TForm1::Button2Click(TObject *Sender)

{

UTF8String U8Str = Edit->Text;

const std::string u8str = U8Str.c_str();

std::vector<std::string> string_vec = create_u8string_vec( u8str );

for( const auto& s : string_vec )

{

UTF8String U8Str = s.c_str();

Memo->Lines->Add( U8Str );

}

結果：
　
以上、とりあえずのテストでは上手くいっているが、何か見落とし等があるかも。

[C++Builder]画像ファイルをテキストで保存、読込

C++Builderのフォーム情報(*.dfm)ではアイコン等の画像を16進文字列で保存しているようで、似たようなことをやってみる。(使いどころはパッとは思い浮かばないが)。

とりあえずVclの例。

サンプルプログラム

TFormにTButtonとTImageを２つずつと、TOpenPictureDialogを設置。TImageは２つともProportionalプロパティをtrueにしておく。

画像を16進文字列で保存

手順は以下の通り
①画像ファイルをTMemoryStreamに読み込む
②サイズの同じunsigned char配列を用意し、MemoryStreamからデータを書き込む
③１バイトずつ16進文字列に変換
④文字列をファイル保存

なお、C++Builderは、デフォルトではcharがsignedなので、明示的にunsigned charを指定している。

#include <memory>   // shared_ptr
#include <sstream>   // stringstream
#include <iomanip>   // "setw":

#include <IOUtils.hpp>   // TPath
#include <jpeg.hpp>
#include <pngimage.hpp>
#include <gifimg.hpp>

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    if( OpenPictureDialog->Execute() )
    {
        // 表示テスト用、Image1に画像を読込・表示
        Image1->Picture->LoadFromFile( OpenPictureDialog->FileName );

        // ①MemoryStreamにファイルから画像を読み込む
        std::shared_ptr<TMemoryStream> ms( new TMemoryStream );
        ms->LoadFromFile( OpenPictureDialog->FileName );

            /* ImageからMemotyStreamに書き込んでも可
            Image1->Picture->SaveToStream( ms.get() );
            ms->Position = 0; // MemotyStreamの読み書き位置オフセットを先頭に
            */


        // ②unsigned char 配列にMemoryStreamの内容を書き込む
        const long long size = (long long)( ms->Size );
        unsigned char* buffer = new unsigned char[size+1];
        ms->Read( buffer, size );

        // ③配列要素の値を16進文字列に変換
        std::stringstream ss;
        ss << std::setfill('0') << std::hex; // 0~Fまでは先頭0埋め、16進
        for( long long i = 0; i < size; ++i )
        {
            ss << std::setw( 2 ); // 二桁にセット
            ss << static_cast<int>( buffer[i] );
        }
        delete [] buffer;

        // ④文字列をファイルに書き込む
        String HexStr = ss.str().c_str();
        TFile::WriteAllText( L"test.txt", HexStr );
    }
}

#include <memory> // shared_ptr

#include <sstream> // stringstream

#include <iomanip> // "setw":

#include <IOUtils.hpp> // TPath

#include <jpeg.hpp>

#include <pngimage.hpp>

#include <gifimg.hpp>

void __fastcall TForm1::Button1Click(TObject *Sender)

{

if( OpenPictureDialog->Execute() )

{

// 表示テスト用、Image1に画像を読込・表示

Image1->Picture->LoadFromFile( OpenPictureDialog->FileName );

// ①MemoryStreamにファイルから画像を読み込む

std::shared_ptr<TMemoryStream> ms( new TMemoryStream );

ms->LoadFromFile( OpenPictureDialog->FileName );

/* ImageからMemotyStreamに書き込んでも可

Image1->Picture->SaveToStream( ms.get() );

ms->Position = 0; // MemotyStreamの読み書き位置オフセットを先頭に

// ②unsigned char 配列にMemoryStreamの内容を書き込む

const long long size = (long long)( ms->Size );

unsigned char* buffer = new unsigned char[size+1];

ms->Read( buffer, size );

// ③配列要素の値を16進文字列に変換

std::stringstream ss;

ss << std::setfill('0') << std::hex; // 0~Fまでは先頭0埋め、16進

for( long long i = 0; i < size; ++i )

{

ss << std::setw( 2 ); // 二桁にセット

ss << static_cast<int>( buffer[i] );

}

delete [] buffer;

// ④文字列をファイルに書き込む

String HexStr = ss.str().c_str();

TFile::WriteAllText( L"test.txt", HexStr );

}

C:\Windows\Web\Wallpaper\Theme2\img7.jpgを読み込んだ結果:

保存されたテキストデータをエディタで見てみる。

テキストファイルから画像を読込、表示

復元手順は以下の通り。
①文字列のテキストファイルを読み込む
②２文字ずつ数値変換しunsigned char配列に格納
③MemoryStreamにデータを書き込む
④TImageにMemoryStreamから読み込む

void __fastcall TForm1::Button2Click(TObject *Sender)
{
    // ①ファイルから文字列を読み込む
    String AllText = TFile::ReadAllText( L"test.txt" );

    // ②必要な長さのunsigned char配列を確保
    AnsiString AText = AllText; // std::stringに格納するためAnsiStringに変換
    std::string all_text = AText.c_str();
    const long long count = static_cast<long long>( all_text.length() / 2 );
    unsigned char* buffer = new unsigned char[count+1];

    // ③文字列から２文字ずつ数値に変換し、unsigned char配列に格納
    for( long long i = 0; i < all_text.length(); i += 2 )
    {
        std::string tmp = all_text.substr( i, 2 );
        buffer[i/2] = stoi( tmp, nullptr, 16 );
    }
    buffer[count] = '\0';

    // ④unsigned char 配列の値をMemotyStreamに書き込む
    std::shared_ptr<TMemoryStream> ms( new TMemoryStream );
    ms->WriteBuffer( buffer, count );
    ms->Position = 0;
    // Image2に画像データを読込・表示
    Image2->Picture->LoadFromStream( ms.get() );

    delete [] buffer;
}

void __fastcall TForm1::Button2Click(TObject *Sender)

{

// ①ファイルから文字列を読み込む

String AllText = TFile::ReadAllText( L"test.txt" );

// ②必要な長さのunsigned char配列を確保

AnsiString AText = AllText; // std::stringに格納するためAnsiStringに変換

std::string all_text = AText.c_str();

const long long count = static_cast<long long>( all_text.length() / 2 );

unsigned char* buffer = new unsigned char[count+1];

// ③文字列から２文字ずつ数値に変換し、unsigned char配列に格納

for( long long i = 0; i < all_text.length(); i += 2 )

{

std::string tmp = all_text.substr( i, 2 );

buffer[i/2] = stoi( tmp, nullptr, 16 );

}

buffer[count] = '\0';

// ④unsigned char 配列の値をMemotyStreamに書き込む

std::shared_ptr<TMemoryStream> ms( new TMemoryStream );

ms->WriteBuffer( buffer, count );

ms->Position = 0;

// Image2に画像データを読込・表示

Image2->Picture->LoadFromStream( ms.get() );

delete [] buffer;

}

復元して右側のImageに表示した結果：

FireMonkeyの場合

FireMonkeyでも、ほぼ同様なコードで可能。
違いは
・OpenPictureDialogがないので代わりにOpenDialogを使う
・Image関連のコードの修正(Pictureの代わりにBitmapを使う)
・jpeg/png/gif用のインクルード不要
だけ。
Image関連の違いは以下の通り。

/** Image1に画像画像を読込・表示 **/
// VCL:
Image1->Picture->LoadFromFile( OpenPictureDilalog->FileName );
// FireMonkey:
Image1->Bitmap->LoadFromFile( OpenDialog->FileName );

/** Image1からMemotyStreamに書き込む **/
// VCL:
Image1->Picture->SaveToStream( ms.get() );
// FireMonkey:
Image1->Bitmap->SaveToStream( ms.get() );

/** Image2にMemoryStreamから画像を読込・表示 **/
// VCL:
Image2->Picture->LoadFromStream( ms.get() );
// FireMonkey:
Image2->Bitmap->LoadFromStream( ms.get() );

/** Image1に画像画像を読込・表示 **/

// VCL:

Image1->Picture->LoadFromFile( OpenPictureDilalog->FileName );

// FireMonkey:

Image1->Bitmap->LoadFromFile( OpenDialog->FileName );

/** Image1からMemotyStreamに書き込む **/

// VCL:

Image1->Picture->SaveToStream( ms.get() );

// FireMonkey:

Image1->Bitmap->SaveToStream( ms.get() );

/** Image2にMemoryStreamから画像を読込・表示 **/

// VCL:

Image2->Picture->LoadFromStream( ms.get() );

// FireMonkey:

Image2->Bitmap->LoadFromStream( ms.get() );

対象ファイル

TImageに読込・表示できる画像ならおおおむね可能な模様。JPEGのほかPNG/BMP/GIF/TIF、さらにアイコンファイル(ico)でＯＫだった。メタファイル(emf)はVclでないと読み込めない模様。

ただし、C:\Windows\Web\Wallpaper\Theme1配下にあるWindows10壁紙用のjpeg画像は、VCLの場合だけ失敗した。テキストとして保存はできても、復元でTImageに読み込む時点で「サポートされていないストリーム形式」のエラーが出て、復元不能だった。理由は謎。

C++Builder10.2.3/Windows10(64bit/バージョン20H2)で確認。

[c++]vectorを配列に／配列をvectorに

どっちからどっちに変換するかで方法が違うため、すぐ忘れるのでメモ。

vectorから配列

std::copyを使う方法。

std::vector<int> v = {0,1,2,3};

int array[v.size()];
std::copy(v.begin(), v.end(), array);

std::vector<int> v = {0,1,2,3};

int array[v.size()];

std::copy(v.begin(), v.end(), array);

配列からvector

std::copyやvectorのメンバ関数assignを使う方法もあるが、c++11以降なら、以下がたぶん一番シンプル。

int array[] = {0,1,2,3,4};

std::vector<int> v( std::begin(array), std::end(array) );

int array[] = {0,1,2,3,4};

std::vector<int> v( std::begin(array), std::end(array) );

配列の大きさとか

以下、おまけ。
既存のvectorに配列を代入するなど、配列のサイズ(要素数)を知りたい場合、c++11以降だと、sizeofを利用する以外の方法も用意されている。

int array[] = { 1,2,3,4,5 };

// c++11以降
const size_t cnt = std::extent<decltype(array),0>::value;
// c++17以降
const aize_t cnt = std::size(array);

int array[] = { 1,2,3,4,5 };

// c++11以降

const size_t cnt = std::extent<decltype(array),0>::value;

// c++17以降

const aize_t cnt = std::size(array);

ただし、既存のvectorに、異なるサイズの配列を代入するだけなら、メモリや実行速度にシビアでなければ、いちいちサイズを求めなくとも以下で済むといえば済む。

std::vector<int> tmp_v( std::begin(array), std::end(array) );
v = tmp_v;

1 2	std::vector<int> tmp_v( std::begin(array), std::end(array) ); v = tmp_v;

[c++11]本日の経過ミリ秒を取得する

現在、本日が始まってから何ミリ秒過ぎたかを求めるため、c++11で追加されたstd::chronoライブラリを勉強がてら使ってみた。もっとスマートな方法もあるかもしれないが。以下、c++11/Windows環境の場合。c++17やLinux環境だと別の方法もあるらしい。

現在時刻に関する情報はnow()関数で取れる。なおこの時刻はUTC(協定世界時)であり日本時間とは異なる。

#include <chrono>

std::chrono::system_clock::time_point
    tp = std::chrono::system_clock::now();

#include <chrono>

std::chrono::system_clock::time_point

tp = std::chrono::system_clock::now();

time_since_epoc関数で「エポックからの経過時間」を求めて、メンバ関数countでミリ秒を取得。そこから現在時刻のミリ秒部分を得る。この「エポック」が何時なのかは未規定だが概ね1970/1/1で、経過ミリ秒は軽く1兆を超える値になり、32bit intでは正常に収容できないので注意が必要。(もちろんautoを使えば問題ない)。

//エポックからの経過時間
std::chrono::milliseconds
    tp_msec = std::chrono::duration_cast<std::chrono::milliseconds>
                ( tp.time_since_epoch() );
//経過時間を総ミリ秒(整数値)に変換
long long all_msec = tp_msec.count();
//１秒未満の値を取り出す
int msec = all_msec % 1000;

//エポックからの経過時間

std::chrono::milliseconds

tp_msec = std::chrono::duration_cast<std::chrono::milliseconds>

( tp.time_since_epoch() );

//経過時間を総ミリ秒(整数値)に変換

long long all_msec = tp_msec.count();

//１秒未満の値を取り出す

int msec = all_msec % 1000;

時間・分・秒を取得するため、time_tに変換。さらに現地時間(日本時間)に変換する。

time_t time = std::chrono::system_clock::to_time_t( tp );
struct tm* t = localtime( &time );

1 2	time_t time = std::chrono::system_clock::to_time_t( tp ); struct tm* t = localtime( &time );

この時点で本日の経過ミリ秒は自前で計算可能だが、せっかくtime_pointは減算が効くので、本日0時0分0秒000のtime_stampを求めてみる。

// 本日0時0分0秒000のtime_pointを求める
std::chrono::system_clock::time_point day_tp = tp;
// 0時にする
day_tp -= std::chrono::hours( t->tm_hour );
// 0分にする
day_tp -= std::chrono::minutes( t->tm_min );
// 0秒にする
day_tp -= std::chrono::seconds( t->tm_sec );
// コンマ0秒にする
day_tp -= std::chrono::milliseconds( msec );

// 本日0時0分0秒000のtime_pointを求める

std::chrono::system_clock::time_point day_tp = tp;

// 0時にする

day_tp -= std::chrono::hours( t->tm_hour );

// 0分にする

day_tp -= std::chrono::minutes( t->tm_min );

// 0秒にする

day_tp -= std::chrono::seconds( t->tm_sec );

// コンマ0秒にする

day_tp -= std::chrono::milliseconds( msec );

time_point同士の減算から本日の経過ミリ秒を求める。

std::chrono::milliseconds
    tp_msec_today = std::chrono::duration_cast<std::chrono::milliseconds>
                    ( tp - day_tp );
int msec_today = tp_msec_today.count();

std::chrono::milliseconds

tp_msec_today = std::chrono::duration_cast<std::chrono::milliseconds>

( tp - day_tp );

int msec_today = tp_msec_today.count();

以下、まとめてシンプルに。

#include <chrono>

using namespace std::chrono;

//現在時刻を取得
system_clock::time_point tp = system_clock::now();
//現在時刻のミリ秒部分を取得
auto msec = duration_cast<milliseconds>( tp.time_since_epoch() ).count()
		  % 1000;
//時間・分・秒を得るためtime_tに変換
time_t time = system_clock::to_time_t( tp );
struct tm* t = localtime( &time );

//本日00:00:00:000のtime_pointを計算
system_clock::time_point
	day_start = tp
			  - hours( t->tm_hour )
			  - minutes( t->tm_min )
			  - seconds( t->tm_sec )
			  - milliseconds( msec );
//本日開始時点からの経過ミリ秒を得る
auto msec_tody = duration_cast<milliseconds>( tp - day_start ).count();

#include <chrono>

using namespace std::chrono;

//現在時刻を取得

system_clock::time_point tp = system_clock::now();

//現在時刻のミリ秒部分を取得

auto msec = duration_cast<milliseconds>( tp.time_since_epoch() ).count()

% 1000;

//時間・分・秒を得るためtime_tに変換

time_t time = system_clock::to_time_t( tp );

struct tm* t = localtime( &time );

//本日00:00:00:000のtime_pointを計算

system_clock::time_point

day_start = tp

- hours( t->tm_hour )

- minutes( t->tm_min )

- seconds( t->tm_sec )

- milliseconds( msec );

//本日開始時点からの経過ミリ秒を得る

auto msec_tody = duration_cast<milliseconds>( tp - day_start ).count();

月初めからや年頭からの経過ミリ秒も求めたいが、std::chrono::monthやstd::chrono::yearはc++20で追加予定らしいので、c++11だとすんなりとはいかないようだ。
c++20では、ローカル時間用のtime_pointとか、 1日内の時間情報を取得するクラスtime_of_dayなども追加されるらしく、time_t変換などせずに、もっと楽に取得できるようになるかも。

c++builder10.2.3/Windows10(64bit/1909)で確認。

vectorの要素をloopしながら削除(添え字版)

久しぶりにやるといつも忘れて、Web検索するハメになるけれど、イテレータの使用例ばかり出てくる(気がする)ので、添え字版をメモ。

#include <vector>

std::vector<int> v = { 0, 1, 2, 3, 4, 5, 6 };
for( size_t i = 0; i < v.size(); ) // ここで添え字をインクリメントしない
{
	if( v[i] % 2 )
		v.erase( v.begin() + i );
	else // 削除しないときだけ添え字をインクリメント
		++i;
}

#include <vector>

std::vector<int> v = { 0, 1, 2, 3, 4, 5, 6 };

for( size_t i = 0; i < v.size(); ) // ここで添え字をインクリメントしない

{

if( v[i] % 2 )

v.erase( v.begin() + i );

else // 削除しないときだけ添え字をインクリメント

++i;

}

std::dequeでも同様。

std::accumulateとtemplate

一度どハマりしたことがあるのでメモ。
std::accumulateは、vectorなどコンテナの要素を加算してくれる便利な関数だが、第三引数にちょっと罠がある。
まず特に問題ないサンプル。

#include <vector>
#include <iostream>
#include <numeric>

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace std;
	vector<int> v = { 1, 2, 3 };
	cout << "sum : " << accumulate( v.begin(), v.end(), 0 ) << endl;
}

#include <vector>

#include <iostream>

#include <numeric>

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

{

using namespace std;

vector<int> v = { 1, 2, 3 };

cout << "sum : " << accumulate( v.begin(), v.end(), 0 ) << endl;

}

出力結果 : sum : 6

ところが以下の例だと値が丸められてしまう。

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace std;
	
	vector<double> dbl_v = { 1.1, 2.2, 3.3 };
	cout << "sum : " << accumulate( dbl_v.begin(), dbl_v.end(), 0 ) << endl;
}

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

{

using namespace std;

vector<double> dbl_v = { 1.1, 2.2, 3.3 };

cout << "sum : " << accumulate( dbl_v.begin(), dbl_v.end(), 0 ) << endl;

}

出力結果 : sum : 6

この場合は、第三引数がdoubleでなくてはならない。

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace std;
	
	vector<double> dbl_v = { 1.1, 2.2, 3.3 };
	cout << "sum : " << accumulate( dbl_v.begin(), dbl_v.end(), 0.0 ) << endl;
}

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

{

using namespace std;

vector<double> dbl_v = { 1.1, 2.2, 3.3 };

cout << "sum : " << accumulate( dbl_v.begin(), dbl_v.end(), 0.0 ) << endl;

}

出力結果 : sum : 6.6

テンプレートクラス内などで使う場合はstatic_castを使う。
例えばメンバをvectorで保持するクラスに合計値を出す関数を実装する例。

#include <vector>
#include <numeric>

template <typename T>
class Test
{
private:
	// Member:
	std::vector<T> vals_;
public:
	// Constructor:
	explicit Test( const std::vector<T>& v )
		: vals_(v)
		{}
	// Method:
	T Sum()const
	{
		return std::accumulate( vals_.begin(), vals_.end(), static_cast<T>( 0 ) );
	}
};

#include <vector>

#include <numeric>

template <typename T>

class Test

{

private:

// Member:

std::vector<T> vals_;

public:

// Constructor:

explicit Test( const std::vector<T>& v )

: vals_(v)

{}

// Method:

T Sum()const

{

return std::accumulate( vals_.begin(), vals_.end(), static_cast<T>( 0 ) );

}

};

出力してみる。

#include <iostream>
#include "test_class.h"

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace std;

	vector<int> int_v = { 1, 2, 3 };
	Test<int> int_test( int_v );

	vector<double> dbl_v = { 1.1, 2.2, 3.3 };
	Test<double> dbl_test( dbl_v );

	cout << "sum : " << int_test.Sum() << endl;
	cout << "sum : " << dbl_test.Sum() << endl;

	return 0;
}

#include <iostream>

#include "test_class.h"

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

{

using namespace std;

vector<int> int_v = { 1, 2, 3 };

Test<int> int_test( int_v );

vector<double> dbl_v = { 1.1, 2.2, 3.3 };

Test<double> dbl_test( dbl_v );

cout << "sum : " << int_test.Sum() << endl;

cout << "sum : " << dbl_test.Sum() << endl;

return 0;

}

出力結果：
sum : 6
sum : 6.6

続・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
—————————————-

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