C++セットの完全ガイド：特徴・使い方・実践テクニック

C++ setの基礎知識

setとは何か：ユニークな要素を保持するコンテナ

C++のstd::setは、標準テンプレートライブラリ(STL)が提供する連想コンテナの一つです。setの最も重要な特徴は以下の3点です：

1. 要素の一意性保証

• 同じ値を持つ要素を複数格納することができません
• 挿入時に自動的に重複チェックが行われます

1. 自動的なソート順の維持

• 要素は常にソートされた状態で保持されます
• デフォルトでは昇順にソートされます

1. テンプレートベースの実装

• あらゆるデータ型に対応可能です
• カスタム比較関数を定義することも可能です

基本的な使用例を見てみましょう：

#include <set>
#include <iostream>

int main() {
    // setの宣言と初期化
    std::set<int> numbers;  // 空のsetを作成

    // 要素の追加
    numbers.insert(3);  // {3}
    numbers.insert(1);  // {1, 3}
    numbers.insert(4);  // {1, 3, 4}
    numbers.insert(1);  // 重複する要素は無視される

    // 要素の出力（自動的にソートされている）
    for (const auto& num : numbers) {
        std::cout << num << " ";  // 出力: 1 3 4
    }

    return 0;
}

setがデータを管理する仕組み：二分探索木の実装

setの内部実装は、Red-Black Tree（赤黒木）と呼ばれる自己平衡二分探索木を使用しています。この実装により、以下の特性が実現されています：

1. 効率的な検索性能

• すべての主要な操作（検索、挿入、削除）が対数時間O(log n)で実行可能
• 木の高さが自動的に調整され、最適な検索効率を維持

1. メモリ効率

• 各ノードは要素値とポインタのみを保持
• 必要最小限のメモリ使用で効率的なデータ管理を実現

実装の具体例を見てみましょう：

#include <set>
#include <string>
#include <iostream>

class Person {
public:
    Person(std::string name, int age) : name_(name), age_(age) {}

    // 比較演算子のオーバーロード（setで必要）
    bool operator<(const Person& other) const {
        return age_ < other.age_;  // 年齢でソート
    }

    std::string getName() const { return name_; }
    int getAge() const { return age_; }

private:
    std::string name_;
    int age_;
};

int main() {
    // カスタムクラスを使用したsetの例
    std::set<Person> people;

    // 要素の追加
    people.insert(Person("Alice", 25));
    people.insert(Person("Bob", 30));
    people.insert(Person("Charlie", 20));

    // 年齢順（昇順）で自動的にソートされる
    for (const auto& person : people) {
        std::cout << person.getName() << ": " << person.getAge() << "歳\n";
    }

    return 0;
}

この実装例では、カスタムクラスをsetで使用する際の重要なポイントを示しています：

• operator<の定義が必要（ソート順の決定に使用）
• 要素は自動的にソートされる
• 重複チェックはoperator<に基づいて行われる

setの内部実装の特徴により、以下のような利点があります：

1. 一貫した性能

• データ量が増えても性能の劣化が緩やか
• 予測可能な実行時間

1. メモリ効率

• 動的なメモリ割り当て
• 必要に応じた木の再構築

setの基本的な使い方を理解することで、より複雑なデータ管理や高度な操作にも対応できるようになります。

setの主要な機能と使い方

要素の追加と削除：insert()とerase()の使用法

setにおける要素の追加と削除は、insert()とerase()メソッドを使用して行います。これらの操作の特徴と使用方法を詳しく見ていきましょう。

1. insert()の使用方法

#include <set>
#include <iostream>

int main() {
    std::set<int> numbers;

    // 単一要素の挿入
    auto result1 = numbers.insert(10);  // 戻り値はpair<iterator, bool>
    std::cout << "挿入成功: " << result1.second << "\n";  // true

    // 重複要素の挿入（無視される）
    auto result2 = numbers.insert(10);
    std::cout << "挿入成功: " << result2.second << "\n";  // false

    // 範囲による複数要素の挿入
    std::vector<int> values = {5, 15, 20};
    numbers.insert(values.begin(), values.end());

    // イテレータを使用した挿入位置のヒント
    auto hint = numbers.lower_bound(12);
    numbers.insert(hint, 12);  // 挿入位置のヒントを使用

    return 0;
}

2. erase()の使用方法

std::set<int> numbers = {10, 20, 30, 40, 50};

