STL(standard template libaray-标准模板库):
是C++标准库的重要组成部分,不仅是一个可复用的组件库,而且是一个包含数据结构与算法的软件框架。
是一套功能强大的 C++ 模板类,提供了通用的模板类和函数,这些模板类和函数可以实现多种流行和常用的算法和数据结构,如向量、链表、队列、栈。
STL以HP版为始祖,衍生出很多版本,其中P.J.版本被被Windows Visual C++采用,RW版本被C+ + Builder 采用,SGI版本被GCC(Linux)采用。
从可读性角度考量,后续参考STL源代码会以SGI版本为主。
算法包含各种常见算法的函数
容器是数据结构
迭代器用于访问容器
空间配置器是内存池
string类的说明文档
总结:
在使用string类时,须包含头文件string并使用命名空间std:
#include
using namespace std;
(构造)函数名称 | 功能说明 |
---|---|
string() (重点) | 构造空的string类对象,即空字符串 |
string(const char* s) (重点) | 用C-string来构造string类对象 |
string(const string&s) (重点) | 拷贝构造函数 |
string(size_t n, char c) | string类对象中包含n个字符c |
例:
#include
#include
using namespace std;
void Teststring() {
string s1; //构造空的string类对象s1
string s2("hell word"); //用C格式的字符串构造string类对象s2
string s3(s2); //拷贝构造s3
string s4 = "hell word"; //也可以这样构造对象,const char* 转 string
for (size_t i = 0; i < s2.size(); ++i) {
cout << s2[i]++ << endl; //std::string::operator[] 重载,返回对字符串中i处字符的引用,可按位置打印字符。
}
cout << endl;
cout << s2 << endl; //std::operator<< (string) 重载,可直接打印整个字符串。
cout << s3 << endl;
}
int main() {
Teststring();
return 0;
}
string();//default (1) *重点*
string (const string& str);//copy (2) *重点*
string (const string& str, size_t pos, size_t len = npos);//substring (3)
string (const char* s);//from c-string (4) *重点*
string (const char* s, size_t n);//from sequence (5)
string (size_t n, char c);//fill (6)
template <class InputIterator> string (InputIterator first, InputIterator last);//range (7)
构造一个string对象,根据使用的构造函数版本初始化其值:
(1) [重点]空字符串构造函数(默认构造函数)
构建一个空字符串,其长度为0个字符。
(2) [重点]拷贝构造函数
构造一个str的副本。
(3) 子串构造函数
复制str中从pos位置开始,跨越leng个字符的部分(如果str太短或者len等于string::npos,则复制到str的末端)。
static const size_t npos = -1;//无符号整型给-1,等效于无符号整型的最大值
(4) [重点]来自c字符串
复制s所指向的以\0作为结尾的字符串(C字符串),即用C字符串构造string类对象。
(5) 来自buffer(缓冲区?)
从s指向的字符数组中复制前n个字符。
(6) fill构造函数
通过连续拷贝n个字符c来填充字符串。
(7) range构造函数(迭代器区间构造)
复制 [first,last) 区间中的字符序列,字符顺序不变。
以上所有构造函数都支持一个成员类型为allocator_type的对象作为最后的额外可选参数,这对于字符串来说是不相关的(上面没有显示,完整的签名见basic_string的构造函数)。
string& operator= (const string& str);//string (1)
string& operator= (const char* s);//c-string (2)
string& operator= (char c);//character (3)
string对象赋值:
为字符串分配一个新值,替换其当前内容。
(1)是赋值,(2)与(3)是用来提供冗余的重载。
出作用域会自动调用析构函数释放对象的资源。不会抛出异常。
函数名称 | 功能说明 |
---|---|
size(重点) | 返回字符串的有效长度 |
length | 返回字符串的有效长度 |
capacity | 返回类所分配的空间的大小 |
empty(重点) | 检查字符串是否为空串,为空则返回true,否则返回false |
clear(重点) | 清空有效字符 |
reserve(重点) | 为字符串预留空间 |
resize(重点) | 将字符串的有效字符数改为指定的大小,多出的空间用特定字符填充 |
size_t size() const;
size_t length() const;
void clear();//清空有效字符
bool empty() const;//检查是否为空字符串
void reserve (size_t n = 0);//n为要预留的字符个数,默认为0
void resize (size_t n);//用0填充
void resize (size_t n, char c);//用指定字符填充
函数名称 | 功能说明 |
---|---|
push_back; | 在字符串后尾插指定的字符,字符串长度增加1 |
append | 在字符串后追加一个字符串 |
operator+= (重点) | 在字符串后追加单个字符或字符串 |
c_str (重点) | 返回C格式字符串 |
【find + npos】 (重点) | 从字符串pos位置开始往后找字符c,返回该字符在字符串中的位置 |
rfind | 从字符串pos位置开始往前找字符c,返回该字符在字符串中的位置 |
substr | 在str中从pos位置开始,截取n个字符,然后将其返回 |
如未指出,默认32位平台。
string共占28个字节,内部结构略复杂:
union _Bxty
{ // storage for small buffer or pointer to larger one
value_type _Buf[_BUF_SIZE];
pointer _Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这样做是因为大多数情况下字符串的长度都小于16,则string对象创建好之后,内部已有16个字符数组的固定空间,不需要专门从堆申请空间创建,效率较高。
一个size_t字段保存字符串长度,一个size_t字段保存从堆上开辟空间总的容量。
一个指针做其他事情。
故vs下string类占16+4+4+4=28字节。
G++下,string是通过写时拷贝实现的,string对象总共占4个字节,内部只包含了一个指针,该指针将来指向一块堆空间,内部包含了如下字段:
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
using namespace std;
namespace my_string {
class string {
public:
//原生指针实现迭代器
typedef char* iterator;
typedef char* const_iterator;//供const使用的重载版本
iterator begin() {
return _str;
}
iterator end() {
return _str + _size;
}
const_iterator begin() const{
return _str;
}
const_iterator end() const{
return _str + _size;
}
string(const char* str = "")//缺省不能给nullptr,因为strlen等函数会解引用。给常量字符串""会自动带上\0,不需要写成"\0"
//若类的声明顺序错误,会导致初始化顺序错误,进而导致问题,故只初始化_size这一个变量以增加容错
:_size(strlen(str))
{
_capacity = _size == 0 ? 3: _size;//保证_capacity不为0
_str = new char[_capacity + 1];//_capacity是有效字符数量,实际空间需加上\0占用的一位
strcpy(_str, str);
}
//默认拷贝构造只能浅拷贝,深拷贝需要手动实现
string(const string& s)
:_size(s._size)
,_capacity(s._capacity)
{
_str = new char[s._capacity + 1];//开空间
strcpy(_str, s._str);//拷数据
}
//赋值是关于两个已经存在的对象进行操作,所以要考虑二者长度不相等的情况
//左值长度小于右值长度时左值会需要扩容,而右值长度远小于左值时直接赋值(一般不会去缩容)会存在极大浪费
//前者的情况直接扩容即可。而对于后者的情况,系统一般会新开一块右值长度的空间并拷入数据,将之作为左值所对应的新空间并释放其旧空间
//库里的实现方式是,不判断大小,直接释放左值(this)原本的空间,给左值新开右值大小的空间并拷贝之
string& operator=(const string& s) {
if (this != &s) {//需要判断是否为自我赋值,是则不进行操作,不然在拷之前就给自己释放掉了
char* tmp = new char[s._capacity + 1];//使用tmp暂存以使得开空间失败时直接抛异常,而不会破坏被赋值的左值的类
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
~string() {
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
const char* c_str() {
return _str;
}
size_t size() const{//加const,普通对象与const对象就都可以调用,普通对象调用时权限缩小
return _size;
}
size_t capacity() const {
return _capacity;
}
const char& operator[](size_t pos) const{//用于const对象,不允许修改
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos) {//用于普通对象,允许修改
assert(pos < _size);
return _str[pos];
}
bool operator==(const string& s) const{
return strcmp(_str, s._str) == 0;
}
bool operator>(const string& s) const {
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string& s) const {
return *this > s || *this == s;
}
bool operator<(const string& s) const {
return !( * this >= s);
}
bool operator<=(const string& s) const {
return !(*this > s);
}
bool operator!=(const string& s) const {
return !(*this == s);
}
//扩容(类似realloc)
void reserve(size_t n) {
if (n > _capacity) {//判断n大小,避免缩容
char* tmp = new char[n + 1];//开新空间,n+1是为\0预留一位
strcpy(tmp, _str);//拷贝到新空间
delete[] _str;//释放旧空间
_str = tmp;
_capacity = n;
}
}
void append(const char* str) {
insert(_size, str);
}
//相比apprnd,push_back只能追加单个字符
void push_back(char ch) {
insert(_size, ch);
}
//扩容+初始化
void resize(size_t n, char ch = '\0') {
//n<_size,删除前n个之后的数据,不缩容(缩容代价大)
if (n <= _size) {//==的情况也包含一下
_size = n;
_str[_size] = '\0';
}
else{
if (n > _capacity) {//n大于容量则先扩容
reserve(n);
}
size_t i = _size;
while (i < n) {
_str[i] = ch;
++i;
}
_size = n;
_str[_size] = '\0';
}
}
string& operator+=(char ch) {
push_back(ch);
return *this;
}
string& operator+=(const char* str) {
append(str);
return *this;
}
//特定位置插入/清除
string& insert(size_t pos, char ch) {//待改进,现在这个写法pos给0会出问题
assert(pos <= _size);
if (_size + 1 > _capacity) {
reserve(2 * _capacity);
}
//
size_t end = _size + 1;//+1错开一位以实现能够判断end>=pos的效果,同时end在循环中不再会变成-1
while (end > pos){//判断end>=pos的话,若pos为0,要到end为-1时循环才会停,但end是无符号整型,会出问题。
_str[end] = _str[end - 1];//与+1对应
--end;
}
_str[pos] = ch;
++_size;
return *this;//与库函数格式保持一致
}
string& insert(size_t pos, const char* str) {
assert(pos <= _size);
size_t len = strlen(str);
//按需扩容
if (_size + len > _capacity) {
reserve(_size + len);
}
//挪数据
size_t end = _size + len;
while (end > pos + len - 1) {
_str[end] = _str[end - len];
--end;
}
//拷贝插入
strncpy(_str + pos, str, len);
_size += len;
return *this;//与库函数格式保持一致
}
string& erase(size_t pos, size_t len = npos) {//不给要删的长度则默认npos
assert(pos < _size);
if (len == npos || pos + len >= _size) {//npos及超出size的长度,从指定位置删到最后
_str[pos] = '\0';
_size = pos;
}
else {
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;//与库函数格式保持一致
}
//内置类型的swap可以直接浅拷贝
void swap(string& s) {
std::swap(_str, s._str);//这里必须指定用std的swap,否则会就近调用自己而报错。
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
size_t find(char ch, size_t pos = 0){
assert(pos < _size);
for (size_t i = pos; i < _size; ++i) {
if (_str[i] == ch) {
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0) {
assert(pos < _size);
char* p = strstr(_str + pos, str);
if (p == nullptr) {
return npos;
}
else {
return p - _str;
}
}
void clear() {
_str[0] = '\0';
_size = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
//传统语法:静态成员变量不能在声明处缺省,可在类外定义
//但,库里的是(static const size_t npos;),然后就可以(static const size_t npos = -1;)
//↑这个语法只是特例,只适用于整型,不能改成(static const double npos = 1.2;)这种
};
size_t string::npos = -1;//静态成员变量不能在声明处缺省,可在类外定义
//流插入与流提取重载,只能在类外
ostream& operator<<(ostream& out, const string& s) {
for (auto ch : s) {
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s) {
s.clear();//流插入前先清理(不缩容)
char ch = in.get();
char buff[128];
//↑类似于库中的解决长字符串情况下频繁扩容的效率问题的方式,每次根据输入的字符数决定扩多少个buff的大小,buff出作用域销毁
size_t i = 0;
while (ch != ' ' && ch != '\n') {
buff[i++] = ch;
if (i == 127) {
buff[127] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0) {
buff[i] = '\0';
s += buff;
}
return in;
}
void test_string1() {
string s1;
string s2("hell word");
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
s2[0]++;
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
}
void test_string2() {
string s1;
string s2("hell word");
string s3(s2);//拷贝
cout << s2.c_str() << endl;
cout << s3.c_str() << endl;
s2[0]++;
cout << s2.c_str() << endl;
cout << s3.c_str() << endl;
s1 = s3;//赋值
cout << s1.c_str() << endl;
cout << s3.c_str() << endl;
}
void Print(const string& s) {
for (size_t i = 0; i < s.size(); ++i) {
cout << s[i] << " ";
}
cout << endl;
string::const_iterator it = s.begin();
while (it != s.end()) {
++it;
}
cout << endl;
for (auto ch : s) {
cout << ch << " ";
}
cout << endl;
}
void test_string3() {
string s1("hell word");
for (size_t i = 0; i < s1.size(); ++i) {
s1[i]++;
}
cout << endl;
for (size_t i = 0; i < s1.size(); ++i) {
cout << s1[i] << " ";
}
cout << endl;
Print(s1);
string::iterator it = s1.begin();
while (it != s1.end()) {
(*it)--;
++it;
}
cout << endl;
it = s1.begin();
while (it != s1.end()) {
cout << *it << " ";
++it;
}
cout << endl;
//范围for的实现类似宏,这里的范围for底层用到的是前面自己实现的迭代器
//若把前面迭代器的begin改成Begin,迭代器依旧正常运行,但范围for会出错,vs会在报错里要求提供"begin"
for (auto ch : s1) {
cout << ch << " ";
}
cout << endl;
}
void test_string4() {
string s1("hell word");
string s2("hell word");
string s3("printf");
cout << (s1 == s2) << endl;
cout << (s1 < s2) << endl;
cout << (s1 >= s3) << endl;
}
void test_string5() {
string s1("hell word");
s1 += '-';
s1 += "114514";
cout << s1.c_str() << endl;
s1.insert(6, '*');
cout << s1.c_str() << endl;
}
void test_string6() {
string s1("12345");
s1.insert(0, 'a');
cout << s1.c_str() << endl;
s1.insert(3, 'b');
cout << s1.c_str() << endl;
s1.insert(0, "cccc");
cout << s1.c_str() << endl;
s1.insert(5, "ddddd");
cout << s1.c_str() << endl;
}
void test_string7() {
string s1("0123456789");
s1.erase(5, 3);
cout << s1.c_str() << endl;
s1.erase(3, 30);
cout << s1.c_str() << endl;
s1.erase(1);
cout << s1.c_str() << endl;
}
void test_string8() {
string s1("0123456789");
s1 += '\0';
s1 += "aaaaaa";
cout << s1 << endl;
cout << s1.c_str() << endl;//c_str若在字符串中间遇到\0,则直接停止,不会完整打印
string s2;
cin >> s2;
cout << s2 << endl;
cin >> s1;
cout << s1 << endl;
}
}
#include"string.h"
int main() {
try {
my_string::test_string8();
}
catch (const exception& e) {
cout << e.what() << endl;//显示异常
}
return 0;
}
迭代器用于遍历对象集合的元素。这些集合可能是容器,也可能是容器的子集。
#include
#include
using namespace std;
int main() {
string s1("hell word");
//迭代器
string::iterator it = s1.begin();
while (it != s1.end()) {
cout << *it << " ";
++it;
}
cout << endl;
//范围for
for (auto ch : s1) {
cout << ch << " ";
}
cout << endl;
//反向迭代器
string::reverse_iterator rit = s1.rbegin();
while (rit != s1.rend()) {
cout << *rit << " ";
++rit;//注意是++不是--
}
cout << endl;
return 0;
}
补充:const迭代器
std::string::begin
iterator begin();
const_iterator begin() const;