“朝朝暮暮”
猛戳订阅🍁🍁 👉 [C++详解专栏] 👈 🍁🍁
这里是目录
一、编码
为什么string不能针对char来写，因为编码不同，。char只能表示256个字符。
所以这时候要用模板。
string管理的是一个char*的字符串。
u16string：一个字符是两个字节
u32string：一个字符是四个字节
wstring：叫做宽字符，一个字符占两个字节
1.ASCII码
ASCII码表。是美国设计的。
ASCII码表是：计算机当中存的值，和字符的映射
但是只有256个字符的表示。用char表示
2.unicode编码
也叫做万国码。
Unicode是针对全世界的语言而设计的一种编码。
常见的有utf-8 utf-16 utf-32
3.gbk
gbk是叫做国标码。是针对中文创建的一个编码。其中还涉及台湾的。
计算机上不止有英文，还要有中文，日文等语言。但是ASCII码表不足以表示。
二、string的使用
string是C++标准库的一部分，但是不属于stl。
使用就不多讲了，详细操作多看C++参考网站。
因为你不可以全记住。记不住很正常，可以查。
网站如下。
C++reference
string是typedef出来的，原生叫做basic_string
可以很好兼容char字符。
linux下用的是utf-8，Windows一般用ASCII
string的头文件就是,C++不分头文件不分后缀。
为了和C语言的string.h做区分，所以可以不加.h。
string是属于std命名空间的。所以需要加上using namesapce std。
学习类先学习构造。
先不学C++11的右值引用。
学习string不是要学全部的函数，学习常用的函数就行，常用的函数如下。string的函数100多个，不认识的可以查文档。
1.构造函数
string类一个管理动态增长字符的数组，可以认为这个就是字符数组，因为要兼容C语言，所以结尾是\0。
注意npos是负一。负一的整形是全1，也就是**整形最大值。**这个参数是默认的，原因为，假如不给参数，给的就是整形最大值。
无参构造函数string()
千万不要在创建对象的时候加括号()。和普通函数的调用不一样。
string s1;
常量字符串构造string(const char* s)
注意：缺省参数不能给nullptr,这样传过去就崩了，只能给双引号也就是空字符串“”.
空字符串后面默认有\0
这个参数是Cstring类型的。
string s1("hello");
底层实现是开一段空间去存放所传递的hello字符串的。
为什么底层要这么麻烦？非要开一个空间，再把东西拷贝过去？
因为这样可以支持后期的增删查改。
假如直接赋值的话后期不支持增删查改。
template<class T>
class basic_string
{
public:
basic_string(const T* str)
{
size_t len = strlen(str);
//开空间，方便增删查改。
_str = new T[len+1];
strcpy(_str, str);
private:
T* _str;
size_t _size;
size_t _capacity;
}
拷贝构造string(const string& s)
string s1(s2);
2.析构函数
析构函数就简单了，析构函数是自动调用的。
3.遍历string
重载operator[] (size_t i)
第一种方式是下表+[]
string 重载下表[].
重载的意义：在于让自定义类型用着像内置类型。
内置类型是原生的指针，直接去内存空间找偏移了多少。
可以像数组一样使用下表访问其中的每个元素
重载函数[]返回的是char的引用。
返回引用的意义：在于可以支持连续赋值。这样字符可以读也可以修改。
假如是自定义类型还可以减少拷贝。
重载const[]。一般重载[]还有一个针对const对象的，const对象只可读不可修改，所以返回值类型也必须是const引用，也要在函数的括号()加上const。
方式一
相当于调的函数s1.operator[] (i);
for(size_t i = 0; i < s1.s1.size();i++)
{
cout << s1[i] << endl;
}
还有一个at()函数和重载[]效果一样，不同点在于at会检查越界，以断言的方式进行检查的。
at一般不用，都是用[].
迭代器遍历
为什么要用迭代器？现阶段学的string底层物理空间连续,可以用数组下表访问，但是当学了map等底层空间不连续的容器，用迭代器非常的方便！因为它是像指针一样的东西。
迭代器是内嵌在string整个类中。vector,list,map通用，都内嵌在各自的类中。
一般使用如下。
方式二
string::iterator it = s1.begin()
while(it != s1.end())
{
cout << *it << " ";
}
cout << endl;
迭代器是像指针一样的东西。
具体要看底层的具体实现。
重点：
begin()返回的第一个元素的位置。
end()是指向最后一个数据的下一个位置。
本质上属于左闭右开 [ )
一般迭代器的标准语法都是用不等于。这样的话可以使得vector,map,set更加的使用。因为他们不是连续的结点。地址不连续。就像vector的迭代器是封装的。
迭代器遍历也有注意点。
const迭代器：
假设有个函数func,用普通迭代器遍历不了。
普通迭代器具有读和写的能力。
形式参数是const对象接收的。假如传的是普通对象，就会报错。
void Func(const string& s){}
1.const迭代器返回的是const的迭代器对象。这样传参就不会报错了
反向迭代器的const_reverse_iterator也如此。
假如感觉类型太长了。可以用atuo来简便书写。
反向迭代器：
reverse_iterator
注意：
1.反向迭代器是倒着走的。
2.rbegin()在最后一个数据的位置。
3.rend()在第一个数据的前一个位置。
string reverse_iterator rit = s.rbegin()
while(rit != s.rend())
{
cout << *rit << " ";
}
cout << endl;
范围for
范围for是C++11的。底层还是迭代器。
实际的使用会被替换成迭代器。
在linux中使用这个语法需要加上-std=c++11
for (auto ch : s1)
{
cout << ch << " ";
}
cout << endl;
4.插入
reserve()
作用：reserve可以提前开空间只改变容量。但是在vs下不会缩容量。
push_back扩容在g++下面是1.5倍扩容的。
在vs下面是
因为扩容有代价，所以有什么方法可以减少扩容？
这时候就有一个函数就叫做reserve()
resize
作用：开空间+初始化。可以改变size
push_back(size_t i)
append
作用：一般用来在尾部插入字符串。尾插的时候使用。但是日常一般不实用，一般都用重载后的+=。
insert
作用：一般在pos位置插入字符或者字符串(对象)。
c_str()
作用：返回指向字符串的指针，可以很好地和C语言的接口配合。
find()
作用：从pos(默认为0)位置查找某个字符或者字符串。如果不匹配返回npos。
substr
作用：取得pos位置的字符串。
三、string模拟实现
string 当前不涉及模板，所以比较简单。
1.浅拷贝
strcpy拷贝的时候会把\0也拷贝过去。
浅拷贝：我们不写，编译器会默认生成一个拷贝构造函数，这个拷贝是值拷贝。也叫做浅拷贝。
浅拷贝没有写拷贝构造函数，完成值拷贝。
这样的缺点是：
1.被析构两次
2.改变一个对象，会牵涉到另一个对象。
string s1("hello");
//析构报错,同一块内存空间析构两次。
string s2(s1);
实际上内存空间不是你用完后就销毁了。而是使用权被操作系统回收了。回收后可能会分配给其他人用。
内存空间就像是你租的房子，房租到了你只会还一次，而不是还两次，你还的第二次可能是别人的房子。你不能拿着别人的房子还，因为你没有使用权。
2.深拷贝
深拷贝需要自己写。
1.先另开一个和原空间一样大的内存空间。
2.再拷贝数据。
s2(s1)
string(const string& s)
//浅拷贝
//:_str(s._str)
:_str(new char[strlen(s._str+1)])//深拷贝
{
strcpy(_str, s._str);
}
3.赋值重载构造
赋值重载是在两个都已经存在的对象赋值。
有两个问题
1.怕空间不够，空间不够没法拷贝。
2.怕空间太大，浪费了空间。
所以在实际中一般都不会直接拷贝。
1.先把原空间释放
2.再开一个和要赋值对象一样大小的新空间。
3.拷贝数据。
注意，引用返回的原因有两个。
1.出了作用域，对象没有销毁。
2.返回的是一个临时对象，临时对象还需要完成拷贝，而string完成的是深拷贝，代价有点大，所以需要返回引用。
string& operator=(const string& s)
{
delete[] _str;
_str = new char[strlen(s._str)+1];
strcpy(__str,s._str);
return *this;
}
上面代码有些瑕疵，万一开空间失败了呢？
失败了的话，不仅新空间没有了，我的_str也没了。
所以推荐下面写法。
这是传统的写法。还有一种现代写法。
string& operator=(const string& s)
{
char* tmp = new char[strlen(s._str)+1];
strcpy(tmp,s._str);
delete[] _str;
_str = tmp;
return *this;
}
4.增删查改
reserve
C++扩容不用考虑realloc。
void reserve(size_t n)
{
if(n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp,_str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
push_back
void push_back(char ch)
{
if(_size == _capacity)
{
//开空间，拷贝，释放原来空间，管理新空间
/*
char* tmp = new char[_capacity*2+1];
strcpy(tmp,_str);
delete[] _str;
_str = tmp;
_capacity *= 2;
*/
//复用reserve
reserve(_capacity == 0 ? 4 :_capacity * 2);
}
//赋值
_str[size] = ch;
++_size;
_str[_size] = '\0';
}
append
void append(const char* str)
{
size_t len = _size + strlen(str);
//如果大于当前容量,扩容
if(len > _capacity)
{
reserve(len);
}
strcpy(_str+_size,str);
_size = len;
}
operator+=
一般尾部加字符或字符串都是用+=，而不用push_back或者append.
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
resize
有三种情况。假如容量是15,_size是11.
void resize(size_t n, char ch = '\0')
{
//如果小于size
if(n < _size)
{
_size = n;
_str[_size] = '\0';
}
//如果大于size
else
{
//假如n比size大，比容量小
//如果n大于容量，也就是容量不够。
if(n > _capacity)
{
reserve(n);
}
for(size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}
insert
在任意位置前插入数据。
//在pos位置前插入字符
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
char* end = _str + _size;
//将pos位置及其之后的字符向后挪动一位
while (end >= _str + pos)
{
*(end + 1) = *end;
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
erase
npos是static的，static变量在类内声明，类外定义。
erase有个npos
这个比较有意思。
//erase删除pos位置后的len个字符，len默认为npos
string& erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
size_t n = _size - pos;
if (len >= n)//说明pos位置后面的字符全部删除
{
_size = pos;
_str[_size] = '\0';
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
5.迭代器
string迭代器没啥说的,和指针差不多,当作指针用就行。
需要注意的是：
const迭代器是返回值是const的。
因为返回值是const的，才能避免值被修改。
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
6.<<流插入
友元函数是为了访问私有，才设置的。
流插入必须写成全局的，这样out对象才能抢占第一个参数。
一般不用out << s打印字符串。
一般使用如下写法
因为输出字符串打印不出来\0.
ostream& operator<<(ostream & out, const string & s)
{
//使用范围for遍历字符串并输出
for (auto e : s)
{
cout << e;
}
return out; //支持连续输出
}
7.>>流提取
流提取的第二个参数不能加const了，因为需要放字符串到里面。
要注意不能用In >> ch 因为in 还是调用的cin不能获取空格，但是get()是从缓冲区获取字符的。
istream& operator>>(istream& in, string& s)
{
s.clear();
//in >> ch;//这样写不可以。
char ch = in.get();//读取一个字符
while (ch != ' ' && ch != '\n')
{
s += ch;//将读取到的字符尾插到字符串后面
//in >> ch;
char ch = in.get();//读取一个字符
}
return in;
}