// 値による削除
numbers.erase(30);  // 要素30を削除

// イテレータによる削除
auto it = numbers.find(40);
if (it != numbers.end()) {
    numbers.erase(it);  // イテレータが指す要素を削除
}

// 範囲による削除
auto start = numbers.lower_bound(20);
auto end = numbers.upper_bound(40);
numbers.erase(start, end);  // 指定範囲の要素を削除

要素の検索：find()とcount()の活用方法

setにおける要素の検索は、主にfind()とcount()メソッドを使用します。

1. find()の使用法

#include <set>
#include <string>

int main() {
    std::set<std::string> words = {"apple", "banana", "orange"};

    // 要素の検索
    auto it = words.find("banana");
    if (it != words.end()) {
        std::cout << "Found: " << *it << "\n";
    }

    // 存在しない要素の検索
    it = words.find("grape");
    if (it == words.end()) {
        std::cout << "Not found\n";
    }

    return 0;
}

2. count()の使用法

std::set<int> numbers = {10, 20, 30, 40, 50};

// 要素の存在確認（setの場合、結果は0か1のみ）
std::cout << "20の数: " << numbers.count(20) << "\n";  // 1
std::cout << "25の数: " << numbers.count(25) << "\n";  // 0

イテレーションと範囲ベースの操作テクニック

setの要素を走査する方法には、複数のアプローチがあります。

1. 基本的なイテレーション

std::set<int> numbers = {10, 20, 30, 40, 50};

// 範囲ベースのforループ（最も簡潔）
for (const auto& num : numbers) {
    std::cout << num << " ";
}

// 通常のイテレータ使用
for (auto it = numbers.begin(); it != numbers.end(); ++it) {
    std::cout << *it << " ";
}

// 逆順イテレーション
for (auto it = numbers.rbegin(); it != numbers.rend(); ++it) {
    std::cout << *it << " ";
}

2. 範囲ベースの操作

std::set<int> numbers = {10, 20, 30, 40, 50};

// lower_bound()とupper_bound()の使用
auto lower = numbers.lower_bound(25);  // 25以上の最初の要素
auto upper = numbers.upper_bound(35);  // 35より大きい最初の要素

// 指定範囲の要素を表示
for (auto it = lower; it != upper; ++it) {
    std::cout << *it << " ";  // 30のみ表示
}

// equal_range()の使用（lower_boundとupper_boundのペアを取得）
auto range = numbers.equal_range(30);
for (auto it = range.first; it != range.second; ++it) {
    std::cout << *it << " ";  // 30のみ表示
}

これらの機能を適切に組み合わせることで、効率的なデータ管理が可能になります。特に、検索や範囲操作については、setの内部実装（赤黒木）により、すべての操作が対数時間で実行されることを覚えておくと良いでしょう。

setの特徴的な性能と限界

要素の一意性が自動的に保証される仕組み

setの最も重要な特徴の一つは、要素の一意性を自動的に保証する機能です。この仕組みについて詳しく見ていきましょう。

1. 比較関数による一意性の判定

#include <set>
#include <string>

// カスタム比較関数を持つクラス
class Book {
public:
    Book(std::string title, std::string author) 
        : title_(title), author_(author) {}

    // 比較演算子のカスタム実装
    bool operator<(const Book& other) const {
        // タイトルとauthorで比較
        if (title_ != other.title_)
            return title_ < other.title_;
        return author_ < other.author_;
    }

    std::string getTitle() const { return title_; }
    std::string getAuthor() const { return author_; }

private:
    std::string title_;
    std::string author_;
};

// カスタム比較関数を使用したsetの例
int main() {
    std::set<Book> library;

    // 同じタイトルと著者の本は1つしか追加されない
    library.insert(Book("1984", "George Orwell"));
    library.insert(Book("1984", "George Orwell")); // 無視される

    // 著者が異なる場合は別の要素として追加される
    library.insert(Book("1984", "Another Author")); // 追加される

    for (const auto& book : library) {
        std::cout << book.getTitle() << " by " << book.getAuthor() << "\n";
    }

    return 0;
}

検索操作の効率性：O(log n)の時間計算量

setの各操作の時間計算量について、具体的な例を交えて解説します：

1. 主要な操作の計算量

#include <set>
#include <chrono>
#include <iostream>

