【C++之STL】009序列容器篇deque更易型操作

熊猫Devin

于 2024-04-10 21:25:25 发布

阅读量687

点赞数 25

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/d710055071/article/details/137611733

版权

C++ 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

文章目录

c.assign
c1.swap(c2)
swap(c1,c2)
c.push_back(elem)
c.pop_back()
c.push_front()
c.pop_front()
c.insert()
c.emplace(pos,args...)
c.emplace_back(args...)
c.emplace_front(args...)
c.erase()
c.resize()
c.clear()

c.assign

在C++的std::deque容器中，assign成员函数用于替换容器中的元素。这个函数有三种常见的用法：

assign(n, elem): 此方法将deque的大小调整为n，并用elem填充新元素。如果n小于当前deque的大小，则删除多余的元素。如果n大于当前deque的大小，则在末尾添加新元素。
assign(beg, end): 此方法将deque的大小调整为[beg, end)范围内的元素数量，并用这个范围内的元素填充deque。beg和end是迭代器，它们定义了要复制的元素范围。
assign(initlist): 此方法使用初始化列表initlist中的元素来替换deque中的元素。initlist可以是一个大括号包围的元素列表，这些元素将用来填充整个deque。

下面是一些使用assign函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5}; // 初始化为1, 2, 3, 4, 5

    // 使用assign替换所有元素为7，并设置deque的大小为3
    myDeque.assign(3, 7);
    // 输出: 7 7 7
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用assign复制另一个容器的元素
    std::deque<int> anotherDeque = {10, 20, 30};
    myDeque.assign(anotherDeque.begin(), anotherDeque.end());
    // 输出: 10 20 30
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用assign和初始化列表替换元素
    myDeque.assign({40, 50, 60, 70});
    // 输出: 40 50 60 70
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先使用assign(3, 7)将myDeque替换为3个值为7的元素。然后，我们使用assign(anotherDeque.begin(), anotherDeque.end())将myDeque替换为anotherDeque中的元素。最后，我们使用assign和初始化列表{40, 50, 60, 70}来替换myDeque中的所有元素。

c1.swap(c2)

在C++中，std::deque（双端队列）容器提供了一个成员函数 swap，它用于交换两个 deque 容器的内容。swap 函数是一个高效的操作，通常只交换两个容器内部的指针或迭代器，而不是逐个交换元素。因此，它的时间复杂度通常是常数时间，即 O(1)。

下面是一个使用 swap 函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> c1 = {1, 2, 3};
    std::deque<int> c2 = {4, 5, 6};

    // 输出交换前的deque
    std::cout << "Before swap:" << std::endl;
    std::cout << "c1: ";
    for (int elem : c1) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;
    std::cout << "c2: ";
    for (int elem : c2) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用swap函数交换两个deque的内容
    c1.swap(c2);

    // 输出交换后的deque
    std::cout << "After swap:" << std::endl;
    std::cout << "c1: ";
    for (int elem : c1) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;
    std::cout << "c2: ";
    for (int elem : c2) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，c1 初始化为 {1, 2, 3}，c2 初始化为 {4, 5, 6}。调用 c1.swap(c2) 之后，c1 的内容变成了 {4, 5, 6}，而 c2 的内容变成了 {1, 2, 3}。

使用 swap 函数可以在不引入临时变量的情况下交换两个容器的内容，这通常比逐个元素交换更高效。因此，当你需要交换两个容器时，应该优先使用 swap 函数。

swap(c1,c2)

在C++中，std::deque（双端队列）容器并没有提供直接接受两个deque对象作为参数的swap函数。相反，swap函数是deque类的成员函数，用于交换当前deque对象与另一个deque对象的内容。要交换两个deque对象c1和c2，你需要分别调用它们的swap成员函数，如下所示：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> c1 = {1, 2, 3};
    std::deque<int> c2 = {4, 5, 6};

    // 输出交换前的deque
    std::cout << "Before swap:" << std::endl;
    std::cout << "c1: ";
    for (int elem : c1) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;
    std::cout << "c2: ";
    for (int elem : c2) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用成员函数swap交换两个deque的内容
    c1.swap(c2);

    // 输出交换后的deque
    std::cout << "After swap:" << std::endl;
    std::cout << "c1: ";
    for (int elem : c1) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;
    std::cout << "c2: ";
    for (int elem : c2) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，c1和c2是两个不同的deque对象。通过调用c1.swap(c2)，我们交换了c1和c2的内容。在交换之后，c1包含了原本属于c2的元素，而c2包含了原本属于c1的元素。

