C++のconstexprとconstevalを学ぶ！コンパイル時計算でプログラムを高速化する方法

#include <iostream>

// 通常の関数
int square_normal(int n)
{
    return n * n;
}

// constexpr関数
constexpr int square_constexpr(int n)
{
    return n * n;
}

int main()
{
    // 通常の関数：実行時に計算される
    int result1 = square_normal(5);
    
    // constexpr関数：コンパイル時に計算される（引数が定数の場合）
    constexpr int result2 = square_constexpr(5);
    
    std::cout << "通常の関数: " << result1 << std::endl;
    std::cout << "constexpr関数: " << result2 << std::endl;
    
    return 0;
}

#include <iostream>
#include <array>

constexpr double PI = 3.14159265359;
constexpr double circle_area(double radius)
{
    return PI * radius * radius;
}

int main()
{
    // 円の面積をコンパイル時に計算
    constexpr double area1 = circle_area(5.0);   // 半径5
    constexpr double area2 = circle_area(10.0);  // 半径10
    
    std::cout << "半径5の円の面積: " << area1 << std::endl;
    std::cout << "半径10の円の面積: " << area2 << std::endl;
    
    return 0;
}

#include <iostream>

// consteval関数：必ずコンパイル時に実行される
consteval int power_compile_time(int base, int exponent)
{
    int result = 1;
    for (int i = 0; i < exponent; ++i) {
        result *= base;
    }
    return result;
}

// constexpr関数：コンパイル時または実行時に実行される
constexpr int power_flexible(int base, int exponent)
{
    int result = 1;
    for (int i = 0; i < exponent; ++i) {
        result *= base;
    }
    return result;
}

int main()
{
    // consteval：必ずコンパイル時に計算される
    constexpr auto result1 = power_compile_time(2, 10); // 1024
    
    // constexpr：定数引数ならコンパイル時、変数引数なら実行時
    constexpr auto result2 = power_flexible(3, 4);      // 81（コンパイル時）
    
    int runtime_value = 5;
    auto result3 = power_flexible(2, runtime_value);    // 32（実行時）
    
    // 以下はコンパイルエラー！constevalは実行時に呼び出せない
    // auto result4 = power_compile_time(2, runtime_value);
    
    std::cout << "2^10 = " << result1 << std::endl;
    std::cout << "3^4 = " << result2 << std::endl;
    std::cout << "2^5 = " << result3 << std::endl;
    
    return 0;
}

#include <iostream>
#include <stdexcept>

consteval int validate_port(int port)
{
    if (port < 1 || port > 65535) {
        throw std::invalid_argument("ポート番号は1-65535の範囲で指定してください");
    }
    return port;
}

consteval const char* validate_protocol(const char* protocol)
{
    // 簡単な検証例
    if (protocol[0] == '\0') {
        throw std::invalid_argument("プロトコルが空です");
    }
    return protocol;
}

int main()
{
    // これらの値はコンパイル時に検証される
    constexpr int server_port = validate_port(8080);
    constexpr const char* protocol = validate_protocol("HTTP");
    
    // 以下はコンパイルエラーになる
    // constexpr int invalid_port = validate_port(70000); // 範囲外
    
    std::cout << "サーバーポート: " << server_port << std::endl;
    std::cout << "プロトコル: " << protocol << std::endl;
    
    return 0;
}

#include <iostream>
#include <array>
#include <chrono>

// 三角関数のテーブルをコンパイル時に生成
constexpr double PI = 3.14159265358979323846;

consteval double sin_approx(double x)
{
    // テイラー級数による近似（簡易版）
    double result = x;
    double term = x;
    for (int i = 1; i < 10; ++i) {
        term *= -x * x / ((2 * i) * (2 * i + 1));
        result += term;
    }
    return result;
}

// コンパイル時にsinテーブルを生成
template<size_t N>
consteval std::array<double, N> generate_sin_table()
{
    std::array<double, N> table{};
    for (size_t i = 0; i < N; ++i) {
        double angle = (2.0 * PI * i) / N;
        table[i] = sin_approx(angle);
    }
    return table;
}

int main()
{
    // 360度分のsinテーブル（コンパイル時に生成）
    constexpr auto sin_table = generate_sin_table<360>();
    
    // 使用例：45度のsin値
    constexpr size_t angle_45 = 45;
    std::cout << "sin(45°) ≈ " << sin_table[angle_45] << std::endl;
    
    // 90度のsin値
    constexpr size_t angle_90 = 90;
    std::cout << "sin(90°) ≈ " << sin_table[angle_90] << std::endl;
    
    return 0;
}

#include <iostream>
#include <chrono>

// 通常の関数
long long fibonacci_normal(int n)
{
    if (n <= 1) return n;
    return fibonacci_normal(n - 1) + fibonacci_normal(n - 2);
}

// constexpr関数
constexpr long long fibonacci_constexpr(int n)
{
    if (n <= 1) return n;
    return fibonacci_constexpr(n - 1) + fibonacci_constexpr(n - 2);
}

int main()
{
    const int N = 35;
    
    // 通常の関数の実行時間測定
    auto start = std::chrono::high_resolution_clock::now();
    auto result1 = fibonacci_normal(N);
    auto end = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    // constexpr関数（コンパイル時計算）の実行時間測定
    start = std::chrono::high_resolution_clock::now();
    constexpr auto result2 = fibonacci_constexpr(N); // コンパイル時に計算済み
    end = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
    
    std::cout << "フィボナッチ数列の" << N << "番目: " << result1 << std::endl;
    std::cout << "通常の関数の実行時間: " << duration1.count() << " ms" << std::endl;
    std::cout << "constexpr関数の実行時間: " << duration2.count() << " ns" << std::endl;
    std::cout << "速度向上: 約" << duration1.count() * 1000000 / duration2.count() << "倍" << std::endl;
    
    return 0;
}

#include <iostream>

constexpr int square(int n)
{
    return n * n;
}

int main()
{
    int user_input;
    std::cout << "数値を入力してください: ";
    std::cin >> user_input;
    
    // これは実行時計算になる（問題なし）
    auto result = square(user_input);
    
    // これはコンパイルエラー！constexprには定数が必要
    // constexpr auto compile_time_result = square(user_input);
    
    std::cout << "結果: " << result << std::endl;
    
    return 0;
}

#include <iostream>
#include <vector>

// これはコンパイルエラー！動的メモリ確保は不可
/*
constexpr std::vector<int> create_vector(int size)
{
    return std::vector<int>(size, 0);
}
*/

// 代わりにstd::arrayを使用
#include <array>

template<size_t N>
constexpr std::array<int, N> create_array()
{
    std::array<int, N> arr{};
    for (size_t i = 0; i < N; ++i) {
        arr[i] = static_cast<int>(i * i);
    }
    return arr;
}

int main()
{
    constexpr auto arr = create_array<10>();
    
    for (size_t i = 0; i < arr.size(); ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }
    
    return 0;
}