C++

// C++ 风格转换
static_cast<int>(3.14)           // 编译时类型转换
dynamic_cast<Derived*>(base)     // 运行时安全检查（多态）
const_cast<const T*>(ptr)        // 添加/移除 const
reinterpret_cast<int*>(addr)     // 底层位模式转换

// 列表初始化（C++11 起推荐）
int a{42};
vector<int> v{1, 2, 3};

#include <iostream>
using namespace std;

cout << "Hello, world!" << endl;
int x = 42;
cout << "x = " << x << endl;   // 链式输出

int age;
string name;
cin >> age;                    // 读取整数
cin >> name;                   // 读取字符串（遇空格停止）
getline(cin, name);            // 读取一行（含空格）

#include <iomanip>

cout << fixed << setprecision(2) << 3.14159;     // 3.14
cout << setw(8) << setfill('0') << 42;            // 00000042
cout << hex << 255 << " " << dec << 255;         // ff 255

if (条件) { ... }
else if (条件) { ... }
else { ... }

switch (表达式) {
    case 值1: ...; break;
    case 值2: ...; break;
    default: ...;
}

for (int i = 0; i < 10; i++) { ... }             // 传统 for
while (条件) { ... }                              // while
do { ... } while (条件);                          // do-while

// 范围 for（C++11）
vector<int> v = {1, 2, 3};
for (int x : v) { cout << x; }                   // 值拷贝
for (int& x : v) { x *= 2; }                     // 引用修改
for (const auto& x : v) { ... }                  // 只读引用（推荐）

// 函数定义
int add(int a, int b) {
    return a + b;
}

// 函数声明（原型）
int add(int a, int b);

// 函数调用
int result = add(3, 4);

int max(int a, int b) { return a > b ? a : b; }
double max(double a, double b) { return a > b ? a : b; }
// 编译时根据参数类型决定调用哪个

void print(string msg, int times = 1, char prefix = '>') {
    for (int i = 0; i < times; i++)
        cout << prefix << msg << endl;
}
print("hello");           // >hello
print("hi", 3, '*');      // *hi 三行

inline int square(int x) { return x * x; }
// 建议编译器将函数体展开，减少调用开销（适合短小函数）

template <typename T>
T max(T a, T b) {
    return a > b ? a : b;
}
max<int>(3, 4);        // 显式指定类型
max(3.0, 4.0);          // 隐式推导

void by_value(string s) { ... }           // 拷贝
void by_ref(string& s) { s += "!"; }      // 修改原值
void by_cref(const string& s) { ... }     // 只读，不拷贝（高效）
void by_move(vector<int>&& v) { ... }     // 移动语义

// 基本语法：[捕获列表](参数) -> 返回类型 { 函数体 }

auto add = [](int a, int b) -> int { return a + b; };
cout << add(3, 4);                              // 7

// 值捕获
int x = 10;
auto f1 = [x]() { return x + 1; };              // 拷贝 x

// 引用捕获
auto f2 = [&x]() { x += 1; };                   // 引用 x

// 隐式捕获
auto f3 = [=]() { ... };                        // 全部值捕获
auto f4 = [&]() { ... };                        // 全部引用捕获

// 泛型 lambda（C++14）
auto generic = [](auto a, auto b) { return a + b; };

int a = 42;
int* p = &a;           // 指针声明 & 取地址
cout << *p;            // 解引用 → 42
*p = 100;              // 通过指针修改
cout << a;             // 100

int* q = nullptr;      // 空指针（C++11，推荐替代 NULL）

int arr[3] = {10, 20, 30};
int* p = arr;
p++;                   // 指向下一个元素
cout << *p;            // 20

int a = 42;
int& ref = a;           // ref 是 a 的引用
ref = 100;              // 修改 ref 等价于修改 a
cout << a;              // 100

// 引用传参（修改原值）
void swap(int& a, int& b) {
    int tmp = a; a = b; b = tmp;
}

// const 引用传参（只读，不拷贝，高效）
void print(const vector<int>& v) {
    for (int x : v) cout << x;
}

// 返回引用（避免拷贝）
const string& getTitle(const Document& doc) {
    return doc.title;
}

#include <memory>

// unique_ptr — 独占所有权
unique_ptr<int> p = make_unique<int>(42);
// 不能拷贝，只能移动

// shared_ptr — 共享所有权（引用计数）
shared_ptr<int> p1 = make_shared<int>(42);
shared_ptr<int> p2 = p1;        // 引用计数 +1
// 最后一个 shared_ptr 析构时自动释放

// weak_ptr — 弱引用，避免循环引用
weak_ptr<int> wp = p1;          // 不影响引用计数
if (auto sp = wp.lock()) {      // 提升为 shared_ptr
    cout << *sp;
}