void measure_performance() {
    std::set<int> numbers;
    const int N = 1000000;  // 100万要素

    // 挿入の性能測定
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < N; ++i) {
        numbers.insert(i);
    }
    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> diff = end - start;
    std::cout << "挿入時間（" << N << "要素）: " << diff.count() << "秒\n";

    // 検索の性能測定
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 1000; ++i) {
        numbers.find(rand() % N);
    }
    end = std::chrono::high_resolution_clock::now();

    diff = end - start;
    std::cout << "検索時間（1000回）: " << diff.count() << "秒\n";
}

メモリ使用効率と実行速度のバランス

setのメモリ使用と実行速度のトレードオフについて解説します：

1. メモリ使用の特徴

#include <set>
#include <vector>
#include <iostream>

void compare_memory_usage() {
    const int N = 1000000;

    // setのメモリ使用
    std::set<int> number_set;
    for (int i = 0; i < N; ++i) {
        number_set.insert(i);
    }

    // vectorのメモリ使用（比較用）
    std::vector<int> number_vector;
    for (int i = 0; i < N; ++i) {
        number_vector.push_back(i);
    }

    // メモリ使用量の概算（実際のサイズは実装依存）
    size_t set_memory = number_set.size() * (sizeof(int) + sizeof(void*) * 2);  // ノードあたりの概算
    size_t vector_memory = number_vector.capacity() * sizeof(int);

    std::cout << "set概算メモリ使用量: " << set_memory / 1024 / 1024 << "MB\n";
    std::cout << "vector概算メモリ使用量: " << vector_memory / 1024 / 1024 << "MB\n";
}

2. メモリと性能のトレードオフ

• ノードベースの実装により、メモリ使用量は要素数に比例
• 各ノードには追加のポインタ情報が必要
• メモリ断片化の可能性がある
• 連続したメモリ領域を使用しないため、キャッシュ効率は配列よりも低い

setの性能特性を理解することで、以下のような状況で適切な判断が可能になります：

• 要素の一意性が重要な場合
• 頻繁な検索操作が必要な場合
• メモリ使用量vs実行速度のバランスが重要な場合

これらの特性を踏まえて、アプリケーションの要件に応じて適切なデータ構造を選択することが重要です。

実践的なsetの活用シーンと実装例

重複除去処理の効率的な実装方法

データから重複を除去する処理は、setの最も一般的な使用例の一つです。以下に、効率的な実装方法を示します。

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

// 配列から重複を除去する関数テンプレート
template<typename T>
std::vector<T> remove_duplicates(const std::vector<T>& input) {
    std::set<T> unique_elements(input.begin(), input.end());
    return std::vector<T>(unique_elements.begin(), unique_elements.end());
}

// 文字列から重複文字を除去する関数
std::string remove_duplicate_chars(const std::string& input) {
    std::set<char> unique_chars(input.begin(), input.end());
    return std::string(unique_chars.begin(), unique_chars.end());
}

int main() {
    // 数値配列の重複除去
    std::vector<int> numbers = {1, 3, 5, 3, 7, 1, 9, 3, 5};
    auto unique_numbers = remove_duplicates(numbers);

    std::cout << "重複除去後の数値: ";
    for (const auto& num : unique_numbers) {
        std::cout << num << " ";  // 出力: 1 3 5 7 9
    }
    std::cout << "\n";

    // 文字列の重複文字除去
    std::string text = "programming";
    std::string unique_text = remove_duplicate_chars(text);
    std::cout << "重複除去後の文字列: " << unique_text << "\n";  // 出力: ginmopr

    return 0;
}

順序付きユニークリストの管理手法

setを使用して順序付きリストを管理する実践的な例を示します。

#include <set>
#include <string>
#include <iostream>

// タスク管理クラスの実装
class TaskManager {
public:
    // 優先度付きタスクの追加
    void addTask(int priority, const std::string& task) {
        tasks_.insert({priority, task});
    }

    // タスクの完了（削除）
    void completeTask(int priority, const std::string& task) {
        tasks_.erase({priority, task});
    }

    // 特定の優先度範囲のタスクを表示
    void showTasksByPriorityRange(int min_priority, int max_priority) {
        auto start = tasks_.lower_bound({min_priority, ""});
        auto end = tasks_.upper_bound({max_priority, ""});

        for (auto it = start; it != end; ++it) {
            std::cout << "優先度 " << it->first << ": " << it->second << "\n";
        }
    }

private:
    std::set<std::pair<int, std::string>> tasks_;
};

