C++从入门到精通——string类

typedef basic_string<char, char_traits, allocator>
string;

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

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

#include <string>


// 测试string容量相关的接口
// size/clear/resize
void Teststring1()
{
	// 注意：string类对象支持直接用cin和cout进行输入和输出
	string s("hello, bit!!!");
	cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	// “aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	// 注意此时s中有效字符个数已经增加到15个
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	// 将s中有效字符个数缩小到5个
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
}

//====================================================================================
void Teststring2()
{
	string s;
	// 测试reserve是否会改变string中有效元素个数
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}

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

// 构建vector时，如果提前已经知道string中大概要放多少个元素，可以提前将string中空间设置好
void TestPushBackReserve()
{
	string s;
	s.reserve(100);
	size_t sz = s.capacity();

	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}



// string的遍历
// begin()+end()   for+[]  范围for
// 注意：string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
// begin()+end()大多数使用在需要使用STL提供的算法操作string时，比如：采用reverse逆置string
void Teststring3()
{
	string s1("hello Bit");
	const string s2("Hello Bit");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;

	// s2[0] = 'h';   代码编译失败，因为const类型对象不能修改
}

void Teststring4()
{
	string s("hello Bit");
	// 3种遍历方式：
	// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
	// 另外以下三种方式对于string而言，第一种使用最多
	// 1. for+operator[]
	for (size_t i = 0; i < s.size(); ++i)
		cout << s[i] << endl;

	// 2.迭代器
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << endl;
		++it;
	}

	// string::reverse_iterator rit = s.rbegin();
	// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
	auto rit = s.rbegin();
	while (rit != s.rend())
		cout << *rit << endl;

	// 3.范围for
	for (auto ch : s)
		cout << ch << endl;
}


//
// 测试string：
// 1. 插入(拼接)方式：push_back  append  operator+= 
// 2. 正向和反向查找：find() + rfind()
// 3. 截取子串：substr()
// 4. 删除：erase
void Teststring5()
{
	string str;
	str.push_back(' ');   // 在str后插入空格
	str.append("hello");  // 在str后追加一个字符"hello"
	str += 'b';           // 在str后追加一个字符'b'   
	str += "it";          // 在str后追加一个字符串"it"
	cout << str << endl;
	cout << str.c_str() << endl;   // 以C语言的方式打印字符串

	// 获取file的后缀
	string file("string.cpp");
	size_t pos = file.rfind('.');
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;

	// npos是string里面的一个静态成员变量
	// static const size_t npos = -1;

	// 取出url中的域名
	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos)
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;

	// 删除url的协议前缀
	pos = url.find("://");
	url.erase(0, pos + 3);
	cout << url << endl;
}

