utility

Header `<utility>`

The <utility> header is part of the C++ Standard Library that provides a collection of utility components. This header contains several useful templates and functions that are widely used in C++ programming. The most notable feature of this header is the std::pair class template, but it also includes other utilities like std::swap, std::move, and std::forward.

Key Characteristics

Defines the std::pair class template for storing two heterogeneous objects as a single unit
Provides std::make_pair function for creating pair objects
Includes std::swap for exchanging values of two objects
Offers std::move and std::forward for supporting move semantics and perfect forwarding
Contains comparison operators for pairs
Provides std::integer_sequence and related utilities (since C++14)
Includes std::piecewise_construct for pair construction

Example 1: Using `std::pair` and `std::make_pair`

#include <utility>
#include <iostream>
#include <string>

int main() {
    // Creating a pair using the constructor
    std::pair<std::string, int> person1("Alice", 30);

    // Creating a pair using make_pair
    auto person2 = std::make_pair("Bob", 25);

    // Accessing pair elements
    std::cout << "Person 1: " << person1.first << ", " << person1.second << " years old" << std::endl;
    std::cout << "Person 2: " << person2.first << ", " << person2.second << " years old" << std::endl;

    // Using structured binding (C++17)
    auto [name, age] = person1;
    std::cout << "Name: " << name << ", Age: " << age << std::endl;

    return 0;
}

Explanation:

We create pairs using both the std::pair constructor and std::make_pair.
Pair elements are accessed using .first and .second.
C++17's structured binding is demonstrated for easy unpacking of pair elements.

Example 2: Using `std::swap` and Custom Swap Functions

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

class MyClass {
public:
    MyClass(int val) : value(val) {}
    int getValue() const { return value; }

    // Custom swap function
    friend void swap(MyClass& a, MyClass& b) noexcept {
        std::cout << "Custom swap called" << std::endl;
        std::swap(a.value, b.value);
    }

private:
    int value;
};

int main() {
    int a = 5, b = 10;
    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
    std::swap(a, b);
    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    std::cout << "Before swap: vec1[0] = " << vec1[0] << ", vec2[0] = " << vec2[0] << std::endl;
    std::swap(vec1, vec2);
    std::cout << "After swap: vec1[0] = " << vec1[0] << ", vec2[0] = " << vec2[0] << std::endl;

    MyClass obj1(100), obj2(200);
    std::cout << "Before swap: obj1 = " << obj1.getValue() << ", obj2 = " << obj2.getValue() << std::endl;
    std::swap(obj1, obj2);
    std::cout << "After swap: obj1 = " << obj1.getValue() << ", obj2 = " << obj2.getValue() << std::endl;

    return 0;
}

Explanation:

std::swap is used to exchange values of built-in types and standard containers.
A custom swap function is defined for MyClass to demonstrate ADL (Argument-Dependent Lookup).
The custom swap is called when std::swap is used on MyClass objects.

Example 3: Move Semantics with `std::move`

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

class Resource {
public:
    Resource(const std::string& s) : data(s) {
        std::cout << "Constructor called for " << data << std::endl;
    }
    Resource(const Resource& other) : data(other.data) {
        std::cout << "Copy constructor called for " << data << std::endl;
    }
    Resource(Resource&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor called for " << data << std::endl;
    }
    ~Resource() {
        std::cout << "Destructor called for " << data << std::endl;
    }

private:
    std::string data;
};

int main() {
    std::vector<Resource> resources;

    std::cout << "Adding Resource without move:" << std::endl;
    Resource r1("Resource 1");
    resources.push_back(r1);

    std::cout << "\nAdding Resource with move:" << std::endl;
    Resource r2("Resource 2");
    resources.push_back(std::move(r2));

    std::cout << "\nEnd of main" << std::endl;
    return 0;
}

Explanation:

We define a Resource class with both copy and move constructors.
std::move is used to invoke the move constructor, avoiding unnecessary copying.
The example demonstrates the difference between copying and moving objects into a vector.

Example 4: Perfect Forwarding with `std::forward`

#include <utility>
#include <iostream>
#include <string>

template<typename T>
void printType(T&& t) {
    std::cout << "T is " << (std::is_lvalue_reference<T>::value ? "lvalue" : "rvalue") << std::endl;
}

