C++ on 奕晨's blog

打开模板元编程的大门

Thu, 10 Apr 2025 00:00:00 +0000

引言

今天看了Cpp con 2014 - Walter E. Brown博士讲的有关模板元编程的讲座，感觉打开了新世界的大门，以前虽然也看了些和模板有关的代码，但一直没有系统的了解过，而今天看完讲座，感觉串通了很多东西，也开始了解模板元编程。所以写者想在这里记录一些讲座上的代码，以及自己的一些思考。

模板元编程(TMP)

普通的编程操作的对象都是数据，而在模板元编程当中，我们可以对类型进行操作。就拿普通函数和元函数进行比较，元函数不在是一个普通函数的形式，通常是一个模板类。普通函数的参数对应了元函数的函数模板，操作的对象也由数据变成了类型。普通函数的返回值与元函数中通常定义公开的type类型和value值形成了对应。

模板也可以递归

以前一直以为，递归只能再函数中实现，没想到也能在模板中进行递归。不过再一想，这里用到都是元函数，那么可以用递归也合理了很多。下面两个例子展现了两种递归的实现。

namespace yc {
     // 计算gcd
    // 在主模板中调用了递归，特化作为递归出口
    template <unsigned M, unsigned N>
    struct gcd {
        static constexpr int value = gcd<N,M%N>::value;
    };

    template<unsigned M>
    struct gcd<M,0> {
        static_assert(M != 0);
        static constexpr int value = M;
    };

    // rank, rank的主要作用是返回数组的维度，rank<int[10][20][30]>::value 的值是3
    // 在特化中调用了递归，主模板作为递归出口
    template<typename T>
    struct rank { static constexpr size_t value = 0u;};

    template<typename U, size_t N>
    struct rank<U[N]> {
        static size_t const value = 1u + rank<U>::value;
    };

}

::type

模板元编程的操作对象是类型，下面就来看看对类型的操作吧。

namespace yc{
    // remove_const
    template<typename T>
    struct remove_const {using type = T;};

    template<typename T>
    struct remove_const<T const> {using type = T;};	// 特化去除类型的const属性，下面去除volatile也是如此

    // 一些元函数可以继承type_is, 保证元函数的一些规范，一定会有名为type的类型
    template<typename T>
    struct type_is { using type = T;};

    template<typename T>
    struct remove_volatile : type_is<T> {};

    template<typename U>
    struct remove_volatile<U volatile> : type_is<U> {};

    // IF编译器决定调用哪一个,因为是模板，所以T和F可以是任意类型，包括函数，类。
    // 可以通过这种方式，让编译器选择将要执行的函数类型，以及将要继承的基类。
    template<bool, typename T, typename>
    struct IF : type_is<T> {};

    template<typename T, typename F>
    struct IF<false,T,F> : type_is<F> {};
}

SFINAE

模板实例化需要经过替换的过程，在替换的过程中，如果失败，并不是错误，而是会放弃这次替换。

namespace yc{	
	// enable_if， SFINAE的实用工具
    template<bool, typename T = void>
    struct enable_if : type_is<T> {};

    template<typename T>
    struct enable_if<false,T> {};   // 当传入为false的时候，不给::type，用来后面enable_if_t发生SFINAE

    template<bool b, typename T>
    using enable_if_t = typename enable_if<b, T>::type;	// 通常后缀_t 表示 ::type

    //SFINAE
    // 当条件是false的时候，enable_if_t会发生错误，因为enable_if没有type类型，发生SFINAE
    template<typename T>
    enable_if_t<is_integral_v<T>, size_t> f(T val) { return val; }

    template<typename T>
    enable_if_t<is_floating_point_v<T>, long double> f(T val) { return val; };
}

::value

namespace yc{
	// ::value
    template<typename T, T v>
    struct integral_constant {	// 这里T类型位置，考虑换一个名字
        static constexpr T value = v;
        
        // 允许将integral_constant 转为T类型 或者调用获得类型T
        constexpr explicit operator T() const noexcept { return value; }    
        constexpr T operator()() const noexcept { return value; }
    };

    // 重构rank
    template<typename T>
    struct rank2 : integral_constant<size_t, 0u> {};

    template<typename U, size_t N>
    struct rank2<U[N]> : integral_constant<size_t, 1u + rank2<U>::value> {};

	// 之前的rank没有考虑过的情况
    template<typename U>
    struct rank2<U[]> : integral_constant<size_t, 1u + rank2<U>::value> {};

    // 一些模板aliases
    template<bool b>
    using bool_constant = integral_constant<bool, b>;
    using true_type = bool_constant<true>;
    using false_type = bool_constant<false>;
}

decltype和declval

namespace yc {
    // decltype 和 declval
    // declval 假装给了这个类型的一个值。
    // 下面假装是一个函数调用，但是是编译期并不会实际执行函数调用，只是为了找到这个函数来获取返回值类型。
    template<typename T>
    decltype(foo(declval<T>())) t;
    // declval<T&>() 给的是一个右值

    // is_copy_assignable
    template<class T>
    struct is_copy_assignable {
    private:
        template<typename U, typename = decltype(declval<U&>() = declval<U const&>())>
        static true_type try_assignment(U&&);	// 可能会触发SFINAE

        static false_type try_assignment(...);

    public:
        using type = decltype(try_assignment(declval<T>()));
    };
}

void_t

namespace yc{
    // void_t
    template<typename...>
    using void_t = void;

    // 查看元函数是否有type成员
    // 为什么typename=void 必须是void, 改成int会发生什么？
  	// 改成int,编译器先看主模板，实例化为has_type_member<SomeType, int>，再尝试匹配偏特化会失败。
    // 特化类型必须精确匹配，才能走特化版本，否则不会
    // 如果想要改成int,上面的也要改成void_t = int
    template<typename, typename = void>     // 这里的void一定要和void_t里的类型相匹配，选择void是一种实现方式
    struct has_type_member : false_type {}; // 类型匹配优先走偏特化，即使这两个看起来一样

    template<typename T>
    struct has_type_member<T,void_t<typename T::type>> : true_type{};

    // is_copy_assignable优化
    template<typename T>
    using copy_assignable_t = decltype(declval<T&>() = declval<T const&>());
    // T const& -> T&& 就可以实现能否进行移动的判断

    template<typename T, typename = void>
    struct is_copy_assignable2 : false_type {};

    template<typename T>
    struct is_copy_assignable2<T, void_t<copy_assignable_t<T>>> : is_same<copy_assignable_t<T>,T&>{};
    // 拷贝后的类型应当是T&, 所以需要和T&比较是否类型相等
}

线程屏障

Wed, 19 Mar 2025 00:00:00 +0000

引言

线程屏障（Thread Barrier）是一种同步机制，用于让一组线程在某个点上等待，直到所有线程都到达该点后再继续执行。屏障通常用于多线程编程中，确保所有线程在某个阶段完成后再进入下一个阶段。

std::latch

在了解barrier之间，让我们先来看一看std::latch吧。

构造函数explicit latch(std::ptrdiff_t expected); 传入一个参数，指定计数器初始的值
成员函数 count_down(std::ptrdiff_t n = 1); 每次执行让计数器减去n，默认为1
成员函数 wait(); 等待计数器减为0
成员函数 try_wait(); 非阻塞检查计数器是否减为0，为0则返回true，极少数情况下也会返回false
- 在多线程环境中，如果多个线程同时操作 latch 的计数器，可能会出现竞争条件。例如：
  - 线程 A 调用 count_down() 将计数器减到 0。
  - 线程 B 在计数器减到 0 的瞬间调用 try_wait()，但由于线程调度或内存可见性问题，线程 B 看到的计数器值可能仍然不为 0。
  这种情况下，try_wait 可能会返回 false，即使计数器实际上已经减到 0。
代码示例

#include <iostream>
#include <latch>
#include <thread>
#include <vector>
#include <chrono>
#include <random>

void func(std::latch& latch) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 10);
    std::this_thread::sleep_for(std::chrono::seconds(dis(gen)));
    std::cout << " finish work " << std::endl;
    latch.count_down();
}

int main() {
    std::latch latch(3);

    std::vector<std::thread> threads;
    for (int i = 0; i < 3; i++) {
        threads.emplace_back(func, std::ref(latch));
    }

    latch.wait();		// 会等待latch减为0，才会继续运行下去
    std::cout << "all work is done" << std::endl;
    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

std::barrier

std::barrier 是 C++20 中引入的一个同步原语，用于让一组线程在某个点上等待，直到所有线程都到达该点后再继续执行。与 std::latch 不同，std::barrier 是 可重用的，适用于多阶段任务的同步。

类别	函数签名	描述
构造函数	`explicit barrier(std::ptrdiff_t count);`	构造一个 `barrier`，指定需要等待的线程数 `count`。
	`template<class CompletionFunction>` `barrier(std::ptrdiff_t count, CompletionFunction&& completion);`	构造一个 `barrier`，指定线程数 `count` 和完成回调函数 `completion`。
成员函数	`arrival_token arrive( std::ptrdiff_t n = 1 );`	通知 `barrier` 当前线程已到达，`update` 指定减少的计数（默认 1）。
	`void wait( arrival_token&& arrival ) const;`	等待计数器减为0
	`void arrive_and_wait();`	通知 `barrier` 当前线程已到达，并阻塞直到所有线程到达。
	`void arrive_and_drop();`	通知 `barrier` 当前线程已到达，并减少 `barrier` 的计数（线程退出）。

代码案例

#include <iostream>
#include <thread>
#include <vector>
#include <barrier>
#include <latch>

#include <chrono>
#include <random>

void func(std::barrier<> & barrier) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 10);
    std::this_thread::sleep_for(std::chrono::seconds(dis(gen)));
    std::cout << " start work" << std::endl;
    barrier.arrive_and_wait();

    std::this_thread::sleep_for(std::chrono::seconds(dis(gen)));
    std::cout << " end work" << std::endl;
    barrier.arrive_and_wait();
}

