詳解C++ 運算符重載中返回值的坑

更新時間：2021年04月06日 09:30:17 作者：txf620

這篇文章主要介紹了C++ 運算符重載中返回值的坑，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧

相信不少朋友在學習運算符重載的時候，都會被參數與返回值應該是左值引用，還是右值引用，還是const常量所困擾。當然我無法一一枚舉，這次先講一下返回值的坑 (沒錯就是我親手寫的bug)

E0334 “Myclass” 沒有適當的復制構造函數

其實這個問題的根源是，沒有定義常量參數類型的拷貝構造函數所致
先來看看代碼

//頭文件head.h
class Myclass
{
private:
 int a;
public:
 Myclass(int b=0):a(b) {} //構造函數
 Myclass(Myclass& c);  //復制構造函數
 ~Myclass(){}   //析構函數
 Myclass operator+(Myclass& d); //重載+運算符
 friend ostream& operator<<(ostream& os ,const Myclass& d);
     //重載<<運算符
};
//以下是定義
Myclass::Myclass(Myclass& c)
{
 a = c.a;
}
Myclass Myclass::operator+(Myclass& d)
{
 return Myclass(d.a+a);  //??！此處報錯
}
ostream& operator<<(ostream& os,const Myclass& d)
{
 os << d.a << std::endl;
 return os;
}
//main.cpp
#include"head.h"
int main()
{
 Myclass a1(5);
 Myclass a2(12);
 Myclass sum = a1 + a2; //?。〈颂巿箦e
 std::cout << sum;
}

代碼在VS中，又出現了令人討厭的小紅線，沒有適當的復制構造函數，這就有疑問了，不是明明有個構造函數Myclass(int b=0):a(b) {}嗎，參數是int很合適啊？于是，我們定義一個臨時變量temp，再將它返回，此時會隱式調用拷貝構造函數而后返回一個副本后原來的temp就die了，因此返回值不可以是引用。下面是代碼

Myclass Myclass::operator+(Myclass& d)
{
 Myclass temp(d.a + a);
 return temp;
}

此時第一處報錯消失了，但是第二處報錯依然存在，而且仍為 “沒有適當的復制構造函數”，這就說明了，我的入手方向應該是拷貝構造函數

經過博主的調試，得知是因為函數的返回值是一個純右值，為了驗證這個想法，使用了右值引用，來接收這個純右值（當然，右值引用更多的是用在移動構造函數上，將將亡值“偷”出來）

#include"head.h"
int main()
{
 Myclass a1(5);
 Myclass a2(12);
 Myclass&& sum = a1 + a2;
}

果然，它不報錯了

但是考慮到實用性，總不能讓用戶今后做個加法都要用右值引用接收吧，因此，我們要從源頭解決，即重載拷貝構造函數。

值得思考的是，右值不就是被賦值的那個嗎，為什么用Myclass&& sum = a1 + a2;無法賦值呢？眾所周知，Myclass&& sum = a1 + a2;調用的是拷貝構造函數，類不同于基本數據類型，它要通過程序員來設置一系列的功能，我們沒有設置接受,Myclass類型的右值的功能，只定義了接受int類型的右值的功能，這自然是不行的了。
因此，重載拷貝構造函數

Myclass::Myclass(const Myclass& c)
{
 a = c.a;
}

此時就能運行了

E0349 沒有與這些操作數匹配的 “<<” 運算符

關于流運算符為什么要寫成$ostream& operator<<(ostream& os,const Myclass& d); 而非ostream& operator<<(ostream& os,Myclass& d);這個問題，網上絕大部分的回答都是輸出沒必要修改值。那么我們先定義后者

#head.h
#pragma once
#include<iostream>
using std::ostream;
class Myclass
{
private:
 int a;
public:
 Myclass(int b=0):a(b) {}
 Myclass(Myclass& c);
 Myclass(const Myclass& c);
 ~Myclass(){}
 Myclass operator+(Myclass& d);
 friend ostream& operator<<(ostream& os ,Myclass& d);
};
Myclass::Myclass(const Myclass& c)
{
 a = c.a;
}
Myclass::Myclass(Myclass& c)
{
 a = c.a;
}
Myclass Myclass::operator+(Myclass& d)
{
 Myclass temp(d.a + a);
 return temp;
}
ostream& operator<<(ostream& os,Myclass& d)
{
 os << d.a << std::endl;
 return os;
}
#main.cpp
#include"head.h"
int main()
{
 Myclass a1(5);
 Myclass a2(12);
 Myclass&& sum = a1 + a2; 
 std::cout << a1 + a2;  //此處有討厭小紅線
}

不難發(fā)現，討厭的小紅線又出來了。
我們可以想象一下這個過程，a1.operator+(a2)，返回了個臨時變量，暫且假設它叫newguy，那么newguy為一個右值，又調用了函數os.<<(&d)，傳參為&d=newguy,現在問題來了，左值引用怎么能夠接受一個純右值呢？而我們定義的重載的流運算符接受的參數類型為左值，我們并沒有給出從左值到右值強制類型轉換的函數，但是在上一部分，我們給出了從右值到左值的拷貝構造函數，因此，將流運算符聲明為前者更好。

C3861 “function”: 找不到標識符

這個問題應該是非常常見的，不習慣將函數（或是類）先聲明后定義而又喜歡讓函數（或是類）相互調用，但是在類模板它比以上兩種更為隱蔽。

#include<iostream>
class A
{
 friend void show();  //“聲明”函數
 friend void show1(); //“聲明”函數
}; 
void show()   //定義
{
 show1();
}
void show1(){}   //定義
int main()
{
 A a;
 show();   //調用
 show1();   //調用
}

以上流程看似聲明->定義->調用非常完美，實則還是會報錯的，不過跟以上兩種不一樣的是，它是在linking的時候出錯，這是為什么呢？

原來友元函數并不屬于這個類的一部分，在類內定義僅僅是為了告訴編譯器“這個函數是這個類的友元函數”，并沒有對這個函數本身進行聲明，因此，正確的做法應該是這樣的：

#include<iostream>
void show();
void show1();
class A
{
 friend void show();
 friend void show1();
}; 
void show()
{
 show1();
}
void show1(){}
int main()
{
 A a;
 show();
 show1();
}