【c++】STL--string-创新互联

push_back

void push_back (char c);

ppends character cto the end of the string, increasing its length by one.

----将字符c追加到字符串的末尾，将其长度增加1

#include#include#includeusing namespace std;

int main()
{
	string str;
	str.push_back('h');
	str.push_back('e');
	str.push_back('l');
	str.push_back('l');
	str.push_back('o');

	std::cout<< str<< '\n';
	return 0;
}

append

string& append (const string& str);

string& append (const string& str, size_t subpos, size_t sublen);

string& append (const char* s);

string& append (const char* s, size_t n);

string& append (size_t n, char c);

templatestring& append (InputIterator first, InputIterator last);

(1) string

Appends a copy of str.----追加str的副本

(2) substring

Appends a copy of a substring of str. The substring is the portion of strthat begins at the character position subposand spans sublencharacters (or until the end of str, if either stris too short or if sublenis string::npos).

----追加str的子字符串的副本。该子字符串是str的一部分，从字符位置子字符串开始，跨越子字符串字符（或直到str结尾，如果str太短或子字符串为string：：npos）

(3) c-string

Appends a copy of the string formed by the null-terminated character sequence (C-string) pointed by s.

----追加由s指向的以空结尾的字符序列（C字符串）形成的字符串的副本

(4) buffer

Appends a copy of the first ncharacters in the array of characters pointed by s.

----追加由s指向的字符数组中前n个字符的副本

(5) fill

Appends nconsecutive copies of character c.

----追加n个字符c的连续副本。

(6) range

Appends a copy of the sequence of characters in the range [first,last), in the same order.

----以相同的顺序追加范围[first，last]中字符序列的副本。

#include#includeint main()
{
	std::string str;
	std::string str2 = "Writing ";
	std::string str3 = "print 10 and then 5 more";

	
	str.append(str2);                       // 情况1
	std::cout<< str<< '\n';

	str.append(str3, 6, 3);                   // 情况2
	std::cout<< str<< '\n';

	str.append("dots are cool", 5);          // 情况3
	std::cout<< str<< '\n';

	str.append("here: ");                   // 情况4
	std::cout<< str<< '\n';

	str.append(10u, '.');                    // 情况5
	std::cout<< str<< '\n';

	str.append(str3.begin() + 8, str3.end());  // 情况6
	std::cout<< str<< '\n';

	return 0;
}

operator+=

Append to string----附加到字符串

string& operator+= (const string& str);

string& operator+= (const char* s);

string& operator+= (char c);

#include#includeint main()
{
	std::string name("John");
	std::string family("Smith");
	name += " K. ";         // c-string
	name += family;         // string
	name += '\n';           // character

	std::cout<< name;
	return 0;
}

运行结果：John K. Smith

c_str

const char* c_str() const;

Get C string equivalent----获取等效的C字符串

Returns a pointer to an array that contains a null-terminated sequence of characters (i.e., a C-string) representing the current value of the string object.

This array includes the same sequence of characters that make up the value of the string object plus an additional terminating null-character ('\0') at the end.

----返回指向数组的指针，该数组包含表示字符串对象当前值的以空结尾的字符序列（即C字符串）。

此数组包含构成字符串对象值的相同字符序列，加上末尾的附加终止空字符（“\0”）。

#include#include#includeint main()
{
	std::string str("Please split this sentence into tokens");//str是一个类

	char * cstr = new char[str.length() + 1];
	std::strcpy(cstr, str.c_str());				//将字符串返回成char *，然后进行拷贝
												//char *strcpy(char *dest, const char *src)
												//  str现在包含str的c字符串副本

	char * p = std::strtok(cstr, " ");			//char *strtok( char *strToken, const char *strDelimit );
												//分解字符串为一组字符串

	while (p != 0)
	{
		std::cout<< p<< '\n';
		p = std::strtok(NULL, " ");
	}

	delete[] cstr;
	return 0;
}

find + npos

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;

Find content in string----在字符串中查找内容

static const size_t npos = -1;

npos：Maximum value for size_t----size_t的大值

#include  
#includeusing namespace std;

int main()
{
	string str("There are two needles in this haystack with needles.");
	string str2("needle");

	// different member versions of find in the same order as above:
	size_t found = str.find(str2);
	if (found != string::npos)
		cout<< "first 'needle' found at: "<< found<< '\n';

	found = str.find("needles are small", found + 1, 6);
	if (found != string::npos)
		cout<< "second 'needle' found at: "<< found<< '\n';

	found = str.find("haystack");
	if (found != string::npos)
		cout<< "'haystack' also found at: "<< found<< '\n';

	found = str.find('.');
	if (found != string::npos)
		cout<< "Period found at: "<< found<< '\n';

	// let's replace the first needle:
	str.replace(str.find(str2), str2.length(), "preposition");
	cout<< str<< '\n';

	return 0;
}

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;

Find last occurrence of content in string----查找字符串中内容的最后一次出现

#include#include#includeint main()
{
	std::string str("The sixth sick sheik's sixth sheep's sick.");
	std::string key("sixth");

	std::size_t found = str.rfind(key);//找到sixth第二次出现的位置

	if (found != std::string::npos)
		str.replace(found, key.length(), "seventh");//seventh替换掉二次出现的sixth

	std::cout<< str<< '\n';

	return 0;
}

输出结果：The sixth sick sheik's seventh sheep's sick.

substr

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

Returns a newly constructed string object with its value initialized to a copy of a substring of this object-----返回一个新构造的字符串对象，其值初始化为此对象的子字符串的副本。

#include#includeint main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

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

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般 情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好

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

