C++ 程序设计：
从面向过程到面向对象与现代 C++ 实战

#include <iostream>

int main()
{
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

// 单行注释（C99/C++ 都支持）

/*
   多行注释
*/

#include <iostream>

// 方式一：每次写 std::  （推荐，更清晰）
int main() {
    std::cout << "A" << std::endl;
    return 0;
}

// 方式二：使用 using 声明简化（大作业慎用，避免命名冲突）
using std::cout;     // 只引入 cout
using std::endl;

// 方式三：using namespace std;  （教学代码常用，工业代码慎用）

# 1. 用编辑器写 hello.cpp
$ vim hello.cpp

# 2. 用 g++ 编译：-o 指定输出文件名
$ g++ -std=c++17 hello.cpp -o hello

# 3. 运行
$ ./hello
Hello, World!

# 常用选项
$ g++ -Wall -Wextra -O2 -std=c++17 main.cpp -o main   # 警告 + 优化
$ g++ -g main.cpp -o main                            # 调试模式
$ g++ main.cpp -o main                               # 默认 C++ 标准（通常 C++14）

# CMakeLists.txt —— CMake 项目配置文件
cmake_minimum_required(VERSION 3.15)       # 最低版本要求
project(hello_cpp LANGUAGES CXX)           # 项目名 + 语言

set(CMAKE_CXX_STANDARD 17)              # 使用 C++17 标准
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(hello main.cpp)             # 生成可执行文件 hello

$ mkdir build && cd build
$ cmake ..            # 生成 Makefile / 构建系统
$ cmake --build .     # 编译
$ ./hello             # 运行

#include <iostream>
#include <string>

int main() {
    // 传统写法：明确类型
    int    age   = 18;
    double score = 95.5;
    std::string name = "Alice";

    // C++11 起：auto 让编译器推断类型
    auto x  = 42;          // int
    auto y  = 3.14;        // double
    auto s  = "hello";     // const char* （注意不是 string）
    auto z  = name + "!";  // std::string

    // 常量：const / constexpr
    const int       MAX = 100;
    constexpr double PI = 3.14159;   // 编译期常量

    std::cout << name << ", age=" << age << ", PI=" << PI << std::endl;
}

#include <iostream>
#include <string>

int main() {
    int          age;
    std::string name;

    std::cout << "请输入姓名和年龄：";
    std::cin >> name >> age;            // 自动跳过空白，不需要 &

    std::cout << "你好，" << name << "！今年 "
              << age << " 岁。" << std::endl;

    // 读一行（含空格）
    std::string line;
    std::getline(std::cin, line);
}

#include <iostream>

int main() {
    int    a = 10;
    double b = static_cast<double>(a) / 3;   // 编译期检查，常用

    const int x = 42;
    int* p = const_cast<int*>(&x);          // 去掉 const（慎用）

    // dynamic_cast 用于多态指针/引用的下行转换（见继承章节）
    // reinterpret_cast 是底层位重解释（极少使用）

    std::cout << b << std::endl;          // 3.333...
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 拷贝每个元素到 x（只读遍历）
    for (int x : numbers) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    // 引用遍历（修改元素）
    for (auto& x : numbers) {
        x = x * x;            // 平方
    }

    // const 引用：避免拷贝
    for (const auto& x : numbers) {
        std::cout << x << " ";
    }
}

if (score >= 90)        grade = 'A';
else if (score >= 80)   grade = 'B';
else if (score >= 60)   grade = 'C';
else                       grade = 'D';

switch (op) {
case '+': result = a + b; break;
case '-': result = a - b; break;
default: std::cerr << "未知操作符";
}

void greet(const std::string& name = "World",
          int times = 1) {
    for (int i = 0; i < times; i++)
        std::cout << "Hello, " << name << "!\n";
}

int main() {
    greet();              // Hello, World!  (用默认值)
    greet("Alice");      // Hello, Alice!
    greet("Bob", 3);    // 打印 3 次
}

int    add(int a, int b)              { return a + b; }
double add(double a, double b)     { return a + b; }
std::string add(const std::string& a,
                 const std::string& b) { return a + b; }

int main() {
    std::cout << add(1, 2)               << "\n"; // 3
    std::cout << add(1.5, 2.5)           << "\n"; // 4
    std::cout << add("Hello, ", "C++") << "\n"; // Hello, C++
}

// 1. 值传递：拷贝一份，不影响原值
void by_value(int x) { x = 999; }

// 2. 引用传递：直接操作原变量
void by_ref(int& x)    { x = 999; }

// 3. const 引用：只读，避免拷贝（推荐用于大对象）
void print(const std::string& s) { std::cout << s; }

// 4. 指针传递：也可修改，但调用方需传地址
void by_ptr(int* x) { if (x) *x = 999; }

// inline：建议编译器把函数体"内联"展开（避免函数调用开销）
inline int square(int x) { return x * x; }

// 递归：阶乘（注意终止条件）
long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

#include <string>
#include <iostream>

int main() {
    std::string s = "Hello";
    s += ", World!";                          // 拼接（+ 可用）
    std::cout << s << " 长度=" << s.size() << std::endl;

    // 子串、查找、替换
    std::string sub = s.substr(0, 5);              // "Hello"
    auto pos = s.find("World");                  // 7 或 npos
    s.replace(7, 5, "C++");                    // 替换 World → C++

    // 遍历
    for (char c : s) std::cout << c;            // 按字符遍历
}

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {1, 2, 3};
    v.push_back(4);                       // 末尾追加
    v.pop_back();                          // 末尾删除
    v.insert(v.begin() + 1, 99);          // 在下标 1 处插入

    std::cout << "size=" << v.size() << ", empty="
              << v.empty() << std::endl;

    // 二维 vector：矩阵
    std::vector<std::vector<int>> mat({{1,2},{3,4}});
}

