STL + string类的使用-优快云博客

在学习String 类之前先来学习下这两个内容，auto 和范围for 在C++中也被叫做语法糖，可以简单理解为使用较为友好，便利性很高。语法糖让更加复杂冗长的代码变得更为简洁并且更易于理解，但是底层的逻辑保持不变。就像糖衣一样，让代码变得更甜，但本质上来说，并没有增加任何功能。比如 += 来说也是一个语法糖。

auto

在早期的C/C++中auto的含义是：使用 auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

auto不能作为函数的参数，可以做返回值，但是建议谨慎使用。

auto不能直接用来声明数组。

1.auto能自动推导参数类型。

void text()
{
    // auto会自动推导 a 参数类型
	auto a = 10;
}

但是参数必须要初始化，否则编译器无法得知参数的类型到底是什么。

// 编译报错:rror C3531: “e”: 类型包含“auto”的符号必须具有初始值设定项

2. auto可以作为返回值，但不能作为参数。

int func1()
{
	return 10;
}

// 不能做参数
void func2(auto a)
{
}

// 可以做返回值，但是建议谨慎使用，此时编译器会根据返回值自动推导返回值类型
auto func3()
{
	return 3;
}

3.auto声明指针类型

int x = 10;    // x 已经指定为 int 类型
auto y = &x;   // auto 推导类型，引用类型


auto* z = &x;  // 此时指定为指针类型，右边必须是指针
auto& m = x;   // 指定为引用类型

在声明指针类型时，使用auto 与 auto* 是一样的，形式上auto*可以更明显的告诉你这是个指针类型。可以理解为auto* 的右边必须是指针。

4.auto必须始终推导为同一类型

auto x = 1, y = 2;
// 类型相同，编译通过


auto cc = 3, dd = 4.0;
// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型

5.auto不能直接用来声明数组

// 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型
auto array[] = { 4, 5, 6 };

范围for

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此 C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围 内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

范围for可以作用到数组和容器对象上进行遍历。

范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

范围for()表示

for（元素类型 element : 容器） {
    // 迭代代码
}

// 容器是想要遍历的目标，可以是数组，字符串等
// 元素类型 是容器中一个元素的类型
// element可以任意命名，表示为容器中的一个元素

范围for()的使用

#include<iostream>
#include <string>
using namespace std;
int main()
{
    int array[] = { 1, 2, 3, 4, 5 };
// C++98的遍历
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
    {
        array[i] *= 2;
    }
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
    {
        cout << array[i] << endl;
    }

// C++11的遍历
    for (auto e : array)  
    cout << e << " " << endl;

    string str("hello world");
    for (auto ch : str)
    {
        cout << ch << " ";
    }
    cout << endl;

}

加&与不加&的区别

假设对于数组内的内容我们只需要进行读操作，就不需要加&。

如果还要进行写操作，需要加&。

同时这点还与下面的是否调用拷贝构造有关。

int arr[]={1,2,3,4,5};

// 只对数据进行读操作
for(auto e : arr)
{
    cout << e << " " ;   
}

cout << endl;

//改变数组内的数据值，加引用
for(auto& e : arr)
{
    e *= 2;
}

是否调用拷贝构造

值类型声明

当循环变量声明是值类型时， 每次迭代时，容器中的元素会被 拷贝 到循环变量中。这会调用元素类型的拷贝构造函数（若存在且未被优化）。

int arr[] = {1,2,3};

for(auto e : arr)
{
    ....
}

数组arr的元素会被拷贝到e中去，这时会调用拷贝构造。

引用类型声明

当循环变量声明为引用类型时：循环变量直接引用容器中的元素，不会触发拷贝操作。不会调用拷贝构造函数。

这点原理是类的默认成员函数中拷贝构造函数内容。类的默认成员函数-优快云博客

这里拷贝构造的好处就是对象比较大的时候，节省空间。

2.3 String类的常用接口说明

1.string类对象常见构造

先了解什么是构造函数，不清楚的可以看这篇博客类的默认成员函数-优快云博客

