文字と文字列

Windowsプログラミングにおいて、文字と文字列の操作は非常に重要な要素です。特に国際化対応やセキュリティの観点から、適切な文字エンコーディングと文字列操作の理解は不可欠です。

文字エンコーディングの基礎

文字コードとエンコーディング

文字エンコーディングは、文字を数値（コードポイント）に変換し、さらにそれをバイト列として表現する仕組みです。コンピューターは数値しか理解できないため、文字を扱うには必ずエンコーディングが必要になります。

主要な文字エンコーディング：

ASCII（American Standard Code for Information Interchange）:
- 7ビット（0-127の128文字）
- 英数字、基本記号、制御文字
- 例：'A' = 65 (0x41), '0' = 48 (0x30)
- 全世界で共通だが、英語圏以外の文字は表現不可
ANSI（拡張ASCII）:
- 8ビット（0-255の256文字）
- 地域固有の文字セット（コードページ）
- 日本語環境：Shift_JIS（CP932）
- 西欧：Latin-1（CP1252）
- 問題：異なる地域間でのデータ交換時に文字化け
Unicode（Universal Coded Character Set）:
- 21ビット（理論上200万文字以上、実際は約15万文字定義済み）
- 世界中の文字を統一的に扱える
- 絵文字、古代文字、数学記号なども含む
- コードポイント表記：U+0041（'A'）、U+3042（'あ'）
UTF-8（8-bit Unicode Transformation Format）:
- Unicodeの可変長エンコーディング（1-4バイト）
- ASCII互換（0-127はASCIIと同じ）
- Webで標準的に使用
- 日本語は3バイトで表現
UTF-16（16-bit Unicode Transformation Format）:
- Unicodeの可変長エンコーディング（2または4バイト）
- Windowsの内部エンコーディング
- BMP（基本多言語面）は2バイト、それ以外は4バイト
- リトルエンディアン（UTF-16LE）が一般的

エンコーディングの実例

// 同じ「あ」という文字の異なるエンコーディング
char utf8_a[] = {0xE3, 0x81, 0x82, 0x00};           // UTF-8: 3バイト
wchar_t utf16_a[] = {0x3042, 0x0000};                // UTF-16: 2バイト
char sjis_a[] = {0x82, 0xA0, 0x00};                  // Shift_JIS: 2バイト

// ASCII文字「A」は全エンコーディングで共通
char ascii_A = 0x41;                                 // ASCII/UTF-8/Shift_JIS共通
wchar_t utf16_A = 0x0041;                            // UTF-16

コードページの概念

Windowsでは、ANSI文字を扱う際にコードページ（Code Page）という概念を使用します。

// 主要なコードページ
#define CP_ACP          0       // システムのデフォルトANSIコードページ
#define CP_OEMCP        1       // システムのデフォルトOEMコードページ
#define CP_MACCP        2       // システムのデフォルトMacintoshコードページ
#define CP_THREAD_ACP   3       // 現在のスレッドのANSIコードページ
#define CP_SYMBOL       42      // シンボルコードページ
#define CP_UTF7         65000   // UTF-7変換
#define CP_UTF8         65001   // UTF-8変換

// 日本語環境での代表的なコードページ
#define CP_SHIFT_JIS    932     // Shift_JIS
#define CP_EUC_JP       20932   // EUC-JP
#define CP_ISO2022_JP   50220   // ISO-2022-JP

// コードページの取得
UINT systemCodePage = GetACP();        // システムのANSIコードページ
UINT oemCodePage = GetOEMCP();          // OEMコードページ

WindowsにおけるUnicodeサポート

Windows NTファミリー（Windows NT、2000、XP以降）は、内部的にUTF-16でUnicodeを処理します。これにより、多言語環境での一貫した文字処理が可能になります。

Unicodeサポートの歴史

Windows 9x系（95/98/Me）：
- 主にANSI（Shift_JIS）ベース
- Unicode APIはあるが、内部でANSIに変換される
Windows NT系（NT/2000/XP以降）：
- カーネルレベルでUnicodeサポート
- ファイルシステム（NTFS）もUnicodeネイティブ
- ANSI APIは内部でUnicodeに変換される
現代のWindows（Vista以降）：
- 完全なUnicodeサポート
- 一部のAPIはUnicodeのみ（ANSI版が削除）

内部処理の仕組み

