【C++】std::mapの使い方について詳しく解説

この記事では、C++の標準ライブラリに含まれるstd::mapの使い方について詳しく解説します。

std::mapは、キーと値のペアを管理する便利なデータ構造で、データの検索や管理が簡単に行えます。

この記事を読むことで、std::mapの基本的な使い方から高度な操作方法までを学び、実際のプログラムでどのように活用できるかを理解することができます。

初心者の方でもわかりやすいように、サンプルコードとその実行結果を交えながら説明していきますので、ぜひ参考にしてください。

目次から探す

std::mapとは

std::mapの基本概念

std::mapは、C++標準ライブラリに含まれる連想コンテナの一つです。

連想コンテナとは、キーと値のペアを管理するデータ構造で、キーを使って値にアクセスすることができます。

std::mapは、キーと値のペアを自動的にソートし、キーを使った高速な検索、挿入、削除をサポートします。

例えば、電話帳のように名前(キー)と電話番号(値)を管理する場合にstd::mapを使用することができます。

std::mapの特徴

std::mapには以下のような特徴があります:

  1. キーの一意性std::mapでは、各キーは一意でなければなりません。

同じキーを持つ複数の要素を持つことはできません。

  1. 自動ソートstd::mapは内部的にバランスの取れた二分探索木(通常は赤黒木)を使用しており、キーに基づいて要素が自動的にソートされます。
  2. 高速な検索:キーを使った検索操作は対数時間(O(log n))で行われます。
  3. メモリ効率std::mapはメモリ効率が良く、大量のデータを扱う場合でもパフォーマンスが安定しています。

std::mapと他のコンテナの比較

std::mapは他のC++標準ライブラリのコンテナと比較して、特定の用途に適しています。

以下にいくつかのコンテナとの比較を示します:

  • std::vectorstd::vectorは動的配列であり、要素の追加や削除が頻繁に行われる場合に適していますが、キーによる検索には向いていません。

一方、std::mapはキーによる高速な検索が可能です。

  • std::unordered_mapstd::unordered_mapはハッシュテーブルを使用しており、平均的な検索時間は定数時間(O(1))です。

しかし、要素がソートされないため、順序が重要な場合にはstd::mapが適しています。

  • std::setstd::setはキーのみを管理するコンテナで、値を持ちません。

キーの一意性と自動ソートという点ではstd::mapと似ていますが、キーと値のペアを管理する場合にはstd::mapが適しています。

以下に、std::mapの基本的な使い方を示すサンプルコードを紹介します:

#include <iostream>
#include <map>
int main() {
    // std::mapの宣言
    std::map<std::string, int> phoneBook;
    // 要素の追加
    phoneBook["Alice"] = 123456789;
    phoneBook["Bob"] = 987654321;
    // 要素のアクセス
    std::cout << "Alice's phone number: " << phoneBook["Alice"] << std::endl;
    std::cout << "Bob's phone number: " << phoneBook["Bob"] << std::endl;
    // 要素の削除
    phoneBook.erase("Alice");
    // 要素の検索
    if (phoneBook.find("Alice") == phoneBook.end()) {
        std::cout << "Alice is not in the phone book." << std::endl;
    }
    return 0;
}

このコードでは、std::mapを使って電話帳を管理しています。

AliceBobの電話番号を追加し、Aliceの電話番号を削除した後、Aliceが電話帳に存在しないことを確認しています。

std::mapの基本的な使い方

std::mapの宣言と初期化

空のstd::mapの宣言

まずは、空のstd::mapを宣言する方法について説明します。

std::mapはキーと値のペアを格納する連想コンテナで、キーは一意でなければなりません。

以下のコードは、キーがint型で値がstd::string型の空のstd::mapを宣言する例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap;
    return 0;
}

初期値を持つstd::mapの宣言

次に、初期値を持つstd::mapの宣言方法について説明します。

以下のコードは、いくつかの初期値を持つstd::mapを宣言する例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {
        {1, "Apple"},
        {2, "Banana"},
        {3, "Cherry"}
    };
    // マップの内容を表示
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、以下のように初期値が表示されます。

1: Apple
2: Banana
3: Cherry

要素の追加と削除

要素の追加(insertとoperator[])

std::mapに要素を追加する方法は主に2つあります。

insertメソッドoperator[]を使う方法です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap;
    // insertメソッドを使って要素を追加
    myMap.insert(std::make_pair(1, "Apple"));
    myMap.insert(std::make_pair(2, "Banana"));
    // operator[]を使って要素を追加
    myMap[3] = "Cherry";
    // マップの内容を表示
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、以下のように要素が追加されます。