int main() {
    TaskManager manager;

    // タスクの追加
    manager.addTask(1, "緊急バグ修正");
    manager.addTask(2, "新機能実装");
    manager.addTask(3, "ドキュメント更新");
    manager.addTask(1, "セキュリティパッチ適用");

    // 優先度1-2のタスクを表示
    std::cout << "優先度1-2のタスク:\n";
    manager.showTasksByPriorityRange(1, 2);

    return 0;
}

集合演算の実装：和集合・積集合・差集合

setを使用した集合演算の実装例を示します。

#include <set>
#include <algorithm>
#include <iostream>

template<typename T>
class SetOperations {
public:
    // 和集合の計算
    static std::set<T> union_sets(const std::set<T>& set1, const std::set<T>& set2) {
        std::set<T> result = set1;
        result.insert(set2.begin(), set2.end());
        return result;
    }

    // 積集合の計算
    static std::set<T> intersection_sets(const std::set<T>& set1, const std::set<T>& set2) {
        std::set<T> result;
        std::set_intersection(
            set1.begin(), set1.end(),
            set2.begin(), set2.end(),
            std::inserter(result, result.begin())
        );
        return result;
    }

    // 差集合の計算
    static std::set<T> difference_sets(const std::set<T>& set1, const std::set<T>& set2) {
        std::set<T> result;
        std::set_difference(
            set1.begin(), set1.end(),
            set2.begin(), set2.end(),
            std::inserter(result, result.begin())
        );
        return result;
    }

    // 結果の表示
    static void print_set(const std::set<T>& set, const std::string& label) {
        std::cout << label << ": ";
        for (const auto& elem : set) {
            std::cout << elem << " ";
        }
        std::cout << "\n";
    }
};

int main() {
    std::set<int> set1 = {1, 2, 3, 4, 5};
    std::set<int> set2 = {4, 5, 6, 7, 8};

    // 各種集合演算の実行
    auto union_result = SetOperations<int>::union_sets(set1, set2);
    auto intersection_result = SetOperations<int>::intersection_sets(set1, set2);
    auto difference_result = SetOperations<int>::difference_sets(set1, set2);

    // 結果の表示
    SetOperations<int>::print_set(union_result, "和集合");
    SetOperations<int>::print_set(intersection_result, "積集合");
    SetOperations<int>::print_set(difference_result, "差集合");

    return 0;
}

これらの実装例は、setの特性を活かした実践的な使用方法を示しています。特に：

• 重複除去処理では、setの一意性保証を利用
• 順序付きリスト管理では、自動ソート機能を活用
• 集合演算では、STLのアルゴリズムと組み合わせて効率的な実装を実現

実際の開発では、これらの基本パターンを組み合わせることで、より複雑な要件にも対応できます。

セットの注意点とベストプラクティス

パフォーマンスを最大化するための使用方法

setのパフォーマンスを最大限に引き出すためのベストプラクティスを紹介します。

1. 効率的な要素挿入

#include <set>
#include <string>

class OptimizedSet {
public:
    // ヒントを使用した効率的な挿入
    void add_sorted_elements(const std::vector<int>& sorted_data) {
        auto hint = container_.begin();
        for (const auto& value : sorted_data) {
            // ヒントを使用して挿入位置を指定
            hint = container_.insert(hint, value);
        }
    }

    // エ​​モープレースを使用した効率的な挿入
    template<typename... Args>
    void emplace_element(Args&&... args) {
        container_.emplace(std::forward<Args>(args)...);
    }

private:
    std::set<int> container_;
};

// 使用例
int main() {
    OptimizedSet optimized_set;
    std::vector<int> sorted_data = {1, 2, 3, 4, 5};
    optimized_set.add_sorted_elements(sorted_data);

    // 直接構築による効率的な要素追加
    optimized_set.emplace_element(6);

    return 0;
}

2. メモリ最適化テクニック

#include <set>
#include <memory>

// カスタムアロケータを使用したset
template<typename T>
class CustomAllocator : public std::allocator<T> {
public:
    T* allocate(std::size_t n) {
        // メモリプールや特定のメモリ管理戦略を実装可能
        return std::allocator<T>::allocate(n);
    }

    void deallocate(T* p, std::size_t n) {
        std::allocator<T>::deallocate(p, n);
    }
};

