关于std::vector<bool>类型使用下标运算符取值出错的研究

最新推荐文章于 2024-08-23 03:11:58 发布
最新推荐文章于 2024-08-23 03:11:58 发布
阅读量2.2k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 杂项 文章标签： vector bool
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jianminfly/article/details/99852591
本文探讨了std::vector<bool>使用下标运算符取值时遇到的问题。通常，vector下标操作返回类型为值引用，但当元素为bool时，返回的是reference类的拷贝，导致内存转换后可能不正确。分析了_Myval2._Myfirst[_Pos]的过程，揭示了这一特殊行为的原因。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

问题提出

std::vectorv(1,true);
void* p = &v[0];// 此时p指向的内存转成bool类型是false
但是
std::vector v2(2,1);
void* p3 = &v2[0];// 此时p指向的内存转成int类型时，值正常

分析

1.一般类型的vector使用下标运算符时

   _NODISCARD _Ty& operator[](const size_type _Pos) {
		auto& _My_data = _Mypair._Myval2;
。。。
		return _My_data._Myfirst[_Pos];
	}

2.继续分析_My_data._Myfirst[_Pos];

1.因为auto& _My_data = _Mypair._Myval2;所以只要分析_Mypair._Myval2._Myfirst[_Pos];即可
2._Mypair定义为_Compressed_pair<_Alty, _Scary_val> _Mypair;
3._Scary_val类型就是_Vector_val<bool _Test, class _Ty1, class _Ty2>
4.这个_Vector_val的特化类型就是_Myval2，同时_Vector_val里面定义了_Myfirst，这就是前面下标运算符用到的指针，那么这个指针是什么类型呢，继续往下看
5.看声明，pointer _Myfirst; // pointer to beginning of array
6.再看声明，using pointer = typename _Val_types::pointer;所以先找到_Val_types类型，再找到这个pointer类型即可
7._Val_types为_Vector_val的特化，所以我们回到_

最低0.47元/天 解锁文章

