C++ 快速学习教程

一、基础语法篇

1. 开发环境搭建

• GCC/MinGW 编译器
  • 详解：GCC 是 GNU 编译器套装，MinGW 是 Windows 平台上的 GCC 移植版。它们可以将 C++ 源代码编译成可执行文件。在 Linux 系统上通常默认安装了 GCC，而在 Windows 上可以通过安装 MinGW 来使用 GCC。
  • 示例（Windows 下使用 MinGW）：假设已经安装并配置好 MinGW，有一个简单的 C++ 源文件 hello.cpp：

#include <iostream>int main() {std::cout << "Hello, MinGW!" << std::endl;return 0;
}

在命令行中使用 g++ hello.cpp -o hello.exe 进行编译，然后运行 hello.exe 即可看到输出。

• IDE 配置（VS/VSCode/CLion）
  • 详解
    • Visual Studio（VS）：是微软的集成开发环境，功能强大，有丰富的调试和代码分析工具。
    • Visual Studio Code（VSCode）：轻量级的跨平台代码编辑器，通过安装 C++ 扩展可以实现 C++ 开发，支持代码高亮、智能代码补全等功能。
    • CLion：JetBrains 开发的跨平台 C++ IDE，对 C++ 支持非常好，有智能代码提示、强大的调试功能等。
  • 示例（VSCode）：安装 C++ 扩展，安装 MinGW 并配置环境变量。创建一个新的 C++ 文件，编写上述 hello.cpp 代码，然后按 F5 进行调试运行。

2. 程序结构

• main 函数
  • 详解：C++ 程序的执行从 main 函数开始。main 函数的返回值类型通常是 int，返回 0 表示程序正常结束，非 0 值表示程序异常结束。
  • 示例：

#include <iostream>// main 函数是程序的入口点
int main() {std::cout << "This is the main function." << std::endl;return 0;
}

• 头文件与源文件
  • 详解：头文件（通常以 .h 或 .hpp 为扩展名）用于声明函数、类、常量等，源文件（通常以 .cpp 为扩展名）用于实现头文件中声明的内容。这样做可以提高代码的模块化和可维护性。
  • 示例：
    example.h

// 函数声明
void printMessage();

example.cpp

#include <iostream>
#include "example.h"// 函数实现
void printMessage() {std::cout << "This is a message from a function." << std::endl;
}

main.cpp

#include "example.h"int main() {printMessage();return 0;
}

3. 基础数据类型

• 整型 / 浮点型 / 字符型
  • 详解
    • 整型：用于表示整数，如 int、short、long 等。
    • 浮点型：用于表示小数，如 float、double。
    • 字符型：用于表示单个字符，如 char。
  • 示例：

#include <iostream>int main() {// 整型int num = 10;// 浮点型double pi = 3.14159;// 字符型char ch = 'A';std::cout << "Integer: " << num << std::endl;std::cout << "Double: " << pi << std::endl;std::cout << "Character: " << ch << std::endl;return 0;
}

• 类型转换（static_cast 等）
  • 详解：static_cast 是一种编译时类型转换，用于在相关类型之间进行转换，如整数类型之间、浮点类型之间、整数和浮点类型之间等。它比 C 风格的强制类型转换更安全，因为它在编译时进行类型检查。
  • 示例：

#include <iostream>int main() {double d = 3.14;// 使用 static_cast 进行类型转换int i = static_cast<int>(d);std::cout << "Double value: " << d << std::endl;std::cout << "Converted int value: " << i << std::endl;return 0;
}

4. 流程控制

• 条件语句（if - else/switch）
  • 详解
    • if - else：用于根据条件执行不同的代码块。
    • switch：用于根据一个表达式的值选择执行多个代码块中的一个。
  • 示例：

#include <iostream>int main() {int num = 5;if (num > 0) {std::cout << "The number is positive." << std::endl;} else if (num < 0) {std::cout << "The number is negative." << std::endl;} else {std::cout << "The number is zero." << std::endl;}int choice = 2;switch (choice) {case 1:std::cout << "You chose option 1." << std::endl;break;case 2:std::cout << "You chose option 2." << std::endl;break;default:std::cout << "Invalid choice." << std::endl;}return 0;
}

• 循环结构（for/while/do - while）
  • 详解
    • for 循环：通常用于已知循环次数的情况。
    • while 循环：在条件为真时重复执行代码块。
    • do - while 循环：先执行一次代码块，然后在条件为真时继续执行。
  • 示例：

