Стандартная библиотека 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 <iostream>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 <utility>
#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 и make_pair
auto student = std::make_pair(101, "Alice");

// Не рекомендуется: явно указывать тип (более многословно)
std::pair<int, std::string> student(101, "Alice");

2. Предпочитайте emplace вместо insert

Пример

std::map<int, std::string> myMap;

// Рекомендуется: используйте emplace (более эффективно)
myMap.emplace(1, "one");

// Не рекомендуется: использовать insert (требует создания временного объекта)
myMap.insert(std::make_pair(1, "one"));

3. Правильное использование семантики перемещения

Пример

std::string createString() {
    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. Использование структурированных привязок

Пример

// Структурированные привязки поддерживаются начиная с C++17
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();  // Более кратко и ясно
}
Другие расширения