SFXArray

配列を表すクラスです。

#include <SFXArray.h.hpp>

class SFXArray;

SFMTYPEDEFCLASS(SFXArray)

継承図

協調図

解説

配列 ( SFXArray クラスのインスタンス ) の要素は 4 バイト以下のデータでなければいけません。 5 バイト以上の UInt64 型データや Double 型データ、クラスのインスタンスを配列の要素として処理するにはポインターを使います。

// 5 バイト以上のデータやクラスのインスタンスは 
// 配列 ( SFXArray クラスのインスタンス ) の要素にできない 

// SFXArray<SInt64> ar64;           NG
// SFXArray<SFXAnsiString> arstr;   NG

// しかし、5 バイト以上のデータやクラスのインスタンスへのポインターは配列の要素にできる

SFXArray<SInt64Ptr> ar64;        // OK
SFXArray<SFXAnsiStringPtr> arstr;// OK

参照

SFXList | SFXStack | コレクション

メンバ

コンストラクタ/デストラクタ
SFXArray( `Void` ) SFXArray( `UInt16` threshold , `UInt16` cluster ) SFXArray クラスのコンストラクタです。

パブリック関数
`SFCError`	Append( `V` value ) Append( `SFXArray< V > const &` collection ) [非推奨 API ( 廃止予定 API )] 要素を追加します。
`Void`	Clear( `Void` ) 配列を空にします。
`Bool`	Contains( `V` value ) 指定した値と同じ要素が含まれるか判定します。
static `SFXArray< V > const &`	EmptyInstance( `Void` ) 空の配列を取得します。
`Bool`	Equals( `SFXArray< V > const &` collection ) 配列が等しいか比較します。
`SInt32`	FirstIndexOf( `V` value , `SInt32` index = SINT32_MINIMUM ) 先頭から検索して、指定した値と一致する最初の要素のインデックスを取得します。
`V`	Get( `SInt32` index ) 要素を取得します。
`UInt16`	GetCluster( `Void` ) 内部バッファメモリのクラスタサイズを取得します。
`Enumerator`	GetEnumerator( `SInt32` index ) 列挙子を取得します。
`V`	GetFirst( `Void` ) 最初の要素を取得します。
`Enumerator`	GetFirstEnumerator( `Void` ) 最初の要素に対応する列挙子を取得します。
`Iterator`	GetFirstIterator( `Void` ) 最初の要素に対応する反復子を取得します。
`Iterator`	GetIterator( `SInt32` index ) 反復子を取得します。
`V`	GetLast( `Void` ) 最後の要素を取得します。
`Enumerator`	GetLastEnumerator( `Void` ) 最後の要素に対応する列挙子を取得します。
`Iterator`	GetLastIterator( `Void` ) 最後の要素に対応する反復子を取得します。
`SInt32`	GetSize( `Void` ) サイズ(要素数)を取得します。
`UInt16`	GetThreshold( `Void` ) 内部バッファサイズの最小値を取得します。
`SFCError`	Insert( `SInt32` index , `V` value ) Insert( `SInt32` index , `SFXArray< V > const &` collection ) 要素を挿入します。
`SFCError`	InsertFirst( `SFXArray< V > const &` collection ) InsertFirst( `V` value ) 最初に要素を挿入します。
`SFCError`	InsertLast( `SFXArray< V > const &` collection ) InsertLast( `V` value ) 最後に要素を挿入します。
`Bool`	IsEmpty( `Void` ) 配列が空であるか判定します。
`SInt32`	LastIndexOf( `V` value , `SInt32` index = SINT32_MAXIMUM ) 末尾から検索して、指定した値と一致する最後の要素のインデックスを取得します。
`SFCError`	Move( `SInt32` destination , `SInt32` source ) 要素を移動します。
`SFCError`	MoveFirst( `SInt32` source ) 要素を最初に移動します。
`SFCError`	MoveLast( `SInt32` source ) 要素を最後に移動します。
`Void`	Remove( `SInt32` index ) Remove( `SInt32` begin , `SInt32` end ) 指定した位置または範囲の要素を消去します。
`Void`	RemoveFirst( `Void` ) 最初の要素を消去します。
`Void`	RemoveLast( `Void` ) 最後の要素を消去します。
`SFCError`	Set( `SFXArray< V > const &` collection ) Set( `SInt32` index , `V` element ) 要素に値を設定します。または配列を設定します。
`Void`	SetCluster( `UInt16` size ) 内部バッファメモリのクラスタサイズを設定します。
`SFCError`	SetFirst( `V` value ) 最初の要素に値を設定します。
`SFCError`	SetLast( `V` value ) 最後の要素に値を設定します。
`SFCError`	SetSize( `SInt32` size ) 配列のサイズを設定します。
`Void`	SetThreshold( `UInt16` size ) 内部バッファサイズの最小値を設定します。
`SFCError`	Swap( `SInt32` destination , `SInt32` source ) 要素を交換します。
`SFCError`	SwapFirst( `SInt32` source ) 最初の要素と交換します。
`SFCError`	SwapLast( `SInt32` source ) 最後の要素と交換します。
`V &`	operator[]( `SInt32` index ) 指定した位置の要素を取得します。
`V const &`	operator[]( `SInt32` index ) 指定した位置の要素を取得します。