Concatenate strings ----连接字符串

#include#includeint main()
{
	std::string firstlevel("com");
	std::string secondlevel("cplusplus");
	std::string scheme("http://");
	std::string hostname;
	std::string url;

	hostname = "www. " + secondlevel + '.' + firstlevel;
	url = scheme + hostname;

	std::cout<< url<< '\n';

	return 0;
}

运行结果：http://www. cplusplus.com

operator>>(string) 

istream& operator>>(istream& is, string& str);

Extract string from stream----从流中提取字符串

#include#includeint main()
{
	std::string name;

	std::cout<< "Please, enter your name: ";
	std::cin >>name;
	std::cout<< "Hello, "<< name<< "!\n";

	return 0;
}

operator<< (string)

ostream& operator<< (ostream& os, const string& str);

Insert string into stream----将字符串插入流 

#include#includeint main()
{
	std::string str = "Hello world!";
	std::cout<< str<< '\n';
	return 0;
}

getline (string)

istream& getline (istream& is, string& str, char delim);

istream& getline (istream& is, string& str);

Get line from stream into string----从流获取线到字符串 

#include#includeint main()
{
	std::string name;

	std::cout<< "Please, enter your full name: ";
	std::getline(std::cin, name);
	std::cout<< "Hello, "<< name<< "!\n";

	return 0;
}

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

Relational operators for string----字符串的关系运算符

#include#includeint 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;
}

我们在模拟实现string的时候，可以先看看string类的经典问题。在实现string类的构造、拷贝构造、赋值运算符重载以及析构函数时，经常会出现深浅拷贝的问题。

构造String类对象的错误：

String(const char* str = "\0") ----错误示范，"\0"是需要内存存放的

String(const char* str = nullptr) ----错误示范，String是类，地址是不会指向nullptr

Sring(const char* str = "")----正确示范

构造String类对象时，如果传递nullptr指针，可以认为程序非法。

浅拷贝的问题：

#include#include 
using namespace std;
class String
{
public:
String(const char* str = "")
{
	
	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);
}

int main()
{
	TestString();

	return 0;
}

在这段代码中，我们发现测试的时候，开始s1传入字符串是没有问题的，但是将s1的地址传入s2时，就会出现错误。因为在s2调用构造函数的时候，s2中的_str存放的地址也是s1的地址。那么在调用析构函数的时候，我们就会发现调用了两次析构函数，第一将_str清除后，s2再调用析构函数的时候，此时_str已经是随机值，再对_str进行删除的时候就会报错。

运行结果：

说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

那么什么是深拷贝？什么是浅拷贝呢？

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。

深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

#define _CRT_SECURE_NO_WARNINGS

#includeusing namespace std;
#include 

#define npos -1

namespace bit
{
	class string
	{
	public:
		typedef char* iterator;

	public:
		string(const char* str = "")//构造空的string类对象，即空字符串
		{
			// 构造String类对象时，如果传递nullptr指针，可以认为程序非法
			if (nullptr == str)
			{
				assert(false);
				return;
			}

			_str = new char[strlen(str) + 1];//扩容要加'/0'
			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;
			}
		}
		/
		// iterator--迭代器
		iterator begin()//返回到开始
		{
			return _str;
		}

		iterator end()//返回到结束
		{
			return _str + _size;
		}

		/
		// modify--修改

		void push_back(char c)//将字符附加到字符串
		{
			if (_size == _capacity)
				reserve(_capacity * 2);//2倍扩容

			_str[_size++] = c;
			_str[_size] = '\0';//++后添加上‘\0’
		}

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

		
		void append(const char* str)
		{
			size_t n = strlen(str);
			if (_size + n >_capacity )
			{
				reserve(_size + n);
			}

			strcpy(_str + _size, str);
			_size += n;

		}
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

		void clear()
		{
			_str[0] = '\0';
			_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)
		{
			return strcmp(c_str(), s.c_str())<0;//需要接受char*
		}
		bool operator<=(const string& s)
		{
			return *this< s || *this == s;
		}
		//复用前<  ==
		bool operator>(const string& s)
		{
			return !(*this<= s);
		}

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

		bool operator==(const string& s)
		{
			return strcmp(c_str(), s.c_str()) == 0;
		}

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

		// 返回c在string中第一次出现的位置

		size_t find(char c, size_t pos = 0) const
		{
			assert(pos< _size);
			while (pos< _size)
			{
				if (_str[pos] == c)
				{
					return pos;
				}
				pos++;
			}
			return npos;
		}

		// 返回子串s在string中第一次出现的位置
		//strstr:返回字符串中首次出现子串的地址
		size_t find(const char* s, size_t pos = 0) const
		{
			assert(pos< _size);
			const char* ptr = strstr(_str + pos, _str);

			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c)
		{
			assert(pos<= _size);
			if (_size == _capacity)
			{
				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newCapacity);
			}

			//end--后，当减到-1时，是size_t类型就会变成一个很大的数，故此必须写成int类型，pos也将被强转
			//int end = _size;
			//while (end >= (int)pos)
			//{
			//	_str[end + 1] = _str[end];
			//	end--;
			//}
			size_t end = _size + 1;
			while (end >pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}

			_str[pos] = c;
			++_size;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos<= _size);
			size_t len = strlen(str);
			if (_size == _capacity)
			{
				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newCapacity);
			}

			size_t end = _size + len;

			while (end >pos + len - 1)
			{
				_str[end] = _str[end - len];
				end--;
			}

			strncpy(_str + len, str, len);
			return *this;
		}

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

			if (len == npos || pos + len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}

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

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