// Windows内部でのANSI→Unicode変換例
BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) {
    // 1. ANSIからUnicodeに変換
    WCHAR widePathName[MAX_PATH];
    MultiByteToWideChar(CP_ACP, 0, lpPathName, -1, widePathName, MAX_PATH);
    
    // 2. Unicode版APIを呼び出し
    return CreateDirectoryW(widePathName, lpSecurityAttributes);
}

バイトオーダーマーク（BOM）

UTF-16やUTF-8ファイルでは、バイトオーダーを示すBOMが先頭に付加される場合があります。

// BOMの定義
const BYTE UTF8_BOM[] = {0xEF, 0xBB, 0xBF};              // UTF-8 BOM
const BYTE UTF16LE_BOM[] = {0xFF, 0xFE};                  // UTF-16 LE BOM
const BYTE UTF16BE_BOM[] = {0xFE, 0xFF};                  // UTF-16 BE BOM

// BOM検出関数の例
typedef enum {
    ENCODING_UNKNOWN,
    ENCODING_UTF8,
    ENCODING_UTF16LE,
    ENCODING_UTF16BE,
    ENCODING_ANSI
} FileEncoding;

FileEncoding DetectFileEncoding(const BYTE* buffer, DWORD size) {
    if (size >= 3 && memcmp(buffer, UTF8_BOM, 3) == 0) {
        return ENCODING_UTF8;
    }
    if (size >= 2 && memcmp(buffer, UTF16LE_BOM, 2) == 0) {
        return ENCODING_UTF16LE;
    }
    if (size >= 2 && memcmp(buffer, UTF16BE_BOM, 2) == 0) {
        return ENCODING_UTF16BE;
    }
    return ENCODING_ANSI;  // BOMなし、またはANSI
}

ANSIとUnicodeのデータ型

Windowsプログラミングでは、文字と文字列を扱うための豊富なデータ型が定義されています。これらを正しく理解することで、効率的で保守性の高いコードを書くことができます。

ANSI データ型

8ビット文字（通常はASCIIまたは拡張ASCII）を扱うためのデータ型です。

// 8ビット文字型
typedef char CHAR;              // 基本的な8ビット文字型
typedef CHAR* PCHAR;            // CHAR へのポインタ
typedef const CHAR* PCCHAR;     // const CHAR へのポインタ

// ANSI文字列型
typedef CHAR* PSTR;             // null終端文字列へのポインタ
typedef const CHAR* PCSTR;      // const null終端文字列へのポインタ
typedef CHAR* LPSTR;            // Long Pointer to STRing（16ビット時代の名残）
typedef const CHAR* LPCSTR;     // Long Pointer to Const STRing

// 使用例
CHAR singleChar = 'A';
CHAR buffer[256];
LPCSTR message = "Hello, World!";
LPSTR writableString = buffer;

// ファイル関連
typedef CHAR* PCHAR;
typedef const CHAR* PCCHAR;

Unicode データ型

16ビット文字（UTF-16）を扱うためのデータ型です。Windowsの内部処理で使用されます。

// 16ビット文字型（ワイド文字）
typedef wchar_t WCHAR;          // 基本的な16ビット文字型
typedef WCHAR* PWCHAR;          // WCHAR へのポインタ  
typedef const WCHAR* PCWCHAR;   // const WCHAR へのポインタ

// Unicode文字列型
typedef WCHAR* PWSTR;           // Unicode null終端文字列へのポインタ
typedef const WCHAR* PCWSTR;    // const Unicode null終端文字列へのポインタ
typedef WCHAR* LPWSTR;          // Long Pointer to Wide STRing
typedef const WCHAR* LPCWSTR;   // Long Pointer to Const Wide STRing

// 使用例
WCHAR wideChar = L'A';          // L プレフィックスでワイド文字リテラル
WCHAR wideBuffer[256];
LPCWSTR wideMessage = L"Hello, 世界!";
LPWSTR writableWideString = wideBuffer;

// サイズ計算の注意点
size_t charCount = wcslen(wideMessage);                    // 文字数
size_t byteSize = wcslen(wideMessage) * sizeof(WCHAR);     // バイト数

汎用データ型（TCHAR）

UNICODEマクロの定義状態に応じて、ANSIまたはUnicodeのデータ型に展開される汎用型です。

