2. 程式人生 > >C++：類中的賦值函式

C++：類中的賦值函式

阿新 • • 發佈：2018-12-12

先來看一個例子：

複製程式碼

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 class Student{
 5 public:
 6     Student(){
 7         cout<<"呼叫預設建構函式"<<endl;
 8     };
 9     Student(string name,int age,string gender):Name(name),Age(age),Gender(gender){
10         //cout<<"呼叫建構函式1"<<endl;
11     }
12     Student(const Student& stu){//拷貝建構函式
13         Name=stu.Name;
14         Age=stu.Age;
15         Gender=stu.Gender;
16         cout<<"呼叫拷貝建構函式"<<endl; 
17     }
18     ~Student(){
19         //cout<<"呼叫解構函式"<<endl;
20     } 
21     void show(){
22         cout<<"Name:"<<Name<<endl;
23         cout<<"Age:"<<Age<<endl;
24         cout<<"Gender:"<<Gender<<endl; 
25     }
26 private:
27     string Name;
28     int Age;
29     string Gender;
30 }; 
31 
32 int main(){
33     Student stu("Tomwenxing",23,"male");
34     Student stu2("Ellen",24,"female");
35     cout<<"---------------------賦值操作之前-----------------"<<endl;
36     stu2.show();
37     cout<<"---------------------賦值操作之後-----------------"<<endl;
38     stu2=stu;
39     stu2.show();
40     return 0; 
41 }

複製程式碼

由上面的例子可以看出，C++支援自定義型別的物件之間的賦值操作，而賦值功能的實現則主要依靠自定義類中的賦值函式。每一個自定義類中都有且只有一個賦值函式，該賦值函式既可以由編譯器隱式地定義在自定義類中，也可以有使用者通過對賦值運算子=的過載顯式地定義在自定義類中：

複製程式碼

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 class Student{
 5 public:
 6     Student(){
 7         cout<<"呼叫預設建構函式"<<endl;
 8     };
 9     Student(string name,int age,string gender):Name(name),Age(age),Gender(gender){
10         //cout<<"呼叫建構函式1"<<endl;
11     }
12     Student(const Student& stu){//拷貝建構函式
13         Name=stu.Name;
14         Age=stu.Age;
15         Gender=stu.Gender;
16         cout<<"呼叫拷貝建構函式"<<endl; 
17     }
18     ~Student(){
19         //cout<<"呼叫解構函式"<<endl;
20     } 
21     Student& operator=(const Student& stu){ //賦值函式
22         cout<<"呼叫類中的賦值函式"<<endl;
23         if(this!=&stu){
24             Name=stu.Name;
25             Age=stu.Age;
26             Gender=stu.Gender;
27         }
28         return *this;
29     }

 
30     void show(){
31         cout<<"Name:"<<Name<<endl;
32         cout<<"Age:"<<Age<<endl;
33         cout<<"Gender:"<<Gender<<endl; 
34     }
35 private:
36     string Name;
37     int Age;
38     string Gender;
39 }; 
40 
41 int main(){
42     Student stu("Tomwenxing",23,"male");
43     Student stu2("Ellen",24,"female");
44     cout<<"---------------------賦值操作之前-----------------"<<endl;
45     stu2.show();
46     cout<<"---------------------賦值操作之後-----------------"<<endl;
47     stu2=stu;
48     stu2.show();
49     return 0; 
50 }

複製程式碼

特別注意：

Question 1：類中的賦值函式中的引數為什麼加const？

Answer：引數使用cosnt的原因有兩個：

• 防止類中的賦值函式對用來賦值的“原物件”進行修改

複製程式碼

 1 Student& Student::operator=(Student& stu){
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         stu.Name="none";//錯誤，對用來賦值的“原物件”進行了修改
 5         stu.Age=0;//錯誤
 6         stu.Gender="none";//錯誤
 7         Name=stu.Name;
 8         Age=stu.Age;
 9         Gender=stu.Gender;
10     }
11     return *this;
12 }

複製程式碼

•若賦值函式的形參加上const，則賦值函式接受的實參物件既可以是const物件，也可以是非const物件；否則賦值函式能夠接受的物件只能是非const物件，而不能是const物件。

複製程式碼

 1 Student& Student::operator=(Student& stu){
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8     return *this;
 9 }
