2. 程式人生 > >C++string類常用介面說明，深淺拷貝

C++string類常用介面說明，深淺拷貝

阿新 • • 發佈：2019-02-13

標準庫中的string類

  1. string是表示字串的字串類
  2. 該類的介面與常規容器的介面基本相同，再添加了一些專門用來操作string的常規操作。
  3. string在底層實際是：basic_string模板類的別名，typedef basic_string<char,char_traits,allocator>string;
  4. 不能操作多位元組或者變長字元的序列

在使用string類時，必須包含標頭檔案以及using namespace std;

string類的常用介面說明：

1.string類物件的常見構造

  • string()    構造空的string類物件，既空字串
  • string(const char* s)    用C格式字串來構造string物件
  • string(size_t n,char c)    string類物件中包含n個字元c
  • string(const string&s)    拷貝建構函式
  • string(const string&s,size_t n)    用s中前5個字元構造新的string物件
void TestString1()
{
	string s1;//構造空的string類物件s1
	string s2("hello word");//用C格式字串構造string類物件s2
	string s3(10, 'a');//用10個字元'a'構造string類物件s3
	string s4(s2);//拷貝構造s4
	string s5(s3, 8);//用s3中下標為8的字元構造string物件s5
	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;
	cout << s4 << endl;
	cout << s5 << endl;

}

 執行結果：

2.string類物件的容量操作

  • size_t size() const    返回字串有效字元長度
  • size_t length() const    返回字串有效字元長度
  • size_t capacity() const    返回空間總大小
  • bool empty() const    檢測字串釋放為空串，是返回true，否則返回false
  • void clear()    清空有效字元
  • void resize(size_t n,char c)    將有效字元的個數改成n個，多出的空間用字元c填充
  • void resize(size_t n)    將有效字元的個數改成n個，多出的空間用0填充
  • void reserve(size_t res_arg = 0)    為字串預留空間
void TestString1()
{
	//注意：string類物件支援直接用cin和cout進行輸入和輸出
	string s("hello,word!!!");
	cout << s.length() << endl;
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	//將s中的字串清空，注意清空時只是將size清0，不改變底層空間的大小
	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	//將s中有效字元個數增加到10個，多處位置用'a'進行填充
	//“aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	//將s中有效字元個數增加到15個，多出位置用預設值'\0'進行填充
	//"aaaaaaaaaa\0\0\0\0\0",此時s中有效字元個數已經增加到15個
	s.resize(15);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	//將s中有效字元個數縮小到5個
	s.resize(5);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;
}

void TestString2()
{
	string s;
	//測試reserve是否會改變string中有效元素個數
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	//測試reserve引數小於string的底層空間大小時，是否會將空間縮小
	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}

測試結果如下：

注意：

  1. size()與length()方法底層實現原理完全相同，引入size()的原因是為了與其他容器的介面保持一致，一般情況下用size().
  2. clear()只是將string中有效字元清空，不改變底層空間大小
  3. resize(size_t n)與resize(size_t n,char c)都是將字串中有效字元個數改變到n個不同的是當字元個數增多時：resize(n)用0來填充多出的元素空間，resize(size_t n,char c)用字元c來填充多出的元素空間。注意：resize在改變元素個數時，如果是將元素個數增多，可能會改變底層容量的大小，如果是將元素個數減少，底層空間總大小不變
  4. reserve(size_t res_arg = 0):為string預留空間，不改變有效元素個數，當reserve的引數小於string的底層空間總大小時，reserve不會改變容量大小。

3.string類物件的訪問操作

  • char& operator[](size_t pos)    返回pos位置的字元，const string類物件呼叫
  • const char& operator[](size_t pos)    返回pos位置的字元，非const string類物件呼叫
void TestString1()
{
	string s1("hello word");
	const string s2("Hello word");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;

	for (size_t i = 0; i < s1.size(); ++i)
	{
		cout << s1[i] << endl;
	}

	//s2[0] = 'h';  編譯失敗，因為const型別物件不能修改
}

執行結果如下：

4.string類物件的修改操作

  • void push_back(char c)    在字串後尾插字元c
  • string& append(const char* s)    在字串後追加一個字串
  • string& operator+=(const string& str)    在字串後追加字串str
  • string& operator+=(const char*s)    在字串後追加C格式字串
  • string& operator+=(char c)    在字串後追加字元c
  • const char* c_str() const    返回C格式字串
  • size_t find(char c,size_t pos=0) const    從字串pos位置開始往後找字元c，返回該字元在字串中的位置
  • size_t rfind(char c,size_t pos = npos)    從字串pos位置開始往前找字元c，返回該字元在字串中的位置
  • string substr(size_t pos=0,size_t n=npos) const    在str中從pos位置開始，擷取n個字元，然後將其返回