#ifdef UNICODE
typedef WCHAR TCHAR;            // UnicodeビルドではWCHAR
typedef LPWSTR LPTSTR;          // 書き込み可能文字列ポインタ
typedef LPCWSTR LPCTSTR;        // 読み取り専用文字列ポインタ
typedef PWSTR PTSTR;            // 短縮形ポインタ
typedef PCWSTR PCTSTR;          // 短縮形constポインタ
#else
typedef CHAR TCHAR;             // ANSIビルドではCHAR
typedef LPSTR LPTSTR;           // 書き込み可能文字列ポインタ  
typedef LPCSTR LPCTSTR;         // 読み取り専用文字列ポインタ
typedef PSTR PTSTR;             // 短縮形ポインタ
typedef PCSTR PCTSTR;           // 短縮形constポインタ
#endif

// 使用例：ビルド設定に依存せず動作
TCHAR fileName[MAX_PATH];
LPCTSTR defaultName = TEXT("default.txt");
LPTSTR buffer = fileName;

// 文字列リテラルもマクロで対応
#ifdef UNICODE
#define TEXT(quote) L##quote    // L"string" に展開
#define _T(quote) L##quote      // 同上（短縮形）
#else  
#define TEXT(quote) quote       // "string" のまま
#define _T(quote) quote         // 同上（短縮形）
#endif

型変換とキャスト

異なる文字型間での変換時の注意点：

// 危険：直接キャストは避ける
LPCWSTR wideStr = L"Unicode文字列";
LPCSTR ansiStr = (LPCSTR)wideStr;  // 危険！文字化けの原因

// 正しい：適切な変換関数を使用
LPCWSTR wideStr = L"Unicode文字列";
char ansiBuffer[256];
WideCharToMultiByte(CP_ACP, 0, wideStr, -1, 
                   ansiBuffer, sizeof(ansiBuffer), NULL, NULL);

// TCHAR から特定型への安全な変換
LPCTSTR genericStr = TEXT("汎用文字列");
#ifdef UNICODE
    // Unicode環境：そのまま使用可能
    LPCWSTR widePtr = genericStr;
#else
    // ANSI環境：変換が必要な場合
    WCHAR wideBuffer[256];
    MultiByteToWideChar(CP_ACP, 0, genericStr, -1, 
                       wideBuffer, _countof(wideBuffer));
#endif

APIやランタイム関数のエンコーディング

Windows APIのUnicode関数（W）とANSI関数（A）

Windows APIの多くの関数は、UnicodeとANSIの両方に対応しており、関数名の末尾にW（Wide）またはA（ANSI）が付きます。Windows 95, 98, Meなどの時代は、それらの環境でも正しく動作させるためにANSI版の関数を使用する必要がありました。この頃に開発されたレガシーなアプリケーションやアプリケーションをサポートするために、現在もANSI版の関数が残されています。しかし、現代のWindowsではUnicodeがネイティブにサポートされているためANSI版を使用する必要は基本的になく、Unicode版の使用が推奨されます。

// Unicode版（推奨）
BOOL CreateDirectoryW(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);

// ANSI版（レガシー）
BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);

// 汎用マクロ（コンパイル時に決定）
#ifdef UNICODE
#define CreateDirectory CreateDirectoryW
#else
#define CreateDirectory CreateDirectoryA
#endif

主要なAPI関数の例：

汎用関数名	Unicode版	ANSI版	説明
`CreateFile`	`CreateFileW`	`CreateFileA`	ファイル作成・オープン
`GetModuleHandle`	`GetModuleHandleW`	`GetModuleHandleA`	モジュールハンドル取得
`MessageBox`	`MessageBoxW`	`MessageBoxA`	メッセージボックス表示
`RegOpenKey`	`RegOpenKeyW`	`RegOpenKeyA`	レジストリキーオープン
`GetWindowText`	`GetWindowTextW`	`GetWindowTextA`	ウィンドウテキスト取得
`FindFirstFile`	`FindFirstFileW`	`FindFirstFileA`	ファイル検索開始
`LoadLibrary`	`LoadLibraryW`	`LoadLibraryA`	DLLロード
`GetCommandLine`	`GetCommandLineW`	`GetCommandLineA`	コマンドライン取得

CランタイムライブラリのUnicode関数とANSI関数

Visual C++のランタイムライブラリも同様に、文字エンコーディングに応じた関数を提供します。

// 文字列操作関数
// ANSI版（標準C）
char* strcpy(char* dest, const char* src);              // 文字列コピー
char* strcat(char* dest, const char* src);              // 文字列連結
int strcmp(const char* str1, const char* str2);         // 文字列比較
size_t strlen(const char* str);                         // 文字列長取得
char* strchr(const char* str, int character);           // 文字検索
char* strstr(const char* str1, const char* str2);       // 文字列検索