template<typename T>
void perfectForward(T&& t) {
    std::cout << "Forwarding: ";
    printType(std::forward<T>(t));
}

int main() {
    int x = 10;
    const int cx = 20;

    std::cout << "Forwarding lvalue:" << std::endl;
    perfectForward(x);

    std::cout << "Forwarding const lvalue:" << std::endl;
    perfectForward(cx);

    std::cout << "Forwarding rvalue:" << std::endl;
    perfectForward(5);

    std::cout << "Forwarding string literal:" << std::endl;
    perfectForward("hello");

    return 0;
}

Explanation:

std::forward is used to implement perfect forwarding in template functions.
It preserves the value category (lvalue or rvalue) of the forwarded argument.
The example shows how different types of arguments are forwarded correctly.

Example 5: Using `std::integer_sequence`

#include <utility>
#include <iostream>
#include <array>

template<typename T, T... Ints>
void printSequence(std::integer_sequence<T, Ints...> int_seq) {
    std::cout << "Sequence size: " << int_seq.size() << std::endl;
    std::cout << "Values: ";
    ((std::cout << Ints << ' '), ...);
    std::cout << std::endl;
}

template<typename T, std::size_t N, std::size_t... I>
void printArrayImpl(const std::array<T, N>& arr, std::index_sequence<I...>) {
    ((std::cout << arr[I] << ' '), ...);
    std::cout << std::endl;
}

template<typename T, std::size_t N>
void printArray(const std::array<T, N>& arr) {
    printArrayImpl(arr, std::make_index_sequence<N>{});
}

int main() {
    printSequence(std::integer_sequence<int, 1, 2, 3, 4, 5>{});
    printSequence(std::make_integer_sequence<int, 5>{});
    printSequence(std::make_index_sequence<5>{});

    std::array<int, 5> arr = {10, 20, 30, 40, 50};
    std::cout << "Array contents: ";
    printArray(arr);

    return 0;
}

Explanation:

std::integer_sequence is used to create compile-time integer sequences.
std::make_integer_sequence and std::make_index_sequence are utility functions to create sequences.
We demonstrate how to use these sequences for template metaprogramming and array manipulation.

Additional Considerations

Move Semantics: std::move doesn't actually move anything; it casts its argument to an rvalue reference, enabling move semantics.
Perfect Forwarding: std::forward is crucial for implementing perfect forwarding in template functions, preserving value categories.
Pair Comparison: <utility> provides comparison operators for pairs, which compare first elements and then second elements.
C++17 Additions: C++17 added std::as_const for obtaining a const reference to an object.
Performance: Using std::move and std::forward correctly can lead to significant performance improvements by avoiding unnecessary copies.

Summary

The <utility> header in C++ provides a collection of utility components that are fundamental to many C++ programming tasks:

std::pair and std::make_pair for creating and manipulating pairs of values.
std::swap for efficiently exchanging values between objects.
std::move for enabling move semantics, crucial for optimizing resource management.
std::forward for implementing perfect forwarding in template functions.
std::integer_sequence and related utilities for compile-time integer sequences.

These utilities are essential for modern C++ programming, enabling efficient and flexible code. They are particularly important in template metaprogramming, optimizing resource management, and implementing generic algorithms.

The components in <utility> are designed to work seamlessly with other parts of the C++ Standard Library, making them invaluable tools in a C++ programmer's toolkit. Understanding and correctly using these utilities can lead to more efficient, expressive, and maintainable code.

What are the main functions provided by the include file
How does the include file enhance C++ programming
What are the common use cases for the library
How can the include file be used to simplify code
What are the differences between and in C++

Previous Page | Course Schedule | Course Content

utility

Header <utility>

Key Characteristics

Example 1: Using std::pair and std::make_pair

Explanation:

Example 2: Using std::swap and Custom Swap Functions

Explanation:

Example 3: Move Semantics with std::move

Explanation:

Example 4: Perfect Forwarding with std::forward

Explanation:

Example 5: Using std::integer_sequence

Explanation:

Additional Considerations

Summary

Related

Header `<utility>`

Example 1: Using `std::pair` and `std::make_pair`

Example 2: Using `std::swap` and Custom Swap Functions

Example 3: Move Semantics with `std::move`

Example 4: Perfect Forwarding with `std::forward`

Example 5: Using `std::integer_sequence`