1: Apple
2: Banana
3: Cherry

要素の削除(erase)

std::mapから要素を削除するには、eraseメソッドを使用します。

以下のコードは、キーを指定して要素を削除する例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {
        {1, "Apple"},
        {2, "Banana"},
        {3, "Cherry"}
    };
    // キー2の要素を削除
    myMap.erase(2);
    // マップの内容を表示
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、キー2の要素が削除されます。

1: Apple
3: Cherry

要素のアクセス

operator[]によるアクセス

operator[]を使ってstd::mapの要素にアクセスする方法を説明します。

operator[]は指定したキーに対応する値を返します。

キーが存在しない場合、新しい要素が追加されます。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {
        {1, "Apple"},
        {2, "Banana"}
    };
    // キー1の要素にアクセス
    std::cout << "Key 1: " << myMap[1] << std::endl;
    // 存在しないキー3にアクセス(新しい要素が追加される)
    std::cout << "Key 3: " << myMap[3] << std::endl;
    // マップの内容を表示
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、以下のように表示されます。

キー3にアクセスした際に新しい要素が追加されることに注意してください。

Key 1: Apple
Key 3: 
1: Apple
2: Banana
3:

at()メソッドによるアクセス

at()メソッドを使ってstd::mapの要素にアクセスする方法を説明します。

at()メソッドは指定したキーに対応する値を返しますが、キーが存在しない場合は例外をスローします。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {
        {1, "Apple"},
        {2, "Banana"}
    };
    try {
        // キー1の要素にアクセス
        std::cout << "Key 1: " << myMap.at(1) << std::endl;
        // 存在しないキー3にアクセス(例外がスローされる)
        std::cout << "Key 3: " << myMap.at(3) << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "例外発生: " << e.what() << std::endl;
    }
    return 0;
}

このコードを実行すると、以下のように表示されます。

キー3にアクセスした際に例外がスローされることに注意してください。

Key 1: Apple
例外発生: map::at:  key not found

以上が、std::mapの基本的な使い方です。

次のセクションでは、std::mapの操作について詳しく見ていきます。

std::mapの操作

イテレータの使用

イテレータの基本

std::mapは内部的にバランスの取れた二分探索木(通常は赤黒木)を使用しており、イテレータを使って要素を順番にアクセスすることができます。

イテレータは、std::mapの要素を指し示すオブジェクトで、ポインタのように扱うことができます。

以下は、std::mapのイテレータの基本的な使い方の例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
    // イテレータの宣言
    std::map<int, std::string>::iterator it;
    // イテレータを使って要素にアクセス
    for (it = myMap.begin(); it != myMap.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }
    return 0;
}

このコードでは、イテレータを使ってstd::mapの全ての要素にアクセスし、キーと値を出力しています。

イテレータを使ったループ処理

イテレータを使ったループ処理は、std::mapの全ての要素に対して何らかの操作を行う場合に非常に便利です。

以下の例では、std::mapの全ての要素をイテレータを使ってループし、値を変更しています。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
    // イテレータを使って値を変更
    for (auto it = myMap.begin(); it != myMap.end(); ++it) {
        it->second = "number " + std::to_string(it->first);
    }
    // 変更後のマップを出力
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードでは、各要素の値を number X という形式に変更し、変更後のマップを出力しています。

検索操作

find()メソッド

std::mapfind()メソッドは、指定したキーに対応する要素を検索し、そのイテレータを返します。

キーが見つからない場合は、end()イテレータを返します。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
    // キー2を検索
    auto it = myMap.find(2);
    if (it != myMap.end()) {
        std::cout << "Found: " << it->first << ": " << it->second << std::endl;
    } else {
        std::cout << "Key not found" << std::endl;
    }
    return 0;
}

このコードでは、キー2を検索し、見つかった場合はそのキーと値を出力しています。

count()メソッド

std::mapcount()メソッドは、指定したキーがマップに存在するかどうかを確認するために使用されます。

キーが存在する場合は1を、存在しない場合は0を返します。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
    // キー2の存在を確認
    if (myMap.count(2) > 0) {
        std::cout << "Key 2 exists" << std::endl;
    } else {
        std::cout << "Key 2 does not exist" << std::endl;
    }
    return 0;
}

このコードでは、キー2がマップに存在するかどうかを確認し、結果を出力しています。

サイズと容量の管理

size()メソッド