200万优质内容无限畅学
std::vector＜bool＞有什么特殊的吗
二进制君
07-06 278
但也带来了与标准容器不一致的行为。在实际开发中，需谨慎评估其适用性，必要时选择替代方案以避免潜在问题。理解其特性是编写健壮C++代码的关键。是标准库中的一个特殊容器，它虽然看似是存储布尔值的动态数组，但实际上是一个。每个布尔值（通常8个布尔值压缩为1字节），以节省内存空间。这些差异可能导致一些反直觉的行为，需特别注意。某些需要直接访问内存地址的算法（如。的迭代器返回的是代理对象，而非。由于位压缩存储，无法提供真正的。
第一篇：C/C++语法与std数据结构
qq_35635374的博客
11-07 1612
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 TODO:写完再整理 文章目录系列文章目录前言一、C++在C基础上的改进1.C语言和C++语言的关系2.C++的开发工具3.面向对象的思想4.面向过程和面向对象的两种思维比喻5.面向对象思想的的特点6.C/C++的特点（1）C++特点：（2）使用面向对象的编程技术开发程序的基本步骤：（3）面向对象的优点（4）高级的面向对象编程方法（5）解决程序的阻塞性二、C++的数据结构【重要】1.布尔型bool2.整型int(int_16、
vector 基本操作（对象、下标）
lovemysea的专栏
02-09 1万+
一、vector对象的操作：1、向vector添加元素push_back()操作接受一个元素值，并将它作为一个新的元素添加到vector对象的后面，也就是“插入（push）”到vector对象的“后面(back)”：小例子：vector text;         // empty vector(空的容器)while (cin >> word) {    text.push_back(word);
获取vector数组元素的下标的方法
发如雪
05-14 1万+
获取vector数组元素的下标的方法 代码： #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; int main() { /****** 方法一： ******/ //定义一个vector数组 vector<int> temp = { 0,1,2,3,4,5,6,7,8,9 }; vect
关于std::vector指针的下标“[]”的使用
maocl1983的专栏
05-21 7511
#include #include #include #include using namespace std;struct test_t {       uint32_t a;       uint32_t b;};int main(int argc, char *argv[]){    test_t t;    memset(&t, 0x00, sizeof(test_t));  
C++ 疑难杂症一——奇怪的 vector＜bool＞
qq_44709318的博客
09-01 541
从节省空间的角度（同时如果实现恰当的话还会加速执行时间），将数组中的每个元素实现成。实际上，en.cppreference.com。类型的非常量左值引用。仔细看报错信息，临时对象的类型为。在增强 for 循环中，遍历。
vector 遍历及下标访问
08-13 1万+
vector 常规的遍历方法有三种： 1.for 遍历 vector theVector; ... vector::iterator theIterator; for (theIterator = theVector.begin(); theIterator != theVector.end(); theIterator++) { cout << *theIterato
``` #include <iostream> #include <string> using namespace std; #include <vector> // 通过27/33，居然还有问题 // 7 // 0 1 3 3 3 2 0 // 9 // 0 3 3 2 4 3 2 2 1 // 3 1 4 1 4 2 2 0 0 // 4 3 2 3 2 4 0 1 4 // 1 1 2 1 2 0 2 2 3 // 2 0 2 0 2 3 0 3 0 // 2 1 1 3 3 3 2 0 1 // 1 3 3 1 3 3 0 1 0 // 0 1 2 0 4 1 4 2 0 // 3 0 2 0 0 2 0 4 4 // 结果应是：7 3 6 3 5 3 5 4 5 5 5 6 4 6 // 这道题做得好费劲 vector<vector<int>> direction = { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } }; // 明文的长度（1 ≤ N ≤ 200） int n; // 密文的长度 int m; string res; string convert(vector<pair<int, int>>& v) { string s; for (auto& p : v) { s += to_string(p.first) + " " + to_string(p.second) + " "; } return s; } // 找data[ans.size()]，ans是值传递 bool dfs(vector<vector<int>>& matrix, vector<vector<bool>>& vis, int r, int c, vector<pair<int, int>>& ans, const vector<int>& data) { // 用字符串的长度判断不准确！因为下标可能是多位数，结束的时候ans.size()/4不一定是n // 还是用数组 // cout << "k=" << k << endl; int k = ans.size(); if (k == n) { // 找到一条路径 string s = convert(ans); cout << "s=" << s << endl; if (res.empty()) { res = s; } else { // 字典序最小 res = min(res, s); } return true; } // 越界 已访问 不匹配 if (r < 0 || r >= m || c < 0 || c >= m || vis[r][c] || matrix[r][c] != data[k]) { return false; } // 匹配 // 选 vis[r][c] = true; // 访问 ans.emplace_back(r, c); bool flag = false; for (int i = 0; i < 4; i++) { int x = r + direction[i][0]; int y = c + direction[i][1]; flag |= dfs(matrix, vis, x, y, ans, data); } if (!flag) { // 不选，回溯 vis[r][c] = false; ans.pop_back(); } return flag; } int main() { while (cin >> n) { // 注意 while 处理多个 case vector<int> data(n); for (int i = 0; i < n; i++) { cin >> data[i]; } cin >> m; // 密文矩阵（密码本） vector<vector<int>> matrix(m, vector<int>(m)); for (int i = 0; i < m; i++) { for (int j = 0; j < m; j++) { cin >> matrix[i][j]; } } for (int i = 0; i < m; i++) { for (int j = 0; j < m; j++) { // cout << "i=" << i << " j=" << j << endl; vector<vector<bool>> vis(m, vector<bool>(m, false)); // 开始DFS vector<pair<int, int>> ans; dfs(matrix, vis, i, j, ans, data); } } if (res.empty()) { cout << "error"; } else { cout << res; } } return 0; } // 64 位输出请用 printf("%lld")```哪里有问题？
最新发布
03-23
vector<vector<int>> direction = { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } }; 也就是右、左、下、上。这可能完全颠倒了正确的顺序。例如，原顺序中，先访问右，然后是左，然后是下，最后是上。这可能导致在...
C++(十) list
2301_79608541的博客
08-23 1224
频繁的随机访问频繁在容器的尾部添加或删除元素vector会表现得非常高效相对较少的中间插入和删除vector在中间插入和删除数据效率较低（因为需要挪动后面全部数据）内存连续性频繁的中间插入和删除,list支持在 O(1) 时间内在链表的任意位置插入或删除元素 (不需要挪动后面数据)迭代器的稳定性，插入或删除元素不会使现有的迭代器失效（除非删除了迭代器指向的元素）不需要随机访问，list不支持随机访问，可以遍历链表但效率低避免内存重新分配，每个元素都是独立分配的节点，因此在插入新元素时不需要像。
C++ 学习指南基础（四）
LYR1994的博客
04-13 1409
目录 81. Formating Output 82. Functions for I/O Stream 83. File Open Mode 84. Introduction to Binary IO 85. How to Do Binary Input/Output 86. File Positioner 87. Random Access File 88. Operat...
vector赋值的常见错误
优快云1HAO的博客
08-03 2780
易范错误1： vector&lt;int&gt; a;     for (int i = 0; i&lt;10; i++)         a[i] = i;     //这种做法以及类似的做法都是错误的。下标只能用于获取已存在的元素，而现在的a[i]还是空的对象 正确做法1： vector&lt;int&gt; a;     for (int i = 0; i&lt;10; i++...
快速高效的循环std::vector处理，以及std::vector::end函数
showlong 专栏「C++」@ http://www.fuel4d.com
07-14 5832
今天闲来没事看了一下N久就在我电脑里面的《Effective STL 中文版》。当我看到第43条的时候发现，按上面所讲用：算法替换手工循环。不由得产生了疑问。我记得我以前看vector源代码的时候循环效率最高的是operator[]操作(下标操作)。怎么这里竟然说是算法速度快。 下面先做个测试，代码如下：  // 测试类及其调用函数class AAA{pub
说一说vector<bool>
weixin_34342578的博客
07-09 631
vector<T>标准库模版类应该是绝大多数c++程序员使用频率比较高的一个类了。不过vector<bool>也许就不那么被程序员所了解。关于vector<bool>不尝试研究一番，一般还不太容易知道其中蕴含的问题。 首先得明确一点，那就是vector<bool>是vector<T>的特化版。这个特化版本要解决的问题就是存储容量的问题。...
vector用法_C++遍历vector元素的四种方式
weixin_40002336的博客
11-24 1万+
vector是相同类型对象的集合，集合中的每个对象有个对应的索引。vector常被称为容器(container)。C++中遍历vector的所有元素是相当常用的操作，这里介绍四种方式。1、通过下标访问通过下标访问，数组的用法，是最基本的操作。2、通过迭代器访问尽管可以使用下标来访问vector的元素，但更一般的机制是使用迭代器(iterator)。上面是最常用的两种方式，下面介绍使用C++11新特...
C++中的vector用法详解
分享实践与思考
03-10 7133
目录 一、vector介绍 1、vector(向量) 2、变量声明 二、详细的函数实现功能 1、建立一个容纳1-1000值的vector 2、使用下标访问元素 3、使用迭代器访问元素 4、插入和删除元素 三、使用vector 1、判断vector中某一元素是否存在 2、返回vector中某一个元素的下标 一、vector介绍 1、vector(向量) C++中的一种数据...
关于 std::vector 的下标越界检查
热门推荐
luansxx的专栏
08-22 1万+
当要获取 std::vector 的第 n 个元素，下面几种方式都可以： std::vector vec; size_t n = 1; int & i = vec[n]; int & j = vec.at(n); int & k = *(vec.begin() + n); 但是如果 n 超过了 vector 的下标范围，在几种方式的结果就有区别了，只有 at(n) 会抛出 std:
4-C++ 中string类、bool类型、模板、array数组、vector向量的基础知识
Summer_taotao的博客
04-12 734
string类、bool类型、模板、array数组、vector向量
动态数组：vector容器
m0_60492395的博客
08-17 389
vector容器
智能指针
qq_41078889的博客
07-09 881
智能指针是为了方便管理动态内存，防止产生内存泄漏，而对指针进行的一层封装，可以通过析构函数，构造函数，赋值运算符重载的处理，而实现的可以自动管理指针所指向的动态内存，防止产生内存泄漏。定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。智能指针：主要有Boost库中的智能指针和STL标准库中的智能指针构成。 所有智能指针编写代码时都需要注意的事： 智能指针编写的时候，因为不知道指向的是何种类型的堆内存，所以都写成模板形式 注
使用**std::vector<bool>**（注意：vector<bool>可能非真正布尔数组，需谨慎使用）
03-20
<think>好的，我现在需要帮助用户理解`std::vector<bool>`在C++中的特性和注意事项。用户之前已经询问过位域和`std::bitset`，现在可能是在进一步探索不同的紧凑存储方法。首先，我得回忆一下`std::vector<bool>`的特殊之处，以及为什么需要谨慎使用。 首先，用户提到“可能非真正布尔数组”，这涉及到`std::vector<bool>`的一个关键点：它并不是普通的容器。根据C++标准，`vector<bool>`是`vector`的一个特化版本，为了节省空间，每个元素只占一个位，而不是一个完整的`bool`大小（通常是一个字节）。这种特化导致它与其他`vector`类型不同，比如`vector<int>`或`vector<char>`，这些容器存储的是实际的对象，而`vector<bool>`存储的是位的引用，这可能引发一些问题。 接下来，我需要整理出`std::vector<bool>`的主要特点。首先，它的存储是紧凑的，每个元素仅占一个位，这对于需要大量布尔值且内存敏感的应用非常有用。但这也带来了访问的问题，因为不能直接取元素的地址，毕竟单个位无法像字节那样寻址。此外，迭代器和引用的行为也不同于标准容器，可能导致一些意料之外的行为，比如无法获得指向单个位的指针，或者在使用某些算法时出现兼容性问题。 然后，用户需要注意潜在的问题。例如，`vector<bool>`的代理对象问题。当使用`operator[]`访问元素时，返回的是一个代理对象（类似于`std::bitset`的引用），而不是真正的`bool&`。这可能导致模板代码中的问题，因为模板可能期望得到真正的引用类型。另外，与其他容器的一致性缺失也是一个问题，比如`vector<T>::data()`方法在`vector<bool>`中不存在，因为它无法返回指向连续内存的指针。 用户可能还想知道替代方案。比如，如果不需要动态大小，可以使用`std::bitset`；如果需要更自然的`bool`存储，可以考虑使用`std::vector<char>`或者`std::deque<bool>`，这些容器不会进行位压缩，但行为更接近标准容器。 另外，需要提到C++标准中对`vector<bool>`的争议。尽管它出于优化目的被特化，但由于其不符合标准容器的行为，有些情况下不被推荐使用，甚至有时建议避免使用，尤其是在需要泛型代码时，因为它可能导致模板实例化错误或未定义行为。 最后，应该给出使用示例，展示如何正确操作`vector<bool>`，同时指出可能遇到的陷阱，比如使用引用的临时性导致的悬挂引用问题。此外，比较不同替代方案的优缺点，帮助用户根据具体需求做出选择。 总结时，需要强调`std::vector<bool>`在内存效率上的优势，但在需要与其他容器一致行为或特定操作时的局限性，建议在明确需求的情况下谨慎选择，或者考虑替代方案。</think>在C++中，`std::vector<bool>` 是一个特殊的容器，其行为与其他 `std::vector<T>` 类型存在显著差异。虽然它的名称暗示存储布尔值，但实际实现可能通过**位压缩**优化存储空间，导致某些操作不符合标准容器的预期行为。以下是详细解析： --- ### 一、`std::vector<bool>` 的核心特性 #### 1. **存储优化** - **位级压缩**：每个`bool`元素仅占用**1比特**（而非通常的1字节），大幅节省内存。 例如：存储 `1000` 个布尔值仅需 `125` 字节（而非 `1000` 字节）。 - **代理对象**：通过代理类（如 `vector<bool>::reference`）间接访问位，而非直接存储 `bool` 对象。 #### 2. **与标准容器的差异** | **特性** | **普通 `std::vector<T>`** | **`std::vector<bool>`** | |---------------------|------------------------------------|----------------------------------------| | 元素类型 | 直接存储 `T` 对象 | 存储位的引用（代理对象） | | 内存布局 | 连续内存块 | 按比特压缩的位序列 | | `operator[]` 返回值 | `T&` | `vector<bool>::reference`（代理对象） | | 支持 `data()` | 返回 `T*` | **无**（无法直接获取连续内存指针） | | 迭代器行为 | 普通随机访问迭代器 | 可能返回代理对象的迭代器 | --- ### 二、潜在问题与注意事项 #### 1. **代理对象陷阱** - **无法获取 `bool&`**： 以下代码会编译失败，因为 `v[0]` 返回的是代理对象，而非 `bool&`： ```cpp std::vector<bool> v{true, false}; bool& ref = v[0]; // 错误！不能将代理对象绑定到 bool& ``` - **临时对象风险**： 代理对象的生命周期短暂，可能导致悬挂引用： ```cpp auto proxy = v[0]; // proxy 是 vector<bool>::reference 类型 v.push_back(true); // 可能导致重新分配内存 bool val = proxy; // 危险！proxy 可能引用已失效的内存 ``` #### 2. **与泛型代码不兼容** - **模板类型推断问题**： 若泛型代码期望 `vector<T>::operator[]` 返回 `T&`，则对 `vector<bool>` 会失败： ```cpp template<typename T> void process(T& container) { typename T::reference ref = container[0]; // 对 vector<bool> 可能出错 } ``` #### 3. **性能权衡** - **访问开销**：读写位需通过位运算（掩码、移位），可能比直接访问字节更慢。 - **线程安全**：多个线程修改同一字节的不同位可能导致竞争条件（需额外同步）。 --- ### 三、适用场景与替代方案 #### 1. **何时使用 `std::vector<bool>`** - **内存敏感场景**：需存储大量布尔值且内存占用是关键约束。 - **无需泛型操作**：代码不依赖容器行为与其他 `vector<T>` 完全一致。 #### 2. **替代方案** | **需求** | **推荐方案** | |-------------------------|-----------------------------------------------------------------------------| | 兼容标准容器行为 | `std::vector<char>`（用 `0/1` 表示 `false/true`，牺牲内存换一致性） | | 动态大小位集合 | `std::deque<bool>`（不压缩位，但支持快速首尾插入） | | 固定大小位集合 | `std::bitset<N>`（编译时确定大小，支持高效位操作） | | 需要真正的布尔数组 | `std::array<bool, N>`（C++17 起支持，但 `bool` 仍占1字节，无压缩） | --- ### 四、代码示例 #### 1. **`std::vector<bool>` 基本操作** ```cpp #include <vector> #include <iostream> int main() { std::vector<bool> flags {true, false, true}; // 修改位 flags[1] = true; // 通过代理对象赋值 flags.push_back(false); // 添加新元素 // 遍历（注意：auto& 会推导为代理对象的引用） for (auto&& flag : flags) { // 使用通用引用避免拷贝 std::cout << flag << " "; } // 输出：1 1 1 0 return 0; } ``` #### 2. **替代方案：`std::vector<char>`** ```cpp #include <vector> #include <iostream> int main() { std::vector<char> flags {1, 0, 1}; // 1 表示 true，0 表示 false // 直接获取引用 char& ref = flags[0]; ref = 0; // 内存占用较大（每个元素占1字节），但行为与普通 vector 一致 std::cout << "Size: " << sizeof(flags[0]) * flags.size() << " bytes\n"; return 0; } ``` --- ### 五、总结 - **优势**：`std::vector<bool>` 通过位压缩实现**极致内存节省**，适合存储海量布尔标志。 - **劣势**：代理对象导致**行为偏离标准容器**，可能引发兼容性问题。 - **建议**： - 优先使用 `std::bitset`（固定大小）或 `std::vector<char>`（动态大小+兼容性）。 - 仅在明确需要位压缩且能规避代理对象陷阱时使用 `std::vector<bool>`。 - **C++标准争议**：`std::vector<bool>` 因特化行为曾被提议从标准中移除，需谨慎对待其使用场景。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值