int main() {
    std::barrier<> barrier(4);
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; i++) {
        threads.emplace_back(func, std::ref(barrier));
    }
    barrier.arrive_and_wait();
    std::cout << "all people ready" << std::endl;


    barrier.wait(barrier.arrive());		// 相当于arrive_and_wait()
    std::cout << "all work is done" << std::endl;
    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

奇异模板

Mon, 10 Mar 2025 00:00:00 +0000

引言

奇异递归模板模式（Curiously Recurring Template Pattern，简称 CRTP），也被称为奇异模板，是 C++ 中的一种模板编程技术。它允许基类使用派生类的类型信息，实现了一种编译时多态。

奇异递归模板模式

奇异递归模板是一种利用模板技术实现的编译时多态，允许一个类在调用函数的时候实现不同的方法。

实现方法：

基类使用模板类，模板参数代表了派生类类型
函数里将基类指针(this)转为派生类指针并调用派生类的实现方法，达到对于传入的不同派生类实现不同的方法。
派生类要继承基类，并将自己的类型传入到模板参数当中

代码实现

// 基类模板
template <typename Derived>
class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;		//进行复用，不用每个类型都写一份
        static_cast<Derived*>(this)->drawImpl();
    }
};

// 派生类：Circle
class Circle : public Shape<Circle> {
public:
    void drawImpl() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// 派生类：Square
class Square : public Shape<Square> {
public:
    void drawImpl() {
        std::cout << "Drawing a square." << std::endl;
    }
};

int main() {
    Circle circle;
    Square square;

    circle.draw();
    square.draw();
}

奇异模板特性

特点

动态多态实现

class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;
        drawImp();
    }
    virtual void drawImp() = 0;
};

class Circle : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a square." << std::endl;
    }
};

int main() {
    Shape* circle = new Circle;
    Shape* square = new Square;

    circle->draw();
    square->draw();
}

奇异模板相较于动态多态，它在编译时确定，避免了运行时虚函数表的查询。
不需要虚函数表，内存占用较小

通过函数调用实现多态

template <typename Derived>
class Shape {
public:
    void draw() {
        std::cout << "shared draw" << std::endl;
        static_cast<Derived*>(this)->drawImpl();
    }
};

// 派生类：Circle
class Circle : public Shape<Circle> {
public:
    void drawImpl() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// 派生类：Square
class Square : public Shape<Square> {
public:
    void drawImpl() {
        std::cout << "Drawing a square." << std::endl;
    }
};

template<typename Shape>
void Draw(Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    Draw(circle);
    Draw(square);
}

其对应的动态多态形式

class Shape {
public:
    void draw() {
        std::cout << "所有类型draw的公用代码" << std::endl;
        drawImp();
    }
    virtual void drawImp() = 0;
};

class Circle : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void drawImp() {
        std::cout << "Drawing a square." << std::endl;
    }
};

void Draw(Shape* shape) {
    shape->draw();
}

int main() {
    Shape* circle = new Circle;
    Shape* square = new Square;

    Draw(circle);
    Draw(square);
}

SFINAE

Wed, 26 Feb 2025 00:00:00 +0000

引言

最近在实现vector的时候，遇到了一个问题：

1
2

template<typename InputIt>
T* insert(const T* pos, InputIt first, InputIt last)

对于上面一个模板函数，如果按照上面那种写法，当调用v.insert(pos,1,2)；的时候，可能也会走进上面那个函数并将InputIt推导为int类型，而实际情况是想要往pos位置上插入1个2。这就会导致编译器不知道调用哪个函数。那么应当如何解决这一个问题呢？下面就要介绍这篇文章的主人公了。

SFINAE

SFINAE（Substitution Failure Is Not An Error，替换失败不是错误）是 C++ 模板元编程中的一个重要规则。它的核心思想是：在模板实例化过程中，如果某个模板参数替换失败（例如，类型不匹配或表达式不合法），编译器不会报错，而是会忽略这个模板特化，继续尝试其他可能的模板特化或重载。

SFINAE 的核心思想

替换（Substitution）：
- 在模板实例化时，编译器会用实际的类型或值替换模板参数。
- 例如，对于 template<typename T> void foo(T t)，如果调用 foo(42)，编译器会用 int 替换 T。
替换失败（Substitution Failure）：
- 如果在替换过程中，某个表达式或类型不合法（例如，类型没有某个成员函数，或操作符不支持），替换就会失败。
不是错误（Not An Error）：
- 如果替换失败，编译器不会报错，而是会忽略这个模板特化，继续尝试其他可能的模板特化或重载。

SFINAE常用工具

std::enable_if

template<bool B, typename T = void>
struct enable_if {};

template<typename T>
struct enable_if<true, T> {
    using type = T;
};

如果条件 B 为 true，std::enable_if<B, T> 会定义嵌套类型 type，其值为 T。
如果条件 B 为 false，std::enable_if<B, T> 不会定义嵌套类型 type，从而导致替换失败（SFINAE）。

例如:

template<typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
void foo(T t) {
    // 只有 T 是整数类型时，这个函数才会启用
}

std::void_t

std::void_t 的核心思想是利用模板的替换规则：

如果传递给 std::void_t 的类型或表达式是合法的，那么 std::void_t 会生成 void 类型。
如果传递给 std::void_t 的类型或表达式是非法的（例如，某个类型不存在或某个操作不支持），那么模板替换会失败，触发 SFINAE，编译器会忽略这个模板特化，而不会报错。

std::declval

std::declval 的定义如下：

1
2

template<typename T>
std::add_rvalue_reference_t<T> declval() noexcept;

std::add_rvalue_reference_t<T> 是类型特征（type trait），用于将类型 T 转换为右值引用 T&&。
noexcept 表示该函数不会抛出异常。

std::declval 的主要作用是在编译时生成一个类型的右值引用，而不需要实际构造该类型的对象。这在以下场景中非常有用：

类型推导：在模板元编程中，推导某个表达式的类型。
SFINAE：检查某个类型是否支持特定操作（例如成员函数、操作符等）。
编译时表达式检查：在不实际构造对象的情况下，检查某个表达式是否合法。

例子：

template<typename T, typename = void>
struct has_foo : std::false_type {};

template<typename T>		//使用declval检查T类型能否调用foo()
struct has_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};

struct Bar {
    void foo() {}
};

struct Baz {};

static_assert(has_foo<Bar>::value, "Bar should have foo()");
static_assert(!has_foo<Baz>::value, "Baz should not have foo()");

最终实现insert

template< class InputIt, typename = std::void_t<
        decltype(*std::declval<InputIt>()),
        decltype(++std::declval<InputIt&>())
    >>
    T* insert(const T* pos, InputIt first, InputIt last)

通过SFINAE，只有支持*和++操作的InputIt才会走进这个函数，从而解决最初的那个问题。

类型萃取

Tue, 18 Feb 2025 00:00:00 +0000

引言

在C++中，类型萃取（Type Traits）是一种在编译时获取和操作类型信息的机制。它通过模板元编程技术实现，允许开发者根据类型的特性进行条件编译或执行不同的代码路径。类型萃取类通常定义在<type_traits>头文件中。

常见类型萃取类

`std::is_*` 系列

这些类型萃取类用于检查类型是否符合某种条件。

std::is_integral<T>：检查类型 T 是否为整数类型。
std::is_floating_point<T>：检查类型 T 是否为浮点类型。
std::is_pointer<T>：检查类型 T 是否为指针类型。
std::is_reference<T>：检查类型 T 是否为引用类型。
std::is_array<T>：检查类型 T 是否为数组类型。
std::is_function<T>：检查类型 T 是否为函数类型。
std::is_const<T>：检查类型 T 是否为常量类型。
std::is_volatile<T>：检查类型 T 是否为易失类型。
std::is_class<T>：检查类型 T 是否为类类型。
std::is_union<T>：检查类型 T 是否为联合体类型。

`std::is_*_v` 系列（C++17引入）

这些是 std::is_* 系列的变量模板版本，简化了使用方式。

std::is_integral_v<T>：如果 T 是整数类型，返回 true，否则返回 false。
std::is_floating_point_v<T>：如果 T 是浮点类型，返回 true，否则返回 false。

`std::is_same<T, U>`

std::is_same<T, U>：检查类型 T 和 U 是否相同。
std::is_same_v<T, U>：这是 std::is_same<T, U> 的变量模板版本。

`std::remove_*` 系列

这些类型萃取类用于修改类型（如去除常量、指针等）。

