【C++强基篇】学习C++就看这篇---＞STL之string使用及实现

#include <string> // 必须包含的头文件
using namespace std; // 或者显式使用 std::string

std::string str1;              // 默认构造，空字符串 ""
std::string str2("Hello");     // 用 C 风格字符串初始化
std::string str3 = "World";    // 同上
std::string str4(str2);        // 拷贝构造 "Hello"
std::string str5(5, 'A');      // 构造包含 5 个 'A' 的字符串 "AAAAA"
std::string str6(str2, 1, 3);  // 从 "Hello" 的索引 1 开始取 3 个字符 "ell"
std::string str7(str2, 1);     // 如果第三个参数不写的话默认是最大的即npos，"ello"
std::string str8(str2, 1，string::npos); //与上述语句功能完全一致
std::string str9 = str2 + " " + str3; // 连接构造 "Hello World"

size_t string::npos = -1;

s.reserve(100);//reserve提前开空间，但要考虑内存对齐，一般都是开给定空间的整数倍
s.resize(100, 'x');//resize是不光开空间而且将开辟的空间给值，不自己设定值默认是'\0'

string s("hello world");
s.resize(5);//会发生截断
s.resize(20, 'x');//在hello world后面补充x直至达到20个空间
cout << s << endl;//也就是说resize是管你空间的，你原本就够的给你截断，你原本不够的给你补充

cout << s1 << endl;//调用的是string重载的operator<< 会将对象数组中的所有字符都输出
cout << s1.c_str() << endl;//直接输出const char*是C语言的形式 遇到\0就会结束
//就会发现cout << s1 << endl;是会打印完的，而cout << s1.c_str() << endl;只打印到\0处

int main() {
	string s1, s2;

	cout << "Enter a string for cin: ";
	cin >> s1;  // 输入 "Hello World"，s1 只得到 "Hello"

	cin.ignore(); // 清除缓冲区残留的换行符

	cout << "Enter a string for getline: ";
	getline(cin, s2); // 输入 "Hello World"，s2 得到完整内容

	cout << "cin: " << s1 << endl;    // 输出 "Hello"
	cout << "getline: " << s2;        // 输出 "Hello World"
	return 0;
}

str1 = "New Value"; // 赋值(重要)
str1.assign("Assigned", 3); // 赋值前 3 个字符 "Ass"

char first = str2[0];   // 'H' (下标运算符，不检查边界)
const char* cstr = str2.c_str(); // 获取指向内部 C 风格字符串的指针 (只读，内容可能随 str2 改变而失效)
---------------------下面不常用---------------------------------------------------------
char second = str2.at(1); // 'e' (at 方法，会检查边界，越界抛 std::out_of_range)
char last = str2.back(); // 'o' (C++11)
char first = str2.front(); // 'H' (C++11)
const char* dataptr = str2.data(); // 类似 c_str() (C++11 起，data() 在非 const string 上也返回 const char*，直到 C++17 才有非 const 版本)

str2 += " C++";         // 追加 " C++" -> "Hello C++" (operator+=)
str2.insert(5, " dear"); // 在索引 5 处插入 " dear" -> "Hello dear C++!!!"
str2.erase(5, 5);       // 从索引 5 开始删除 5 个字符 -> "Hello C++!!!"
str2.clear();           // 清空字符串 -> ""
str2.resize(10, 'X');   // 改变大小为 10，不足部分用 'X' 填充 -> "XXXXXXXXXX"
str2.append("!!!");     // 追加 "!!!" -> "Hello C++!!!"
str2.push_back('!');    // 追加单个字符 '!'
str2.replace(6, 3, "Standard"); // 从索引 6 开始替换 3 个字符 ("C++") 为 "Standard" -> "Hello Standard!!!"

//插入一般喜欢用+=

size_t pos1 = str.find("World"); // 查找子串 "World" 首次出现的位置，找不到返回 std::string::npos
size_t pos2 = str.find("lo", 1); // 从索引 1 开始查找 "lo"
size_t pos3 = str.rfind("l");    // 查找 'l' 最后一次出现的位置
size_t pos4 = str.find_first_of("aeiou"); // 查找 "a", "e", "i", "o", "u" 中任意一个首次出现的位置
size_t pos5 = str.find_first_not_of("0123456789"); // 查找第一个非数字字符的位置
// 类似的有 find_last_of, find_last_not_of

