C++——string使用

string的常见构造接口 

string s1; 
string s2("hello world");
string s3(s2); 
string s4(10,'*');

string类对象的容量操作

size——返回字符串的有效长度

std::string::size
size_t size() const;

int main ()
{
  std::string str ("Test string");
  std::cout << "The size of str is " << str.size() << " bytes.\n";
  return 0;
}
//The size of str is 11 bytes

 capacity——返回空间总大小

std::string::capacity
size_t capacity() const;

int main ()
{
  std::string str ("Test string");
  std::cout << "size: " << str.size() << "\n";
  std::cout << "capacity: " << str.capacity() << "\n";
  return 0;
}

//size: 11
//capacity: 15

 empty——判断对象是否为空

std::string::empty
bool empty() const;

应用：将用户输入的内容逐行读取并存储，直到遇到空行 

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string line;
	string content;
	do
	{
		getline(cin, line);
		content += line + '\n';
	} while (!line.empty());
	cout << content;
}

clear——清空有效字符

std::string::clear
void clear();

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string str("hello world");
	str.clear();
	if (str.empty())
		cout << "string has been deleted" << endl;
}

clear只改清空数据，不改变空间大小 

reserve——为字符串预留空间

std::string::reserve
void reserve (size_t n = 0);

int main()
{
	string str("hello world");
	cout << str.capacity() << endl;
	cout << str.size() << endl;
	str.reserve(100);
	cout << str.capacity() << endl;
	cout << str.size() << endl;
}

 当参数n小于字符串大小时，不会缩小容量

resize——修改有效字符个数

std::string::resize
void resize (size_t n);void resize (size_t n, char c);

当n大于字符串大小时，多的空间会用字符c来填充(\0不会被覆盖) ，如果c缺省会自动补\0；如果n小于字符串大小时，会将多出的字符直接删除，但是不会改变基层空间capacity

int main()
{
	string str;
	str.resize(1);
	cout << str << endl;
	str.resize(5, '+');
	cout << str << endl;//字符串是 \0++++ 不同编译器输出可能不同
	str.resize(1);
	cout << str << endl;
}

string类对象的访问及遍历

operator[ ]——[ ]的运算符重载

std::string::operator[]
char& operator[] (size_t pos);const char& operator[] (size_t pos) const;

使用和数组类似，都是访问[ ]内数字下标位置的字符

int main()
{
	string str("hello world");
	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i];
	}
	cout << endl;
}

迭代器begin和end，顺序遍历

iterator begin();const_iterator begin() const;
iterator end();const_iterator end() const;

using namespace std;

int main()
{
	string str("hello world");
	string::iterator sit = str.begin();
	while (sit != str.end())
	{
		cout << *sit;
		sit++;
	}
	cout << endl;
}

迭代器rbegin和rend，逆序遍历

reverse_iterator rbegin();const_reverse_iterator rbegin() const;
reverse_iterator rend();const_reverse_iterator rend() const;

using namespace std;

int main()
{
	const string str("hello world");
	string::const_reverse_iterator sit = str.rbegin();
	while (sit != str.rend())
	{
		cout << *sit;
		sit++;
	}
	cout << endl;
}

范围for(底层使用迭代器)

int main()
{
	const string str("hello world");
	for (char c : str)
	{
		cout << c;
	}
	cout << endl;
}

c_str——返回c格式字符串

std::string::c_str

const char* c_str() const;

int main()
{
	string str("hello world");
	const char* ch = str.c_str();
	cout << ch << endl;
}

 这个接口是为了和c语言更好兼容

string类对象的修改

append——追加字符串

std::string::append
	
//追加str
string& append (const string& str);
	
//追加str的子串，字串是从str的subpos下标位置开始，向后的sublen个字符
string& append (const string& str, size_t subpos, size_t sublen);

//追加常量字符串s
string& append (const char* s);
	
//追加常量字符串的前n个字符
string& append (const char* s, size_t n);
	
//追加n个字符c
string& append (size_t n, char c);

//迭代器追加
template <class InputIterator>   string& append (InputIterator first, InputIterator last);

#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(10,'.');                    // ".........."
  str.append(str3.begin()+8,str3.end());  // " and then 5 more"
  str.append(5,'.');                // "....."

  std::cout << str << '\n';
  return 0;
}
//Writing 10 dots here: .......... and then 5 more.....

operator+= ——追加字符串

std::string::operator+=
	
string& operator+= (const string& str);
	
string& operator+= (const char* s);
	
string& operator+= (char c);

+=运算符重载和append的功能基本相同，append除此之外可以使用迭代器，插入指定数量的字符，但是+=使用更方便

find——从前寻找字符(串)并返回下标位置

std::string::find

size_t find (const string& str, size_t pos = 0) const;	
size_t find (const char* s, size_t pos = 0) const;
size_t find (const char* s, size_t pos, size_t n) const;
size_t find (char c, size_t pos = 0) const;

rfind——从后寻找字符(串)并返回下标位置

string::npos是一个静态无符号整型变量，大小为-1(即最大的无符号整数)

std::string::rfind

size_t rfind (const string& str, size_t pos = npos) const;	
size_t rfind (const char* s, size_t pos = npos) const;
size_t rfind (const char* s, size_t pos, size_t n) const;	
size_t rfind (char c, size_t pos = npos) const;

rfind如果未给出查找的起始位置，或者起始位置下标越界，会从字符串末尾开始寻找；rfind和find一样，如果未找到目标，就会返回npos

substr——从字符串中截取子串

std::string::substr
string substr (size_t pos = 0, size_t len = npos) const;

如果pos等于字符串大小，就会返回空字符串；如果pos大于字符串大小，就会抛异常

#include <iostream>
#include <string>

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

  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;
}

string类的非成员函数

operator+

std::operator+ (string)

string operator+ (const string& lhs, const string& rhs);	

string operator+ (const string& lhs, const char*   rhs);
string operator+ (const char*   lhs, const string& rhs);

string operator+ (const string& lhs, char          rhs);
string operator+ (char          lhs, const string& rhs);

这个函数是传值返回，需要深拷贝，效率低少用为好

operator+=前面提到过

operator<<和operator>>

输入输出运算符重载，使用很简单,遇到空格或者换行结束文章来源地址https://www.toymoban.com/news/detail-692175.html

getline——获取一行字符串

std::getline (string)

istream& getline (istream& is, string& str, char delim);//读到delim字符结束

istream& getline (istream& is, string& str);//读到'\n'结束

relational operators——大小比较

relational operators (string)

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);

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);

#include <iostream>
#include <vector>

int main ()
{
  std::string foo = "alpha";
  std::string bar = "beta";

  if (foo==bar) std::cout << "foo and bar are equal\n";
  if (foo!=bar) std::cout << "foo and bar are not equal\n";
  if (foo< bar) std::cout << "foo is less than bar\n";
  if (foo> bar) std::cout << "foo is greater than bar\n";
  if (foo<=bar) std::cout << "foo is less than or equal to bar\n";
  if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";

  return 0;
}

到了这里，关于C++——string使用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！