std::remove_const<T>：去除类型 T 的常量修饰符。
std::remove_volatile<T>：去除类型 T 的易失修饰符。
std::remove_cv<T>：去除类型 T 的常量和易失修饰符。
std::remove_reference<T>：去除类型 T 的引用。
std::remove_pointer<T>：去除类型 T 的指针。
std::remove_extent<T>：去除类型 T 的数组维度。

`std::is_base_of<Base, Derived>` 和 `std::is_convertible<From, To>`

std::is_base_of<Base, Derived>：检查 Derived 是否是 Base 的派生类。
std::is_convertible<From, To>：检查类型 From 是否能转换为类型 To。

`std::enable_if<T, U>` 和 `std::disable_if<T, U>`

std::enable_if<T, U>：当 T 为真时，启用类型 U。
std::disable_if<T, U>：当 T 为真时，禁用类型 U。

`std::is_trivially_*` 系列（C++11引入）

这些类型萃取类用于检查类型是否具有某些简单的特性，如无构造函数、无拷贝构造函数等。

std::is_trivially_copyable<T>：检查类型 T 是否是一个 trivially copyable 类型（可以直接内存拷贝的类型）。
std::is_trivially_constructible<T>：检查类型 T 是否可以通过简单的构造函数构造。
std::is_trivially_destructible<T>：检查类型 T 是否有简单的析构函数。

`std::conditional<T, U, V>`（C++11引入）

这个类型萃取类根据条件 T 选择类型 U 或 V。

std::conditional<T, U, V>：如果 T 为真，则类型为 U，否则为 V。

is_integral<T>的实现

使用模板特化实现简单的类型萃取

template<typename T>
class my_is_integral {
public:
    static constexpr bool value = false;
};

//特化版本
template<> class my_is_integral<int> : public std::true_type {};

// 下面这些类型也是integral类型,后面的讨论不再全部写出来
template<> class my_is_integral<bool> : public std::true_type {};
template<> class my_is_integral<char> : public std::true_type {};
template<> class my_is_integral<signed char> : public std::true_type {};
template<> class my_is_integral<unsigned char> : public std::true_type {};
template<> class my_is_integral<short> : public std::true_type {};
template<> class my_is_integral<unsigned short> : public std::true_type {};
template<> class my_is_integral<unsigned int> : public std::true_type {};
template<> class my_is_integral<long> : public std::true_type {};
template<> class my_is_integral<unsigned long> : public std::true_type {};
template<> class my_is_integral<long long> : public std::true_type {};
template<> class my_is_integral<unsigned long long> : public std::true_type {};
template<> class my_is_integral<wchar_t> : public std::true_type {};
template<> class my_is_integral<char16_t> : public std::true_type {};
template<> class my_is_integral<char32_t> : public std::true_type {};

基于c++14的变量的模板

template<typename T>
class my_is_integral {
public:
    static constexpr bool value = false;
};

//特化版本
template<> class my_is_integral<int> : public std::true_type {};

//变量的模板，可以之间使用my_is_intergral_value<int>作为true or false
template<typename T>
constexpr bool my_is_integral_value = my_is_integral<T>::value;

解决修饰符问题

template<typename T>
class my_is_integral_helper {
public:
    static constexpr bool value = false;
};

//特化版本
template<> class my_is_integral_helper<int> : public std::true_type {};


//使用helper类
//my_is_integral继承了helper类并且使用remove_cv_t消除了cv限定符
template<typename T>
class my_is_integral : public my_is_integral_helper<std::remove_cv_t<T>> {};

template<typename T>
constexpr bool my_is_integral_value = my_is_integral<T>::value;

这样，就基本实现了自己的is_integral类了

reactor模型

Tue, 28 Jan 2025 00:00:00 +0000

引言

reactor模型是一种事件驱动的设计模式，广泛应用于并发编程中，特别是在网络编程和高性能服务器设计中。它的基本思想是通过集中式的事件分发机制来处理输入/输出事件和相关的操作。

前置知识：线程池

reactor实现简要介绍

本案例实现的reactor模型用于服务器端，可以和用户端建立多个连接，每当用户有数据发送过来时，就需要通过线程池执行对应的任务，当任务结束以后，再由主线程将数据发送回用户

两个重要的类

EventLoop类

事件循环监听机制，主要会监听三个事件
- 连接建立
- 消息到达，通常会将处理消息的任务交给线程池去处理
- 消息处理完成，将处理好的消息发送回去

TcpConnection类

该类主要记录服务器这边的所有连接，并提供接受和发送数据

三个回调函数(通常由自己去实现，可以更改实现，去完成不同的业务)

连接建立

我们可以打印连接信息

消息达到

在监听消息达到，并且用户没有断开时执行
我们去接受消息，然后将消息和连接和线程池任务绑定，将任务放到线程池的任务队列中，让线程去执行任务

连接断开

在监听消息到达时执行，当发现消息到达并且结果为0时，说明用户断开，执行回调函数。
我们可以打印连接断开信息

线程池任务处理逻辑 (通常由自己去实现，可以更改实现，去完成不同的业务)

先根据msg进行对应的任务，然后将msg2交给主函数去发送(将发送能力打包成一个可调用对象，交给主函数)

三个回调函数和线程池任务处理逻辑都在main函数所在文件夹中进行定义

源码实现

InetAddress（ip地址和端口号对象）

封装了ip和端口号

#ifndef INET_ADDRESS_H_
#define INET_ADDRESS_H_

#include <arpa/inet.h>
#include <string>

class InetAddress{
public:
    InetAddress(const std::string& ip, unsigned short port);
    InetAddress(const struct sockaddr_in& addr);
    ~InetAddress() = default;
    auto Ip() const -> std::string;
    auto Port() const -> unsigned short;
    auto GetPtr() const -> const struct sockaddr_in*;

private:
    struct sockaddr_in addr_;

};

#endif

#include "inet_address.h"

#include <strings.h>

InetAddress::InetAddress(const std::string& ip, unsigned short port) {
    ::bzero(&addr_,sizeof(struct sockaddr_in));
    addr_.sin_family = AF_INET;
    addr_.sin_port = htons(port);
    addr_.sin_addr.s_addr = inet_addr(ip.c_str());
}

InetAddress::InetAddress(const struct sockaddr_in& addr) : addr_(addr) {

}

std::string InetAddress::Ip() const {
    return std::string(inet_ntoa(addr_.sin_addr));
}

unsigned short InetAddress::Port() const {
    return ntohs(addr_.sin_port);
}

const struct sockaddr_in* InetAddress::GetPtr() const {
    return &addr_;
}

Socket对象

封装了socket文件描述符

#ifndef SOCKET_H_
#define SOCKET_H_

class Socket {
public:
    Socket();
    explicit Socket(int fd);
    ~Socket();
    auto Fd() const -> int;

    Socket(const Socket&) = delete;
    void operator=(const Socket&) = delete;

private:
    int fd_;
};

#endif

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>

#include "socket.h"

Socket::Socket() {
    fd_ = ::socket(AF_INET,SOCK_STREAM, 0);
    if (fd_ < 0) {
        perror("socket");
        return;
    }
}

Socket::Socket(int fd) : fd_(fd) {}

Socket::~Socket() {
    close(fd_);
}

int Socket::Fd() const {
    return fd_;
}

SocketIO对象 (用于发送接受数据)

封装了通过socket进行收发数据的操作

#ifndef SOCKET_IO_H_
#define SOCKET_IO_H_

class SocketIO
{
public:
    explicit SocketIO(int fd);
    ~SocketIO();
    auto Readn(char *buf, int len) -> int;
    auto ReadLine(char *buf, int len) -> int;
    auto Writen(const char *buf, int len) -> int;

private:
    int fd_;
};

#endif

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>

#include "socket_io.h"

SocketIO::SocketIO(int fd) : fd_(fd) {}

SocketIO::~SocketIO() {
    close(fd_);
}

//len = 10000    1500/6     1000/1
int SocketIO::Readn(char *buf, int len) {
    int left = len;
    char *pstr = buf;
    int ret = 0;

    while(left > 0) {
        ret = read(fd_, pstr, left);
        if(-1 == ret && errno == EINTR) {
            continue;
        } else if(-1 == ret) {
            perror("read error -1");
            return -1;
        } else if(0 == ret) {
            break;
        } else {
            pstr += ret;
            left -= ret;
        }
    }

    return len - left;
}

int SocketIO::ReadLine(char *buf, int len) {
    int left = len - 1;
    char *pstr = buf;
    int ret = 0, total = 0;

    while(left > 0) {
        //MSG_PEEK不会将缓冲区中的数据进行清空,只会进行拷贝操作
        ret = recv(fd_, pstr, left, MSG_PEEK);
        if(-1 == ret && errno == EINTR) {
            continue;
        } else if(-1 == ret) {
            perror("readLine error -1");
            return -1;
        } else if(0 == ret) {
            break;
        } else {
            for(int idx = 0; idx < ret; ++idx) {
                if(pstr[idx] == '\n') {
                    int sz = idx + 1;
                    Readn(pstr, sz);
                    pstr += sz;
                    *pstr = '\0';//C风格字符串以'\0'结尾

                    return total + sz;
                }
            }
            Readn(pstr, ret);//从内核态拷贝到用户态
            total += ret;
            pstr += ret;
            left -= ret;
        }
    }
    *pstr = '\0';

    return total - left;

}

