C++进阶学习

模板编程

模板函数和模板类的基本概念和用法

模板编程是C++中一种强大的特性，它允许程序员编写与类型无关的代码。这意味着你可以编写一个函数或类，让它能够处理任何数据类型。这不仅可以提高代码的重用性，还可以提高编程效率和程序的可维护性。

模板函数

模板函数是一种函数，其操作不仅适用于一种数据类型，而是可以适用于多种数据类型。你可以定义一个模板，然后在需要的时候对其进行具体化，以适应特定的数据类型。

基本语法：

template <typename T>
T functionName(T parameter1, T parameter2) {
    // 函数体
}

• template <typename T> 告诉编译器以下是一个模板，T 是一个占位符类型，你可以在函数体中像使用实际的数据类型一样使用它。
• T functionName(T parameter1, T parameter2) 定义了一个函数，其参数和返回类型由 T 指定。

示例：

#include <iostream>

template <typename T>
T max(T x, T y) {
    return (x > y) ? x : y;
}

int main() {
    std::cout << max(10, 5) << std::endl; // 输出: 10
    std::cout << max(2.3, 3.2) << std::endl; // 输出: 3.2
    std::cout << max('a', 'b') << std::endl; // 输出: b
    return 0;
}

模板类

模板类与模板函数类似，允许你定义一个可以适用于任何类型的类。模板类非常适用于容器类，如列表、队列、栈等，因为它们的实现对于存储的元素类型几乎没有要求。

基本语法：

template <typename T>
class ClassName {
public:
    T memberFunction(T parameter);
    // 类成员
};

• template <typename T> 同样声明这是一个模板。
• T memberFunction(T parameter) 是一个成员函数，其参数和返回类型由 T 定义。

示例：

#include <iostream>

template <typename T>
class Box {
private:
    T content;
public:
    void setContent(T newContent) {
        content = newContent;
    }
    
    T getContent() {
        return content;
    }
};

int main() {
    Box<int> intBox;
    intBox.setContent(123);
    std::cout << intBox.getContent() << std::endl; // 输出: 123
    
    Box<std::string> stringBox;
    stringBox.setContent("Hello, Templates!");
    std::cout << stringBox.getContent() << std::endl; // 输出: Hello, Templates!
    return 0;
}

模板的高级用法

除了基本用法外，模板编程还有很多高级特性，如模板特化、模板的偏特化、可变参数模板等。这些高级特性使得模板编程更加强大，但同时也增加了学习的复杂度。掌握了模板的基础之后，你可以逐步深入学习这些高级话题，以充分利用C++模板编程的强大能力。

模板特化和偏特化

模板特化和偏特化是C++模板编程中的两个高级概念，它们提供了针对特定类型或类型组合进行优化或特殊处理的能力。这两个概念有助于提高程序的灵活性和效率，特别是在处理一些特定类型时需要不同于通用模板的逻辑。

模板特化

模板特化是指为模板定义一个特殊版本，这个版本仅适用于特定的数据类型或数据类型组合。当编译器遇到与特化匹配的模板使用时，它将使用特化版本而不是通用模板。

模板特化分为两类：函数模板特化和类模板特化。

函数模板特化

函数模板特化允许你为特定类型提供一个特殊的函数实现。

示例：

template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}

// 特化版本
template <>
void print<char>(char value) {
    std::cout << "Char: " << value << std::endl;
}

在这个例子中，当你使用print函数打印一个char类型的值时，编译器会选择特化版本，从而输出一个不同的格式。

类模板特化

类模板特化让你为特定类型提供一个特殊的类定义。

示例：

template <typename T>
class Box {
public:
    void display() {
        std::cout << "Generic Box" << std::endl;
    }
};

// 类模板特化
template <>
class Box<int> {
public:
    void display() {
        std::cout << "Int Box" << std::endl;
    }
};

在这个例子中，当你使用Box<int>时，编译器会使用特化的类定义，从而输出一个特定的消息。

模板偏特化

模板偏特化是介于通用模板和完全特化之间的一种形式，它允许你为模板的一个子集提供特殊实现。偏特化可以应用于类模板，但不能直接应用于函数模板（函数模板可以通过重载实现类似效果）。

模板偏特化通常用于处理特定类型的组合或特定的模板参数特性，比如指针类型、一定长度的数组等。

示例：

template <typename T, typename U>
class Map {
public:
    void insert(T key, U value) {
        // 通用实现
    }
};