#include <iostream>int main() {// for 循环for (int i = 0; i < 5; ++i) {std::cout << "For loop iteration: " << i << std::endl;}// while 循环int j = 0;while (j < 3) {std::cout << "While loop iteration: " << j << std::endl;++j;}// do - while 循环int k = 0;do {std::cout << "Do - while loop iteration: " << k << std::endl;++k;} while (k < 2);return 0;
}

二、面向对象编程

1. 类与对象

• 成员变量 / 方法
  • 详解：类是一种用户自定义的数据类型，它可以包含成员变量（数据成员）和成员方法（函数成员）。成员变量用于存储对象的状态，成员方法用于操作这些状态。
  • 示例：

#include <iostream>// 定义一个简单的类
class Rectangle {
private:// 成员变量int width;int height;public:// 构造函数Rectangle(int w, int h) : width(w), height(h) {}// 成员方法int area() {return width * height;}
};int main() {// 创建对象Rectangle rect(5, 3);std::cout << "Rectangle area: " << rect.area() << std::endl;return 0;
}

• 访问控制（public/private/protected）
  • 详解
    • public：公有成员可以在类的外部被访问。
    • private：私有成员只能在类的内部被访问，通常用于封装数据，防止外部直接修改。
    • protected：受保护成员可以在类的内部和派生类中被访问。
  • 示例：在上面的 Rectangle 类中，width 和 height 是私有的，只能通过类的成员方法访问，保证了数据的安全性。

2. 构造函数与析构函数

• 详解
  • 构造函数：在创建对象时自动调用，用于初始化对象的成员变量。
  • 析构函数：在对象销毁时自动调用，用于释放对象占用的资源。
• 示例：

#include <iostream>class MyClass {
public:// 构造函数MyClass() {std::cout << "Constructor called." << std::endl;}// 析构函数~MyClass() {std::cout << "Destructor called." << std::endl;}
};int main() {{MyClass obj;} // 当 obj 离开作用域时，析构函数会被调用return 0;
}

3. 继承与多态

• 虚函数与 override 关键字
  • 详解
    • 虚函数：在基类中用 virtual 关键字声明的函数，允许在派生类中重写。
    • override 关键字：用于显式地表明派生类中的函数是重写基类的虚函数，避免因函数签名错误而导致的错误。
  • 示例：

#include <iostream>// 基类
class Shape {
public:// 虚函数virtual void draw() {std::cout << "Drawing a shape." << std::endl;}
};// 派生类
class Circle : public Shape {
public:// 重写虚函数void draw() override {std::cout << "Drawing a circle." << std::endl;}
};int main() {Shape* shape = new Circle();shape->draw(); // 调用派生类的 draw 函数delete shape;return 0;
}

• 抽象类与接口
  • 详解
    • 抽象类：包含纯虚函数（用 = 0 声明的虚函数）的类，不能实例化，通常作为基类供其他类继承。
    • 接口：在 C++ 中通常用抽象类来实现接口的概念，一个类可以继承多个抽象类来实现多个接口。
  • 示例：

#include <iostream>// 抽象类
class AbstractShape {
public:// 纯虚函数virtual void draw() = 0;
};// 派生类实现抽象类
class Square : public AbstractShape {
public:void draw() override {std::cout << "Drawing a square." << std::endl;}
};int main() {AbstractShape* shape = new Square();shape->draw();delete shape;return 0;
}

4. 运算符重载

• 详解：运算符重载允许自定义类的对象使用内置运算符（如 +、-、* 等）进行操作。通过重载运算符，可以使自定义类的对象的行为更像内置类型。
• 示例：

#include <iostream>class Complex {
private:double real;double imag;public:Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}// 重载 + 运算符Complex operator+(const Complex& other) const {return Complex(real + other.real, imag + other.imag);}void print() {std::cout << real << " + " << imag << "i" << std::endl;}
};int main() {Complex c1(1.0, 2.0);Complex c2(3.0, 4.0);Complex c3 = c1 + c2;c3.print();return 0;
}

三、高级特性

1. 模板编程

• 函数模板
  • 详解：函数模板是一种通用的函数定义，它可以处理不同类型的数据，通过模板参数来实现类型的参数化。编译器会根据调用时的实际参数类型生成具体的函数实例。
  • 示例：

#include <iostream>// 函数模板
template <typename T>
T add(T a, T b) {return a + b;
}int main() {int result1 = add(1, 2);double result2 = add(1.5, 2.5);std::cout << "Int result: " << result1 << std::endl;std::cout << "Double result: " << result2 << std::endl;return 0;
}

• 类模板
  • 详解：类模板是一种通用的类定义，它可以根据不同的类型参数生成不同的类。类似于函数模板，编译器会根据实际使用的类型生成具体的类实例。
  • 示例：

