CString.cpp

[詳解]

//=============================================================================
/// @file
/// 文字列クラス実装ファイル
///
/// 文字列クラス実装ファイルです。
///
/// $Id: CString.cpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma managed( push, off )

//=============================================================================
// インクルードファイル
#include <CString.h>
#include <stdio.h>
#include <algorithm>

//=============================================================================
// 共通ライブラリ名前空間
namespace LibCommon {
    //=========================================================================
    // 文字列クラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString() noexcept
        // メンバ変数初期化
        : m_pszBuffer( nullptr )
        , m_nSize( 0 )
        , m_nCount( 0 )
    {}

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( wchar_t const& rChar ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( rChar );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( wchar_t const* pszString ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( pszString );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( wchar_t const* pszString, int nCount ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( pszString, nCount );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( char const* pszMbString ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( pszMbString );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( char const* pszMbString, int nCount ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( pszMbString, nCount );
    }

    //-------------------------------------------------------------------------
    // コンストラクタ
    CString::CString( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( rcInitializer );
    }

    //-------------------------------------------------------------------------
    // コピーコンストラクタ
    CString::CString( CString const& rcInstance ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // コピーする
        Copy( rcInstance );
    }

    //-------------------------------------------------------------------------
    // ムーブコンストラクタ
    CString::CString( CString&& rcInstance ) noexcept
        // 移譲コンストラクタ
        : CString()
    {
        // ムーブする
        Move( std::move( rcInstance ) );
    }

    //-------------------------------------------------------------------------
    // デストラクタ
    CString::~CString() noexcept {
        // クリアする
        Clear();
    }

    //=========================================================================
    // 公開演算子オーバーロード関数
    //-------------------------------------------------------------------------
    // コピー代入演算子オーバーロード関数
    CString& CString::operator=( CString const& rcInstance ) noexcept {
        // コピーする
        Copy( rcInstance );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // ムーブ代入演算子オーバーロード関数
    CString& CString::operator=( CString&& rcInstance ) noexcept {
        // ムーブする
        Move( std::move( rcInstance ) );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    CString& CString::operator=( wchar_t const& rChar ) noexcept {
        // コピーする
        Copy( rChar );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    CString& CString::operator=( wchar_t const* pszString ) noexcept {
        // コピーする
        Copy( pszString );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    CString& CString::operator=( char const* pszMbString ) noexcept {
        // コピーする
        Copy( pszMbString );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 代入演算子オーバーロード関数
    CString& CString::operator=( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // コピーする
        Copy( rcInitializer );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    CString& CString::operator+=( CString const& rcInstance ) noexcept {
        // 追加する
        Append( rcInstance );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    CString& CString::operator+=( wchar_t const& rChar ) noexcept {
        // 追加する
        Append( rChar );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    CString& CString::operator+=( wchar_t const* pszString ) noexcept {
        // 追加する
        Append( pszString );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    CString& CString::operator+=( char const* pszMbString ) noexcept {
        // 追加する
        Append( pszMbString );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 加算代入演算子オーバーロード関数
    CString& CString::operator+=( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // 追加する
        Append( rcInitializer );

        // インスタンス参照を返す
        return *this;
    }

    //-------------------------------------------------------------------------
    // 配列添字演算子オーバーロード関数
    wchar_t& CString::operator[]( int nIndex ) noexcept {
        // 静的文字コード
        static wchar_t ch;

        // 処理ブロック
        wchar_t* result = &ch;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = &m_pszBuffer[ nIndex ];
        } while ( false );

        // 実行結果を返す
        return *result;
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // クリア関数
    void CString::Clear() noexcept {
        // バッファを削除する
        delete[] m_pszBuffer;

        // メンバ変数を初期化する
        m_pszBuffer = nullptr;
        m_nSize   = 0;
        m_nCount  = 0;
    }

    //-------------------------------------------------------------------------
    // バッファ作成関数
    bool CString::CreateBuffer( int nSize ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファサイズを調べる
            if ( m_nCount >= nSize ) {
                // 失敗！
                break;
            }
            // バッファサイズを調べる
            else if ( m_nSize != nSize ) {
                // 新規バッファを作成する
                wchar_t* pNewBuffer = new wchar_t[ nSize ];
                if ( nullptr == pNewBuffer ) {
                    // 失敗！
                    break;
                }
                // 巡回する
                else for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                    // 文字コードをコピーする
                    pNewBuffer[ nIndex ] = m_pszBuffer[ nIndex ];
                }

                // 巡回する
                for ( int nIndex = m_nCount; nSize > nIndex; ++nIndex ) {
                    // 文字コードをクリアする
                    ::memset( &pNewBuffer[ nIndex ], 0, sizeof( wchar_t ) );
                }

                // 既存バッファを削除する
                delete[] m_pszBuffer;

                // バッファポインタとバッファサイズを設定する
                m_pszBuffer = pNewBuffer;
                m_nSize   = nSize;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // バッファサイズ更新関数
    bool CString::UpdateBuffer( int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字数とバッファサイズを比較する
            if ( m_nSize < nCount ) {
                // 終端文字コード分を追加したセグメント単位のバッファサイズを取得する
                int nSize = ( ( nCount + GetSegmentSize() ) / GetSegmentSize() * GetSegmentSize() );

                // バッファを作成する
                if ( !CreateBuffer( nSize ) ) {
                    // 失敗！
                    break;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // バッファサイズコンパクト化関数
    bool CString::CompactBuffer() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファサイズとバッファカウントを比較する
            if ( m_nSize > ( m_nCount + 1 ) ) {
                // バッファを作成する
                if ( !CreateBuffer( m_nCount + 1 ) ) {
                    // 失敗！
                    break;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( CString const& rcInstance ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rcInstance );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( wchar_t const& rChar ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rChar );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( wchar_t const* pszString ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, pszString );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( wchar_t const* pszString, int nCount ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, pszString, nCount );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( char const* pszMbString ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, pszMbString );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( char const* pszMbString, int nCount ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, pszMbString, nCount );
    }

    //-------------------------------------------------------------------------
    // コピー関数
    bool CString::Copy( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // クリアする
        Clear();

        // 挿入する
        return Insert( 0, rcInitializer );
    }

    //-------------------------------------------------------------------------
    // ムーブ関数
    bool CString::Move( CString&& rcInstance ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // クリアする
            Clear();

            // メンバ変数をコピーする
            m_pszBuffer      = rcInstance.m_pszBuffer;
            m_nSize   = rcInstance.m_nSize;
            m_nCount = rcInstance.m_nCount;

            // ムーブ元インスタンスのメンバ変数を初期化する
            rcInstance.m_pszBuffer = nullptr;
            rcInstance.m_nSize   = 0;
            rcInstance.m_nCount  = 0;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( CString const& rcInstance ) noexcept {
        // 挿入する
        return Insert( m_nCount, rcInstance );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( wchar_t const& rChar ) noexcept {
        // 挿入する
        return Insert( m_nCount, rChar );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( wchar_t const* pszString ) noexcept {
        // 挿入する
        return Insert( m_nCount, pszString );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( wchar_t const* pszString, int nCount ) noexcept {
        // 挿入する
        return Insert( m_nCount, pszString, nCount );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( char const* pszMbString ) noexcept {
        // 挿入する
        return Insert( m_nCount, pszMbString );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( char const* pszMbString, int nCount ) noexcept {
        // 挿入する
        return Insert( m_nCount, pszMbString, nCount );
    }

    //-------------------------------------------------------------------------
    // 追加関数
    bool CString::Append( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // 挿入する
        return Insert( m_nCount, rcInitializer );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, CString const& rcInstance ) noexcept {
        // 挿入する
        return Insert( nIndex, rcInstance.m_pszBuffer, rcInstance.m_nCount );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, wchar_t const& rChar ) noexcept {
        // 挿入する
        return Insert( nIndex, &rChar, 1 );
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, wchar_t const* pszString ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファポインタを調べる
            if ( nullptr == pszString ) {
                // 失敗！
                break;
            }

            // 文字数を取得する
            int nCount = static_cast< int >( ::wcslen( pszString ) );

            // 挿入する
            result = Insert( nIndex, pszString, nCount );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, char const* pszMbString ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファポインタを調べる
            if ( nullptr == pszMbString ) {
                // 失敗！
                break;
            }

            // 文字数を取得する
            int nCount = static_cast< int >( ::strlen( pszMbString ) );

            // 挿入する
            result = Insert( nIndex, pszMbString, nCount );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, wchar_t const* pszString, int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // バッファポインタを調べる
            if ( nullptr == pszString ) {
                // 失敗！
                break;
            }
            // インデックスを調べる
            else if ( ( 0 > nIndex ) || ( m_nCount < nIndex ) ) {
                // 失敗！
                break;
            }
            // 文字数を調べる
            else if ( 0 > nCount ) {
                // 失敗！
                break;
            }
            // バッファサイズを更新する
            else if ( !UpdateBuffer( m_nCount + nCount ) ) {
                // 失敗！
                break;
            }

            // 移動文字数を取得する
            int nMove = ( m_nCount - nIndex );
            if ( 0 < nMove ) {
                // 巡回する
                wchar_t*       pDst = &m_pszBuffer[ m_nCount + nCount - 1 ];
                wchar_t const* pSrc = &m_pszBuffer[ m_nCount - 1 ];
                for ( ; 0 < nMove; --nMove ) {
                    // 文字コードをコピーする
                    *pDst-- = *pSrc--;
                }
            }

            // 文字数を更新する
            m_nCount += nCount;

            // 巡回する
            wchar_t const* pSrc = pszString;
            wchar_t*       pDst = &m_pszBuffer[ nIndex ];
            for ( ; 0 < nCount; --nCount ) {
                // 文字コードをコピーする
                *pDst++ = *pSrc++;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, char const* pszMbString, int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列ポインタを調べる
            if ( nullptr == pszMbString ) {
                // 失敗！
                break;
            }

            // ワイド文字列バッファサイズを取得する
            int nCount = ::MultiByteToWideChar( CP_ACP, 0, pszMbString, -1, nullptr, 0 );
            if ( 0 >= nCount ) {
                // 失敗！
                break;
            }

            // ワイド文字列バッファを作成する
            int      nSize     = ( nCount + 1 );
            wchar_t* pszBuffer = new wchar_t[ nSize ];
            if ( nullptr == pszBuffer ) {
                // 失敗！
                break;
            }
            // 処理ブロック
            else do {
                // ワイド文字列に変換する
                if ( nCount != ::MultiByteToWideChar( CP_ACP, 0, pszMbString, -1, pszBuffer, nSize ) ) {
                    // 失敗！
                    break;
                }
                // 挿入する
                else if ( !Insert( nIndex, pszBuffer, nCount ) ) {
                    // 失敗！
                    break;
                }

                // 成功！
                result = true;
            } while ( false );

            // ワイド文字列バッファを削除する
            delete[] pszBuffer;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 挿入関数
    bool CString::Insert( int nIndex, std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 巡回する
            for ( auto pcIter = rcInitializer.begin();; ++pcIter ) {
                // イテレータを調べる
                if ( rcInitializer.end() == pcIter ) {
                    // 成功！
                    result = true;
                    break;
                }

                // 挿入する
                if ( !Insert( nIndex++, *pcIter ) ) {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 削除関数
    bool CString::Remove() noexcept {
        // 削除する
        return Remove( m_nCount - 1 );
    }

    //-------------------------------------------------------------------------
    // 削除関数
    bool CString::Remove( int nIndex ) noexcept {
        // 削除する
        return Remove( nIndex, 1 );
    }

    //-------------------------------------------------------------------------
    // 削除関数
    bool CString::Remove( int nIndex, int nCount ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }
            // 文字数を調べる
            else if ( ( m_nCount - nIndex ) < nCount ) {
                // 失敗！
                break;
            }

            // 移動文字数を取得する
            int nMove = ( m_nCount - nIndex - nCount );
            if ( 0 < nMove ) {
                // 巡回する
                for ( ; 0 < nMove; --nMove, ++nIndex ) {
                    // 文字コードをコピーする
                    m_pszBuffer[ nIndex ] = m_pszBuffer[ nIndex + nCount ];
                }
            }

            // 巡回する
            for ( ; m_nCount > nIndex; ++nIndex ) {
                // 文字コードをクリアする
                ::memset( &m_pszBuffer[ nIndex ], 0, sizeof( wchar_t ) );
            }

            // 文字数を更新する
            m_nCount -= nCount;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 取得関数
    bool CString::Get( int nIndex, wchar_t& rChar ) const noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 文字コードを取得する
            rChar = m_pszBuffer[ nIndex ];

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 設定関数
    bool CString::Set( int nIndex, wchar_t const& rChar ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // インデックスを調べる
            if ( ( 0 > nIndex ) || ( m_nCount <= nIndex ) ) {
                // 失敗！
                break;
            }

            // 文字コードを設定する
            m_pszBuffer[ nIndex ] = rChar;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 検索関数
    int CString::Find( wchar_t const& rChar ) const noexcept {
        // 処理ブロック
        int result = -1;
        do {
            // 巡回する
            for ( int nIndex = 0; m_nCount > nIndex; ++nIndex ) {
                // 文字コードを調べる
                if ( rChar == m_pszBuffer[ nIndex ] ) {
                    // 成功！
                    result = nIndex;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( wchar_t const& rChar ) noexcept {
        // 追加する
        return Append( rChar );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( wchar_t const* pszString ) noexcept {
        // 追加する
        return Append( pszString );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( wchar_t const* pszString, int nCount ) noexcept {
        // 追加する
        return Append( pszString, nCount );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( char const* pszMbString ) noexcept {
        // 追加する
        return Append( pszMbString );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( char const* pszMbString, int nCount ) noexcept {
        // 追加する
        return Append( pszMbString, nCount );
    }

    //-------------------------------------------------------------------------
    // プッシュ関数
    bool CString::Push( std::initializer_list< wchar_t const > const& rcInitializer ) noexcept {
        // 追加する
        return Append( rcInitializer );
    }

    //-------------------------------------------------------------------------
    // ポップ関数
    bool CString::Pop( wchar_t& rChar ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字数を取得する
            if ( !Get( ( m_nCount - 1 ), rChar ) ) {
                // 失敗！
                break;
            }
            // 削除する
            else if ( Remove() ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // ポップフロント関数
    bool CString::PopFront( wchar_t& rChar ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字数を取得する
            if ( !Get( 0, rChar ) ) {
                // 失敗！
                break;
            }
            // 削除する
            else if ( Remove( 0 ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 書式設定文字列代入関数
    wchar_t const* CString::Format( wchar_t const* pszFormat, ... ) noexcept {
        // 処理ブロック
        wchar_t const* result = nullptr;
        do {
            // 引数リストを作成する
            va_list vaArgs;
            va_start( vaArgs, pszFormat );

            // 引数リスト書式設定文字列を代入する
            result = FormatArgs( pszFormat, vaArgs );

            // 引数リストを解放する
            va_end( vaArgs );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // 引数リスト書式設定文字列代入関数
    wchar_t const* CString::FormatArgs( wchar_t const* pszFormat, va_list vaArgs ) noexcept {
        // 処理ブロック
        wchar_t const* result = nullptr;
        do {
            // 書式設定文字列ポインタを調べる
            if ( nullptr == pszFormat ) {
                // 失敗！
                break;
            }

            // 文字列バッファサイズを取得する
            int nCount = ::_vscwprintf( pszFormat, vaArgs );
            if ( 0 >= nCount ) {
                // 失敗！
                break;
            }

            // クリアする
            Clear();

            // バッファサイズを更新する
            if ( !UpdateBuffer( nCount ) ) {
                // 失敗！
                break;
            }
            // 書式設定文字列を展開する
            else if ( nCount != ::vswprintf_s( m_pszBuffer, ( nCount + 1 ), pszFormat, vaArgs ) ) {
                // 失敗！
                break;
            }

            // 文字数を設定する
            m_nCount = nCount;

            // 成功！
            result = m_pszBuffer;
        } while ( false );

        // 実行結果を返す
        return result;
    }
}

#pragma managed( pop )