vector<bool>中的代理机制与程序运行效率

最新推荐文章于 2022-05-20 20:51:43 发布
最新推荐文章于 2022-05-20 20:51:43 发布
阅读量796 收藏 1
点赞数
分类专栏： C++ 文章标签： stl vector 代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hekailing/article/details/40481559
版权

事情起源于一道LeetCode题。

LeetCode上有一道题，叫N-Queens。这是一道很经典的题，很快我就给出了我的代码。如下：

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
		vvi.clear();
		vvs.clear();
		for (int i = 0; i < n; ++i) vvi.push_back(vector<int>(n, 0));
		vvn = n;
		for (int i = 0; i < n; ++i) dfs(0, i);
		return vvs;
    }

	void dfs(int x, int y)
	{
		if (vvi[x][y]) return;
		if (x == vvn-1) {
			if (vvi[x][y] == 0) {
				vvi[x][y] = 1;
				vector<string> vs;
				for (int i = 0; i < vvn; ++i) {
					string str;
					for (int j = 0; j < vvn; ++j) {
						if (vvi[i][j] == 1) str.push_back('Q');
						else str.push_back('.');
					}
					vs.push_back(str);
				}
				vvs.push_back(vs);
				vvi[x][y] = 0;
			}
			return;
		}
		mark(x, y);
		for (int i = 0; i < vvn; ++i) {
			dfs(x+1, i);
		}
		unmark(x, y);
	}

	void mark(int x, int y) {
		vvi[x][y] = 1;
		int I = min(x, y)+1;
		for (int i = 1; i < I; ++i) if (vvi[x-i][y-i] <= 0) --vvi[x-i][y-i];
		I = min(vvn-x, y+1);
		for (int i = 1; i < I; ++i) if (vvi[x+i][y-i] <= 0) --vvi[x+i][y-i];
		I = min(vvn-x, vvn-y);
		for (int i = 1; i < I; ++i) if (vvi[x+i][y+i] <= 0) --vvi[x+i][y+i];
		I = min(x+1, vvn-y);
		for (int i = 1; i < I; ++i) if (vvi[x-i][y+i] <= 0) --vvi[x-i][y+i];
		for (int i = 0; i < vvn; ++i) if (vvi[i][y] <= 0) --vvi[i][y];
		for (int i = 0; i < vvn; ++i) if (vvi[x][i] <= 0) --vvi[x][i];
	}

	void unmark(int x, int y) {
		vvi[x][y] = 0;
		int I = min(x, y)+1;
		for (int i = 1; i < I; ++i) if (vvi[x-i][y-i] < 0) ++vvi[x-i][y-i];
		I = min(vvn-x, y+1);
		for (int i = 1; i < I; ++i) if (vvi[x+i][y-i] < 0) ++vvi[x+i][y-i];
		I = min(vvn-x, vvn-y);
		for (int i = 1; i < I; ++i) if (vvi[x+i][y+i] < 0) ++vvi[x+i][y+i];
		I = min(x+1, vvn-y);
		for (int i = 1; i < I; ++i) if (vvi[x-i][y+i] < 0) ++vvi[x-i][y+i];
		for (int i = 0; i < vvn; ++i) if (vvi[i][y] < 0) ++vvi[i][y];
		for (int i = 0; i < vvn; ++i) if (vvi[x][i] < 0) ++vvi[x][i];
	}

