push_back

void push_back (char c);

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

----將字符c追加到字符串的末尾，將其長(zhǎng)度增加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的一部分，從字符位置子字符串開(kāi)始，跨越子字符串字符（或直到str結(jié)尾，如果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指向的以空結(jié)尾的字符序列（C字符串）形成的字符串的副本

(4) buffer

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

----追加由s指向的字符數(shù)組中前n個(gè)字符的副本

(5) fill

Appends?nconsecutive copies of character?c.

----追加n個(gè)字符c的連續(xù)副本。

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

運(yùn)行結(jié)果：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.

----返回指向數(shù)組的指針，該數(shù)組包含表示字符串對(duì)象當(dāng)前值的以空結(jié)尾的字符序列（即C字符串）。

此數(shù)組包含構(gòu)成字符串對(duì)象值的相同字符序列，加上末尾的附加終止空字符（“\0”）。

#include#include#includeint main()
{
	std::string str("Please split this sentence into tokens");//str是一個(gè)類

	char * cstr = new char[str.length() + 1];
	std::strcpy(cstr, str.c_str());				//將字符串返回成char *，然后進(jìn)行拷貝
												//char *strcpy(char *dest, const char *src)
												//  str現(xiàn)在包含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----在字符串中查找內(nèi)容

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

r?nd ?

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----查找字符串中內(nèi)容的最后一次出現(xiàn)

#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第二次出現(xiàn)的位置

	if (found != std::string::npos)
		str.replace(found, key.length(), "seventh");//seventh替換掉二次出現(xiàn)的sixth

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

	return 0;
}

輸出結(jié)果：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-----返回一個(gè)新構(gòu)造的字符串對(duì)象，其值初始化為此對(duì)象的子字符串的副本。

#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尾部追加字符時(shí)，s.push_back(c) / s.append(1, c) / s += 'c'三種的實(shí)現(xiàn)方式差不多，一般 情況下string類的+=操作用的比較多，+=操作不僅可以連接單個(gè)字符，還可以連接字符串。

2. 對(duì)string操作時(shí)，如果能夠大概預(yù)估到放多少字符，可以先通過(guò)reserve把空間預(yù)留好

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

運(yùn)行結(jié)果：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----字符串的關(guān)系運(yùn)算符

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

我們?cè)谀M實(shí)現(xiàn)string的時(shí)候，可以先看看string類的經(jīng)典問(wèn)題。在實(shí)現(xiàn)string類的構(gòu)造、拷貝構(gòu)造、賦值運(yùn)算符重載以及析構(gòu)函數(shù)時(shí)，經(jīng)常會(huì)出現(xiàn)深淺拷貝的問(wèn)題。

構(gòu)造String類對(duì)象的錯(cuò)誤：

String(const char* str = "\0") ----錯(cuò)誤示范，"\0"是需要內(nèi)存存放的

String(const char* str = nullptr) ----錯(cuò)誤示范，String是類，地址是不會(huì)指向nullptr

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

構(gòu)造String類對(duì)象時(shí)，如果傳遞nullptr指針，可以認(rèn)為程序非法。

淺拷貝的問(wèn)題：

#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;
};
// 測(cè)試
void TestString()
{
	String s1("hello bit!!!");
	String s2(s1);
}

int main()
{
	TestString();

	return 0;
}

在這段代碼中，我們發(fā)現(xiàn)測(cè)試的時(shí)候，開(kāi)始s1傳入字符串是沒(méi)有問(wèn)題的，但是將s1的地址傳入s2時(shí)，就會(huì)出現(xiàn)錯(cuò)誤。因?yàn)樵趕2調(diào)用構(gòu)造函數(shù)的時(shí)候，s2中的_str存放的地址也是s1的地址。那么在調(diào)用析構(gòu)函數(shù)的時(shí)候，我們就會(huì)發(fā)現(xiàn)調(diào)用了兩次析構(gòu)函數(shù)，第一將_str清除后，s2再調(diào)用析構(gòu)函數(shù)的時(shí)候，此時(shí)_str已經(jīng)是隨機(jī)值，再對(duì)_str進(jìn)行刪除的時(shí)候就會(huì)報(bào)錯(cuò)。

運(yùn)行結(jié)果：

說(shuō)明：上述String類沒(méi)有顯式定義其拷貝構(gòu)造函數(shù)與賦值運(yùn)算符重載，此時(shí)編譯器會(huì)合成默認(rèn)的，當(dāng)用s1構(gòu)造s2時(shí)，編譯器會(huì)調(diào)用默認(rèn)的拷貝構(gòu)造。最終導(dǎo)致的問(wèn)題是，s1、s2共用同一塊內(nèi)存空間，在釋放時(shí)同一塊 空間被釋放多次而引起程序崩潰，這種拷貝方式，稱為淺拷貝。