10 int main(){
11     const Student stu("Tomwenxing",23,"male");
12     Student stu2("Ellen",24,"female");
13     stu2=stu; //錯誤！不能將const物件賦值給非const物件
14     return 0; 
15 }

複製程式碼

Question 2：類中的賦值函式中的引數為什麼使用引用？

Answer：避免呼叫類中的拷貝建構函式在記憶體中開闢空間來建立形參物件，而是讓形參成為實參的別名，從而節省時間和空間，提供程式設計效率

複製程式碼

 1 Student& Student::operator=(const Student &stu){ //引數中使用引用
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8     return *this;
 9 }
10 
11 int main(){
12     const Student stu("Tomwenxing",23,"male");
13     Student stu2("Ellen",24,"female");
14     stu2=stu;
15     return 0; 
16 }

複製程式碼

複製程式碼

 1 Student& Student::operator=(const Student stu){ //引數中沒有使用引用
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8     return *this;
 9 }
10 
11 int main(){
12     const Student stu("Tomwenxing",23,"male");
13     Student stu2("Ellen",24,"female");
14     stu2=stu;
15     return 0; 
16 }

複製程式碼

Question 3：類中的賦值函式的返回值型別為什麼是Student&，不可以是Student或void嗎？

Answer：在C++中，系統支援變數之間的連續賦值，如：

1 int a=10;
2 int b,c;
3 b=c=a;//變數之間的連續賦值，b、c的值均為10

其本質是先將變數a的值賦值給變數c，然後將賦值後的變數c返回到賦值運算子=的右邊，再將其賦值給變數b，即：

1 int a=10;
2 b=(c=a); //即c=a,b=c;

同理，如果類中賦值函式的返回值型別為void，即類中的賦值函式沒有返回值，此時編譯器將不支援對該類中的物件進行連續賦值

複製程式碼

 1 void Student::operator=(const Student &stu){
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8 }
 9 int main(){
10     const Student stu("Tomwenxing",23,"male");
11     Student stu2("Ellen",24,"female");
12         Student stu3;
13     stu3=stu2=stu; //錯誤！stu3=stu2=stu相當於stu3.operator=(stu2.operator=(stu)) ,由於賦值函式沒有返回值，則該語句無法執行
14     return 0; 
15 }

複製程式碼

 而賦值函式的返回值型別之所以是Student&而非Student是為了避免函式在返回物件時呼叫類中的拷貝建構函式在記憶體中建立臨時物件，從而提高程式的執行效率

複製程式碼

 1 Student& Student::operator=(const Student& stu){ //返回值型別中使用引用&
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8     return *this;
 9 }