// Unicode版（ワイド文字）
wchar_t* wcscpy(wchar_t* dest, const wchar_t* src);     // ワイド文字列コピー
wchar_t* wcscat(wchar_t* dest, const wchar_t* src);     // ワイド文字列連結
int wcscmp(const wchar_t* str1, const wchar_t* str2);   // ワイド文字列比較
size_t wcslen(const wchar_t* str);                      // ワイド文字列長取得
wchar_t* wcschr(const wchar_t* str, wchar_t character); // ワイド文字検索
wchar_t* wcsstr(const wchar_t* str1, const wchar_t* str2); // ワイド文字列検索

// 汎用マクロ（tchar.h）
#ifdef UNICODE
#define _tcscpy wcscpy          // ワイド文字版を使用
#define _tcscat wcscat
#define _tcscmp wcscmp
#define _tcslen wcslen
#define _tcschr wcschr
#define _tcsstr wcsstr
#else
#define _tcscpy strcpy          // ANSI版を使用
#define _tcscat strcat
#define _tcscmp strcmp
#define _tcslen strlen
#define _tcschr strchr
#define _tcsstr strstr
#endif

安全な文字列操作関数の使用

文字列操作においてセキュリティと安定性を確保するために、従来の文字列操作関数の代わりに用意されている安全な関数を使用することが推奨されています。これらの関数は、バッファオーバーランやその他のセキュリティ脆弱性を防ぐために設計されています。従来の文字列操作関数は、バッファサイズを考慮せずに使用すると、バッファオーバーランの原因となる可能性があります。安全な関数は、バッファサイズを引数として受け取り、オーバーフローを防ぐためのチェックを行います。従来の文字列操作関数は、セキュリティ上の理由から使用を避けるべきです。

安全な文字列操作関数の例

// 安全な文字列コピー
errno_t strcpy_s(char* dest, rsize_t destsz, const char* src); // ANSI版
errno_t wcscpy_s(wchar_t* dest, rsize_t destsz, const wchar_t* src); // Unicode版
// 安全な文字列連結
errno_t strcat_s(char* dest, rsize_t destsz, const char* src); // ANSI版
errno_t wcscat_s(wchar_t* dest, rsize_t destsz, const wchar_t* src); // Unicode版
// 安全な文字列長取得
errno_t strlen_s(const char* str, rsize_t maxsize, rsize_t* outlen); // ANSI版
errno_t wcslen_s(const wchar_t* str, rsize_t maxsize, rsize_t* outlen); // Unicode版
// 安全な文字列比較
errno_t strcmp_s(const char* str1, const char* str2, int* result); // ANSI版
errno_t wcscmp_s(const wchar_t* str1, const wchar_t* str2, int* result); // Unicode版

従来の文字列操作関数を使用した場合の警告

従来の安全ではない文字列を使用した場合、Visual C++コンパイラは警告W4996を出力します。これらの警告はセキュリティ上のリスクを示しており、可能な限り安全な関数に置き換えることが推奨されます。推奨はされませんが、もし従来の関数を使用する必要がある場合は#define _CRT_SECURE_NO_WARNINGSを定義することで警告を抑制できます。ただし、これはセキュリティリスクを伴うため、注意が必要です。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
    char buffer[10];
    // 従来の関数を使用
    strcpy(buffer, "This string is longer than 10 characters");
    return 0;
}

バッファオーバーランの検出

バッファオーバーランは、Windowsプログラミングにおける最も深刻なセキュリティ脆弱性の一つです。そして、文字列操作はバッファオーバーランの最も一般的な原因の一つです。バッファオーバーランは、プログラムが予期しないメモリ領域にデータを書き込むことで発生し、これによりプログラムのクラッシュや悪意のあるコードの実行が可能になることがあります。これを防ぐためには、適切な文字列操作とセキュリティ機能の使用が不可欠です。様々なシナリオで発生し得るバッファーオーバーランを検出するために、Visual Studioのコンパイラオプションやランタイム、Windowsの機能を活用することができます。

1. /GS オプション（スタック保護）

Visual Studioで/GSオプションを有効にすると、スタックバッファオーバーランを検出できます。このオプションは、関数のリターンアドレスを保護するためのスタッククッキー（セキュリティクッキー）を挿入します。

// プロジェクト設定での有効化
// プロパティ → C/C++ → コード生成 → バッファセキュリティチェック → はい(/GS)

// コードでの制御（通常は不要）
#pragma warning(push)
#pragma warning(disable: 4996) // 非推奨関数の警告を無効化（推奨しない）