private:
	vector<vector<int> > vvi;
	int vvn;
	vector<vector<string> > vvs;
};
考虑到上述代码中的mask和unmask函数对vvi矩阵的修改操作较复杂。于是不用二维数组作为flag，改用四个分别代表行、列和两条对角线的数组作为flag。代码如下： 

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
		row_marker = vector<bool>(n, false);
		col_marker = vector<bool>(n, false);
		diag_marker = vector<bool>(n*2-1, false);
		diag_marker2 = vector<bool>(n*2-1, false);
		stkQ.clear();
		vvs.clear();
		vvn = n;
		dfs(0);
		return vvs;
	}

	void dfs(int n) {
		for (int i = 0; i < vvn; ++i) {
			if (permition(n, i)) {
				mark(n, i);
				if (n < vvn-1) dfs(n+1);
				else {
					vector<string> vs;
					for (int j = 0; j < vvn; ++j) {
						string str(vvn, '.');
						str.replace(stkQ[j], 1, 1, 'Q');
						vs.push_back(str);
					}
					vvs.push_back(vs);
					unmark(n, i);
					break;
				}
				unmark(n, i);
			}
		}
	}

	bool permition(int x, int y) {
		return (row_marker[x] == false) && \
			   (col_marker[y] == false) && \
			   (diag_marker[x-y+vvn-1] == false) && \
			   (diag_marker2[x+y] == false);
	}

	void mark(int x, int y) {
		row_marker[x] = true;
		col_marker[y] = true;
		diag_marker[x-y+vvn-1] = true;
		diag_marker2[x+y] = true;
		stkQ.push_back(y);
	}
	
	void unmark(int x, int y) {
		row_marker[x] = false;
		col_marker[y] = false;
		diag_marker[x-y+vvn-1] = false;
		diag_marker2[x+y] = false;
		stkQ.pop_back();
	}

private:
	vector<bool> row_marker;
	vector<bool> col_marker;
	vector<bool> diag_marker;
	vector<bool> diag_marker2;
	vector<int> stkQ;
	int vvn;
	vector<vector<string> > vvs;
};

本来以为这样修改既降低了空间复杂度，也降低了时间复杂度，应该是极好的。可惜在服务器上后者的测试时间居然略高与前者。

以后为说明方便，将修改前的代码称为代码一，修改后的代码称为代码二。

起初以为是测试使用的n较小（在我台式机上n=10时，程序就要跑几秒），所以代码二体现不出优势。但后来仔细一想，觉得就算n小一点，代码二也不至于比代码一慢呀。于是仔细分析上面两份代码。

代码一与代码二的核心思想都是采用递归形式的深度优先遍历算法。两者的遍历过程几乎完全一样，不同的仅仅是mask、unmask和判断操作。于是猜想两者的差距应该与mask和unmask的运行时间有很大关系。于是对mask和unmask性能进行测试，测试代码如下：

<span style="white-space:pre">	</span>int start = GetTickCount();
	for (int i = 0; i < 10000; ++i) {
		solution1.mark(0, 0);
		solution1.unmark(0, 0);
	}
	int end = GetTickCount();
	cout << end - start << endl;
	start = GetTickCount();
	for (int i = 0; i < 10000; ++i) {
		solution2.mark(0, 0);
		solution2.unmark(0, 0);
	}
	end = GetTickCount();
	cout << end - start << endl;
方格边长n代码一执行10000次时间(ms)
346
578
7140
9172
11187
13234
15265
17296

从上表中可以看出n与T之间近似呈线性关系，这是正常的。 

row_marker
然后，将代码二中的col_marker等vector的元素类型设置为bool，再将n分别设置为上述值，得到的T基本上都是234左右。col_marker的元素类型设置为char或int的时候，得到的T近似为5。我很好奇bool和char之间的区别到底是什么？

这是bool类型的row_marker[x]=1;的汇编代码：

row_marker[x] = 1;
003D36B2  push        1  
003D36B4  mov         eax,dword ptr [ebp+8]  
003D36B7  push        eax  
003D36B8  lea         ecx,[ebp-134h]  
003D36BE  push        ecx  
003D36BF  mov         ecx,dword ptr [ebp-14h]  
003D36C2  call        std::vector<bool,std::allocator<bool> >::operator[] (3D1181h)  
003D36C7  mov         dword ptr [ebp-13Ch],eax  
003D36CD  mov         edx,dword ptr [ebp-13Ch]  
003D36D3  mov         dword ptr [ebp-140h],edx  
003D36D9  mov         dword ptr [ebp-4],0  
003D36E0  mov         ecx,dword ptr [ebp-140h]  
003D36E6  call        std::_Vb_reference<std::allocator<bool> >::operator= (3D142Eh)  
003D36EB  mov         dword ptr [ebp-4],0FFFFFFFFh  
003D36F2  lea         ecx,[ebp-134h]  
003D36F8  call        std::_Vb_reference<std::allocator<bool> >::~_Vb_reference<std::allocator<bool> > (3D18D9h)  
这是char类型的row_marker[x]=1;的汇编代码：

