11.C++入门：String|auto|范围for|常用接口

最新推荐文章于 2026-01-07 11:46:22 发布

原创最新推荐文章于 2026-01-07 11:46:22 发布 · 826 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

C++ 专栏收录该内容

16 篇文章

订阅专栏

STL简介

什么是STL

STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架

STL的六大组件

仿函数：greater、less、…
算法：find、swap、reverse、sort、merge、…
迭代器：iterator、const_iterator、reverse_iterator、const_reverse_iterator
空间配置器：allocator
容器：string、vector、list、deque、map、set、multimap、multiset
配接器：stack、queue、priority_queue

C语言中的字符串

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

标准库中的string类

string类

cplusplus.com/reference/string/string/?kw=string
在使用string类时，必须包含#include头文件以及using namespace std;

auto和范围for

auto关键字

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto不能作为函数的参数，可以做返回值，但是建议谨慎使用
auto不能直接用来声明数组

#include<iostream>  
using namespace std;  

int func1()  
{  
	return 10;  
} 

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

// 可以做返回值，但是建议谨慎使用  
auto func3()  
{  
	return 3;  
} 

int main()  
{  
	int a = 10;  
	auto b = a;  
	auto c = 'a';  
	auto d = func1();  
	// 编译报错:rror C3531: “e”: 类型包含“auto”的符号必须具有初始值设定项  
	auto e;  
	
	cout << typeid(b).name() << endl;  
	cout << typeid(c).name() << endl;  
	cout << typeid(d).name() << endl;  
	
	int x = 10;  
	auto y = &x;  
	auto* z = &x;  
	auto& m = x;  
	
	cout << typeid(x).name() << endl;  
	cout << typeid(y).name() << endl;  
	cout << typeid(z).name() << endl;  
	
	auto aa = 1, bb = 2;  
	// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型  
	auto cc = 3, dd = 4.0; 
	 
	// 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型  
	auto array[] = { 4, 5, 6 };  
	
	return 0;  
}

#include<iostream>  
#include <string>  
#include <map>  
using namespace std;
  
int main()  
{  
	std::map<std::string, std::string> dict = { { "apple", "苹果" },{ "orange",  
	"橙子" }, {"pear","梨"} };  
	// auto的用武之地  
	//std::map<std::string, std::string>::iterator it = dict.begin();  
	auto it = dict.begin();  
	while (it != dict.end())  
	{  
		cout << it->first << ":" << it->second << endl;  
		++it;  
	}
	
	return 0;  
}

范围for

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
范围for可以作用到数组和容器对象上进行遍历
范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

#include<iostream>  
#include <string>  
#include <map>  
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)  
		e *= 2;  
		
	for (auto e : array)  
		cout << e << " " << endl;  
		
	string str("hello world");  
	for (auto ch : str)  
	{  
		cout << ch << " ";  
	} 
	cout << endl;  
	
	return 0;  
}

string类的常用接口说明

string类对象的常见构造

(constructor)函数名称	功能说明
string()	构造空的string类对象，即空字符串
string(const char* s)	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s)	拷贝构造函数

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

string类对象的容量操作

函数名称	功能说明
size	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty	检测字符串是否为空串，是返回 true，否则返回 false
clear	清空有效字符
reserve	为字符串预留空间 **
resize	将有效字符的个数改成 n 个，多出的空间用字符 c 填充
扩容