需要注意的是，swap操作通常是一个常数时间复杂度（O(1)）的操作，因为它只是交换两个对象的内部指针或迭代器，而不是逐个交换元素。因此，使用swap来交换两个容器通常比使用赋值操作更高效。

c.push_back(elem)

在C++中，push_back是std::deque（双端队列）容器的一个成员函数，用于在容器的尾部添加一个元素。push_back将元素添加到deque的末尾，类似于在一个队列的末尾添加元素。

下面是一个使用push_back函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque;

    // 使用push_back添加元素到deque的尾部
    myDeque.push_back(1);
    myDeque.push_back(2);
    myDeque.push_back(3);

    // 输出deque的内容
    std::cout << "The deque contains: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们创建了一个名为myDeque的空std::deque对象，然后使用push_back函数向其中添加了三个整数。最后，我们使用范围基础的for循环遍历deque并输出其内容。

push_back函数的时间复杂度通常是常数时间，即O(1)，因为它只是在deque的尾部添加元素，不需要移动其他元素。这使得std::deque在需要频繁在尾部添加或删除元素时非常高效。

c.pop_back()

在C++中，pop_back是std::deque（双端队列）容器的一个成员函数，用于删除容器尾部的最后一个元素。这个函数不需要任何参数，并且它修改容器，使其大小减少1。

下面是一个使用pop_back函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 输出deque的初始内容
    std::cout << "Initial deque: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用pop_back删除尾部的元素
    myDeque.pop_back();

    // 输出deque的当前内容
    std::cout << "Deque after pop_back: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先创建了一个包含5个整数的std::deque对象myDeque。然后，我们使用pop_back函数删除了尾部的元素（在这个例子中是5）。最后，我们输出deque的当前内容，可以看到最后一个元素已经被删除。

pop_back函数的时间复杂度通常是常数时间，即O(1)，因为它只是简单地删除尾部元素，不需要移动其他元素。这使得std::deque在需要频繁在尾部删除元素时非常高效。然而，如果deque是空的，调用pop_back将会导致未定义行为，因此在调用pop_back之前，通常应该检查deque是否为空，可以通过empty成员函数来完成这个检查。

c.push_front()

在C++中，push_front是std::deque（双端队列）容器的一个成员函数，用于在容器的开头添加一个元素。push_front将元素添加到deque的起始位置，类似于在一个队列的开头添加元素。

下面是一个使用push_front函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque;

    // 使用push_front添加元素到deque的开头
    myDeque.push_front(3);
    myDeque.push_front(2);
    myDeque.push_front(1);

    // 输出deque的内容
    std::cout << "The deque contains: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们创建了一个名为myDeque的空std::deque对象，然后使用push_front函数向其中添加了三个整数。注意，元素是按照相反的顺序添加到deque中的，因为push_front总是在deque的开头添加元素。最后，我们使用范围基础的for循环遍历deque并输出其内容。

push_front函数的时间复杂度通常是常数时间，即O(1)，因为std::deque被设计为在头部和尾部添加或删除元素时具有高效的性能。这是通过存储指向其内部元素的指针或迭代器来实现的，因此不需要移动其他元素来插入新元素。

在实际应用中，std::deque的push_front和push_back函数使得它在实现需要频繁在两端添加或删除元素的算法时非常有用，例如在某些类型的队列或双端队列算法中。

c.pop_front()

在C++中，pop_front是std::deque（双端队列）容器的一个成员函数，用于删除容器开头的元素。换句话说，它移除deque的第一个元素。

下面是一个使用pop_front函数的例子：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 输出初始的deque
    std::cout << "Initial deque: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    // 使用pop_front删除deque的第一个元素
    myDeque.pop_front();

    // 输出pop_front后的deque
    std::cout << "Deque after pop_front: ";
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先创建了一个包含五个元素的deque对象myDeque。然后，我们使用pop_front函数删除了deque的第一个元素（即数字1）。最后，我们再次遍历deque并输出其内容，以显示pop_front操作后的结果。