这里根据cplusplus.com - The C++ Resources Network的内容来讲解：

1.1 string()

string()是默认构造，可以不传任何参数。

#include<iostream>
using namespace std;
int main()
{
	string a;
	return 0;
}

1.2 string (const string& str)

string (const string& str) 可以传入一个string类型的对象。

#include<iostream>
using namespace std;
int main()
{
	string a = "hello";
	string b(a);
	return 0;
}

1.3 string (const string& str, size_t pos, size_t len = npos);

这个构造的功能是从str 串的pos 开始，往后截取len个字符长度的元素。

#include<iostream>
using namespace std;
int main()
{
	string s = "hello";
	string b(s, 1, 2);
	return 0;
}

如果len的长度超出了字符串原有的长度会如何？

string b(s, 2, 1000);

显然字符串s肯定没有1000个字符的，遇到这样的情况，会读取到字符串s的最后一个字符。

假若不填最后一个参数也是没问题的，size_t len = npos是一个缺省值，它也会读取到最后一个字符停止。

npos

这时可能有人会问，这个 npos 是什么，结合官方文档来看

表面上它是一个静态类型的 -1，实则并不然。size_t是无符号类型的整数，但是-1是有符号整数，我们可以知道-1的补码是全1，全1在无符号整数中是整数的最大值，所以这里的npos是整数所能表示的最大值，所以当npos作为缺省值时，他必定会读取到字符的最后一个位置。

总结

void Teststring()
{
    string s1; // 构造空的string类对象s1
    string s2("hello bit"); // 用C格式字符串构造string类对象s2
    string s3(s2); // 拷贝构造s3
}

2. string 类对象的访问和遍历操作

遍历总结来说共有三类：1.下标+[ ] 2.迭代器 3.范围for()

1.下标+[ ]

对于数组元素的读取，我们通常使用 数组名[下标] 的方式进行访问，这样访问的便捷性不用多说，而C++又有运算符重载的功能，因此String类中给出了 [] 的重载，使得字符串能够像数组一样使用下标进行访问，这无疑大大增加了便利性。

string::operator[ ]重载了两种类型，第一种是能进行读写，第二种是只读的。

	// 1、下标+[]
	for (size_t i = 0; i < s2.size(); i++)
	{
		s2[i] += 1;
		//s2.operator[](i) += 1;
	}



	//for (size_t i = 0; i < s2.length(); i++)
	for (size_t i = 0; i < s2.size(); i++)
	{
		cout << s2[i] << " ";
	}



	const string s5("xxxxxx");
	//s5[0] = 'y';
    // s5是const 类型的，只读，因此不能进行修改

2.迭代器

迭代器是一个左闭右开的区间：[ )

在行为上可以将迭代器理解为像指针一样的对象，它有 begin() 和 end() 两个值，分别指向开始到结束的位置，使用迭代器时它会自动从 begin 进行遍历，到 end 时结束。

注意它是一个左闭右开的空间，end()指向最后一个元素的下一个位置。

如何使用

迭代器的类型根据你使用的容器来定，比如这里使用的string类型的字符串

string::iterator it = s.begin()

但是这样来说类型的名称就太冗长了，可以使用 auto 来自动生成类型

auto it = s2.begin()

	auto it = s2.begin();
	while (it != s2.end())
	{
		*it += 1;
		cout << *it << " ";
		++it;
	}
	cout << endl;

因为迭代器是行为类似于指针的对象，所以要访问内容时要使用 * （注意这里的 * 不一定是解引用的意思，C++可以对 * 进行重载）

还有一点要注意的是，这里的便利方式使用的是 while，而不是 for()循环，字符串和数组这里也可以使用for 循环来遍历，因为它的底层是数组，后一个元素的地址肯定要大于前一个，但是对于链表等来说，它的物理地址并不是连续的，因此建议使用while()遍历。

