string------1
文章目录
- 一. STL
- 1.概念
- 2.版本
- 二. string类
- 2.1 为什么学习string类
- 2. 标准库中的string类
- 2.2.1 构造(7个)
- 2.2.2 对string类对象进行“访问和修改”
- (1)operator[]
- (2)迭代器
- 1.迭代器的使用
- 2.迭代器的价值(list)
- 3. 为什么有operator[]之后还需要迭代器
- (3) 范围for
- 三. 补充的小知识点:auto(语法糖)
- 1.auto介绍
- 2.auto的使用价值
- 四. 补充的小知识点:范围for(语法糖)
- 1.使用
- 2. 两个语法糖融合
- 二. string类的2.2.3
- 2.2.3 反向迭代器
- 2.2.4 const迭代器
- 2.2.5 const反向迭代器
- 2.2.6 Capacity相关的
- 1. size()和length()
- 2. max_size()
- 3. capacity()
- 4. clear()
- 5. empty()
- 2.2.7 Element access(元素访问)相关的
- operator[](前面已经了解)
- 1. at
- 3. back
- 4. front
- 2.2.8 修改相关的
- 1. 尾插一个字符push_back
- 2. 尾插一个字符串append
- 3. operator+=
一. STL
1.概念
STL(standard template libaray-标准模板库):是C++标准库的重要组成部分,不仅是一个可复用的组件库,而且是一个包罗数据结构与算法的软件框架。
2.版本
- 原始版本
Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本,本着开源精神,他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码,无需付费。唯一的条件就是也需要向原始版本一样做开源使用。 HP 版本–所有STL实现版本的始祖。
P. J. 版本
由P. J. Plauger开发,继承自HP版本,被Windows Visual C++采用,不能公开或修改,缺陷:可读性比较低,符号命名比较怪异。
RW版本
由Rouge Wage公司开发,继承自HP版本,被C+ + Builder 采用,不能公开或修改,可读性一般。
SGI版本
由Silicon Graphics Computer Systems,Inc公司开发,继承自HP版 本。被GCC(Linux)采用,可移植性好,可公开、修改甚至贩卖,从命名风格和编程 风格上看,阅读性非常高。我们后面学习STL要阅读部分源代码,主要参考的就是这个版本。
二. string类
2.1 为什么学习string类
- C语言中,字符串是以’\0’结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问。
2. 标准库中的string类
string是在STL之前,并没有什么参考,它是独立弄出来的。so它可能偏乱偏多一些
- 首先,我们要学会看文档(此处注意,句子里的单词翻译的顺序并不是最佳的,只是反映了自己翻译时的第一反应)
string是在STL之前就设计出来了,所以比较复杂,总共有100多个接口(什么是接口,就是提供给我们,可以去调用的),但是我们只需要记住重要的20多个,剩下的使用时查询即可。
- 使用string类的时候,必须包含头文件
#include<string>
以及using namespace std
(这个可以选择不写) - string实际上是个模板,但是它的参数一定确定了,so我们不太用关注它。
- 先使用默认构造,构造一个空的字符串。
std::string str1;
2.2.1 构造(7个)
我们可以先简单看一看接口,进行猜测(它的参数的名字都是有意义的,所以猜测的还是很接近的)。具体的内容看下面的接口介绍
记住:initialize是初始化
规定:string的结尾一定是‘\0’结尾
#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{//1.创建空的字符串string str1; //构造空的string类对象str1//2.填充:string(size_t n, char c);string str2(5, 'r'); //用5个'r'初始化cout << str2 << endl;//3.copy--->string(const string & str);string str3(str2); //用str2初始化str3cout << str3 << endl;//4.from c-string--->string(const char* s);char s1[5] = "abcd";string str4(s1); //用字符串s1初始化str4cout << str4 << endl;//5.将字符串s的地址传过来,复制n个它的字符:string (const char* s, size_t n);char s[4] = { 'a','b','c','d' };string str5(s, 3); //用字符串s的前三个字符初始化str5cout << str5 << endl;//注意:字符串传递过去默认也是首地址string str6("abcd", 3); //常量(const)字符串的类型的地址是const char*cout << str6 << endl;//6.substring--->string(const string & str, size_t pos, size_t len = npos);string str7("abcdefghijklmn",14);string str8(str7, 3, 9);cout << str8 << endl;//如果没有写复制几个字符,则拷贝到str7结束string str9(str7, 3);cout << str9 << endl;return 0;
}
2.2.2 对string类对象进行“访问和修改”
一共有三种方法:下标+方括号;迭代器;范围for(看目录,在最后面写着呢)
(1)operator[]
std::string::operator[]
的底层大致意思是:
class string
{
public:char& operator[](size_t pos){assert(pos < _size);//防止越界return _str[pos];}
private:char* _str;size_t _size;size_t _capacity;
};
它是用来返回pos这个位置的字符的别名。
接下来,如何使用operator方括号呢?
- 可以用来修改某个位置的字符(因为是引用返回,so可直接修改)
#include<stdio.h>
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;
int main()
{//char& std::string::operator[](size_t pos)string str1("abcdefg");//str1.operator[](0)='p';str1[0] = 'p';std::cout << str1 << std::endl;return 0;
}
- 可用来遍历string的每个字符
int main()
{string str1("abcdefg");for (size_t i = 0; i < str1.size(); i++){cout << str1[i] << " ";}return 0;
}
循环遍历,将每个字符都加1
int main()
{string str1("abcdefg");for (size_t i = 0; i < str1.size(); i++){//将所有的字符都加1str1[i]++;}
- 可以很好的防止越界
这个返回值不可以被修改
(2)迭代器
1.迭代器的使用
在此先声明,迭代器会先学习4种:迭代器,反向迭代器,const迭代器,const反向迭代器
(像指针一样的东西,但并不是指针)
- 迭代器的使用
begin()返回第一个位置的迭代器
end()指的是最后一个有效字符的下一个位置(即\0)的迭代器(\0是标识字符,不是有效字符)
#include <iostream>
#include<stdio.h>
#include<assert.h>
#include<string>
using namespace std;
int main()
{string str1("hello world");//在string这个类里面,有iterator这个类型
// 类域 :: 类型 定义的对象 begin()返回第一个位置的迭代器string::iterator it1 = str1.begin();while (it1 != str1.end()) //end()指的是最后一个字符的下一个位置// 不到最后一个\0{cout << *it1 << " "; //it1是地址it1++; //++就到下一个地址了,在解引用就是下一个字符}//在字符串打印完之后,换行cout << endl;return 0;
}
同样的,在遍历读取的时候,也可以修改数据。
while (it1 != str1.end())
{(*it1)++;cout << *it1 << " "; it1++;
}
如果像倒着遍历,则使用反向迭代器
2.迭代器的价值(list)
(链表的那个list,带头双向循环的链表)
list的遍历和修改只能借助迭代器,push_back等等
#include <iostream>
#include<stdio.h>
#include<assert.h>
#include<string>
#include<list>
using namespace std;
int main()
{list<int> lt1;lt1.push_back(9);lt1.push_back(8);lt1.push_back(7);lt1.push_back(6);//定义list的迭代器list<int>::iterator it1 = lt1.begin();while (it1 != lt1.end()){cout << *it1 << " ";it1++;}return 0;
}
3. 为什么有operator[]之后还需要迭代器
下标[]确实很方便,但并不是通用的。它只适用于string和vector(它们的底层是连续的物理空间)。
像链表等等,它们的结点的地址并没有什么大小关系。
(3) 范围for
在后面讲解
三. 补充的小知识点:auto(语法糖)
C++11引入
1.auto介绍
auto声明的变量:变量的类型由编译器在编译时期推导而得。(根据右边的值推导左边变量的类型)
- 在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,后来这个不重要了。C++11中,标准委员会变废为宝赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得。
int main()
{int i = 9;int j = i;//所以j的类型是int//用auto自动推导类型auto m = j; //右边变量j的类型是int.m的类型是intauto n = 1.2;//右边常量1.2的类型是double,n的类型是doublereturn 0;
}
- 用auto声明引用类型时则必须加&
int main()
{int i = 9;int& j = i; //j是i的别名,是int&类型//但是后面再使用j的时候,它的本质和i一样,是int类型auto m = j; //j的本质还是int,所以m的类型也还是int//用auto声明'引用类型'时则必须加&auto& n = m; //m是int类,n是int&类return 0;
}
- 当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量
auto aa = 1, bb = 2;// 编译报错:error C3538: 在声明符列表中,“auto”必须始终推导为同一类型
auto cc = 3, dd = 4.0;
- 类型包含“auto”的符号必须具有初始值设定项
即不可以auto j;
,没有初始值的话,就没有办法判断auto代表的什么类型,会报错。所以必须有初始值auto j = 4.3;
- auto不可以做参数,可以作为函数返回值
// 不能做参数
void func2(auto a)
{}
// 可以做返回值,但是建议谨慎使用
auto func3()
{return 3;
}
2.auto的使用价值
在前面介绍中所使用的案例,我们会觉得,也不需要编译器去判断呀,我们可以直接写它们的类型的。那么什么时候auto会很方便呢?
简化代码,替代类型很长的类型
在前面我们曾写过
string str1("aassddff");
std::string::iterator it1 = str1.begin();
在有了auto之后,可以怎么写呢?
string str1("aassddff");
//std::string::iterator it1 = str1.begin();auto it1 = str1.begin();
四. 补充的小知识点:范围for(语法糖)
1.使用
C++11引入
简答:范围for是遍历容器的东西(底层是迭代器)
在此之前,对于一个有范围的集合,遍历都是程序员自己写循环的范围。而C++11引入的基于范围的for循环,不再需要程序员自己写循环的范围了。
书写:for后面括号里的内容,由冒号:分为两部分。第一个部分:变量(被迭代的变量,变量名自己写);第二个部分:被迭代的集合。【自动迭代,自动取数据,自动判断结束。】
自动迭代(即:自动取容器的数据赋值给左边的值)
- 范围for可以作用到数组和容器对象上进行遍历
- 范围for的底层很简单,容器遍历实际就是替换为迭代器,这个从汇编层也可以看到
int main()
{string str1("aassddff");// 变量名:迭代的范围(集合)for (char ch : str1)cout << ch << " ";cout << endl;
// for (int i = 0; i < str1.size(); i++)
// {
// cout << str1[i] << " ";
// }
// cout << endl;return 0;
}
注意:如果想通过范围for修改数据。有一种方法是错误的。
为什么我们已经ch++了,再次for循环打印str1却还是原来的数据?
因为我们是将str1的数据拷贝给ch的,修改了ch,并没有修改str1。再次范围for打印str1就还是原来的数据了。
那如何修改数据呢?
- 我们可以不拷贝,去引用
- 刚刚修改ch,就将ch打印出来。但是要明白,str1里的数据并没有被修改,只是ch修改了。【如果想减少拷贝,使用了引用&,但不想数据被修改,则使用const修饰(const auto& ch : str1)】
int main()
{string str1("aassddff");for (auto ch : str1){ch++;cout << ch << " ";}cout << endl;return 0;
}
2. 两个语法糖融合
int main()
{string str1("aassddff");// 变量名:迭代的范围(集合)for (auto ch : str1)cout << ch << " ";cout << endl;return 0;
}
二. string类的2.2.3
迭代器:正向迭代器iterator,反向迭代器reverse_iterator
2.2.3 反向迭代器
int main()
{string str1("aassddff");std::string::reverse_iterator it1 = str1.rbegin();//或者auto it1 = str1.rbegin();while (it1 != str1.rend()) //rend就相当于正向迭代器中的end(){cout << *it1 << " " ;it1++; //一定要记得将it1++,不然会陷入死循环,一直打印最后一个字符}cout << endl;return 0;
}
2.2.4 const迭代器
const迭代器在string类对象是const的时候使用。
const对象无法使用普通迭代器
编译器会调用最匹配的函数:
-
普通对象调用普通begin(),const对象调用普通const begin()
-
const迭代器可以遍历,但无法修改数据
int main()
{const string str1("aassddff"); //const对象std::string::const_iterator it1 = str1.begin(); //调用const begin()//const//或者auto it1 = str1.begin();while (it1 != str1.end()){cout << *it1 << " ";it1++;}cout << endl;return 0;
}
2.2.5 const反向迭代器
当对象是const类型,且想倒着遍历的时候,可以选择const反向迭代器。
但是仍然无法修改数据哈。
int main()
{const string str1("aassddff");std::string::const_reverse_iterator it1 = str1.rbegin();//const反向迭代器//或者auto it1 = str1.rbegin();while (it1 != str1.rend()){cout << *it1 << " ";it1++;}cout << endl;return 0;
}
2.2.6 Capacity相关的
1. size()和length()
size和length都是在计算string对象的长度。
int main()
{string str1("abcdefg");//STL经常使用size()cout << str1.size() << endl;//不要忘记()cout << str1.length() << endl;return 0;
}
2. max_size()
意思就是:这个长度是----->字符串可以达到那么长,但是对象不一定可以达到那么长。(感觉这个没有意义,且不同平台的返回结果可能不一样)
3. capacity()
capacity是容量的意思。即空间大小
图中的意思是:开了15个空间,只放了7个字符。
4. clear()
clear()清除内容但是不清除空间
5. empty()
可以在判断的时候用
while(str1.empty());
2.2.7 Element access(元素访问)相关的
operator[](前面已经了解)
1. at
用的比较少。
at也是用来访问元素的,它和operator有什么区别呢?
operator[]越界是通过断言处理的(暴力报错),而at(pos)是通过抛异常来反应错误的,我们需要捕获异常try catch,如果是标准库的异常,就捕获一个叫exception的东西。
3. back
这个是返回最后一个字符的别名。不经常使用,因为operator[]下标写成0就是第一个字符,写成size-1就是最后一个字符。
4. front
返回字符串第一个字符的参考。
2.2.8 修改相关的
1. 尾插一个字符push_back
容易忽视的: 记得一个字符,使用的是单引号‘’
int main()
{string str1("hounuli");str1.push_back(' '); str1.push_back('a');cout << str1 << endl;return 0;
}
2. 尾插一个字符串append
且append支持一堆的接口
int main()
{//string& append(const string & str);string str1("my name is hou nu li");string str2; //可以在另一个string后面加str2.append(str1);str1.append(str1); //在自己后面加return 0;
}
int main()
{//string& append(const string & str, size_t subpos, size_t sublen);string str1("my name is hou nu li!");str1.append(str1,0,7); //0是被复制给对象的第一个字符的位置,我想在str1的后面再加一个my name,首字符位置是0//7是子串的长度cout << str1 << endl;//my name is hou nu li!my namereturn 0;
}
int main()
{//string& append (const char* s);string str1("my name is hou nu li!");str1.append("asdf");cout << str1 << endl;//my name is hou nu li!asdf//string& append (const char* s, size_t n);str1.append("asdf",1);cout << str1 << endl;//my name is hou nu li!asdfareturn 0;
}
int main()
{//string& append (size_t n, char c);string str1("my name is hou nu li!");str1.append(5, 'x');//在str1后面+5个xcout << str1 << endl;//my name is hou nu li!xxxxxreturn 0;
}
int main()
{//插入一段迭代器区间//string& append (InputIterator first, InputIterator last);string str1("my name is hou nu li!");string str2("abcdefg");str1.append(str2.begin(),str2.end());//将str2全部复制str1.append(str2.begin()+3, str2.end());//从d开始cout << str1 << endl;//my name is hou nu li!abcdefgreturn 0;
}
3. operator+=