SFXStack

スタックを表すクラスです。

#include <SFXStack.h.hpp>

class SFXStack;

SFMTYPEDEFCLASS(SFXStack)

継承図

協調図

解説

SFXStack は、最後に追加した要素を最初に取り出すためのデータ構造です。 SFXStack は、SFXArray の基底クラスを継承し、内部的には配列として処理されます。配列の最後の要素がスタックの先頭要素であり、配列のサイズがスタックのサイズです。

デフォルトの設定では、最初に要素を追加したときに SFXStack::SetThreshold 関数で設定するサイズ(デフォルトでは 4 要素分)の内部バッファが確保されます。その後、順次要素を追加していったとき、要素を格納する領域が不足する場合は、 SFXStack::SetCluster 関数で設定するクラスタサイズ単位(デフォルトでは 8 要素分)で内部バッファは拡張されます。逆に、要素が削除されたときは、クラスタサイズ単位でまとめてメモリ再割り当てが実行され、メモリが解放されます。因みに、1 要素のサイズは 4 バイトです。

内部バッファの拡張は、クラスタサイズ分だけ大きくした連続したメモリ領域が新たに確保され、そこに既存の全要素がコピーされます。頻繁にメモリ再割り当てを行うと、パフォーマンス劣化の一因になります。

予め要素数が分かっている場合は、 SFXStack::SetThreshold / SFXStack::SetCluster 関数を使用して内部バッファの設定を最適化することを推奨します。

	注意
	`SFXStack::SetSize` 関数を呼び出すと、スタックは指定したサイズに設定されます。値が設定されていない要素は 0 で初期化されます(既存の要素の値はそのままです)。内部的には、配列で実装されており、配列の最後の要素がスタックの先頭の要素になります。

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

// 5 バイト以上のデータやクラスインスタンスは、スタックの要素に格納できない
// SFXStack<SInt64> st64;           NG
// SFXStack<SFXAnsiString> ststr;   NG

// ポインタはスタックの要素に格納できる
// 5 バイト以上のデータをスタックの要素にしたい場合は、ポインタを利用する
SFXStack<SInt64Ptr> st64;        // OK
SFXStack<SFXAnsiStringPtr> ststr;// OK

参照

SFXArray | SFXList | スタック

メンバ

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

パブリック関数
`SFCError`	Append( `SFXStack< V > const &` collection ) [廃止予定] 要素を追加します。
`SFCError`	Append( `V` value ) [廃止予定] 要素を追加します。
`Void`	Clear( `Void` ) スタックを空にします。
`Bool`	Contains( `V` value ) 指定された値と同じ要素が含まれるか判定します。
static `SFXStack< V > const &`	EmptyInstance( `Void` ) 空のスタックを取得します。
`Bool`	Equals( `SFXStack< 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 , `SFXStack< V > const &` collection ) 要素またはスタックを挿入します。
`SFCError`	Insert( `SInt32` index , `V` value ) 要素またはスタックを挿入します。
`SFCError`	InsertFirst( `SFXStack< V > const &` collection ) 先頭に要素またはスタックを挿入します。
`SFCError`	InsertFirst( `V` value ) 先頭に要素またはスタックを挿入します。
`SFCError`	InsertLast( `SFXStack< V > const &` collection ) 末尾に要素またはスタックを挿入します。
`SFCError`	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 ) 要素を最後に移動します。
`V`	Peek( `Void` ) トップの要素を取得します。
`V`	Pop( `Void` ) スタックの先頭要素を取り出します。
`SFCError`	Push( `V` value ) スタックに要素を追加します。
`Void`	Remove( `SInt32` index ) 指定されたインデックスの位置または範囲にある要素を削除します。
`Void`	Remove( `SInt32` begin , `SInt32` end ) 指定されたインデックスの位置または範囲にある要素を削除します。
`Void`	RemoveFirst( `Void` ) 先頭の要素を削除します。
`Void`	RemoveLast( `Void` ) 末尾の要素を削除します。
`SInt32`	Search( `V` value ) 指定された値の要素をスタックのトップから検索します。
`SFCError`	Set( `SFXStack< V > const &` collection ) 要素に値を設定します。またはスタックを設定します。
`SFCError`	Set( `SInt32` index , `V` value ) 要素に値を設定します。またはスタックを設定します。
`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 ) 指定された 2 つの要素を交換します。
`SFCError`	SwapFirst( `SInt32` source ) 指定された要素と先頭の要素を交換します。
`SFCError`	SwapLast( `SInt32` source ) 指定された要素と末尾の要素を交換します。
`V &`	operator[]( `SInt32` index ) 指定された位置の要素を取得します。
`V const &`	operator[]( `SInt32` index ) 指定された位置の要素を取得します。

