2.1. スタック領域 (Stack)

スタック領域は、主に関数のローカル変数、関数パラメータ、および関数の呼び出し情報を格納するために使用されます。メモリは連続したブロックとして割り当てられ、LIFO (Last-In, First-Out) の原則に従って管理されます。つまり、最後に追加されたデータが最初に取り出されます。

特性:

• メモリ割り当てと解放は非常に高速です。これは、スタックポインタを上下させるだけで実現できるためです。
• コンパイラによって自動的に管理されるため、プログラマが明示的にメモリを解放する必要はありません。
• 領域のサイズは通常、コンパイル時に決定され、ヒープ領域に比べて比較的小さいです（通常数MB程度）。
• スタック領域が一杯になるとスタックオーバーフローが発生し、プログラムがクラッシュする可能性があります。
• データは、そのデータが宣言されたスコープ（通常は関数）内でのみ有効です。スコープを抜けると自動的に解放されます。

割り当てと解放:

関数が呼び出されると、その関数のためのスタックフレームがスタックの最上部に作成（プッシュ）されます。このフレームには、ローカル変数、引数、戻りアドレスなどが格納されます。関数が終了すると、対応するスタックフレームはスタックから取り除かれ（ポップされ）、そのメモリは解放されたとみなされます。

サンプルコード:

#include <iostream>

void myFunction(int param) { // param はスタックにコピーされる
    int localVar = 10; // localVar は myFunction のスタックフレームに確保される
    std::cout << "param: " << param << ", localVar: " << localVar << std::endl;
    // param と localVar は myFunction 終了時に自動的に破棄される
}

int main() {
    int mainVar = 5; // mainVar は main のスタックフレームに確保される
    myFunction(mainVar);
    // mainVar は main 終了時に自動的に破棄される
    return 0;
}

2.2. ヒープ領域 (Heap / Free Store)

ヒープ領域（フリーストアとも呼ばれる）は、プログラムの実行中に動的にメモリを割り当てたり解放したりするために使用されます。スタックとは異なり、ヒープに割り当てられたメモリの生存期間はスコープに束縛されず、プログラマが明示的に解放するまで、あるいはプログラムが終了するまで存在し続けます。

特性:

• 大きなメモリ領域を確保でき、サイズは実行時に決定できます。
• メモリの割り当て（`new`、`malloc`など）と解放（`delete`、`free`など）はプログラマが手動で行う必要があります（C++の場合）。
• スタックに比べて割り当てと解放のコストが高いです。これは、利用可能なメモリブロックを見つける必要があるためです。
• メモリの断片化（フラグメンテーション）が発生しやすいです。
• 適切に解放されないとメモリリークが発生し、プログラムが利用可能なメモリを使い果たしてしまう可能性があります。

割り当てと解放:

C++では、`new`演算子を使ってヒープからメモリを割り当て、`delete`演算子を使って解放します。`new`は割り当てられたメモリブロックの先頭アドレスを指すポインタを返します。

サンプルコード:

#include <iostream>

class MyClass {
public:
    int data;
    MyClass(int d) : data(d) { std::cout << "MyClass(" << data << ") created on heap.\n"; }
    ~MyClass() { std::cout << "MyClass(" << data << ") destroyed.\n"; }
};

int main() {
    int* p_int = new int(100); // ヒープに int を割り当て
    MyClass* p_obj = new MyClass(200); // ヒープに MyClass オブジェクトを割り当て

    std::cout << "Value of int on heap: " << *p_int << std::endl;
    std::cout << "Data in MyClass object on heap: " << p_obj->data << std::endl;

    delete p_int;    // int を解放
    p_int = nullptr; 

    delete p_obj;    // MyClass オブジェクトを解放
    p_obj = nullptr; 

    return 0;
}

現代のオペレーティングシステムでは仮想メモリが利用されており、スタックとヒープが物理メモリ上で必ずしも連続しているわけではなく、アドレス空間配置のランダム化（ASLR）によって正確な位置を予測することは困難です。しかし、スタックとヒープが共有された有限の論理アドレス空間を消費するという概念モデルは、リソースの限界を理解する上で依然として有効です。スタックオーバーフローやヒープの枯渇は、プロセスがそのセグメントに割り当てられた論理アドレス空間を使い果たしたことを意味します。

2.3. 静的/グローバルデータ領域 (Static/Global Data Segment)

静的/グローバルデータ領域は、グローバル変数と静的変数（ローカルスコープの静的変数およびクラスレベルの静的変数を含む）を格納します。これらの変数の寿命はプログラムの実行期間全体です。メモリはプログラムの開始前に割り当てられ、`main()`関数が実行される前に初期化されることがあります。

この領域はさらに2つに分けられます:

• 初期化済みデータセグメント (Initialized Data Segment / DS): プログラマによって明示的な初期値が与えられたグローバル変数と静的変数が格納されます。
• 未初期化データセグメント (Uninitialized Data Segment / BSS): 明示的な初期値なしで宣言されたグローバル変数と静的変数が格納されます。これらの変数は通常、オペレーティングシステムによって実行時にゼロで初期化されます。

