[转载] C++ STL中判断list为空，size()==0和empty()有什么区别

最新推荐文章于 2024-07-15 03:21:47 发布
最新推荐文章于 2024-07-15 03:21:47 发布
阅读量414 收藏
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：http://www.cnblogs.com/pjl1119/p/8892318.html
版权

关于两个的区别，首先size()==0为bool表达式，empty()为函数调用，这一点很明显。查看源代码，

    bool empty() const { return _M_node->_M_next == _M_node; }  

    size_type size() const {  
      size_type __result = 0;  
      distance(begin(), end(), __result);  
      return __result;  
    }

 

可以看出empty直接检查标记节点，而size是通过求首尾迭代器的距离来获取元素个数的。

查看的源代码来自http://www.sgi.com/tech/stl/download.html

 

 

 Effective STL中文版：50条有效使用STL的经验

对任一容器c ，下面的代码
if (c.size() == 0)…

本质上与
if (c.empty())…

是等价的。既然如此，你或许会疑惑为什么要偏向于某一种形式，尤其是考虑到empty 通常被
实现为内联函数(inline function )，并且它所做的仅仅是返回 size 是否为0。

你应该使用empty 形式，理由很简单：empty 对所有的标准容器都是常数时间操作，而对一些list 实现，size 耗费线性时间。

到底是什么使list 这么讨厌呢？为什么它不也提供常数时间的size 呢？答案在于list 所独有的链接(splice)操作。考虑如下代码：
list<int> list1;
list<int> list2;
…
list1.splice( //把list2中从第一个含5 的节点
    list1.end(), list2,  //到最后一个含10的所有节点
    find(list2.begin(), list2.end(), 5), //移动到list1的末尾
    find(list2.rbegin(), list2.rend(), 10).base()
 //关于base() 调用的信息，见第28条
);

这段代码只有当list2 中在含5 的节点之后有含10的节点时才工作。假定这不是一个问题，而把注意力集中在下面这个问题上：链接后的list1 中有多少个元素？很明显，链接后的list1 中的元素个数是它链接前的元素个数加上链接过来的元素个数。但有多少个元素被链接过来了
呢？应该与find(list2.begin(), list2.end(), 5)和find(list2.rbegin(), list2.rend(), 10). base() 所定义的区间中的元素个数一样多。好，那究竟是多少个呢？如果不遍历该区间来数一数，你是没法知道的。问题就在这里。

假定由你来负责实现list。list 不仅是容器，而且是标准容器，它将会被广泛使用。你自然会希望自己的实现尽量高效。你发现用户通常希望知道 list 中有多少个元素，所以你想使 size 成为常数时间操作。因此，你希望设计list，使它总知道自己含有多少个元素。

同时，你知道在所有的标准容器中，只有list 具有把元素从一处链接到另一处而不需要拷贝任何数据的能力。你推断，许多 list 的客户之所以选择它，是因为它提供了高效的链接操作。他们知道把一个区间从一个list 链接到另一个list 可以通过常数时间来完成。你很清楚他们知道这一点，所以你当然想满足他们的期望，使splice成为常数时间的成员函数。

这将使你左右为难。如果 size 是常数时间操作，那么 list 的每个成员函数都必须更新它们所操作的链表的大小(size )，当然也包括 splice。可是 splice更新它所改变的链表的大小的唯一方式是计算所链接的元素的个数，而这会使 splice不具有你所希望的常数时间操作性能。如果你不要求splice更新它所改变的链表的大小，则splice可以成为常数时间操作，可是这时size 会成为线性时间操作。通常，它需要遍历自己的整个数据结构来看一看自己含有多少个元素。不管你怎么看，某些方面——list 或splice——必须做出让步。其中的一个可以成为常数时间操作，但不可能二者都是。

不同的链表实现通过不同的方式解决这一冲突，具体方式取决于作者选择把 size 还是splice实现得最为高效。如果你使用的list 实现恰好是把splice的常数时间操作放在第一位的，那么你使用empty 而不是size 会更好些，因为empty 操作总是花费常数时间。即使现在你使用的list 实现不是这种方式，将来你也可能会发现自己在使用这样的实现。比如，你可能把自己的代码移植到不同的平台上，该平台上的 STL 采用了不同的实现；又如，你可能决定切换到当前平台上的不同的STL 实现。

不管发生了什么，调用empty 而不是检查size==0 是否成立总是没错的。所以，如果你想知道容器中是否含有零个元素，请调用empty。

 
 
 

 

转载于:https://www.cnblogs.com/pjl1119/p/8892318.html

