C++標準ライブラリでの効率的な繰り返し処理の最適化手法

C++プログラミングにおいて、繰り返し処理は非常に重要な要素です。効率的な繰り返し処理を実現することで、プログラムのパフォーマンスを大幅に向上させることができます。本記事では、C++の標準ライブラリを活用し、繰り返し処理を最適化するためのさまざまな手法を詳しく解説します。

繰り返し処理の基礎

C++のプログラミングにおいて、繰り返し処理は重要な構造の一つです。基本的な繰り返し処理には、forループ、whileループ、およびdo-whileループがあります。

forループ

forループは、特定の回数だけ繰り返し処理を行う際に使用されます。以下に基本的なforループの構文を示します。

for (int i = 0; i < n; ++i) {
    // 繰り返し処理
}

whileループ

whileループは、条件が真である限り繰り返し処理を行います。以下に基本的なwhileループの構文を示します。

int i = 0;
while (i < n) {
    // 繰り返し処理
    ++i;
}

do-whileループ

do-whileループは、少なくとも一度は繰り返し処理を行い、その後条件を評価します。以下に基本的なdo-whileループの構文を示します。

int i = 0;
do {
    // 繰り返し処理
    ++i;
} while (i < n);

これらの基本的な繰り返し処理を理解することは、効率的なプログラムを作成するための第一歩です。次に、C++標準ライブラリを活用した繰り返し処理の最適化手法について説明します。

C++標準ライブラリの概要

C++標準ライブラリは、多くの便利な関数やクラスを提供しており、効率的なプログラム開発をサポートします。特に、繰り返し処理に関連するライブラリには、algorithmヘッダーに含まれる関数群があります。これらの関数を活用することで、コードの可読性を向上させ、バグを減少させることができます。

主要な繰り返し処理関数

C++標準ライブラリには、多くの繰り返し処理を簡素化する関数が含まれています。ここでは、その中でも特に頻繁に使用される関数を紹介します。

std::for_each

std::for_eachは、指定した範囲内の各要素に対して指定した関数を適用します。

#include <algorithm>
#include <vector>
#include <iostream>

void print(int n) {
    std::cout << n << " ";
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(v.begin(), v.end(), print);
}

std::transform

std::transformは、指定した範囲内の各要素に対して変換を行い、その結果を別の範囲に出力します。

#include <algorithm>
#include <vector>
#include <iostream>

int increment(int n) {
    return n + 1;
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result(v.size());
    std::transform(v.begin(), v.end(), result.begin(), increment);

    for (int n : result) {
        std::cout << n << " ";
    }
}

std::accumulate

std::accumulateは、指定した範囲内の要素を累積し、その結果を返します。

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::accumulate(v.begin(), v.end(), 0);

    std::cout << "Sum: " << sum << std::endl;
}

これらの関数を活用することで、繰り返し処理を簡潔に書くことができ、プログラムのパフォーマンスも向上します。次に、各関数の具体的な活用方法について詳しく見ていきましょう。

std::for_eachの活用

std::for_eachは、指定された範囲内の各要素に対して特定の操作を実行するための関数です。この関数を使用することで、従来のforループをより簡潔に書くことができます。

std::for_eachの基本構文

std::for_eachの基本的な構文は以下の通りです。

#include <algorithm>
#include <vector>
#include <iostream>

void print(int n) {
    std::cout << n << " ";
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(v.begin(), v.end(), print);
}

この例では、std::for_eachを使ってベクター内の各要素を出力しています。

利点と使用例

std::for_eachを使用する利点は、コードがシンプルで読みやすくなることです。また、関数オブジェクトやlambda関数を使用することで、より柔軟な処理が可能になります。

関数オブジェクトの使用

関数オブジェクトを用いると、特定の状態を持つ処理を実行することができます。

#include <algorithm>
#include <vector>
#include <iostream>

struct PrintWithPrefix {
    std::string prefix;
    PrintWithPrefix(const std::string& p) : prefix(p) {}

    void operator()(int n) const {
        std::cout << prefix << n << " ";
    }
};

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(v.begin(), v.end(), PrintWithPrefix("Number: "));
}

lambda関数の使用

lambda関数を用いると、短い無名関数をその場で定義して使用することができます。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(v.begin(), v.end(), [](int n) {
        std::cout << "Value: " << n << " ";
    });
}

std::for_eachを使ったパフォーマンスの向上