// 最適化されたsetの定義
template<typename T>
using OptimizedSet = std::set<T, std::less<T>, CustomAllocator<T>>;

メモリ管理における注意事項

メモリ管理に関する重要な注意点と対策を説明します。

1. リソース管理の基本

#include <set>
#include <memory>

class ResourceManager {
public:
    // スマートポインタを使用したリソース管理
    void add_resource(std::unique_ptr<Resource> resource) {
        resources_.insert(std::move(resource));
    }

    // 安全なリソースクリーンアップ
    void clear_resources() {
        resources_.clear();  // スマートポインタにより自動的にリソースを解放
    }

private:
    std::set<std::unique_ptr<Resource>> resources_;
};

2. イテレータの安全な使用

class SafeIterationExample {
public:
    void safe_modification() {
        std::set<int> numbers = {1, 2, 3, 4, 5};

        // 安全なイテレーション中の要素削除
        for (auto it = numbers.begin(); it != numbers.end();) {
            if (*it % 2 == 0) {
                it = numbers.erase(it);  // eraseは次のイテレータを返す
            } else {
                ++it;
            }
        }
    }

    void safe_iteration_with_modification() {
        std::set<int> numbers = {1, 2, 3, 4, 5};

        // 変更が必要な要素を別のコンテナに保存
        std::vector<int> to_remove;
        for (const auto& num : numbers) {
            if (num % 2 == 0) {
                to_remove.push_back(num);
            }
        }

        // 後で安全に削除
        for (const auto& num : to_remove) {
            numbers.erase(num);
        }
    }
};

よくある実装ミスと回避方法

一般的な実装ミスとその解決方法を示します。

1. 比較関数の正しい実装

class CorrectComparison {
public:
    // 正しい比較関数の実装
    struct ProperCompare {
        bool operator()(const std::string& left, const std::string& right) const {
            // 厳密な弱順序を保証
            return left < right;
        }
    };

    // 誤った比較関数（非推奨）
    struct IncorrectCompare {
        bool operator()(const std::string& left, const std::string& right) const {
            // 推移律を違反する可能性がある
            return left.length() <= right.length();
        }
    };

    void example() {
        // 正しい使用例
        std::set<std::string, ProperCompare> proper_set;

        // 誤った使用例（予期しない動作の可能性）
        std::set<std::string, IncorrectCompare> incorrect_set;
    }
};

2. スレッドセーフティの確保

#include <set>
#include <mutex>

class ThreadSafeSet {
public:
    void add(int value) {
        std::lock_guard<std::mutex> lock(mutex_);
        data_.insert(value);
    }

    void remove(int value) {
        std::lock_guard<std::mutex> lock(mutex_);
        data_.erase(value);
    }

    bool contains(int value) const {
        std::lock_guard<std::mutex> lock(mutex_);
        return data_.find(value) != data_.end();
    }

private:
    mutable std::mutex mutex_;
    std::set<int> data_;
};

これらのベストプラクティスを適用することで、以下のような利点が得られます：

• メモリリークの防止
• パフォーマンスの最適化
• スレッドセーフな実装
• バグの少ないコード

特に重要な点は：

• 適切なメモリ管理手法の使用
• イテレータの正しい取り扱い
• 比較関数の正しい実装
• スレッドセーフティへの配慮

これらの注意点を守ることで、より信頼性の高いコードを作成することができます。

他のコンテナとの比較と使い分け

unordered_setとの違いと選択基準

std::setとstd::unordered_setの主な違いと、それぞれの使用に適した状況を比較します。

#include <set>
#include <unordered_set>
#include <chrono>
#include <iostream>