std::mapsize()メソッドは、マップに含まれる要素の数を返します。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}};
    // マップのサイズを出力
    std::cout << "Size of map: " << myMap.size() << std::endl;
    return 0;
}

このコードでは、マップのサイズ(要素の数)を出力しています。

empty()メソッド

std::mapempty()メソッドは、マップが空であるかどうかを確認します。

空の場合はtrueを、そうでない場合はfalseを返します。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> myMap;
    // マップが空かどうかを確認
    if (myMap.empty()) {
        std::cout << "Map is empty" << std::endl;
    } else {
        std::cout << "Map is not empty" << std::endl;
    }
    // 要素を追加
    myMap[1] = "one";
    // 再度確認
    if (myMap.empty()) {
        std::cout << "Map is empty" << std::endl;
    } else {
        std::cout << "Map is not empty" << std::endl;
    }
    return 0;
}

このコードでは、マップが空であるかどうかを確認し、要素を追加した後に再度確認しています。

高度な使い方

カスタムコンパレータの使用

カスタムコンパレータの定義

std::mapはデフォルトでキーを昇順にソートしますが、カスタムコンパレータを使用することで独自のソート順を定義することができます。

カスタムコンパレータは、キーの比較方法を指定する関数オブジェクト(ファンクタ)やラムダ式を用いて定義します。

以下は、カスタムコンパレータを定義する例です。

ここでは、キーを降順にソートするコンパレータを定義します。

