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

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----查找字符串中內容的最后一次出現

#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元起，快前往官網查看詳情吧

分享文章：【c++】STL--string-創新互聯
文章轉載：http://www.yijiale78.com/article42/ddcchc.html

成都網站建設公司_創新互聯，為您提供云服務器、動態網站、網站制作、外貿建站、Google、域名注冊

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