string 总结

最新推荐文章于 2024-03-18 03:58:29 发布

田怼怼

最新推荐文章于 2024-03-18 03:58:29 发布

阅读量266

点赞数

分类专栏： C++ STL 容器

本文链接：https://blog.csdn.net/tianduidui/article/details/101056316

版权

C++ 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

STL 容器

5 篇文章 0 订阅

订阅专栏

一、string的初始化

1、在使用string的过程中，需要添加头文件，即

#include<string>

切记，不是<string.h>
2、string类是一个模板类，在使用过程中应该还要加上名字空间，即

using namespace std;

3、声明字符串变量

string str;

二、string类常用接口说明

1、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)
用s的前n个字符构造新的string 类对象

测试代码

void Test()
{
	string s1;//构造空的string类对象s1
	string s2("hello world!");//用C-string构造string 类的对象s2
	string s3(4, 's');//用4个字符s构造对象s3
	string s4(s3);//拷贝构造s4
	string s5(s3, 3);//用s3中的前3个字符构造对象s5
}

2、string类对象的容量操作
1>size_t size()const
返回字符串的有效长度

2>size_t length()const
返回字符串的有效长度

注：在string类中size()和length()的作用及用法均相同
3>size_t capacity() const
没有参数，返回空间总大小（容量是16的倍数-1）

注：capacity()的值在一个string类中不会改变
4>bool empty() const
检查字符串是否为空，若为空返回1，否则，返回0

5>void clear()
清空有效字符

注：清空字符串后capacity的值也不会改变，而size和length的值变为0

6>void resize(size_t n, char c)
将有效字符串的个数改成n个，多出的空间用字符c填充

7>void resize(size_t n)
将有效字符的个数改成n个，多出的空间用0来填充，如果元素个数增多，可能会改变底层容量大小，如果元素个数减少，底层容量大小不会改变

8>void reserve(size_t res_arg 0)
为字符串预留空间，不改变有效元素的个数，当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小

9>append
可以对字符串进行追加，类似 +=，但可以串n个字符的形式

实现代码：

size_t size()
	{
		return m_size;
	}

	size_t length()
	{
		return m_size;
	}

	size_t capacity()
	{
		return m_capacity - 1;//减去尾0
	}

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

3、运算符的重载
直接看代码吧
以下代码包含了 > < >= <= == != 运算符的重载（每个运算符有三种实现方式）

bool String::operator > (const char * str) const
{
	return strncmp(m_data, str, m_size) > 0;

}

bool String::operator < (const char * str) const
{
	int tmp = strncmp(m_data, str, m_size);
	if (!tmp && strlen(str) > m_size)
	{
		return true;
	}
	return tmp < 0;
}

bool String::operator >= (const char * str) const
{
	return !(*this < str);
}

bool String::operator <= (const char * str) const
{
	return !(*this > str);
}

bool String::operator == (const char * str) const
{
	int tmp = strncmp(m_data, str, m_size);
	if (!tmp && strlen(str) == m_size)
	{
		return true;
	}
	return false;
}

bool String::operator != (const char * str) const
{
	return !(*this == str);
}

bool String::operator >  (const String &s) const
{
	int i;
	int minsize = m_size < s.m_size ? m_size : s.m_size;
	for (i = 0; i < minsize; i++)
	{
		if (m_data[i] > s.m_data[i])
		{
			return true;
		}
		else if (m_data[i] < s.m_data[i])
		{
			return false;
		}
	}
	return m_size > s.m_size;
}

bool String::operator <  (const String &s) const
{
	int i;
	int minsize = m_size < s.m_size ? m_size : s.m_size;
	for (i = 0; i < minsize; i++)
	{
		if (m_data[i] < s.m_data[i])
		{
			return true;
		}
		else if (m_data[i] > s.m_data[i])
		{
			return false;
		}
	}
	return m_size < s.m_size;
}

bool String::operator >= (const String &s) const
{
	return !(*this < s);
}

bool String::operator <= (const String &s) const
{
	return !(*this > s);
}