std::for_eachは、標準ライブラリに最適化された実装が用意されているため、手動で書いたforループに比べて高速に動作する場合があります。また、並列処理を導入する場合にも有利です。C++17から導入されたstd::for_each_nを用いることで、指定した回数だけ処理を行うことができます。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each_n(v.begin(), v.size(), [](int n) {
        std::cout << "Number: " << n << " ";
    });
}

このように、std::for_eachを活用することで、繰り返し処理の効率とコードの可読性を大幅に向上させることができます。次に、std::transformを用いた繰り返し処理の応用について説明します。

std::transformの応用

std::transformは、指定された範囲内の各要素に変換関数を適用し、その結果を別の範囲に出力するための関数です。これにより、繰り返し処理を効率化し、コードの可読性を向上させることができます。

std::transformの基本構文

std::transformの基本的な構文は以下の通りです。

#include <algorithm>
#include <vector>
#include <iostream>

int increment(int n) {
    return n + 1;
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result(v.size());
    std::transform(v.begin(), v.end(), result.begin(), increment);

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、std::transformを使ってベクター内の各要素に対してインクリメント操作を行い、その結果を別のベクターに格納しています。

利点と使用例

std::transformの利点は、簡潔でわかりやすいコードを書くことができる点です。また、並列処理や異なる範囲への出力も容易に行うことができます。

異なる範囲への変換

異なる範囲に変換結果を出力する例を示します。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v1 = {1, 2, 3, 4, 5};
    std::vector<int> v2 = {10, 20, 30, 40, 50};
    std::vector<int> result(v1.size());
    std::transform(v1.begin(), v1.end(), v2.begin(), result.begin(), std::plus<int>());

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、二つのベクターの対応する要素を加算し、その結果を新しいベクターに格納しています。

lambda関数の使用

lambda関数を使用して変換処理を簡潔に記述する例です。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result(v.size());
    std::transform(v.begin(), v.end(), result.begin(), [](int n) {
        return n * n;
    });

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、各要素を平方に変換して結果を出力しています。

std::transformを使ったパフォーマンスの向上

std::transformは、繰り返し処理の最適化において非常に効果的です。C++17以降では、並列処理をサポートするために、std::transformを並列アルゴリズムで使用することもできます。これにより、マルチスレッド環境でのパフォーマンスが向上します。

#include <algorithm>
#include <vector>
#include <execution>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result(v.size());
    std::transform(std::execution::par, v.begin(), v.end(), result.begin(), [](int n) {
        return n * 2;
    });

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、std::execution::parを指定して並列処理を行い、各要素を2倍に変換しています。並列処理を活用することで、大規模なデータセットに対しても効率的に処理を行うことができます。

次に、std::accumulateを使用した集計処理について詳しく説明します。

std::accumulateによる集計処理

std::accumulateは、指定された範囲内の要素を累積して1つの結果を得るための関数です。これにより、繰り返し処理をシンプルかつ効率的に実装することができます。

std::accumulateの基本構文

std::accumulateの基本的な構文は以下の通りです。

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::accumulate(v.begin(), v.end(), 0);

    std::cout << "Sum: " << sum << std::endl;
}

この例では、ベクター内のすべての要素を累積して合計を計算しています。

カスタム累積処理

std::accumulateはデフォルトで加算を行いますが、カスタムの累積処理を指定することも可能です。以下は、各要素を累積してその積を計算する例です。

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int product = std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>());

    std::cout << "Product: " << product << std::endl;
}

この例では、std::multipliesを使用して各要素の積を計算しています。

複雑な累積処理

より複雑な累積処理を行いたい場合は、カスタムの関数オブジェクトやlambda関数を利用することができます。以下は、各要素を累積し、その結果をベクターに格納する例です。

#include <numeric>
#include <vector>
#include <iostream>

struct SumAndStore {
    int operator()(int total, int current) {
        total += current;
        results.push_back(total);
        return total;
    }

    std::vector<int>& results;
};

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result;
    SumAndStore sumAndStore{result};
    std::accumulate(v.begin(), v.end(), 0, sumAndStore);

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、SumAndStore関数オブジェクトを使用して累積結果を別のベクターに格納しています。

std::accumulateを使ったパフォーマンスの向上

std::accumulateを使用することで、繰り返し処理の効率が向上し、コードの可読性も高まります。特に、大規模なデータセットを扱う場合に効果的です。また、並列処理を導入することでさらなるパフォーマンス向上が期待できますが、std::accumulateは標準ライブラリに並列版が存在しないため、std::reduceを利用することが推奨されます。

