配列

[C++] 二次元配列の使い方をマスターする

C++で二次元配列を扱うには、配列の宣言、初期化、アクセス方法を理解することが重要です。

二次元配列は「行」と「列」で構成され、宣言は型名配列名[行数][列数];の形式で行います。

初期化は{{値1, 値2}, {値3, 値4}}のように行列形式で指定します。

要素へのアクセスは配列名[行インデックス][列インデックス]を使用します。

インデックスは0から始まるため注意が必要です。

ループを用いると効率的に操作可能で、特にforループをネストして行列全体を処理するのが一般的です。

動的配列を使う場合は、ポインタとnewを活用し、メモリ管理を適切に行う必要があります。

目次から探す

二次元配列とは？
- 二次元配列の特徴
- 二次元配列の使用例
二次元配列の宣言と初期化
二次元配列の要素へのアクセス
- 要素へのアクセス方法
- 要素の変更
二次元配列の操作例
二次元配列の応用例
二次元配列とSTLの比較
二次元配列のメモリ管理
まとめ

二次元配列とは？

二次元配列は、配列の中に配列を持つデータ構造で、行と列の形式でデータを格納します。

これにより、表形式のデータを効率的に扱うことができます。

例えば、行列やグリッド状のデータを表現するのに適しています。

C++では、二次元配列を使うことで、複雑なデータを整理し、アクセスしやすくすることが可能です。

二次元配列の特徴

行と列: 二次元配列は、行と列の組み合わせで要素を管理します。
固定サイズ: 配列のサイズは宣言時に決定され、変更できません。
メモリの連続性: メモリ上に連続して配置されるため、効率的なアクセスが可能です。

二次元配列の使用例

以下は、二次元配列を使って3行2列の整数を格納する例です。