那么什么是深拷貝？什么是淺拷貝呢？

淺拷貝：也稱位拷貝，編譯器只是將對(duì)象中的值拷貝過(guò)來(lái)。如果對(duì)象中管理資源，最后就會(huì)導(dǎo)致多個(gè)對(duì)象共享同一份資源，當(dāng)一個(gè)對(duì)象銷(xiāo)毀時(shí)就會(huì)將該資源釋放掉，而此時(shí)另一些對(duì)象不知道該資源已經(jīng)被釋放，以為還有效，所以當(dāng)繼續(xù)對(duì)資源進(jìn)項(xiàng)操作時(shí)，就會(huì)發(fā)生發(fā)生了訪問(wèn)違規(guī)。

可以采用深拷貝解決淺拷貝問(wèn)題，即：每個(gè)對(duì)象都有一份獨(dú)立的資源，不要和其他對(duì)象共享。

深拷貝：如果一個(gè)類中涉及到資源的管理，其拷貝構(gòu)造函數(shù)、賦值運(yùn)算符重載以及析構(gòu)函數(shù)必須要顯式給出。一般情況都是按照深拷貝方式提供。

#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 = "")//構(gòu)造空的string類對(duì)象，即空字符串
		{
			// 構(gòu)造String類對(duì)象時(shí)，如果傳遞nullptr指針，可以認(rèn)為程序非法
			if (nullptr == str)
			{
				assert(false);
				return;
			}

			_str = new char[strlen(str) + 1];//擴(kuò)容要加'/0'
			strcpy(_str, str);
		}

		string(const string& s) //拷貝構(gòu)造函數(shù)
			: _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()//析構(gòu)函數(shù)
		{
			if (_str)
			{
				delete[] _str;
				_str=nullptr;
			}
		}
		/
		// iterator--迭代器
		iterator begin()//返回到開(kāi)始
		{
			return _str;
		}

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

		/
		// modify--修改

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

			_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大于底層空間大小，則需要重新開(kāi)辟空間
				if (newSize >_capacity)
				{
					reserve(newSize);
				}

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

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

		void reserve(size_t newCapacity)
		{
			// 如果新容量大于舊容量，則開(kāi)辟空間
			if (newCapacity >_capacity)
			{
				char* str = new char[newCapacity + 1];
				strcpy(str, _str);

				// 釋放原來(lái)舊空間,然后使用新空間
				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];
		}

		
		// 作業(yè)
		bool operator<(const string& s)
		{
			return strcmp(c_str(), s.c_str())<0;//需要接受char*
		}
		bool operator<=(const string& s)
		{
			return *this< s || *this == s;
		}
		//復(fù)用前<  ==
		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中第一次出現(xiàn)的位置

		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中第一次出現(xiàn)的位置
		//strstr:返回字符串中首次出現(xiàn)子串的地址
		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--后，當(dāng)減到-1時(shí)，是size_t類型就會(huì)變成一個(gè)很大的數(shù)，故此必須寫(xiě)成int類型，pos也將被強(qiáng)轉(zhuǎn)
			//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位置上的元素，并返回該元素的下一個(gè)位置
		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)
	{
		// 不能使用這個(gè), 因?yàn)閟tring的字符串內(nèi)部可能會(huì)包含\0
		// 直接cout時(shí), 是將_str當(dāng)成char*打印的，遇到內(nèi)部的\0時(shí)后序內(nèi)容就不打印了
		//cout<< s._str;
		for (size_t i = 0; i< s.size(); ++i)
		{
			_cout<< s[i];
		}
		return _cout;
	}
}

你是否還在尋找穩(wěn)定的海外服務(wù)器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機(jī)房具備T級(jí)流量清洗系統(tǒng)配攻擊溯源，準(zhǔn)確流量調(diào)度確保服務(wù)器高可用性，企業(yè)級(jí)服務(wù)器適合批量采購(gòu)，新人活動(dòng)首月15元起，快前往官網(wǎng)查看詳情吧

分享文章：【c++】STL--string-創(chuàng)新互聯(lián)
文章轉(zhuǎn)載：http://www.rwnh.cn/article42/ddcchc.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供云服務(wù)器、動(dòng)態(tài)網(wǎng)站、網(wǎng)站制作、外貿(mào)建站、Google、域名注冊(cè)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源： 創(chuàng)新互聯(lián)