#include <iostream>
#include <map>
// カスタムコンパレータの定義
struct DescendingOrder {
    bool operator()(const int& lhs, const int& rhs) const {
        return lhs > rhs;
    }
};
int main() {
    // カスタムコンパレータを使ったstd::mapの宣言
    std::map<int, std::string, DescendingOrder> myMap;
    myMap[1] = "one";
    myMap[2] = "two";
    myMap[3] = "three";
    // 要素の表示
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、キーが降順にソートされていることが確認できます。

カスタムコンパレータを使ったstd::mapの宣言

カスタムコンパレータを使ったstd::mapの宣言は、上記の例のようにテンプレート引数としてコンパレータを指定するだけです。

以下に、カスタムコンパレータを使ったstd::mapの宣言方法を示します。

std::map<int, std::string, DescendingOrder> myMap;

このように宣言することで、myMapはキーを降順にソートするようになります。

std::mapのコピーとムーブ

コピーコンストラクタと代入演算子

std::mapはコピーコンストラクタと代入演算子をサポートしています。

これにより、既存のstd::mapから新しいstd::mapを作成したり、既存のstd::mapに別のstd::mapを代入することができます。

以下は、コピーコンストラクタと代入演算子の使用例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> originalMap;
    originalMap[1] = "one";
    originalMap[2] = "two";
    // コピーコンストラクタを使って新しいstd::mapを作成
    std::map<int, std::string> copiedMap(originalMap);
    // 代入演算子を使って既存のstd::mapに代入
    std::map<int, std::string> assignedMap;
    assignedMap = originalMap;
    // 要素の表示
    for (const auto& pair : copiedMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    for (const auto& pair : assignedMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、originalMapの内容がcopiedMapとassignedMapにコピーされていることが確認できます。

ムーブコンストラクタとムーブ代入演算子

C++11以降、std::mapはムーブコンストラクタとムーブ代入演算子もサポートしています。

これにより、リソースの所有権を効率的に移動することができます。

以下は、ムーブコンストラクタとムーブ代入演算子の使用例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> originalMap;
    originalMap[1] = "one";
    originalMap[2] = "two";
    // ムーブコンストラクタを使って新しいstd::mapを作成
    std::map<int, std::string> movedMap(std::move(originalMap));
    // ムーブ代入演算子を使って既存のstd::mapに代入
    std::map<int, std::string> anotherMap;
    anotherMap = std::move(movedMap);
    // 要素の表示
    for (const auto& pair : anotherMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、originalMapの内容がmovedMapにムーブされ、さらにanotherMapにムーブされていることが確認できます。

std::mapのスワップ操作

swap()メソッド

std::mapには、swap()メソッドが用意されており、2つのstd::mapの内容を効率的に交換することができます。

以下は、swap()メソッドの使用例です。

#include <iostream>
#include <map>
int main() {
    std::map<int, std::string> map1;
    map1[1] = "one";
    map1[2] = "two";
    std::map<int, std::string> map2;
    map2[3] = "three";
    map2[4] = "four";
    // swap()メソッドを使って内容を交換
    map1.swap(map2);
    // 要素の表示
    std::cout << "map1:" << std::endl;
    for (const auto& pair : map1) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    std::cout << "map2:" << std::endl;
    for (const auto& pair : map2) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、map1とmap2の内容が交換されていることが確認できます。

std::swap()関数

C++標準ライブラリには、std::swap()関数も用意されており、これを使ってstd::mapの内容を交換することもできます。

以下は、std::swap()関数の使用例です。

#include <iostream>
#include <map>
#include <utility> // std::swapを使用するために必要
int main() {
    std::map<int, std::string> map1;
    map1[1] = "one";
    map1[2] = "two";
    std::map<int, std::string> map2;
    map2[3] = "three";
    map2[4] = "four";
    // std::swap()関数を使って内容を交換
    std::swap(map1, map2);
    // 要素の表示
    std::cout << "map1:" << std::endl;
    for (const auto& pair : map1) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    std::cout << "map2:" << std::endl;
    for (const auto& pair : map2) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

このコードを実行すると、map1とmap2の内容がstd::swap()関数を使って交換されていることが確認できます。

以上が、std::mapの高度な使い方に関する解説です。

カスタムコンパレータの使用、コピーとムーブ、スワップ操作を理解することで、std::mapをより柔軟に活用できるようになります。

実践的な例

学生の成績管理システム

ここでは、std::mapを使って学生の成績管理システムを作成する例を紹介します。

このシステムでは、学生の名前をキーとして、成績を値として管理します。

#include <iostream>
#include <map>
#include <string>
int main() {
    // 学生の名前をキー、成績を値としてstd::mapを宣言
    std::map<std::string, int> studentGrades;
    // 学生の成績を追加
    studentGrades["Alice"] = 85;
    studentGrades["Bob"] = 92;
    studentGrades["Charlie"] = 78;
    // 成績を表示
    for (const auto& student : studentGrades) {
        std::cout << "学生: " << student.first << ", 成績: " << student.second << std::endl;
    }
    // 特定の学生の成績を取得
    std::string name = "Alice";
    if (studentGrades.find(name) != studentGrades.end()) {
        std::cout << name << "の成績: " << studentGrades[name] << std::endl;
    } else {
        std::cout << name << "の成績は見つかりませんでした。" << std::endl;
    }
    return 0;
}

このプログラムでは、std::mapを使って学生の名前と成績を管理しています。

operator[]を使って要素を追加し、forループを使って全ての学生の成績を表示しています。

また、findメソッドを使って特定の学生の成績を取得しています。

商品の在庫管理システム

次に、std::mapを使って商品在庫管理システムを作成する例を紹介します。

このシステムでは、商品の名前をキーとして、在庫数を値として管理します。

#include <iostream>
#include <map>
#include <string>
int main() {
    // 商品の名前をキー、在庫数を値としてstd::mapを宣言
    std::map<std::string, int> inventory;
    // 商品の在庫を追加
    inventory["Apple"] = 50;
    inventory["Banana"] = 30;
    inventory["Orange"] = 20;
    // 在庫を表示
    for (const auto& item : inventory) {
        std::cout << "商品: " << item.first << ", 在庫数: " << item.second << std::endl;
    }
    // 特定の商品在庫を取得
    std::string product = "Banana";
    if (inventory.find(product) != inventory.end()) {
        std::cout << product << "の在庫数: " << inventory[product] << std::endl;
    } else {
        std::cout << product << "の在庫は見つかりませんでした。" << std::endl;
    }
    // 商品の在庫を更新
    inventory["Apple"] += 10; // Appleの在庫を10増やす
    std::cout << "Appleの新しい在庫数: " << inventory["Apple"] << std::endl;
    return 0;
}

このプログラムでは、std::mapを使って商品の名前と在庫数を管理しています。

operator[]を使って要素を追加し、forループを使って全ての商品在庫を表示しています。

また、findメソッドを使って特定の商品在庫を取得し、在庫数を更新しています。

これらの例を通じて、std::mapがどのように実際のアプリケーションで使用されるかを理解することができます。

std::mapはキーと値のペアを効率的に管理するための強力なツールであり、さまざまなシステムで役立ちます。

std::mapのパフォーマンスと最適化

std::mapの内部構造

std::mapは内部的に赤黒木(Red-Black Tree)という自己平衡二分探索木を使用しています。

この構造により、要素の挿入、削除、検索がすべてO(log n)の時間で行われます。

赤黒木は、木の高さが常にO(log n)に保たれるため、最悪の場合でも効率的な操作が保証されます。

パフォーマンスの考慮点

std::mapを使用する際には、以下の点に注意することでパフォーマンスを最適化できます。

  1. 頻繁な挿入と削除:
  • std::mapは挿入と削除がO(log n)で行われますが、頻繁にこれらの操作を行う場合、パフォーマンスに影響が出ることがあります。

大量のデータを一度に挿入する場合は、他のデータ構造(例えばstd::vector)を一時的に使用し、最後にstd::mapに移行する方法も検討してください。

  1. アクセスパターン:
  • std::mapはキーに基づいて要素を検索するため、アクセスパターンがランダムである場合でも効率的に動作します。

しかし、連続したアクセスが多い場合は、キャッシュのヒット率が低下する可能性があります。

  1. カスタムコンパレータ:
  • デフォルトのコンパレータ(std::less)を使用する場合、キーの比較が効率的に行われますが、カスタムコンパレータを使用する場合は、その実装が効率的であることを確認してください。

std::unordered_mapとの比較

std::unordered_mapはハッシュテーブルを内部構造として使用しており、平均的な挿入、削除、検索の時間はO(1)です。

以下に、std::mapstd::unordered_mapの比較を示します。

特徴std::mapstd::unordered_map
内部構造赤黒木ハッシュテーブル
挿入/削除/検索の時間O(log n)平均O(1)
順序キーの順序でソート順序なし
メモリ使用量少ない多い場合がある
カスタムコンパレータ可能不可能

使用例

以下に、std::mapstd::unordered_mapの使用例を示します。

#include <iostream>
#include <map>
#include <unordered_map>
int main() {
    // std::mapの例
    std::map<int, std::string> ordered_map;
    ordered_map[1] = "one";
    ordered_map[3] = "three";
    ordered_map[2] = "two";
    std::cout << "std::map:" << std::endl;
    for (const auto& pair : ordered_map) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    // std::unordered_mapの例
    std::unordered_map<int, std::string> unordered_map;
    unordered_map[1] = "one";
    unordered_map[3] = "three";
    unordered_map[2] = "two";
    std::cout << "std::unordered_map:" << std::endl;
    for (const auto& pair : unordered_map) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
    return 0;
}

実行結果

std::map:
1: one
2: two
3: three
std::unordered_map:
1: one
2: two
3: three

std::mapはキーの順序でソートされているのに対し、std::unordered_mapは順序が保証されていないことがわかります。

用途に応じて、適切なコンテナを選択することが重要です。

まとめ

std::mapの利点と欠点

利点:

  1. 自動ソート: std::mapはキーに基づいて自動的に要素をソートします。

これにより、データを挿入するたびにソートする手間が省けます。

  1. 高速な検索: std::mapは内部的にバランスの取れた二分探索木(通常は赤黒木)を使用しているため、検索、挿入、削除の操作が対数時間で行えます。
  2. キーの一意性: std::mapはキーが一意であることを保証します。

同じキーで複数の値を持つことはできません。

欠点:

  1. メモリ使用量: std::mapは内部構造が複雑であるため、他のコンテナ(例えばstd::unordered_map)に比べてメモリ使用量が多くなることがあります。
  2. 挿入・削除のコスト: 挿入や削除の操作は対数時間で行われますが、これが頻繁に行われる場合、パフォーマンスに影響を与えることがあります。
  3. 順序の必要性: キーの順序が必要ない場合、std::unordered_mapの方がパフォーマンスが良いことがあります。

std::mapを使うべきシチュエーション

  1. キーに基づいたソートが必要な場合: データをキーに基づいて自動的にソートしたい場合、std::mapは非常に便利です。

例えば、学生の成績を学籍番号順に管理する場合などです。

  1. 高速な検索が必要な場合: キーに基づいて高速にデータを検索したい場合、std::mapは適しています。

例えば、商品IDに基づいて在庫情報を管理する場合などです。

  1. キーの一意性が重要な場合: キーが一意であることを保証したい場合、std::mapは適しています。

例えば、ユーザーIDに基づいてユーザー情報を管理する場合などです。

  1. 順序が重要な場合: データの順序が重要であり、挿入順序ではなくキーの順序でデータを管理したい場合、std::mapは適しています。

例えば、イベントのタイムラインを管理する場合などです。

  1. メモリ使用量が許容範囲内の場合: メモリ使用量が多少多くても問題ない場合、std::mapの利点を活かすことができます。

以上のように、std::mapは特定のシチュエーションで非常に有用なコンテナです。

適切な場面で使用することで、効率的なプログラムを作成することができます。

目次から探す