#include <iostream>// 类模板
template <typename T>
class Pair {
private:T first;T second;public:Pair(T f, T s) : first(f), second(s) {}T getFirst() const {return first;}T getSecond() const {return second;}
};int main() {Pair<int> p(1, 2);std::cout << "First: " << p.getFirst() << ", Second: " << p.getSecond() << std::endl;return 0;
}

2. 异常处理

• 详解：异常处理机制允许程序在运行时处理错误和异常情况。try 块中包含可能抛出异常的代码，catch 块用于捕获并处理异常，throw 语句用于抛出异常。
• 示例：

#include <iostream>int divide(int a, int b) {if (b == 0) {throw std::runtime_error("Division by zero!");}return a / b;
}int main() {try {int result = divide(10, 0);std::cout << "Result: " << result << std::endl;} catch (const std::runtime_error& e) {std::cout << "Exception caught: " << e.what() << std::endl;}return 0;
}

3. 命名空间

• 详解：命名空间用于避免命名冲突，将不同的代码模块或库中的名称分隔开来。可以在命名空间中定义变量、函数、类等。
• 示例：

#include <iostream>// 定义命名空间
namespace MyNamespace {int value = 42;void printValue() {std::cout << "Value in MyNamespace: " << value << std::endl;}
}int main() {// 使用命名空间中的成员MyNamespace::printValue();return 0;
}

4. 类型推导（auto/decltype）

• 详解
  • auto：用于自动推导变量的类型，编译器会根据变量的初始化表达式来确定其类型。
  • decltype：用于获取表达式的类型，常用于模板编程和泛型编程中。
• 示例：

#include <iostream>int main() {auto num = 10; // 自动推导为 int 类型decltype(num) anotherNum = 20; // 与 num 类型相同std::cout << "num: " << num << std::endl;std::cout << "anotherNum: " << anotherNum << std::endl;return 0;
}

四、标准库与 STL

1. 容器

• vector：动态数组，支持随机访问，元素在内存中连续存储。

#include <iostream>
#include <vector>int main() {std::vector<int> v;v.push_back(1);v.push_back(2);for (int i : v) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

• list：双向链表，不支持随机访问，但插入和删除操作效率高。

#include <iostream>
#include <list>int main() {std::list<int> l;l.push_back(1);l.push_front(2);for (int i : l) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

• map：关联容器，存储键值对，键是唯一的，元素按照键的顺序排序。

#include <iostream>
#include <map>int main() {std::map<std::string, int> m;m["apple"] = 10;m["banana"] = 20;for (const auto& pair : m) {std::cout << pair.first << ": " << pair.second << std::endl;}return 0;
}

2. 算法

• sort：对容器中的元素进行排序。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> v = {3, 1, 2};std::sort(v.begin(), v.end());for (int i : v) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

• find：在容器中查找指定元素。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> v = {1, 2, 3};auto it = std::find(v.begin(), v.end(), 2);if (it != v.end()) {std::cout << "Found: " << *it << std::endl;} else {std::cout << "Not found" << std::endl;}return 0;
}

• transform：对容器中的元素进行变换。

#include <iostream>
#include <vector>
#include <algorithm>int square(int x) {return x * x;
}int main() {std::vector<int> v = {1, 2, 3};std::vector<int> result;std::transform(v.begin(), v.end(), std::back_inserter(result), square);for (int i : result) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

3. 智能指针

• unique_ptr：独占式智能指针，同一时间只能有一个 unique_ptr 指向同一个对象。当 unique_ptr 离开作用域时，它会自动释放所指向的对象。

#include <iostream>
#include <memory>int main() {std::unique_ptr<int> p(new int(10));std::cout << *p << std::endl;return 0;
}

• shared_ptr：共享式智能指针，多个 shared_ptr 可以指向同一个对象，通过引用计数来管理对象的生命周期。当引用计数为 0 时，对象会被自动释放。

#include <iostream>
#include <memory>int main() {std::shared_ptr<int> p1(new int(10));std::shared_ptr<int> p2 = p1;std::cout << *p1 << " " << *p2 << std::endl;return 0;
}

4. 文件流操作

• ifstream：用于读取文件。

#include <iostream>
#include <fstream>
#include <string>int main() {std::ifstream file("test.txt");if (file.is_open()) {std::string line;while (std::getline(file, line)) {std::cout << line << std::endl;}file.close();}return 0;
}

• ofstream：用于写入文件。

#include <iostream>
#include <fstream>int main() {std::ofstream file("test.txt");if (file.is_open()) {file << "Hello, World!" << std::endl;file.close();}return 0;
}

