C++ STL---string

string

与C语言的字符串操作函数不同的一点是，C语言的string是通过\0来判断字符串的结束的，而C++STL中的string类是通过capacity来知道是否应该扩容，不存在满的情况，相当于是个动态的操作，当size==capacity的时候就会按照一定的规则扩容，同时C++的string类中函数丰富的库函数，能更加丰富我们对于字符串的操作。

string类常见的构造函数的写法

1. string()—构造空的string类对象，即空字符串
2. string(const char * s)—用C-string来构造string类对象
3. string(size_t n,char c)—string类对象中包括n个字符c
4. string(const string&s)—拷贝构造函数
5. string(const string&s,size_t n)—用s中前n个字符来构造新的string类对象
   代码示例：

String(const char * str = "") :
		m_capacity(DEFAULTCAPA)
	{
		if (nullptr == str)
		{
			str = "";
		}

		m_size = strlen(str);
		m_capacity = COUNTCAPA(m_size);
		m_data = new char[m_capacity];
		strncpy(m_data, str, m_size);
	}

	String(String &s)
	{
		m_size = s.m_size;
		m_capacity = s.m_capacity;

		m_data = new char[m_capacity];
		strcpy(m_data, s.m_data);
	}

	String & operator = (const char * str)
	{
		m_size = strlen(str);
		reserve(m_size);

		strcpy(m_data, str);
		return *this;
	}

	String & operator = (String &s)
	{
		m_size = s.m_size;
		reserve(m_size);

		strcpy(m_data, s.m_data);
		return *this;
	}

	String(size_t n, char ch) :
		m_size(n),
		m_capacity(COUNTCAPA(n))
	{
		m_data = new char[m_capacity];
		memset(m_data, ch, m_size);
	}

string类中常用容量操作的函数
1.size ：string字符串中实际字符的数量，也就是字符串的长度
2.length：string字符串中字符串的实际长度
3.capacity：string字符串的容量大小
4.empty：检测string串是否为空串
5.clear：清空有效字符，不会改变capacity
6.resize：将有效字符的个数改成n个，多余的字符用\0或c填写，小于size的话就截取前n个
7.reverse：为字符串预留空间，若是预留的空间比原空间大的话，capacity就跟着增大，反之capacity不变

size_t size()
	{
		return m_size;
	}

	size_t length()
	{
		return m_size;
	}

	size_t capacity()
	{
		return m_capacity - 1;
	}

	bool empty()
	{
		return m_size == 0;
	}

	void clear()
	{
		m_size = 0;
	}

	void reserve(size_t size)
	{
		if (size >= m_capacity)
		{
			m_capacity = COUNTCAPA(size);
			m_data = (char *)realloc(m_data, m_capacity);
		}
	}

	void resize(size_t size, char ch = '\0')
	{
		reserve(size);

		if (m_size < size)
		{
			memset(m_data + m_size, ch, size - m_size);
		}
		m_size = size;
	}

string类中常用的对象访问操作
char & operator [] (size_t pos)—返回pos的位置

char &operator[](int i)
	{
		return m_data[i];
	}

string类中常用的对象修改操作
1.push_back：尾插一个字符
2.string & append (const char s) ：追加一个字符串*
3.string & operator+=(const string&str) ：追加字符串str
4.string & operator+=(const char s) ： 追加s个字符*
5.string & operator +=(const char c) :追加字符c
6.find ： 从begin开始查找
7.rfind ： 从end开始向后查找
8.substr ： 截取从某个位置开始到某个位置之间的字符
c_str 返回C格式的字符串，也就是char *类型
代码示例：

size_t find(char ch, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}

		char * tmp = strchr(m_data + pos, ch);

		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}

	size_t find(const char *str, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}

		char * tmp = strstr(m_data + pos, str);

		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}

	size_t find(const String &s, int pos = 0)
	{
		if (pos < 0 || pos >= m_size)
		{
			return -1;
		}

		char * tmp = strstr(m_data + pos, s.m_data);

		if (tmp)
		{
			return tmp - m_data;
		}
		return -1;
	}


	String substr(size_t start, size_t num)
	{
		String tmp;

		tmp.resize(num);

		strncpy(tmp.m_data, m_data + start, num);
		return tmp;
	}

string—getline：

//cin.getline(str,100);
	getline(cin, s1);

getline的两种使用方式，获取字符串或字符

各种运算符的重载…

string剩下的部分：迭代器：iterator：

string::reverse_iterator i;
		int j = 0;
		for (i = s.rbegin; i != s.rend(); i++)
		{
			m_data[j] = *i - '0';
			j++;
		}

relational operators 大小比较