row_marker[x] = 1;
00D832A3  mov         eax,dword ptr [x]  
00D832A6  push        eax  
00D832A7  mov         ecx,dword ptr [this]  
00D832AA  call        std::vector<char,std::allocator<char> >::operator[] (0D81122h)  
00D832AF  mov         byte ptr [eax],1  

很明显，vector<bool>的汇编代码比vector<char>的汇编代码长太多了，可以明显看出来的区别就是vector<bool>的代码还需要调用赋值运算符，相比之下vector<char>则只是简单的使用了一句mov命令就完成了赋值操作。为什么会有这个区别？不过为了完整地看明白vector<bool>的内部机制，我们还是从[]运算符开始看起：

在执行row_marker[x] = true;语句时，程序首先调用[]操作符：

reference operator[](size_type _Off)
		{	// subscript mutable sequence
		return (*(begin() + _Off));
		}
支持随机访问容器的[]运算符都这样，并不奇怪，于是接着进入到+运算符函数中： 

_Mytype operator+(difference_type _Off) const
		{	// return this + integer
		_Mytype _Tmp = *this;
		return (_Tmp += _Off);
		}
再然后是+=运算符： 
_Mytype& operator+=(difference_type _Off)
		{	// increment by integer
		*(_Mybase *)this += _Off;
		return (*this);
		}
奇怪的地方出现了，对于vector的迭代器，+=运算符只需要将指向该元素的指针加_Off即可，而这里转而去调用_Mybase的+=运算符操作。就让我们一窥_Mybase中的玄机吧！ 

_Mytype& operator+=(difference_type _Off)
		{	// increment by integer
		if (_Off < 0 && this->_Myoff < 0 - (size_type)_Off)
			{	/* add negative increment */
			this->_Myoff += _Off;
			this->_Myptr -= 1 + ((size_type)(-1) - this->_Myoff) / _VBITS;
			this->_Myoff %= _VBITS;
			}
		else
			{	/* add non-negative increment */
			this->_Myoff += _Off;
			this->_Myptr += this->_Myoff / _VBITS;
			this->_Myoff %= _VBITS;
			}
		return (*this);
		}
至此，聪明的程序员应该能看出端倪了。这个函数的大意就是：若_Off大于0，则将_Myoff加上_Off，然后_Myoff除以_VBITS，商再累加给_Myptr，余数赋给_Myoff；若_Off小于0，则要看_MyOff是否小于_Off，如果是，则_Myptr要减去商。。。（其实就是比特映射，不再赘言了）
现在，终于完成了迭代器的运算，然后就是调用迭代器的*运算符访问了，这个方法和普通迭代器的*运算符一样。
最后，便是调用赋值运算符： 

_Mytype& operator=(bool _Val)
		{	// assign _Val to bit
		if (_Val)
			*(_Vbase *)_Getptr() |= _Mask();
		else
			*(_Vbase *)_Getptr() &= ~_Mask();
		return (*this);
		}
这里面关键是一个_Mask()函数： 

_Vbase _Mask() const
		{	// convert offset to mask
		return ((_Vbase)(1 << this->_Myoff));
		}
根据_Myoff找到需要修改的bit位。
经过如此复杂的工序，终于完成了vector<bool>中元素的赋值。同时也找到了代码二效率低的原因。


PS：

