Стандартная библиотека C++ utility
В стандартной библиотеке C++,<utility>Заголовочный файл содержит некоторые практические вспомогательные классы и функции, которые очень полезны при написании эффективного и читаемого кода.
utilityОсновная ценность библиотеки заключается в:
- Предоставление фундаментальных структур данных и вспомогательных функций
- Упрощение реализации распространённых задач программирования
- Обеспечение фундаментальной поддержки для других компонентов стандартной библиотеки
utilityХотя заголовочный файл небольшой, инструменты, которые он предоставляет, очень практичны:
| Компоненты/Функции | Назначение | Сценарий использования |
|---|---|---|
std::pair |
Хранить два связанных значения | Функции, возвращающие несколько значений, элементы map |
std::make_pair |
Удобное создание пар | Вывод типов шаблонов, упрощающий код |
std::swap |
Обмен двух значений | Реализация алгоритмов, операции сортировки |
std::move |
Включение семантики перемещения | Управление ресурсами, оптимизация производительности |
std::forward |
Идеальная передача | Универсальные ссылки, шаблонное программирование |
Объяснение основных компонентов
std::pair: контейнер пар ключ-значение
std::pairДаutilitypair: наиболее часто используемый компонент библиотеки, используется для объединения двух значений в один объект.
Базовый синтаксис
#include <utility> // 创建 pair 对象的基本方式 std::pair<类型1, 类型2> 变量名(值1, 值2);
Пример
#include <utility>
#include <string>
int main() {
// Способ 1: Прямая инициализация
std::pair<int, std::string> student1(101, "Alice");
// Способ 2: Использование функции make_pair (рекомендуется)
auto student2 = std::make_pair(102, "Bob");
// Способ 3: Руководство по выводу типа поддерживается начиная с C++17
std::pair student3(103, "Charlie");
// Доступ к членам pair
std::cout << "ID студента: " << student1.first << ", Имя: " << student1.second << std::endl;
return 0;
}
Общие операции с pair
Пример
#include <iostream>
void pairOperations() {
// Создать pair
std::pair<int, double> p1(10, 3.14);
std::pair<int, double> p2(20, 2.71);
// Операции сравнения
if (p1 < p2) {
std::cout << "p1 меньше p2" << std::endl;
}
// Операция присваивания
p1 = p2;
// Поэлементное присваивание поддерживается начиная с C++11
int a;
double b;
std::tie(a, b) = p1; // Присвоить значение p1 переменным a и b соответственно
// Структурированное связывание C++17 (более кратко)
auto [x, y] = p1;
std::cout << "x = " << x << ", y = " << y << std::endl;
}
std::make_pair: удобная функция создания
std::make_pairstd::make_pair: шаблонная функция, которая может автоматически выводить типы, упрощая процесс создания пар.
Пример
#include <iostream>
#include <string>
void demonstrateMakePair() {
// Автоматический вывод типов, нет необходимости явно указывать параметры шаблона
auto p1 = std::make_pair(42, "Hello");
auto p2 = std::make_pair(3.14, true);
// Особенно удобно для использования в контейнерах
std::vector<std::pair<int, std::string>> students;
students.push_back(std::make_pair(101, "Alice"));
students.push_back(std::make_pair(102, "Bob"));
for (const auto& student : students) {
std::cout << "Идентификатор студента: " << student.first
<< ", Имя: " << student.second << std::endl;
}
}
Вспомогательные функции
std::swap: обмен двух значений
std::swapИспользуется для обмена значениями двух объектов одного типа.
Пример
#include <iostream>
void demonstrateSwap() {
int a = 10, b = 20;
std::cout << "До обмена: a = " << a << ", b = " << b << std::endl;
std::swap(a, b);
std::cout << "После обмена: a = " << a << ", b = " << b << std::endl;
// Также может использоваться для пользовательских типов (если реализована семантика перемещения)
std::string str1 = "Привет", str2 = "Мир";
std::swap(str1, str2);
std::cout << "Обмен строк: " << str1 << " " << str2 << std::endl;
}
std::move: поддержка семантики перемещения
std::moveИспользуется для преобразования объекта в rvalue-ссылку, что позволяет реализовать семантику перемещения.
Пример
#include <iostream>
#include <vector>
void demonstrateMove() {
std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2;
std::cout << "До перемещения - размер v1: " << v1.size()
<< ", размер v2: " << v2.size() << std::endl;
// Использование семантики перемещения для передачи владения ресурсом
v2 = std::move(v1);
std::cout << "После перемещения - размер v1: " << v1.size()
<< ", размер v2: " << v2.size() << std::endl;
// v1 теперь находится в корректном, но неопределённом состоянии
// Обычно v1 не следует использовать повторно, если только ей не присвоено новое значение
}
std::forward: идеальная пересылка
std::forwardИспользуется для реализации идеальной передачи, сохраняя категорию значения аргументов.
Пример
#include <iostream>
// Обычная функция - не может сохранить категорию значения
template<typename T>
void normalFunction(T arg) {
std::cout << "Параметр обычной функции" << std::endl;
}
// Функция, использующая идеальную передачу
template<typename T>
void perfectForwardingFunction(T&& arg) {
// Сохранить исходную категорию значения параметра (lvalue или rvalue)
normalFunction(std::forward<T>(arg));
}
void demonstrateForward() {
int x = 10;
// Передать lvalue
perfectForwardingFunction(x);
// Передать rvalue
perfectForwardingFunction(20);
}
Утилиты целочисленных последовательностей (C++14)
В C++14 появились утилиты целочисленных последовательностей, в основном используемые для метапрограммирования шаблонов.
std::integer_sequence
Пример
#include <iostream>
// Использовать целочисленную последовательность для вывода каждого значения в последовательности
template<typename T, T... Ints>
void print_sequence(std::integer_sequence<T, Ints...>) {
// Использовать выражение свёртки (C++17) для вывода всех значений
((std::cout << Ints << " "), ...);
std::cout << std::endl;
}
void demonstrateIntegerSequence() {
// Создать целочисленную последовательность
auto seq = std::integer_sequence<int, 1, 2, 3, 4, 5>();
print_sequence(seq);
// Используйте make_integer_sequence для генерации последовательности
auto seq2 = std::make_integer_sequence<int, 5>();
print_sequence(seq2); // Вывод: 0 1 2 3 4
}
Примеры практического применения
Пример 1: Функция, возвращающая несколько значений
Пример
#include <iostream>
#include <cmath>
// Функция возвращает несколько значений: результат вычисления и код ошибки
std::pair<double, bool> calculateSqrt(double number) {
if (number < 0) {
return std::make_pair(0.0, false); // Случай ошибки
}
return std::make_pair(std::sqrt(number), true); // Случай успеха
}
void multipleReturnValues() {
auto result1 = calculateSqrt(16.0);
if (result1.second) {
std::cout << "Квадратный корень: " << result1.first << std::endl;
} else {
std::cout << "Ошибка вычисления: невозможно извлечь квадратный корень из отрицательного числа" << std::endl;
}
auto result2 = calculateSqrt(-4.0);
if (!result2.second) {
std::cout << "Ошибка вычисления: невозможно извлечь квадратный корень из отрицательного числа" << std::endl;
}
}
Случай 2: Применение в контейнерах STL
Пример
#include <map>
#include <iostream>
#include <string>
void mapWithPair() {
// Каждый элемент std::map является std::pair
std::map<int, std::string> studentMap;
// Вставить пару ключ-значение
studentMap.insert(std::make_pair(101, "Alice"));
studentMap.emplace(102, "Bob"); // Более эффективный способ
// Итерация по map
for (const auto& [id, name] : studentMap) {
std::cout << "ID студента: " << id << ", Имя: " << name << std::endl;
}
// Найти элемент
auto it = studentMap.find(101);
if (it != studentMap.end()) {
std::cout << "Найден студент: " << it->second << std::endl;
}
}
Пример 3: Реализация простого словаря
Пример
#include <vector>
#include <iostream>
#include <algorithm>
class SimpleDictionary {
private:
std::vector<std::pair<std::string, std::string>> entries;
public:
void addWord(const std::string& word, const std::string& meaning) {
entries.emplace_back(word, meaning);
}
std::pair<bool, std::string> findMeaning(const std::string& word) {
for (const auto& [w, m] : entries) {
if (w == word) {
return std::make_pair(true, m);
}
}
return std::make_pair(false, "");
}
void printAll() {
for (const auto& [word, meaning] : entries) {
std::cout << word << ": " << meaning << std::endl;
}
}
};
void dictionaryExample() {
SimpleDictionary dict;
dict.addWord("apple", "a fruit");
dict.addWord("book", "an object used for reading");
auto result = dict.findMeaning("apple");
if (result.first) {
std::cout << "Meaning: " << result.second << std::endl;
}
}
Лучшие практики и соображения
1. Используйте auto для упрощения создания pair
Пример
auto student = std::make_pair(101, "Alice");
// Не рекомендуется: явно указывать тип (более многословно)
std::pair<int, std::string> student(101, "Alice");
2. Предпочитайте emplace вместо insert
Пример
// Рекомендуется: используйте emplace (более эффективно)
myMap.emplace(1, "one");
// Не рекомендуется: использовать insert (требует создания временного объекта)
myMap.insert(std::make_pair(1, "one"));
3. Правильное использование семантики перемещения
Пример
std::string str = "a very large string";
// Правильно: используйте move при возврате
return str; // Компилятор автоматически оптимизирует, нет необходимости в явном вызове move
}
void processString(std::string str) {
// Обработка строк
}
void usageExample() {
std::string largeStr = "very large data";
// Правильно: используйте move при передаче
processString(std::move(largeStr));
// Примечание: largeStr больше не следует использовать
}
4. Использование структурированных привязок
Пример
std::pair<int, std::string> getStudent() {
return {101, "Alice"};
}
void structuredBindingExample() {
// Традиционный способ
auto student = getStudent();
int id = student.first;
std::string name = student.second;
// Современный способ (C++17)
auto [id2, name2] = getStudent(); // Более кратко и ясно
}