サンプルコード:

#include <iostream>

int global_initialized_var = 10; // 初期化済みデータセグメント
int global_uninitialized_var;    // BSS (ゼロ初期化)

static int static_initialized_var = 20; // 初期化済みデータセグメント
static int static_uninitialized_var;    // BSS (ゼロ初期化)

void func() {
    static int static_local_var = 30; // 初期化済みデータセグメント
    std::cout << "Static local var: " << static_local_var++ << std::endl;
}

int main() {
    std::cout << "Global initialized: " << global_initialized_var << std::endl;
    std::cout << "Global uninitialized: " << global_uninitialized_var << std::endl;
    func(); // Static local var: 30
    func(); // Static local var: 31
    return 0;
}

2.4. テキスト領域 (Text / Code Segment)

テキスト領域（コードセグメントとも呼ばれる）には、プログラムのコンパイル済み機械語コード（実行可能な命令群）が格納されます。

特性:

• 通常、読み取り専用であり、プログラム実行中に誤ってコードが変更されるのを防ぎます。
• 同じプログラムを実行する複数のプロセス間で共有されることがあり、メモリ使用量を節約できます。

2.5. メモリ領域の比較

3.1. int

int型は基本的な整数型です。

• サイズ: ほとんどの現代のシステムでは通常4バイト（32ビット）ですが、C++標準は少なくとも16ビットを保証しています。
• 表現: 符号付き整数は、ほぼ普遍的に2の補数形式で表現されます。
• エンディアンネス: 複数バイト型の場合、メモリ内でのバイト順序はエンディアンネスに影響されます（リトルエンディアン/ビッグエンディアン）。

サンプルコード:

#include <iostream>
#include <climits>

void print_bytes(const void* object, size_t size) {
    const unsigned char* bytes = static_cast<const unsigned char*>(object);
    std::cout << "Bytes (address: value): ";
    for (size_t i = 0; i < size; ++i) {
        std::cout << "[" << static_cast<const void*>(bytes + i) << ": "
                  << std::hex << static_cast<int>(bytes[i]) << std::dec << "] ";
    }
    std::cout << std::endl;
}

int main() {
    int num = 0x0A0B0C0D; 
    std::cout << "int num = 0x" << std::hex << num << std::dec << std::endl;
    std::cout << "sizeof(int): " << sizeof(int) << " bytes" << std::endl;
    print_bytes(&num, sizeof(num));
    return 0;
}

3.2. float と double

floatとdoubleは浮動小数点数を扱います。通常、IEEE 754標準で実装されます。

• float: 単精度、通常4バイト。符号1bit, 指数8bit, 仮数23bit。
• double: 倍精度、通常8バイト。符号1bit, 指数11bit, 仮数52bit。

サンプルコード:

#include <iostream>
#include <cmath>
#include <iomanip>

int main() {
    float f_val = 3.14f;
    double d_val = 2.718281828459045;
    std::cout << "sizeof(float): " << sizeof(float) << ", value: " 
              << std::fixed << std::setprecision(7) << f_val << std::endl;
    // ... (0.1 + 0.2 != 0.3 のデモなど)
    return 0;
}

3.3. char

char型は文字表現のための型です。

• サイズ: 常に1バイト (`sizeof(char)`は1)。
• 符号: `char`はデフォルトで符号付きか符号なしかがコンパイラ依存。
• エンコーディング: ASCIIやUTF-8 (UTF-8では1文字が複数バイトになることも)。

サンプルコード:

#include <iostream>
#include <string>

int main() {
    char c1 = 'A';
    std::cout << "sizeof(char): " << sizeof(char) << std::endl;
    std::cout << "c1: " << c1 << ", int(c1): " << static_cast<int>(c1) << std::endl;
    
    std::string utf8_char_str = "€";
    std::cout << "UTF-8 Euro sign: " << utf8_char_str 
              << ", length: " << utf8_char_str.length() << " bytes" << std::endl;
    return 0;
}

3.4. void と void*

• void: 「型がない」を示す不完全型。変数は宣言不可。
• void*: あらゆるデータ型を指せる汎用ポインタ。逆参照前にキャストが必要。

サンプルコード:

#include <iostream>

void print_value(void* data, char type_char) {
    if (type_char == 'i') {
        std::cout << "Int: " << *static_cast<int*>(data) << std::endl;
    } // ... 他の型も同様
}
int main() {
    int my_int = 123;
    void* void_ptr = &my_int;
    print_value(void_ptr, 'i');
    // *void_ptr; // コンパイルエラー
    return 0;
}

3.5. 基本データ型の概要

4.1. 宣言、初期化、連続メモリ

type name[size]; で宣言。要素はメモリ上で連続します。

4.2. スタック割り当て配列 vs. ヒープ割り当て配列

• スタック配列: ローカル宣言、スコープ依存の寿命、コンパイル時サイズ。
• ヒープ配列: `new type[size]`、手動解放 (`delete[]`)、実行時サイズ。

サンプルコード:

