const 与 constexpr

const int ci = 10;          // 顶层 const：ci 本身不可变
const int* pi = &ci;        // 底层 const：pi 可改，但所指对象不可改
int* const cp = &x;         // 顶层 const：cp 不可改，所指对象可改
const int* const ccp = &ci; // 顶层 + 底层

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>

class GradeBook {
public:
    void add_student(const std::string& name, double score) {
        names_.push_back(name);
        scores_.push_back(score);
    }

    // const 成员函数：承诺不修改对象状态
    double average() const {
        if (scores_.empty()) return 0.0;
        double total = std::accumulate(scores_.begin(), scores_.end(), 0.0);
        return total / scores_.size();
    }

    double highest() const {
        if (scores_.empty()) return 0.0;
        return *std::max_element(scores_.begin(), scores_.end());
    }

    size_t student_count() const {
        return names_.size();
    }

    // 返回 const 引用：防止外部意外修改
    const std::vector<std::string>& names() const { return names_; }
    const std::vector<double>& scores() const { return scores_; }

private:
    std::vector<std::string> names_;
    std::vector<double> scores_;
    mutable size_t average_query_count_{0};  // 即使在 const 函数中也可修改
};

// 接收 const 引用：承诺不修改传入对象
void print_report(const GradeBook& book) {
    std::cout << "===== 成绩报告 =====" << std::endl;
    std::cout << "学生人数: " << book.student_count() << std::endl;
    std::cout << "平均分:   " << book.average() << std::endl;
    std::cout << "最高分:   " << book.highest() << std::endl;

    const auto& names = book.names();
    const auto& scores = book.scores();
    for (size_t i = 0; i < names.size(); ++i) {
        std::cout << "  " << names[i] << ": " << scores[i] << std::endl;
    }
}

int main() {
    GradeBook book;
    book.add_student("张三", 88.5);
    book.add_student("李四", 92.0);
    book.add_student("王五", 76.5);
    book.add_student("赵六", 85.0);

    print_report(book);

    // 验证 const 安全性：
    // book.names().push_back("攻击者");  // 编译错误：返回的是 const&
    // print_report 中 book.average() 合法，因为 average() 是 const

    return 0;
}

#include <iostream>
#include <array>

// C++11 写法：单一 return 语句
constexpr int factorial_11(int n) {
    return n <= 1 ? 1 : n * factorial_11(n - 1);
}

// C++14 写法：允许多条语句（编译器支持时可用）
constexpr int factorial_14(int n) {
    int result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

// 编译期计算斐波那契
constexpr int fibonacci(int n) {
    return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    // 编译期常量用于数组大小
    constexpr size_t size = factorial_11(5);  // 120
    std::array<int, size> arr{};               // 编译期确定大小

    std::cout << "数组大小: " << arr.size() << std::endl;

    // 编译期常量用于模板参数
    std::array<int, factorial_11(4)> fib_arr{};  // 24

    // 运行期也可调用 constexpr 函数
    int n;
    std::cout << "输入 n: ";
    std::cin >> n;
    std::cout << n << "! = " << factorial_14(n)
              << " (运行期计算)" << std::endl;

    // const vs constexpr
    const int rt_const = n * 2;            // 运行期只读
    constexpr int ct_const = factorial_11(6); // 编译期常量 = 720

    // constexpr 的威力：保证编译期可求值
    // constexpr int bad = n * 2;  // 编译错误：n 不是编译期常量

    std::cout << "6! = " << ct_const << " (编译期常量)" << std::endl;
    std::cout << "fibonacci(10) = " << fibonacci(10)
              << " (可在编译期求值)" << std::endl;

    return 0;
}

#include <iostream>

int main() {
    int x = 10, y = 20;

    // 从右向左读
    const int* p1 = &x;    // p1 是 → 指针 → 指向 → int → const
                           // 指向的 int 不可修改
    int const* p2 = &x;    // 与 p1 完全相同（const 在 * 前即可）

    int* const p3 = &x;    // p3 是 → const → 指针 → 指向 → int
                           // 指针本身不可修改

    const int* const p4 = &x; // 指针和所指对象都不可修改

    // *p1 = 30;   // 错误：p1 指向 const int
    p1 = &y;        // 正确：p1 本身不是 const

    *p3 = 30;       // 正确：p3 指向的 int 可修改
    // p3 = &y;    // 错误：p3 本身是 const

    std::cout << "x=" << x << ", y=" << y << std::endl;

    return 0;
}