void UnsafeFunction() {
    char buffer[10];
    // 危険な操作
    strcpy(buffer, "This string is longer than 10 characters"); // オーバーフロー発生
}

#pragma warning(pop)

// /GSオプションが有効な場合、実行時にスタック破損が検出される

/GSオプションの詳細動作

// /GSによって挿入されるコードの概念的な例
void ProtectedFunction() {
    // コンパイラが自動的に挿入するコード
    DWORD_PTR stackCookie = __security_cookie;
    
    char buffer[256];
    // ユーザーコード
    ProcessBuffer(buffer);
    
    // 関数終了時の検証（コンパイラが自動挿入）
    if (stackCookie != __security_cookie) {
        __security_check_cookie(stackCookie);  // 異常終了
    }
}

// 手動でのスタッククッキーチェック
void ManualStackCheck() {
    // 現在のスタッククッキー値を保存
    DWORD_PTR originalCookie = __security_cookie;
    
    char buffer[100];
    // 何らかの処理
    
    // 手動チェック（通常は不要、デバッグ目的）
    if (originalCookie != __security_cookie) {
        __debugbreak();  // デバッガで停止
    }
}

2. /RTCs オプション（ランタイムチェック）

デバッグビルドで/RTCsオプションを有効にすると、スタック破損を検出できます。これは開発時のみ使用し、リリースビルドでは無効にします。

// デバッグビルドでの設定例
#ifdef _DEBUG
    // CRTデバッグ機能を有効化
    #include <crtdbg.h>
    
    void InitializeDebugSettings() {
        // メモリリーク検出を有効化
        _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
        
        // 重要なメモリ破損を即座に検出
        _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_CHECK_ALWAYS_DF);
        
        // ヒープ破損時のブレークポイント設定
        _CrtSetBreakAlloc(-1);  // 特定の割り当て番号でブレーク
    }
    
    // デバッグ用のマクロ
    #define DEBUG_ASSERT(expr) _ASSERT(expr)
    #define DEBUG_TRACE(msg, ...) _CrtDbgReport(_CRT_WARN, __FILE__, __LINE__, NULL, msg, __VA_ARGS__)
#else
    #define DEBUG_ASSERT(expr) ((void)0)
    #define DEBUG_TRACE(msg, ...) ((void)0)
    void InitializeDebugSettings() { /* リリースビルドでは何もしない */ }
#endif

// ランタイムチェックの使用例
void RuntimeCheckExample() {
    char buffer[10];
    
    // /RTCsが有効な場合、以下でランタイムエラーが発生
    for (int i = 0; i <= 10; ++i) {  // 境界を1つ超える
        buffer[i] = 'A';  // buffer[10]でエラー検出
    }
    
    DEBUG_TRACE("Buffer access completed\n");
}

3. 静的解析ツール

Visual Studioの静的解析（/analyze）やCode Analysis機能を使用して、潜在的な問題を検出します。

// 静的解析による検出例

// SAL（Source Annotation Language）アノテーションの使用
void AnnotatedFunction(
    _In_z_ const char* inputString,           // null終端文字列
    _Out_writes_(bufferSize) char* outputBuffer, // 出力バッファ
    _In_ size_t bufferSize                    // バッファサイズ
) {
    // 静的解析が以下の問題を検出
    if (strlen(inputString) >= bufferSize) {  // 警告: バッファオーバーフローの可能性
        return;
    }
    
    strcpy_s(outputBuffer, bufferSize, inputString);  // 安全
}

// 静的解析警告の例
void StaticAnalysisExamples() {
    char buffer[10];
    char* dynamicBuffer = (char*)malloc(20);
    
    // C6054: 文字列がnull終端されていない可能性
    strncpy(buffer, "LongString", sizeof(buffer));  // 警告
    
    // C6386: バッファオーバーランの可能性
    strcpy(buffer, "This string is too long");      // 警告
    
    // C6001: 初期化されていない変数の使用
    char uninitializedBuffer[50];
    printf("%s", uninitializedBuffer);               // 警告
    
    // C6308: 'realloc'が null を返す可能性
    dynamicBuffer = (char*)realloc(dynamicBuffer, 100);
    strcpy(dynamicBuffer, "test");                   // 警告（nullチェックなし）
    
    free(dynamicBuffer);
}

// SALアノテーションの活用例
class AnnotatedStringClass {
public:
    // 入力パラメータのアノテーション
    static errno_t SafeCopyWithAnnotation(
        _Out_writes_z_(destSize) TCHAR* dest,      // 出力バッファ（null終端）
        _In_ size_t destSize,                      // バッファサイズ
        _In_z_ const TCHAR* src                    // 入力文字列（null終端）
    ) {
        return _tcscpy_s(dest, destSize, src);
    }
    