int SocketIO::Writen(const char *buf, int len) {
    int left = len;
    const char *pstr = buf;
    int ret = 0;

    while(left > 0) {
        ret = write(fd_, pstr, left);
        if(-1 == ret && errno == EINTR) {
            continue;
        } else if(-1 == ret) {
            perror("writen error -1");
            return -1;
        } else if(0 == ret) {
            break;
        } else {
            pstr += ret;
            left -= ret;
        }
    }
    return len - left;
}

Acceptor对象(用于建立tcp连接)

封装了通过socket建立tcp连接的过程

#ifndef ACCEPTOR_H_
#define ACCEPTOR_H_

#include <string>

#include "socket.h"
#include "inet_address.h"

class Acceptor{
public:
    Acceptor(const std::string& ip, unsigned short port);
    ~Acceptor() = default;
    auto Ready() -> void;		//服务器端准备
    auto Accept() -> int;		//服务器端获得新连接
    auto Fd() -> int;

private:
    auto SetReuseAddr() -> void;
    auto SetReusePort() -> void;
    auto Bind() -> void;
    auto Listen() -> void;

private:
    Socket sock_;       //welcome socket
    InetAddress addr_;
};

#endif

#include <stdio.h>

#include "acceptor.h"

Acceptor::Acceptor(const std::string& ip, unsigned short port) :
sock_(),
addr_(ip,port) {}

void Acceptor::Ready() {
    SetReuseAddr();
    SetReusePort();
    Bind();
    Listen();
}