void TestString1()
{
	string str;
	str.push_back(' ');//在str後插入空格
	str.append("hello");//在str後追加一個字串
	str += 'w';//在str後追加一個字元
	str += "ord";//在str後面追加一個字串
	cout << str << endl;
	cout << str.c_str() << endl;//以C語言的格式列印字串

	//獲取檔案的字尾
	string file1("string.cpp");
	size_t pos = file1.rfind('.');
	string file2(file1.substr(pos, file1.size() - pos));
	cout << file2 << endl;

	//npos是string裡面的一個靜態成員變數
	//static const size_t npos = -1;
	//取出url的域名
	string url("https://blog.csdn.net/Damn_Yang");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos)
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;

	//刪除url的協議字首
	pos = url.find("://");
	url.erase(0, pos + 3);
	cout << url << endl;
}

//利用reserve提高插入資料的效率，避免增容帶來的開銷
void TestPushBack()
{
	string s;
	size_t sz = s.capacity();
	cout << "making s grow : \n";
	for (int i = 0; i < 100; ++i)
	{
		s += 'c';
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

void TestPushBack_P()
{
	string s;
	s.reserve(50);
	size_t sz = s.capacity();
	cout << "making s grow: \n";
	for (int i = 0; i < 100; i++)
	{
		s += 'c';
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

執行結果如下：

注意：

  1. 在string尾部追加字元時，s.push_back/s.append(1,c)/s += 'c'三種實現方式差不多，一般情況下string類的+=操作用的比較懂，+=操作不僅可以連結單個字元，還可以連線字串。
  2. 對string操作時，如果能夠大概預估到放多少字元，可以先通過reserve把空間預留好。

5.string類非成員函式

  • operator+    連線字串  儘量少用，因為效率低
  • operator>>    輸入運算子過載
  • operator<<    輸出運算子過載
  • getline            獲取一行字串
  • relational operators        大小比較

string的訪問方式：

1.迭代器--不常用，跟其他容器保持統一的訪問方式

void TestString2()
{
	string num("1234");
	//迭代器給出統一的方式訪問容器,遮蔽掉底層複雜的結構細節
	string::iterator it = num.begin();//指向第一個位置迭代器
	int value = 0;
	while (it != num.end())//指向最後一個數據的迭代器
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	
}

void TestString3()
{
	string num("1234");
	//反向迭代器
	string::reverse_iterator rit = num.rbegin();
	while (rit != num.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}

2.for+下標--更常用

void TestString4()
{
	string num("1234");
	for (size_t i = 0; i < num.size(); ++i)
	{
		cout << num[i] << " ";
	}
	cout << endl;
}

3.C++11 語法糖

void TestString5()
{
	string num("1234");
	for (auto& e : num)
	{
		cout << e << " ";
	}
	cout << endl;
}

淺拷貝

淺拷貝：也成為拷貝，編譯器只是將物件中的值拷貝過來。如果物件中管理資源，最後就會導致多個物件共享同一份資源，當一個物件銷燬時就會將該資源釋放掉，而此時另一些物件不知道該資源已經釋放，以為還有效，所以當繼續對資源進行操作時，就會發生訪問違規。

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

說明：上述String類沒有顯示定義其拷貝建構函式和運算子過載，此時編譯器會生成預設的，當用s1構造s2時，編譯器會呼叫預設的拷貝構造，最終導致的問題是:s1和s2共用同一塊記憶體空間，在釋放時同一塊空間被釋放多次而引起程式崩潰，這種拷貝方式，稱為淺拷貝

深拷貝

如果一個類中涉及到資源的管理，其拷貝建構函式、賦值運算子過載以及解構函式必須要顯式給出。一般情況都是按照深拷貝方式提供。

深拷貝：給每個物件獨立分配資源，保證多個物件之間不會因共享資源而造成多次釋放造成程式崩潰的問題
傳統寫法：

class String
{
	
public:
	String(const char* str = "")
	{
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];
		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;
		}
	}
private:
	char* _str;
};

現代寫法：

class String
{
public:
	String(const char* str = "")
	{
		if (nullptr == str)
		{
			str = "";
		}
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
	String(String& s)
		: _str(nullptr)
	{
		String strTmp(s._str);
		swap(_str, strTmp._str);
	}

	String& operator=(String s)
	{
		swap(_str, s._str);
		return *this;
	}
	/*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;
		}
	}
private:
	char* _str;
};

3.寫時拷貝

寫時拷貝就是一種拖延症，是在淺拷貝的基礎之上增加了引用技術的方式來實現的。

引用計數：用來記錄資源使用者的個數。在構造時，將資源的計數給成1，每增加一個物件使用該資源，就給計數增加1，當某個物件被銷燬時，先給該計數減1，然後再檢查是否需要釋放資源，如果計數為1，說明該物件時資源的最後一個使用者，將該資源釋放；否則就不能釋放，因為還有其他物件在使用該資源。

相關推薦

C++string類常用介面說明，深淺拷貝

標準庫中的string類 string是表示字串的字串類 該類的介面與常規容器的介面基本相同，再添加了一些專門用來操作string的常規操作。 string在底層實際是：basic_string模板類的別名，typedef basic_string<char,ch

C++ string類常用的函式

 字串是一種線性表，有著廣泛的應用，比如：文字編輯 、 情報檢索 、 拼寫檢查 、 網際網路搜尋引擎和自然語言翻譯等。 string append(const char *s);              &n

C++string類常用函式

string類的建構函式：string(const char *s);    //用c字串s初始化string(int n,char c);     //用n個字元c初始化此外，string類還支援預設建構函式和複製建構函式，如string s1；string s2="hel

C++string類常用的操作函式

#include <iostream> #include <string>//必須包含該C++標頭檔案 using namespace std; int main() { //string物件的初始化，也就是建構函式與解構函式

c++ String 類之深淺拷貝

一、string類的實現：存放字串的指標、建構函式、拷貝建構函式、解構函式、賦值運算子過載 1、無引數的建構函式  給陣列初始化成，分配一個char空間存放‘\0’ 2、帶引數的建構函式 分配一個和傳進來的引數多一的空間用來存放‘\0’,然後初始化時進行復制。 3

c++ string類 及其常用方法

包結構：#include<string>//c++標頭檔案     注意：在c中的標頭檔案為#include<string.h>名稱空間using namespace std;string類中的方法（加粗字型為常用方法）：字串構造方法（初始化）：str

c++實現String類（建構函式，解構函式，複製建構函式，各類運算子過載函式的編寫）

編寫類 String 的建構函式，解構函式，複製建構函式  需要過載下面的運算子： 1、<、>、==和！=比較運算子 2、+=連線運算子和賦值運算子 3、<<輸出運算子和>>輸入運算子 String.h #ifndef _STRING

java中String類常用方法I（判斷 Java 檔名是否正確，判斷郵箱格式是否正確）

內容摘自慕課網 具體程式碼： public class HelloWorld { public static void main(String[] args) { // Java檔名 String fileName

C++string類的常用方法

在使用string類時，需要包含標頭檔案 #include<string>,並且引入using std::string; using std::wstring; 或 using namespace std; 下面你就可以使用string/w

C++String 類中的常用函式

下面推薦一些字串的題目 hdoj 2017 字串中統計數字，直接呼叫上面s.digit()函式 hdoj 1020  判斷輸出重複、水題、 hdoj 1062 逆轉字串 注意1：getchar()吸收3後'\n',2:空格不止有一個 hdoj 1039，字串處理，清晰思路，可以寫三個判斷條件的3個函式，呼叫函

C++string類的常用函式

1、string 類的物件可以直接賦值   string &operator=(const string &s); 2、string &operator+=(const string &s); 3、還可以直接用運算子“>”，“<”

c++string類的常用方法詳解

     大部分程式都要頻繁地對字串進行操作，而c++的string類對字串進行了很強大的封裝，方便我們使用，但我常常忘了一些函式的用法，故查詢文章，轉載過來，供查詢用。 要想使用標準C++中string類，必須要包含#include <string>// 注意

c++ string類的完整實現！！！

class sun double ref basic 更新 方便 iterator locate 本文實現了c++ STL中的basic_string模板類，當然。通過typedef也就實現了string類和wstring類。限於篇幅，實現代碼中用到了標準庫的char_

C++string類用法

last emp 進行 iii str2 line rep har ddd 1.string類的輸入操作（string類重載運算符operator>>用於輸入，同樣重載運算符operator<<用於輸出操作）operator是C++的關鍵字，它和運算

java中String類常用方法、屬性等

col clas equal ack length ++ ava eal rgs package Head18; public class java09 { public static void main(String[] args) { St

c++String類

... getchar() 子串 ins ted 類型 num ron .com C++ 標準庫提供了 string 類類型，支持上述所有的操作，另外還增加了其他更多的功能。我們將學習 C++ 標準庫中的這個類，現在讓我們先來看看下面這個實例： 現在您可能還無法透徹地理解這

C++string類總結

signed align 初學 獲取 amp hello tail 即將 -h 一、string的初始化 首先，為了在程序中使用string類型，必須包含頭文件 <string>。如下： #include <string> 註意這裏不是st

【C++】C++string類總結

ont cst number 開始 RoCE 模板 tro sig def 首先，為了在程序中使用string類型，必須包含頭文件 <string>。如下： #include <string> 註意這裏不是string.h，stri

Java面向對象-- String 類 常用方法及基本使用

for str news http clas substr 實例 div print 首先來學習基本使用Jdk api chm文檔： 點擊 左上角-顯示： 1, char chartAt(int index) 返回指定索引處的char值 這裏的index 是從0

Java面向物件-- String 類 常用方法及基本使用

首先來學習基本使用Jdk api chm文件： 點選 左上角-顯示：     1, char chartAt(int index) 返回指定索引處的char值 這裡的index 是從0開始的； package com.xuyigang1234.chp02.strin