// 模板偏特化：当键和值类型相同时
template <typename T>
class Map<T, T> {
public:
    void insert(T key, T value) {
        // 特殊实现
    }
};

// 模板偏特化：处理指针类型
template <typename T>
class Map<T*, T*> {
public:
    void insert(T* key, T* value) {
        // 特殊实现，针对指针
    }
};

通过这些特化和偏特化的应用，你可以针对特定类型或条件提供最优或特殊的实现，这在开发通用库和组件时非常有用，可以极大提高代码的可重用性和效率。

现代 C++ 特性

C++11、C++14、C++17 甚至 C++20 的新特性

C++的现代化进程自C++11开始加速，随后C++14、C++17和C++20等版本陆续引入了许多新特性，极大地提高了编程效率和代码的可读性、安全性。下面，我会概述一些关键的现代C++特性，这些特性涵盖了从C++11到C++20的多个版本。

C++11

自动类型推断（auto）

C++11引入了auto关键字，可以自动推断变量的类型，简化了代码的编写。

auto x = 5; // x 被推断为 int
auto y = 1.5; // y 被推断为 double

基于范围的for循环

允许直接在容器上迭代，无需手动操作迭代器或计数变量。

std::vector<int> v = {1, 2, 3, 4, 5};
for(auto i : v) {
    std::cout << i << std::endl;
}

智能指针（Smart Pointers）

管理动态分配的内存，避免内存泄露。主要包括std::unique_ptr、std::shared_ptr和std::weak_ptr。

std::unique_ptr<int> ptr(new int(10));
std::shared_ptr<int> ptr2 = std::make_shared<int>(20);

Lambda表达式

提供了一种定义匿名函数对象的方式，便于在算法中直接定义函数逻辑。

auto sum = [](int a, int b) { return a + b; };
std::cout << sum(5, 3); // 输出: 8

C++14

泛型Lambda

C++14允许Lambda表达式使用auto类型的参数，使得Lambda表达式可以更加通用。

auto lambda = [](auto x, auto y) { return x + y; };

返回类型推断

C++14扩展了函数返回类型的自动推断能力，使得函数可以根据return语句自动推断返回类型。

auto add(int a, int b) {
    return a + b;
}

C++17

结构化绑定（Structured Bindings）

允许从数组或tuple中直接解包值到变量中。

std::pair<int, double> p = {2, 2.5};
auto [i, d] = p; // i = 2, d = 2.5

内联变量（Inline Variables）

对于头文件中定义的全局变量，可以使用inline避免多重定义的问题。

inline int myVar = 42;

std::optional

提供了一种表达可选值（可能没有值）的方式。

std::optional<int> getResult() {
    return {}; // 没有值
    // return 1; // 有值
}

C++20

概念（Concepts）

概念是对模板参数的约束，用于指定模板参数必须满足的接口和语义要求。

template<typename T>
requires std::integral<T>
T add(T a, T b) {
    return a + b;
}

范围视图（Ranges）

引入了范围库，提供了更加简洁的方式来操作和组合容器和范围。

#include <ranges>
std::vector<int> v = {0, 1, 2, 3, 4, 5};
auto even = v | std::views::filter([](int i){ return i % 2 == 0; });
for(int i : even) std::cout << i << " "; // 输出: 0 2 4

这些特性只是现代C++中的一小部分，但它们是提高编程效率、编写安全和可维护代码的重要工具。随着你深入学习，你会发现更多强大的特性和技巧。

C++ 并发编程

理解并发和多线程的基本概念

在现代计算机系统中，尤其是在多核处理器变得普遍的情况下，利用并发（Concurrency）和多线程（Multithreading）能够显著提高程序的性能和响应速度。理解并发和多线程的基本概念是进行有效的并行程序设计的基础。下面对这些概念进行详细讲解。

并发（Concurrency）

并发是指两个或多个事件在同一时间段内发生。在单核处理器系统中，由于处理器在任何时刻只能执行一个任务，因此并发通常通过时间分片来实现，即操作系统轮流给每个任务分配处理器时间，从宏观上看似乎是同时执行的。在多核处理器系统中，不同的任务可以被分配到不同的处理器上，从而实现真正的同时执行。

并发不仅仅是关于同时执行多个任务，它更关注任务的分解、任务间的协作和管理，以及资源的共享。

多线程（Multithreading）

多线程是并发的一种实现方式，它允许单个程序创建多个并行执行的线程。每个线程可以看作是程序执行流的一个分支，拥有自己的执行上下文（如程序计数器、寄存器集和栈），但是与同一进程内的其他线程共享进程级别的资源（如代码、数据和文件等）。

