【C++之STL】015序列容器篇forward_list非更易型操作

c.empyt()

在C++标准库中，std::forward_list是一个单向链表容器，它提供了一系列成员函数来操作链表。其中，empty()是std::forward_list的一个成员函数，用于检查链表是否为空。

empty()函数的声明如下：

bool empty() const;

这个函数返回一个布尔值，如果std::forward_list中没有任何元素，即链表为空，则返回true；如果链表至少包含一个元素，则返回false。

下面是一个简单的示例，展示了如何使用empty()函数：

#include <iostream>
#include <forward_list>

int main() {
    // 创建一个空的forward_list
    std::forward_list<int> empty_list;

    // 检查链表是否为空
    if (empty_list.empty()) {
        std::cout << "The list is empty." << std::endl;
    } else {
        std::cout << "The list is not empty." << std::endl;
    }

    // 向链表添加元素
    empty_list.push_front(1);

    // 再次检查链表是否为空
    if (empty_list.empty()) {
        std::cout << "The list is still empty." << std::endl;
    } else {
        std::cout << "The list is now not empty." << std::endl;
    }

    return 0;
}

输出

The list is empty.
The list is now not empty.

在上面的示例中，我们首先创建了一个空的std::forward_list，然后使用empty()函数检查它是否为空，输出结果为"The list is empty.“。接着，我们向链表中添加了一个元素，并再次使用empty()函数检查链表，这次输出结果为"The list is now not empty.”，因为链表现在包含至少一个元素。

c.size()

在C++中，std::forward_list 是一个单向链表容器。它提供了对链表的基本操作，如插入、删除和遍历等。

要获取 std::forward_list 的大小（即其中元素的数量），你可以使用 size 成员函数。这个函数返回一个 size_t 类型的值，表示链表中当前元素的数量。

下面是一个简单的示例，展示了如何使用 size 成员函数来获取 std::forward_list 的大小：

#include <iostream>
#include <forward_list>

int main() {
    // 创建一个 forward_list 并添加一些元素
    std::forward_list<int> myList = {1, 2, 3, 4, 5};

    // 使用 size 函数获取 forward_list 的大小
    size_t size = myList.size();

    // 输出 forward_list 的大小
    std::cout << "Size of the forward_list: " << size << std::endl;

    return 0;
}

在这个示例中，myList 是一个包含5个元素的 std::forward_list。因此，myList.size() 将返回 5，并且程序将输出 “Size of the forward_list: 5”。

请注意，std::forward_list 是一个单向链表，因此其 size 操作可能需要遍历整个链表来计算元素数量，这可能会导致线性时间复杂度。对于需要频繁访问元素数量的场景，使用 std::vector 或 std::list 等其他容器可能会更加高效。

c.max_szie()

在C++11中，std::forward_list是一个双向链表容器，它提供了在链表中进行高效插入和删除操作的能力。std::forward_list中的max_size成员函数用于返回容器可以容纳的最大元素数量。

max_size函数返回一个size_t类型的值，该值表示容器可以容纳的最大元素数量。对于std::forward_list来说，max_size通常返回一个非常大的数，因为链表容器的大小只受限于可用内存的大小。

以下是std::forward_list中max_size函数的示例用法：

#include <iostream>
#include <forward_list>

int main() {
    std::forward_list<int> myList;
    
    // 获取容器的最大容量
    size_t maxSize = myList.max_size();
    
    std::cout << "Maximum size of the forward_list: " << maxSize << std::endl;
    
    return 0;
}

在上面的示例中，我们创建了一个空的std::forward_list容器，并使用max_size函数获取其最大容量，并将其打印到控制台上。请注意，由于max_size返回的是一个非常大的数，因此在实际使用中，我们通常不会受到这个限制。

c.assign

std::forward_list的assign成员函数用于给链表分配特定数量的元素，每个元素都具有指定的值。这个函数有几种重载形式，允许你以不同的方式指定要分配的元素。

以下是std::forward_list::assign的一些常见用法：

分配指定数量的相同元素

你可以使用单个值来调用assign，这将为链表分配指定数量的具有该值的元素。

std::forward_list<int> myList;
int value = 42;
size_t count = 5;

myList.assign(count, value);
// 现在myList包含5个元素，每个元素的值都是42

从另一个容器复制元素

你也可以使用另一个容器的迭代器来调用assign，这将复制从起始迭代器到结束迭代器之间的所有元素到链表中。

std::vector<int> vec = {1, 2, 3, 4, 5};
std::forward_list<int> myList;

myList.assign(vec.begin(), vec.end());
// 现在myList包含与vec相同的元素：1, 2, 3, 4, 5

使用初始化列表

你也可以使用C++11的初始化列表来调用assign。

std::forward_list<int> myList;

myList.assign({1, 2, 3, 4, 5});
// 现在myList包含元素：1, 2, 3, 4, 5

请注意，调用assign将清除链表中的所有现有元素，并用新的元素替换它们。如果你想在链表的末尾添加元素而不是替换现有元素，你应该使用push_front、push_back、emplace_front或emplace_back等成员函数。

此外，assign函数的时间复杂度是线性的，因为它需要遍历所有要分配的元素。因此，对于大型容器，这可能会是一个相对昂贵的操作。

c1.swap(c2)

std::forward_list 是 C++ 标准库中的一个双向链表容器。swap() 成员函数是 std::forward_list 提供的一个成员函数，用于交换两个 forward_list 容器的元素。

函数原型如下：

void swap(forward_list& other) noexcept;

这个函数会将调用它的 forward_list 容器与参数 other 所代表的 forward_list 容器的元素进行交换。

这个函数是 noexcept 的，意味着它不会抛出异常。在交换两个 forward_list 容器时，它仅仅交换了内部指针，所以操作非常快。

使用示例：

#include <iostream>
#include <forward_list>

int main() {
    std::forward_list<int> list1 = {1, 2, 3, 4, 5};
    std::forward_list<int> list2 = {6, 7, 8, 9, 10};

    std::cout << "Before swap:" << std::endl;
    for (int num : list1) std::cout << num << " ";
    std::cout << std::endl;
    for (int num : list2) std::cout << num << " ";
    std::cout << std::endl;

    list1.swap(list2);

    std::cout << "After swap:" << std::endl;
    for (int num : list1) std::cout << num << " ";
    std::cout << std::endl;
    for (int num : list2) std::cout << num << " ";
    std::cout << std::endl;

    return 0;
}

输出：

mathematica
Before swap:
1 2 3 4 5 
6 7 8 9 10 
After swap:
6 7 8 9 10 
1 2 3 4 5

如你所见，swap() 函数成功地交换了两个 forward_list 容器的元素。

c.front()

返回第一个元素

c.begin()

返回一个迭代器，指向第一个元素

c.end()

返回一个迭代器，指向最后一个元素的下一个位置

c.cbegin()

返回一个常量的迭代器，指向第一个元素

c.cend()

返回一个常量的迭代器，指向最后一个元素的下一个位置

c.before_begin()

返回一个迭代器，指向第一个元素的前一个位置

c.cbefore_begin()

返回一个常量的迭代器