pop_front函数的时间复杂度也是常数时间，即O(1)，因为deque内部是通过分段连续存储来实现的，允许在头部和尾部添加或删除元素时保持高效。

请注意，如果deque是空的，调用pop_front将导致未定义的行为。因此，在调用pop_front之前，通常需要检查deque是否为空，这可以通过empty成员函数来实现。例如：

if (!myDeque.empty()) {
    myDeque.pop_front();
}

c.insert()

在C++的std::deque（双端队列）容器中，insert函数用于在指定位置插入一个或多个元素。这个函数有几种重载形式，以适应不同的插入需求。

c.insert(pos, elem)

这个版本的insert函数在deque的pos位置插入一个elem的副本。pos是一个迭代器，指向deque中你希望插入新元素的位置。

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 在位置2（即第三个元素之前）插入元素10
    myDeque.insert(myDeque.begin() + 2, 10);

    // 输出deque的内容
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

输出将会是：1 2 10 3 4 5

c.insert(pos, n, elem)

这个版本的insert函数在deque的pos位置插入n个elem的副本。n是你要插入的元素数量，elem是要插入的元素值。

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 在位置2（即第三个元素之前）插入3个元素10
    myDeque.insert(myDeque.begin() + 2, 3, 10);

    // 输出deque的内容
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

输出将会是：1 2 10 10 10 3 4 5

c.insert(pos, initlist)

这个版本的insert函数在deque的pos位置插入一个由initlist初始化的元素序列。initlist可以是一个初始化列表、数组或另一个容器。

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};
    std::deque<int> toInsert = {10, 11, 12};

    // 在位置2（即第三个元素之前）插入toInsert的元素
    myDeque.insert(myDeque.begin() + 2, toInsert.begin(), toInsert.end());

    // 输出deque的内容
    for (int elem : myDeque) {
        std::cout << elem << ' ';
    }
    std::cout << std::endl;

    return 0;
}

输出将会是：1 2 10 11 12 3 4 5

在使用insert函数时，需要确保pos指向的位置是有效的，即它不应该超出deque的范围。否则，程序将触发未定义行为。同样，如果deque的大小在插入后超过了其最大大小限制，也会发生未定义行为。在大多数情况下，deque的大小只受限于可用内存的大小。

c.emplace(pos,args…)

在C++中，emplace是std::deque（双端队列）容器的一个成员函数，用于在指定位置pos构造并插入一个元素。与insert函数不同，emplace直接在deque内部构造元素，避免了额外的拷贝或移动操作，这通常可以提高性能。

emplace函数的参数args…是传递给元素构造函数的参数，这些参数用于在deque中直接构造新元素。这意味着你可以使用emplace来避免不必要的拷贝，尤其是当元素类型涉及大量数据或复杂构造逻辑时。

下面是一个使用emplace函数的例子：

#include <iostream>
#include <deque>

struct MyData {
    int x;
    std::string s;

    MyData(int val, const std::string& str) : x(val), s(str) {
        std::cout << "Constructing MyData with " << val << " and " << str << std::endl;
    }

    MyData(const MyData& other) {
        x = other.x;
        s = other.s;
        std::cout << "Copying MyData" << std::endl;
    }

    MyData(MyData&& other) noexcept {
        x = other.x;
        s = std::move(other.s);
        other.s.clear();
        std::cout << "Moving MyData" << std::endl;
    }
};

int main() {
    std::deque<MyData> myDeque;

    // 使用emplace在deque的末尾构造并插入一个MyData对象
    myDeque.emplace_back(10, "Hello");

    // 使用emplace在deque的指定位置构造并插入一个MyData对象
    myDeque.emplace(myDeque.begin(), 20, "World");

    // 输出deque的内容
    for (const auto& elem : myDeque) {
        std::cout << "x: " << elem.x << ", s: " << elem.s << std::endl;
    }

    return 0;
}

在这个例子中，我们定义了一个MyData结构体，它有一个构造函数和两个拷贝构造函数（一个普通的，一个移动拷贝的）。当使用emplace_back或emplace时，会调用MyData的构造函数来直接构造元素，而不是先创建一个临时对象再进行拷贝或移动。

在main函数中，我们首先使用emplace_back在deque的末尾构造并插入一个MyData对象。然后，我们使用emplace在deque的开始位置构造并插入另一个MyData对象。注意，我们没有看到任何"Copying MyData"或"Moving MyData"的输出，因为emplace直接构造了元素。