多线程的优点包括提高程序的响应性（特别是在需要等待的操作中），更有效地利用多核处理器资源，以及简化复杂但相关任务的管理。

基本概念

• 线程安全（Thread Safety）：如果一个函数或对象在多线程环境中被多个线程同时使用时能够保持正确的行为，则该函数或对象是线程安全的。实现线程安全可能需要使用互斥锁（mutexes）、信号量（semaphores）等同步机制。

• 死锁（Deadlock）：当两个或多个线程相互等待对方释放资源而无法继续执行时，就发生了死锁。避免死锁需要仔细设计线程间的交互和资源分配策略。

• 竞态条件（Race Condition）：当多个线程访问共享资源并试图同时修改它时，程序的输出可能依赖于线程执行的顺序，这种情况被称为竞态条件。避免竞态条件通常需要通过同步机制来确保对共享资源的访问在任意时刻最多只有一个线程。

C++ 中的并发支持

C++11 标准引入了多线程支持库，提供了线程管理、同步原语（如互斥锁、条件变量等）、以及线程本地存储等功能。这些功能定义在 <thread>、<mutex>、<atomic>、<future> 等头文件中。

• 创建线程：使用 std::thread 类创建新线程。

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Hello, World from thread!" << std::endl;
}

int main() {
    std::thread t(threadFunction); // 创建线程，执行 threadFunction
    t.join(); // 等待线程结束
    return 0;
}

总结

并发和多线程是现代软件开发中不可或缺的部分，它们使得程序能够更高效地执行，更好地利用系统资源，并提高用户体验。C++ 通过标准库提供了丰富的多线程编程支持，使得实现并发程序变得更加简单和安全。然而，并发编程也引入了新的复杂性和潜在的错误源，如线程安全问题、死锁和竞态条件，因此开发者需要仔细设计和测试并发程序。

使用 C++ 的线程库（如 std::thread）

C++11 标准引入了对多线程编程的直接支持，其中 std::thread 是标准线程库的核心，提供了一种表示和管理单个线程的方式。使用 std::thread，你可以创建并行执行的任务，这对于提高应用程序的性能和响应性非常有用。下面是关于如何使用 std::thread 的基本介绍。

创建和启动线程

创建一个 std::thread 对象时，你需要提供一个函数（或函数对象、Lambda 表达式等），该函数将在新线程中执行。线程开始执行的同时，控制立即返回到创建线程的代码中，这意味着创建线程的操作是非阻塞的。

#include <iostream>
#include <thread>

void helloFunction() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(helloFunction); // 创建并启动线程
    t.join(); // 等待线程完成
    return 0;
}

在这个例子中，helloFunction 会在由 std::thread t 创建的新线程中执行。

等待线程完成

创建线程后，原始线程（通常是主线程）可以通过调用 join() 方法来等待新线程完成执行。join() 会阻塞调用它的线程，直到与之关联的线程结束其执行。

传递参数给线程函数

如果你想向线程函数传递参数，可以将这些参数直接放在 std::thread 构造函数中函数名之后。参数会被安全地传递给新线程中的函数。

#include <iostream>
#include <thread>
#include <string>

void printMessage(const std::string &message) {
    std::cout << message << std::endl;
}

int main() {
    std::string message = "Hello from another thread!";
    std::thread t(printMessage, message);
    t.join();
    return 0;
}

Lambda 表达式和线程

你也可以直接在 std::thread 构造函数中使用 Lambda 表达式来定义线程执行的代码。

#include <iostream>
#include <thread>

int main() {
    std::thread t([](){
        std::cout << "Hello from thread using Lambda!" << std::endl;
    });
    t.join();
    return 0;
}

分离线程

除了 join()，还有 detach() 方法，它允许线程在后台运行，即允许线程独立于主线程继续执行。一旦线程被分离，就不能再与之进行同步（即不能再使用 join() 等待它）。

std::thread t(doSomeWork);
t.detach();

注意，分离线程需要谨慎使用，因为分离的线程在主线程结束后仍可能运行，如果主线程结束时分离线程还在访问已经被销毁的资源，则可能导致未定义行为。

总结

std::thread 提供了一种强大且相对简单的方式来创建和管理线程，使得并行编程在 C++ 中变得更加容易。理解并正确使用 std::thread 的各种功能对于编写高效、健壯的多线程 C++ 应用程序至关重要。同时，开发者需要注意线程同步和数据竞争等并发编程中的常见问题。