// reserve 保留
// reverse 反转 逆置
int main()
{
	try
	{
		string s1;
		string s2("hello world");

		// 实践中没有参考和使用的价值
		cout << s1.max_size() << endl;
		cout << s2.max_size() << endl;
		s1.reserve(s1.max_size());
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

检查扩容情况

int main()
{
	try
	{
		string s1;
		string s2("hello worldxxxxxxxxxxxxx");
		// 确定需要多少空间，提前开好空间即可
		s1.reserve(500);

		size_t old = s1.capacity();
		cout << old << endl;


		for (size_t i = 0; i < 500; i++)
		{
			s1.push_back('x');
			if (old != s1.capacity())
			{
				cout << s1.capacity() << endl;
				old = s1.capacity();
			}
		}
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

扩容倍数大致是1.5
reserve一般不会缩容，不会删除数据，最小缩到size()
resize

int main()
{
	string s1("hello world");
	cout << s1.size() << endl;
	cout << s1.capacity() << endl;
	cout << s1 << endl;

	// > capacity -》 扩容+尾插
	//s1.resize(100);
	s1.resize(100, 'x');
	cout << s1.size() << endl;
	cout << s1.capacity() << endl;
	cout << s1 << endl;

	// size < n < capacity  -> 尾插
	string s2("hello world");
	cout << s2.size() << endl;
	cout << s2.capacity() << endl;
	cout << s2 << endl;
	s2.resize(12);
	cout << s2.size() << endl;
	cout << s2.capacity() << endl;

	// n < size -> 删除数据，保留前n个
	string s3("hello world");
	cout << s3.size() << endl;
	cout << s3.capacity() << endl;
	cout << s3 << endl;
	s3.resize(5);
	cout << s3.size() << endl;
	cout << s3.capacity() << endl;

	string s5;
	s5.resize(100, '#');
	cout << s5 << endl;

	return 0;
}

注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

string类对象的访问及遍历操作

函数名称	功能说明
operator []	返回 pos 位置的字符，const string 类对象调用
begin+ end	begin 获取一个字符的迭代器 + end 获取最后一个字符下一个位置的迭代器
rbegin + rend	begin 获取一个字符的迭代器 + end 获取最后一个字符下一个位置的迭代器
范围 for	C++11 支持更简洁的范围 for 的新遍历方式
`[]`

int main()
{
	string s1("hello world");
	
	cout << s1.size() << endl;
	cout << s1.length() << endl;

	for (size_t i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << " ";
		//cout << s1.operator[](i) << " ";
	}
	cout << endl;
	
	return 0;
}

// string给逆置一下
size_t begin = 0, end = s1.size() - 1;
while (begin < end)
{
	/*char tmp = s1[begin];
	s1[begin] = s1[end];
	s1[end] = tmp;*/
	swap(s1[begin], s1[end]);

	++begin;
	--end;
}
cout << s1 << endl;

iterator

// iterator用法像指针
string::iterator it = s1.begin();
while (it != s1.end())
{
	*it += 1;
	cout << *it << " ";
	++it;
}
cout << endl;
reverse(s1.begin(), s1.end());
cout << s1 << endl;

范围for

int main()
{
	string s1("hello world");
	const string s2("hello world");
	s1[0] = 'x';
	//s2[0] = 'x';
	
	cout << s2[0] << endl;
	string::const_iterator it = s2.begin();
	while (it != s2.end())
	{
		//*it += 1;
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	// yyds
	for (auto e : s1)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

反向迭代器

void func(const string& s)
{
	//string::const_reverse_iterator it = s.rbegin();
	auto it = s.rbegin();
	while (it != s.rend())
	{
		// *it = 'x';
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
	auto it = s.crbegin();
	while (it != s.crend())
	{
		// *it = 'x';
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

int main()
{
	string s1("hello world");
	// 遍历
	// 1、下标+[]
	// 2、迭代器
	// 3、范围for

	string::reverse_iterator it1 = s1.rbegin();
	while (it1 != s1.rend())
	{
		//*it1 = 'x';

		cout << *it1 << " ";
		++it1;
	}
	cout << endl;

	func(s1);

	return 0;
}

at：抛异常，[]是程序报错

int main()
{
	try
	{
		string s1("hello world");
		cout << s1[11] << endl;
		//cout << s1[20] << endl;

		cout << s1.at(20) << endl;	
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

string类对象的修改操作

函数名称	功能说明
push_back	在字符串后尾插字符 c
append	在字符串后追加一个字符串
operator+=	在字符串后追加字符串 str
c_str	返回 C 格式字符串
find + npos	从字符串 pos 位置开始往后找字符 c，返回该字符在字符串中的位置
rfind	从字符串 pos 位置开始往前找字符 c，返回该字符在字符串中的位置
substr	在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

// 增  +=(push_back/append)/insert
// 删  erase
// 查  []
// 改  []/迭代器
int main()
{
	string s1("hello");
	s1.push_back(' ');
	s1.append("world");
	cout << s1 << endl;

	string s2 = "xxxx";
	const string& s3 = "xxxx";

	s2.append(++s1.begin(), --s1.end());
	cout << s2 << endl;

	s1 += '!';
	s1 += "xxxxx";
	s1 += s2;
	cout << s1 << endl;

	return 0;
}

insert、erase：

int main()
{
	//string s1("hello world");
	//s1.insert(5, "xxxx");
	//cout << s1 << endl;

	////s1.insert(0, 1, 'x');
	//s1.insert(s1.begin(), 'y');
	//cout << s1 << endl;

	string s1("hello world");
	s1.insert(5, "xxxx");
	cout << s1 << endl;

	s1.insert(0, 1, 'x');
	s1.insert(s1.begin(), 'y');
	cout << s1 << endl;

	s1.erase(5, 4);
	cout << s1 << endl;

	s1.erase(5);
	cout << s1 << endl;

	return 0;
}

find、replace、s2.swap(s3)表示交换指针

int main()
{
	string s1("hello  world hello bit");
	cout << s1 << endl;

	// 所有的空格替换为20%
	size_t pos = s1.find(' ', 0);
	while (pos != string::npos)
	{
		s1.replace(pos, 1, "20%");
		// 效率很低，能不用就不要用了

		pos = s1.find(' ', pos + 3);
	}
	cout << s1 << endl;

	string s2("hello  world hello bit");
	cout << s2 << endl;
	string s3;
	for (auto ch : s2)
	{
		if (ch == ' ')
		{
			s3 += "20%";
		}
		else
		{
			s3 += ch;
		}
	}
	cout << s3 << endl;
	s2.swap(s3);
	cout << s2 << endl;

	return 0;
}

c_str()：

int main()
{
	string filename("Test.cpp");
	FILE* fout = fopen(filename.c_str(), "r");
	char ch = fgetc(fout);
	while (ch != EOF)
	{
		cout << ch;
		ch = fgetc(fout);
	}

	return 0;
}

substr()：

int main()
{
	string s1("Test.cpp");
	string s2("Test.tar.zip");

	size_t pos1 = s1.rfind('.');
	if (pos1 != string::npos)
	{
		//string suff = s1.substr(pos1, s1.size() - pos1);
		string suff = s1.substr(pos1);
		cout << suff << endl;
	}

	size_t pos2 = s2.rfind('.');
	if (pos2 != string::npos)
	{
		string suff = s2.substr(pos2);
		cout << suff << endl;
	}
	
	string str("https://legacy.cplusplus.com/reference/string/string/substr/");
	string sub1, sub2, sub3;
	pos1 = str.find(':');
	sub1 = str.substr(0, pos1 - 0);
	cout << sub1 << endl;

	pos2 = str.find('/', pos1+3);
	sub2 = str.substr(pos1 + 3, pos2 - (pos1 + 3));
	cout << sub2 << endl;

	sub3 = str.substr(pos2 + 1);
	cout << sub3 << endl;

	return 0;
}

find_first_of()：

int main()
{
	std::string str("Please, replace the vowels in this sentence by asterisks.");
	std::size_t found = str.find_first_not_of("abc");
	while (found != std::string::npos)
	{
		str[found] = '*';
		found = str.find_first_not_of("abc", found + 1);
	}

	std::cout << str << '\n';

	string s1("xxxx");
	string s2 = "xxxx";

	return 0;
}

注意：
1. 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
5. string类非成员函数

函数	功能说明
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator>>	输入运算符重载
operator<<	输出运算符重载
getline	获取一行字符串
relational operators	大小比较

vs和g++下string结构的说明
vs下string的结构
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：

当字符串长度小于16时，使用内部固定的字符数组来存放
当字符串长度大于等于16时，从堆上开辟空间

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字段保存从堆上开辟空间总的容量
最后：还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节
![[Pasted image 20251229195717.png]]

g++下string的结构
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个
指针，该指针将来指向一块堆空间，内部包含了如下字段：

空间总大小
字符串有效长度
引用计数

struct _Rep_base  
{  
	size_type _M_length;  
	size_type _M_capacity;  
	_Atomic_word _M_refcount;  
};

指向堆空间的指针，用来存储字符串。