型
DefaultEnum 内部バッファメモリの最小値とクラスタサイズのデフォルト値を表します。[単位: バイト]
Enumerator 列挙子を保持するクラスです。
Iterator 反復子を保持するクラスです。

SFXStack::SFXStack

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

[ public, explicit ]
SFXStack(Void);

[ public, explicit ]
SFXStack(
    UInt16 threshold   // 内部バッファメモリの最小値
    UInt16 cluster     // クラスタサイズ
);

SFXStack::Append

[廃止予定] 要素を追加します。

[ public ]
SFCError Append(
    SFXStack< V > const & collection   // 追加するスタック
);

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

戻り値

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

解説

スタックの最後に要素を追加します。この関数は非推奨関数です。替わりに SFXStack::InsertLast 関数を使用してください。

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

使用例

SFXStack<SInt08> stack;
SInt16 i;

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

参照

SFXStack::Clear

スタックを空にします。

[ public ]
Void Clear(Void);

解説

この関数は、スタックを空にします。スタックに割り当てられていた内部バッファはすべて解放されます。

この関数を実行した後、スタックのサイズは 0 になります。

	注意
要素がクラスインスタンスや 4 バイトよりも大きなデータへのポインタの場合、ポインタが指すメモリ領域は解放されません。スタックをクリアする前に、 delete 文を使用して明示的にその領域を解放する必要があります。さもなければ、メモリリークが発生します。

注意

要素がクラスインスタンスや 4 バイトよりも大きなデータへのポインタの場合、ポインタが指すメモリ領域は解放されません。

スタックをクリアする前に、 delete 文を使用して明示的にその領域を解放する必要があります。さもなければ、メモリリークが発生します。

	注意
	この関数は、このスタックがスコープから外れるタイミングで自動的に呼び出されます。

使用例

SFXStack<SInt08> stack;
    
...
     
stack.Clear();    // スタックを空にする

参照

SFXStack::Remove | SFXStack::SetCluster | SFXStack::SetThreshold | SFXStack::GetSize

SFXStack::Contains

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

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

戻り値

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

解説

この関数は、このスタックに指定された値と同じ要素が含まれるか判定します。

	注意
	要素がポインタの場合、アドレスを比較します。

使用例

SFXStack<SInt08> stack;

// 要素をプッシュする
if (stack.Push(2) == SFERR_NO_ERROR) {

    // 要素をプッシュする
    if (stack.Push(5) == SFERR_NO_ERROR) {

        // 指定した値と同じ要素が含まれるか判定する
        TRACE("Contains(2) = %s", (stack.Contains(2)) ? ("true") : ("false"));  // Contains(2) = true
        TRACE("Contains(4) = %s", (stack.Contains(4)) ? ("true") : ("false"));  // Contains(4) = false
    }
}

参照

SFXStack::FirstIndexOf | SFXStack::LastIndexOf

SFXStack::EmptyInstance

空のスタックを取得します。

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

解説

空のスタックを表すインスタンスを取得します。

SFXStack::Equals

指定されたスタックと等しいか判定します。

[ public, const ]
Bool Equals(
    SFXStack< V > const & collection   // 比較するスタック
);

戻り値

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

解説

この関数は、このスタックが指定されたスタックと等しいか（同じ要素が同じ順で格納されているか）を判定します。

	注意
	要素がポインタの場合、アドレスを比較します。

SFXStack::FirstIndexOf

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

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

戻り値

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

解説

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

開始位置を指定することで、先頭以外の任意の位置から検索できます（先頭のインデックスは 0 です）。

	注意
	要素がポインタである場合、アドレスを比較します。