    // 戻り値のアノテーション
    _Ret_maybenull_ _Must_inspect_result_
    static TCHAR* AllocateString(_In_ size_t charCount) {
        if (charCount == 0) return NULL;
        
        size_t byteSize = charCount * sizeof(TCHAR);
        return (TCHAR*)malloc(byteSize);
    }
    
    // プリ・ポストコンディション
    static void ProcessStringWithConditions(
        _Inout_updates_z_(bufferSize) TCHAR* buffer,
        _In_ size_t bufferSize
    ) 
    // プリコンディション：bufferは有効で、bufferSizeは0より大きい
    // ポストコンディション：bufferは変更される可能性がある
    {
        if (buffer && bufferSize > 0) {
            // 安全な処理
            buffer[0] = TEXT('\0');
        }
    }
};

4. Application Verifier

Microsoftが提供するApplication Verifierを使用して、より詳細なヒープ破損を検出できます。

// Application Verifierの設定
// 1. Application Verifierツールを起動
// 2. 対象のEXEファイルを追加
// 3. 以下のテストを有効化:
//    - Heaps

// Application Verifier対応のテストコード
void ApplicationVerifierExample() {
    // ヒープオーバーランテスト
    char* buffer = (char*)HeapAlloc(GetProcessHeap(), 0, 10);
    if (buffer) {
        // Application Verifierが以下を検出:
        buffer[10] = 'X';  // ヒープオーバーラン
        buffer[-1] = 'Y';  // ヒープアンダーラン
        
        HeapFree(GetProcessHeap(), 0, buffer);
        // buffer[0] = 'Z';  // 解放後使用（Use After Free）
    }    
}

5. Address Sanitizer (ASan)

Visual Studio 2019以降で利用可能なAddress Sanitizerは、メモリエラーを高精度で検出します。

// Address Sanitizerの有効化
// プロジェクト設定 → C/C++ → 全般 → Address Sanitizerを有効にする → はい

// ASanが検出するエラーの例
void AddressSanitizerExamples() {
    // 1. スタックバッファオーバーフロー
    {
        char buffer[10];
        buffer[10] = 'X';  // ASanが即座に検出
    }
    
    // 2. ヒープバッファオーバーフロー
    {
        char* heap_buffer = new char[10];
        heap_buffer[10] = 'X';  // ASanが検出
        delete[] heap_buffer;
    }
    
    // 3. Use after free
    {
        char* ptr = new char[10];
        delete[] ptr;
        ptr[0] = 'X';  // ASanが検出
    }
    
    // 4. Double free
    {
        char* ptr = new char[10];
        delete[] ptr;
        delete[] ptr;  // ASanが検出
    }
}

まとめ：多層防御アプローチ

バッファオーバーランの防止には、以下の多層防御アプローチが効果的です：

コンパイル時検出: 静的解析（/analyze）、SALアノテーション
リンク時保護: /GSオプション、Control Flow Guard (/guard:cf)
ランタイム検出: /RTCs、Application Verifier、Address Sanitizer
実装時対策: 安全な関数の使用、入力検証、適切なエラーハンドリング
テスト時検証: ファズテスト、境界値テスト、セキュリティレビュー

これらの対策を組み合わせることで、バッファオーバーラン脆弱性を効果的に防ぐことができます。

文字エンコーディングの基礎​

文字コードとエンコーディング​

エンコーディングの実例​

コードページの概念​

WindowsにおけるUnicodeサポート​

Unicodeサポートの歴史​

内部処理の仕組み​

バイトオーダーマーク（BOM）​

ANSIとUnicodeのデータ型​

ANSI データ型​

Unicode データ型​

汎用データ型（TCHAR）​

型変換とキャスト​

APIやランタイム関数のエンコーディング​

Windows APIのUnicode関数（W）とANSI関数（A）​

CランタイムライブラリのUnicode関数とANSI関数​

安全な文字列操作関数の使用​

安全な文字列操作関数の例​

従来の文字列操作関数を使用した場合の警告​

バッファオーバーランの検出​

1. /GS オプション（スタック保護）​

/GSオプションの詳細動作​

2. /RTCs オプション（ランタイムチェック）​

3. 静的解析ツール​

4. Application Verifier​

5. Address Sanitizer (ASan)​

まとめ：多層防御アプローチ​