//取文件后缀名
void test_string1()
{
	string s1("string.cpp");
	string s2("string.c");
	string s3("string.txt");
	size_t pos1 = s1.find('.');//如果没找到的话返回的就是无符号整型的最大值
	if (pos1 != string::npos)
	{
		cout << s1.substr(pos1) << endl;
	}
	size_t pos2 = s2.find('.');
	if (pos2 != string::npos)
	{
		cout << s2.substr(pos1) << endl;
	}
}
//分离网址
void test_string2()
{
	string habcsdnurl("https://blog.csdn.net/qq_53706413?spm=1011.2124.3001.5343");
	string& url = habcsdnurl;
	//分离url 协议   域名    资源名称
	size_t pos1 = url.find(':');
	if (pos1 != string::npos)
	{
		cout << url.substr(0, pos1) << endl;
	}

	size_t pos2 = url.find('/', pos1 + 3);
	if (pos2 != string::npos)
	{
		cout << url.substr(pos1 + 3, pos2 - (pos1 + 3)) << endl;
	}
	cout << url.substr(pos2+1);
}

std::string sub1 = str.substr(6);     // 从索引 6 开始到结尾的子串 ("Standard!!!")
std::string sub2 = str.substr(6, 8);  // 从索引 6 开始长度为 8 的子串 ("Standard")

if (str1 == str2) { ... }    // 相等比较
if (str1 != str3) { ... }    // 不等比较
if (str1 < str4) { ... }     // 小于比较 (字典序)
int result = str1.compare(str2); // 返回 0(相等), >0(str1>str2), <0(str1<str2)
int result = str1.compare(0, 3, "Hel"); // 比较 str1 的前 3 个字符和 "Hel"

size_t len = str.size();      // 或 str.length(), 当前字符数
bool isEmpty = str.empty();   // 是否为空字符串 (size() == 0)
size_t cap = str.capacity(); // 当前已分配的内存能容纳的字符数 (通常 >= size())
str.reserve(100);             // 请求预留至少 100 字符的容量 (优化后续操作，减少重新分配)
str.shrink_to_fit();          // 请求减少 capacity() 到 size() (C++11, 请求非强制)

std::cout << str << std::endl; // 输出字符串
std::cin >> str;              // 读取一个单词 (遇空格/换行停止)
std::getline(std::cin, str);  // 读取一整行 (包括空格，直到换行符)

namespace hab 
{
	class string 
	{
	public:
		/*string(char* str)
			:_str(new char[strlen(str) + 1])
		{
			strcpy(_str, str);
		}
		string()
			:_str(new char[1])
		{
			_str[0] = '\0';
		}*/
		//合并写法
		string(const char* str ="\0")
			:_str(new char[strlen(str) + 1])
		{
			strcpy(_str, str);
		}
		string(const string& s)//为什么const string s报错,因为陷入了死循环，一直在调用拷贝构造
			:_str(new char[strlen(s._str) + 1])
		{
			strcpy(_str, s._str);
		}//这是深拷贝，即重新开辟空间
		//但是如果是编译器默认生成的就会造成浅拷贝的问题，浅拷贝就是对同一块空间释放多次导致的错误。
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
			}
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		const char* c_str()
		{
			return _str;
		}
		size_t size()
		{
			return strlen(_str);
		}

	
	private:
		char* _str;
	};
}

		string(const string& s)//拷贝构造的另一种写法
			:_str(nullptr)
		{
			string tmp(s._str);
			swap(_str, tmp._str);
		}//有点空手套白狼的感觉
		
		//沿用上述思路，可以对赋值进行更改
		//string& operator=(const string& s)
		//{
		//	if (this != &s)
		//	{
		//		string tmp(s);
		//		swap(_str, tmp._str);//这里遇到如果由capacity和size时交换存在问题
		//	}
		//	return *this;
		//}
		//也可以用下述的写法
		string& operator=(string s)//这里最巧的就是这个传值操作
		{
			swap(_str, s._str);
			return *this;
		}

istream& operator>>(istream& in, string& s)
	{
		while (1)
		{
			char ch;
			//in >> ch;//这里会导致无法读取换行符或者空格的问题，
					 //原因就在于当执行 in >> ch 时，运算符会忽略（跳过）所有前导空白字符（包括空格、换行符 '\n'、制表符等）。
			ch = in.get();
			if (ch == ' ' || ch == '\n')
				break;
			else
				s += ch;
		}
		return in;
	}