【完全ガイド】C++のfor文を使いこなす7つのテクニック – 現場で使える実践的な例付き

C++のfor文の基礎知識
for文の実践的な使い方
モダンC++におけるfor文の進化
for文の落とし穴と対策
実務で使えるfor文活用事例
実務で使えるfor文活用事例

C++のfor文の基礎知識

従来のfor文の構文と動作原理

C++の従来のfor文は、繰り返し処理を実装する際の基本的な制御構文です。その基本構文は以下の通りです：

for (初期化式; 条件式; 更新式) {
    // 繰り返し実行する処理
}

実際の使用例を見てみましょう：

// 基本的なfor文の例
for (int i = 0; i < 5; i++) {
    std::cout << i << " ";  // 出力: 0 1 2 3 4
}

// 複数の変数を使用する例
for (int i = 0, j = 10; i < 5; i++, j--) {
    std::cout << "i: " << i << ", j: " << j << std::endl;
}

// 条件式のみを使用する例（while文のような使い方）
int k = 0;
for (; k < 5;) {
    std::cout << k << " ";
    k++;
}

各部分の役割：

初期化式: ループ開始前に1回だけ実行

変数の宣言と初期化が可能
カンマ区切りで複数の初期化が可能
省略可能

条件式: 各イテレーション開始時に評価

true の場合、ループ本体を実行
false の場合、ループを終了
省略すると常にtrue（無限ループ）

更新式: 各イテレーション終了時に実行

カウンタの増減やその他の更新処理
カンマ区切りで複数の更新が可能
省略可能

範囲ベースfor文の特徴と利点

C++11で導入された範囲ベースfor文（range-based for）は、コンテナの要素を簡潔に走査できる現代的な構文です：

// ベクターの全要素を走査
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (const auto& num : numbers) {
    std::cout << num << " ";
}

// 配列の走査
int arr[] = {1, 2, 3, 4, 5};
for (auto element : arr) {
    std::cout << element << " ";
}

// 文字列の走査
std::string text = "Hello";
for (char c : text) {
    std::cout << c << " ";
}

範囲ベースfor文の利点：

シンプルな構文

イテレータの管理が不要
境界チェックが自動的に行われる
コードの可読性が向上

安全性の向上

範囲外アクセスのリスクが低減
要素数の計算ミスを防止

パフォーマンスの最適化

コンパイラが最適化しやすい
参照を使用することで不要なコピーを回避

初期化・条件・更新部分のベストプラクティス

効率的で保守性の高いfor文を書くためのベストプラクティスを紹介します：

変数のスコープ管理

// Good: ループ変数のスコープを制限
for (int i = 0; i < 10; i++) {
    // i はこのブロック内でのみ有効
}

// Bad: グローバルスコープの変数を使用
int i;
for (i = 0; i < 10; i++) {
    // i はループ外でも使用可能（スコープが広すぎる）
}

効率的なループ条件

std::vector<int> vec = {1, 2, 3, 4, 5};

// Good: サイズを事前に取得
for (size_t i = 0, size = vec.size(); i < size; i++) {
    // vec.size()の呼び出しが1回で済む
}

// Bad: 毎回サイズを計算
for (size_t i = 0; i < vec.size(); i++) {
    // 毎イテレーションでvec.size()を呼び出す
}

適切な更新式の選択

// Good: 明示的なインクリメント
for (int i = 0; i < 10; ++i) {
    // 前置インクリメントを使用（わずかなパフォーマンス向上の可能性）
}

// Good: ステップ値の明示
for (int i = 0; i < 100; i += 2) {
    // 2ずつ増加（意図が明確）
}

範囲ベースfor文での参照使用

std::vector<std::string> words = {"Hello", "World"};

// Good: const参照を使用（コピーを避ける）
for (const auto& word : words) {
    std::cout << word << " ";
}

// Bad: 不要なコピーが発生
for (auto word : words) {
    std::cout << word << " ";
}

初期化式での複数変数の適切な使用

// Good: 関連する変数をまとめて初期化
for (int i = 0, j = 10; i < 5; i++, j--) {
    std::cout << "i + j = " << (i + j) << std::endl;
}

// Bad: 複雑すぎる初期化
for (int i = 0, j = 10, k = 20, l = 30; i < 5; i++, j--, k += 2, l -= 3) {
    // 理解と保守が困難
}