#include <iostream>
int main() {
    // 3行2列の二次元配列を宣言
    int array[3][2] = {
        {1, 2},
        {3, 4},
        {5, 6}
    };
    // 配列の要素を出力
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            std::cout << array[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

1 2 
3 4 
5 6

この例では、3行2列の二次元配列を宣言し、各要素に整数を格納しています。

二重ループを使用して、配列の全要素を出力しています。

二次元配列の宣言と初期化

C++における二次元配列の宣言と初期化は、一次元配列と似ていますが、行と列のサイズを指定する必要があります。

以下に、二次元配列の宣言方法と初期化の方法を詳しく説明します。

二次元配列の宣言

二次元配列を宣言する際は、次のように行数と列数を指定します。

データ型 配列名[行数][列数];

例えば、整数型の二次元配列を3行4列で宣言する場合は次のようになります。

int array[3][4];

二次元配列の初期化

二次元配列は、宣言と同時に初期化することができます。

初期化は、波括弧 {} を使って行います。

以下に、初期化の例を示します。

int array[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

初期化の省略

初期化を省略した場合、配列の要素は自動的に0で初期化されます。

以下のように宣言することも可能です。

int array[3][4]; // 要素はすべて0で初期化される

以下は、二次元配列を宣言し、初期化した後に要素を出力する例です。

#include <iostream>
int main() {
    // 3行4列の二次元配列を宣言と初期化
    int array[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    // 配列の要素を出力
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << array[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

1 2 3 4 
5 6 7 8 
9 10 11 12

この例では、3行4列の二次元配列を宣言し、初期化した後、全要素を出力しています。

二次元配列の宣言と初期化は非常にシンプルで、行列データを扱う際に便利です。

二次元配列の要素へのアクセス

二次元配列の要素には、行と列のインデックスを使用してアクセスします。

C++では、配列のインデックスは0から始まるため、最初の行や列はインデックス0で表されます。

以下に、要素へのアクセス方法を詳しく説明します。

要素へのアクセス方法

二次元配列の要素にアクセスするには、次の構文を使用します。

配列名[行インデックス][列インデックス]

例えば、arrayという名前の二次元配列の2行目3列目の要素にアクセスする場合は、次のように記述します。

array[1][2]; // 2行目3列目の要素にアクセス

要素の変更

要素にアクセスした後、その値を変更することも可能です。

以下の例では、特定の要素の値を変更しています。

array[1][2] = 99; // 2行目3列目の要素を99に変更

以下は、二次元配列の要素にアクセスし、値を変更した後に全要素を出力する例です。

#include <iostream>
int main() {
    // 3行3列の二次元配列を宣言と初期化
    int array[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    // 2行目3列目の要素を変更
    array[1][2] = 99; // 6を99に変更
    // 配列の要素を出力
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << array[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

1 2 3 
4 5 99 
7 8 9

この例では、2行目3列目の要素を99に変更し、その後全要素を出力しています。

二次元配列の要素へのアクセスは非常に直感的で、行列データの操作を簡単に行うことができます。

二次元配列の操作例

二次元配列を使用すると、さまざまなデータ操作が可能です。

ここでは、二次元配列の基本的な操作例をいくつか紹介します。

具体的には、要素の合計、転置、特定の行や列の取得などの操作を行います。

1. 要素の合計

二次元配列内の全要素の合計を計算する方法を示します。

#include <iostream>
int main() {
    // 3行3列の二次元配列を宣言と初期化
    int array[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int sum = 0; // 合計を格納する変数
    // 全要素の合計を計算
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            sum += array[i][j]; // 要素を合計
        }
    }
    std::cout << "全要素の合計: " << sum << std::endl; // 合計を出力
    return 0;
}

全要素の合計: 45

2. 転置行列

二次元配列の転置を行う方法を示します。

転置行列とは、行と列を入れ替えた行列のことです。

#include <iostream>
int main() {
    // 2行3列の二次元配列を宣言と初期化
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    // 転置行列を格納する配列
    int transpose[3][2];
    // 転置を計算
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            transpose[j][i] = array[i][j]; // 行と列を入れ替え
        }
    }
    // 転置行列を出力
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            std::cout << transpose[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

1 4 
2 5 
3 6

3. 特定の行の取得

特定の行を取得して出力する方法を示します。

以下の例では、2行目を取得します。

#include <iostream>
int main() {
    // 3行3列の二次元配列を宣言と初期化
    int array[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int rowIndex = 1; // 取得したい行のインデックス(2行目)
    // 特定の行を出力
    std::cout << "行 " << rowIndex + 1 << ": ";
    for (int j = 0; j < 3; j++) {
        std::cout << array[rowIndex][j] << " "; // 行の要素を出力
    }
    std::cout << std::endl; // 行の区切り
    return 0;
}

行 2: 4 5 6

これらの例では、二次元配列を使った基本的な操作を示しました。

要素の合計、転置行列の作成、特定の行の取得など、二次元配列は多様なデータ操作に役立ちます。

これらの操作を理解することで、より複雑なデータ処理が可能になります。

二次元配列の応用例

二次元配列は、さまざまな場面で応用される強力なデータ構造です。

ここでは、実際のプログラミングにおける二次元配列の応用例をいくつか紹介します。

具体的には、マトリックス演算、ゲームのボード、画像処理などの例を取り上げます。

1. マトリックス演算

二次元配列は、数学的なマトリックスの演算に非常に便利です。

以下の例では、2つの行列の加算を行います。

#include <iostream>
int main() {
    // 2行2列の行列を宣言と初期化
    int matrixA[2][2] = {
        {1, 2},
        {3, 4}
    };
    
    int matrixB[2][2] = {
        {5, 6},
        {7, 8}
    };
    
    int result[2][2]; // 結果を格納する行列
    // 行列の加算
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            result[i][j] = matrixA[i][j] + matrixB[i][j]; // 要素ごとに加算
        }
    }
    // 結果を出力
    std::cout << "行列の加算結果:" << std::endl;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            std::cout << result[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

行列の加算結果:
6 8 
10 12

2. ゲームのボード

二次元配列は、ゲームのボードを表現するのにも適しています。

以下の例では、簡単なマス目のボードを作成し、特定の位置にプレイヤーのマークを置きます。

#include <iostream>
int main() {
    // 3x3のゲームボードを宣言と初期化
    char board[3][3] = {
        {'-', '-', '-'},
        {'-', '-', '-'},
        {'-', '-', '-'}
    };
    // プレイヤーのマークを置く
    board[1][1] = 'X'; // 中央にXを置く
    // ボードを出力
    std::cout << "ゲームボード:" << std::endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << board[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

ゲームボード:
- - - 
- X - 
- - -

3. 画像処理

二次元配列は、画像のピクセルデータを表現するのにも使用されます。

以下の例では、簡単なグレースケール画像を表現し、ピクセルの値を出力します。

#include <iostream>
int main() {
    // 3x3のグレースケール画像を宣言と初期化
    int image[3][3] = {
        {255, 128, 64},
        {0, 128, 255},
        {64, 192, 128}
    };
    // 画像のピクセル値を出力
    std::cout << "グレースケール画像のピクセル値:" << std::endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << image[i][j] << " "; // ピクセル値を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

グレースケール画像のピクセル値:
255 128 64 
0 128 255 
64 192 128

これらの例からもわかるように、二次元配列は多くの実用的なアプリケーションで使用されます。

マトリックス演算、ゲームのボード、画像処理など、さまざまな分野でのデータ管理や操作に役立ちます。

二次元配列を使いこなすことで、より複雑なプログラムを効率的に構築することが可能になります。

二次元配列とSTLの比較

C++では、二次元配列とSTL(Standard Template Library)のコンテナを使用してデータを管理することができます。

ここでは、二次元配列とSTLのstd::vectorを比較し、それぞれの利点と欠点を説明します。

1. 二次元配列の特徴

特徴	説明
サイズ固定	宣言時にサイズを決定し、変更できない。
メモリ効率	メモリ上に連続して配置されるため、効率的。
アクセス速度	インデックスを使用したアクセスが高速。
初期化の簡便さ	簡単に初期化できる。

2. STLのstd::vectorの特徴

特徴	説明
サイズ可変	要素の追加や削除が可能。
メモリ管理	自動的にメモリを管理し、必要に応じて再配置。
多次元配列の実装	`std::vector<std::vector<T>>`で実現可能。
標準ライブラリの機能	アルゴリズムやイテレータなどの機能が豊富。

3. 二次元配列とstd::vectorの比較

比較項目	二次元配列	`std::vector`
サイズ	固定	可変
メモリ管理	手動管理	自動管理
アクセス速度	高速	やや遅い(オーバーヘッドあり)
初期化の簡便さ	簡単	やや複雑(ネストされたベクター)
使用例	行列計算、固定サイズのデータ	動的データ、サイズが変動するデータ

4. サンプルコード：二次元配列とstd::vectorの使用例

以下は、二次元配列とstd::vectorを使った同様の操作の例です。

二次元配列の例

#include <iostream>
int main() {
    // 2行3列の二次元配列を宣言と初期化
    int array[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    // 要素を出力
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << array[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

std::vectorの例

#include <iostream>
#include <vector>
int main() {
    // 2行3列のstd::vectorを宣言と初期化
    std::vector<std::vector<int>> vec = {
        {1, 2, 3},
        {4, 5, 6}
    };
    // 要素を出力
    for (size_t i = 0; i < vec.size(); i++) {
        for (size_t j = 0; j < vec[i].size(); j++) {
            std::cout << vec[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    return 0;
}

二次元配列とSTLのstd::vectorは、それぞれ異なる利点と欠点を持っています。

固定サイズのデータを扱う場合は二次元配列が適しており、動的にサイズが変わるデータを扱う場合はstd::vectorが便利です。

使用する場面に応じて、適切なデータ構造を選択することが重要です。

二次元配列のメモリ管理

C++における二次元配列のメモリ管理は、配列のサイズや使用方法に応じて適切に行う必要があります。

ここでは、二次元配列のメモリ管理の基本、メモリの割り当て、解放、そして動的配列の使用方法について説明します。

1. スタティック配列とダイナミック配列

スタティック配列: コンパイル時にサイズが決定され、プログラムの実行中にサイズを変更できません。

メモリはスタックに割り当てられます。

ダイナミック配列: 実行時にサイズを決定し、必要に応じてメモリを動的に割り当てます。

メモリはヒープに割り当てられ、使用後は手動で解放する必要があります。

2. スタティック二次元配列のメモリ管理

スタティック二次元配列は、次のように宣言します。

int array[3][4]; // 3行4列のスタティック配列

この場合、メモリは自動的に割り当てられ、プログラムのスコープが終了すると自動的に解放されます。

3. ダイナミック二次元配列のメモリ管理

ダイナミック二次元配列を使用する場合、new演算子を使ってメモリを割り当て、delete演算子で解放します。

以下に、ダイナミック二次元配列の例を示します。

ダイナミック二次元配列の例

#include <iostream>
int main() {
    int rows = 3;
    int cols = 4;
    // ダイナミック二次元配列のメモリを割り当て
    int** array = new int*[rows]; // 行のポインタ配列を作成
    for (int i = 0; i < rows; i++) {
        array[i] = new int[cols]; // 各行に列の配列を作成
    }
    // 配列に値を代入
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            array[i][j] = i * cols + j + 1; // 値を代入
        }
    }
    // 配列の要素を出力
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cout << array[i][j] << " "; // 要素を出力
        }
        std::cout << std::endl; // 行の区切り
    }
    // メモリの解放
    for (int i = 0; i < rows; i++) {
        delete[] array[i]; // 各行のメモリを解放
    }
    delete[] array; // 行のポインタ配列を解放
    return 0;
}