10 
11 int main(){
12     Student stu("Tomwenxing",23,"male);
13     Student stu2;
14     stu2=stu;
15     return 0;
16 }

複製程式碼

複製程式碼

 1 Student Student::operator=(const Student& stu){ //返回值型別中沒有使用引用&
 2     cout<<"呼叫類中的賦值函式"<<endl;
 3     if(this!=&stu){
 4         Name=stu.Name;
 5         Age=stu.Age;
 6         Gender=stu.Gender;
 7     }
 8     return *this;
 9 }
10 
11 int main(){
12     Student stu("Tomwenxing",23,"male");
13     Student stu2;
14     stu2=stu;
15     return 0;
16 }

複製程式碼

Question 4：語句“if(this!=&stu)”的作用是什麼？

Answer：通過比較賦值者和被賦值者的地址是否相同來判斷兩者是否是同一個物件，從而避免自賦值（即自己給自己賦值）的情況的發生，原因如下：

• 為了提高程式的執行效率。自己給自己賦值是完全無意義的行為，只會浪費程式的時間資源。

• 當類中的資料成員中含有指標時，自賦值操作可能會帶來災難性的後果。例如假設物件a和b中都含有一個指標ptr，它們分別指向一塊通過new動態開闢的記憶體空間A和記憶體空間B，當將物件a賦值給物件b時，要求先將物件b中指標ptr指向的記憶體空間B通過delete釋放掉（否則將造成記憶體洩漏），然後在記憶體中重新開闢記憶體空間C以拷貝記憶體空間A中的內容，並讓物件b的指標ptr重新指向記憶體空間C，從而完成賦值。如果此時允許物件的自賦值，那麼物件會在自賦值前先釋放自己指標所指的記憶體空間，然後重新在記憶體中開闢空間，然而由於之前的記憶體空間已經釋放，此時新記憶體空間希望拷貝的內容將不復存在，因而造成災難性後果。

因此，對於類中的賦值函式，一定要先檢查是否是自賦值，如果是，直接return *this。

Question 5：自定義類的物件之間的賦值操作的本質是什麼？

Answer：本質是呼叫類中的成員函式（operator=()函式）。如：

複製程式碼

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 class Student{
 5 public:
 6     Student(){
 7         //cout<<"呼叫預設建構函式"<<endl;
 8     };
 9     Student(string name,int age,string gender):Name(name),Age(age),Gender(gender){
10         //cout<<"呼叫建構函式1"<<endl;
11     }
12     Student(const Student& stu){//拷貝建構函式
13         Name=stu.Name;
14         Age=stu.Age;
15         Gender=stu.Gender;
16         cout<<"呼叫拷貝建構函式"<<endl; 
17     }
18     ~Student(){
19         //cout<<"呼叫解構函式"<<endl;
20     } 
21     Student& operator=(const Student& stu){ //賦值函式
22         cout<<"呼叫類中的賦值函式"<<endl;
23         if(this!=&stu){
24             Name=stu.Name;
25             Age=stu.Age;
26             Gender=stu.Gender;
27         }
28         return *this;
29     }
30     void show(){
31         cout<<"\tName:"<<Name<<endl;
32         cout<<"\tAge:"<<Age<<endl;
33         cout<<"\tGender:"<<Gender<<endl; 
34     }
35 private:
36     string Name;
37     int Age;
38     string Gender;
39 }; 
40 
41 int main(){
42     Student stu("Tomwenxing",23,"male");
43     Student stu2,stu3;
44     stu2=stu;//對stu2進行賦值 
45     cout<<"物件stu2："<<endl; 
46     stu2.show();
47     cout<<"------------分界線-------------------"<<endl;
48     stu3.operator=(stu);//對stu3進行賦值
49     cout<<"物件stu3："<<endl;
50     stu3.show();
51     return 0; 
52 }

複製程式碼

相關推薦

C++：類中的賦值函式

先來看一個例子： 1 #include<iostream> 2 #include<string> 3 using namespace std; 4 class Student{ 5 public: 6 Student(){ 7

C++本質：類的賦值運算符=的重載，以及深拷貝和淺拷貝

fin 過程 種類 解決 對象的引用 執行 面向 鏈式 alt 關鍵詞：構造函數，淺拷貝，深拷貝，堆棧(stack)，堆heap，賦值運算符摘要: 在面向對象程序設計中，對象間的相互拷貝和賦值是經常進行的操作。 如果對象在申明的同時馬上進行的初始化操作，則

C++：類中兩個易被忽略的默認函數

ont names namespace tor img c++編譯 style div 顯式 C++的自定義類中有六個默認的函數，即如果用戶沒有顯式定義這些函數時，C++編譯器會類中生成這些函數的默認形式。除了大家所熟知的構造函數、拷貝構造函數、賦值函數和析構函數外，C++

python筆記： 類中的__str__ 函式

如果要把一個類的例項變成 str，就需要實現特殊方法__str__()： 不使用__str()__ 時 class Member: def __init__(self , name , number): self.name = name s

C：char 陣列賦值

定義一個數組char a[10]; 怎麼給這個陣列賦值呢？ 1. 定義的時候直接用字串賦值 char a[10]="hello";  正確 【注】：不能先定義再給它賦值，如char a[10]; a[10]="hello"; 這樣是錯誤的！ 2. 對陣列中字元逐個賦值 char a[1

python學習（六）：python中賦值、淺拷貝、深拷貝的區別

存在賦值、淺拷貝、深拷貝問題的資料型別是對組合物件來說，所謂的組合物件就是包含了其它物件的物件，如列表，類例項。 其他的單個物件則不存在這個問題。 可變物件： list, dict. 不可變物件有: int, string, float, tuple.  

條款5：類拷貝賦值操作符不能作用於-》常量成員變數和引用成員變數

1.知識點： 什麼時候一個空類，不再是空類了呢？當c++編譯器處理之後。 如果沒有定義，編譯器會為你產生四個函式： 1）  預設建構函式 2）  Copy建構函式 3）  賦值建構函式 4）  解構函

C結構體中賦值使用的冒號和點號

根據論壇中，別人的回答，總結試驗的成果 1、其中位域列表的形式為： 型別說明符 位域名：位域長度 struct bs { 　int a:8; 　int b:2; 　int c:6; }data; 說明data為bs變數，共佔兩個位元組。其中位域a佔8位，位域b佔2位，位域c

C++String 類中的常用函式

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

C++ | vector 類中的 push_back( ) 函式 、（新增和刪除函式）

vector是用陣列實現的，每次執行push_back操作，相當於底層的陣列實現要重新分配大小（即先free掉原來的儲存，後重新malloc） 函式名 push_back，演算法語言裡面的一個函式名，如: 　　 1) c++中的vector標頭檔案裡面就有這個push_

c++：類拷貝控制 - 拷貝建構函式 & 拷貝賦值運算子

一、拷貝控制 當定義一個類時，我們可以顯式或隱式地指定此型別的物件拷貝、移動、賦值和銷燬時做什麼。 一個類可以通過定義五種特殊的成員函式來控制這些操作，包括：++拷貝建構函式++、++拷貝賦值函式++、++移動建構函式++、++移動複製函式++和++解構函式++。我們稱這些操作為

C++類中的一些細節(過載、重寫、覆蓋、隱藏，建構函式、解構函式、拷貝建構函式、賦值函式在繼承時的一些問題)

1 函式的過載、重寫（重定義）、函式覆蓋及隱藏 其實函式過載與函式重寫、函式覆蓋和函式隱藏不是一個層面上的概念。前者是同一個類內，或者同一個函式作用域內，同名不同引數列表的函式之間的關係。而後三者是基類和派生類函式不同情況下的關係。 1.1 函式過載

C/C++面試題：編寫類String的建構函式、解構函式和賦值函式。

考點：建構函式、解構函式和賦值函式的編寫方法出現頻率：☆☆☆☆☆已知類String的原型為：        class String        {        public:                String(const char *str = NULL);

C++類使用建構函式初始化類表和建構函式函式體中賦值的區別

參考：http://www.360doc.com/content/13/0607/19/1317564_291331713.shtml C++ Primer中在講建構函式初始化列表的時候有這麼一段話：  無論是在建構函式初始化列表中初始化成員，還是在建構函式體中對它們賦

【C++筆記】編寫類string的建構函式、解構函式和賦值函式

#include<iostream> using namespace std; class String { public: String(const char *str=NULL); //普通建構函式 String(const Stri

C++給類中陣列賦值

在一個類中聲明瞭一個類，想能同時給給它賦值，直接賦值是不行的。 在建構函式中直接賦值好像也不行。 一種作法是單個單個的賦值。可是是很麻煩的。 另外一種作法是： class A{        private :                  int m_arr[10];

c++建構函式成員初始化中賦值和初始化列表兩種方式的區別

先總結下： 由於類成員初始化總在建構函式執行之前 1）從必要性：      a. 成員是類或結構，且建構函式帶引數：成員初始化時無法呼叫預設（無參）建構函式      b. 成員是常量或引用：成員無法賦值，只能被初始化 2）從效率上：     如果在類建構函式裡賦值：在成員

c++編寫類String的建構函式、解構函式和賦值函式

C++程式碼  按 Ctrl+C 複製程式碼 class String { public: String(const char *str = NULL);// 普通建構函式 String(const String &other);

C++中建構函式初始化列表為什麼會比建構函式中賦值要高效

Test { Test(test& t1) { this->t=t1; } private: test t; } 相信很多人跟我一樣，非常困惑為什麼Test構造時會先呼叫test的建構函式，再呼叫test類的賦值操作符。那是因為賦值操作符不能產生新的物件，Te

c#字典中傳入結構體和類在賦值時候的區別

//我以為這裡可以和c++中的map一樣，可以直接賦值，但是會報錯 //這裡不能這樣直接賦值 //然後我是用方法1中那種方式處理的，但我感覺這麼處理很麻煩 //然後我在csdn論壇上問了下，然後我換成方法2，這種方法可以直接賦值，不再那麼繁瑣 //可以說是各有各的好處吧