使用例

SFXStack<SInt08> stack;

// 要素を追加する
if (stack.Push(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.Push(5) == SFERR_NO_ERROR) {

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

参照

SFXStack::Contains | SFXStack::LastIndexOf | SFXStack::Search

SFXStack::Get

指定された位置にある要素を取得します。

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

戻り値

指定された位置にある要素。要素が存在しない場合は、0 または null。

解説

この関数は、指定された位置にある要素を取得します。

	注意
	指定された位置に要素が存在しない場合、エラーは発生せず、この関数は 0 または null を返します。

参照

SFXStack::GetFirst | SFXStack::GetLast | SFXStack::Insert | SFXStack::Remove | SFXStack::Set

SFXStack::GetCluster

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

[ public, const ]
UInt16 GetCluster(Void);

戻り値

内部バッファメモリのクラスタサイズ[単位: バイト]

解説

この関数は、内部バッファメモリを確保する時の最小単位（クラスタサイズ）を取得します。[単位: バイト]

参照

SFXStack::SetCluster

SFXStack::GetEnumerator

列挙子を取得します。

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

戻り値

指定された要素に対応する列挙子

解説

この関数は、このスタックの指定された要素に対応する列挙子を取得します。

注意

	注意
引数に 0 以下の値を指定した場合、この関数は `SFXStack::GetFirstEnumerator` 関数と同等です。引数にこのスタックのサイズ以上の値を指定した場合、この関数は `SFXStack::GetLastEnumerator` 関数と同等です。

引数に 0 以下の値を指定した場合、この関数は SFXStack::GetFirstEnumerator 関数と同等です。

引数にこのスタックのサイズ以上の値を指定した場合、この関数は SFXStack::GetLastEnumerator 関数と同等です。

参照

SFXStack::GetFirst

先頭の要素を取得します。

[ public, const ]
V GetFirst(Void);

戻り値

最初の位置にある要素。要素が存在しない場合は、0 または null。

解説

この関数は、先頭の要素を取得します。

	注意
	要素が存在しない場合、エラーは発生せず、この関数は 0 または null を返します。

参照

SFXStack::Get | SFXStack::GetLast | SFXStack::InsertFirst | SFXStack::RemoveFirst

SFXStack::GetFirstEnumerator

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

[ public, const ]
Enumerator GetFirstEnumerator(Void);

戻り値

最初の要素に対応する列挙子。

解説

この関数は、このスタックの最初の要素に対応する列挙子を取得します。

使用例

SFXStack<SInt08> stack;
SFXStack<SInt08>::Enumerator en;

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

参照

SFXStack::GetEnumerator | SFXStack::GetFirstIterator | SFXStack::Enumerator

SFXStack::GetFirstIterator

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

[ public ]
Iterator GetFirstIterator(Void);

戻り値

最初の要素に対応する反復子。

解説

この関数は、このスタックの最初の要素に対応する反復子を取得します。

使用例

SFXStack<SInt08> stack;
SFXStack<SInt08>::Iterator it;

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

参照

SFXStack::GetIterator | SFXStack::GetFirstEnumerator | SFXStack::Iterator

SFXStack::GetIterator

反復子を取得します。

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

戻り値

指定された要素に対応する反復子

解説

この関数は、このスタックの指定された要素に対応する反復子を取得します。

注意

	注意
引数に 0 以下の値を指定した場合、この関数は `SFXStack::GetFirstIterator` 関数と同等です。引数にこのスタックのサイズ以上の値を指定した場合、この関数は `SFXStack::GetLastIterator` 関数と同等です。

引数に 0 以下の値を指定した場合、この関数は SFXStack::GetFirstIterator 関数と同等です。

引数にこのスタックのサイズ以上の値を指定した場合、この関数は SFXStack::GetLastIterator 関数と同等です。

参照

SFXStack::GetFirstIterator | SFXStack::GetLastIterator | SFXStack::GetEnumerator | SFXStack::Iterator

SFXStack::GetLast

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

[ public, const ]
V GetLast(Void);

戻り値

最後の位置にある要素。要素が存在しない場合は、0 または null。

解説

この関数は、最後の位置にある要素を取得します。

	注意
	要素が存在しない場合、エラーは発生せず、この関数は 0 または null を返します。

参照

SFXStack::Get | SFXStack::GetFirst | SFXStack::Peek | SFXStack::InsertLast | SFXStack::RemoveLast

SFXStack::GetLastEnumerator

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

[ public, const ]
Enumerator GetLastEnumerator(Void);

戻り値

最後の要素に対応する列挙子。

解説

この関数は、このスタックの最後の要素に対応する列挙子を取得します。

参照

SFXStack::GetEnumerator | SFXStack::GetLastIterator | SFXStack::Enumerator

SFXStack::GetLastIterator

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

[ public ]
Iterator GetLastIterator(Void);

戻り値

最後の要素に対応する反復子。

解説

この関数は、このスタックの最後の要素に対応する反復子を取得します。

参照

SFXStack::GetIterator | SFXStack::GetLastEnumerator | SFXStack::Iterator

SFXStack::GetSize

スタックのサイズを取得します。

[ public, const ]
SInt32 GetSize(Void);

戻り値

このスタックのサイズ(要素数)

解説

この関数は、このスタックのサイズ(要素数)を取得します。

使用例

SFXStack<SInt08> stack;
SInt16 i;

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

参照

SFXStack::SetSize

SFXStack::GetThreshold

内部バッファメモリの最小値を取得します。[単位: バイト]

[ public, const ]
UInt16 GetThreshold(Void);

戻り値

内部バッファメモリの最小値[単位: バイト]

解説

この関数は、内部バッファメモリの最小値を取得します。[単位: バイト]

参照

SFXStack::SetThreshold

SFXStack::Insert

要素またはスタックを挿入します。

[ public ]
SFCError Insert(
    SInt32 index                       // 挿入する位置
    SFXStack< V > const & collection   // 挿入するスタック
);

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

戻り値

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

解説

この関数は、指定されたインデックスの位置に指定した値の要素またはスタックを挿入します。

インデックスが 0 以下の場合は最初に挿入されます。

インデックスが要素数以上の場合は最後に挿入されます。

使用例

SFXStack<SInt08> stack;
SInt16 i;

// 要素を追加する
if (stack.InsertLast(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.InsertLast(5) == SFERR_NO_ERROR) {

        // 最初の位置に要素を挿入する
        if (stack.Insert(0, 3) == SFERR_NO_ERROR) {

            // 要素を挿入する
            // 指定したインデックスが有効でない場合、要素は有効な位置に挿入される
            if (stack.Insert(10, 4) == SFERR_NO_ERROR) {

                // インデックスを元にデータを列挙する
                for (i = 0; i < stack.GetSize(); ++i) {

                    TRACE("%d", stack[i]);  // 3 2 5 4
               }
           }
       }
    }

参照

SFXStack::InsertFirst | SFXStack::InsertLast | SFXStack::Set | SFXStack::Get | SFXStack::Remove

SFXStack::InsertFirst

先頭に要素またはスタックを挿入します。

[ public ]
SFCError InsertFirst(
    SFXStack< V > const & collection   // 挿入するスタック
);

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

戻り値

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

解説

この関数は、先頭に指定された要素またはスタックを挿入します。

参照

SFXStack::Insert | SFXStack::InsertLast | SFXStack::RemoveFirst | SFXStack::GetFirst

SFXStack::InsertLast

末尾に要素またはスタックを挿入します。

[ public ]
SFCError InsertLast(
    SFXStack< V > const & collection   // 挿入するスタック
);

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

戻り値

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

解説

この関数は、末尾に指定された要素またはスタックを挿入します。

参照

SFXStack::Insert | SFXStack::InsertFirst | SFXStack::Push | SFXStack::GetLast | SFXStack::RemoveLast

SFXStack::IsEmpty

スタックが空であるか判定します。

[ public, const ]
Bool IsEmpty(Void);

戻り値

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

解説

この関数は、このスタックが空であるか判定します。

SFXStack::LastIndexOf

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

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

戻り値

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

解説

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

開始位置を指定することで、末尾以外の任意の位置から検索できます（先頭のインデックスは 0 です）。

	注意
	要素がポインタである場合、アドレスを比較します。

使用例

SFXStack<SInt08> stack;

// 要素を追加する
if (stack.Push(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.Push(5) == SFERR_NO_ERROR) {

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

参照

SFXStack::Contains | SFXStack::FirstIndexOf | SFXStack::Search

SFXStack::Move

要素を移動します。

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

戻り値

成功したとき: SFERR_NO_ERROR
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された位置にある要素を指定した位置に移動します。

参照

SFXStack::MoveFirst | SFXStack::MoveLast

SFXStack::MoveFirst

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

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された位置にある要素を最初に移動します。

参照

SFXStack::Move | SFXStack::MoveLast

SFXStack::MoveLast

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

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された位置にある要素を最後に移動します。

参照

SFXStack::Move | SFXStack::MoveFirst

SFXStack::Peek

トップの要素を取得します。

[ public, const ]
V Peek(Void);

戻り値

トップの要素（最後にプッシュした要素）

解説

この関数は、このスタックのトップの要素（最後にプッシュした要素）を取得します。

	注意
	スタックが空の場合は、エラーにならず、要素の型に応じて 0 または null を返します。

	注意
	この関数を実行しても、このスタックの内容は変化しません。

使用例

SFXStack<SInt08> stack;

// 要素をプッシュする
if (stack.Push(1) == SFERR_NO_ERROR) {    

    // トップの要素を取得する
    TRACE("%d", stack.Peek());  // 1

    // 要素をプッシュする
    if (stack.Push(2) == SFERR_NO_ERROR) { 
    
    	// トップの要素を取得する
        TRACE("%d", stack.Peek());  // 2
        
        // 要素をプッシュする
        if (stack.Push(3) == SFERR_NO_ERROR) {
        
            // トップの要素を取得する
            TRACE("%d", stack.Peek());  // 3
        }
    }
}

参照

SFXStack::Push | SFXStack::Pop | SFXStack::Get | SFXStack::GetFirst | SFXStack::GetLast

SFXStack::Pop

スタックの先頭要素を取り出します。

[ public ]
V Pop(Void);

戻り値

スタックの先頭要素。スタックが空の場合は、0。

解説

この関数は、スタックの先頭要素取り出し、削除します。

	注意
	スタックが空の場合は、エラーにならず、要素の型に応じて 0 または null を返します。

使用例

SFXStack<SInt08> stack;

// スタックに要素を追加する
if (stack.Push(1) == SFERR_NO_ERROR) {    

    // スタックに要素を追加する
    if (stack.Push(2) == SFERR_NO_ERROR) { 
         
        // スタックに要素を追加する
        if (stack.Push(3) == SFERR_NO_ERROR) {
  
            // スタックの先頭要素を取り出す
            TRACE("%d", stack.Pop());  // 3
            TRACE("%d", stack.Pop());  // 2
            TRACE("%d", stack.Pop());  // 1
        }
    }
}

参照

SFXStack::Push

スタックに要素を追加します。

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

戻り値

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

解説

Push 関数の内部で、 SFXStack::InsertLast 関数が呼び出されます。

使用例

SFXStack<SInt08> stack;

// スタックに要素を追加する
if (stack.Push(1) == SFERR_NO_ERROR) {    

    // スタックの先頭要素を取得する
    TRACE("%d", stack.Peek());  // 1

    // スタックに要素を追加する
    if (stack.Push(2) == SFERR_NO_ERROR) { 
    
    	// スタックの先頭要素を取得する
        TRACE("%d", stack.Peek());  // 2
        
        // スタックに要素を追加する
        if (stack.Push(3) == SFERR_NO_ERROR) {
        
            // スタックの先頭要素を取得する
            TRACE("%d", stack.Peek());  // 3
        }
    }
}

参照

SFXStack::Insert | SFXStack::InsertLast | SFXStack::Set | SFXStack::Pop | SFXStack::Peek

SFXStack::Remove

指定されたインデックスの位置または範囲にある要素を削除します。

[ public ]
Void Remove(
    SInt32 index   // 削除する要素の位置
);

[ public ]
Void Remove(
    SInt32 begin   // 削除開始位置（この位置を含む）
    SInt32 end     // 削除終了位置（この位置を含まない）
);

解説

この関数は、指定されたインデックスの位置または範囲にある要素を削除します。

削除する要素の位置が 0 より小さい場合、または要素数以上の場合、要素の削除は行われません。

削除開始位置が要素数以上の場合、または削除終了位置が 0 以下の場合、要素の削除は行われません。

削除開始位置が 0 より小さい場合、削除開始位置は 0 に再設定されます。

削除終了位置が要素数より大きい場合、削除終了位置は要素数に再設定されます。

	注意
	指定した要素が存在しない場合、エラーは発生せず、何も起こりません。

使用例

SFXStack<SInt08> stack;
SInt16 i;

// 要素を追加する
if (stack.InsertLast(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.InsertLast(5) == SFERR_NO_ERROR) {

        // 最初の位置に要素を挿入する
        if (stack.Insert(0, 3) == SFERR_NO_ERROR) {

            // 要素を挿入する
            // 指定したインデックスが有効でない場合、要素は有効な位置に挿入される
            if (stack.Insert(10, 4) == SFERR_NO_ERROR) {

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

                // インデックスを元にデータを列挙する
                for (i = 0; i < stack.GetSize(); ++i) {

                    TRACE("%d", stack[i]);  // 3 4
               }
           }
       }
    }
}

参照

SFXStack::RemoveFirst | SFXStack::RemoveLast | SFXStack::Insert | SFXStack::Get | SFXStack::Set

SFXStack::RemoveFirst

先頭の要素を削除します。

[ public ]
Void RemoveFirst(Void);

解説

この関数は、先頭の要素を削除します。

	注意
	このスタックに要素が存在しない場合、エラーは発生せず、何も起こりません。

参照

SFXStack::Remove | SFXStack::RemoveLast | SFXStack::GetFirst | SFXStack::InsertFirst

SFXStack::RemoveLast

末尾の要素を削除します。

[ public ]
Void RemoveLast(Void);

解説

この関数は、末尾の要素を削除します。

	注意
	このスタックに要素が存在しない場合、エラーは発生せず、何も起こりません。

参照

SFXStack::Remove | SFXStack::RemoveFirst | SFXStack::GetLast | SFXStack::InsertLast | SFXStack::Pop

SFXStack::Search

指定された値の要素をスタックのトップから検索します。

[ public, const ]
SInt32 Search(
    V value   // 検索する値
);

戻り値

見つかったとき: スタックのトップ（最後にプッシュした要素）から数えた当該要素の位置
見つからなかったとき: -1

解説

この関数は、指定された値の要素をスタックのトップ（最後にプッシュした要素）から検索します。

見つかったときは、スタックのトップから数えた当該要素の位置を返します（トップの位置は 1）。見つからなかったときは、-1 を返します。

	注意
	要素がポインタである場合、アドレスを比較します。

使用例

SFXStack<SInt08> stack;

// 要素をプッシュする
if (stack.Push(1) == SFERR_NO_ERROR) {    

    // 要素をプッシュする
    if (stack.Push(2) == SFERR_NO_ERROR) { 
         
        // 要素をプッシュする
        if (stack.Push(3) == SFERR_NO_ERROR) {
  
            // トップから要素を検索する
            TRACE("Search(3) = %d", stack.Search(3));  // 1
            TRACE("Search(5) = %d", stack.Search(5));  // -1
        }
    }
}

参照

SFXStack::Push | SFXStack::Contains | SFXStack::FirstIndexOf | SFXStack::LastIndexOf

SFXStack::Set

要素に値を設定します。またはスタックを設定します。

[ public ]
SFCError Set(
    SFXStack< V > const & collection   // 設定するスタック
);

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

戻り値

成功したとき: SFERR_NO_ERROR
メモリ不足のとき: SFERR_NO_MEMOERY
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された位置にある要素の値を設定します。またはこのスタックを指定されたスタックに設定します。

※処理中にエラーが発生した場合は、元の状態に戻します。

使用例

SFXStack<SInt08> stack;
SInt16 i;

// 要素を追加する
if (stack.InsertLast(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.InsertLast(5) == SFERR_NO_ERROR) {

        // 要素の値を設定する
        if (stack.Set(1, 10) == SFERR_NO_ERROR) {

            // インデックスを元に要素を列挙する
            for (i = 0; i < stack.GetSize(); ++i) {

                TRACE("%d", stack[i]);  // 2 10
           }
       }
    }
}

参照

SFXStack::Get | SFXStack::SetFirst | SFXStack::SetLast | SFXStack::Insert | SFXStack::Remove

SFXStack::SetCluster

内部バッファのクラスタサイズを設定します。[単位: バイト]

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

解説

この関数は、内部バッファ(SFXClusterHeap)を確保する時の最小単位（クラスタサイズ）を設定します。[単位: バイト]

デフォルト値: SFXStack::DEFAULT_CLUSTER バイト

SFXStack::DEFAULT_CLUSTER の値は SFXStack::DefaultEnum を参照してください。

	Tip
	1 要素のサイズは 4 バイトなので、size 引数には 4 の倍数を指定します。

内部バッファメモリ

	内部バッファメモリ
`SFXStack` クラスでは、要素が追加されると、要素は内部バッファメモリに格納されます。最初、内部バッファメモリは、 `SFXStack::SetThreshold` 関数で設定されるサイズで確保されます。ある要素を追加しようとしたときに内部バッファメモリに格納できない場合、 `SFXStack::SetCluster` 関数で設定されるクラスタサイズだけ拡張した内部バッファメモリを再割り当てします。内部バッファメモリ再割り当ての回数が最少になるように、 `SFXStack::SetThreshold` 関数と `SFXStack::SetCluster` 関数で設定するサイズをアプリケーションの特性に合わせて最適化することを推奨します。

SFXStack クラスでは、要素が追加されると、要素は内部バッファメモリに格納されます。

最初、内部バッファメモリは、 SFXStack::SetThreshold 関数で設定されるサイズで確保されます。

ある要素を追加しようとしたときに内部バッファメモリに格納できない場合、 SFXStack::SetCluster 関数で設定されるクラスタサイズだけ拡張した内部バッファメモリを再割り当てします。

内部バッファメモリ再割り当ての回数が最少になるように、 SFXStack::SetThreshold 関数と SFXStack::SetCluster 関数で設定するサイズをアプリケーションの特性に合わせて最適化することを推奨します。

参照

SFXStack::GetCluster | SFXStack::SetThreshold | SFXStack::DefaultEnum | SFXClusterHeap::SetCluster | SFXClusterHeap

SFXStack::SetFirst

先頭の要素に指定された値を設定します。

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE

解説

この関数は、先頭の要素に指定された値を設定します。

※処理中にエラーが発生した場合は、元の状態に戻します。

参照

SFXStack::GetFirst | SFXStack::Set | SFXStack::SetLast

SFXStack::SetLast

末尾の要素に指定された値を設定します。

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE

解説

この関数は、末尾の要素に指定された値を設定します。

※処理中にエラーが発生した場合は、元の状態に戻します。

参照

SFXStack::GetLast | SFXStack::Set | SFXStack::SetFirst

SFXStack::SetSize

要素数を設定します。

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

戻り値

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

解説

この関数は、スタックのサイズを設定します。

	注意
	現在のスタックのサイズよりも設定するサイズが小さいと、そのサイズ以降の要素は削除されます。逆に、現在のサイズよりも大きい場合は、既存の要素の値はそのままですが、拡張された各要素の値は 0 に初期化されます。

参照

SFXStack::GetSize

SFXStack::SetThreshold

内部バッファメモリの最小値を設定します。[単位: バイト]

[ public ]
Void SetThreshold(
    UInt16 size   // 設定する最小値 [単位: バイト]
);

解説

この関数は、内部バッファメモリ(SFXClusterHeap)の最小値を設定します。[単位: バイト]

デフォルト値: SFXStack::DEFAULT_THRESHOLD バイト

SFXStack::DEFAULT_THRESHOLD の値は SFXStack::DefaultEnum を参照してください。

	Tip
	1 要素のサイズは 4 バイトなので、size 引数には 4 の倍数を指定します。

内部バッファメモリ

	内部バッファメモリ
`SFXStack` クラスでは、要素が追加されると、要素は内部バッファメモリに格納されます。最初、内部バッファメモリは、 `SFXStack::SetThreshold` 関数で設定されるサイズで確保されます。ある要素を追加しようとしたときに内部バッファメモリに格納できない場合、 `SFXStack::SetCluster` 関数で設定されるクラスタサイズだけ拡張した内部バッファメモリを再割り当てします。内部バッファメモリ再割り当ての回数が最少になるように、 `SFXStack::SetThreshold` 関数と `SFXStack::SetCluster` 関数で設定するサイズをアプリケーションの特性に合わせて最適化することを推奨します。

SFXStack クラスでは、要素が追加されると、要素は内部バッファメモリに格納されます。

最初、内部バッファメモリは、 SFXStack::SetThreshold 関数で設定されるサイズで確保されます。

参照

SFXStack::GetThreshold | SFXStack::SetCluster | SFXStack::DefaultEnum | SFXClusterHeap::SetThreshold | SFXClusterHeap

SFXStack::Swap

指定された 2 つの要素を交換します。

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

戻り値

成功したとき: SFERR_NO_ERROR
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された 2 つの要素を交換します。

参照

SFXStack::SwapFirst | SFXStack::SwapLast

SFXStack::SwapFirst

指定された要素と先頭の要素を交換します。

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された要素と先頭の要素を交換します。

参照

SFXStack::Swap | SFXStack::SwapLast

SFXStack::SwapLast

指定された要素と末尾の要素を交換します。

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

戻り値

成功したとき: SFERR_NO_ERROR
スタックが空のとき: SFERR_INVALID_STATE
指定された位置に要素が存在しないとき: SFERR_INVALID_PARAM

解説

この関数は、指定された要素と末尾の要素を交換します。

参照

SFXStack::Swap | SFXStack::SwapFirst

SFXStack::operator[]

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

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

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

参照

SFXStack::Get | SFXStack::Set

SFXStack::DefaultEnum

内部バッファメモリの最小値とクラスタサイズのデフォルト値を表します。[単位: バイト]

enum DefaultEnum {
    DEFAULT_THRESHOLD           = 4 * 4,     // 内部バッファメモリの最小値 [単位: バイト]
    DEFAULT_CLUSTER             = 8 * 4      // 内部バッファメモリのクラスタサイズ(メモリ確保の最小単位) [単位: バイト]
};

解説

DEFAULT_THRESHOLD と DEFAULT_CLUSTER は、内部バッファメモリ(SFXClusterHeap)の最小値とクラスタサイズのデフォルト値を表します。[単位: バイト]

参照

SFXStack::SetCluster | SFXStack::SetThreshold | SFXClusterHeap

SFXStack::Enumerator

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

[ public ]

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

解説

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

このクラスは、以下のメンバ関数を持ちます。

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

使用例

SFXStack<SInt08> stack;
SFXStack<SInt08>::Enumerator en;

// 要素を追加する
if (stack.InsertLast(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する列挙子を取得する
        en = stack.GetFirstEnumerator();
        
        // 次の要素があるか判定する
        while(en.HasNext()) {

            TRACE("%d", en.GetNext());  // 2 5 
        }
    }
}

参照

SFXStack::Iterator

SFXStack::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);
        Void                Remove              (Void);

    friend      class               Enumerator;
};

解説

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

このクラスは、以下のメンバ関数を持ちます。

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

使用例

SFXStack<SInt08> stack;
SFXStack<SInt08>::Iterator it;

// 要素を追加する
if (stack.InsertLast(2) == SFERR_NO_ERROR) {

    // 要素を追加する
    if (stack.InsertLast(5) == SFERR_NO_ERROR) {
        
        // 最初の要素に対応する反復子を取得する
        it = stack.GetFirstIterator();
        
        // 次の要素があるか判定する
        while(it.HasNext()) {

            TRACE("%d", it.GetNext());  // 2 5 
        }
    }
}

参照

SFXStack::Enumerator