list<int> lt1 = { 1,2,3,4,5 };
	list<int>::iterator it1 = lt1.begin();
	while (it1 != lt1.end())
	{
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;

begin() / end()

前面已经说过这两个分别指向开始和结束。

C++里给出了两个重载，可以根据const来进行区分，const这里缩小了权限，只能进行读操作。

这里会使用即可。

rbegin() / rend()

rbegin()/rend()是用来反向遍历的。

	string::reverse_iterator rit = s2.rbegin();
	while (rit != s2.rend())
	{
		//*rit += 1;
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

注意观察这里使用的是反向迭代器，但是往后遍历的时候，使用的是 ++it，这也说明了 * 不是指针的解引用。

3.范围for()

这个前面已经讲解过，这里不做过多阐述，范围for()的底层是迭代器

	// 范围for
	for (auto ch : s)
	{
		cout << ch << " ";
	}

4.at() 与 [ ]

at()与 opreator[ ] 的功能相同，他们的不同点在于二者对于越界访问的处理不同

operator[ ] 是断言处理，会直接终止程序

at() 是try-catch捕获异常

5.back() / front()

front()返回字符串的首字符，back()返回字符串的结尾字符。

3.String类对象的容量操作

3.1 size() / length()

size() 与 lenght() 都是返回字符串有效字符的长度，即从字符串开始到 '/0' 前的有效字符个数，注意这两个都不包含 '/0' 。

	string s = "abcdef";
	cout << s.size() << endl;
	cout << s.length() << endl;

运行结果，显而易见二者的功能相同。

size()和length() 是等价的，二者可以用来获取字符串的长度。二者返回相同的结果，但是size()更符合标准库的容器类。

string这里可以使用length()，但是STL中的容器类有很多，根据字面意思，length更适合长度，但是后面有树这样的非线性的数据结果，使用length多少有点不合适，所以size()更符合标准库的容器类。

3.2 capacity()

capacity()用于返回当前字符串分配的空间大小。即其能够容纳的字符数量而不必立即重新分配内存

字符串当前分配的空间大小，并不一定等于字符串当前的字符长度。同时二者均不计算最后一个字符后的 '/0' 。capacity() 返回字符串当前分配的内存空间大小，单位为字符数。即使字符串为空，该值也可能大于零，因为字符串通常预先分配内存以提高效率。

	string s = "abcdef";
	cout << s.size() << endl;
	cout << s.capacity() << endl;

自动扩容

当size()达到capacity()时，字符串会自动扩展内存，此时的capacity()会增加。但是不同的编译器实现的机制不同，扩容的方式也不同。比如 VS 是 1. 5 倍扩容，但是Linux下的g++是 2 倍扩容。

3.3 empty()

用于判断字符串是否为空。如果字符串中没有任何字符，包括没有终止空字符（'\0'），则返回true。不需要参数直接调用。

这里只了解如何使用即可。

3.4 clear()

用于清空字符串内容，但一般情况下不会清理内存空间。

	string s = "abcdef";
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;

3.5 shrink_to_fit()

shrink_to_fit() 会尝试将字符串的内存容量（capacity()）调整为刚好等于当前字符串的大小（size()）。这样可以释放之前预留的未使用的内存空间，优化内存使用。

同时shrink_to_fit 是异地缩容，即它缩容时会另外开辟一块新的空间。因为释放空间不能从字符串中间开始释放，只能从起始指针处释放。

3.6 reserve()

reserve(n) 请求将字符串的容量（capacity()）调整为至少 n 个字符，以容纳未来的扩展，避免频繁的内存重新分配。调用此函数不会改变字符串的内容或长度（size()），仅调整底层内存的容量。

reserve()扩容分为三种情况：

1. n < size() < capacity()

2. size() < n < capacity()

这两种情况不一定会缩容，主要看编译器如何解释。

3.size() < capacity() < n

一定会扩容。·

注意：无论是哪种情况，都不会改变字符串的内容。

    string s = "abcdef";	
    cout << s.capacity() << endl;
	s.reserve(1);
	cout << s.capacity() << endl;
	cout << s << endl;

3.7 resize()

resize()会将字符串的长度size()显式调整为 n 。

// resizing string
#include <iostream>
#include <string>

int main ()
{
  std::string str ("I like to code in C");
  std::cout << str << '\n';

  unsigned sz = str.size();

  str.resize (sz+2,'+');
  std::cout << str << '\n';

  str.resize (14);
  std::cout << str << '\n';
  return 0;
}



COUT
I like to code in C
I like to code in C++
I like to code

这里跟reserve()一样分多种情况。

4. string类对象的修改操作

1. push_back()

在字符串后尾插一个元素。

代码演示

	string s = "abcdef";
	s.push_back('1');
	cout << s << endl;

注意这里的参数只有一个char 类型的字符，写入 '12'只会保留最后一个字符。

2.append()

将指定内容追加到字符串的末尾，它会修改字符串的长度，返回自身(*this)的引用。

这里的append（）有多种类型重载，使用时查看文档即可

代码演示

// appending to string
#include <iostream>
#include <string>

int main ()
{
  std::string str;
  std::string str2="Writing ";
  std::string str3="print 10 and then 5 more";

  // used in the same order as described above:
  str.append(str2);                       // "Writing "
  str.append(str3,6,3);                   // "10 "
  str.append("dots are cool",5);          // "dots "
  str.append("here: ");                   // "here: "
  str.append(10u,'.');                    // ".........."
  str.append(str3.begin()+8,str3.end());  // " and then 5 more"
  str.append<int>(5,0x2E);                // "....."

  std::cout << str << '\n';
  return 0;
}

3.operator+=()

在字符串后追加内容，这个使用比较常见。

比如我们常见的数值 += 操作，此处功能相同。

// string::operator+=
#include <iostream>
#include <string>

int main ()
{
  std::string name ("John");
  std::string family ("Smith");
  name += " K. ";         // c-string
  name += family;         // string
  name += '\n';           // character

  std::cout << name;
  return 0;
}

4.c_str()

返回C格式的字符串。

这里的功能主要与语言的兼容有关，比如平时完成C++项目工程时，一般来说不是全部使用C++完成，会有一部分内容使用C语言完成，如果C内容处想从C++内容处获取某些字符串，直接获取就不行的，这里便要使用c_str()来完成转换。

5.find()

查看指定内容在字符串中的位置。根据重载函数不同功能也不同。

代码演示

	// 从pos位置开始查看 s1 在 s中的位置
	string s = "abcdefgh";
	string s1 = "ab";
	cout << s.find(s1, 0);

如果说指定内容没找到会怎么样？

	// 从pos位置开始查看 s1 在 s中的位置
	string s = "abcdefgh";
	string s1 = "ab";
	cout << s.find(s1, 1);

返回了 npos。

6.rfind()

与find()功能相同，不过是从后往前进行查找。

rfind()的使用场景举例：要得到某个文件的后缀，这时从后往前查找更快。

7.substr()

从指定位置开始，截取字符串 len长度的目标串

代码演示

// string::substr
#include <iostream>
#include <string>

int main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

  std::string str2 = str.substr (3,5);     // "think"

  std::size_t pos = str.find("live");      // position of "live" in str

  std::string str3 = str.substr (pos);     // get from "live" to the end

  std::cout << str2 << ' ' << str3 << '\n';

  return 0;
}

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差

不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可

以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留

好。

5 string类的非成员函数

1.getline()

获取一行字符串。

平时我们使用 cin 时，遇到空格和换行就是遇到了终止符，如果我们想要输入的字符串带有空格等就会比较麻烦。

getline()就解决了这一问题，两个函数的第一个参数都是输入流对象，即 cin ，第二个是指定字符串，第一个式子中的第三个参数是指定终止符，不填的话默认是 ' /n'。

// extract to string
#include <iostream>
#include <string>

int main ()
{
  std::string name;

  std::cout << "Please, enter your full name: ";
  std::getline (std::cin,name);
  std::cout << "Hello, " << name << "!\n";

  return 0;
}