#include <array>
#include <string>
#include <cstring>      // C 字符串函数（strlen 等）

std::array<int, 5> a = {1,2,3,4,5};   // 固定长度数组，有 size()、at()

// string ↔ C 风格字符串
std::string s = "hi";
const char* c = s.c_str();              // string → C-string
std::string s2 = c;                         // C-string → string

int a = 10;
int& ref = a;       // 引用：ref 是 a 的别名
int* p   = &a;      // 指针：p 存储 a 的地址

ref = 20;             // a 现在是 20
*p  = 30;             // a 现在是 30

int* p = nullptr;          // 推荐
// int* p = NULL;             // 不推荐（C 风格宏）

if (p == nullptr) { /* 安全检查 */ }
// 或更简洁（C++17）
if (!p) { /* ... */ }

// 1. 避免大对象拷贝
void print(const std::vector<int>& v) { /* 只读 */ }

// 2. 绑定到临时对象（右值）
std::string const& r = "literal" + "suffix";

// 3. const 引用延长临时对象生命周期
const int& x = 42;            // OK，普通引用不行

#include <string>

class Student {
public:                              // 公开：外部可访问
    Student();                              // 默认构造函数
    Student(const std::string& name, int age);
    ~Student();                             // 析构函数

    void study() const;
    void print() const;

    std::string getName() const { return name_; }   // 内联实现
    int         getAge()  const { return age_;  }

private:                             // 私有：外部不可访问（封装）
    std::string name_;
    int         age_;
};

#include <iostream>
#include "Student.h"

Student::Student() : name_("Unknown"), age_(0) {}    // 初始化列表

Student::Student(const std::string& n, int a)
    : name_(n), age_(a) {}

Student::~Student() { std::cout << name_ << " 毕业\n"; }

void Student::study() const {
    std::cout << name_ << " 正在学习\n";
}

void Student::print() const {
    std::cout << "姓名：" << name_ << "，年龄 " << age_ << std::endl;
}

int main() {
    Student s1;                              // 默认构造
    Student s2("Alice", 20);              // 带参构造
    Student* p = new Student("Bob", 19); // 堆上构造
    s2.study();
    s2.print();
    delete p;
}

class Box {
public:
    // this 指向当前对象的指针（类型 Box* const）
    Box& setW(int w) { this->w_ = w; return *this; }

    // const 成员函数：承诺不修改成员（可被 const 对象调用）
    int volume() const { return w_ * h_ * d_; }

private:
    int w_ = 1, h_ = 1, d_ = 1;
};

class Person {                       // 基类（父类）
public:
    void sayHi() { std::cout << "Hi!\n"; }
};

class Student : public Person {      // 派生类（子类）
public:
    void study() { std::cout << "学习\n"; }
};

Student s;
s.sayHi();   // 继承自 Person
s.study();   // 自己定义

#include <iostream>

class Animal {
public:
    virtual void speak() const {       // 虚函数
        std::cout << "...\n";
    }
    virtual ~Animal() = default;       // 虚析构（必须！）
};

class Dog : public Animal {
public:
    void speak() const override {         // override：编译期校验
        std::cout << "汪汪!\n";
    }
};