これらのベストプラクティスを意識することで、より効率的で保守性の高いコードを書くことができます。特に大規模なプロジェクトでは、これらの原則に従うことで長期的なメリットが得られます。

for文の実践的な使い方

配列操作での効率的なfor文の活用法

配列操作は開発現場でよく遭遇する処理です。ここでは、効率的な配列操作のテクニックを紹介します。

固定長配列の操作

// 基本的な配列操作
int arr[5] = {1, 2, 3, 4, 5};

// Good: 配列サイズを定数で保持
const size_t arr_size = sizeof(arr) / sizeof(arr[0]);
for (size_t i = 0; i < arr_size; ++i) {
    arr[i] *= 2;  // 各要素を2倍に
}

// Better: C++17以降では構造化束縛を活用
for (size_t i = 0; const auto& element : arr) {
    std::cout << "Index " << i++ << ": " << element << '\n';
}

動的配列（std::vector）の効率的な操作

std::vector<int> vec = {1, 2, 3, 4, 5};

// メモリ予約による効率化
vec.reserve(1000);  // 追加操作前にメモリを確保
for (int i = 6; i <= 1000; ++i) {
    vec.push_back(i);  // 再割り当てが発生しない
}

// 要素の削除を伴う操作
for (auto it = vec.begin(); it != vec.end();) {
    if (*it % 2 == 0) {  // 偶数を削除
        it = vec.erase(it);  // eraseは次の要素を指すイテレータを返す
    } else {
        ++it;
    }
}

多次元配列の効率的な走査

// 2次元配列の効率的な走査
const int rows = 3, cols = 4;
int matrix[rows][cols] = {{1, 2, 3, 4},
                         {5, 6, 7, 8},
                         {9, 10, 11, 12}};

// Good: キャッシュフレンドリーな走査（行優先）
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
        std::cout << matrix[i][j] << ' ';
    }
}

// Bad: キャッシュ効率の悪い走査（列優先）
for (int j = 0; j < cols; ++j) {
    for (int i = 0; i < rows; ++i) {
        std::cout << matrix[i][j] << ' ';
    }
}

イテレータを使用したコンテナの走査テクニック

STLコンテナを効率的に操作するためのイテレータの活用テクニックを紹介します。

イテレータの基本的な使用法

std::vector<int> numbers = {1, 2, 3, 4, 5};

// 通常のイテレータ走査
for (auto it = numbers.begin(); it != numbers.end(); ++it) {
    *it *= 2;  // 各要素を2倍に
}

// 逆順走査
for (auto rit = numbers.rbegin(); rit != numbers.rend(); ++rit) {
    std::cout << *rit << ' ';  // 逆順に出力
}

// 特定範囲の走査
auto start = std::next(numbers.begin(), 1);  // 2番目の要素から
auto end = std::prev(numbers.end(), 1);      // 最後の一つ前まで
for (auto it = start; it != end; ++it) {
    std::cout << *it << ' ';
}

コンテナ固有のイテレータ活用

// std::mapでのイテレータ活用
std::map<std::string, int> scores = {
    {"Alice", 90}, {"Bob", 85}, {"Charlie", 95}
};

// mapの効率的な走査
for (auto it = scores.begin(); it != scores.end(); ++it) {
    std::cout << it->first << ": " << it->second << '\n';
}

// 条件を満たす要素の削除
for (auto it = scores.begin(); it != scores.end();) {
    if (it->second < 90) {
        it = scores.erase(it);  // 90点未満を削除
    } else {
        ++it;
    }
}

イテレータと各種アルゴリズムの組み合わせ

std::vector<int> data = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};

// 部分ソート
auto middle = data.begin() + data.size() / 2;
std::partial_sort(data.begin(), middle, data.end());

// 条件を満たす要素の検索
auto it = std::find_if(data.begin(), data.end(),
    [](int n) { return n > 5; });

// イテレータ範囲での演算
int sum = 0;
for (auto it = data.begin(); it != data.end(); ++it) {
    sum += *it;
}

ネストしたfor文でのパフォーマンス最適化

ネストしたループは計算量が増大しやすいため、効率的な実装が特に重要です。

ループ変数の最適化

const int size = 1000;
std::vector<std::vector<int>> matrix(size, std::vector<int>(size));

// Good: ループ不変の計算を外部で実行
const size_t matrix_size = matrix.size();
for (size_t i = 0; i < matrix_size; ++i) {
    const size_t row_size = matrix[i].size();
    for (size_t j = 0; j < row_size; ++j) {
        matrix[i][j] = i + j;
    }
}

// Bad: 毎回サイズを計算
for (size_t i = 0; i < matrix.size(); ++i) {
    for (size_t j = 0; j < matrix[i].size(); ++j) {
        matrix[i][j] = i + j;
    }
}

キャッシュ効率を考慮したアクセスパターン

// キャッシュフレンドリーな実装
const int block_size = 32;
for (int i = 0; i < size; i += block_size) {
    for (int j = 0; j < size; j += block_size) {
        // ブロック内の処理
        for (int bi = i; bi < std::min(i + block_size, size); ++bi) {
            for (int bj = j; bj < std::min(j + block_size, size); ++bj) {
                matrix[bi][bj] = bi + bj;
            }
        }
    }
}

早期終了条件の活用

// 条件を満たしたら早期終了
bool findElement(const std::vector<std::vector<int>>& matrix, int target) {
    for (const auto& row : matrix) {
        for (const auto& element : row) {
            if (element == target) {
                return true;  // 要素が見つかったら即座に終了
            }
        }
    }
    return false;
}

// 不要な反復を避ける
bool isUpperTriangular(const std::vector<std::vector<double>>& matrix) {
    for (size_t i = 1; i < matrix.size(); ++i) {
        for (size_t j = 0; j < i; ++j) {  // 下三角部分のみチェック
            if (matrix[i][j] != 0.0) {
                return false;
            }
        }
    }
    return true;
}

これらの技術を適切に組み合わせることで、効率的で保守性の高いコードを実装することができます。特に大規模なデータを扱う場合は、これらの最適化テクニックが重要になります。

モダンC++におけるfor文の進化

C++11以降で追加された機能と活用法

C++11以降、for文は大きく進化し、より表現力豊かで効率的な記述が可能になりました。

初期化式を持つrange-based for文（C++20）

std::vector<int> createVector() {
    return {1, 2, 3, 4, 5};
}

// C++20: 初期化式付きrange-based for
for (auto vec = createVector(); const auto& elem : vec) {
    std::cout << elem << ' ';
}

// インデックス付きrange-based for
for (std::vector<int> vec = {1, 2, 3}; auto [i, elem] : std::views::enumerate(vec)) {
    std::cout << i << ": " << elem << '\n';
}

構造化束縛との組み合わせ（C++17）

std::map<std::string, int> scores = {
    {"Alice", 90}, {"Bob", 85}, {"Charlie", 95}
};

// 構造化束縛を使用したマップの走査
for (const auto& [name, score] : scores) {
    std::cout << name << " scored " << score << " points\n";
}

// ネストされたデータ構造の走査
std::vector<std::pair<std::string, std::vector<int>>> students = {
    {"Alice", {90, 85, 95}},
    {"Bob", {85, 90, 80}}
};

for (const auto& [name, grades] : students) {
    double average = 0.0;
    for (const auto& grade : grades) {
        average += grade;
    }
    average /= grades.size();
    std::cout << name << "'s average: " << average << '\n';
}

constexpr forループ（C++20）

// コンパイル時の計算
constexpr auto calculateFactorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}

// 使用例
constexpr auto factorial_5 = calculateFactorial(5);
static_assert(factorial_5 == 120);

ラムダ式とfor_eachの組み合わせテクニック

ラムダ式とfor_eachの組み合わせにより、より表現力豊かで柔軟な反復処理が可能になります。

基本的なfor_eachとラムダの使用

std::vector<int> numbers = {1, 2, 3, 4, 5};

// 基本的な使用法
std::for_each(numbers.begin(), numbers.end(), 
    [](int& n) { n *= 2; });

// キャプチャを使用した例
int sum = 0;
std::for_each(numbers.begin(), numbers.end(),
    [&sum](int n) { sum += n; });

// メンバ関数を呼び出す例
std::vector<std::string> words = {"hello", "world"};
std::for_each(words.begin(), words.end(),
    [](std::string& s) { s[0] = std::toupper(s[0]); });

高度なラムダ式の活用

// 状態を持つラムダ式
auto generateSequence = [n = 0]() mutable { return ++n; };
std::vector<int> sequence(5);
std::generate(sequence.begin(), sequence.end(), generateSequence);

// 複数の条件を組み合わせた処理
std::vector<int> values = {1, -2, 3, -4, 5};
std::for_each(values.begin(), values.end(),
    [total = 0](int& v) mutable {
        if (v < 0) {
            v = std::abs(v);
        }
        total += v;
        std::cout << "Running total: " << total << '\n';
    });

カスタムイテレータとの組み合わせ

// カスタムイテレータを使用したfor_each
template<typename Container, typename Func>
void for_each_indexed(Container& c, Func f) {
    size_t index = 0;
    std::for_each(c.begin(), c.end(),
        [&index, &f](auto& element) {
            f(index++, element);
        });
}

// 使用例
std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
for_each_indexed(names,
    [](size_t i, const std::string& name) {
        std::cout << i << ": " << name << '\n';
    });

並列アルゴリズムでのfor文の応用

C++17で導入された並列アルゴリズムを使用することで、for文の処理を簡単に並列化できます。

基本的な並列for_each

#include <execution>
std::vector<int> large_vector(1000000);

// 並列実行
std::for_each(std::execution::par,
    large_vector.begin(), large_vector.end(),
    [](int& n) { 
        // 重い計算
        n = static_cast<int>(std::sqrt(std::pow(n, 3)));
    });

// 並列非順序実行
std::for_each(std::execution::par_unseq,
    large_vector.begin(), large_vector.end(),
    [](int& n) { n *= 2; });

並列リダクション操作

// 並列リダクション（総和の計算）
auto parallel_sum = [](const std::vector<int>& vec) {
    return std::reduce(std::execution::par,
        vec.begin(), vec.end(), 0);
};

// 並列変換＋リダクション
auto parallel_transform_reduce = [](const std::vector<int>& vec) {
    return std::transform_reduce(
        std::execution::par,
        vec.begin(), vec.end(),
        0,
        std::plus<>(),
        [](int n) { return n * n; }
    );
};

データ依存性を考慮した並列処理

// データ依存性のない処理の並列化
std::vector<std::vector<int>> matrix(1000, std::vector<int>(1000));
std::for_each(std::execution::par,
    matrix.begin(), matrix.end(),
    [](auto& row) {
        std::transform(row.begin(), row.end(),
            row.begin(),
            [](int n) { return n * 2; });
    });

// 依存関係のある処理の適切な分割
struct Block {
    std::vector<int> data;
    std::mutex mutex;
};

std::vector<Block> blocks(100);
std::for_each(std::execution::par,
    blocks.begin(), blocks.end(),
    [](Block& block) {
        std::lock_guard<std::mutex> lock(block.mutex);
        // スレッドセーフな処理
        for (auto& n : block.data) {
            n = static_cast<int>(std::sqrt(n));
        }
    });

これらのモダンな機能を適切に活用することで、より表現力豊かで効率的なコードを書くことができます。特に大規模なデータ処理や性能要求の高いアプリケーションでは、これらの機能が真価を発揮します。

for文の落とし穴と対策

よくある間違いとデバッグのポイント

for文を使用する際によく遭遇する問題とその解決方法を紹介します。

配列境界の誤り

// Bad: 配列の境界を超えたアクセス
int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i <= 5; i++) {  // <= を使用している
    std::cout << arr[i] << ' ';  // 境界外アクセス！
}

// Good: 正しい境界チェック
for (int i = 0; i < 5; i++) {  // < を使用
    std::cout << arr[i] << ' ';
}

// Better: サイズを動的に取得
const size_t size = sizeof(arr) / sizeof(arr[0]);
for (size_t i = 0; i < size; i++) {
    std::cout << arr[i] << ' ';
}

無限ループの防止

// Bad: 意図しない無限ループ
for (unsigned int i = 10; i >= 0; --i) {  // unsigned intは0未満にならない
    std::cout << i << ' ';
}

// Good: 適切な型と条件の使用
for (int i = 10; i >= 0; --i) {
    std::cout << i << ' ';
}

// デバッグ用のガード追加
for (int i = 0, guard = 0; i < someValue && guard < 1000; ++i, ++guard) {
    // 無限ループの可能性がある処理
    if (guard == 999) {
        std::cerr << "Possible infinite loop detected\n";
        break;
    }
}

イテレータの無効化

std::vector<int> vec = {1, 2, 3, 4, 5};

// Bad: イテレータが無効化される
for (auto it = vec.begin(); it != vec.end(); ++it) {
    if (*it % 2 == 0) {
        vec.push_back(*it);  // 要素追加によりイテレータが無効化
    }
}

// Good: 安全な実装
std::vector<int> temp;
for (const auto& num : vec) {
    if (num % 2 == 0) {
        temp.push_back(num);
    }
}
vec.insert(vec.end(), temp.begin(), temp.end());

パフォーマンスを低下させる実装パターン

パフォーマンスに悪影響を与える一般的なパターンとその改善方法を解説します。

不必要なオブジェクトのコピー

std::vector<std::string> strings = {"Hello", "World"};

// Bad: 要素のコピーが発生
for (auto str : strings) {
    str += "!";  // コピーされた一時オブジェクトを変更
}

// Good: 参照を使用
for (auto& str : strings) {
    str += "!";  // 実際のオブジェクトを直接変更
}

// Best: 変更不要な場合はconst参照
for (const auto& str : strings) {
    std::cout << str << '\n';
}

非効率なコンテナ操作

std::vector<int> numbers;

// Bad: 頻繁なメモリ再割り当て
for (int i = 0; i < 10000; ++i) {
    numbers.push_back(i);
}

// Good: 事前にメモリを確保
numbers.reserve(10000);
for (int i = 0; i < 10000; ++i) {
    numbers.push_back(i);
}

// Bad: 要素の頻繁な削除
for (auto it = numbers.begin(); it != numbers.end();) {
    if (*it % 2 == 0) {
        it = numbers.erase(it);  // 毎回要素をシフト
    } else {
        ++it;
    }
}

// Good: 削除する要素をマークしてから一括削除
numbers.erase(
    std::remove_if(numbers.begin(), numbers.end(),
        [](int n) { return n % 2 == 0; }),
    numbers.end()
);

キャッシュ効率の悪い操作

// Bad: キャッシュ効率の悪いアクセスパターン
const int size = 1000;
std::vector<std::vector<int>> matrix(size, std::vector<int>(size));

for (int j = 0; j < size; ++j) {
    for (int i = 0; i < size; ++i) {
        matrix[i][j] = i + j;  // 列優先アクセス
    }
}

// Good: キャッシュフレンドリーなアクセス
for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
        matrix[i][j] = i + j;  // 行優先アクセス
    }
}

メモリリークを防ぐためのベストプラクティス

for文使用時のメモリ管理に関する問題とその対策を説明します。

スマートポインタの活用

// Bad: 生ポインタの使用でメモリリークの危険
std::vector<MyClass*> objects;
for (int i = 0; i < 10; ++i) {
    objects.push_back(new MyClass());  // メモリリークの可能性
}

// Good: スマートポインタの使用
std::vector<std::unique_ptr<MyClass>> safe_objects;
for (int i = 0; i < 10; ++i) {
    safe_objects.push_back(std::make_unique<MyClass>());
}

// 共有リソースの場合
std::vector<std::shared_ptr<MyClass>> shared_objects;
for (int i = 0; i < 10; ++i) {
    shared_objects.push_back(std::make_shared<MyClass>());
}

RAII原則の遵守

// Bad: リソース管理が不適切
for (int i = 0; i < file_count; ++i) {
    FILE* file = fopen(filenames[i], "r");
    // 例外が発生するとファイルハンドルがリークする
    process_file(file);
    fclose(file);
}

// Good: RAIIによる自動リソース管理
for (int i = 0; i < file_count; ++i) {
    std::ifstream file(filenames[i]);  // RAIIでファイルハンドルを管理
    process_file(file);
}  // fileは自動的にクローズされる

例外安全性の確保

// Bad: 例外時にメモリリークの可能性
void process_data() {
    for (int i = 0; i < count; ++i) {
        Resource* res = new Resource();
        // 例外が発生するとメモリリーク
        process(res);
        delete res;
    }
}

// Good: 例外安全な実装
void safe_process_data() {
    for (int i = 0; i < count; ++i) {
        auto res = std::make_unique<Resource>();
        process(res.get());
    }  // リソースは自動的に解放される
}

// Better: スコープガードの使用
for (int i = 0; i < count; ++i) {
    Resource* res = new Resource();
    auto guard = std::unique_ptr<Resource>(res);  // スコープガード
    process(res);  // 例外が発生しても安全
}

これらの落とし穴を認識し、適切な対策を講じることで、より安全で効率的なコードを書くことができます。特に大規模なプロジェクトでは、これらのベストプラクティスを守ることが重要です。

実務で使えるfor文活用事例

大規模データ処理での効率的な実装例

実務で遭遇する大規模データ処理において、for文を効率的に活用する方法を紹介します。

チャンク処理による大規模データの効率的な処理

class DataProcessor {
public:
    // 大規模データを小さなチャンクに分割して処理
    void processLargeDataset(const std::vector<Record>& records) {
        const size_t chunk_size = 1000;
        const size_t total_size = records.size();

        // 進捗管理用のカウンター
        std::atomic<size_t> processed_count{0};

        // チャンク単位での処理
        for (size_t offset = 0; offset < total_size; offset += chunk_size) {
            size_t current_chunk_size = std::min(chunk_size, total_size - offset);
            processChunk(records, offset, current_chunk_size, processed_count);

            // 進捗報告
            double progress = (static_cast<double>(offset + current_chunk_size) / total_size) * 100.0;
            std::cout << "\rProgress: " << std::fixed << std::setprecision(1) << progress << "%" << std::flush;
        }
        std::cout << "\nProcessing completed." << std::endl;
    }

private:
    void processChunk(const std::vector<Record>& records, 
                     size_t offset, 
                     size_t chunk_size,
                     std::atomic<size_t>& processed_count) {
        for (size_t i = 0; i < chunk_size; ++i) {
            const auto& record = records[offset + i];
            processRecord(record);
            ++processed_count;
        }
    }

    void processRecord(const Record& record) {
        // 個別レコードの処理
    }
};

バッチ処理とトランザクション管理

class BatchProcessor {
public:
    void processBatch(std::vector<Transaction>& transactions) {
        const size_t batch_size = 100;
        std::vector<Transaction> failed_transactions;

        // トランザクションのバッチ処理
        for (size_t i = 0; i < transactions.size(); i += batch_size) {
            auto batch_end = std::min(i + batch_size, transactions.size());
            try {
                DatabaseTransaction db_transaction;  // RAIIでトランザクション管理

                for (size_t j = i; j < batch_end; ++j) {
                    if (!processTransaction(transactions[j])) {
                        failed_transactions.push_back(transactions[j]);
                    }
                }

                db_transaction.commit();
            } catch (const std::exception& e) {
                std::cerr << "Batch processing failed: " << e.what() << std::endl;
                // 失敗したバッチを再試行キューに追加
                for (size_t j = i; j < batch_end; ++j) {
                    failed_transactions.push_back(transactions[j]);
                }
            }
        }

        // 失敗したトランザクションの再処理
        if (!failed_transactions.empty()) {
            handleFailedTransactions(failed_transactions);
        }
    }
};

マルチスレッド環境での安全な使い方

マルチスレッド環境でのfor文の安全な使用方法と、効率的な並列処理の実装例を紹介します。

スレッドプールを使用した並列処理

class ThreadSafeProcessor {
public:
    ThreadSafeProcessor(size_t thread_count = std::thread::hardware_concurrency())
        : thread_pool_(thread_count) {}

    void processItems(const std::vector<Item>& items) {
        // 処理結果を格納するスレッドセーフなコンテナ
        std::vector<Result> results(items.size());
        std::mutex results_mutex;
        std::atomic<size_t> completed_count{0};

        // タスクをスレッドプールに分配
        for (size_t i = 0; i < items.size(); ++i) {
            thread_pool_.enqueue([this, &items, &results, &results_mutex, &completed_count, i]() {
                Result result = processItem(items[i]);

                {
                    std::lock_guard<std::mutex> lock(results_mutex);
                    results[i] = std::move(result);
                }

                ++completed_count;
            });
        }

        // 全タスクの完了を待機
        while (completed_count < items.size()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            double progress = (static_cast<double>(completed_count) / items.size()) * 100.0;
            std::cout << "\rProgress: " << progress << "%" << std::flush;
        }
        std::cout << "\nAll tasks completed." << std::endl;
    }

private:
    ThreadPool thread_pool_;

