C++ マップとは？STL コンテナの魅力を徹底解説
連想配列として使える C++ マップの基本概念
C++のmap（マップ）は、Standard Template Library (STL)が提供する連想コンテナの一つです。キーと値のペアを格納できる強力なデータ構造で、以下のような特徴を持っています：
- キーによる自動ソート: 要素は常にキーの順序で自動的にソートされます
- ユニークなキー: 同じキーを持つ要素は1つしか存在できません
- 効率的な検索: 平均的な検索時間は O(log n) です
- 動的なメモリ管理: 要素数に応じて自動的にメモリを確保・解放します
基本的な使用例を見てみましょう：
#include <map>
#include <string>
#include <iostream>
int main() {
// string型のキーとint型の値を持つマップを作成
std::map<std::string, int> scores;
// 要素の追加
scores["Alice"] = 100; // キー: "Alice", 値: 100
scores["Bob"] = 85; // キー: "Bob", 値: 85
// 要素へのアクセス
std::cout << "Aliceのスコア: " << scores["Alice"] << std::endl;
return 0;
}
他の配列やコンテナとの違いを理解する
mapと他のSTLコンテナには、それぞれ特徴的な違いがあります。以下の表で主な違いを比較してみましょう：
| 特徴 | std::map | std::vector | std::array |
|---|---|---|---|
| インデックス方式 | キーによるアクセス | 数値インデックス | 数値インデックス |
| メモリ割り当て | 動的 | 動的 | 静的 |
| 要素の順序 | キーでソート済み | 挿入順 | 挿入順 |
| 検索時間 | O(log n) | O(n) | O(n) |
| メモリ効率 | 中 | 高 | 最高 |
| 要素の追加/削除 | 効率的 | 末尾なら効率的 | 不可 |
mapが特に優れている用途：
- データベース的な使用
std::map<std::string, UserInfo> users; // ユーザーIDで検索可能なデータベース
- カウンター実装
std::map<std::string, int> wordCount; // 単語の出現回数カウント
- キャッシュシステム
std::map<int, ComputationResult> cache; // 計算結果のキャッシュ
mapの内部実装は通常、Red-Black木という自己平衡二分探索木を使用しており、これによって効率的な検索・挿入・削除操作を実現しています。この実装により、以下のような特性が保証されます：
- 検索、挿入、削除の操作時間が常に O(log n)
- キーによる範囲検索が容易
- メモリ使用量は要素数に比例
これらの特徴を理解することで、プロジェクトの要件に応じて適切なコンテナを選択できるようになります。次のセクションでは、mapの基本的な使い方について詳しく見ていきましょう。
C++ マップの基本的な使い方をマスターしよう
要素の追加と削除を効率的に行う方法
mapでの要素操作は直感的で使いやすく設計されていますが、効率的に使うにはいくつかのテクニックがあります。
1. 要素の追加
#include <map>
#include <string>
int main() {
std::map<std::string, int> scores;
// 方法1: operator[] を使用
scores["Alice"] = 100; // 新規追加
scores["Alice"] = 95; // 既存の値を更新
// 方法2: insert() メソッドを使用
scores.insert(std::make_pair("Bob", 85)); // 新規追加
// 方法3: emplace() を使用（最も効率的）
scores.emplace("Charlie", 90); // 新規追加
return 0;
}
2. 要素の削除
// キーを指定して削除
scores.erase("Alice"); // "Alice"のエントリを削除
// イテレータを使用して削除
auto it = scores.find("Bob");
if (it != scores.end()) {
scores.erase(it); // "Bob"のエントリを削除
}
// 条件に基づいて削除（C++17以降）
std::erase_if(scores, [](const auto& pair) {
return pair.second < 60; // 60点未満の要素を削除
});
キーと値のペアを自在に操作するテクニック
mapの要素を効率的に操作するためのテクニックをいくつか紹介します：
1. 安全なアクセス方法
std::map<std::string, int> data;
// at()メソッドを使用（存在しない要素にアクセスすると例外を投げる）
try {
int value = data.at("key");
} catch (const std::out_of_range& e) {
std::cout << "キーが存在しません" << std::endl;
}
// find()メソッドを使用（存在確認が可能）
auto it = data.find("key");
if (it != data.end()) {
int value = it->second;
} else {
std::cout << "キーが存在しません" << std::endl;
}
2. デフォルト値の設定
// キーが存在しない場合のデフォルト値を設定
int value = data.value_or("key", 0); // キーが存在しない場合は0を返す
イテレーターを使った効率的なmap操作
イテレーターを使用すると、mapの要素を効率的に走査できます：
std::map<std::string, int> scores;
// 通常のイテレーション
for (const auto& [key, value] : scores) { // C++17の構造化束縛を使用
std::cout << key << ": " << value << std::endl;
}
// 特定の範囲のイテレーション
auto start = scores.lower_bound("B"); // "B"以降で最初の要素
auto end = scores.upper_bound("D"); // "D"より大きい最初の要素
for (auto it = start; it != end; ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
// 逆順イテレーション
for (auto it = scores.rbegin(); it != scores.rend(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
実践的なテクニック：
- 値の存在確認と挿入の組み合わせ
auto [it, inserted] = scores.insert_or_assign("Dave", 95);
if (inserted) {
std::cout << "新しい要素を挿入しました" << std::endl;
} else {
std::cout << "既存の要素を更新しました" << std::endl;
}
- 複数の値を効率的に挿入
std::map<std::string, int> newScores; newScores.insert(scores.begin(), scores.end()); // 別のmapの要素をまとめて挿入
これらの基本操作を理解することで、mapを効率的に使用できるようになります。次のセクションでは、より高度な使用方法について説明します。
実践で活きる！mapの高度な使い方
カスタムキーを使ったmapの実装方法
mapの真の力を引き出すには、カスタムキーの実装が重要です。以下に、効果的な実装方法を示します：
#include <map>
#include <string>
// カスタムキーとして使用するクラス
class UserKey {
public:
UserKey(std::string id, std::string department)
: id_(id), department_(department) {}
// operator< の実装（必須）
bool operator<(const UserKey& other) const {
// 部署で第一ソート、IDで第二ソート
if (department_ != other.department_) {
return department_ < other.department_;
}
return id_ < other.id_;
}
// ゲッターメソッド
std::string getId() const { return id_; }
std::string getDepartment() const { return department_; }
private:
std::string id_;
std::string department_;
};
// 使用例
int main() {
// UserKeyをキーとして使用するmap
std::map<UserKey, std::string> userMap;
// 要素の追加
userMap.emplace(UserKey("001", "Engineering"), "Alice");
userMap.emplace(UserKey("002", "Engineering"), "Bob");
userMap.emplace(UserKey("001", "Marketing"), "Charlie");
// 部署とIDで自動的にソートされる
for (const auto& [key, value] : userMap) {
std::cout << "Department: " << key.getDepartment()
<< ", ID: " << key.getId()
<< ", Name: " << value << std::endl;
}
return 0;
}
複合データ構造でmapを活用するテクニック
複雑なデータ構造を効率的に管理するために、mapを活用する高度なテクニックを紹介します：
#include <map>
#include <vector>
#include <string>
#include <memory>
// ネストされたmap構造の例
class OrganizationStructure {
private:
// 部署ごとの従業員マップ
std::map<std::string, std::map<std::string, std::vector<std::string>>> organization;
public:
// 従業員を追加
void addEmployee(const std::string& department,
const std::string& team,
const std::string& employeeName) {
organization[department][team].push_back(employeeName);
}
// チーム内の全従業員を取得
std::vector<std::string> getTeamMembers(const std::string& department,
const std::string& team) const {
auto deptIt = organization.find(department);
if (deptIt != organization.end()) {
auto teamIt = deptIt->second.find(team);
if (teamIt != deptIt->second.end()) {
return teamIt->second;
}
}
return std::vector<std::string>();
}
};
スレッドマルチ環境での安全なmap操作
マルチスレッド環境でmapを安全に使用するための実装例を示します：
#include <map>
#include <mutex>
#include <shared_mutex>
template<typename K, typename V>
class ThreadSafeMap {
private:
std::map<K, V> data;
mutable std::shared_mutex mutex; // 読み書きロック
public:
// 要素の追加（書き込みロック）
void insert(const K& key, const V& value) {
std::unique_lock<std::shared_mutex> lock(mutex);
data[key] = value;
}
// 要素の取得（読み取りロック）
std::optional<V> get(const K& key) const {
std::shared_lock<std::shared_mutex> lock(mutex);
auto it = data.find(key);
if (it != data.end()) {
return it->second;
}
return std::nullopt;
}
// 要素の削除（書き込みロック）
bool erase(const K& key) {
std::unique_lock<std::shared_mutex> lock(mutex);
return data.erase(key) > 0;
}
// 安全なイテレーション
template<typename Func>
void forEach(Func func) const {
std::shared_lock<std::shared_mutex> lock(mutex);
for (const auto& [key, value] : data) {
func(key, value);
}
}
};
// 使用例
int main() {
ThreadSafeMap<std::string, int> scores;
// 複数スレッドからの安全なアクセス
scores.insert("Alice", 100);
if (auto score = scores.get("Alice")) {
std::cout << "Score: " << *score << std::endl;
}
scores.forEach([](const std::string& name, int score) {
std::cout << name << ": " << score << std::endl;
});
return 0;
}
このスレッドセーフな実装のポイント：
std::shared_mutexを使用して読み書きロックを実現- 読み取り操作には共有ロック（
shared_lock）を使用 - 書き込み操作には排他ロック（
unique_lock）を使用 - データの一貫性を保ちながら並行アクセスを最適化
これらの高度なテクニックを使いこなすことで、複雑なアプリケーションでもmapを効果的に活用できます。次のセクションでは、パフォーマンスの最適化について詳しく見ていきましょう。
パフォーマンスを最適化する実装テクニック
メモリ使用量を考えるベストプラクティス
mapのメモリ使用を最適化するための重要なテクニックを紹介します：
1. リザーブヒントの使用
#include <map>
#include <string>
int main() {
std::map<std::string, int> data;
// 事前にノードを確保してメモリ再割り当てを減らす
data.reserve(1000); // C++17以降
// データ追加
for (int i = 0; i < 1000; ++i) {
data.emplace(std::to_string(i), i);
}
return 0;
}
2. メモリ効率の良いキー設計
// メモリ効率の悪い例
struct IneffiecientKey {
std::string longString;
std::vector<int> data;
// 比較演算子
bool operator<(const IneffiecientKey& other) const {
return longString < other.longString;
}
};
// メモリ効率の良い例
struct EfficientKey {
uint64_t hash; // 文字列のハッシュ値
// 比較演算子
bool operator<(const EfficientKey& other) const {
return hash < other.hash;
}
};
3. カスタムアロケータの活用
#include <map>
#include <memory_resource>
// メモリプール用のバッファ
char buffer[4096]; // 固定サイズのメモリプール
int main() {
// メモリプールの作成
std::pmr::monotonic_buffer_resource pool{buffer, sizeof(buffer)};
// カスタムアロケータを使用するmap
std::pmr::map<int, std::pmr::string> pooledMap{&pool};
// メモリプールを使用してデータを追加
pooledMap.emplace(1, "test");
return 0;
}
検索・挿入操作の速度を向上させる方法
mapの操作パフォーマンスを最適化するための重要なテクニックを紹介します：
1. ヒント付き挿入の活用
std::map<int, std::string> data;
// 効率的な逐次挿入
auto it = data.begin();
for (int i = 0; i < 1000; ++i) {
// 挿入位置のヒントを使用
it = data.emplace_hint(it, i, std::to_string(i));
}
2. 不要なコピーの回避
class HeavyValue {
std::vector<double> largeData;
public:
HeavyValue(size_t size) : largeData(size) {}
};
std::map<int, HeavyValue> data;
// 非効率な方法
data[1] = HeavyValue(1000); // 一時オブジェクトのコピーが発生
// 効率的な方法（その場で構築）
data.emplace(1, 1000); // コピーなしで直接構築
3. ノードハンドルの活用
#include <map> // ノードの抽出と移動 std::map<int, std::string> source; std::map<int, std::string> destination; // データを追加 source.emplace(1, "one"); source.emplace(2, "two"); // ノードを抽出して移動（コピーなし） auto node = source.extract(1); destination.insert(std::move(node));
パフォーマンス最適化のための重要なポイント：
- メモリアクセスパターンの最適化
- 連続したキーを使用する場合は、ヒント付き挿入を活用
- キャッシュラインの効率的な使用を考慮
- アロケーション戦略
- 頻繁な割り当て/解放を避ける
- カスタムアロケータを使用して特定のユースケースに最適化
- 操作の選択
operator[]よりもemplaceを優先- 一時オブジェクトの生成を避ける
- ムーブセマンティクスを活用
これらの最適化テクニックを適切に組み合わせることで、mapの性能を大幅に向上させることができます。ただし、過度な最適化は可読性を損なう可能性があるため、実際のパフォーマンス要件に応じて適切なバランスを取ることが重要です。
C++ マップのよくあるエラーと解決方法
メモリリークを防ぐための注意点
mapを使用する際の典型的なメモリリークのパターンと、その対策方法を詳しく解説します：
// 危険なパターン1: 生ポインタの使用
std::map<int, MyClass*> dangerousMap;
dangerousMap[1] = new MyClass(); // メモリリークの危険性
// 安全なパターン1: スマートポインタの使用
std::map<int, std::unique_ptr<MyClass>> safeMap;
safeMap[1] = std::make_unique<MyClass>(); // 安全な実装
// 危険なパターン2: 例外発生時のリーク
void riskyOperation() {
std::map<int, Resource*> resources;
resources[1] = new Resource(); // 例外が発生するとリーク
doSomethingThatMightThrow(); // 例外発生の可能性
delete resources[1]; // 例外発生時にここまで到達しない
}
// 安全なパターン2: RAIIの活用
void safeOperation() {
std::map<int, std::shared_ptr<Resource>> resources;
resources[1] = std::make_shared<Resource>(); // RAIIで安全
doSomethingThatMightThrow(); // 例外が発生しても自動でクリーンアップ
}
メモリリーク防止のベストプラクティス：
- スマートポインタの積極的な活用
- RAIIパターンの採用
- 例外安全性を考慮した設計
- リソース管理の一元化
イテレータ有効化の罠と対策方法
イテレータの無効化は非常に厄介な問題を引き起こす可能性があります。以下に主な問題パターンと対策を示します：
std::map<int, std::string> dataMap = {{1, "one"}, {2, "two"}, {3, "three"}};
// 危険なパターン1: 要素削除後の無効なイテレータ使用
auto it = dataMap.begin();
dataMap.erase(it); // イテレータが無効化される
++it; // 未定義動作
// 安全なパターン1: erase()の戻り値を使用
auto it = dataMap.begin();
it = dataMap.erase(it); // 次の有効なイテレータを取得
// 危険なパターン2: 要素追加時のイテレータ保持
auto it = dataMap.find(1);
dataMap[4] = "four"; // イテレータは依然有効
auto it2 = dataMap.insert({5, "five"}).first; // 既存のイテレータは有効なまま
// 安全なパターン2: イテレータの再取得
void safeIteration(std::map<int, std::string>& dataMap) {
for (auto it = dataMap.begin(); it != dataMap.end(); ) {
if (shouldDelete(it->second)) {
it = dataMap.erase(it); // 新しいイテレータを取得
} else {
++it;
}
}
}
イテレータ関連の問題を防ぐためのガイドライン：
- erase()後は必ず次の有効なイテレータを取得する
- 要素追加・削除後のイテレータの有効性を常に意識する
- 必要に応じてイテレータを再取得する
- 範囲ベースのforループを活用する（可能な場合）
// 安全な反復処理の例
void processMap(std::map<int, std::string>& dataMap) {
// 範囲ベースのforループを使用（要素の追加・削除を行わない場合）
for (const auto& [key, value] : dataMap) {
std::cout << key << ": " << value << std::endl;
}
// 要素の削除を伴う場合の安全な実装
for (auto it = dataMap.begin(); it != dataMap.end(); ) {
if (needsToBeDeleted(it->second)) {
it = dataMap.erase(it);
} else {
++it;
}
}
}
これらのエラーパターンと対策を理解することで、より安全で信頼性の高いコードを書くことができます。特に以下の点に注意を払うことが重要です：
- メモリ管理の自動化
- スマートポインタの使用
- RAIIパターンの適用
- 例外安全な実装
- イテレータの適切な管理
- 無効化条件の理解
- 安全な削除操作
- イテレータの再取得タイミング
- デバッグとテスト
- メモリリーク検出ツールの活用
- 境界条件のテスト
- 例外発生時の動作確認
これらの注意点を守ることで、多くの一般的な問題を未然に防ぐことができます。
実務で使える！マップの実践的なユースケース
キャッシュシステムの実装例
高性能なキャッシュシステムをmapを使って実装する方法を紹介します：
#include <map>
#include <chrono>
#include <optional>
template<typename K, typename V>
class CacheSystem {
private:
struct CacheEntry {
V value;
std::chrono::system_clock::time_point expiry;
CacheEntry(const V& v, std::chrono::seconds ttl)
: value(v)
, expiry(std::chrono::system_clock::now() + ttl) {}
};
std::map<K, CacheEntry> cache;
std::chrono::seconds defaultTTL;
public:
CacheSystem(std::chrono::seconds ttl = std::chrono::seconds(3600))
: defaultTTL(ttl) {}
// 値の追加
void put(const K& key, const V& value) {
cache.insert_or_assign(key, CacheEntry(value, defaultTTL));
}
// 値の取得
std::optional<V> get(const K& key) {
auto now = std::chrono::system_clock::now();
auto it = cache.find(key);
if (it != cache.end()) {
if (it->second.expiry > now) {
return it->second.value;
} else {
cache.erase(it); // 期限切れエントリの削除
}
}
return std::nullopt;
}
// キャッシュのクリーンアップ
void cleanup() {
auto now = std::chrono::system_clock::now();
for (auto it = cache.begin(); it != cache.end(); ) {
if (it->second.expiry <= now) {
it = cache.erase(it);
} else {
++it;
}
}
}
};
// 使用例
int main() {
CacheSystem<std::string, int> cache;
// データのキャッシュ
cache.put("key1", 100);
// キャッシュからデータ取得
if (auto value = cache.get("key1")) {
std::cout << "Cached value: " << *value << std::endl;
}
return 0;
}
グラフ構造の実装におけるmap活用法
mapを使用して効率的なグラフ構造を実装する例を示します：
#include <map>
#include <vector>
#include <queue>
#include <limits>
class Graph {
private:
// 隣接リストをmapで実装
std::map<int, std::map<int, int>> adjacencyList; // node -> {neighbor -> weight}
public:
// エッジの追加
void addEdge(int from, int to, int weight) {
adjacencyList[from][to] = weight;
}
// 最短経路計算（ダイクストラアルゴリズム）
std::map<int, int> shortestPath(int start) {
std::map<int, int> distances;
std::map<int, bool> visited;
// 初期化
for (const auto& [node, _] : adjacencyList) {
distances[node] = std::numeric_limits<int>::max();
}
distances[start] = 0;
// 優先度付きキュー
std::priority_queue<
std::pair<int, int>,
std::vector<std::pair<int, int>>,
std::greater<>
> pq;
pq.push({0, start});
while (!pq.empty()) {
auto [dist, current] = pq.top();
pq.pop();
if (visited[current]) continue;
visited[current] = true;
// 隣接ノードの処理
for (const auto& [neighbor, weight] : adjacencyList[current]) {
if (!visited[neighbor]) {
int newDist = distances[current] + weight;
if (newDist < distances[neighbor]) {
distances[neighbor] = newDist;
pq.push({newDist, neighbor});
}
}
}
}
return distances;
}
// グラフの可視化
void printGraph() const {
for (const auto& [node, edges] : adjacencyList) {
std::cout << "Node " << node << " connects to: ";
for (const auto& [neighbor, weight] : edges) {
std::cout << "(" << neighbor << ", " << weight << ") ";
}
std::cout << std::endl;
}
}
};
// 使用例
int main() {
Graph g;
// エッジの追加
g.addEdge(0, 1, 4);
g.addEdge(0, 2, 1);
g.addEdge(1, 3, 1);
g.addEdge(2, 1, 2);
g.addEdge(2, 3, 5);
// グラフの表示
g.printGraph();
// 最短経路の計算
auto distances = g.shortestPath(0);
for (const auto& [node, dist] : distances) {
std::cout << "Distance to node " << node << ": " << dist << std::endl;
}
return 0;
}
これらの実装例は、以下のような実務上の利点があります：
- キャッシュシステム
- メモリ使用の効率化
- アクセス速度の向上
- 有効期限管理の自動化
- グラフ構造
- 疎なグラフの効率的な表現
- 動的なグラフ操作
- メモリ使用の最適化
これらの実装は、実際のプロジェクトで直接利用できる実践的なものです。
C++ マップの代替手段と活用
unordered_mapとの比較と正しい選択方法
std::mapとstd::unordered_mapの主要な違いと選択基準を解説します：
#include <map>
#include <unordered_map>
#include <string>
#include <chrono>
// 両者の特性を比較するベンチマーク
class MapComparison {
public:
static void compareOperations() {
std::map<int, std::string> ordered;
std::unordered_map<int, std::string> unordered;
// 挿入性能の比較
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 100000; ++i) {
ordered[i] = "value" + std::to_string(i);
}
auto orderedInsertTime = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::high_resolution_clock::now() - start
).count();
start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 100000; ++i) {
unordered[i] = "value" + std::to_string(i);
}
auto unorderedInsertTime = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::high_resolution_clock::now() - start
).count();
std::cout << "Insert time comparison:\n"
<< "std::map: " << orderedInsertTime << "ms\n"
<< "std::unordered_map: " << unorderedInsertTime << "ms\n";
}
};
選択基準のポイント：
std::mapを選ぶ場合：
- キーの順序が重要な場合
- イテレータの安定性が必要な場合
- メモリ使用効率を重視する場合
- 範囲検索が必要な場合
std::unordered_mapを選ぶ場合：
- キーの順序が不要な場合
- 検索・挿入の平均的な性能を重視する場合
- メモリ使用量よりも速度を優先する場合
- 単一要素のアクセスが主な用途の場合
他のSTLコンテナとの組み合わせ活用術
mapと他のSTLコンテナを組み合わせた高度な使用例を紹介します：
#include <map>
#include <vector>
#include <set>
#include <queue>
// 複合データ構造の例：優先度付きタスク管理システム
class TaskManager {
private:
// タスクの優先度管理
std::map<int, std::set<std::string>> priorityTasks;
// タスクの詳細情報
std::unordered_map<std::string, TaskDetails> taskDetails;
// 完了タスクの履歴
std::vector<std::string> completedTasks;
public:
struct TaskDetails {
std::string description;
std::chrono::system_clock::time_point deadline;
bool isCompleted;
};
// タスクの追加
void addTask(const std::string& taskId,
const std::string& description,
int priority,
std::chrono::system_clock::time_point deadline) {
priorityTasks[priority].insert(taskId);
taskDetails[taskId] = {description, deadline, false};
}
// 最高優先度のタスクを取得
std::optional<std::string> getHighestPriorityTask() {
if (priorityTasks.empty()) return std::nullopt;
auto& highestPrioritySet = priorityTasks.rbegin()->second;
if (highestPrioritySet.empty()) return std::nullopt;
return *highestPrioritySet.begin();
}
// タスクの完了処理
void completeTask(const std::string& taskId) {
auto detailsIt = taskDetails.find(taskId);
if (detailsIt == taskDetails.end()) return;
detailsIt->second.isCompleted = true;
completedTasks.push_back(taskId);
// 優先度リストから削除
for (auto& [priority, tasks] : priorityTasks) {
tasks.erase(taskId);
if (tasks.empty()) {
priorityTasks.erase(priority);
}
}
}
// 期限切れタスクの取得
std::vector<std::string> getOverdueTasks() {
std::vector<std::string> overdueTasks;
auto now = std::chrono::system_clock::now();
for (const auto& [taskId, details] : taskDetails) {
if (!details.isCompleted && details.deadline < now) {
overdueTasks.push_back(taskId);
}
}
return overdueTasks;
}
};
STLコンテナの組み合わせテクニック：
- マップとベクターの組み合わせ
// キーでソートされた値のリストを管理
std::map<std::string, std::vector<int>> sortedLists;
// 値の追加
void addValue(const std::string& key, int value) {
auto& vec = sortedLists[key];
vec.push_back(value);
std::sort(vec.begin(), vec.end());
}
- マップとキューの組み合わせ
// イベント処理システムの実装例
std::map<std::string, std::queue<Event>> eventQueues;
void pushEvent(const std::string& channel, const Event& event) {
eventQueues[channel].push(event);
}
std::optional<Event> popEvent(const std::string& channel) {
auto it = eventQueues.find(channel);
if (it == eventQueues.end() || it->second.empty()) {
return std::nullopt;
}
Event event = it->second.front();
it->second.pop();
return event;
}
これらの組み合わせにより、以下のような利点が得られます：
- データ構造の柔軟性向上
- 複雑な要件への対応
- パフォーマンスとメモリ使用の最適化
- コードの保守性向上
適切なコンテナの組み合わせを選択することで、より効率的で保守性の高いコードを実現できます。