五、内存管理

1. 指针与引用

• 指针：存储变量的内存地址，可以通过解引用操作符 * 访问所指向的变量。

#include <iostream>int main() {int x = 10;int* p = &x;std::cout << *p << std::endl;return 0;
}

• 引用：是变量的别名，必须在定义时初始化，并且不能重新绑定到其他变量。

#include <iostream>int main() {int x = 10;int& ref = x;std::cout << ref << std::endl;return 0;
}

2. 堆与栈内存

• 栈内存：由编译器自动分配和释放，用于存储局部变量。栈内存的分配和释放速度快，但空间有限。
• 堆内存：由程序员手动分配和释放（使用 new 和 delete 运算符），用于存储动态分配的对象。堆内存的空间较大，但分配和释放速度相对较慢，并且容易出现内存泄漏。

3. 内存泄漏检测

• Valgrind：一个流行的内存调试工具，可以检测内存泄漏、越界访问等问题。

valgrind --leak-check=full ./your_program

4. 移动语义（C++11）

• 移动构造函数和移动赋值运算符：用于避免不必要的拷贝操作，提高性能。例如，std::vector 在移动时会直接转移资源的所有权，而不是进行拷贝。

#include <iostream>
#include <vector>class MyClass {
private:std::vector<int> data;
public:MyClass() = default;MyClass(const MyClass& other) : data(other.data) {std::cout << "Copy constructor" << std::endl;}MyClass(MyClass&& other) noexcept : data(std::move(other.data)) {std::cout << "Move constructor" << std::endl;}MyClass& operator=(const MyClass& other) {data = other.data;std::cout << "Copy assignment" << std::endl;return *this;}MyClass& operator=(MyClass&& other) noexcept {data = std::move(other.data);std::cout << "Move assignment" << std::endl;return *this;}
};int main() {MyClass a;MyClass b = std::move(a);return 0;
}

六、现代 C++ 特性

1. C++11/14/17/20 新特性

• lambda 表达式：一种匿名函数，可以方便地定义和使用函数对象。

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> v = {1, 2, 3};std::for_each(v.begin(), v.end(), [](int x) {std::cout << x << " ";});std::cout << std::endl;return 0;
}

• 范围 for 循环：一种简化的循环语法，用于遍历容器中的元素。

#include <iostream>
#include <vector>int main() {std::vector<int> v = {1, 2, 3};for (int i : v) {std::cout << i << " ";}std::cout << std::endl;return 0;
}

• constexpr：用于在编译时计算表达式的值，提高性能。

#include <iostream>constexpr int square(int x) {return x * x;
}int main() {constexpr int result = square(5);std::cout << result << std::endl;return 0;
}

2. 多线程编程

• thread/async
  • std::thread：用于创建和管理线程。

#include <iostream>
#include <thread>void hello() {std::cout << "Hello from thread" << std::endl;
}int main() {std::thread t(hello);t.join();return 0;
}

• std::async：用于异步执行任务，返回一个 std::future 对象，可以用于获取任务的结果。

#include <iostream>
#include <future>int add(int a, int b) {return a + b;
}int main() {std::future<int> result = std::async(add, 1, 2);std::cout << result.get() << std::endl;return 0;
}

• 互斥锁 / 条件变量
  • std:mutex：用于保护共享资源，防止多个线程同时访问。
  • std::condition_variable：用于线程间的同步，一个线程可以等待某个条件满足，另一个线程可以通知条件已满足。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool ready = false;void worker() {std::unique_lock<std::mutex> lock(mtx);cv.wait(lock, []{ return ready; });std::cout << "Worker thread is running" << std::endl;
}int main() {std::thread t(worker);{std::lock_guard<std::mutex> lock(mtx);ready = true;}cv.notify_one();t.join();return 0;
}

七、项目实践

1. 代码规范（Google C++ Style）

• 遵循统一的代码规范可以提高代码的可读性和可维护性。Google C++ Style 是一种广泛使用的代码规范，包括命名约定、代码格式、注释风格等方面的规定。

2. 单元测试（Google Test）

• Google Test 是一个开源的 C++ 单元测试框架，可以帮助你编写和运行单元测试。

#include <gtest/gtest.h>int add(int a, int b) {return a + b;
}TEST(AddTest, PositiveNumbers) {EXPECT_EQ(add(1, 2), 3);
}int main(int argc, char** argv) {::testing::InitGoogleTest(&argc, argv);return RUN_ALL_TESTS();
}

3. 调试技巧（gdb/IDE 调试器）

• gdb：一个强大的命令行调试工具，可以用于设置断点