void Acceptor::SetReuseAddr() {
    int on = 1;
    int ret = setsockopt(sock_.Fd(), SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    if (ret) {
        perror("setsockopt");
        return;
    }
}

void Acceptor::SetReusePort() {
    int on = 1;
    int ret = setsockopt(sock_.Fd(), SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
    if (ret) {
        perror("setsockopt");
        return;
    }
}

void Acceptor::Bind() {
    int ret = ::bind(sock_.Fd(),(struct sockaddr*)addr_.GetPtr(), sizeof(struct sockaddr));
    if (-1 == ret) {
        perror("bind");
        return;
    }
}

void Acceptor::Listen() {
    int ret = ::listen(sock_.Fd(),128);
    if (-1 == ret) {
        perror("listen");
        return;
    }
}

int Acceptor::Accept() {
    int connfd = ::accept(sock_.Fd(),nullptr,nullptr);
    if (-1 == connfd) {
        perror("accept");
        return -1;
    }
    return connfd;
}

int Acceptor::Fd() {
    return sock_.Fd();
}

EventLoop类

实现了事件循环机制，通过io多路复用对各种事件进行了监听
存储了连接所有连接fd和封装的连接类，可以进行连接上的处理

#ifndef EVENT_LOOP_H_
#define EVENT_LOOP_H_

#include <vector>
#include <map>
#include <memory>
#include <functional>
#include <mutex>

class Acceptor;
class TcpConnection;

using TcpConnectionPtr = std::shared_ptr<TcpConnection>;
using TcpConnectionCallback = std::function<void(const TcpConnectionPtr &)>;

class EventLoop
{
    using TcpConnectionPtr = std::shared_ptr<TcpConnection>;
    using Functor = std::function<void()>;
public:
    EventLoop(Acceptor &acceptor);
    ~EventLoop();

    //循环与否
    auto Loop() -> void;
    auto Unloop() -> void;

private:
    //封装类epoll_wait函数
    auto WaitEpollFd() -> void;

    //处理新的连接
    auto HandleNewConnection() -> void;

    //处理老的连接上的消息
    auto HandleMessage(int fd) -> void;

    //epfd的创建
    auto CreateEpollFd() -> int;

    //监听文件描述符
    auto AddEpollReadFd(int fd) -> void;

    //取消文件描述符的监听
    auto DelEpollReadFd(int fd) -> void;

public:
    auto SetNewConnectionCallback(TcpConnectionCallback&& cb) -> void;
    auto SetMessageCallback(TcpConnectionCallback&& cb) -> void;
    auto SetCloseCallback(TcpConnectionCallback&& cb) -> void;

private:
    auto HandleRead() -> void;
    auto DoPendingFunctors() -> void;
    auto CreateEventFd() -> int;
    
public:
    auto Wakeup() -> void;
    auto RunInLoop(std::function<void()>&& f) -> void;

private:
    int epfd_;//epoll_create创建的文件描述符
    std::vector<struct epoll_event> evtList_;//存放满足条件的文件描述符的数据结构
    bool isLooping_;//标识循环是否在运行的标志
    Acceptor& acceptor_;//因为需要调用其中的accept函数
    std::map<int, TcpConnectionPtr> conns_;//存放的是文件描述符与连接的键值对

    TcpConnectionCallback onNewConnectionCb_;//连接建立
    TcpConnectionCallback onMessageCb_;//消息到达
    TcpConnectionCallback onCloseCb_;//连接断开

    int evtfd_;     //用于通知有消息处理完成，并放入到pendings_中了
    std::vector<Functor> pendings_;     //消息处理完后
    std::mutex mutex_;
};

#endif

#include <unistd.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>

#include <iostream>

#include "event_loop.h"
#include "acceptor.h"
#include "tcp_connection.h"


EventLoop::EventLoop(Acceptor &acceptor) : 
epfd_(CreateEpollFd()), 
evtList_(1024), 
isLooping_(false), 
acceptor_(acceptor),
evtfd_(CreateEventFd()) {
    //将listenfd放在红黑树上进行监听（socket）
    int listenfd = acceptor_.Fd();
    AddEpollReadFd(listenfd);
    AddEpollReadFd(evtfd_);
}

EventLoop::~EventLoop() {
    close(epfd_);
    close(evtfd_);
}

//循环与否
void EventLoop::Loop() {
    isLooping_ = true;
    while(isLooping_)
    {
        WaitEpollFd();
    }
}

void EventLoop::Unloop() {
    isLooping_ = false;
}

//封装类epoll_wait函数
void EventLoop::WaitEpollFd() {
    int nready = 0;
    do {
        nready = epoll_wait(epfd_, &*evtList_.begin(), evtList_.size(), 3000);
    } while(-1 == nready && errno == EINTR);

    if(-1 == nready) {
        std::cerr << "-1 == nready" << std::endl;
        return;
    } else if(0 == nready) {
        std::cout << ">>epoll_wait timeout" << std::endl;
    } else {
        //可以判断一下，文件描述符是不是已经达到了1024
        //如果达到1024就需要进行扩容
        if(nready == (int)evtList_.size()) {
            evtList_.reserve(2 * nready);
        }

        for(int idx = 0; idx < nready; ++idx) {
            int fd = evtList_[idx].data.fd;
            //查看文件描述符是不是listenfd
            if(fd == acceptor_.Fd()) {           // 事件1，有新连接 
                if(evtList_[idx].events & EPOLLIN) {
                    //处理新的连接
                    HandleNewConnection();
                }
            } else if (fd == evtfd_) {            //事件2，有连接的任务处理完成了
                if(evtList_[idx].events & EPOLLIN) {
                    HandleRead();
                    DoPendingFunctors();        //主线程中发送被线程池处理好的数据
                }
            } else {                              //事件3，连接有数据到达
                if(evtList_[idx].events & EPOLLIN) {
                    //处理老的连接
                    HandleMessage(fd);
                }
            }
        }
    }
}

//处理新的连接
void EventLoop::HandleNewConnection() {
    int connfd = acceptor_.Accept();
    if(connfd < 0) {
        perror("handleNewConnection accept");
        return;
    }

    AddEpollReadFd(connfd);

    //就表明三次握手已经建立成功了
    /* TcpConnection con(connfd); */
    TcpConnectionPtr con(new TcpConnection(connfd, this));

    //将三个回调函数注册给TcpConnection
    con->SetNewConnectionCallback(onNewConnectionCb_);//连接建立的注册
    con->SetMessageCallback(onMessageCb_);//消息到达的注册
    con->SetCloseCallback(onCloseCb_);//连接断开的注册

    //以键值对的形式存起来
    /* _conns.insert(std::make_pair(connfd, con)); */
    conns_[connfd] = con;

    con->HandleNewConnectionCallback(); 
}

//处理老的连接上的消息
void EventLoop::HandleMessage(int fd) {
    auto it = conns_.find(fd);
    if(it != conns_.end()) {
        //连接是存在的，可以进行数据的收发
        bool flag = it->second->IsClosed();//读的时候客户端是不是与服务器断开
        if(flag) {
            //连接已经断开
            it->second->HandleCloseCallback();//连接断开的事件的触发时机已经到达
            DelEpollReadFd(fd);//将文件描述符从红黑树上摘除掉
            conns_.erase(it);//同时将该链接从map中删除
        } else {
            it->second->HandleMessageCallback();//消息到达事件的触发时机已经到达
        }
    } else {
        //连接不存在，可以直接让程序退出来
        std::cout << "连接不存在" << std::endl;
        return;
    }
}

//epfd的创建
int EventLoop::CreateEpollFd() {
    int fd = ::epoll_create(100);
    if(fd < 0) {
        perror("epoll_create");
        return fd;
    }
    return fd;
}

//监听文件描述符
void EventLoop::AddEpollReadFd(int fd) {
    struct epoll_event evt;
    evt.events = EPOLLIN;
    evt.data.fd = fd;

    int ret = ::epoll_ctl(epfd_, EPOLL_CTL_ADD, fd, &evt);
    if(ret < 0) {
        perror("epoll_ctl add");
        return;
    }
}

//取消文件描述符的监听
void EventLoop::DelEpollReadFd(int fd) {
    struct epoll_event evt;
    evt.events = EPOLLIN;
    evt.data.fd = fd;

    int ret = ::epoll_ctl(epfd_, EPOLL_CTL_DEL, fd, &evt);
    if(ret < 0) {
        perror("epoll_ctl add");
        return;
    }
}

void EventLoop::SetNewConnectionCallback(TcpConnectionCallback &&cb) {
    onNewConnectionCb_ = std::move(cb);
}

void EventLoop::SetMessageCallback(TcpConnectionCallback &&cb) {
    onMessageCb_ = std::move(cb);
}

void EventLoop::SetCloseCallback(TcpConnectionCallback &&cb) {
    onCloseCb_ = std::move(cb);
}

void EventLoop::HandleRead() {
    uint64_t two;
    ssize_t ret = read(evtfd_, &two, sizeof(uint64_t));
    if(ret != sizeof(uint64_t)) {
        perror("read");
        return;
    }
}

void EventLoop::DoPendingFunctors() {       //将处理好的数据发送回去，处理函数已经绑定了连接和数据，所以直接执行就好了
    std::vector<Functor> tmp;
    {   
        std::lock_guard<std::mutex> lc(std::mutex);
        tmp.swap(pendings_);
    }
    for (auto& cb : tmp) {
        cb();
    }
}

int EventLoop::CreateEventFd() {
    int fd = eventfd(10, 0);
    if(fd < 0) {
        perror("eventfd");
        return fd;
    }

    return fd;
}

void EventLoop::Wakeup() {
    uint64_t one = 1;
    ssize_t ret = write(evtfd_, &one, sizeof(uint64_t));
    if(ret != sizeof(uint64_t)) {
        perror("write");
        return;
    }
}

void EventLoop::RunInLoop(Functor&& cb) {
    {       
        std::lock_guard<std::mutex> lc(mutex_);
        pendings_.push_back(std::move(cb));             //交给主线程去执行回调函数,将处理好的数据发送回去
    }
    Wakeup();
}

TcpConnection类

tcp连接类，负责连接相关的操作
可以调用底层的sockio类进行数据的收发，同时main里面的回调函数最终是通过连接类来执行的。(只是执行的时机由EventLoop类控制，在EventLoop类中调用TcpConnection的方法执行回调函数)

#ifndef TCP_CONNECTION_H_
#define TCP_CONNECTION_H_

#include <memory>
#include <functional>
#include <string>

#include "socket.h"
#include "socket_io.h"
#include "inet_address.h"
#include "event_loop.h"

class TcpConnection;

using TcpConnectionPtr = std::shared_ptr<TcpConnection>;
using TcpConnectionCallback = std::function<void(const TcpConnectionPtr &)>;

class TcpConnection : public std::enable_shared_from_this<TcpConnection> {
public:
    explicit TcpConnection(int fd, EventLoop* loop);
    ~TcpConnection();
    auto Send(const std::string &msg) -> void;
    auto Receive() -> std::string;

    auto IsClosed() const -> bool;

    //为了方便调试的函数
    auto ToString() -> std::string;

    auto SetNewConnectionCallback(const TcpConnectionCallback& cb) -> void;
    auto SetMessageCallback(const TcpConnectionCallback& cb) -> void;
    auto SetCloseCallback(const TcpConnectionCallback& cb) -> void;

    auto HandleNewConnectionCallback() -> void;
    auto HandleMessageCallback() -> void;
    auto HandleCloseCallback() -> void;

    auto SendInLoop(const std::string& msg) -> void;

private:
    //获取本端地址与对端地址
    auto GetLocalAddr() -> InetAddress;
    auto GetPeerAddr() -> InetAddress;

private:
    SocketIO sockIO_;
    EventLoop* loop_;

    //为了调试而加入的三个数据成员
    Socket sock_;
    InetAddress localAddr_;
    InetAddress peerAddr_;

    TcpConnectionCallback onNewConnectionCb_;//连接建立
    TcpConnectionCallback onMessageCb_;//消息到达
    TcpConnectionCallback onCloseCb_;//连接断开
};

#endif

#include <iostream>
#include <sstream>
#include <functional>

#include "tcp_connection.h"

TcpConnection::TcpConnection(int fd, EventLoop* loop) :
sockIO_(fd),
loop_(loop),
sock_(fd),
localAddr_(GetLocalAddr()),
peerAddr_(GetPeerAddr()) {}

TcpConnection::~TcpConnection() {}

void TcpConnection::Send(const std::string &msg) {
    sockIO_.Writen(msg.c_str(), msg.size());
}

std::string TcpConnection::Receive() {
    char buff[65535] = {0};
    sockIO_.ReadLine(buff, sizeof(buff));

    return std::string(buff);
}

//可以通过该函数判断读的数据是不是空的，也就是有没有断开
bool TcpConnection::IsClosed() const {
    char buf[10]= {0};
    int ret = ::recv(sock_.Fd(), buf, sizeof(buf), MSG_PEEK);
    return (0 == ret);
}

std::string TcpConnection::ToString() {
    std::ostringstream oss;
    oss << localAddr_.Ip() << ":"
        << localAddr_.Port() << "---->"
        << peerAddr_.Ip() << ":"
        << peerAddr_.Port();

    return oss.str();
}

void TcpConnection::SendInLoop(const std::string& msg) {
    auto f = std::bind(&TcpConnection::Send,this,msg);      //Send函数绑定好TcpConnection对象和处理好的msg
    if (loop_) {
        //发送操作交给eventloop,放入pendings数组中，并调用wakeup，让eventloop的evtfd_可读
        //这样事件循环就能检测到事件，将pendings里的操作发送回去
        loop_->RunInLoop(std::move(f));        
    }
}

//获取本端的网络地址信息
InetAddress TcpConnection::GetLocalAddr() {
    struct sockaddr_in addr;
    socklen_t len = sizeof(struct sockaddr );
    //获取本端地址的函数getsockname
    int ret = getsockname(sock_.Fd(), (struct sockaddr *)&addr, &len);
    if(-1 == ret) {
        perror("getsockname");
    }

    return InetAddress(addr);
}

//获取对端的网络地址信息
InetAddress TcpConnection::GetPeerAddr() {
    struct sockaddr_in addr;
    socklen_t len = sizeof(struct sockaddr );
    //获取对端地址的函数getpeername
    int ret = getpeername(sock_.Fd(), (struct sockaddr *)&addr, &len);
    if(-1 == ret) {
        perror("getpeername");
    }

    return InetAddress(addr);
}

void TcpConnection::SetNewConnectionCallback(const TcpConnectionCallback &cb) {
    onNewConnectionCb_ = cb;
}

void TcpConnection::SetMessageCallback(const TcpConnectionCallback &cb) {
    onMessageCb_ = cb;
}

void TcpConnection::SetCloseCallback(const TcpConnectionCallback &cb) {
    onCloseCb_ = cb;
}

//三个回调的执行
void TcpConnection::HandleNewConnectionCallback() {
    if(onNewConnectionCb_) {
        /* _onNewConnectionCb(shared_ptr<TcpConnection>(this)); */
        onNewConnectionCb_(shared_from_this());
    } else {
        std::cout << "_onNewConnectionCb == nullptr" << std::endl;
    }
}

void TcpConnection::HandleMessageCallback()
{
    if(onMessageCb_) {
        onMessageCb_(shared_from_this());
    } else {
        std::cout << "_onMessageCb == nullptr" << std::endl;
    }
}

void TcpConnection::HandleCloseCallback()
{
    if(onCloseCb_) {
        onCloseCb_(shared_from_this());
    } else {
        std::cout << "_onCloseCb == nullptr" << std::endl;
    }
}

TcpServer类(封装EventLoop和Acceptor类)

#ifndef TCP_SERVER_H_
#define TCP_SERVER_H_

#include <string>

#include "acceptor.h"
#include "event_loop.h"

class TcpServer{

    using Callback = std::function<void(const TcpConnectionPtr &)>;
public:
    TcpServer(const std::string& ip, unsigned short port);
    ~TcpServer() = default;

    auto Start() -> void;
    auto Stop() -> void;
    auto SetAllCallback(Callback&& cb1, Callback&& cb2, Callback&& cb3) -> void;

private:
    Acceptor acceptor_;
    EventLoop loop_;

};

#endif

#include "tcp_server.h"

TcpServer::TcpServer(const std::string& ip, unsigned short port) : 
acceptor_(ip,port), 
loop_(acceptor_) {}

void TcpServer::Start() {
    acceptor_.Ready();      //创建socket连接，等待连接
    loop_.Loop();           //开启事件循环
}

void TcpServer::Stop() {
    loop_.Unloop();
}

//设置处理事件回调函数
void TcpServer::SetAllCallback(Callback&& cb1, Callback&& cb2, Callback&& cb3) {
    loop_.SetNewConnectionCallback(std::move(cb1));
    loop_.SetMessageCallback(std::move(cb2));
    loop_.SetCloseCallback(std::move(cb3));
}

main函数文件

#include <iostream>
#include <string>
#include <functional>

#include "acceptor.h"
#include "tcp_connection.h"
#include "event_loop.h"
#include "tcp_server.h"
#include "thread_pool.h"

class MyTask{
public:
    MyTask(const std::string& msg, TcpConnectionPtr con) : 
    msg_(msg),
    con_(con){
        std::cout << "construct " << msg << std::endl;
        std::cout << "construct2 " << msg_ << std::endl;
    }

    void process(){         //线程池中线程执行的业务处理逻辑
        std::string msg2 = "";
        std::cout << "before process: " << msg_ << std::endl;
        for (auto c : msg_) {
            if (c >= 'a' && c <= 'z') {
                msg2 += (c - 32);
            } else {
                msg2 += c;
            }
        }
        msg2 += '\n';
        std::cout << "after process: " << msg2 << std::endl;

        //处理完成后，发送交给主线程去处理
        //先将信息msg2交给TcpConnection,将msg2和connnction的send函数进行绑定，形成一个具有发送msg2能力的可调用对象void()
        //再将这个可调用对象交给EventLoop，放入到pendings中(所有线程处理完数据后，形成的可调用对象集合) 
        //这里还会去让EventLoop的向evtfd_写入数据，让evtfd_可读，这样下一个loop循环检测到就去执行集合里的所有可调用对象
        //即在主函数中将数据发送出去了
        con_->SendInLoop(msg2);       
    }

private:
    std::string msg_;
    TcpConnectionPtr con_;
};

//连接建立
void onNewConnection(const TcpConnectionPtr &con)
{
    std::cout << con->ToString() << " has connected!" << std::endl;
}

//文件描述符可读(消息到达)
void onMessage(const TcpConnectionPtr &con, ThreadPool& pool)
{
    std::string msg = con->Receive();
    std::cout << ">>recv client msg = " << msg << std::endl;

    //业务处理逻辑函数交给线程池取完成
    std::shared_ptr<MyTask> task = std::make_shared<MyTask>(msg,con);
    pool.AddTask(std::bind(&MyTask::process,task));
}

//连接断开
void onClose(const TcpConnectionPtr &con)
{
    std::cout << con->ToString() << " has closed!" << std::endl;
}
    
void test()
{
    TcpServer tcpServer("127.0.0.1", 8888);
    ThreadPool pool(4,10);
    pool.Start();
    tcpServer.SetAllCallback(onNewConnection,
        std::bind(&onMessage,std::placeholders::_1,std::ref(pool)),
        onClose);
    tcpServer.Start();
}

int main(int argc, char *argv[])
{
    test();
    return 0;
}

线程池相关类（之前博客有相关介绍）

#ifndef TASKQUEUE_H_
#define TASKQUEUE_H_

#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class TaskQueue{
    //表示任务的类型
    using ElemType = std::function<void()>;
 
public:
    explicit TaskQueue(int que_size);
    ~TaskQueue() = default;
    auto Push(ElemType&& ptask) -> void;
    auto Pop() -> ElemType;
    [[nodiscard]] auto IsFull() const -> bool;
    [[nodiscard]] auto IsEmpty() const -> bool;
    auto WakeUp() -> void;

private:
    size_t que_size_;
    std::queue<ElemType> que_;			//用于存放任务，任务应当是一个void()的可调用对象
    std::mutex mutex_;
    std::condition_variable not_full_;
    std::condition_variable not_empty_;
    bool flag_;  //为了唤醒所有的工作线程，可以让while退出
};

#endif

#include "task_queue.h"

TaskQueue::TaskQueue(const int que_size) : 
que_size_(que_size),
mutex_(),
not_full_(),
not_empty_(),
flag_(true)
{   
}

void TaskQueue::Push(ElemType&& ptask) {
    std::unique_lock lock(mutex_);
    while(IsFull()) {
        //等待not_full_来唤醒
        not_full_.wait(lock);
    }
    que_.push(std::move(ptask));
    not_empty_.notify_one();
}

TaskQueue::ElemType TaskQueue::Pop() {
    std::unique_lock lock(mutex_);
    while(IsEmpty() && flag_) {
        //等待not_empty_来唤醒
        not_empty_.wait(lock);
    }
    if (flag_) {
        ElemType task = que_.front();
        que_.pop();
        not_full_.notify_one();
        return task;
    } else {
        return nullptr;
    }
}

bool TaskQueue::IsFull() const {
    return que_.size() == que_size_;
}

bool TaskQueue::IsEmpty() const {
    return que_.empty();
}

void TaskQueue::WakeUp() {
    flag_ = false;
    not_empty_.notify_all();
}

#ifndef THREAD_POOL_H_
#define THREAD_POOL_H_

#include <memory>
#include <vector>
#include <functional>
#include <thread>

#include "task_queue.h"

class ThreadPool {
    using Task = std::function<void()>;
    friend class WorkThread;
public:
    ThreadPool(size_t thread_num, size_t que_size);
    ~ThreadPool() = default;
    auto Start() -> void;
    auto Stop() -> void;
    auto AddTask(Task&& task) -> void;

private:
    auto GetTask() -> Task;
    auto DoTask() -> void;

private:
    size_t thread_num_;
    size_t que_size_; 
    std::vector<std::unique_ptr<std::thread>> threads_;
    TaskQueue task_que_;
    bool is_exit_;
};

#endif

#include <iostream>
#include <functional>
#include <thread>
#include <chrono>

#include "thread_pool.h"

ThreadPool::ThreadPool(const size_t thread_num, const size_t que_size) :
thread_num_(thread_num),
que_size_(que_size),
task_que_(que_size_),
is_exit_(false) {
    threads_.reserve(thread_num_);
}

void ThreadPool::Start() {
    for (size_t i = 0; i < thread_num_; i++) {
        threads_.push_back(std::make_unique<std::thread>(std::bind(&ThreadPool::DoTask,this)));
    }
}

void ThreadPool::Stop() {
    //确保任务队列里的任务可以执行完
    while(!task_que_.IsEmpty()) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    is_exit_ = true;
    task_que_.WakeUp();
    for (size_t i = 0; i < thread_num_; i++) {
        threads_[i]->join();
    }
}

void ThreadPool::AddTask(Task&& task) {
    if (task) {
        task_que_.Push(std::move(task));
    }
} 

ThreadPool::Task ThreadPool::GetTask() {
    return task_que_.Pop();
}

void ThreadPool::DoTask() {
    while(!is_exit_) {
        if (Task task = GetTask()) {
            task();
        }
    } 
}

使用教学

主要代码写在MyTask类和三个回调函数中
核心业务代码可以在MyTask中完成
三个回调函数可以用来打印对应信息或进行其他处理

C++异步编程工具 (二)

Fri, 24 Jan 2025 00:00:00 +0000

引言

std::shared_future 是 C++ 标准库中的一个类，用于表示可以共享的异步计算结果。它与 std::future 类似，但允许多个线程共享同一个异步结果，而 std::future 只能被单个线程访问。

std::shared_future

`std::shared_future` 的特点

共享性: 多个 std::shared_future 对象可以引用同一个异步计算结果。
多次访问: 可以多次调用 get() 方法获取结果，而 std::future 的 get() 只能调用一次。
线程安全: 多个线程可以同时访问同一个 std::shared_future 对象。

与 `std::future` 的区别

特性	`std::future`	`std::shared_future`
共享性	只能由一个线程访问	可以由多个线程共享
`get()` 调用次数	只能调用一次	可以多次调用
拷贝语义	不可拷贝，只能移动	可以拷贝，也可以移动

获取std::shared_future的方式

//方式一 移动future对象
std::promive<int> p;
std::future<int> f = p.get_future();
std::shared_future<int> sf(std::move(f));

//方式二 调用futured的share()方法
std::shared_future<int> sf = f.shared();

//方式三 通过future的右值对象直接进行转移
std::shared_future<int> sf(p.get_future());

shared_future的代码示例

void func(std::shared_future<int> sf) {
    std::cout << "sf.get() is " << sf.get() << std::endl;
}


int main() {
    std::promise<int> p;
    std::future<int> f = p.get_future();
    std::shared_future<int> sf = f.share();

    //shared_future允许多个线程同时访问future对象，如果是future，则只能有一个线程访问
    std::thread t1(func,sf);
    std::thread t2(func,sf);
    
    std::this_thread::sleep_for(std::chrono::seconds(5));

    p.set_value(1);
    t1.join();
    t2.join();
}

不同的shared_future对象都绑定同一个异步任务，异步任务结束后，所有的shared_future对象都可以通过get()获取值。
如果shared_future对象状态是ready，那么再新创建shared_future对象，其状态也是ready，可以通过get()立刻获得值。
std::shared_future 的核心作用就是将 std::future 分发（共享）给多个线程，使得多个线程可以同时调用 get() 获取异步任务的结果。

C++异步编程工具 (一)

Thu, 23 Jan 2025 00:00:00 +0000

引言

std::async、std::packaged_task 和 std::promise 是C++11引入的三个用于异步编程的工具，它们都与 std::future 配合使用，用于在多线程环境中执行任务并获取结果。本篇文中的工具都在<future>头文件中声明。

std::future

`std::future` 的核心功能

获取异步操作的结果：
- 通过 get() 方法获取异步操作的结果。
- 如果结果尚未准备好，get() 会阻塞当前线程，直到结果可用。
检查异步操作的状态：
- 通过 valid() 方法检查 std::future 是否关联了一个有效的共享状态。
- 通过 wait()、wait_for() 和 wait_until() 方法等待异步操作完成。
移动语义：
- std::future 只能移动（Move），不能复制。

`std::future` 的主要方法

方法	描述
`get()`	获取异步操作的结果。如果结果未准备好，会阻塞当前线程直到结果可用。
`valid()`	检查 `std::future` 是否关联了一个有效的共享状态。
`wait()`	阻塞当前线程，直到异步操作完成。
`wait_for()`	阻塞当前线程一段时间，等待异步操作完成。
`wait_until()`	阻塞当前线程直到某个时间点，等待异步操作完成。
`share()`	将 `std::future` 转换为 `std::shared_future`，允许多个线程共享结果。

get和wait方法
wait方法没有返回值，只是等待异步操作完成

get方法等待异步操作完成并会返回具体future<T>中T类型的值

调用wait方法后，还可以调用get方法；返过来则不行

具体使用看后面小节与其他工具相互配合

std::async

async是一个模板函数，下面是这个函数的使用方法。

int func1() {
    std::cout << " (hello world in func1) " << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 1024;
}

void func2() {
    std::cout << " (hello world in func2) " << std::endl;
}

int main() {
    //第一个参数的两种形式deferred   async(可以省略)
    std::future<int> f1 = std::async(std::launch::deferred, func1);
    //如果第一个参数是deferrd，则func1不会立即执行，等到后面调用get()或wait()方法时才会执行。
    //如果第一个参数是async，创建一个新线程立刻执行func1，并返回结果。(async可以省略)
    //如果第一个参数是 deferred | async ，那么就会由async的实现自行决定选择运行方式
    func2();

    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::cout << " Result: " << f1.get() << std::endl;       //等待func1执行完毕，并获取结果
}

std::package_task

`std::packaged_task` 的核心功能

包装可调用对象：
- std::packaged_task 可以包装一个可调用对象（函数、lambda表达式、函数对象等）。
关联 std::future：
- 通过 get_future() 方法，可以获取一个与任务结果关联的 std::future 对象。
执行任务：
- 调用 operator() 或将其传递给线程执行时，任务会被执行，并将返回值或异常自动设置到 std::future 中。

`std::packaged_task` 的主要方法

方法	描述
`operator()`	执行包装的可调用对象，并将返回值或异常与 `std::future` 关联。
`get_future()`	获取与 `std::packaged_task` 关联的 `std::future` 对象。
`reset()`	重置 `std::packaged_task`，使其可以重新包装一个新的可调用对象。

具体使用

//函数模板参数指定函数的参数和返回值
//传入的函数不需要严格匹配，但是函数参数应当可以进行隐式转换
//该对象含有operator(),是调用对象，可以传给std::function
//该对象可以移动，但是不能拷贝
int print(int d) {
    cout << d << endl;
    return d;
}

int main() {
    std::packaged_task<int(double)> task(print);	//传入函数参数可以发生隐式类型转换即可
    std::future<int> fut = task.get_future();

    //在main函数执行
    task(3.14159265359);
    cout << fut.get() << endl;	//执行完task才会得到结果
}

int print(int d) {
    this_thread::sleep_for(chrono::seconds(5));
    cout << d << endl;
    return d;
}

void func(packaged_task<int(double)>&& task, const double d) {
    task(d);
}

int main() {
    packaged_task<int(double)> task(print);
    future<int> fut = task.get_future();

    //在新线程上面去执行task
    thread t1(func,std::move(task),3.1415926);
    cout << fut.get() << endl;		//等待t1线程的task执行结束才会获得值
    t1.join
}

std::async和std::packaged_task<>使用对比

std::async

将任务(函数)交给它，由它决定立刻执行还是延时执行，并直接返回future对象用来获取返回值。
std::launch::async立刻执行函数，会创建新线程
std::launch::deferred不会立刻执行，future对象调用wait或get时候才执行，不会创建新线程

std::packaged_task

直接绑定任务，通过get_future成员方法得到future对象，通过oprator()进行任务的调用。
手动控制调用的时机

对比下面三个程序

int print(int d) {
  this_thread::sleep_for(chrono::seconds(5));
  cout << d << endl;
  return d;
}

void func(future<int>& fut) {
  this_thread::sleep_for(chrono::seconds(10));
  fut.wait();
}

int main() {
  future<int> fut =  async(launch::deferred, print, 10);
  thread t1(func,std::ref(fut));
  cout << fut.get() << endl;		//立刻执行get,但是t1线程之后会执行wait导致报错。
  t1.join();
}

int print(int d) {
  this_thread::sleep_for(chrono::seconds(5));
  cout << d << endl;
  return d;
}

void func(future<int>& fut) {
  this_thread::sleep_for(chrono::seconds(10));
  fut.wait();
}

int main() {
  future<int> fut =  async(launch::deferred, print, 10);
  thread t1(func,std::ref(fut));

  auto state = fut.wait_for(chrono::seconds(0));
  while (state != future_status::ready) {		//异步任务还没有结束
      state = fut.wait_for(chrono::milliseconds(200));	//继续等待
  }

  cout << fut.get() << endl;	//调用get时候，异步任务以及结束，这里只是获得结果
  t1.join();
}

int print(int d) {
  this_thread::sleep_for(chrono::seconds(5));
  cout << d << endl;
  return d;
}

void func(packaged_task<int(int)>&& task, const int d) {
  this_thread::sleep_for(chrono::seconds(10));
  task(d);
}

int main() {
  packaged_task<int(int)> task(print);
  future<int> fut = task.get_future();
  thread t(func,std::move(task),10);
  cout << fut.get() << endl;
  t.join();
}

std::promise

`std::promise` 的核心功能

用途：std::promise 用于手动设置一个值或异常，并将其与 std::future 关联。
特点：
- 需要显式调用 set_value() 或 set_exception() 来设置值或异常。
- 适用于需要手动控制结果设置的场景。
- 通常用于将结果从一个线程传递到另一个线程。
- std::promise 不能复制，但它支持移动语义（Move Semantics）

std::promise 的主要方法

方法	描述
`set_value()`	设置值，并将 `std::future` 标记为就绪。
`set_exception()`	设置异常，并将 `std::future` 标记为就绪。
`get_future()`	获取与 `std::promise` 关联的 `std::future` 对象。

std::promise 的使用示例

#include <iostream>
#include <thread>
#include <future>

void task(std::promise<int> prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2));  // 模拟耗时操作
    prom.set_value(42);  // 设置值
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();  // 获取与 promise 关联的 future

    std::thread t(task, std::move(prom));  // 启动线程，传递 promise

    std::cout << "Waiting for the result..." << std::endl;
    int result = fut.get();  // 阻塞，直到 promise 设置值
    std::cout << "Result: " << result << std::endl;

    t.join();  // 等待线程结束
    return 0;
}

