にアクセスしていますが、size() は 3 であり、これは未定義動作です

C++ 容器类 <vector>C++ コンテナクラス <vector>


vectorの要素にアクセスするすべての方法の中で、operator[]は最も一般的で直接的な方法であり、配列の要素にアクセスするのと同じです。

operator[]はコンテナクラスの添字演算子であり、指定された位置の要素を返すために使用されますが、境界チェックは行いません。使い方は通常の配列とまったく同じです。

operator[]配列のようなランダムアクセス機能を提供し、任意の位置の要素にすばやくアクセスできます。

単語の意味: operator[]は添字演算子であり、角括弧は配列アクセスの目印です。


基本構文とパラメータ

operator[]はコンテナクラスのメンバ関数であり、配列と同じように使用するだけです。

構文形式

reference operator[](size_type pos);
const_reference operator[](size_type pos) const;

パラメータの説明

  • パラメータ: pos
    • 型:size_type(符号なし整数型、通常はsize_t)
    • 説明: アクセスする要素の位置(インデックス)。インデックスは0から始まり、最大有効インデックスはsize() - 1。

関数の説明

  • 戻り値: 指定された位置の要素の参照。コンテナがconstコンテナの場合は、const参照を返します。
  • 効果: 指定された位置の要素を返します。境界チェックは行われず、範囲外アクセスの結果は未定義です。
  • at() との違い: operator[]境界チェックを行わないため、速度がわずかに速い;at()境界チェックを行い、範囲外の場合は例外をスローします。

実例

簡単なものから複雑なものまでの一連の例を通して、operator[]の使い方を完全にマスターしましょう。

例1:基本の使い方 - 要素へのアクセス

実例

#include <iostream>
#include <vector>

int main() {
    // 1. vectorを作成し、いくつかの要素を追加する
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    std::cout << "vectorのサイズは: " << numbers.size() << std::endl;

    // 2. operator[] を使用して要素にアクセスする
    std::cout << "最初の要素 << numbers[0] << std::endl;
    std::cout << "2番目の要素 << numbers[1] << std::endl;
    std::cout << "3番目の要素 << numbers[2] << std::endl;
    std::cout << "最後の要素 << numbers[4] << std::endl;

    // 3. ループを使用してすべての要素にアクセスする
    std::cout << "すべての要素: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

実行結果の予想:

vector的大小是: 5
第一个元素 [0]: 10
第二个元素 [1]: 20
第三个元素 [2]: 30
最后一个元素 [4]: 50
所有元素: 10 20 30 40 50

コードの解説:

  1. numbers[0]最初の要素を返します10(インデックスは0から始まります)。
  2. numbers[4]最後の要素を返します50(なぜならsize()は5であり、有効なインデックスは0-4だからです)。
  3. ループとoperator[]operator[] を使用すると、すべての要素を走査できます。使い方は配列とまったく同じです。

例2:要素の値の変更

operator[]参照を返すため、要素の値を変更するために使用できます。

実例

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30};

    std::cout << "変更前: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // operator[] を使用して参照を取得し、要素を変更する
    numbers[0] = 100;
    numbers[1] = 200;
    numbers[2] = 300;

    std::cout << "変更後: ";
    for(size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

実行結果の予想:

修改前: 10 20 30
修改后: 100 200 300

コードの解説:

  • numbers[0] = 100;参照を通じて最初の要素の値を変更しました。
  • これは、operator[] がoperator[]変更可能な左辺値参照を返すことを示しています。

例3:autoによる型の自動推論

autoキーワードと組み合わせるautoと、operator[] をより便利に使用できます。operator[]。

実例

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

    // autoを使用して型を自動推論する
    for(size_t i = 0; i < names.size(); ++i) {
        auto& name = names[i]; // std::string& と推論される
        std::cout << "第 " << (i + 1) << " 番目の人: " << name << std::endl;
    }

    return 0;
}

実行結果の予想:

第 1 个人: Alice
第 2 个人: Bob
第 3 个人: Charlie

コードの解説:

  • auto& name = names[i];は std::string& と自動推論され、std::string&要素を直接変更できます。
  • 例4:operator[] と at() の違い

    operator[] と at() の動作の違いをoperator[]とat()比較します。

    実例

    #include <iostream>
    #include <vector>
    #include <stdexcept>

    int main() {
        std::vector<int> numbers = {10, 20, 30};

        // operator[] は境界チェックを行わず、範囲外アクセスは自己責任です
        // ここでは numbers
        // デモのために、有効な範囲のみにアクセスします

        std::cout << "operator[] アクセス:" << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
        }

        std::cout << "\n"at() アクセス(境界チェックあり):" << std::endl;
        for(size_t i = 0; i < 3; ++i) {
            std::cout << "numbers.at(" << i << ") = " << numbers.at(i) << std::endl;
        }

        std::cout << "\n推奨:インデックスが範囲外にならないことが確実な場合は operator[] を使用し、 << std::endl;
        std::cout << " 不確かな場合は、例外保護を得るために at() を使用します。" << std::endl;

        return 0;
    }

    コードの解説:

    • operator[]境界チェックを行わないため、アクセス速度が速くなります。
    • at()より安全ですが、例外処理のオーバーヘッドがあります。
    • 選択の推奨:インデックスが確実に安全な場合(ループ変数が0からsize()-1の間にある場合など)、operator[]operator[] を使用します。インデックスが外部入力に由来する場合や不確かな場合は、at() を使用します。at()。

    例5:ベクトルの内積の計算

    operator[] を使用してoperator[]ベクトル演算を実装します。

    実例

    #include <iostream>
    #include <vector>

    // 2つのベクトルの内積を計算する
    int dotProduct(const std::vector<int>& v1, const std::vector<int>& v2) {
        int result = 0;
        for(size_t i = 0; i < v1.size(); ++i) {
            result += v1[i] * v2[i];
        }
        return result;
    }

    int main() {
        std::vector<int> v1 = {1, 2, 3};
        std::vector<int> v2 = {4, 5, 6};

        int result = dotProduct(v1, v2);

        std::cout << "ベクトル v1: ";
        for(size_t i = 0; i < v1.size(); ++i) {
            std::cout << v1[i] << " ";
        }
        std::cout << std::endl;

        std::cout << "ベクトル v2: ";
        for(size_t i = 0; i < v2.size(); ++i) {
            std::cout << v2[i] << " ";
        }
        std::cout << std::endl;

        std::cout << "内積: " << result << std::endl;
        // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

        return 0;
    }

    実行結果の予想:

    向量 v1: 1 2 3
    向量 v2: 4 5 6
    点积: 32
    

    コードの解説:

    • operator[] を使用すると、operator[]アルゴリズム内でベクトルの要素にすばやくアクセスできます。
    • 内積の計算は、対応する位置の要素を掛け合わせてから合計するものです。

    C++ 容器类 <vector>C++ コンテナクラス <vector>

    その他の拡張