型
DefaultEnum 内部で使うヒープサイズの閾値とクラスタサイズの既定値を表します。
Enumerator 列挙子を保持するクラスです。
Iterator 反復子を保持するクラスです。

SFXArray::SFXArray

SFXArray クラスのコンストラクタです。

[ public, explicit ]
SFXArray(Void);

[ public, explicit ]
SFXArray(
    UInt16 threshold   // バッファ サイズの最小値
    UInt16 cluster     // クラスタ サイズ
);

解説

配列を構築する時に、予め要素数が分かっている場合は、初期サイズを指定すると性能が向上します。　　　メモリ再割り当てを回避できるからです。

参照

SFXArray::Set

SFXArray::Append

[非推奨 API ( 廃止予定 API )] 要素を追加します。

[ public ]
SFCError Append(
    V value   // 追加する要素
);

[ public ]
SFCError Append(
    SFXArray< V > const & collection   // 追加する配列
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき : SFERR_NO_MEMOERY
失敗したとき : SFERR_FAILED

解説

配列の最後に要素を追加します。この関数は非推奨関数です。替わりに SFXArray::InsertLast 関数を利用してください。

	非推奨 API ( 廃止予定 API )
	この API は、SophiaFramework UNIVERSE 6.0 では廃止される予定です。この API の替わりに `SFXArray::InsertLast` 関数を利用することを推奨します。

使用例

SFXArray<SInt16> array;
SInt16 i;

// 要素を追加する
if (array.Append(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.Append(5) == SFERR_NO_ERROR) {
        // インデックスを元にデータを列挙する
        for (i = 0; i < array.GetSize(); ++i) {
            TRACE("%d", array[i]);  // 2 5 
        }
    }
}

参照

SFXArray::Insert | SFXArray::InsertLast | SFXArray::Get | SFXArray::Remove | SFXArray::Set

SFXArray::Clear

配列を空にします。

[ public ]
Void Clear(Void);

解説

格納されている要素がクラスのインスタンスへのポインターの場合、そのインスタンスは自動的に解放されません。

使用例

SFXArray<SInt16> array;
    
...
     
array.Clear();    // すべてのデータと管理用メモリを解放する

参照

SFXArray::Remove

SFXArray::Contains

指定した値と同じ要素が含まれるか判定します。

[ public, const ]
Bool Contains(
    V value   // 含まれるか調べる値
);

戻り値

含まれるとき : true
含まれないとき : false

解説

要素がクラスのインスタンスへのポインターの場合、アドレスを比較します。

使用例

SFXArray<SInt16> array;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 指定した値と同じ要素が含まれるか判定する
        TRACE("Contains(2) = %s", (array.Contains(2)) ? ("true") : ("false"));  // Contains(2) = true
        TRACE("Contains(4) = %s", (array.Contains(4)) ? ("true") : ("false"));  // Contains(4) = false
    }
}

参照

SFXArray::FirstIndexOf

SFXArray::EmptyInstance

空の配列を取得します。

[ public, static ]
SFXArray< V > const & EmptyInstance(Void);

解説

空の配列を表すインスタンスを取得します。

SFXArray::Equals

配列が等しいか比較します。