class Cat : public Animal {
public:
    void speak() const override {
        std::cout << "喵喵!\n";
    }
};

int main() {
    Animal* p = new Dog;
    p->speak();   // 汪汪!（运行时绑定到 Dog::speak）
    delete p;
}

class Shape {                       // 抽象类
public:
    virtual double area() const = 0;  // 纯虚函数
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double r_;
public:
    Circle(double r) : r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }
};

// Shape s;        // ❌ 不能实例化抽象类
Shape* p = new Circle(2);   // ✔ 通过派生类指针使用

#include <iostream>

struct Vec2 {
    double x, y;

    // 成员函数版：+=
    Vec2& operator+=(const Vec2& rhs) {
        x += rhs.x; y += rhs.y; return *this;
    }
};

// 非成员函数版：+ 与 <<
Vec2 operator+(Vec2 a, const Vec2& b) {
    return {a.x + b.x, a.y + b.y};
}

std::ostream& operator<<(std::ostream& os, const Vec2& v) {
    return os << "(" << v.x << ", " << v.y << ")";
}

int main() {
    Vec2 a{1,2}, b{3,4};
    std::cout << (a + b) << std::endl;   // (4, 6)
}

#include <iostream>

// 函数模板：T 是类型参数
template <typename T>
T add(T a, T b) { return a + b; }

// 类模板：通用的"盒子"
template <typename T>
class Box {
    T value_;
public:
    Box(T v) : value_(v) {}
    T get() const { return value_; }
};

int main() {
    std::cout << add(3, 5)            << "\n";   // 8（int）
    std::cout << add(1.5, 2.5)        << "\n";   // 4（double）

    Box<int>    bi(42);
    Box<std::string> bs("hello");
}

#include <concepts>

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

template <Addable T>
T add(T a, T b) { return a + b; }

#include <unordered_map>
#include <iostream>
#include <string>

int main() {
    std::unordered_map<std::string, int> scores;

    // 增
    scores["Alice"] = 95;
    scores["Bob"]   = 87;
    scores.insert({"Carol", 92});

    // 查
    auto it = scores.find("Alice");
    if (it != scores.end())
        std::cout << "Alice = " << it->second << std::endl;

    // 遍历（C++17 结构化绑定）
    for (const auto& [name, score] : scores)
        std::cout << name << ": " << score << std::endl;

    // 删
    scores.erase("Bob");
}

#include <algorithm>
#include <vector>
#include <numeric>     // accumulate
#include <iostream>

int main() {
    std::vector<int> v = {5, 2, 8, 1, 9, 3};

    std::sort(v.begin(), v.end());                 // 升序
    std::reverse(v.begin(), v.end());              // 反转

    auto it = std::find(v.begin(), v.end(), 8);   // 查找
    int  cnt = std::count(v.begin(), v.end(), 5); // 计数

    int sum = std::accumulate(v.begin(), v.end(), 0);

    bool found = std::binary_search(v.begin(), v.end(), 8);

    // 自定义比较器：降序
    std::sort(v.begin(), v.end(), [](int a, int b){ return a > b; });
}

[捕获列表] (参数) -> 返回类型 { 函数体 }

// 最简形式
auto hello = []() { std::cout << "Hi\n"; };

// 带参数和返回值
auto add = [](int a, int b) -> int { return a + b; };

// 与 STL 算法配合
std::sort(v.begin(), v.end(),
      [](int a, int b) { return a > b; });   // 降序

int x = 10, y = 20;

[]            // 不捕获任何外部变量
[x, y]        // 值捕获（拷贝）
[&x, &y]     // 引用捕获（可修改）
[=]           // 值捕获所有用到的外部变量
[&]           // 引用捕获所有用到的外部变量
[=, &x]      // 默认值捕获，但 x 用引用
[this]        // 捕获当前类的 this 指针

// 例：计数器
int cnt = 0;
auto inc = [&]() { return ++cnt; };
inc(); inc();    // cnt 现在是 2

#include <memory>

// 1) unique_ptr：独占（推荐首选）
auto p1 = std::make_unique<int>(42);
// std::unique_ptr p2 = p1;       // ❌ 不可复制
auto p2 = std::move(p1);                // ✔ 可移动

// 2) shared_ptr：共享
auto sp1 = std::make_shared<std::string>("hi");
auto sp2 = sp1;                          // 引用计数=2