#include <numeric>
#include <vector>
#include <execution>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int sum = std::reduce(std::execution::par, v.begin(), v.end(), 0);

    std::cout << "Sum: " << sum << std::endl;
}

この例では、std::reduceを使用して並列処理を行い、ベクター内の要素を累積しています。並列処理により、大規模なデータセットでも効率的に処理を行うことができます。

次に、lambda関数を用いた柔軟な繰り返し処理の実装方法について説明します。

lambda関数の利用

lambda関数は、C++11以降で導入された無名関数で、関数オブジェクトを簡潔に記述するための強力なツールです。lambda関数を使用することで、繰り返し処理を柔軟かつ効率的に実装することができます。

lambda関数の基本構文

lambda関数の基本的な構文は以下の通りです。

[](引数リスト) -> 戻り値の型 {
    関数の本体
}

基本的な使用例

以下は、lambda関数を用いてベクターの各要素を2倍にする例です。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(v.begin(), v.end(), [](int& n) {
        n *= 2;
    });

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、std::for_eachを用いて各要素を2倍にしています。

捕捉機能の活用

lambda関数は、外部の変数をキャプチャすることができます。これにより、関数内で外部の状態を操作することが可能です。

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int factor = 3;
    std::for_each(v.begin(), v.end(), [factor](int& n) {
        n *= factor;
    });

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、外部変数factorをキャプチャし、各要素をその値で乗算しています。

複雑な条件での繰り返し処理

lambda関数を用いることで、複雑な条件を持つ繰り返し処理を簡潔に実装できます。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> evens;

    std::copy_if(v.begin(), v.end(), std::back_inserter(evens), [](int n) {
        return n % 2 == 0;
    });

    for (int n : evens) {
        std::cout << n << " ";
    }
}

この例では、std::copy_ifを使用して、偶数の要素だけを新しいベクターにコピーしています。

lambda関数を使ったパフォーマンスの向上

lambda関数を使用することで、コードが簡潔になり、可読性が向上します。また、キャプチャ機能を活用することで、状態を保持しつつ効率的な処理を実現できます。並列処理や他の標準ライブラリ関数と組み合わせることで、さらなるパフォーマンス向上も期待できます。

#include <vector>
#include <algorithm>
#include <execution>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int factor = 2;
    std::for_each(std::execution::par, v.begin(), v.end(), [factor](int& n) {
        n *= factor;
    });

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、並列実行ポリシーを指定してstd::for_eachを使用し、各要素を並列に処理しています。

次に、繰り返し処理における効率的なメモリ管理の重要性とその対策について説明します。

効率的なメモリ管理

繰り返し処理において、効率的なメモリ管理はプログラムのパフォーマンスを最適化するために非常に重要です。メモリの無駄を削減し、キャッシュの利用効率を高めることで、処理速度を向上させることができます。

メモリ管理の基本

メモリ管理の基本は、メモリの動的確保と解放を適切に行うことです。C++では、newとdelete、mallocとfreeなどの関数を用いてメモリを管理します。しかし、これらの関数を適切に使用しないと、メモリリークやフラグメンテーションが発生する可能性があります。

メモリリークの防止

動的に確保したメモリは、必ず適切に解放する必要があります。スマートポインタを使用することで、メモリリークを防止することができます。

#include <memory>
#include <vector>
#include <iostream>

int main() {
    std::vector<std::unique_ptr<int>> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(std::make_unique<int>(i));
    }

    for (const auto& ptr : v) {
        std::cout << *ptr << " ";
    }
}

この例では、std::unique_ptrを使用してメモリを自動的に管理しています。

キャッシュの利用効率を高める

メモリアクセスパターンを工夫することで、キャッシュの利用効率を高めることができます。連続したメモリ領域へのアクセスはキャッシュヒット率を高め、パフォーマンスを向上させます。

連続メモリへのアクセス

以下の例では、連続したメモリ領域にアクセスすることで、キャッシュヒット率を高めています。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v(100, 0);
    for (int i = 0; i < 100; ++i) {
        v[i] = i * 2;
    }

    int sum = 0;
    for (int i = 0; i < 100; ++i) {
        sum += v[i];
    }

    std::cout << "Sum: " << sum << std::endl;
}

この例では、ベクターに対するアクセスが連続して行われるため、キャッシュの利用効率が高まります。

std::vectorの利点