[ public, const ]
Bool Equals(
    SFXArray< V > const & collection   // 比較する配列
);

戻り値

等しいとき : true
異なるとき : false

解説

2 つの配列に同じ要素が同じ順で格納されているか調べます。

格納されている要素がクラスのインスタンスへのポインターの場合、アドレスを比較します。

SFXArray::FirstIndexOf

先頭から検索して、指定した値と一致する最初の要素のインデックスを取得します。

[ public, const ]
SInt32 FirstIndexOf(
    V value                         // 検索する値
    SInt32 index = SINT32_MINIMUM   // 検索開始位置
);

戻り値

成功したとき : 見つかった位置の最初のインデックス
失敗したとき : -1

解説

要素を先頭から末尾に向かって検索し、最初に見つかった位置のインデックスを取得します。

検索開始位置を指定することで、先頭以外の位置から検索できます。

格納されている要素がクラスのインスタンスへのポインターの場合、アドレスを比較します。

使用例

SFXArray<SInt16> array;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 先頭から検索して、指定した値と一致する最初の要素のインデックスを取得する
        TRACE("FirstIndexOf(1) = %d", array.FirstIndexOf(1));  // FirstIndexOf(1) = -1
        TRACE("FirstIndexOf(2) = %d", array.FirstIndexOf(2));  // FirstIndexOf(2) = 0
        TRACE("FirstIndexOf(5) = %d", array.FirstIndexOf(5));  // FirstIndexOf(5) = 1
    }
}

参照

SFXArray::Contains | SFXArray::LastIndexOf

SFXArray::Get

要素を取得します。

[ public, const ]
V Get(
    SInt32 index   // 取得する要素の位置
);

参照

SFXArray::GetFirst | SFXArray::GetLast | SFXArray::Insert | SFXArray::Remove | SFXArray::Set

SFXArray::GetCluster

内部バッファメモリのクラスタサイズを取得します。

[ public, const ]
UInt16 GetCluster(Void);

参照

SFXArray::SetCluster

SFXArray::GetEnumerator

列挙子を取得します。

[ public, const ]
Enumerator GetEnumerator(
    SInt32 index   // 開始位置
);

参照

SFXArray::GetIterator | SFXArray::Enumerator

SFXArray::GetFirst

最初の要素を取得します。

[ public, const ]
V GetFirst(Void);

参照

SFXArray::Get | SFXArray::GetLast

SFXArray::GetFirstEnumerator

最初の要素に対応する列挙子を取得します。

[ public, const ]
Enumerator GetFirstEnumerator(Void);

使用例

SFXArray<SInt16> array;
SFXArray<SInt16>::Enumerator en;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する列挙子を取得する
        en = array.GetFirstEnumerator();
        
        // 次の要素があるか判定する
        while(en.HasNext()) {
            TRACE("%d", en.GetNext());  // 2 5 
        }
    }
}

参照

SFXArray::GetFirstIterator | SFXArray::Enumerator

SFXArray::GetFirstIterator

最初の要素に対応する反復子を取得します。

[ public ]
Iterator GetFirstIterator(Void);

使用例

SFXArray<SInt16> array;
SFXArray<SInt16>::Iterator it;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する反復子を取得する
        it = array.GetFirstIterator();
        
        // 次の要素があるか判定する
        while(it.HasNext()) {
            TRACE("%d", it.GetNext());  // 2 5 
        }
    }
}

参照

SFXArray::GetFirstEnumerator | SFXArray::Iterator

SFXArray::GetIterator

反復子を取得します。

[ public ]
Iterator GetIterator(
    SInt32 index   // 開始位置
);

参照

SFXArray::GetEnumerator | SFXArray::Iterator

SFXArray::GetLast

最後の要素を取得します。

[ public, const ]
V GetLast(Void);

参照

SFXArray::Get | SFXArray::GetFirst

SFXArray::GetLastEnumerator

最後の要素に対応する列挙子を取得します。

[ public, const ]
Enumerator GetLastEnumerator(Void);

参照

SFXArray::GetLastIterator | SFXArray::Enumerator

SFXArray::GetLastIterator

最後の要素に対応する反復子を取得します。

[ public ]
Iterator GetLastIterator(Void);

参照

SFXArray::GetLastEnumerator | SFXArray::Iterator