#include <iostream>
void array_on_stack() {
    int st_arr[5] = {1,2,3,4,5}; // スタック
    // ... st_arr は関数終了で破棄
}
void array_on_heap(int size) {
    int* hp_arr = new int[size]; // ヒープ
    // ...
    delete[] hp_arr; // 手動解放
}
// ...
                    

4.3. 配列名とポインタ（配列のdecay）

多くの場合、配列名は最初の要素へのポインタに「decay」します。関数に渡すとサイズ情報が失われます。

サンプルコード:

#include <iostream>
// arr_param は実際には int*
void print_array_size_decay(int arr_param[]) { 
    std::cout << "sizeof(arr_param) in func: " << sizeof(arr_param) << std::endl; // ポインタのサイズ
}
int main() {
    int arr[5] = {1,2,3,4,5};
    std::cout << "sizeof(arr) in main: " << sizeof(arr) << std::endl; // 配列全体のサイズ
    print_array_size_decay(arr);
    return 0;
}

5.1. std::vector

動的サイズの配列。要素はメモリ上で連続。size()とcapacity()を持ち、capacityを超えると再割り当てが発生。

インタラクティブデモ: std::vector

サンプルコード:

#include <iostream>
#include <vector>
int main() {
    std::vector<int> vec;
    vec.reserve(5);
    for (int i = 0; i < 8; ++i) {
        vec.push_back(i);
        std::cout << "Added " << i << " - capacity: " << vec.capacity() 
                  << ", size: " << vec.size() << std::endl;
    }
    return 0;
}

5.2. std::list

双方向リンクリスト。要素は非連続。各要素はノード（データ + prev/nextポインタ）に格納。挿入/削除はO(1)。

インタラクティブデモ: std::list

サンプルコード:

#include <iostream>
#include <list>
#include <string>
int main() {
    std::list<std::string> l;
    l.push_back("Banana");
    l.push_front("Apple");
    // ...
    return 0;
}

5.3. std::deque (両端キュー)

先頭/末尾での挿入/削除がO(1)。固定サイズのチャンク（ブロック）のシーケンスとして実装されることが多い。

インタラクティブデモ: std::deque

サンプルコード:

#include <iostream>
#include <deque>
int main() {
    std::deque<int> dq;
    dq.push_back(10);
    dq.push_front(5);
    // ...
    return 0;
}

5.4. std::stack と std::queue

コンテナアダプタ。デフォルト基底コンテナはstd::deque。

インタラクティブデモ: std::stack

インタラクティブデモ: std::queue

サンプルコード:

#include <iostream>
#include <stack>
#include <queue>
int main() {
    std::stack<int> s; s.push(1); s.push(2); // top is 2
    std::queue<int> q; q.push(1); q.push(2); // front is 1
    return 0;
}

5.5. std::map と std::set

連想コンテナ。通常、赤黒木で実装。要素はキーでソート。検索/挿入/削除はO(log N)。

インタラクティブデモ: std::map

インタラクティブデモ: std::set

サンプルコード:

#include <iostream>
#include <map>
#include <set>
#include <string>
int main() {
    std::map<std::string, int> ages; ages["Alice"] = 30;
    std::set<int> numbers; numbers.insert(50);
    return 0;
}

5.6. STLコンテナのメモリ特性の概要

6.1. 定義、宣言、初期化 (nullptr)

type* pointer_name;。初期化は変数のアドレスかnullptrへ。

6.2. アドレス演算子 (&) と間接参照演算子 (*)

&varでアドレス取得、*ptrでポインタが指す値にアクセス。

サンプルコード:

#include <iostream>
int main() {
    int val = 42;
    int* ptr_val = &val;
    std::cout << "Address of val: " << &val << std::endl;
    std::cout << "Value in ptr_val: " << ptr_val << std::endl;
    std::cout << "Value pointed to by ptr_val: " << *ptr_val << std::endl;
    *ptr_val = 100; // val の値を変更
    std::cout << "New value of val: " << val << std::endl; // 100
    return 0;
}

6.3. ポインタ演算

ptr++, ptr + n など。操作はsizeof(pointed_type)でスケーリング。

サンプルコード:

#include <iostream>
int main() {
    int arr[] = {10, 20, 30};
    int* ptr = arr; // arr[0] を指す
    ptr++;          // arr[1] を指す
    std::cout << "*ptr: " << *ptr << std::endl; // 20
    return 0;
}

6.4. スタック変数へのポインタ vs. ヒープ変数へのポインタ

ポインタはスタック上の変数もヒープ上のデータも指せます。スコープや寿命に注意。

7.1. ポインタとの関係と主な違い

逆参照(*it)、インクリメント(++it)は類似。イテレータはより高レベルな抽象化。

7.2. イテレータによるメモリ移動（内部メカニズム）

• vector::iterator: ポインタに近い。++itは次の要素へ。
• list::iterator: ノードポインタを保持。++itはnextポインタを辿る。
• map::iterator: ツリーノードポインタを保持。++itは木の順序に従う。

サンプルコード:

#include <iostream>
#include <vector>
#include <list>
#include <map>
int main() {
    std::vector<int> v = {10, 20};
    for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    // list, map も同様にイテレート可能
    return 0;
}