std::vectorは、動的配列であり、連続したメモリ領域を確保するため、キャッシュ効率が高いです。また、メモリ管理が自動化されているため、安全で効率的なメモリ操作が可能です。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i * 2);
    }

    for (const int& n : v) {
        std::cout << n << " ";
    }
}

この例では、std::vectorを使用して動的にメモリを管理し、効率的にデータを操作しています。

メモリプールの利用

大量の小さなメモリブロックを頻繁に確保・解放する場合、メモリプールを利用すると効率的です。メモリプールは、予め確保したメモリブロックを再利用することで、メモリ確保と解放のオーバーヘッドを削減します。

#include <boost/pool/simple_segregated_storage.hpp>
#include <vector>
#include <iostream>

int main() {
    boost::simple_segregated_storage<std::size_t> storage;
    std::vector<char> memory_pool(1024);
    storage.add_block(memory_pool.data(), memory_pool.size(), 16);

    int* p1 = static_cast<int*>(storage.malloc());
    int* p2 = static_cast<int*>(storage.malloc());

    *p1 = 42;
    *p2 = 84;

    std::cout << *p1 << " " << *p2 << std::endl;

    storage.free(p1);
    storage.free(p2);
}

この例では、Boostライブラリのメモリプールを使用して効率的にメモリを管理しています。

次に、繰り返し処理における応用例として、並列処理の活用方法について説明します。

応用例：並列処理

並列処理を用いることで、繰り返し処理のパフォーマンスを大幅に向上させることができます。C++では、標準ライブラリに含まれる並列アルゴリズムやスレッドライブラリを利用して、効率的な並列処理を実現できます。

並列アルゴリズムの使用

C++17以降、標準ライブラリに並列アルゴリズムが導入されました。これにより、for_eachやtransformなどのアルゴリズムを並列に実行することができます。

std::for_eachの並列実行

並列実行ポリシーを指定して、std::for_eachを並列に実行する例です。

#include <algorithm>
#include <vector>
#include <execution>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::for_each(std::execution::par, v.begin(), v.end(), [](int& n) {
        n *= 2;
    });

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、std::execution::parを指定することで、std::for_eachが並列に実行されます。

std::transformの並列実行

std::transformも同様に並列実行が可能です。

#include <algorithm>
#include <vector>
#include <execution>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    std::vector<int> result(v.size());
    std::transform(std::execution::par, v.begin(), v.end(), result.begin(), [](int n) {
        return n * 2;
    });

    for (int n : result) {
        std::cout << n << " ";
    }
}

この例では、各要素を並列に変換しています。

スレッドライブラリの使用

標準ライブラリのスレッド機能を使用して、並列処理を手動で実装することもできます。これにより、より細かな制御が可能となります。

std::threadを用いた並列処理

std::threadを使用して並列処理を実装する例です。

#include <thread>
#include <vector>
#include <iostream>

void multiply_by_two(std::vector<int>& v, int start, int end) {
    for (int i = start; i < end; ++i) {
        v[i] *= 2;
    }
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    int mid = v.size() / 2;
    std::thread t1(multiply_by_two, std::ref(v), 0, mid);
    std::thread t2(multiply_by_two, std::ref(v), mid, v.size());

    t1.join();
    t2.join();

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、ベクターの要素を2つのスレッドで並列に処理しています。

タスク並列ライブラリの使用

タスク並列ライブラリ（TBB）などの外部ライブラリを使用することで、さらに高度な並列処理が可能です。

Intel TBBを用いた並列処理

Intel TBBを使用して並列処理を実装する例です。

#include <tbb/tbb.h>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    tbb::parallel_for(tbb::blocked_range<size_t>(0, v.size()), [&](const tbb::blocked_range<size_t>& r) {
        for (size_t i = r.begin(); i != r.end(); ++i) {
            v[i] *= 2;
        }
    });

    for (int n : v) {
        std::cout << n << " ";
    }
}

この例では、tbb::parallel_forを使用してベクターの要素を並列に処理しています。

並列処理を適用することで、大規模なデータセットに対する繰り返し処理の効率を大幅に向上させることができます。次に、理解を深めるための実践的な演習問題を提示します。

演習問題

理解を深めるために、以下の演習問題に取り組んでみてください。これらの問題を解くことで、C++標準ライブラリと並列処理を用いた効率的な繰り返し処理のスキルを向上させることができます。

演習問題1：std::for_eachの利用