class ContainerComparison {
public:
    void compare_performance() {
        std::set<int> ordered_set;
        std::unordered_set<int> unordered_set;
        const int N = 1000000;

        // 挿入性能の比較
        {
            auto start = std::chrono::high_resolution_clock::now();
            for (int i = 0; i < N; ++i) {
                ordered_set.insert(i);
            }
            auto ordered_time = std::chrono::high_resolution_clock::now() - start;

            start = std::chrono::high_resolution_clock::now();
            for (int i = 0; i < N; ++i) {
                unordered_set.insert(i);
            }
            auto unordered_time = std::chrono::high_resolution_clock::now() - start;

            std::cout << "挿入時間比較（" << N << "要素）:\n";
            std::cout << "  set: " << std::chrono::duration<double>(ordered_time).count() << "秒\n";
            std::cout << "  unordered_set: " << std::chrono::duration<double>(unordered_time).count() << "秒\n";
        }

        // 検索性能の比較
        {
            auto start = std::chrono::high_resolution_clock::now();
            for (int i = 0; i < 10000; ++i) {
                ordered_set.find(rand() % N);
            }
            auto ordered_time = std::chrono::high_resolution_clock::now() - start;

            start = std::chrono::high_resolution_clock::now();
            for (int i = 0; i < 10000; ++i) {
                unordered_set.find(rand() % N);
            }
            auto unordered_time = std::chrono::high_resolution_clock::now() - start;

            std::cout << "\n検索時間比較（10000回）:\n";
            std::cout << "  set: " << std::chrono::duration<double>(ordered_time).count() << "秒\n";
            std::cout << "  unordered_set: " << std::chrono::duration<double>(unordered_time).count() << "秒\n";
        }
    }
};

主な違いの比較：

ベクターやリストと比較した際の特徴

配列ベースのコンテナ（vector）やリンクリスト（list）との比較を行います。

#include <vector>
#include <list>
#include <algorithm>

class ContainerFeatures {
public:
    void demonstrate_differences() {
        // vectorの特徴
        std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
        std::sort(vec.begin(), vec.end());  // ソートが必要
        vec.erase(std::unique(vec.begin(), vec.end()), vec.end());  // 重複削除が必要

        // listの特徴
        std::list<int> lst = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
        lst.sort();  // 専用のソート関数
        lst.unique();  // 重複削除（事前にソートが必要）

        // setの特徴
        std::set<int> st = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
        // 自動的にソートされ、重複も除去される
    }

    void compare_operations() {
        std::vector<int> vec;
        std::list<int> lst;
        std::set<int> st;

        // 末尾への追加
        vec.push_back(1);  // O(1)平均
        lst.push_back(1);  // O(1)
        st.insert(1);      // O(log n)

        // 先頭への追加
        vec.insert(vec.begin(), 1);  // O(n)
        lst.push_front(1);           // O(1)
        // setは位置指定の追加なし

        // 要素の検索
        std::find(vec.begin(), vec.end(), 1);  // O(n)
        std::find(lst.begin(), lst.end(), 1);  // O(n)
        st.find(1);                            // O(log n)
    }
};

主な特徴の比較：

マルチセットの特徴と使用シーン

std::multisetの特徴と使用例を示します。

#include <set>

class MultisetExample {
public:
    void demonstrate_multiset() {
        std::multiset<int> numbers;

        // 重複要素の追加
        numbers.insert(1);
        numbers.insert(1);
        numbers.insert(2);
        numbers.insert(2);
        numbers.insert(3);

        // 特定の値の出現回数を数える
        std::cout << "1の出現回数: " << numbers.count(1) << "\n";  // 2

        // 特定の値のすべての要素を削除
        numbers.erase(1);  // すべての1が削除される

        // 特定の値の最初の要素のみを削除
        auto it = numbers.find(2);
        if (it != numbers.end()) {
            numbers.erase(it);  // 最初の2のみ削除
        }
    }

    // 実践的な使用例：頻度カウント
    void frequency_counter(const std::vector<std::string>& words) {
        std::multiset<std::string> word_counts;

        // 単語を追加
        for (const auto& word : words) {
            word_counts.insert(word);
        }

        // ユニークな単語とその出現回数を表示
        std::set<std::string> unique_words(words.begin(), words.end());
        for (const auto& word : unique_words) {
            std::cout << word << ": " << word_counts.count(word) << "回\n";
        }
    }
};

コンテナ選択の基準：

1. setを選ぶ場合

• 要素の順序が重要
• 重複を許可しない
• 頻繁な検索操作が必要
• メモリ使用を最適化したい

1. unordered_setを選ぶ場合

• 最高の検索性能が必要
• 要素の順序が不要
• メモリ使用量より速度を優先

1. vectorを選ぶ場合

• シーケンシャルアクセスが主
• メモリ効率が最重要
• 要素数が少ない
• キャッシュ効率が重要

1. multisetを選ぶ場合

• 重複要素の管理が必要
• 順序付きの頻度カウントが必要
• 範囲検索と重複処理の組み合わせ

これらの特徴を理解し、アプリケーションの要件に応じて適切なコンテナを選択することが重要です。