vector

[C++] vector二次元配列に値を代入する方法

2025-04-14更新日: 2025-04-14

C++で二次元配列を扱う際、std::vectorを使用することで動的なサイズ変更が可能です。

二次元配列はstd::vector<std::vector<int>>のように定義されます。

値を代入するには、まず外側のvectorに対してpush_backを用いて内側のvectorを追加し、その後、内側のvectorに対してpush_backやインデックスを用いて値を代入します。

この方法により、柔軟に二次元配列を操作することができます。

目次から探す

二次元vectorへの値の代入方法
二次元vectorの操作
応用例
まとめ

二次元vectorへの値の代入方法

C++のvectorを使って二次元配列を扱う際、値を代入する方法はいくつかあります。

ここでは、インデックスを使った方法、ループを使った方法、そしてstd::fillを使った方法について解説します。

インデックスを使った代入

インデックスを使った代入は、特定の位置に直接値を設定する方法です。

以下のサンプルコードでは、二次元vectorに対してインデックスを指定して値を代入しています。

#include <iostream>
#include <vector>
int main() {
    // 3x3の二次元vectorを作成
    std::vector<std::vector<int>> matrix(3, std::vector<int>(3));
    // インデックスを使って値を代入
    matrix[0][0] = 1;
    matrix[0][1] = 2;
    matrix[0][2] = 3;
    matrix[1][0] = 4;
    matrix[1][1] = 5;
    matrix[1][2] = 6;
    matrix[2][0] = 7;
    matrix[2][1] = 8;
    matrix[2][2] = 9;
    // 結果を出力
    for (const auto& row : matrix) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

1 2 3 
4 5 6 
7 8 9

この方法は、特定の位置に直接アクセスして値を設定するため、簡単で直感的です。

ただし、インデックスを間違えると意図しない位置に値を代入してしまう可能性があるため注意が必要です。

ループを使った代入

ループを使った代入は、forループやwhileループを用いて、二次元vectorの各要素に値を設定する方法です。

以下のサンプルコードでは、二重のforループを使って値を代入しています。

#include <iostream>
#include <vector>
int main() {
    // 3x3の二次元vectorを作成
    std::vector<std::vector<int>> matrix(3, std::vector<int>(3));
    // ループを使って値を代入
    int value = 1;
    for (size_t i = 0; i < matrix.size(); ++i) {
        for (size_t j = 0; j < matrix[i].size(); ++j) {
            matrix[i][j] = value++;
        }
    }
    // 結果を出力
    for (const auto& row : matrix) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

1 2 3 
4 5 6 
7 8 9

ループを使うことで、規則的な値の代入や、条件に基づいた値の設定が容易になります。

特に、行列全体に同じ処理を施す場合に便利です。

std::fillを使った代入

std::fillを使った代入は、<algorithm>ヘッダに含まれるstd::fill関数を利用して、vectorの範囲に同じ値を設定する方法です。

以下のサンプルコードでは、std::fillを使って二次元vectorを初期化しています。

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    // 3x3の二次元vectorを作成
    std::vector<std::vector<int>> matrix(3, std::vector<int>(3));
    // std::fillを使って値を代入
    for (auto& row : matrix) {
        std::fill(row.begin(), row.end(), 5);
    }
    // 結果を出力
    for (const auto& row : matrix) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

5 5 5 
5 5 5 
5 5 5

std::fillを使うことで、特定の値でvector全体を初期化することができます。

特に、全ての要素を同じ値にしたい場合に便利です。

二次元vectorの操作

二次元vectorは、C++で動的な二次元配列を扱うための便利なデータ構造です。

ここでは、二次元vectorの基本的な操作として、値の取得方法、サイズの取得方法、そしてvectorのリサイズ方法について解説します。

値の取得方法

二次元vectorから値を取得するには、インデックスを使用します。

以下のサンプルコードでは、二次元vectorから特定の位置の値を取得しています。

#include <iostream>
#include <vector>
int main() {
    // 3x3の二次元vectorを作成し、初期化
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    // インデックスを使って値を取得
    int value = matrix[1][2]; // 2行3列目の値を取得
    // 結果を出力
    std::cout << "取得した値: " << value << std::endl;
    return 0;
}

取得した値: 6

この方法では、vectorの行と列のインデックスを指定して、特定の要素の値を取得します。

インデックスは0から始まることに注意してください。

サイズの取得方法

二次元vectorのサイズを取得するには、size()メソッドを使用します。

以下のサンプルコードでは、二次元vectorの行数と列数を取得しています。

#include <iostream>
#include <vector>
int main() {
    // 3x3の二次元vectorを作成
    std::vector<std::vector<int>> matrix(3, std::vector<int>(3));
    // 行数と列数を取得
    size_t numRows = matrix.size();
    size_t numCols = matrix[0].size();
    // 結果を出力
    std::cout << "行数: " << numRows << ", 列数: " << numCols << std::endl;
    return 0;
}

行数: 3, 列数: 3

size()メソッドを使うことで、vectorの行数や列数を簡単に取得できます。

特に、動的にサイズが変わる場合に便利です。

vectorのリサイズ

二次元vectorのサイズを変更するには、resize()メソッドを使用します。

以下のサンプルコードでは、二次元vectorの行数と列数を変更しています。

#include <iostream>
#include <vector>
int main() {
    // 2x2の二次元vectorを作成
    std::vector<std::vector<int>> matrix(2, std::vector<int>(2, 0));
    // vectorのリサイズ
    matrix.resize(3); // 行数を3に変更
    for (auto& row : matrix) {
        row.resize(4, 0); // 各行の列数を4に変更
    }
    // 結果を出力
    for (const auto& row : matrix) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

0 0 0 0 
0 0 0 0 
0 0 0 0

resize()メソッドを使うことで、vectorの行数や列数を動的に変更できます。

新しい要素は指定した初期値で初期化されます。

リサイズ後の要素数が元の要素数より少ない場合、余分な要素は削除されます。

応用例

二次元vectorは、行列のようなデータを扱う際に非常に便利です。

ここでは、二次元vectorを使った行列の加算、転置、スカラー倍の応用例を紹介します。

二次元vectorを使った行列の加算

行列の加算は、同じサイズの行列同士の対応する要素を足し合わせる操作です。

以下のサンプルコードでは、二つの行列を加算しています。

#include <iostream>
#include <vector>
std::vector<std::vector<int>> addMatrices(const std::vector<std::vector<int>>& matrixA, const std::vector<std::vector<int>>& matrixB) {
    size_t numRows = matrixA.size();
    size_t numCols = matrixA[0].size();
    std::vector<std::vector<int>> result(numRows, std::vector<int>(numCols));
    for (size_t i = 0; i < numRows; ++i) {
        for (size_t j = 0; j < numCols; ++j) {
            result[i][j] = matrixA[i][j] + matrixB[i][j];
        }
    }
    return result;
}
int main() {
    std::vector<std::vector<int>> matrixA = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    std::vector<std::vector<int>> matrixB = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    std::vector<std::vector<int>> result = addMatrices(matrixA, matrixB);
    // 結果を出力
    for (const auto& row : result) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

10 10 10 
10 10 10 
10 10 10

このコードでは、addMatrices関数を使って、二つの行列を加算しています。

行列のサイズが同じであることが前提です。

二次元vectorを使った行列の転置

行列の転置は、行と列を入れ替える操作です。

以下のサンプルコードでは、行列を転置しています。

#include <iostream>
#include <vector>
std::vector<std::vector<int>> transposeMatrix(const std::vector<std::vector<int>>& matrix) {
    size_t numRows = matrix.size();
    size_t numCols = matrix[0].size();
    std::vector<std::vector<int>> result(numCols, std::vector<int>(numRows));
    for (size_t i = 0; i < numRows; ++i) {
        for (size_t j = 0; j < numCols; ++j) {
            result[j][i] = matrix[i][j];
        }
    }
    return result;
}
int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    std::vector<std::vector<int>> result = transposeMatrix(matrix);
    // 結果を出力
    for (const auto& row : result) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

1 4 7 
2 5 8 
3 6 9

このコードでは、transposeMatrix関数を使って、行列を転置しています。

転置後の行列の行数と列数が元の行列の列数と行数に入れ替わります。

二次元vectorを使った行列のスカラー倍

行列のスカラー倍は、行列の全ての要素に同じスカラー値を掛ける操作です。

以下のサンプルコードでは、行列をスカラー倍しています。

#include <iostream>
#include <vector>
std::vector<std::vector<int>> scalarMultiplyMatrix(const std::vector<std::vector<int>>& matrix, int scalar) {
    size_t numRows = matrix.size();
    size_t numCols = matrix[0].size();
    std::vector<std::vector<int>> result(numRows, std::vector<int>(numCols));
    for (size_t i = 0; i < numRows; ++i) {
        for (size_t j = 0; j < numCols; ++j) {
            result[i][j] = matrix[i][j] * scalar;
        }
    }
    return result;
}
int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int scalar = 2;
    std::vector<std::vector<int>> result = scalarMultiplyMatrix(matrix, scalar);
    // 結果を出力
    for (const auto& row : result) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}