vector<bool>这种机制叫做代理。通过代理，原本由一个字节存储的逻辑变量只需要一个比特来存储，内存占用降低八倍，代价就是访问和修改的复杂度大大增加。所以除非是数据量特别大的情况，平时还是慎用vector<bool>。可以使用deque<bool>代替。

由于使用了代理，所以vector<bool> vb; bool* p = &vb[0];这样的语句是会编译报错的！


Kylin_he
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Effective STL：杂记（一）
u014209688的专栏
10-13 251
1. 避免使用vector<bool> vector<bool>实际上并不能算是一个STL容器，实际上也并不存储bool。因为一个对象要成为STL容器，就必须满足C++标准的第23.1节列出的所有条件，其中一个条件是，如果 c 是包含对象T的容器，而且 c 支持operator[]，则必须能够编译下面代码： T *p = &c[0]; 也就是...
不使用vector<bool>的原因和替代方法
靖哥哥的专栏
05-08 5006
vecotr不是容器，至少，不是标准意义上的容器。  vector的名称有点让人误解，因为其内部元素实际上并不是标准的bool值，标准的bool值至少与char拥有一样的大小，从而可以被“正常”使用。  然而C++标准对于vecotr值有其特殊的实现方法。目的是为了减小空间的耗用。特殊版本内部只使用一个bit来存储一个元素，所以通常要比一般的bool值小8倍之多。
vector＜bool＞的特殊性
qq_45853229的博客
05-20 6178
起因是这样的，昨天在查C++11的range base for loop相关的东西的时候，看到说vector< bool >是一个proxy iterator，非常的特殊，于是就好奇的研究了一下。 首先vector< bool> 并不是一个通常意义上的vector容器，这个源自于历史遗留问题。 早在C++98的时候，就有vector< bool>这个类型了，但是因为当时为了考虑到节省空间的想法，所以vector< bool>里面不是一个Byte一个Byte储存
【C++】vector＜bool＞的特别之处
qq_52134928的博客
10-31 4431
在一次刷题的过程中偶然发现一个问题，vector<bool>的运行速度要比其他vector<T>慢很多，查阅资料后惊奇的发现，vector<bool>甚至不是一个STL容器。 vector<bool> 不像其他容器一样按Byte存储的，它是按bit存储的，也就是说一个正常的bool类型的空间可以存放vector<bool>中的8个，空间上确实优化了很多，然鹅，c++是不能直接取对bit操作的，对其使用operator[]其实返回的不是boo.
2021/4/6 剑指 Offer 13. 机器人的运动范围 bfs+queue
lardoris928的博客
04-06 117
DFS：深度优先搜索 这个图讲的很好 但是底下的程序讲的不行 贴一个自己写的： 注意：c++里二维数组不能bool visited[m][n]这样传参 vector<vector<bool>> visited(m, vector<bool>(n, 0));代表一个二维矩阵，m行，每行有n个0 class Solution { public: int movingCount(int m, int n, int k) { //.
c++中为什么不提倡使用vector示例详解
08-25
这意味着，当你访问vector< bool>中的元素时，你实际上访问的是一个代理对象，而不是真正的元素引用。例如， bool b = c[0]; auto d = c[0]; 在这里，b的初始化实际上暗含了一个隐式的类型转换，而d的类型并不是bool...
谈谈vector的特殊性之为什么它不是STL容器
08-25
在C++11引入的范围基础循环（range-based for loop）中，`vector<bool>`仍然能够工作，但需要注意的是，循环中的元素并不会是`bool`类型，而是`vector<bool>::reference`类型的代理对象。因此，对循环内的元素进行...
C#中Predicate<T>与Func<T, bool>泛型委托的用法实例
09-04
在C#编程中，`Predicate<T>` 和 `Func<T, bool>` 是两种常见的泛型委托类型，它们在处理集合和函数式编程时扮演着重要角色。这两种委托虽然在功能上非常相似，但在特定上下文中有着微妙的区别。 首先，让我们详细...
C#中PredicateT与FuncT, bool泛型委托的用法实例
01-20
本文以实例形式分析了C#中Predicate<T>与Func<T>泛型委托的用法，分享给大家供大家参考之用。具体如下： 先来看看下面的例子： static void Main(string[] args) { List<string> l = new List<string>(); l.Add(a...
Effective stl---笔记
weixin_34195364的博客
12-13 121
1 只有序列容器支持push_front或push_back， 只有关联容器支持count和lower_bound，等等. 2 （条款1解释了deque是唯一一个在迭代器失效的 情况下指针和引用仍然有效的东西） 【不作为特例】 3 迭代器/指针/参考的失效规则 4 typedef代码封装 typedef vector<Widget> Wi...
C++ 提高教程 STL deque容器-赋值操作
qq_40214464的博客
10-13 112
代码简单 # include<iostream> #include<deque> # include<algorithm> # include<string> using namespace std; void printVector(const deque<int>& v) //容器中的数不可以需改 { for (deque<int>::const_iterator it = v.begin(); it != v...
说一说vector<bool>
weixin_34342578的博客
07-09 541
vector<T>标准库模版类应该是绝大多数c++程序员使用频率比较高的一个类了。不过vector<bool>也许就不那么被程序员所了解。关于vector<bool>不尝试研究一番，一般还不太容易知道其中蕴含的问题。 首先得明确一点，那就是vector<bool>是vector<T>的特化版。这个特化版本要解决的问题就是存储容量的问题。...
C++ vector＜vector＜int＞＞ bool数组false
weixin_44769957的博客
09-28 2787
C++ vector<vector> 如何初始化 就是 容器的每个元素又是一个容器而已 就这么简单 例如：vector<vector<int>> ivec; 插入的值类型是vector<int> 二维向量的输入问题： 不像二维数组那样，可以直接对arr[i][j]进行循环赋值。 在vector<vector>中，因为vector是一个容器， 最外层的vector容器中放着更小的vector， 而里层的vector里面放的是int型的数字。 所以我
教你做回溯题(Leetcode全排列和全排列II)-第三期
Airy的博客
08-28 180
前两期指路： 第一期：第一期 第二期：第二期 例题 全排列 给定一个不含重复数字的数组，返回所有可能的全排列，对于组合集合来说，要考虑顺序 ①选择一个实例[1,2,3]画图 ②确定结束条件 由于是全排列，所以最后结果的集合一定包含多有的数，那么结束条件是path的长度与题目给的nums一样 //结束条件 if(path.size()==nums.size()){ res.push_back(path); } ③确定选择列表，我们发现这题选择列表相对于前几期没那么有规律。 .
c++中为什么不提倡使用vector<bool>(转)
DoronLee的博客
11-06 4113
vector< bool> 并不是一个STL容器，不是一个STL容器，不是一个STL容器！首先vector< bool> 并不是一个通常意义上的vector容器，这个源自于历史遗留问题。 早在C++98的时候，就有vector< bool>这个类型了，但是因为当时为了考虑到节省空间的想法。
vector<int>和vector<bool>的存储方式有什么不同
最新发布
05-10
在C++中，vector<int>和vector<bool>的存储方式是不同的。 vector<int>是一个动态数组，它使用连续的内存存储其元素。每个int元素在内存中占用4个字节，可以被直接访问和修改。 vector<bool>的存储方式有所不同。由于bool类型只需要1位的存储空间，所以vector<bool>使用了一个特殊的压缩存储方式，将相邻的bool值打包存储在一个字节中。这个字节中每一位代表一个bool值。这种压缩存储方式使得vector<bool>的内存使用量比vector<int>更加紧凑，但也导致了对vector<bool>中的元素的访问和修改操作变得更加复杂。 因此，当需要使用一个动态数组来存储大量bool类型的数据时，vector<bool>可能比vector<int>更加节省内存。但是当需要频繁地访问和修改这些bool值时，vector<int>可能更加高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值