emplace函数有多个重载版本，可以接受不同的迭代器位置和参数列表，以适应在deque的不同位置构造和插入元素的需求。

c.emplace_back(args…)

在C++中，emplace_back是std::deque（双端队列）容器的一个成员函数，用于在容器的尾部直接构造并添加一个元素。emplace_back函数接受与元素构造函数相同的参数，这些参数被用来在deque的尾部直接构造新元素，从而避免了额外的拷贝或移动操作。

使用emplace_back通常比使用push_back更加高效，特别是当元素类型涉及大量数据或复杂构造逻辑时。push_back通常需要创建一个临时对象，然后再将其拷贝或移动到deque中，而emplace_back则直接在deque的尾部构造元素。

下面是一个使用emplace_back的例子：

#include <iostream>
#include <deque>

struct MyData {
    int x;
    std::string s;

    MyData(int val, const std::string& str) : x(val), s(str) {
        std::cout << "Constructing MyData with " << val << " and " << str << std::endl;
    }

    // 拷贝构造函数和移动构造函数（如果需要的话）
    // ...
};

int main() {
    std::deque<MyData> myDeque;

    // 使用emplace_back在deque的尾部构造并插入一个MyData对象
    myDeque.emplace_back(10, "Hello");

    // 输出deque的内容
    for (const auto& elem : myDeque) {
        std::cout << "x: " << elem.x << ", s: " << elem.s << std::endl;
    }

    return 0;
}

在这个例子中，MyData是一个结构体，它有一个构造函数，用于接收两个参数来初始化其成员变量。当我们调用emplace_back时，我们传递与MyData构造函数相同的参数，deque容器会在其尾部直接构造一个MyData对象，而不需要先创建一个临时对象再进行拷贝或移动。

输出将会是：

Constructing MyData with 10 and Hello
x: 10, s: Hello

你可以看到只调用了一次构造函数，这表明MyData对象是在deque内部直接构造的，而不是先在其他地方构造然后再移动或拷贝到deque中。

c.emplace_front(args…)

在C++中，emplace_front是std::deque（双端队列）容器的一个成员函数，用于在容器的开头直接构造并插入一个元素。与push_front函数不同，emplace_front避免了不必要的拷贝或移动操作，因为它直接在deque的开头构造新元素。

emplace_front函数接受与元素构造函数相同的参数args…，这些参数被用来在deque的开头直接构造新元素。这通常比使用push_front更加高效，特别是当元素类型涉及大量数据或复杂构造逻辑时。

下面是一个使用emplace_front的例子：

#include <iostream>
#include <deque>

struct MyData {
    int x;
    std::string s;

    MyData(int val, const std::string& str) : x(val), s(str) {
        std::cout << "Constructing MyData at the front with " << val << " and " << str << std::endl;
    }

    // 拷贝构造函数和移动构造函数（如果需要的话）
    // ...
};

int main() {
    std::deque<MyData> myDeque;

    // 使用emplace_front在deque的开头构造并插入一个MyData对象
    myDeque.emplace_front(10, "Hello");

    // 输出deque的内容
    for (const auto& elem : myDeque) {
        std::cout << "x: " << elem.x << ", s: " << elem.s << std::endl;
    }

    return 0;
}

在这个例子中，MyData是一个结构体，它有一个构造函数，用于接收两个参数来初始化其成员变量。当我们调用emplace_front时，我们传递与MyData构造函数相同的参数，deque容器会在其开头直接构造一个MyData对象，而不需要先创建一个临时对象再进行拷贝或移动。

输出将会是：

Constructing MyData at the front with 10 and Hello
x: 10, s: Hello

你可以看到只调用了一次构造函数，这表明MyData对象是在deque内部直接构造的，而不是先在其他地方构造然后再移动或拷贝到deque中。此外，注意构造函数的输出表明元素是在deque的开头构造的。

c.erase()

在C++的std::deque（双端队列）容器中，erase是一个成员函数，用于删除一个或多个元素。这个函数有两种形式：

c.erase(pos)：删除位于pos位置的单个元素。
c.erase(beg, end)：删除从beg到end（不包括end）之间的所有元素。

c.erase(pos)

