c++ std::swap

std::swap 是 C++ 标准库中的一个函数模板，用于交换两个变量的值。它的定义位于 <algorithm> 头文件中。

std::swap 有多个重载版本，可以用于不同类型的变量交换操作。基本用法如下：

#include <algorithm>

int main() {
    int a = 10;
    int b = 20;
    
    std::swap(a, b);
    
    // 现在 a 的值为 20，b 的值为 10
    return 0;
}

在这个例子中，我们使用 std::swap 来交换变量 a 和 b 的值。

需要注意的是，std::swap 是一个模板函数，它可以接受任意类型的参数。对于自定义类型，需要提供相应的交换操作，或者重载 std::swap 函数来适配该类型。

相关问题

C++ std::队列

C++ 中的 std::queue 是一个容器适配器，它是基于 deque 实现的队列。它提供了一组函数来实现队列的基本操作，如 push()、pop()、front()、back() 和 empty() 等。其中，push() 函数用于将元素插入队列的尾部，pop() 函数用于删除队列的头部元素，front() 函数用于返回队列头部元素的引用，back() 函数用于返回队列尾部元素的引用，empty() 函数用于判断队列是否为空。C++ 的 std::queue 还提供了一些其他的函数，如 size()、swap() 等。使用 std::queue 需要包含头文件 <queue>。

C++ std::option 使用

在 C++11 中，没有类似于 Rust 中 `std::option` 的标准库类型。但是 C++17 引入了 `std::optional` 类型，它的用法很类似于 Rust 中的 `std::option`。

`std::optional` 也表示一个值可能存在或者不存在的情况。它的定义如下：

template< class T >
class optional {
public:
    // 构造函数
    constexpr optional() noexcept;
    constexpr optional( nullopt_t ) noexcept;
    constexpr optional( const optional& other );
    constexpr optional( optional&& other ) noexcept( std::is_nothrow_move_constructible_v<T> );
    template< class... Args > requires std::is_constructible_v<T, Args...>
    constexpr explicit optional( std::in_place_t, Args&&... args );
    template< class U, class... Args > requires std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>
    constexpr explicit optional( std::in_place_t, std::initializer_list<U> ilist, Args&&... args );
    template< class U = T > requires std::is_copy_constructible_v<T> && std::is_convertible_v<const U&, T>
    constexpr optional( const U& value );
    template< class U = T > requires std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>
    constexpr optional( U&& value );
    template< class U > requires std::is_constructible_v<T, std::initializer_list<U>&>
    constexpr optional( std::initializer_list<U> ilist );
    
    // 成员函数
    constexpr T* operator->();
    constexpr const T* operator->() const;
    constexpr T& operator*();
    constexpr const T& operator*() const;
    constexpr explicit operator bool() const noexcept;
    constexpr T& value();
    constexpr const T& value() const;
    template< class U > constexpr T value_or( U&& default_value ) const&;
    template< class U > constexpr T value_or( U&& default_value ) &&;
    void reset() noexcept;
    template< class... Args > requires std::is_constructible_v<T, Args&&...>
    T& emplace( Args&&... args );
    template< class U, class... Args > requires std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>
    T& emplace( std::initializer_list<U> ilist, Args&&... args );
    void swap( optional& other ) noexcept( std::is_nothrow_move_constructible_v<T>&& noexcept(std::swap( std::declval<T&>(), std::declval<T&>() ) ) );
};

其中，`T` 是可能存在的值的类型。如果可能存在的值存在，那么 `optional` 对象就包含这个值；如果可能存在的值不存在，那么 `optional` 对象为空。

`std::optional` 提供了一些方法来处理可能存在的值。例如，可以使用 `value()` 方法获取可能存在的值，如果对象为空则会抛出 `std::bad_optional_access` 异常。也可以使用 `value_or()` 方法获取可能存在的值，如果对象为空则返回一个默认值。还可以使用 `has_value()` 方法来判断一个值是否存在。

例如，下面的代码演示了如何使用 `std::optional`：

#include <iostream>
#include <optional>

int main() {
    std::optional<int> x = 5;
    std::optional<int> y = std::nullopt;

    std::cout << "x is " << *x << std::endl; // 输出 x is 5
    std::cout << "y is " << y.value_or(0) << std::endl; // 输出 y is 0

    if (x.has_value()) {
        std::cout << "x has value" << std::endl; // 输出 x has value
    }

    if (!y.has_value()) {
        std::cout << "y does not have value" << std::endl; // 输出 y does not have value
    }

    return 0;
}