1
2
3
4

# 最常用的三条命令
clang++ -std=c++23 -Wall -Wextra -O2 -o app main.cpp   # 编译
./app                                                  # 运行
clang++ -std=c++23 -Wall -Wextra -g -fsanitize=address,undefined -o app_dbg main.cpp   # 带检查的调试版

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <cstdio>
#include <format>
#include <iostream>

int main() {
    // printf：靠"格式符"对齐类型，写错了是 UB（不会报错，只会出怪结果）
    std::printf("%d %u %zu %lld %.2f %c %s %p\n",
                -1, 1u, sizeof(int), 1LL, 3.14159, 'A', "text", (void*)nullptr);

    // std::format（C++20）：靠"类型"检查，写错了编译期就报错
    std::cout << std::format("{}\n", 42);                     // 42
    std::cout << std::format("{:d} {:x} {:#x}\n", 255, 255, 255);   // 255 ff 0xff
    std::cout << std::format("{:.2f} {:>8} {:08.3f}\n", 3.14159, "hi", 3.14159);
    // 3.14       hi 0003.142
    std::cout << std::format("{:L}\n", 1234567);              // 按 locale 加千位分隔符
}

1
2
3
4

int a = 3.14;      // ① 拷贝初始化：可能发生隐式窄化（3.14 → 3），不推荐
int b(3.14);       // ② 直接初始化：同样可能窄化
int c{3.14};       // ③ 列表初始化：❌ 编译错误（防止窄化）——推荐
int d{};           // ④ 值初始化：d == 0

1
2
3
4

constexpr int n = 10;              // 编译期常量
const int m = 20;                  // 可能只是运行期常量
consteval int sq(int x) { return x * x; }
static_assert(sq(5) == 25);

1
2
3
4
5

int v = 1;
auto   a = v;        // int
auto&  b = v;        // int&
decltype(v)  c = v;  // int
decltype((v)) d = v; // int&（多了一层括号）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <map>
#include <iostream>
#include <string>
#include <tuple>

int main() {
    std::pair<int, std::string> p{1, "one"};
    auto [id, name] = p;                 // 拷贝
    auto& [id2, name2] = p;              // 引用，改 id2 就是改 p.first

    std::map<std::string, int> m{{"a", 1}};
    for (const auto& [key, value] : m) {   // 最常用的写法
        std::cout << key << " = " << value << '\n';
    }

    std::cout << id << ' ' << name << ' ' << id2 << ' ' << name2 << '\n';
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

double d = 3.9;
int i = static_cast<int>(d);          // 3（截断，不是四舍五入）

struct Base { virtual ~Base() = default; };
struct Derived : Base { int v = 1; };

void f(Base* b) {
    if (auto* p = dynamic_cast<Derived*>(b)) {   // 失败返回 nullptr
        (void)p->v;
    }
}

1
2
3
4
5
6
7
8
9

#include <memory>

void use(const Widget& w);                     // 只读借用：const 引用
void maybe(Widget* w) { if (w) use(*w); }      // 可能为空：指针

auto owned = std::make_unique<Widget>();       // 独占
auto shared = std::make_shared<Widget>();      // 共享
std::weak_ptr<Widget> weak = shared;           // 观察
if (auto locked = weak.lock()) { /* 还活着 */ }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

int main() {
    std::vector<int> v{5, 2, 9, 1, 7};
    std::ranges::sort(v);                     // C++20 的 ranges 版，直接传容器

    auto evens = v | std::views::filter([](int x){ return x % 2 == 0; });  // 惰性视图
    for (int x : evens) std::cout << x << ' ';      // 2
    std::cout << '\n';

    std::cout << std::accumulate(v.begin(), v.end(), 0) << '\n';   // 24
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

auto f1 = []{ return 1; };                          // 无参数
auto f2 = [](int x){ return x * 2; };               // 有参数
auto f3 = [](int x) -> long { return x; };          // 指定返回类型
int n = 10;
auto f4 = [n](int x){ return x + n; };              // 按值捕获
auto f5 = [&n](int x){ n += x; };                   // 按引用捕获
auto f6 = [=, &n]{ return n; };                     // 其余按值，n 按引用
auto f7 = [p = std::move(ptr)]{ return *p; };       // 初始化捕获（C++14）
auto f8 = [](auto x){ return x; };                  // 泛型 lambda（C++14）
auto f9 = [](this auto&& self, int x){ return x; }; // 显式对象参数（C++23）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Rule of 5 的手写签名
class Resource {
public:
    Resource();                                        // 构造
    ~Resource();                                       // 析构
    Resource(const Resource&);                         // 拷贝构造
    Resource& operator=(const Resource&);              // 拷贝赋值
    Resource(Resource&&) noexcept;                     // 移动构造
    Resource& operator=(Resource&&) noexcept;           // 移动赋值
};

1
2
3
4
5
6
7

class NonCopyable {
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;             // 禁止拷贝
    NonCopyable& operator=(const NonCopyable&) = delete;
    void legacy() = delete("请改用 newApi()");             // C++26：删除时给出理由
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <concepts>
#include <iostream>
#include <vector>

// 函数模板 + 约束（C++20）
template <std::integral T>
T twice(T x) { return x * 2; }

// 可变参数模板 + 折叠表达式（C++17）
template <typename... Ts>
auto sum(const Ts&... xs) { return (xs + ... + 0); }

// if constexpr：编译期分支（C++17）
template <typename T>
void describe(const T& v) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << v << '\n';
    } else {
        std::cout << "其他类型\n";
    }
}

// 可简写的约束（C++20）
void only_ints(std::integral auto x) { (void)x; }

int main() {
    std::cout << twice(21) << '\n';      // 42
    std::cout << sum(1, 2, 3) << '\n';   // 6
    describe(7);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 1. 有符号溢出 = UB；无符号溢出 = 良好定义（按 2^n 取模）
unsigned u = 0u - 1u;      // ✅ 良好定义：UINT_MAX
// int i = INT_MAX; i += 1;   // ❌ UB

// 2. UB 最可怕的地方：编译器会"假设它不会发生"，从而删掉你的检查
int f(int* p) {
    int x = *p;      // 如果 p 是空的，这里是 UB
    if (p == nullptr) return 0;   // 编译器可能把这一行整个删掉！
    return x;
}