// 3) weak_ptr：观察但不拥有
std::weak_ptr<std::string> wp = sp1;
if (auto locked = wp.lock()) {       // 提升为 shared_ptr
    // 使用 *locked
}

class File {
    FILE* fp_;
public:
    File(const char* path) : fp_(fopen(path, "r")) {}
    ~File() { if (fp_) fclose(fp_); }   // 自动关闭
    // 禁止拷贝或转移所有权
    File(const File&) = delete;
    File& operator=(const File&) = delete;
};

void read() {
    File f("data.txt");    // 打开；离开作用域自动关闭
    // 即使抛异常，析构也会执行
}

#include <fstream>
#include <string>

int main() {
    // 写文本
    std::ofstream out("out.txt");
    if (!out) return 1;
    out << "Hello, " << 42 << std::endl;

    // 读文本（按行）
    std::ifstream in("out.txt");
    std::string line;
    while (std::getline(in, line))
        std::cout << line << "\n";

    // 二进制：reinterpret_cast + read/write
    int arr[3] = {1, 2, 3};
    std::ofstream bin("a.bin", std::ios::binary);
    bin.write(reinterpret_cast<const char*>(arr), sizeof arr);
}

#include <stdexcept>

double divide(double a, double b) {
    if (b == 0)
        throw std::runtime_error("除数不能为零");
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 0);
    } catch (const std::runtime_error& e) {
        std::cerr << "错误：" << e.what() << std::endl;
    } catch (std::exception& e) {
        std::cerr << "其它异常：" << e.what() << std::endl;
    } catch (...) {
        std::cerr << "未知异常\n";
    }
}

#include <iostream>

template <typename T>
struct Node {
    T     data;
    Node* next;
    Node(T d, Node* n = nullptr) : data(d), next(n) {}
};

template <typename T>
class LinkedList {
    Node<T>* head_ = nullptr;
public:
    ~LinkedList() { while (head_) { auto t = head_; head_ = head_->next; delete t; } }

    void push_front(T v) { head_ = new Node<T>(v, head_); }

    void print() const {
        for (auto p = head_; p; p = p->next)
            std::cout << p->data << " -> ";
        std::cout << "nullptr\n";
    }
};

#include <vector>
#include <algorithm>

std::vector<int> v = {1, 3, 5, 7, 9};

bool ok = std::binary_search(v.begin(), v.end(), 7);

auto lo = std::lower_bound(v.begin(), v.end(), 5);  // 第一个 ≥5
auto hi = std::upper_bound(v.begin(), v.end(), 5);  // 第一个 >5

void quickSort(std::vector<int>& a, int lo, int hi) {
    if (lo >= hi) return;
    int pivot = a[(lo + hi) / 2];
    int i = lo, j = hi;
    while (i <= j) {
        while (a[i] < pivot) i++;
        while (a[j] > pivot) j--;
        if (i <= j) std::swap(a[i++], a[j--]);
    }
    quickSort(a, lo, j);
    quickSort(a, i, hi);
}

my_project/
├── CMakeLists.txt
├── include/
│   └── Student.h
├── src/
│   ├── Student.cpp
│   └── main.cpp
├── build/               // 编译产物
└── README.md

#pragma once
#include <string>

class Student {
public:
    Student(const std::string& name, int age);
    std::string getName() const;
private:
    std::string name_;
    int age_;
};

#include "Student.h"

Student::Student(const std::string& n, int a)
    : name_(n), age_(a) {}

std::string Student::getName() const { return name_; }

#include <iostream>
#include "Student.h"

int main() {
    Student s("Alice", 20);
    std::cout << s.getName();
}

cmake_minimum_required(VERSION 3.15)
project(my_project LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include_directories(include)        # 头文件搜索路径

add_executable(app
    src/main.cpp
    src/Student.cpp
)

$ git init
$ git add .
$ git commit -m "feat: 完成 Student 类的基本实现"
$ git log --oneline                # 查看历史

// 1) RAII 文件句柄
std::unique_ptr<FILE, decltype(&fclose)> fp(fopen("a.txt", "r"), &fclose);

// 2) 读整行
std::getline(std::cin, line);

// 3) split 字符串
std::istringstream iss(s); std::string tok;
while (iss >> tok) { /* ... */ }

// 4) 类型擦除的函数包装
std::function<int(int,int)> f = [](int a, int b){ return a + b; };

// 5) 时间测量
auto t0 = std::chrono::steady_clock::now();
// ... do work ...
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
    std::chrono::steady_clock::now() - t0).count();