lesson11:
一、
1.string大概有多少个接口函数？（3：2：25）
2.string在C++库的reference的XX（3：3：47）
a.我们平时用的string是下面的哪一个？（3：4：15）
3.string是一个模板吗？（3：4：46）
4.由图可知，string本质上是什么？（3：5：35）
5.wstring存的是什么类型？（3：6：8）
6.由该图可知，string本质上是XX（3：7：45）
二、Ascll码
1.为什么一个字符可以表示英美的文字？（3：10：40）（3：14：30）
2.一个char可以表示多少种状态？（3：11：15）
3.一个状态就是一个XX，对应一个XX（3：11：19）
4.在内存当中存的都是XX（3：11：25）
a.实际当中如何在屏幕上显示呢？(3：11：33)
5.Ascll就是一种XX，它能很好的表示XX（3：11：46）
6.这个是XX（3：12：10）
char a1[] = "hello";a.内存当中存的是h、e、l、l、o吗？（3：12：20）
①实际上内存中存的是XX（3：12：40）
7.计算机如何表示中文？（3：13：25）
8.中文用char能够映射下吗？（3：14：58）
9.在内存中存的是比、特吗？（3：17：10）
char a2[] = "比特";a.一个汉字由一个ascll码表示吗？（3：17：15）
①如何证明？（3：18：10）
Ⅰ.将int给char，涉及XX（3：17：45）
b.编码表是XX和XX的映射？（3：19：20）
c.ascll码是啥？（3：19：55）
①实际上内存当中存的是XX（3：20：35）
char ch= 'a';10.ascll是美国的编码表，一个字节表示X个比特位就能映射（3：22：20）
11.中文一个字节足够吗？（3：23：5）
a.一个字节能够映射XX个汉字（3：23：10）
b.两个字节能够映射XX个汉字（3：23：30）
c.所有的汉字都是两个字节吗？（3：23：56~3：24：10）
d.XX要兼容ascll码（3：24：20）
①ascll码可以用负数吗？（3：24：30）
②一般什么开头是汉字？（2种）（3：24：50~3：25：20 ）
12.打印结果是什么？（3：26：0）
char a[] = "比特";
cout << a << endl;
a[3]++;
cout << a << endl;
a[3]++;
cout << a << endl;a.同音字放在一起有什么作用？（3：27：37）
b.净网行动如何实现？（3：28：50）
①缺点（3：29：30）
Ⅰ.如何解决同音字（3：29：59）
13.utf-8中的8是什么意思？（3：32：56）
a.我中文都16个比特位了。为什么还要用utf-8？（3：33：0）
b.那要是表示全世界的文字，utf-8够用吗？（3：33：40）
①为了解决这个问题，引入了XX（3：33：50）
c.宽字符存在的原因（3：33：58）
①宽字符是几个字节？（3：34：5）
Ⅰ.宽字符有哪些？（2个）（3：34：8）
②目的（3：34：15）
14.C++的为什么要把string设成basic_string?（3：34：34）
15.unicode和utf-8、utf-16、utf-32的关系（3：34：55）
16.平时用的最多的还是char,它一般是按照XX或XX来编的（3：35：20）
a.gbk叫XX（3：35：23）
b.gbk也能兼容ascll吗？（3：35：31）
lesson12：
一、
1.红线框起来的部分表示什么？（0：12：55）
二、string的构造函数
1.string的构造函数一共重载了几种？（0：15：30）
2.对应哪个构造函数？（0：15：48）
string s1;a.调用构造函数后的结果是XX（0：17：0）
①空串是什么都没有吗？（0：17：10）
b.原始视图的作用？（0：17：20）
3.对应哪个构造函数？（0：16：14）
string s2("hello");a.调用函数后的结果中，字符串里面只有h e l l o吗？（0：17：35）
4.为什么string类可以用cin和cout？（0：18：18）
5.string的底层结构是怎样的？（0：21：45）
a._size的大小是5还是6？（0：22：45）
6.这是啥意思？（0：24：25）
string (const string& str, size_t pos, size_t len = npos);a.如果len值给大了，超过了字符串的长度，会发生什么？（0：28：53）（0：32：0）
b.如果len值不传呢？（0：30：55）
①npos是啥？（0：29：40）
7.这是啥意思？（0：32：45）
string (const char* s, size_t n);8.这是啥意思？（0：33：25）
string (size_t n, char c);9.支持这样写的原因是运算符重载吗？（0：35：35~0：36：30）
string s2 = "hello world!!!";三、析构函数
1.析构函数什么时候会被调用？(0：37：14）
四、operator=
1.赋值重载有几个？（0：37：34）
a.分别对应的实际使用写法（0：38：40）
2.本质上调用了哪些函数？（0：39：25）
string s2 = "hello world!!!";a.它和s1="XXXX"调用的区别？（0：39：33~0：40：0）
五、operator[ ]
1.有几种？（0：43：29）
a.它们调用的区别？（0：43：45）
b.它们的返回值有区别吗？（0：44：4）
c.第一种是怎么实现的？（0：44：25~0：46：5）
①引用做返回的意义（0：47：55）
Ⅰ.如何理解？(0：46：50)
s1[0] = 'x';2.[ ]的作用（0：43：33）
3.如果调用它的话，还能有修改的功能吗？（0：51：25）
const char& operator[] (size_t pos) const;a.它只能被哪种类型的string调用？（0：51：10）
4.它内部会检查越界吗？（0：56：10）
a.谁在起作用？（0：56：7）
六、size
1.我想要遍历string类并且给每个字符+1，现在有了[ ]可以+1，但是我怎么走到要遍历到多少，才能跳出while循环，遍历完？（0：49：30）
2.String类中有没有和size等价的成员函数？（0：53：45）
a.杭哥推荐用XX（0：54：5）
七、at
1.at的作用？（0：57：49）
a.它和operator[ ]的区别（0：59：5）
八、front和back
1.作用？（0：59：45）
2.它俩可以被XX等价替用（0：59：55）
九、917. 仅仅反转字母 - 力扣（LeetCode）
1.思路（1：2：25）
2.它有什么问题吗？（1：5：40）
while (!IsLetter(s[begin]))
{
begin++;
}3.如何把它替换掉？（1：6：28）
char tmp = s[head];
s[head] = s[tail];
s[tail] = tmp;4.注意：这里是<不是<= !!!
十、迭代器
1.除了上面的遍历string类的方法，还有没有其它遍历的方法？（1：28：20）
2.什么是迭代器？(1：28：47）
a.迭代器就是指针吗？（1：32：0）
3.迭代器怎么写？（1：28：55）(1：30：40)
a.什么是内嵌类型？（2种）（1：29：5）
b.类模板的迭代器怎么写？（1：31：15）
4.end()是最后一个数据的位置吗？（1：29：40）（1：33：36）
5.string建议用迭代器还是[ ]?（1：36：45）（1：37：35）
a.vector呢？（1：38：20）
b.list呢？（1：38：25）
c.map/set呢？（1：38：33）
d.底层是什么样的结构才有[ ]?(1：38：35)
6.迭代器是所有容器通用访问方式吗？（1：39：15）
7.list的底层是一个带头节点的双向循环链表吗？（1：43：20）
a.在该结构中，begin()和end(）分别指向哪儿？（1：45：10）
8.迭代器的while循环可以由下图这样改吗？（1：48：30）
9.模板在报错时的缺点（1：49：40）
10.迭代器都是左XX右XX的区间，因此，while循环都可以采用XX（1：51：25）
十一、范围for
1.除了size()、迭代器之外，还可以用XX来遍历容器（1：52：20）
2.范围for的特点（3点）（1：52：50~1：53：30）
a.范围for可用于链表这种非连续物理结构的容器吗？（1：53：53）
3.范围for的底层是XX（1：55：15）（1：58：45 ）
4.ch++后，s的值会改变吗？（2：1：0）
a.如果我想让ch的改变引起s的改变，应该怎么修改？（2：1：10）
十二、反向迭代器
1.作用（2：6：0）
2.反向迭代器怎么写？（2：6：45）
a.反向迭代器用--还是++?（2：7：35）
3.rbegin和rend分别指向哪里？（2：8：20）
4.这种带const的迭代器是什么场景使用的？（2种）（2：10：10~3：10：50）
const_iterator begin() const;a.const迭代器可以传给普通迭代器吗？（2：13：15）
b.迭代器过长，如何简化？（2：13：30）
5.迭代器一共有几种？（2：16：40）
十三、push_back
1.它只能一个字符一个字符的插入吗？（2：21：43）
2.我想插入一个字符串咋办？（2：21：57）
a.还有没有更好用的方式？（2：23：10）
十四、operator+=
1.+=后面可以跟哪些？（2：24：15）
2.它的底层会去遍历字符串找尾吗？（2：26：5）
十五、append
1.迭代器区间的作用（2：42：0）
template <class InputIterator>
string& append (InputIterator first, InputIterator last);2.打印结果是‘XXX来了’吗？（2：42：50）
string s("我来了");
string s1("XXX");
s1.append(++s.begin(), --s.end());十六、max_size
1.它的值是写死的吗？（2：46：35）
2.它的作用是啥？（2：46：40）
十七、capacity
1.作用（2：47：4）
2.查看扩容机制的代码？（2：48：35）
a.由图可知，第一次开辟的容量大小是15吗？（2：50：10）
a.容量的大小包括\0占用的空间吗？（2：50：15）
b.15表示的是什么？（2：50：27）
c.\0是XX字符（2：50：47）
十八、reserve
1.作用（2：57：55）
2.如果我用reserve申请了1000个空间，实际上它真的只给我1000个空间吗？（2：58：10）
a.它给了1007个空间吗？（2：58：18）
3.reverse的意思是XX（2：58：45）
4.reserve的意思是XX（2：58：50）
十九、resize
1.作用（3：1：10）
2.它的第二个参数要是没写，默认给的初始值是XX（3：1：48）
void resize (size_t n, char c);二十、clear
1.作用（3：2：48）
二十一：empty
1.作用（3：20：52）
二十二、shrink_to_fit
1.作用（3：2：57）
二十三、415. 字符串相加 - 力扣（LeetCode）
1.用字符串保存数字的意义（3：4：25~3：5：0）
2.思路（3：6：20）
a.可以用stoi和itoa函数吗？（3：6：26）
b.每一位的字符怎么相加？（3：7：55）
①可以直接字符相加吗？（3：8：3）
c.如何进位？
定义一个变量next,如果两字符相加>10,则让next=1,下一位字符相加时，如果next=1,则相加结果还要加1.
d.循环终止的条件（3：9：50）
①为什么不可以一个字符串结束了，另一个字符串直接拷贝下来？（3：10：25 ）
e.这么写错误的原因是什么？
string addStrings(string num1, string num2)
{
string c1 = num1.end();
}f.这样写，有什么问题？（3：14：10）
while (end1 >= 0 || end2 >= 0)
{
int n1 = num1[end1] - '0';
int n2 = num2[end2] - '0';
//...
}①如果不用if判断，还可以怎么修改?（3：14：55）
g.如何将字符数字转化为整型数字？（3：15：50）
注意：这种方式仅针对字符有用，字符串不行！！！
h.string类有提供头插的接口吗？为什么？（3：18：7）
①那我就是打算头插，有解决方法吗？（3：18：20）
②这样写，可以吗？(3：19：39)
int n=...
sum.insert(0, 1,n);Ⅰ.整型怎么换成字符？（3：19：50）
Ⅱ.如何写成迭代器的重载类型（3：23：25）
i.如何将下列的写法替换成三目运算符形式？（3：21：25）
next = 0;
if (n >= 10)
{
next = 1;
n = n / 10;
}j.为什么运行效率很低？（3：28：20）
①如何修改，才能提高效率？（3：29：22~3：31：50）
Ⅰ.string有逆置接口吗？（3：30：44）
lesson13:
一、insert
1.必须要记住的4个重载（0：9：23）
2.在空格处插入20%
string str("wo lai le");a.这么写有什么问题吗？（0：11：40）
string str("wo lai le");
for (size_t i = 0; i < str.size(); i++)
{
if (str[i] == ' ')
{
str.insert(i,"20%");
}
}
cout << str << endl;①如何修改？（0：15：25）（0：16：35）
3.将空格替换成20%
a.额外借助了哪个接口？（0：18：25）
4.为什么不可以直接用挪动的方法来将20%插入？（0：22：25）
a.如果我就是要挪动数据来解决问题，应该怎么办？（0：23：2）
5.如何用以空间换时间的方法来优化解决这个问题？（0：25：15）
6.如何用一个接口解决上面的问题？（0：28：45）
二、erase
1.不给参数的话，会发生什么？（0：19：6）
string& erase (size_t pos = 0, size_t len = npos);三、replace
1.replace的效率怎么样？（0：29：9）
四、c_str
1.作用（0：30：19）
2.使用场景（0：31：50~0：33：10）
a.读取当前文件内容的代码（0：34：15）
b.它俩的打印原理是一样的么？（0：36：20）（0：37：34）
string filename("Test.cpp");
//1.
cout << filename << endl;
//2.
cout << filename.c_str() << endl;①日常打印的时候，它俩使用上没区别，什么时候才不一样？（0：38：45）
②它俩的底层区别是什么？（0：40：10）
3.C语言的strlen、strcpy....接口的缺点是XX（0：41：10）
a.\0是有效的显示字符吗？（0：42：18）
①什么是不显示字符？（0：42：43）
②那我如何才能看到\0？（0：43：5）
Ⅰ.它只有这一个\0吗？（0：43：12）
Ⅱ.上图中的\0是标识字符吗？（0：43：19）
Ⅲ.打印结果是什么？（0：43：50）
b.监视窗口的小bug（0：44：15）
五、data
1.作用（0：45：30）
六、
1.0~127的ASCLL码打印出来的结果是什么？（0：47：58）
a.char来定义会出现什么问题？（0：47：30）
2.可以将\0打印出来吗？（0：49：43）
cout << '\0' << endl;a.如果我想打印\0怎么办？（0：49：55）
①此时的长度是多少？（0：50：3）
七、find
1.有几种？（0：51：40）
2.
size_t find (const char* s, size_t pos, size_t n) const;a.pos是什么意思？（0：51：3）
b.n是什么意思？（0：52：55）
3.如果没有找到，会返回什么？（0：55：5）
a.如果返回失败，if判断怎么写？（0：56：33）
①npos本质上是一个XX（0：56：41）
八、substr
1.作用（0：56：5）
2.如果我想取find的返回值之后的字符串，这么写正确吗？（0：57：25）
3.如果len大于pos位置后面的字符串长度，那么会取到何处终止？（0：58：40）
string substr (size_t pos = 0, size_t len = npos) const;4.如果我想取最后一个后缀，怎么办？（1：0：15）
九、rfind
1.使用场景：分割网址（1：2：15）
a.如何根据://取协议？（1：10：25）
b.如何取域名（1：13：25）
①怎么算域名的长度？（1：15：0~1：16：10）
十、find_first_of
1.和find的区别是什么？（1：43：25）
十一、find_last_of
1.作用（1：45：17）
十二、find_first_not_of
1.作用（1：45：35）
十三、operator+
1.作用（1：46：3）
a.和+=相比，更推荐使用XX
十四、relational operators
1.作用（1：47：0）
2.只能和string比较吗？（1：47：19）
a.是根据XX进行比较的（1：47：24）
十五、operator>>和operator<<
十六、getline
1.字符串最后一个单词的长度_牛客题霸_牛客网 (nowcoder.com)
a.结果是size()-pos吗？（1：51：18）
①应该怎么修改？（1：51：55）
b.能成功运行吗？（1：52：0）
string str;
cin >> str;
size_t pos = str.rfind(' ');
if (pos != string::npos)
{
cout << str.size() - pos - 1 << endl;
}
else
{
cout << str.size() << endl;
}c.我想要输入年月日，请问sanf和cin是怎么间隔的？（2种）（1：53：50）
①它是怎么看待你输入的 hello nowcoder?（1：56：0）
Ⅰ.验证（1：57：0）
d.如何解决cin带来的空格问题？（1：57：20）
①cin是istream的XX（1：57：27）
②delim的作用？（1：57：33）
③如何写？（1：58：35）
十七、和string相关的转换函数（1：59：12）
1.atoi的作用？（1：59：35）
2.itoa的作用？（1：59：47）
3.stoi的作用？（2：0：30）
十八、to_string
1.作用（1：59：57）
2.演示整型转string，string转整型（2：4：30）
十九、力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
1.为什么数组下标是26？（2：16：20）
2.要遍历一遍计数，如何便利for?（2：17：10）
3.如何将字符转化为整型下标？（2：17：18）
4.这是在干嘛？（2：17：35）
for(auto ch : s)
{
countArr[ch-'a']++;
}
二十、125. 验证回文串 - 力扣（LeetCode）
1.大写字母如何转化为小写字母？（2：24：0）（2：26：40）
二十一、模拟实现string（2：4）
1.要写成类模板吗？（2：47：52）
2.如下程序，模拟实现string时，类名和库中的string同名，为了进行区分，应该怎么办？（2种）
class string
{
//...
};a.第一种（2：49：3）
b.第二种（2：49：9）
二十二、构造函数
1.可以这样写吗？(2：50：40)
string(const char* str)
:_str(str)
{}a.为什么？（2：50：49）
b.怎么修改？（2：52：40）
①_capacity包含\0吗？（2：53：33）
2.如下，开辟完空间后，如何拷贝？（2：54：35）
string(const char* str)
:_str(new char[strlen(str)+1])
,_size(strlen(str))
,_capacity(strlen(str))
{
//拷贝？
}3.这种写法还有问题吗？（2：55：40）
string(const char* str)
:_str(new char[strlen(str)+1])
,_size(strlen(str))
,_capacity(strlen(str))
{
strcpy(_str,str);
}a.为什么_str只开一个空间，我们也要用[ ]？（2：55：22）
string()
:_str(new char[1])
,_size(0)
,_capacity(0)
{}①还有什么要补充的吗？（2：57：15）
b.改成这样，有什么问题？(2：59：44)
string()
:_str(nullptr)
,_size(0)
,_capacity(0)
{}a.这样写，析构的时候会有问题吗？为什么？（2：58：14）
4.现在要把它改成全缺省的构造函数，缺省值怎么给，给个nullptr吗？（3：3：0）
string(const char* str)
:_str(new char[strlen(str)+1])
,_size(strlen(str))
,_capacity(strlen(str))
{
strcpy(_str, str);
}a.那给什么？（3：3：25）
①strlen("\0")等于XX（3：4：5）
b.现在我不想给"\0"'了，还可以给什么？（3：5：5）
①为什么它可以代替"\0"？（3：5：30）
c.常量字符串默认会在后面XX（3：5：45）
①”\0“本质上是XX（3：5：40）
②" "本质上是XX（3：5：45）
5.strlen的时间复杂度是XX（3：7：17）
6.如何优化它的时间复杂度？（3：8：0）
string(const char* str = "")
:_str(new char[strlen(str) + 1])
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}a.改成这样可以吗？（3：8：55）
string(const char* str = "")
: _size(strlen(str))
, _capacity(_size)
, _str(new char[_capacity + 1])
{
strcpy(_str, str);
}①try catch捕获的错误打印出来是什么？（3：10：40）
②修改声明的顺序，有什么问题？（3：12：0）
③怎么修改最好？（3：12：50）
④我要是在声明处给缺省值呢？（3：14：30）
二十三、析构函数（2：56：55）
二十四、c_str（2：59：5）
二十五、size（2：17：10）
二十六、operator[ ]
1.返回值是char吗？（3：17：25）
2.如果pos是size_t类型的，那么assert检查还需要这么写吗？（3：18：0）
assert(pos >= 0 && pos <= _size - 1);3.const string 类型的对象调不了它，怎么办？（3：19：20）
4.为什么size函数只需要写一个？（3：19：30）
二十七、迭代器
1.iterator是由XX经过typedef来的（3：21：20）
2.为什么我在模拟实现string的时候，明明没有写范围for，可它却支持了？（3：25：30）
3.普通迭代器可读可写吗？（3：28：0）
二十八、begin（3：21：50）
二十九、end（3：22：7）
三十、const 迭代器
1.怎么来的？(3：27：47 )
2.对于const对象，应该使用XX（3：27：40）
3.const迭代器的特点（3：27：47）
lesson14:
一、拷贝构造
1.在还没有写流提取和流插入以前，怎么用cout打印对象？（0：3：50）
qkj::string s("hello");
cout << s << endl;2.在没有写拷贝构造的情况下，下列代码会发生什么？（0：4：10）
qkj::string s1("hello");
qkj::string s2(s1);
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;a.崩溃的原因（0：4：28）
b.为什么它俩会指向同一块空间？（0：4：49~0：5：）
①它是怎么拷贝的？（0：5：30）
②s1和s2是指向同一块空间吗？（0：6：5）
③析构的时候会发生什么？（0：6：13）
④s1和s2谁先析构（0：6：30）
⑤释放置空s2对象，对s1有影响吗？（0：7：0）
Ⅰ.析构完s2后，_str变成XX（0：7：30）
c.所有的类都不可以用默认生成的拷贝构造吗？（0：8：22）
3.应该怎么写拷贝构造？（0：9：25~0：9：45）
4.实现（0：12：0）
5.监视窗口只能观察XX的变量（0：12：44）
6.我想将s3的值赋给s1，使用默认的赋值运算符，能正常运行吗？（0：15：30）
qkj::string s3("1111111111");
s1 = s3;a.这里的赋值是一种XX（0：15：47）
b.s1会发生XX（0：16：36）
二、赋值运算符
1.怎么实现赋值？
a.思路一：
①如果容量够，XX（0：27：30）
Ⅰ.够就一定好吗？（0：27：55~0：28：50）
②如果容量不够，XX（0：27：30）
b.思路二：（0：29：4）
2.这样写，有什么问题？（0：35：45 ）
a.返回值返回什么？（0：31：58）
b.怎么修改？（0：36：45）
3.这种写法，有什么问题吗？（1：37：33）
string& operator=(const string& s)
{
if (this != &s)
{
delete[] _str;
_str = new char[s._capacity + 1];
_size = s._size;
_capacity = s._capacity;
strcpy(_str, s._str);
}
return *this;
}a.new失败，会造成什么后果？（0：38：3）
b.怎么修改？（0：38：17）
①这种写法下，判断自己给自己赋值还有必要吗？（0：39：45）
三、拷贝构造的现代写法
1.这种被称之为拷贝构造的XX写法（0：41：30）
string(const string& s)
:_str(new char[s._capacity + 1])
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str);
}2.现代写法的特点：更XX但是更XX、更XX（0：41：51）
3.现代写法是XX思维（0：42：50）
4.怎么实现（0：44：15）
a.这种写法能正常运行吗？（0：46：20）
b.这种写法的实现思路（0：46：40）
c.崩掉的原因是什么？（0：47：40）
d.怎么修改？（0：48：7）
①delete 空指针会报错吗？（0：48：17）
②思路（0：49：50）
③为什么swap会报错？
因为传进来的参数是用const修饰了，你用swap就是在修改，会和const冲突
5.swap函数的实现
a.如何将函数名swap和调用的全局的swap区分开？（0：52：50）
b.使用库里的swap时，要么把std库展开，要么std::指明去std库里找。
四、赋值运算符的现代写法
1.思路（0：59：55）
2.实现（1：1：40）
a.选哪个？（1：2：0）
string tmp(s._str);
string tmp(s);b.析构函数析构的是tmp交换前的空间还是交换后的空间？（1：2：50）
五、swap函数
1.string::swap和std::swap函数有什么区别？（1：10：20）
2.它们会构成函数重载吗？（1：10：50）
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}a.你不加::会发生什么？（1：11：5）
3.哪个swap代价更高？（1：11：25）
4.可以把它换成::swap(*this,tmp)吗？（1：14：24）
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(tmp);
}
return *this;
}a.什么情况下会发生栈溢出？（1：14：44）
b.为什么会发生栈溢出？（1：14：55~1：15：45）
5.可以这样写吗？（1：17：30）
string& operator=(string s)
{
swap(s);
return *this;
}a.一定得用传值传参吗？（1：17：50）
b.谁是打工人？（1：17：53）
六、push_back
1.思路（1：42：48）
2.如果调用reserve函数扩容，怎么处理容量为0的特殊情况？（1：49：30）
3.实现（1：50：20）
a.末尾需要单独添加\0吗？（1：50：30）
①如果不添加\0，会出什么问题？（1：52：20）
七、reserve
1.扩容的前提（1：45：8）
2.是原地扩吗？（1：45：57）
3.我输入的扩容空间是n,为什么实际开的时候是n+1?（1：47：14）
4.实现（1：47：55）
八、operator+=
1.实现+=字符（1：56：55）
2.实现+=字符串（2：13：20）
九、append
1.思路（1：59：50）
a.if判断==意味着什么？（2：0：18）
b.能不能扩容扩2倍？（2：0：55）
c.扩容怎么扩？（2：2：55）
d.拷贝的时候怎么拷？（2：4：15）
①_str+_size处于什么位置？（2：4：30）
e.还需要写这个吗？
_str[_size] = '\0';不需要，因为拷贝的是字符串，字符串里有\0
2.实现（2：5：50）
3.可以把strcpy换成strcat吗？（2：8：25）
a.
strcat(_str,str);①strcat追加，是从XX开始追加的（2：9：29）
②strcat最大的问题是什么？（2：10：8）
③实际上，strcat尽量XX（2：10：26）
④怎么修改？（2：11：52）
4.append支持指定位置追加吗？（2：15：24）
5.如何实现append(const string& s)?（2：16：50）
6.如何实现append(size_t n,char ch)?（2：19：0）
十、insert
1.pos能否等于_size?（2：24：8）
2.返回值和返回值类型有意义吗？（2：27：33）
3.这种写法哪里有问题？（2：30：8）
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
//if pos=0
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size;
while (end >= pos)
{
_str[end + 1] = _str[end];
--end;
}
_str[pos] = ch;
_size++;
return*this;
}a.把end的类型改成int，可以解决上面的问题吗？（2：30：45）
①为什么？（2：31：3）
Ⅰ.怎么进一步修改，可以防止转型提升？（2：31：8）
b.更好的解决方案是XX（2：31：54）
4.如何实现insert(size_t pos,const char* str)?
a.如何挪n个空间出来？
①end还是指向_size的位置吗？（2：49：35）
②每次执行的挪动指令是_str[end] = _str[end - 1]吗？（2：50：20）
③循环终止的条件是end>pos吗？（2：53：25）
b.挪完以后，可以用strcpy把数据放进去吗？（2：55：5）
①那应该怎么把数据放进去？（2：55：20）
5.有了insert以后，push_back怎么修改？（2：58：20）
十一、erase
1.npos是啥？（2：59：40）
2.静态成员变量就只能在类外面定义初始化吗？（3：0：40）
3.如果删除的长度超过了剩余的长度，还需要挪动数据吗？（3：3：50）
a.对应的两种情况（3：5：30）
b.怎么处理？（3：5：55）
4.如果删除的长度没有超过剩余的长度：
a.处理思路（3：7：45）
b.不用覆盖，怎么处理？（3：8：35）（3：9：30）
十二、operator<<
1.形参只有const string& str吗？（3：16：15）
2.为什么返回值类型是ostream& ?（3：16：23）
3.operator必须是友元吗？（3：16：52）
a.为什么（3：17：32）
4.实现（3：18：30）
5.它俩什么时候不一样？（3：20：0~3：20：40）
string s1("hello");
cout << s1 << ndl;
cout << s1.c_str() << endl;十三、operator>>
1.可以向流提取那样，用in>>ch获取数据吗？（3：21：45）
a.这样去拿，拿不到XX和XX（3：21：57）
2.接收字符串的时候，字符串默认是以XX为间隔的？（3：22：40）
3.空格和换行对应的字符是分别是XX（3：25：10）
4.这样写，正确吗？（3：24：55）
istream& operator>>(istream& in, string& s)
{
char ch;
in >> ch;
while (ch != ' ' && ch != '\0')
{
s += ch;
}
return in;
}
a.为什么？（3：26：0）
b.怎么修改？（3：27：45）
c.如果输入很多，+=要频繁扩容，效率很低，怎么优化？
lesson15:
一、
1.string和顺序表的区别？（0：1：20~0：2：5）
2.cout<<s1的等价写法是（0：3：0）
3.对operator>>,如果输入很多，+=要频繁扩容，效率很低，怎么优化？
istream& operator>>(istream& in, string& s)
{
char ch;
in >> ch;
while (ch != ' ' && ch != '\0')
{
s += ch;
}
return in;
}a.一上来就reserve扩容128，有什么缺陷？（0：9：0）
b.怎么修改？（0：11：5~0：16：30）
①思路（0：15：10）
Ⅰ.i=0的作用？（0：15：35）
②要是添加的字符不够N怎么办？（0：16：5）
③buffer[N]相当于string的XX（0：19：29）
4.可以这样定义吗？（0：21：40）
string s3("hello"), s4;5.假如我字符串本身初始化了一个字符串，然后再用刚刚写的流插入函数，会发生什么？（0：22：0）
a.库里面的流插入也是这样的吗？（0：22：40）
b.如何修改？（0：22：55）
二、clear
1.实现（0：23：30）
三、find
1.find(char ch, size_t pos = 0)的实现（0：25：15）
a.没有找到时，返回什么？（0：25：10）
2.C语言中专门用来查找子串的库函数（0：25：30）
3.我们得到的是指针，怎么转化为下标？（0：27：35）
4.实现？（0：28：25）
5.kmp算法的效率很高吗？（0：29：30）
6.bm算法（0：29：52）
7.我们写的是XX匹配算法（0：30：35）
8.前提（0：46：15）（0：46：35）
四、substr
1.前提（0：33：50）
2.对于左毕右开的字符串，它的长度怎么算？（0：37：19）
3.实现（0：39：40）
五、operator>
1.它是比较长度吗？（0：46：15）
2.C语言中，用来比较字符串大小的库函数（0：49：57）
3.实现（0：50：25）
六、operator==
1.实现（0：50：45）
七、operator>=
1.任何类，只要写比较大小，只需要写XX个，其余复用（0：51：15）
八、operator<
1.小于可以写成XX取反（0：52：5）
九、resize
1.resize可以将size变小吗？（0：59：25）
2.如果newsize大于size呢？小于size呢？（1：0：55）
3.实现（1：4：25）
十、
1.它们的结果一样吗？（1：9：50）
int main()
{
string s0;
string s1("123456");
string s2("123456789");
cout << sizeof(s0) << endl;
cout << sizeof(s1) << endl;
cout << sizeof(s2) << endl;
}