int main()
{
	return 0;
}

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";

    // 使用下标和方括号遍历string类
    for (int i = 0; i < str.length(); i++) {
        std::cout << str[i] << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>

int main() {
    // 一个字符串示例
    std::string myString = "Hello, World!";

    // 使用for循环遍历字符串
    for (auto ch : myString) {
        std::cout << ch << std::endl;
    }

    return 0;
}

H
e
l
l
o
,
 
W
o
r
l
d
!

#include <iostream>
#include <string>

int main() {
    // 一个字符串示例
    std::string myString = "Hello, World!";

    // 使用迭代器遍历字符串
    for (std::string::iterator it = myString.begin(); it != myString.end(); ++it) {
        char ch = *it; // 获取迭代器指向的字符
        std::cout << ch << std::endl;
    }

    return 0;
}

H
e
l
l
o
,
 
W
o
r
l
d
!

s1 += 'y';
s1 +='yyyyyyyyyyyyyyyyyy';

string s2 ("11111111111");
s1 += s2;

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;

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

class Solution {
public:
	bool isLetter(char ch)
	{
		if (ch >= 'a' && ch <= 'z')
			return true;
		if (ch >= 'A' && ch <= 'Z')
			return true;

		return false;
	}
	string reverseOnlyLetters(string S) {
		if (S.empty())
			return S;

		size_t begin = 0, end = S.size() - 1;
		while (begin < end)
		{
			while (begin < end && !isLetter(S[begin]))
				++begin;

			while (begin < end && !isLetter(S[end]))
				--end;

			swap(S[begin], S[end]);
			++begin;
			--end;
		}

		return S;
	}
};

class Solution {
public:
	int firstUniqChar(string s) {

		// 统计每个字符出现的次数
		int count[256] = { 0 };
		int size = s.size();
		for (int i = 0; i < size; ++i)
			count[s[i]] += 1;

		// 按照字符次序从前往后找只出现一次的字符
		for (int i = 0; i < size; ++i)
			if (1 == count[s[i]])
				return i;

		return -1;
	}
};

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

int main()
{
	string line;
	// 不要使用cin>>line,因为会它遇到空格就结束了
	// while(cin>>line)
	while (getline(cin, line))
	{
		size_t pos = line.rfind(' ');
		cout << line.size() - pos - 1 << endl;
	}
	return 0;
}

class Solution {
public:
	bool isLetterOrNumber(char ch)
	{
		return (ch >= '0' && ch <= '9')
			|| (ch >= 'a' && ch <= 'z')
			|| (ch >= 'A' && ch <= 'Z');
	}

	bool isPalindrome(string s) {
		// 先小写字母转换成大写，再进行判断
		for (auto& ch : s)
		{
			if (ch >= 'a' && ch <= 'z')
				ch -= 32;
		}

		int begin = 0, end = s.size() - 1;
		while (begin < end)
		{
			while (begin < end && !isLetterOrNumber(s[begin]))
				++begin;

			while (begin < end && !isLetterOrNumber(s[end]))
				--end;

			if (s[begin] != s[end])
			{
				return false;
			}
			else
			{

				++begin;
				--end;
			}
		}

		return true;
	}
};

class Solution {
public:
	string addstrings(string num1, string num2)
	{
		// 从后往前相加，相加的结果到字符串可以使用insert头插
		// 或者+=尾插以后再reverse过来
		int end1 = num1.size() - 1;
		int end2 = num2.size() - 1;
		int value1 = 0, value2 = 0, next = 0;
		string addret;
		while (end1 >= 0 || end2 >= 0)
		{
			if (end1 >= 0)
				value1 = num1[end1--] - '0';
			else
				value1 = 0;

			if (end2 >= 0)
				value2 = num2[end2--] - '0';
			else
				value2 = 0;

			int valueret = value1 + value2 + next;
			if (valueret > 9)
			{
				next = 1;
				valueret -= 10;
			}
			else
			{
				next = 0;
			}

			//addret.insert(addret.begin(), valueret+'0');
			addret += (valueret + '0');
		}

		if (next == 1)
		{
			//addret.insert(addret.begin(), '1');
			addret += '1';
		}

		reverse(addret.begin(), addret.end());
		return addret;
	}
};

// 为了和标准库区分，此处使用String
class String
{
public:
	/*String()
	 :_str(new char[1])
	 {*_str = '\0';}
	 */
	 //String(const char* str = "\0") 错误示范
	 //String(const char* str = nullptr) 错误示范
	String(const char* str = "")
	{
		// 构造String类对象时，如果传递nullptr指针，可以认为程序非
		if (nullptr == str)
		{
			assert(false);
			return;
		}

		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

// 测试
void TestString()
{
	String s1("hello bit!!!");
	String s2(s1);
}

class String
{
public:
	String(const char* str = "")
	{
		// 构造String类对象时，如果传递nullptr指针，可以认为程序非
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
	String(const String& s)
		:
		_str(new char[strlen(s._str) + 1])
	{
	}
	strcpy(_str, s._str);
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* pStr = new char[strlen(s._str) + 1];
			strcpy(pStr, s._str);
			delete[] _str;
			_str = pStr;
		}
		return *this;
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

class String
{
public:
	String(const char* str = "")
	{
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
	String(const String& s)
		:
		_str(nullptr)
	{
	}
	String strTmp(s._str);
	swap(_str, strTmp._str);
	// 对比下和上面的赋值那个实现比较好？
	String& operator=(String s)
	{
		swap(_str, s._str);
		return *this;
	}
	/*
	String& operator=(const String& s)
	{
	if(this != &s)
	{
	String strTmp(s);
	swap(_str, strTmp._str);
	}
	return *this;
	}
	*/
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;
#include <assert.h>

namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
	public:
		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		string(const string& s)
			: _str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			this->swap(tmp);
		}

		string& operator=(string s)
		{
			this->swap(s);
			return *this;
		}

		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}

		/
		// iterator
		iterator begin() 
		{ 
			return _str; 
		}

		iterator end() 
		{ 
			return _str + _size; 
		}

		/
		// modify
		void push_back(char c)
		{
			if (_size == _capacity)
				reserve(_capacity * 2);

			_str[_size++] = c;
			_str[_size] = '\0';
		}

		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

		// 作业实现
		void append(const char* str);
		string& operator+=(const char* str);

		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		const char* c_str()const
		{
			return _str;
		}

		/
		// capacity
		size_t size()const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}

		bool empty()const
		{
			return 0 == _size;
		}

		void resize(size_t newSize, char c = '\0')
		{
			if (newSize > _size)
			{
				// 如果newSize大于底层空间大小，则需要重新开辟空间
				if (newSize > _capacity)
				{
					reserve(newSize);
				}

				memset(_str + _size, c, newSize - _size);
			}

			_size = newSize;
			_str[newSize] = '\0';
		}

		void reserve(size_t newCapacity)
		{
			// 如果新容量大于旧容量，则开辟空间
			if (newCapacity > _capacity)
			{
				char* str = new char[newCapacity + 1];
				strcpy(str, _str);

				// 释放原来旧空间,然后使用新空间
				delete[] _str;
				_str = str;
				_capacity = newCapacity;
			}
		}

		
		// access
		char& operator[](size_t index)
		{
			assert(index < _size);
			return _str[index];
		}

		const char& operator[](size_t index)const
		{
			assert(index < _size);
			return _str[index];
		}

		
		// 作业
		bool operator<(const string& s);
		bool operator<=(const string& s);
		bool operator>(const string& s);
		bool operator>=(const string& s);
		bool operator==(const string& s);
		bool operator!=(const string& s);

		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const;
		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const;

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c);
		string& insert(size_t pos, const char* str);

		// 删除pos位置上的元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len);

	private:
		friend ostream& operator<<(ostream& _cout, const bit::string& s);
		friend istream& operator>>(istream& _cin, bit::string& s);
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};

	ostream& operator<<(ostream& _cout, const bit::string& s)
	{
		// 不能使用这个, 因为string的字符串内部可能会包含\0
		// 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了
		//cout << s._str;
		for (size_t i = 0; i < s.size(); ++i)
		{
			_cout << s[i];
		}
		return _cout;
	}
}