SFXArray::GetSize

サイズ(要素数)を取得します。

[ public, const ]
SInt32 GetSize(Void);

使用例

SFXArray<SInt16> array;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
            // サイズ(要素数)を表示する
            TRACE("%d",array.GetSize());  // 2
    }
}

参照

SFXArray::SetSize

SFXArray::GetThreshold

内部バッファサイズの最小値を取得します。

[ public, const ]
UInt16 GetThreshold(Void);

参照

SFXArray::SetThreshold

SFXArray::Insert

要素を挿入します。

[ public ]
SFCError Insert(
    SInt32 index   // 挿入する位置
    V value        // 挿入する要素の値
);

[ public ]
SFCError Insert(
    SInt32 index                       // 挿入する位置
    SFXArray< V > const & collection   // 挿入する配列
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき: SFERR_NO_MEMOERY
失敗したとき : SFERR_FAILED

解説

指定した位置に要素を挿入します。

挿入する位置が有効でない場合は、自動的に有効な範囲に修正されます。

使用例

SFXArray<SInt16> array;
SInt16 i;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 最初の位置に要素を挿入する
        if (array.Insert(0, 3) == SFERR_NO_ERROR) {
            // 要素を挿入する
            // 指定したインデックスが有効でない場合、要素は有効な位置に挿入される
            if (array.Insert(10, 4) == SFERR_NO_ERROR) {
                // インデックスを元に要素を列挙する
                for (i = 0; i < array.GetSize(); ++i) {
                    TRACE("%d", array[i]);  // 3 2 5 4
               }
           }
       }
    }
}

参照

SFXArray::Get | SFXArray::InsertFirst | SFXArray::InsertLast | SFXArray::Remove | SFXArray::Set

SFXArray::InsertFirst

最初に要素を挿入します。

[ public ]
SFCError InsertFirst(
    SFXArray< V > const & collection   // 挿入する配列
);

[ public ]
SFCError InsertFirst(
    V value   // 挿入する要素の値
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき: SFERR_NO_MEMOERY
失敗したとき : SFERR_FAILED

参照

SFXArray::Insert | SFXArray::InsertLast

SFXArray::InsertLast

最後に要素を挿入します。

[ public ]
SFCError InsertLast(
    SFXArray< V > const & collection   // 挿入する配列
);

[ public ]
SFCError InsertLast(
    V value   // 挿入する要素の値
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき: SFERR_NO_MEMOERY
失敗したとき : SFERR_FAILED

参照

SFXArray::Insert | SFXArray::InsertFirst

SFXArray::IsEmpty

配列が空であるか判定します。

[ public, const ]
Bool IsEmpty(Void);

戻り値

空のとき : true
空でないとき : false

SFXArray::LastIndexOf

末尾から検索して、指定した値と一致する最後の要素のインデックスを取得します。

[ public, const ]
SInt32 LastIndexOf(
    V value                         // 検索する値
    SInt32 index = SINT32_MAXIMUM   // 検索開始位置
);

戻り値

成功したとき : 見つかった位置の最後のインデックス
失敗したとき : -1

解説

要素を末尾から先頭に向かって検索し、最初に見つかった位置のインデックスを取得します

検索開始位置を指定することで、末尾以外の位置から検索できます。

格納されている要素がクラスのインスタンスへのポインターの場合、アドレスを比較します。

使用例

SFXArray<SInt16> array;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 末尾から検索して、指定した値と一致する最後の要素のインデックスを取得する
        TRACE("LastIndexOf(1) = %d", array.LastIndexOf(1));  // LastIndexOf(1) = -1
        TRACE("LastIndexOf(2) = %d", array.LastIndexOf(2));  // LastIndexOf(2) = 0
        TRACE("LastIndexOf(5) = %d", array.LastIndexOf(5));  // LastIndexOf(5) = 1
    }
}

参照

SFXArray::Contains | SFXArray::FirstIndexOf

SFXArray::Move

要素を移動します。

