关键字与类型检查¶

#include <iostream>
using namespace std;

int main() {
    // const变量必须初始化
    const int size = 10;

    // C++中const是真正的编译期常量，可用于数组长度
    int arr[size];      // ✓ 正确！

    // 通过指针修改const变量 → 编译错误
    // int* p = &size;          // 错误！不能将 const int* 转为 int*
    // const_cast<int*>(&size); // 可以强制转换，但修改是未定义行为

    cout << "size = " << size << endl;

    return 0;
}

#include <iostream>
using namespace std;

// constexpr函数：在编译期求值
constexpr int square(int x) {
    return x * x;
}

int main() {
    // constexpr声明的数据必须是编译期常量
    constexpr int SIZE = 10;              // ✓ 编译期常量
    constexpr int ARR_SIZE = SIZE * 2;    // ✓ 编译期常量
    constexpr int SQUARE = square(5);     // ✓ 编译期求值

    int arr[ARR_SIZE];                    // ✓ 可用于数组长度

    cout << "SIZE = " << SIZE << endl;
    cout << "ARR_SIZE = " << ARR_SIZE << endl;
    cout << "SQUARE = " << SQUARE << endl;

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // auto自动推导类型
    auto i = 10;           // int
    auto d = 3.14;         // double
    auto c = 'A';          // char
    auto s = "hello";      // const char*

    // 复杂类型用auto更简洁
    vector<int> v = {1, 2, 3, 4, 5};

    // C++98/03风格：迭代器类型很长
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    // C++11风格：使用auto
    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

int x = 10;
const int cx = 20;
int& rx = x;

auto a1 = x;      // int
auto a2 = cx;     // int（忽略const）
auto a3 = rx;     // int（忽略引用）

const auto a4 = x;  // const int（显式添加const）
auto& a5 = rx;      // int&（显式添加引用）

auto a6 = 1, a7 = 2;   // 正确：auto 都推导为 int
//auto a8 = 1, a9 = 2.0;   // 错误：a8 推导为 int，a9 推导为 double

#include <iostream>
using namespace std;

int main() {
    int x = 10;
    const int cx = 20;
    int& rx = x;

    decltype(x) d1 = 5;      // int
    decltype(cx) d2 = 30;    // const int（保留const）
    decltype(rx) d3 = x;     // int&（保留引用）

    // 表达式推导
    decltype(x + 3.14) d4 = x + 3.14;  // double
    decltype(&x) d5 = &x;              // int*

    cout << "d1 = " << d1 << endl;
    cout << "d2 = " << d2 << endl;
    cout << "d3 = " << d3 << endl;
    cout << "d4 = " << d4 << endl;

    return 0;
}

#include <iostream>
using namespace std;

void func(int x) {
    cout << "func(int) called" << endl;
}

void func(char* p) {
    cout << "func(char*) called" << endl;
}

int main() {
    func(0);       // 调用 func(int)
    func(NULL);    // 调用 func(int)！而不是 char* 版本
    // func(nullptr); // C++11：调用 func(char*)

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

// constexpr 函数：编译期求值
constexpr int square(int x) {
    return x * x;
}

// 函数重载演示
void printValue(int x) {
    cout << "printValue(int): " << x << endl;
}

void printValue(double x) {
    cout << "printValue(double): " << x << endl;
}

void printValue(const char* s) {
    cout << "printValue(const char*): " << s << endl;
}

// 接受指针参数的函数
void process(int* p) {
    if (p != nullptr) {   // 推荐使用 nullptr
        cout << "process: " << *p << endl;
    } else {
        cout << "process: null pointer" << endl;
    }
}

int main() {
    // 1. constexpr：编译期常量
    constexpr int ARRAY_SIZE = square(5);   // 编译期计算 25
    int arr[ARRAY_SIZE];                    // 可用于数组长度

    // 2. auto：类型推导
    auto i = 10;                    // int
    auto d = 3.14;                  // double
    auto s = "hello";               // const char*
    auto v = vector<int>{1, 2, 3};  // vector<int>

    // 3. decltype：表达式类型推导
    decltype(i) a = 20;             // int
    decltype(d) b = 2.71;           // double
    decltype(i + d) c = i + d;      // double

    // 4. nullptr：类型安全的空指针
    int* p1 = nullptr;
    int* p2 = nullptr;

    // 5. 函数调用
    printValue(10);       // printValue(int)
    printValue(3.14);     // printValue(double)
    printValue("hello");  // printValue(const char*)

    // 6. nullptr 与函数重载
    process(p1);          // process: null pointer
    process(&a);          // process: 20

    // 7. const vs constexpr
    const int runtime_const = i + 10;   // 运行时只读
    constexpr int compile_const = 100;  // 编译期常量

    // 8. 范围 for + auto（简单示例）
    cout << "Vector elements: ";
    for (auto x : v) {
        cout << x << " ";
    }
    cout << endl;

    return 0;
}