///对自定义的string类进行测试
void TestBitstring()
{
	bit::string s1("hello");
	s1.push_back(' ');
	s1.push_back('b');
	s1.push_back('i');
	s1 += 't';
	cout << s1 << endl;
	cout << s1.size() << endl;
	cout << s1.capacity() << endl;

	// 利用迭代器打印string中的元素
	bit::string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;

	// 这里可以看到一个类只要支持的基本的iterator，就支持范围for
	for (auto ch : s1)
		cout << ch;
	cout << endl;
}

#include <algorithm>

sort(container.begin(), container.end());

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

int main() {
    int arr[] = {5, 2, 8, 1, 9};
    int n = sizeof(arr) / sizeof(arr[0]);

    sort(arr, arr + n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

sort(container.begin(), container.end(), greater<>());

15
31
……

std::vector<int> myVector;
std::cout << "容量：" << myVector.capacity() << std::endl;

std::string myString;
std::cout << "容量：" << myString.capacity() << std::endl;

std::vector<int> myVector;
myVector.reserve(100); // 预分配容量为100

std::string myString;
myString.reserve(100); // 预分配容量为100

std::vector<int> myVector;
myVector.reserve(100); // 预分配容量为100

std::string myString;
myString.reserve(100); // 预分配容量为100

std::vector<int> myVector;
myVector.resize(10); // 将容器的大小设置为10

std::string myString;
myString.resize(10); // 将字符串的大小设置为10

void shrink_to_fit();

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;

    // 在不断添加元素后，vector的容量可能会超过实际需要的大小
    for (int i = 0; i < 100; i++) {
        vec.push_back(i);
    }

    std::cout << "容量：" << vec.capacity() << std::endl;
    std::cout << "大小：" << vec.size() << std::endl;

    // 调用shrink_to_fit函数，释放多余的内存空间
    vec.shrink_to_fit();

    std::cout << "调用shrink_to_fit函数后的容量：" << vec.capacity() << std::endl;
    std::cout << "调用shrink_to_fit函数后的大小：" << vec.size() << std::endl;

    return 0;
}

容量：128
大小：100
调用shrink_to_fit函数后的容量：100
调用shrink_to_fit函数后的大小：100

reference at(size_type pos);
const_reference at(size_type pos) const;

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    try {
        // 访问索引为2的元素
        int value = vec.at(2);
        std::cout << "索引为2的元素：" << value << std::endl;

        // 访问超出范围的索引
        value = vec.at(10);  // 这里会抛出std::out_of_range异常
        std::cout << "索引为10的元素：" << value << std::endl;
    } catch (const std::out_of_range& e) {
        std::cout << "发生了out_of_range异常：" << e.what() << std::endl;
    }

    return 0;
}

索引为2的元素：3
发生了out_of_range异常：vector::_M_range_check: __n (which is 10) >= this->size() (which is 5)

vector<int> nums = {1, 2, 3, 4};
nums.insert(nums.begin() + 2, 5);  // 在索引为2的位置插入元素5

list<int> nums = {1, 2, 3, 4};
auto it = nums.begin();
advance(it, 2);
nums.insert(it, 5);  // 在迭代器指向的位置插入元素5

map<string, int> scores = {{"Alice", 90}, {"Bob", 80}, {"Charlie", 70}};
scores.insert(make_pair("David", 60));  // 插入键值对"Davis"和60

set<string> names = {"Alice", "Bob", "Charlie"};
names.insert("David");  // 插入元素"David"

string str = "Hello World";
str.erase(5);  // 删除索引为5的字符，结果为"HelloWorld"
str.erase(0, 5);  // 删除从索引0开始的5个字符，结果为"World"

vector<int> vec = {1, 2, 3, 4, 5};
vec.erase(vec.begin());  // 删除容器的第一个元素，结果为{2, 3, 4, 5}
vec.erase(vec.begin() + 2, vec.begin() + 4);  // 删除容器的第3个和第4个元素，结果为{2, 3, 5}