[ public ]
SFCError Move(
    SInt32 destination   // 移動先の位置
    SInt32 source        // 移動元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::MoveFirst | SFXArray::MoveLast

SFXArray::MoveFirst

要素を最初に移動します。

[ public ]
SFCError MoveFirst(
    SInt32 source   // 移動元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
要素が空のとき : SFERR_INVALID_STATE
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::Move | SFXArray::MoveLast

SFXArray::MoveLast

要素を最後に移動します。

[ public ]
SFCError MoveLast(
    SInt32 source   // 移動元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
要素が空のとき : SFERR_INVALID_STATE
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::Move | SFXArray::MoveFirst

SFXArray::Remove

指定した位置または範囲の要素を消去します。

[ public ]
Void Remove(
    SInt32 index   // 消去する位置
);

[ public ]
Void Remove(
    SInt32 begin   // 消去開始位置
    SInt32 end     // 消去終了位置
);

使用例

SFXArray<SInt16> array;
SInt16 i;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 最初の位置に要素を挿入する
        if (array.Insert(0, 3) == SFERR_NO_ERROR) {
            // 要素を挿入する
            // 指定したインデックスが有効でない場合、要素は有効な位置に挿入される
            if (array.Insert(10, 4) == SFERR_NO_ERROR) {

                // array[1] から array[2] までを削除する
                array.Remove(1, 3);

                // インデックスを元に要素を列挙する
                for (i = 0; i < array.GetSize(); ++i) {
                    TRACE("%d", array[i]);  // 3 4
               }
           }
       }
    }
}

参照

SFXArray::Insert | SFXArray::Get | SFXArray::Set

SFXArray::RemoveFirst

最初の要素を消去します。

[ public ]
Void RemoveFirst(Void);

参照

SFXArray::Remove | SFXArray::RemoveLast

SFXArray::RemoveLast

最後の要素を消去します。

[ public ]
Void RemoveLast(Void);

参照

SFXArray::Remove | SFXArray::RemoveFirst

SFXArray::Set

要素に値を設定します。または配列を設定します。

[ public ]
SFCError Set(
    SFXArray< V > const & collection   // 設定する配列
);

[ public ]
SFCError Set(
    SInt32 index   // 設定する位置
    V element      // 設定する値
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき : SFERR_NO_MEMOERY
引数が不正なとき : SFERR_INVALID_PARAM
失敗したとき : SFERR_INVALID_STATE

使用例

SFXArray<SInt16> array;
SInt16 i;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        // 要素に値を設定する
        if (array.Set(1, 10) == SFERR_NO_ERROR) {
            // インデックスを元に要素を列挙する
            for (i = 0; i < array.GetSize(); ++i) {
                TRACE("%d", array[i]);  // 2 10
           }
       }
    }
}

参照

SFXArray::Get | SFXArray::Insert | SFXArray::Remove

SFXArray::SetCluster

内部バッファメモリのクラスタサイズを設定します。

[ public ]
Void SetCluster(
    UInt16 size   // 設定するクラスタ サイズ
);

参照

SFXArray::GetCluster

SFXArray::SetFirst

最初の要素に値を設定します。

[ public ]
SFCError SetFirst(
    V value   // 設定する値
);

戻り値

成功したとき : SFERR_NO_ERROR
失敗したとき : SFERR_INVALID_STATE

参照

SFXArray::GetFirst

SFXArray::SetLast

最後の要素に値を設定します。

[ public ]
SFCError SetLast(
    V value   // 設定する値
);

戻り値

成功したとき : SFERR_NO_ERROR
失敗したとき : SFERR_INVALID_STATE

参照

SFXArray::GetLast

SFXArray::SetSize

配列のサイズを設定します。

[ public ]
SFCError SetSize(
    SInt32 size   // 設定するサイズ
);

戻り値

成功したとき : SFERR_NO_ERROR
メモリ不足のとき : SFERR_NO_MEMOERY

解説

現在の配列のサイズよりも設定するサイズが小さいと、そのサイズ以降の要素は消去されます。

参照

SFXArray::GetSize

SFXArray::SetThreshold

内部バッファサイズの最小値を設定します。

[ public ]
Void SetThreshold(
    UInt16 size   // 設定する最小値
);

参照

SFXArray::GetThreshold

SFXArray::Swap

要素を交換します。

