STL-string类常用接口总结

概要：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> 
string;
4. 不能操作多字节或者变长字符的序列

注意：在使用string类时，必须包含头文件以及using namespace std；

 

接下来看看string类的各个常用接口：

1. string类对象的常见构造

#include <iostream>
#include <string>
using namespace std;

void TestString()
{
	string s1;//string();构造空的string类对象s1
	string s2("hello");//string (const char* s);用C格式字符串构造string类对象s2
	string s3(5, 'a');//string(size_t n, char c);用n个字符 'c'构造string类对象s3
	string s4(s2);//string (const string& str);用str对象拷贝构造对象s4
	string s5("world", 2);//string (const char* s, size_t n);从s指向的字符串中取前n个字符构造对象s5
	string s6(s2, 2, 3);//string (const string& str, size_t pos, size_t len = npos);
	                  //用str对象的字符串中从下标为pos开始，选取长度为npos的字符构造对象s6
	                 //如果npos省略没写，则默认长度一直到结尾字符
}

int main()
{
	TestString();
	//system("pause");
	return 0;
}

 

2. string类对象的容量操作

void TestString()
{
	string s1("hello world!");
	string s2;
	cout << s1.size() << endl;//size_t size() const;返回对象中字符串的字符个数
	cout << s1.length() << endl;//size_t length() const;返回字符串中的字符个数
	cout << s1.capacity() << endl;//size_t capacity() const;返回对象的空间总大小【起步15个字节】,不包含'\0'
	                              //当空间个数已满，则对象空间大小自动增加16个字节大小
	cout << s2.empty() << endl;//bool empty() const;判断对象字符串是否为空串【1为真，即空】【0为假，即非空】
	s1.clear();//void clear();清空对象字符串
	s1.resize(15, 'a');//void resize(size_t n, char c);将字符串调整为n个字符的长度,n大于原size，则剩余字符用字符c补满
	                   //n小于原size，直接将字节数截断为n个字节，内容不变
	s1.resize(10);//void resize(size_t n);将字符串调整为n个字符的长度，n大于原size，则剩余字节添'0'补满
	             //n小于原size，直接将字节数截断为n个字节，内容不变
	s1.reserve(30);//void reserve(size_t n = 0);为string预留空间，不改变有效元素个数，当reserve的参数小于
	             //string的底层空间总大小时，reserver不会改变容量大小
}

 

3. string类对象的访问操作

void TestString()
{
	string s1("hello world!");
	const string s2("Hello world!");
	cout << s1[0] << endl;//char& operator[] (size_t pos);返回对字符串中位置pos处的字符的引用。
	cout << s2[0] << endl;//const char& operator[] (size_t pos) const 返回对字符串中位置pos处的字符的引用。
}

4. string类对象的修改操作

void TestString()
{
	string s1("hello world");
	string s2(" i am coming");
	string s3;
	s1.push_back('!');//void push_back(char c);将字符c附加到字符串的末尾，将其长度增加一个。
	s1.append(" i am coming");//string& append(const char* s);将s指向的字符串追加到该对象字符串后面
	s1.append(5, '!');//string& append(size_t n, char c);给对象字符串后面追加n个字符c
	s1.append(s2, 6, 10);//string& append(const string& s, size_t subpos, size_t sublen);追加s对象的字符串【从s对象下标subpos开始，追加sublen个字符】
	s1 += s2;//string& operator+= (const string& s);追加对象字符串
	s1 += " i am coming";//string& operator+= (const char* s);追加指针指向的字符串
	s1 += '!';//string& operator+= (char c);追加字符
	const char *s = nullptr;
	s = s1.c_str();//const char* c_str() const;返回指向数组的指针，该数组包含一个以空结尾的字符序列(即表示字符串对象当前值的C-字符串)。
	cout << s1.find('w', 5);//size_t find (char c, size_t pos = 0) const;从字符串pos位置开始往后找字符c，返回该字符在字符串中的下标
	cout << s1.rfind('w', 8);//size_t rfind (char c, size_t pos = npos) const;从字符串pos位置开始往前找字符c，返回该字符在字符串中的下标
	s3 = s1.substr(0, 5);//string substr(size_t pos = 0, size_t len = npos) const;在str中从pos位置开始，截取len个字符，然后将其返回
}

void TestString()//打印对象file1的后缀
{
	string file1("string.cpp");
	size_t pos = file1.rfind('.');
	string suffix(file1.substr(pos, file1.size()-pos));
	cout << suffix << endl;
}

void TestString()// 取出url中的域名
{	
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos){   //如果url中没有://则直接返回
		cout << "invalid url" << endl;//打印：无效的url
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string s_str(url.substr(start, finish - start));
	cout << s_str << endl;

}

void TestString()// 删除url的协议前缀
{	
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t pos = url.find("://");
	url.erase(0, pos+3);
	cout << url << endl;

}

void TestPushBack_P()// 利用reserve提高插入数据的效率，避免增容带来的开销
{
	string s;
	s.reserve(100);//提前预开辟100字节空间，避免了增容带来的开销
	size_t sz = s.capacity();
	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i){
		s += 'c';
		if (sz != s.capacity()){
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

 

5. string类非成员函数

void TestString()
{	
	//istream& getline(istream& is, string& str, char delim);
	//istream& getline(istream& is, string& str);
	std::string name;
	std::cout << "Please, enter your full name: ";
	std::getline(std::cin, name); //从cin中提取字符并将它们存储到name中，直到找到定界字符换行符‘\n’
	std::cout << "Hello, " << name << "!\n";

}

void TestString()
{	
	//istream& operator>> (istream& is, string& str);
	string s1;
	cin >> s1;
	cout << s1 << endl;

	//ostream& operator<< (ostream& os, const string& str);
	string s2("hello");
	cout << s2 << endl;
}

void TestString()
{	
	//void swap(string& x, string& y);
	string s1(" hello");
	string s2(" bit");
	swap(s1, s2);
	s1.swap(s2);

}

void TestString()
{	
	string s1("hello");
	string s2("bit");
	//bool operator== (const string& lhs, const string& rhs);
	//bool operator== (const char*   lhs, const string& rhs);
	//bool operator== (const string& lhs, const char*   rhs);
	cout << (s1 == s2) << endl;
	cout << ("bit" == s2) << endl;
	cout << (s1 == "hello") << endl;

	//bool operator!= (const string& lhs, const string& rhs);
	//bool operator!= (const char*   lhs, const string& rhs);
	//bool operator!= (const string& lhs, const char*   rhs);
	cout << (s1 != s2) << endl;
	cout << ("bit" != s2) << endl;
	cout << (s1 != "hello") << endl;

	//bool operator<  (const string& lhs, const string& rhs);
	//bool operator<  (const char*   lhs, const string& rhs);
	//bool operator<  (const string& lhs, const char*   rhs);
	cout << (s1 < s2) << endl;
	cout << ("bit" < s2) << endl;
	cout << (s1 < "hello") << endl;

	//bool operator<= (const string& lhs, const string& rhs);
	//bool operator<= (const char*   lhs, const string& rhs);
	//bool operator<= (const string& lhs, const char*   rhs);
	
	//bool operator>  (const string& lhs, const string& rhs);
	//bool operator>  (const char*   lhs, const string& rhs);
	//bool operator>  (const string& lhs, const char*   rhs);
	
	//bool operator>= (const string& lhs, const string& rhs);
	//bool operator>= (const char*   lhs, const string& rhs);
	//bool operator>= (const string& lhs, const char*   rhs);

}