diaokua8472
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ list判断是否包含_判断List集合为空还是null的正确打开方式
weixin_39956443的博客
11-28 1321
事故场景还原最近在写一个项目的时候遇到一个这样一个问题，我简单的还原一下场景，这是模拟一个简单的管理系统① 一张简单的客户表CREATE TABLE customer(id INT(11) NOT NULL AUTO_INCREMENT UNIQUE,NAME VARCHAR(255) NOT NULL,gender VARCHAR(255) NOT NULL,phonenumber VARCHA...
size() == 0和empty()的比较
FateDier的专栏
09-26 6794
最近开发公司项目的时候发现大量用到了STL模板库，而且很多地方都需要判断一个容器是否为空，看到了两种写法，分别使用了容器的 size() 函数和 empty()函数。            我觉得很好奇，这两种写法有什么区别呢？在网上查阅了一些资料，发现说empty()效率更高的占大多数。又查看了SGI STL的帮助文档，里面有一句话：            Ifyou are testi
C++ STL中判断list为空，size()==0和empty()有什么区别
luo809976897的专栏
11-26 4005
关于两个的区别，首先size()==0为bool表达式，empty()为函数调用，这一点很明显。查看源代码， bool empty() const { return _M_node-&gt;_M_next == _M_node; } size_type size() const { size_type __result = 0; dis...
list.size python
最新发布
Python老吕的博客
07-15 935
在Python中，列表的长度是通过len()函数获取的，而不是像一些其他编程语言那样通过.size属性。了解列表的长度对于索引访问、切片操作、循环迭代以及列表的各种操作都是至关重要的。通过合理地使用len()函数，我们可以编写出更加健壮和灵活的代码。
c++ 判断list是否为空（empty）
weixin_30394633的博客
12-12 3352
#include <list> #include <iostream> using namespace std; int main() { list<int> numbers; cout << "Initially, numbers.empty(): " << numbers.empty() <...
c++ STL之list对结构体的增加,删除,排序等操作详解
01-19
bool empty() 判断容器是否为空,true为空； 增加函数:void push_back(元素) 尾元素后增加一个元素；push_front(元素) 首元素前增加一个元素； iterator insert(lit,元素)在迭代器指针lit前插入元素，返回插入元素...
list_list_STL_C++_
09-29
在C++编程语言中，标准模板库（Standard Template Library，STL）是不可或缺的一部分，它提供了许多高效的数据结构和算法。其中，`list`是一种序列容器，专门用于处理链表数据结构。本篇文章将深入探讨`list`容器的...
C++语言 STL容器list总结
09-01
**C++语言STL容器list总结** STL（Standard Template Library，标准模板库）是C++编程中不可或缺的一部分，它提供了各种容器、迭代器、算法和函数对象等工具。其中，`list`是一种序列容器，它实现了一个双向链表，...
c++ stl list总结
11-04
C++ STL（Standard Template Library，标准模板库）中的`list`是一种双向链表容器，它提供了高效的操作，如插入和删除元素。在这个总结中，我们将深入探讨`list`的特性和使用方法，以及如何在实际编程中充分利用它。...
[C++][STL] C++ STL 之 List
03-18
总结，`list`作为C++ STL中的重要容器，它的特性和操作为处理动态序列提供了便利。理解并熟练使用`list`能够帮助开发者编写更加高效和灵活的C++代码。通过实际编程练习，你可以进一步掌握`list`的用法，并将其应用于...
谨慎使用效率极低的std::list.size()函数
冷风吹醒
08-27 3420
linux环境下的一个刚完成的库函数效率极低，经测试发现瓶颈在std::list.size()函数，而我是这样使用的：while (aList.size()) { ... }。 　　查看stl源码（SGI版本，一般Linux都是使用这个）发现std::list.size()要遍
empty()和size()的优劣
diaocuiguo2493的博客
03-20 750
通常下面代码： if(c.size() == 0) if(c.empty()) 我们会觉得它们是是等价的。 为何empty()比较好？ 主要是他们之间的效率有一定差距： empty对任意的容器都是常数时间 对于有点list实现，size需要线性时间 bool empty() const //list的empty操作 { return node->next =...
stl::list_C ++ STL中的std :: list :: empty（）函数
07-25 1243
stl::listempty() is the function of list class, it is used to check whether a list container is empty or not, it returns true (integer value: 1) if list container is empty i.e. its size is 0, otherwis...
Java集合中，isEmpty()与size()==0的区别
程序员Forlan的博客
03-01 2617
关于集合的处理，Java开发手册有这么一段话: 【强制】判断所有集合内部的元素是否为空，使用 isEmpty()方法，而不是 size()==0 的方式。 说明：在某些集合中，前者的时间复杂度为 O(1)，而且可读性更好。 下面我们通过一些源码来看看 HashMap源码 /** * Returns the number of key-value mappings in this map. * * @return the number of key-value
C++学习——empty()还是size()
m0_37876745的博客
08-29 600
为何empty()比较好？ 主要是他们之间的效率有一定差距： empty对任意的容器都是常数时间 对于有点list实现，size需要线性时间
List isEmpty()和size()==0 有什么区别
热门推荐
Sunny
06-13 1万+
没有区别，isEmpty()方法也是判断size是否为0. /** * Tests if this list has no elements. * * @return true if this list has no elements; * false otherwise. */ public boolean
用empty()代替size()==0
coderchen
01-24 3144
对于任意容器c，写下代码： if(c.size()==0)目的就是判断容器c是否为空，即if(c.empty())。 你可能会奇怪，为什么使用empty()要好于size()，尤其是事实上，empty是一个判断size的内联函数。 选择empty的理由：对于所有标准容器，empty()是一个常数时间操作，而对于一些list实现，size()不保证是一个常数时间操作。why？ list li
C++中STL list的实现
04-05
STL（Standard Template Library）是C++中的一个标准库，其中包含了许多常用的数据结构和算法。其中，list是一种常用的数据结构，它是一个双向链表，可以实现快速的插入和删除操作。 下面是C++中STL list的简单实现： ```cpp template <typename T> class List { private: struct Node { T data; Node* prev; Node* next; Node(const T& d = T(), Node* p = nullptr, Node* n = nullptr) : data(d), prev(p), next(n) {} }; Node* head; Node* tail; int size; public: List() : head(nullptr), tail(nullptr), size(0) {} List(const List& other) : head(nullptr), tail(nullptr), size(0) { for (const auto& item : other) { push_back(item); } } ~List() { clear(); } List& operator=(const List& other) { if (this != &other) { List tmp(other); swap(tmp); } return *this; } void push_back(const T& item) { Node* new_node = new Node(item, tail, nullptr); if (tail) { tail->next = new_node; } else { head = new_node; } tail = new_node; ++size; } void push_front(const T& item) { Node* new_node = new Node(item, nullptr, head); if (head) { head->prev = new_node; } else { tail = new_node; } head = new_node; ++size; } void pop_back() { if (tail) { Node* tmp = tail; tail = tail->prev; if (tail) { tail->next = nullptr; } else { head = nullptr; } delete tmp; --size; } } void pop_front() { if (head) { Node* tmp = head; head = head->next; if (head) { head->prev = nullptr; } else { tail = nullptr; } delete tmp; --size; } } T& front() { return head->data; } T& back() { return tail->data; } bool empty() const { return size == 0; } int size() const { return size; } void clear() { while (!empty()) { pop_back(); } } class iterator { private: Node* ptr; public: iterator(Node* p = nullptr) : ptr(p) {} iterator(const iterator& other) : ptr(other.ptr) {} iterator& operator++() { ptr = ptr->next; return *this; } iterator operator++(int) { iterator tmp(*this); ptr = ptr->next; return tmp; } iterator& operator--() { ptr = ptr->prev; return *this; } iterator operator--(int) { iterator tmp(*this); ptr = ptr->prev; return tmp; } T& operator*() const { return ptr->data; } T* operator->() const { return &(ptr->data); } bool operator==(const iterator& other) const { return ptr == other.ptr; } bool operator!=(const iterator& other) const { return ptr != other.ptr; } }; iterator begin() const { return iterator(head); } iterator end() const { return iterator(nullptr); } iterator rbegin() const { return iterator(tail); } iterator rend() const { return iterator(nullptr); } void swap(List& other) { std::swap(head, other.head); std::swap(tail, other.tail); std::swap(size, other.size); } }; ``` 上述代码中，List类中定义了一个私有结构体Node，它表示双向链表中的每个节点。Node中包含了数据成员data、指向前一个节点的指针prev和指向后一个节点的指针next。List类中还包含了头指针head、尾指针tail和大小size等数据成员。 List类提供了许多操作，包括push_back、push_front、pop_back、pop_front、front、back、empty、size、clear等。其中，push_back和push_front分别表示在双向链表的末尾和开头插入一个元素，pop_back和pop_front分别表示删除双向链表的末尾和开头的元素，front和back分别表示获取双向链表的第一个和最后一个元素，empty表示判断双向链表是否为空，size表示获取双向链表中元素的个数，clear表示清空双向链表中的所有元素。 List类还定义了一个迭代器iterator，它可以用于遍历双向链表中的所有元素。迭代器中包含了一个指向Node的指针ptr，它可以指向双向链表中的任意一个节点。迭代器提供了许多操作，包括++、--、*、->、==、!=等。其中，++和--分别表示迭代器向前和向后移动一个位置，*表示获取迭代器所指向节点的数据成员data，->表示获取迭代器所指向节点的数据成员data的指针，==和!=分别表示判断两个迭代器是否相等和不相等。 List类中还提供了一些其他操作，比如拷贝构造函数、析构函数、赋值运算符、begin、end、rbegin、rend和swap等。其中，拷贝构造函数用于复制另一个List对象，析构函数用于释放所有节点的内存，赋值运算符用于将一个List对象赋值给另一个List对象，begin和end分别返回指向双向链表中第一个元素和最后一个元素的迭代器，rbegin和rend分别返回指向双向链表中最后一个元素和第一个元素的迭代器，swap用于交换两个List对象中的所有数据成员。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值