目录
问题三:string与vector的capacity大小设计的特点
前言:
前几篇文章我们已经介绍完了string,vector,list的使用与string的使用原理,但是仅仅知道这些对于我们日常使用来说已经够了,但是在我们日常使用的时候,不免会有报错与相关的疑惑,那么这里我介绍几个我认为有问题的地方,后续有问题的话,还会继续补充。
问题一:关于string的''\0''问题讨论
之前在某篇文章中看到,C语言字符串是以'\0'结尾的,但是C++string类型的字符串并不是以'\0'结尾。话不多说,直接放代码(vsX86环境):
#include<iostream> #include<string> using namespace std; int main() { string b("abc"); cout << b.capacity() << endl; cout << b.size() << endl; if (b[3] == '\0') cout << "yes" << endl; else cout << "no" << endl; return 0; }
运行结果:
.
可以看到我们创建的这个string,他的容器大小为15,这个string存储大小为3,但是我们却可以通过越界访问 b[3] ,并且通过验证字符串的结尾就是'\0'。此时我的内心是疑惑的,心想"abc"是C语言风格的字符串给b构造,肯定会把"abc"后面影藏的'\0'给构造进去,如果不会这样就会在迭代器里面不会遇见结束表示符。那么至于这里的结尾的最后一个'\0',从结果来说是大小size不计算的,所以大小size是3。
但是我们又尝试别的构造的话又会尝试别的疑惑,比如这个代码:
#include<iostream>
#include<string>
using namespace std;
int main()
{
string b("abcd",3);//这种构造方法是通过字符串abcd,然后只取前3个字符进行构造string
//但是这个字符串存放的其实是 abcd\0
cout << b.capacity() << endl;
cout << b.size() << endl;
if (b[3] == '\0')
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
}
结果跟上面一模一样。此刻我又想,构造函数会在末尾自动添加一个'\0',并且size和capacity函数都不计算'\0'的。
但是我们一开始是假设他跟c语言的风格相似的会把abc后面的'\0'会自动添加上,但是我们这个代码是只取了abcd\0这个字符串的前三个,没有'\0'啊~!
所以此刻,我肯定是矛盾的!!因为最开始说string字符串是不以'\0'结尾的,但是测试下来,确实是以'\0'结尾的。
哎呀~为什么呢?经过查阅资料后,才得知了其中的奥妙,奥妙如下:
std::string:标准中未明确规定需要\0作为字符串结尾。编译器在实现时既可以在结尾加\0,也可以不加。(因编译器不同,就比如vs就不用)
但是,当通过c_str()或data()(二者在 C++11 及以后是等价的)来把std::string转换为const char *时,会发现最后一个字符是\0。但是C++11,string字符串都是以'\0'结尾(这也是c++祖师爷为以前的自己的规定的优化)。
为什么C语言风格的字符串要以'\0'结尾,C++可以不要?
c语言用char*指针作为字符串时,在读取字符串时需要一个特殊字符0来标记指针的结束位置,也就是通常认为的字符串结束标记。而c++语言则是面向对象的,长度信息直接被存储在了对象的成员中,读取字符串可以直接根据这个长度来读取,所以就没必要需要结束标记了。而且结束标记也不利于读取字符串中夹杂0字符的字符串。
这里我们深入一下string的构造时的细节:
#include<iostream> #include<string> using namespace std; int main() { int aa = 0; printf("栈区的地址:%p\n", &aa); int* pl = new int; printf("堆区的地址:%p\n", pl); string a("abcddddddddddddddddddddddddd", 20); printf("a的地址: %p\n", &a); printf("a[0]的地址: %p\n", &a[0]); a[1] = 'X'; cout << a << endl; printf("a的地址: %p\n", &a); printf("a[0]的地址: %p\n", &a[0]); string b("abc"); printf("b的地址: %p\n", &b); printf("b[0]的地址: %p\n", &b[0]); return 0; }
然后通过运行的知,
用红色标注出来的是在栈上存储的,蓝色标注的时在堆上存储的,然而a,b就与指针类似,他们指向一片空间,空间内存储的对象信息, 对象地址分别是006FF6AC与006FF688,他俩的地址跟栈区地址最为接近所以该对象存储在栈区上。同理a[0]是堆区上,但是b[0]按道理也应该是在堆区上,但是为什么会是是在栈区上呢?其实这是c++的一个特殊处理,这里留下一个小疑问,(下一个问题进行解答,这里先给出为什么的答案:当string内存存储的个数在16以内(包括'\0')(后面解释为什么是16)在栈上,超过以后在堆上。)
所以,string在构造函数的时候,会在堆上开辟一块内存存放字符串,并且指向这块字符串。
(这里给大家提问一个小问题:就是为什么a先定义的,但是a对象地址为什么比b的大?)
解答:a、b是两个局部对象变量,栈是向下增长的,所以先入栈的变量地址高,即&a > &b,
问题二:C++标准库中的string内存是分配在堆上面吗?
例如我声明一个string变量。
string str;
一直不停的str.append("xxxxx");时,str会不停的增长。
我想问的是这个内存的增长,标准库中的string会把内存放置到堆上吗?
另外STL中的其他容器是否遵循相同的规则。
首先我们给出结论:16以内在栈上,超过以后在堆上。(这句话的答案省略上面的问题的前提条件:【在栈上构造的 string 对象】,如果string 是 new 出来的即在堆上构造的,当然内部的缓冲区总是在堆上的)。(vector也是如此,但是细节上略有不同)
为什么要这样做呢?
如果以动态增长来解释就是:
因为栈通常是一种具有固定大小的数据结构,如数组实现的栈在创建时会指定一个固定的容量。因此,一般情况下,栈是不支持动态增长的。
所以是存储在堆上的。
其实还有另一个原因,那么下一个问题给出解答;
问题三:string与vector的capacity大小设计的特点
在我们设计string与vector的时候,你是否观察过他的capacity的大小呢?就比如vs里面为什么会让string与vector在其存储的内存个数小于16时会将数据存储在栈上,大于16存储在堆上呢?
这是因为string与vector第一次会在栈上开辟空间,直接开辟16个单位空间,然后挨个进行流提取,这样的话就会方便很多 ,就算要再添加数据,也不需要进行动态增长,然后这个16个单位空间就是string与vector的capacity。这里的证明可以通过调试自己查看他的capacity,当然编译器不同,可能这个首次开辟空间大小略有不同,但是不影响。
总的来说这两种解释都是解决的次要问题,他这样设计主要为了解决内存碎片的问题;如果存储的内容大小小于16,他就会先存在栈上的数组里面,当大于16,就会进行拷贝到堆上,然后栈上的数组就会进行浪费,这样达到了利用空间换时间的效果
问题四:string的流提取问题
首先如果我们自己实现string的流提取,我们会下意识认为会挨个提取输入的字符,然后挨个与s进行对接,代码试下如下: (这个代码实现的流提取是完全没有问题的)
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
但是这样写会有一个弊端,就是会多次进行扩容,俗话常说:扩容本身就是一件麻烦的时,浅拷贝就不多说了,深拷贝就更麻烦了;
所以后来就进行了优化,会先开辟一个数组,然后将流提取的字符挨个放到数组里面,当数组满的时候(或者流提取的字符提取完了)我们当让s+=数组;这样既保证了存储的数据在堆上,也避免了多次进行扩容;(需要注意的是我们要自己添加 '\0' 在string的末尾)
istream& operator>>(istream& in, string& s)
{
s.clear();
char buff[129];
size_t i = 0;
char ch;
//in >> ch;
ch = in.get();
s.reserve(128);
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 128)
{
buff[i] = '\0';
s += buff;
i = 0;
}
//in >> ch;
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
当然这上面的两个问题都是存在于string于vector上的,因为他们存储的数据是连续的,二list作为链表就不存在这样的问题。
问题五:迭代器失效
然而迭代器失效就不一样了,string,vector,list都存在。
在我们使用迭代器进行遍历的时候,不免会出现不正当的使用而使其迭代器失效;
失效的主要原因就是:迭代器对应的指针所指向的空间已经被销毁了,而使用一块已经被释放的空间的时候,就会造成程序崩溃(即如果继续使用已经失效的迭代器, 程序可能会崩溃)。俗话来说就是野指针了。
前面我们都在用string来进行解释,这里我们使用vector来解释,
1
就比如下面这个代码:
include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v(10, 1);
auto it = v.begin();
v.insert(it, 0);
(*it)++;
return 0;
}
看起来没有问题,但是我们是先给迭代器赋值,然后进行插入,但是有一点问题就是如果插入时恰好进行扩容,并且时异地扩容,那么这个it就会变为野指针。从而达到迭代器失效的问题。
2
同样插入存在异地扩容,当然删除也存在着迭代器失效的问题;
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v(10, 1);
auto it = v.end() - 1;
v.erase(it);
(*it)++;
return 0;
}
这时候如果再进行使用it,那么就会报错。
注意:
- vs 对于迭代器失效检查很严格,如使用了 erase 之后,之前的迭代器就不允许使用,只有重新给迭代器赋值,才可以继续使用
- Linux下,g++编译器对迭代器失效的检测并不是非常严格,处理也没有vs下极端。
问题六:Vector 最大 最小值 索引 位置
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<double> v{ 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
vector<double>::iterator biggest = max_element(begin(v), end(v));
cout << "Max element is " << *biggest << " at position " << distance(begin(v), biggest) << endl;
auto smallest = min_element(begin(v), end(v));
cout << "min element is " << *smallest << " at position " << distance(begin(v), smallest) << endl;
return 0;
}
运行结果:
到这里就完了,写作不易还请点赞;