[ public ]
SFCError Swap(
    SInt32 destination   // 交換先の位置
    SInt32 source        // 交換元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::SwapFirst | SFXArray::SwapLast

SFXArray::SwapFirst

最初の要素と交換します。

[ public ]
SFCError SwapFirst(
    SInt32 source   // 交換元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
要素が空のとき : SFERR_INVALID_STATE
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::Swap | SFXArray::SwapLast

SFXArray::SwapLast

最後の要素と交換します。

[ public ]
SFCError SwapLast(
    SInt32 source   // 交換元の位置
);

戻り値

成功したとき : SFERR_NO_ERROR
要素が空のとき : SFERR_INVALID_STATE
引数が不正なとき : SFERR_INVALID_PARAM

参照

SFXArray::Swap | SFXArray::SwapFirst

SFXArray::operator[]

指定した位置の要素を取得します。

[ public ]
V & operator[](
    SInt32 index   // 取得する要素の位置
);

[ public, const ]
V const & operator[](
    SInt32 index   // 取得する要素の位置
);

参照

SFXArray::Get | SFXArray::Set

SFXArray::DefaultEnum

内部で使うヒープサイズの閾値とクラスタサイズの既定値を表します。

enum DefaultEnum {
    DEFAULT_THRESHOLD = 4 * sizeof(VoidPtr),      // ヒープ サイズの閾値
    DEFAULT_CLUSTER   = 8 * sizeof(VoidPtr)       // 既定のクラスタ サイズ
};

参照

SFXClusterHeap

SFXArray::Enumerator

列挙子を保持するクラスです。

[ public ]

SFMTYPEDEFCLASS(Enumerator)
friend class Enumerator;
class Enumerator  {
    public:
        explicit            Enumerator          (Void) : Enumeratoa();
                            Enumerator          (IteratorConstRef iterator) : Enumeratoa(iterator);
        EnumeratorRef       operator=           (IteratorConstRef iterator);
        V                   GetNext             (Void);
        V                   GetPrevious         (Void);
        Bool                HasNext             (Void) const;
        Bool                HasPrevious         (Void) const;
        Bool                IsValid             (Void) const;
};

解説

Enumerator クラスは、列挙子を保持するクラスです。

以下のメンバ関数を持ちます。

GetNext	次の要素を取得します。要素がない場合 null を返します。
GetPrevious	前の要素を取得します。要素がない場合 null を返します。
HasNext	次の要素があるか調べます。
HasPrevious	前の要素があるか調べます。
IsValid	列挙子が有効であるか判定します。

使用例

SFXArray<SInt16> array;
SFXArray<SInt16>::Enumerator en;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する列挙子を取得する
        en = array.GetFirstEnumerator();
        
        // 次の要素があるか判定する
        while(en.HasNext()) {
            TRACE("%d", en.GetNext());  // 2 5 
        }
    }

参照

SFXArray::Iterator

SFXArray::Iterator

反復子を保持するクラスです。

[ public ]

SFMTYPEDEFCLASS(Iterator)
friend class Iterator;
class Iterator  {
    public:
        explicit            Iterator            (Void) : Iteratoa();
        SFCError            Set                 (V value);
        V                   GetNext             (Void);
        V                   GetPrevious         (Void);
        Bool                HasNext             (Void) const;
        Bool                HasPrevious         (Void) const;
        Bool                IsValid             (Void) const;
        SFCError            Insert              (V value);
        Vold                Remove              (Void);

    friend      class               Enumerator;
};

解説

Iterator クラスは、反復子を保持するクラスです。

以下のメンバ関数を持ちます。

Set	反復子が指す要素に値を設定します。
GetNext	次の要素を取得します。要素がない場合 null を返します。
GetPrevious	前の要素を取得します。要素がない場合 null を返します。
HasNext	次の要素があるか調べます。
HasPrevious	前の要素があるか調べます。
IsValid	反復子が有効であるか判定します。
Insert	反復子が指す要素の次に要素を挿入します。
Remove	反復子が指す要素を削除します。

使用例

SFXArray<SInt16> array;
SFXArray<SInt16>::Iterator it;

// 要素を追加する
if (array.InsertLast(2) == SFERR_NO_ERROR) {
    // 要素を追加する
    if (array.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する反復子を取得する
        it = array.GetFirstIterator();
        
        // 次の要素があるか判定する
        while(it.HasNext()) {
            TRACE("%d", it.GetNext());  // 2 5 
        }
    }
}

参照

SFXArray::Enumerator