bool String::operator == (const String &s) const
{
	int i;
	int minsize = m_size < s.m_size ? m_size : s.m_size;
	for (i = 0; i < minsize; i++)
	{
		if (m_data[i] != s.m_data[i])
		{
			return false;
		}
	}
	return m_size == s.m_size;
}

bool String::operator != (const String &s) const
{
	return !(*this == s);
}


bool operator >  (const char * str, const String &s)
{
	int tmp = strncmp(str, s.m_data, s.m_size);
	if (!tmp && strlen(str) > s.m_size)
	{
		return true;
	}
	return tmp > 0;
}

bool operator <  (const char * str, const String &s)
{
	return strncmp(str, s.m_data, s.m_size) < 0;
}

bool operator >= (const char * str, const String &s)
{
	return !(str < s);
}

bool operator <= (const char * str, const String &s)
{
	return !(str > s);
}

bool operator == (const char * str, const String &s)
{
	int tmp = strncmp(s.m_data, str, s.m_size);
	if (!tmp && strlen(str) == s.m_size)
	{
		return true;
	}
	return false;
}
bool operator != (const char * str, const String &s)
{
	return !(str == s);
}

4、string类对象的修改操作
1>void push_back(char c)
在字符串后尾插字符c

2>string& append (const char* s)
在字符串后追加一个字符串，其作用相当于 +=

3>string& operator+=(const string&str)
在字符串后追加字符串str

4>string& operator+=(const char* s)
在字符串后追加C个数字符串(+的重载不是容器string容器的成员，+=才是)

5>string& operator+=(char c)
在字符串后追加字符c

6>const char* c_str( )const
返回C格式字符串

7>size_t find (char c, size_t pos =0)const
从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置

8>size_t rfind(char c, size_t pos = npos)
从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置

9>string substr(size_t pos = 0, size_t n= npos)const
在str中从pos位置开始，截取n个字符，然后将其返回(找到了返回下标，找不到返回-1,。但是由于返回值是unsigned类型，所以打印出来就是4294967295)

实现代码

	interator begin()
	{
		return m_data;
	}

	interator end()
	{
		return m_data + m_size;
	}

	void pushback(char ch)
	{
		reserve(m_size);//判断数据是否已满，若相等则直接扩容

		m_data[m_size] = ch;
		m_size++;
	}

	void popback(char ch)
	{
		if (!empty())
		{
			m_size--;
		}
	}

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

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

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

		strcat(m_data +tmp, s.m_data);
		return *this;
	}

	const char * c_str()
	{
		return m_data;
	}

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

5、string类的非成员函数
1>operator+
尽量少用，因为效率低

2>operator>>
输入运算符重载

3>operator<<
输出运算符重载

4>getline
获取一行字符串(getline是为了解决cin输入字符串碰到空格就停止的问题，getline碰到回车才会停止)

5>relational operators
大小比较

实现代码

ostream & operator << (ostream & os, const String &s)
{
	int i;

	for (i = 0; i < s.m_size; i++)
	{
		os << s.m_data[i];
	}

	return os;
}

istream & operator >> (istream & is, String &s)
{
	char *tmp = new char[1024];
	is.getline(tmp, 1024);

	s.m_size = strlen(tmp);
	s.m_capacity = COUNTCAPA(s.m_size);
	
	//方式一
	strcpy(s.m_data, tmp);
	delete tmp;

	//方式二,效率更高
	//delete[]s.m_data;
	//s.m_data = tmp;

	return is;
}

String String::operator + (const char * str)  const//在左边
{
	String res;
	res.m_size = m_size + strlen(str);
	res.reserve(res.m_size);

	strncpy(res.m_data, m_data,m_size);
	strcpy(res.m_data + m_size, str);

	return res;
}

String String::operator + (const String &s) const //在右边
{
	String res;
	res.m_size = m_size + s.m_size;
	res.reserve(res.m_size);

	strncpy(res.m_data, m_data,m_size);
	strncpy(res.m_data + m_size, s.m_data,s.m_size);

	return res;
}

String operator + (const char * str, const String &s)//在中间
{
	String res;
	res.m_size = strlen(str) + strlen(str);
	res.reserve(res.m_size);

	strcpy(res.m_data, str);
	strncat(res.m_data, s.m_data, s.m_size);

	return res;
}