プログラミング/C++

C++の進化と現代的な設計

C++は、Bjarne Stroustrupによって1979年に開発が始まった言語で、継続的に進化し続けるプログラミング言語です。C++20とC++23の規格は、言語に革新的な機能をもたらし、モダンなプログラミングパラダイムを支援しています。

最新の言語機能

コンセプト（Concepts）と制約

C++20で導入されたコンセプトは、テンプレートの型に対する制約を明確に定義できます。

// テンプレート制約の定義
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// コンセプトを使用した関数テンプレート
template<Numeric T>
T add(T a, T b) {
    return a + b;
}

// 範囲ベースのアルゴリズム
template<Numeric T>
T sum_range(const std::vector<T>& values) {
    return std::accumulate(values.begin(), values.end(), T{0});
}

コルーチンと非同期処理

#include <coroutine>
#include <future>
#include <iostream>

// コルーチンを使用した非同期タスク
std::future<int> async_computation() {
    co_await std::suspend_always{};
    co_return 42;
}

// ジェネレータの実装
std::generator<int> range(int start, int end) {
    for (int i = start; i < end; ++i) {
        co_yield i;
    }
}

auto main() -> int {
    // 非同期タスクの実行
    auto future = async_computation();
    std::cout << "結果: " << future.get() << std::endl;

    // ジェネレータの使用
    for (int value : range(0, 5)) {
        std::cout << value << " ";
    }
}

モジュール

// math.cppm (モジュールインターフェース)
export module math;

export namespace math {
    export double square(double x) {
        return x * x;
    }

    export class Vector {
    public:
        Vector(double x, double y);
        double length() const;
    private:
        double x_, y_;
    };
}

// main.cpp
import math;
#include <iostream>

auto main() -> int {
    std::cout << "2の二乗: " << math::square(2) << std::endl;
    math::Vector vec(3, 4);
    std::cout << "ベクトルの長さ: " << vec.length() << std::endl;
}

オブジェクト指向とジェネリックプログラミング

// コンセプトを使用した汎用的なデータ構造
template<typename T>
requires std::copyable<T>
class SmartContainer {
private:
    std::vector<T> data;
    std::function<void(T&)> transformer;

public:
    SmartContainer(std::function<void(T&)> transform = [](T&){}) 
        : transformer(transform) {}

    void add(T item) {
        transformer(item);
        data.push_back(std::move(item));
    }

    // 範囲ベースのアルゴリズム
    template<typename Predicate>
    std::vector<T> filter(Predicate pred) const {
        std::vector<T> result;
        std::copy_if(data.begin(), data.end(), std::back_inserter(result), pred);
        return result;
    }
};

auto main() -> int {
    // 自動変換機能付きコンテナ
    SmartContainer<std::string> names([](std::string& s) {
        std::transform(s.begin(), s.end(), s.begin(), ::toupper);
    });

    names.add("alice");
    names.add("bob");

    // ラムダ式を使用したフィルタリング
    auto longNames = names.filter([](const std::string& s) {
        return s.length() > 3;
    });
}

並行処理と並列アルゴリズム

#include <thread>
#include <mutex>
#include <shared_mutex>
#include <execution>
#include <algorithm>

class ThreadSafeCounter {
private:
    mutable std::shared_mutex mutex_;
    unsigned int value_ = 0;

public:
    void increment() {
        std::unique_lock lock(mutex_);
        ++value_;
    }

    unsigned int get() const {
        std::shared_lock lock(mutex_);
        return value_;
    }
};

auto main() -> int {
    // 並列アルゴリズム
    std::vector<int> numbers(1000);
    std::iota(numbers.begin(), numbers.end(), 1);

    // 並列アルゴリズムによる変換
    std::transform(
        std::execution::par,  // 並列実行
        numbers.begin(), numbers.end(), numbers.begin(),
        [](int x) { return x * x; }
    );

    // スレッドプール
    std::vector<std::thread> threads;
    ThreadSafeCounter counter;

    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&counter]() {
            for (int j = 0; j < 1000; ++j) {
                counter.increment();
            }
        });
    }

    for (auto& t : threads) {
        t.join();
    }
}

メモリ管理と所有権

#include <memory>

class Resource {
public:
    Resource(int value) : data(value) {
        std::cout << "リソース作成: " << data << std::endl;
    }
    ~Resource() {
        std::cout << "リソース破棄: " << data << std::endl;
    }
private:
    int data;
};

void manage_resources() {
    // ユニークポインタ（排他的所有権）
    auto uniqueRes = std::make_unique<Resource>(42);

    // 共有ポインタ（参照カウント）
    auto sharedRes1 = std::make_shared<Resource>(100);
    auto sharedRes2 = sharedRes1;  // 参照カウントが増加
}

適用領域と設計哲学

C++は以下の分野で卓越しています：

• ゲーム開発
• システムプログラミング
• 高性能コンピューティング
• 組み込みシステム
• リアルタイムシステム

まとめ

C++は、低レベルの効率性と高レベルの抽象化を両立する言語です。C++20以降の規格は、言語に柔軟性と表現力をもたらし、現代的なプログラミングパラダイムへの対応を強化しています。複雑さの中にも洗練された設計哲学を持ち、プログラマに強力な表現力を提供します。