    Result processItem(const Item& item) {
        // 個別アイテムの処理
        Result result;
        // 処理ロジック
        return result;
    }
};

並列アルゴリズムの活用

class ParallelDataProcessor {
public:
    void processData(std::vector<Data>& data) {
        // データの並列変換
        std::for_each(std::execution::par_unseq, 
                      data.begin(), data.end(),
                      [this](Data& item) {
                          processDataItem(item);
                      });

        // 並列リダクション
        auto total = std::reduce(std::execution::par,
                               data.begin(), data.end(),
                               0.0,
                               [](double acc, const Data& item) {
                                   return acc + item.getValue();
                               });

        std::cout << "Total value: " << total << std::endl;
    }

private:
    void processDataItem(Data& item) {
        // スレッドセーフな処理
    }
};

テスタビリティを考慮したfor文の設計

テストが容易なfor文の実装パターンと、ユニットテストの作成例を紹介します。

テスト可能な反復処理の設計

// テスト可能な設計
class DataIterator {
public:
    explicit DataIterator(std::shared_ptr<IDataSource> data_source)
        : data_source_(std::move(data_source)) {}

    void processData() {
        auto data = data_source_->getData();
        ProcessingResult result;

        for (const auto& item : data) {
            if (shouldProcess(item)) {
                auto processed_item = processItem(item);
                result.addProcessedItem(processed_item);
            }
        }

        data_source_->saveResult(result);
    }

    // テスト用に公開されたメソッド
    bool shouldProcess(const DataItem& item) const {
        return item.isValid() && meetsProcessingCriteria(item);
    }

    ProcessedItem processItem(const DataItem& item) const {
        // ビジネスロジックの実装
        return ProcessedItem(item);
    }

private:
    std::shared_ptr<IDataSource> data_source_;

    bool meetsProcessingCriteria(const DataItem& item) const {
        // 処理基準のチェック
        return true;
    }
};

// 対応するユニットテスト
class DataIteratorTest : public ::testing::Test {
protected:
    void SetUp() override {
        data_source_ = std::make_shared<MockDataSource>();
        iterator_ = std::make_unique<DataIterator>(data_source_);
    }

    std::shared_ptr<MockDataSource> data_source_;
    std::unique_ptr<DataIterator> iterator_;
};

TEST_F(DataIteratorTest, ShouldProcessValidItem) {
    DataItem valid_item(true);
    EXPECT_TRUE(iterator_->shouldProcess(valid_item));
}

TEST_F(DataIteratorTest, ShouldNotProcessInvalidItem) {
    DataItem invalid_item(false);
    EXPECT_FALSE(iterator_->shouldProcess(invalid_item));
}

モックオブジェクトを使用したテスト

class MockProcessor : public IDataProcessor {
public:
    MOCK_METHOD(void, processItem, (const DataItem&), (override));
};

TEST(DataProcessingTest, ProcessesAllItemsInBatch) {
    // テストデータの準備
    std::vector<DataItem> items = {
        DataItem(1), DataItem(2), DataItem(3)
    };

    // モックの設定
    MockProcessor processor;
    EXPECT_CALL(processor, processItem(testing::_))
        .Times(items.size());

    // テスト対象の処理実行
    for (const auto& item : items) {
        processor.processItem(item);
    }
}

パラメータ化されたテスト

class ProcessingTest : public testing::TestWithParam<std::tuple<DataItem, bool>> {
protected:
    DataProcessor processor_;
};

TEST_P(ProcessingTest, ValidatesItemsCorrectly) {
    auto [item, expected] = GetParam();
    EXPECT_EQ(processor_.isValid(item), expected);
}

INSTANTIATE_TEST_SUITE_P(
    ProcessingTestSuite,
    ProcessingTest,
    testing::Values(
        std::make_tuple(DataItem(true), true),
        std::make_tuple(DataItem(false), false),
        std::make_tuple(DataItem(true, 5), true),
        std::make_tuple(DataItem(false, 0), false)
    )
);

これらの実装例は、実務で直面する様々な要件に対応できる堅牢なコードの基礎となります。パフォーマンス、スレッドセーフティ、テスタビリティを考慮することで、保守性の高い信頼できるシステムを構築することができます。