C++STL---＜utility＞

C++标准库的<utility>头文件提供了一组通用的工具函数、类型和模板，主要用于简化开发中的常见操作。

---

1. <utility>概述

主要功能

<utility>库包含以下内容：

1. 类型辅助工具 ：如std::pair、std::tuple的支持。
2. 移动语义支持 ：如std::move和std::forward。
3. 交换操作 ：如std::swap。
4. 类型特性 ：如std::declval。
5. 其他工具 ：如std::make_pair、std::exchange等。

头文件

#include <utility>

---

2. 常用工具和函数

以下是<utility>中常用的工具和函数分类讲解：

---

2.1 std::pair

std::pair是一个轻量级的模板类，用于存储两个相关联的值。

主要功能

• 存储两个值：first 和 second。
• 支持比较操作（按字典序比较）。
• 常用于键值对存储（如std::map）。

示例

#include <utility>
#include <iostream>

int main() {
    std::pair<int, std::string> p = std::make_pair(1, "Hello");
    std::cout << p.first << " " << p.second << "\n";
    return 0;
}

---

2.2 std::move

std::move是一个函数模板，用于显式地将对象转换为右值引用，以支持移动语义。

特点

• 本质上是一个类型转换，不会实际移动数据。
• 通常与移动构造函数或移动赋值运算符一起使用。

示例

#include <iostream>
#include <utility>
#include <vector>

int main() {
    std::vector<int> v1 = {1, 2, 3};
    std::vector<int> v2 = std::move(v1); // v1的内容被"移动"到v2
    std::cout << "v1 size: " << v1.size() << "\n"; // 输出: 0
    std::cout << "v2 size: " << v2.size() << "\n"; // 输出: 3
    return 0;
}

---

2.3 std::forward

std::forward是一个函数模板，用于完美转发（perfect forwarding）。它可以保留参数的左值或右值属性。

特点

• 常用于泛型函数中，将参数传递给另一个函数时保留其值类别。

示例

#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "Lvalue: " << x << "\n";
}

void process(int&& x) {
    std::cout << "Rvalue: " << x << "\n";
}

template <typename T>
void forwardExample(T&& arg) {
    process(std::forward<T>(arg)); // 保留传入参数的值类别
}

int main() {
    int a = 10;
    forwardExample(a);        // 调用Lvalue版本
    forwardExample(20);       // 调用Rvalue版本
    return 0;
}

---

2.4 std::swap

std::swap用于交换两个对象的值。

特点

• 支持用户自定义类型的交换（需要提供swap函数）。
• 常用于容器操作或排序算法中。

示例

#include <iostream>
#include <utility>

int main() {
    int a = 5, b = 10;
    std::swap(a, b);
    std::cout << "a: " << a << ", b: " << b << "\n"; // 输出: a: 10, b: 5
    return 0;
}

---

2.5 std::declval

std::declval是一个函数模板，用于生成一个未初始化的对象引用，通常用于推导类型或编译期检查。

特点

• 只能用于不实际创建对象的场景（如decltype）。
• 不会调用构造函数。

示例

#include <iostream>
#include <utility>
#include <type_traits>

struct Example {
    void func() {}
};

template <typename T>
decltype(std::declval<T>().func()) testFunc(); // 推导T的成员函数类型

int main() {
    std::cout << std::is_void<decltype(testFunc<Example>())>::value << "\n"; // 输出: 1 (true)
    return 0;
}

---

2.6 std::make_pair

std::make_pair用于生成一个std::pair对象，常用于简化代码。

示例

#include <iostream>
#include <utility>

int main() {
    auto p = std::make_pair(1, "Hello");
    std::cout << p.first << " " << p.second << "\n"; // 输出: 1 Hello
    return 0;
}

---

2.7 std::exchange

std::exchange是一个函数模板，用于将一个值替换为新值，并返回旧值。

特点

• 常用于实现资源管理（如RAII）。

示例

#include <iostream>
#include <utility>

int main() {
    int x = 10;
    int old = std::exchange(x, 20); // 将x替换为20，并返回旧值
    std::cout << "Old: " << old << ", New: " << x << "\n"; // 输出: Old: 10, New: 20
    return 0;
}

---

2.8 std::rel_ops（已弃用）

std::rel_ops提供了基于==和<自动生成的比较运算符（如!=、>、<=、>=）。由于现代C++中可以直接通过<=>（三向比较）实现类似功能，std::rel_ops在C++20中已被弃用。

---

3. <utility>中的类型和别名

3.1 std::integer_sequence

std::integer_sequence是一个模板类，用于表示一组整数序列，常用于元编程。

示例

#include <iostream>
#include <utility>

template <typename T, T... Ints>
void printSequence(std::integer_sequence<T, Ints...>) {
    ((std::cout << Ints << " "), ...); // C++17折叠表达式
}

int main() {
    printSequence(std::integer_sequence<int, 1, 2, 3>{}); // 输出: 1 2 3
    return 0;
}

---

3.2 std::index_sequence

std::index_sequence是std::integer_sequence的特化，用于生成从0开始的索引序列。

示例

#include <iostream>
#include <utility>

template <typename... Args, std::size_t... Indexes>
void printArgs(std::index_sequence<Indexes...>, Args... args) {
    ((std::cout << Indexes << ": " << args << "\n"), ...);
}

int main() {
    printArgs(std::index_sequence_for<int, double, char>{}, 42, 3.14, 'A');
    return 0;
}

---

4. 注意事项

1. std::move和std::forward

   • std::move并不会真正移动对象，只是将其类型转换为右值引用。
   • std::forward常用于泛型编程，需结合模板参数使用。

2. std::swap的效率

   • 对于自定义类型，建议提供自定义的swap函数以提高效率。

3. std::exchange的用途

   • 常用于重置资源（如智能指针的管理对象）。

4. std::pair和std::tuple的对比

   • std::pair仅支持两个元素，而std::tuple支持任意数量的元素。

---