当你调用c.erase(pos)时，deque容器会删除位于pos位置的元素，并将后续元素向前移动以填补空缺。pos是一个迭代器，指向要删除的元素。

示例：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 删除位于位置2的元素（即值为3的元素）
    myDeque.erase(myDeque.begin() + 2);

    // 输出剩余元素
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }

    return 0;
}

输出：

1 2 4 5

c.erase(beg, end)

当你调用c.erase(beg, end)时，deque容器会删除从beg到end之间的所有元素（不包括end指向的元素）。beg和end都是迭代器，分别指向要删除范围的起始和结束位置。

示例：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 删除从位置1到位置3的元素（即值为2和3的元素）
    myDeque.erase(myDeque.begin() + 1, myDeque.begin() + 3);

    // 输出剩余元素
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }

    return 0;
}

输出：

1 4 5

在这两个例子中，你都可以看到deque容器中的元素在删除操作后是如何重新排列的。请注意，erase操作可能会使指向容器的迭代器、引用和指针失效，因此在调用erase之后，你应该避免使用这些可能已经失效的迭代器、引用和指针。

c.resize()

在C++的std::deque（双端队列）容器中，resize是一个成员函数，用于改变容器的大小。它有两种形式：

c.resize(num)：将容器c的大小调整为num个元素。如果num大于当前容器的大小，容器将在尾部添加新元素（使用其默认构造函数创建）。如果num小于当前容器的大小，容器将删除尾部的元素。
c.resize(num, elem)：将容器c的大小调整为num个元素。如果num大于当前容器的大小，容器将在尾部添加新元素，每个新元素都将被初始化为elem。如果num小于当前容器的大小，容器将删除尾部的元素。

这里有一个简单的例子，演示了如何使用resize函数：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3};

    // 输出原始deque
    std::cout << "Original deque: ";
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 使用resize调整大小，不指定新元素的值
    myDeque.resize(5);
    std::cout << "After resize(5): ";
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 使用resize调整大小，并指定新元素的值
    myDeque.resize(7, 100);
    std::cout << "After resize(7, 100): ";
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出将是：

Original deque: 1 2 3 
After resize(5): 1 2 3 0 0 
After resize(7, 100): 1 2 3 0 0 100 100

在这个例子中，我们首先创建了一个包含三个元素的deque。然后，我们调用resize(5)来增加容器的大小到五个元素。由于我们没有为新元素提供值，因此新添加的元素将被初始化为int类型的默认值（在这种情况下是0）。最后，我们调用resize(7, 100)来进一步增加容器的大小到七个元素，并指定新元素的值为100。

c.clear()

在C++的std::deque（双端队列）容器中，clear是一个成员函数，用于删除容器中的所有元素。调用clear函数后，deque的大小将变为0，即它不会包含任何元素。

这里是如何使用clear函数的简单示例：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque = {1, 2, 3, 4, 5};

    // 输出原始deque
    std::cout << "Original deque: ";
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 使用clear删除所有元素
    myDeque.clear();

    // 输出清除后的deque
    std::cout << "Deque after clear: ";
    for (int elem : myDeque) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

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

    return 0;
}

输出将是：

Original deque: 1 2 3 4 5 
Deque after clear: 
The deque is empty.

在这个例子中，我们首先创建了一个包含五个元素的deque。然后，我们调用clear函数来删除所有元素。在调用clear之后，我们尝试遍历deque来输出其元素，但由于它现在是空的，因此不会输出任何内容。最后，我们检查deque是否为空，并输出相应的消息。

请注意，调用clear函数后，任何指向deque中元素的迭代器、引用和指针都将变得无效。因此，在调用clear之后，你应该避免使用这些可能已经失效的迭代器、引用和指针。

熊猫Devin

关注

25
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++之STL】009序列容器篇deque更易型操作

然而，如果deque是空的，调用pop_back将会导致未定义行为，因此在调用pop_back之前，通常应该检查deque是否为空，可以通过empty成员函数来完成这个检查。在C++中，emplace_back是std::deque（双端队列）容器的一个成员函数，用于在容器的尾部直接构造并添加一个元素。在C++中，emplace_front是std::deque（双端队列）容器的一个成员函数，用于在容器的开头直接构造并插入一个元素。最后，我们输出deque的当前内容，可以看到最后一个元素已经被删除。
复制链接

扫一扫