future保存异常

一下几种情况可以将异常保存到future中，当future.get()的时候会重新抛出异常
- async执行操作的时候发生异常，会将异常保存到future中。
- packaged_task执行任务函数的时候抛出异常，会将异常保存到future中。
- promise对象调用set_exception()设置异常。
- 当async和packaged_task对象在future未就绪的时候被销毁，他们的析构函数就会将std::future_error存储为异步任务的状态，它的值（std::future_error::code()方法获得）是std::future_errc::broken_promise(枚举类型)。

C++11线程池

Mon, 06 Jan 2025 00:00:00 +0000

引言

在C++11之前，标准库并不提供线程相关的支持（如std::thread、std::mutex等），因此在C++11之前创建线程池需要依赖于操作系统的线程库或第三方库，如 POSIX线程（pthread） 或 Boost.Thread。而在c++11之后，我们可以使用c++的标准库来实现线程池，从而写出跨平台的线程池。

线程池简介

线程池的定义

线程池是一种线程管理模式，用于复用一组固定数量的线程来执行任务，而不是为每个任务都单独创建和销毁线程。通过线程池，任务被放入任务队列中，由空闲的线程依次取出并执行，从而提升性能和资源利用率。

为什么需要线程池？

线程创建和销毁的开销：

每次创建和销毁线程都需要占用系统资源。
在线程数量较多时，这些开销会变得显著。

系统资源限制：

一个进程中可以创建的线程数量是有限的（由系统资源决定）。
如果频繁创建过多线程，可能会导致资源耗尽。

高效的任务调度：

使用线程池可以让多个任务由有限的线程处理，避免因线程切换导致的性能下降。
空闲线程可以立即复用，减少等待时间。

控制并发量：

限制线程的数量，防止系统过载。

线程池的工作原理

初始化线程池：

创建一定数量的线程，并让它们处于等待（阻塞）状态。

任务提交：

新任务被添加到任务队列中。

任务执行：

空闲线程从任务队列中取出任务并执行。
执行完任务后，线程继续等待下一个任务。

线程池销毁：

停止线程池，等待所有线程完成任务并退出。

线程池的主要组件

任务队列：

存放待执行的任务，可以是FIFO队列或优先级队列。
每个任务通常是一个函数或可调用对象。

线程集合：

一组预创建的工作线程，用于执行任务。

同步机制：

使用锁（如std::mutex或pthread_mutex_t）保护任务队列，防止多线程竞争条件。
使用条件变量（如std::condition_variable或pthread_cond_t）来通知线程任务的到来。

线程池管理器：

提供接口来提交任务、管理线程池大小、以及终止线程池。

线程池的优点

减少资源消耗：

复用线程，避免频繁创建和销毁线程。

提高系统性能：

避免过多线程竞争CPU资源。
降低线程切换的开销。

方便任务管理：

可控制任务的执行顺序（如任务优先级）。
可根据负载动态调整线程池的大小。

提高可扩展性：

在多核处理器上，线程池能够更好地利用多核资源，实现并行化处理。

线程池的使用场景

高并发服务器：

如Web服务器、数据库服务器等，需要处理大量短时间的任务。

CPU密集型任务：

通过固定数量的线程并行处理计算任务，提高CPU利用率。

I/O密集型任务：

处理网络请求或文件I/O时，通过线程池避免阻塞。

定时任务：

周期性任务调度，例如日志清理、数据备份等。

示例：线程池的任务调度流程

应用程序提交任务。
任务被放入任务队列。
线程池中一个空闲线程取出任务并执行。
执行完成后，线程返回线程池，等待下一任务。

基于c++11的线程池的实现

task_queue类的设计

任务队列使用生产者消费者模型，将任务当作物品，每当将任务放到任务队列的时候，就会通知线程拿取任务，并让线程执行任务。
task_queue的接口如下

#ifndef TASKQUEUE_H_
#define TASKQUEUE_H_

#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class TaskQueue{
    //表示任务的类型
    using ElemType = std::function<void()>;
 
public:
    explicit TaskQueue(int que_size);
    ~TaskQueue() = default;
    void Push(ElemType&& ptask);
    ElemType Pop();
    bool IsFull() const;
    bool IsEmpty() const;
    void WakeUp();

private:
    size_t que_size_;
    std::queue<ElemType> que_;			//用于存放任务，任务应当是一个void()的可调用对象
    std::mutex mutex_;
    std::condition_variable not_full_;
    std::condition_variable not_empty_;
    bool flag_;  //为了唤醒所有的工作线程，可以让while退出
};

#endif

task_queue类的实现如下

#include "task_queue.h"

TaskQueue::TaskQueue(const int que_size) : 
que_size_(que_size),
mutex_(),
not_full_(),
not_empty_(),
flag_(true)
{   
}

void TaskQueue::Push(ElemType&& ptask) {
    std::unique_lock lock(mutex_);
    while(IsFull()) {
        //等待not_full_来唤醒
        not_full_.wait(lock);
    }
    que_.push(std::move(ptask));
    not_empty_.notify_one();
}

TaskQueue::ElemType TaskQueue::Pop() {
    std::unique_lock lock(mutex_);
    while(IsEmpty() && flag_) {
        //等待not_empty_来唤醒
        not_empty_.wait(lock);
    }
    if (flag_) {
        ElemType task = que_.front();
        que_.pop();
        not_full_.notify_one();
        return task;
    } else {
        return nullptr;
    }
}

bool TaskQueue::IsFull() const {
    return que_.size() == que_size_;
}

bool TaskQueue::IsEmpty() const {
    return que_.empty();
}

void TaskQueue::WakeUp() {
    flag_ = false;
    not_empty_.notify_all();
}

thread_pool类的设计

thread_pool用于创建多个线程，并可以添加和获取任务，让线程去执行任务。其中有一个DoTask函数，当作线程函数，让线程执行任务。DoTask在执行任务前应当获取任务，如果没有任务，线程就会阻塞等待任务。当任务到来时，通过条件变量唤醒线程，并获取到任务task(一个可调用对象)，这时候就可以直接调用task()去执行任务。
thread_pool的接口如下

#ifndef THREAD_POOL_H_
#define THREAD_POOL_H_

#include <memory>
#include <vector>
#include <functional>
#include <thread>

#include "task_queue.h"

class ThreadPool {
    using Task = std::function<void()>;
public:
    ThreadPool(size_t thread_num, size_t que_size);
    ~ThreadPool() = default;
    void Start();
    void Stop();
    void AddTask(Task&& task);

private:
    Task GetTask();
    void DoTask();

private:
    size_t thread_num_;
    size_t que_size_; 
    std::vector<std::unique_ptr<std::thread>> threads_;
    TaskQueue task_que_;
    bool is_exit_;
};

#endif

thread_pool的实现如下

#include <iostream>
#include <functional>
#include <thread>
#include <chrono>

#include "thread_pool.h"

ThreadPool::ThreadPool(const size_t thread_num, const size_t que_size) :
thread_num_(thread_num),
que_size_(que_size),
task_que_(que_size_),
is_exit_(false) {
    threads_.reserve(thread_num_);
}

void ThreadPool::Start() {
    for (size_t i = 0; i < thread_num_; i++) {
        threads_.push_back(std::make_unique<std::thread>(std::bind(&ThreadPool::DoTask,this)));
    }
}

void ThreadPool::Stop() {
    //确保任务队列里的任务可以执行完
    while(!task_que_.IsEmpty()) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    is_exit_ = true;
    task_que_.WakeUp();
    for (size_t i = 0; i < thread_num_; i++) {
        threads_[i]->join();
    }
}

void ThreadPool::AddTask(Task&& task) {
    if (task) {
        task_que_.Push(std::move(task));
    }
} 

ThreadPool::Task ThreadPool::GetTask() {
    return task_que_.Pop();
}

void ThreadPool::DoTask() {
    while(!is_exit_) {
        if (Task task = GetTask()) {
            task();
        }
    } 
}

设计上的细节

在终止线程池之前，要确保任务队列中的任务被全部取出。
当线程池终止的时候，会将退出标志设置为true，并且会唤醒所有睡着的线程，并告知退出，此时线程将不再会进入循环。

使用线程池

定义MyTask类，使用process()成员函数作为任务的具体执行过程，任务所需要的变量可以用MyTask的成员变量来表示。注意任务应当是void()类型的可调用对象，所以thread_pool添加任务的时候，需要绑定一下this指针。

#include <iostream>
#include <vector>
#include <functional>

#include "thread_pool.h"

//自己实现任务逻辑交给线程池去执行
class MyTask {
public:
    explicit MyTask(const int num) : num_(num) {}
    void process() const {
        std::cout << num_ << std::endl;
    }
    char num_;
};

int main() {
    ThreadPool pool(4, 10);
    std::vector<MyTask> tasks;
    for (int i = 0; i < 40; i++) {
        tasks.emplace_back(i+'A');
    }
    pool.Start();
    for (int i = 0; i < 40; i++) {
        pool.AddTask(std::bind(&MyTask::process,&tasks[i]));
    }
    pool.Stop();
}

C++ on 奕晨's blog

打开模板元编程的大门

引言

模板元编程(TMP)

模板也可以递归

::type

SFINAE

::value

更多的类型判断

decltype和declval

void_t

线程屏障

引言

std::latch

std::barrier

奇异模板

引言

奇异递归模板模式

代码实现

奇异模板特性

特点

通过函数调用实现多态

SFINAE

引言

SFINAE

SFINAE 的核心思想

SFINAE常用工具

std::enable_if

std::void_t

std::declval

最终实现insert

类型萃取

引言

常见类型萃取类

std::is_* 系列

std::is_*_v 系列（C++17引入）

std::is_same<T, U>

std::remove_* 系列

std::is_base_of<Base, Derived> 和 std::is_convertible<From, To>

std::enable_if<T, U> 和 std::disable_if<T, U>

std::is_trivially_* 系列（C++11引入）

std::conditional<T, U, V>（C++11引入）

is_integral<T>的实现

使用模板特化实现简单的类型萃取

基于c++14的变量的模板

解决修饰符问题

reactor模型

引言

reactor实现简要介绍

两个重要的类

EventLoop类

TcpConnection类

三个回调函数(通常由自己去实现，可以更改实现，去完成不同的业务)

连接建立

消息达到

连接断开

线程池任务处理逻辑 (通常由自己去实现，可以更改实现，去完成不同的业务)

源码实现

InetAddress（ip地址和端口号对象）

Socket对象

SocketIO对象 (用于发送接受数据)

Acceptor对象(用于建立tcp连接)

EventLoop类

TcpConnection类

TcpServer类(封装EventLoop和Acceptor类)

main函数文件

线程池相关类（之前博客有相关介绍）

使用教学

C++异步编程工具 (二)

引言

std::shared_future

std::shared_future 的特点

与 std::future 的区别

获取std::shared_future的方式

shared_future的代码示例

C++异步编程工具 (一)

引言

std::future

std::future 的核心功能

std::future 的主要方法

`std::is_*` 系列

`std::is_*_v` 系列（C++17引入）

`std::is_same<T, U>`

`std::remove_*` 系列

`std::is_base_of<Base, Derived>` 和 `std::is_convertible<From, To>`

`std::enable_if<T, U>` 和 `std::disable_if<T, U>`

`std::is_trivially_*` 系列（C++11引入）

`std::conditional<T, U, V>`（C++11引入）

`std::shared_future` 的特点

与 `std::future` 的区别

`std::future` 的核心功能

`std::future` 的主要方法

`std::packaged_task` 的核心功能

`std::packaged_task` 的主要方法

`std::promise` 的核心功能