std::for_eachを使用して、ベクター内の各要素を3倍にし、結果を出力するプログラムを作成してください。

ヒント

std::for_eachを使用して、各要素に対して操作を実行する
lambda関数を使用して簡潔に記述する

演習問題2：std::transformの利用

std::transformを使用して、ベクター内の各要素を平方に変換し、その結果を別のベクターに格納して出力するプログラムを作成してください。

ヒント

std::transformを使用して、各要素を変換する
変換結果を新しいベクターに格納する

演習問題3：std::accumulateの利用

std::accumulateを使用して、ベクター内のすべての要素の合計を計算し、結果を出力するプログラムを作成してください。
std::accumulateを使用して、ベクター内のすべての要素の積を計算し、結果を出力するプログラムを作成してください。

ヒント

std::accumulateを使用して、累積処理を実行する
加算と乗算の両方の例を実装する

演習問題4：並列処理の利用

std::for_eachを並列実行ポリシーを用いて並列に実行し、ベクター内の各要素を2倍にするプログラムを作成してください。
std::transformを並列実行ポリシーを用いて並列に実行し、ベクター内の各要素を3倍にするプログラムを作成してください。

ヒント

std::execution::parを使用して並列実行を指定する
並列実行ポリシーを適用する

演習問題5：効率的なメモリ管理

std::vectorを使用して、動的に整数値を格納し、すべての要素を出力するプログラムを作成してください。
スマートポインタを使用して、動的に確保されたメモリを自動的に管理し、メモリリークを防止するプログラムを作成してください。

ヒント

std::vectorを使用して動的メモリを管理する
std::unique_ptrやstd::shared_ptrを使用してメモリリークを防止する

これらの演習問題に取り組むことで、C++標準ライブラリを使用した効率的な繰り返し処理と並列処理のスキルを磨くことができます。次に、本記事の要点を簡潔にまとめます。

まとめ

本記事では、C++標準ライブラリを活用した効率的な繰り返し処理の最適化手法について詳しく解説しました。まず、基本的な繰り返し処理の構文を確認し、その後、標準ライブラリに含まれる主要な関数であるstd::for_each、std::transform、std::accumulateの使い方を紹介しました。これらの関数を用いることで、コードの可読性とパフォーマンスを向上させることができます。

さらに、lambda関数を利用することで、より柔軟で簡潔なコードを書く方法を説明しました。繰り返し処理における効率的なメモリ管理の重要性と、メモリリークを防ぐための手法についても解説しました。最後に、並列処理を用いて繰り返し処理のパフォーマンスをさらに向上させる方法を紹介し、具体的な実装例を示しました。

演習問題を通じて、これらの概念を実践し、理解を深めていただければ幸いです。C++標準ライブラリを効果的に活用し、効率的なプログラムを作成するための参考になればと思います。

C++標準ライブラリでの効率的な繰り返し処理の最適化手法

繰り返し処理の基礎

forループ

whileループ

do-whileループ

C++標準ライブラリの概要

主要な繰り返し処理関数

std::for_each

std::transform

std::accumulate

std::for_eachの活用

std::for_eachの基本構文

利点と使用例

関数オブジェクトの使用

lambda関数の使用

std::for_eachを使ったパフォーマンスの向上

std::transformの応用

std::transformの基本構文

利点と使用例

異なる範囲への変換

lambda関数の使用

std::transformを使ったパフォーマンスの向上

std::accumulateによる集計処理

std::accumulateの基本構文

カスタム累積処理

複雑な累積処理

std::accumulateを使ったパフォーマンスの向上

lambda関数の利用

lambda関数の基本構文

基本的な使用例

捕捉機能の活用

複雑な条件での繰り返し処理

lambda関数を使ったパフォーマンスの向上

効率的なメモリ管理

メモリ管理の基本

メモリリークの防止

キャッシュの利用効率を高める

連続メモリへのアクセス

std::vectorの利点

メモリプールの利用

応用例：並列処理

並列アルゴリズムの使用

std::for_eachの並列実行

std::transformの並列実行

スレッドライブラリの使用

std::threadを用いた並列処理

タスク並列ライブラリの使用

Intel TBBを用いた並列処理

演習問題

演習問題1：std::for_eachの利用

ヒント

演習問題2：std::transformの利用

ヒント

演習問題3：std::accumulateの利用

ヒント

演習問題4：並列処理の利用

ヒント

演習問題5：効率的なメモリ管理

ヒント

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル