friend ostream & operator<<(ostream &os, Stonewt &st);
friend Stonewt operator+(Stonewt &st1, Stonewt &st2);
如果我依赖构造函数进行隐式转换并让编译器完成工作，如下所示（test1和test2是类对象）：
cout << "Summing both weights: " << test1 + test2;
我收到如下错误消息：
无法将'std :: basic_ostream'左值绑定到'std :: basic_ostream＆amp;＆amp;'
初始化'std :: basic_ostream＆lt; _CharT，_Traits＆gt;＆amp;的参数1 std :: operator＆lt;＆lt;（std :: basic_ostream＆lt; _CharT，_Traits＆gt;＆amp;＆amp;，const _Tp＆amp;）[with _CharT = char; _Traits = std :: char_traits; _Tp = Stonewt]'
OTOH，如果我执行以下操作，我不会收到任何错误：
Stonewt test3 = test1 + test2;
cout << "Summing both weights: " << test3;
就像编译器获得Stonewt对象一样，它可以转换为Stonewt＆amp; （这就是函数所期望的）。但如果它得到了其他的东西，它就无法到达Stonewt＆amp;。 （同样的事情发生在其他运算符重载的其他实例中，如operator *，如果我放一个double并期望编译器通过构造函数将其转换为Stonewt，然后转换为Stonewt＆amp;，它不起作用。我必须放一个Stonewt对象）。
我会把整个程序放在你需要的地方：
班级定义：
// stonewt1.h -- revised definition for the Stonewt class (for project Exercise 11.5.cbp)
#ifndef STONEWT1_H_
#define STONEWT1_H_
using std::ostream;
class Stonewt
{
public:
enum {Lbs_per_stn = 14}; // pounds per stone
enum Mode {STN, ILBS, FLBS}; // stone, integer pounds, and floating-point pounds modes
private:
int stone; // whole stones
double pds_left; // fractional pounds
double pounds; // entire weight in pounds
Mode mode; // state member
public:
Stonewt(double lbs = 0.0, Mode form = FLBS); // construct from pounds
Stonewt(int stn, double lbs, Mode form = STN); // construct from stones and pounds
~Stonewt(); // do-nothing destructor
void reset(double lbs = 0);
void reset(int stn, double lbs = 0);
void set_mode(Mode form);
Mode mode_val() const;
friend ostream & operator<<(ostream &os, Stonewt &st);
friend Stonewt operator+(Stonewt &st1, Stonewt &st2);
friend Stonewt operator-(Stonewt &st1, Stonewt &st2);
friend Stonewt operator*(Stonewt &st1, Stonewt &st2);
// conversion functions
explicit operator int() const;
explicit operator double() const;
};
#endif
方法+友元函数+转换函数实现：
// stonewt1.cpp -- Stonewt class: methods, friend functions, and conversion functions implementation (compile alongside main.cpp)
#include <iostream>
#include "stonewt1.h"
using std::cout;
// construct from pounds (both arguments defaulted, form defaulted to FLBS)
Stonewt::Stonewt(double lbs, Mode form)
{
stone = int (lbs) / Lbs_per_stn; // integer division
pds_left = int (lbs) % Lbs_per_stn + lbs - int(lbs);
pounds = lbs;
mode = form;
}
// construct from stones and pounds (form defaulted to STN)
Stonewt::Stonewt(int stn, double lbs, Mode form)
{
stone = stn;
pds_left = lbs;
pounds = stn * Lbs_per_stn + lbs;
mode = form;
}
Stonewt::~Stonewt() // do-nothing destructor
{
}
// reset object data members (don't change mode)
void Stonewt::reset(double lbs)
{
stone = int(lbs) / Lbs_per_stn;
pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
pounds = lbs;
}
void Stonewt::reset(int stn, double lbs)
{
stone = stn;
pds_left = lbs;
pounds = stn * Lbs_per_stn + lbs;
}
// change object mode
void Stonewt::set_mode(Mode form)
{
mode = form;
}
// returns mode
Stonewt::Mode Stonewt::mode_val() const
{
return mode;
}
// friend functions
ostream & operator<<(ostream &os, Stonewt &st)
{
if (st.mode == Stonewt::STN)
os << st.stone << " stones and " << int(st.pds_left + 0.5) << " pounds.\n";
else if (st.mode == Stonewt::ILBS)
os << int(st.pounds + 0.5) << " pounds.\n";
else if (st.mode == Stonewt::FLBS)
os << int(st.pounds) << " pounds.\n";
else
os << "Invalid mode.";
return os;
}
Stonewt operator+(Stonewt &st1, Stonewt &st2)
{
Stonewt result;
result.stone = int(st1.pounds + st2.pounds) / Stonewt::Lbs_per_stn;
result.pds_left = int(st1.pounds + st2.pounds) % Stonewt::Lbs_per_stn + (st1.pounds + st2.pounds) - int(st1.pounds + st2.pounds);
result.pounds = st1.pounds + st2.pounds;
return result;
}
Stonewt operator-(Stonewt &st1, Stonewt &st2)
{
Stonewt result;
result.stone = int(st1.pounds - st2.pounds) / Stonewt::Lbs_per_stn;
result.pds_left = int(st1.pounds - st2.pounds) % Stonewt::Lbs_per_stn + (st1.pounds - st2.pounds) - int(st1.pounds - st2.pounds);
result.pounds = st1.pounds - st2.pounds;
return result;
}
Stonewt operator*(Stonewt &st1, Stonewt &st2)
{
Stonewt result;
result.stone = int(st1.pounds * st2.pounds) / Stonewt::Lbs_per_stn;
result.pds_left = int(st1.pounds * st2.pounds) % Stonewt::Lbs_per_stn + (st1.pounds * st2.pounds) - int(st1.pounds * st2.pounds);
result.pounds = st1.pounds * st2.pounds;
return result;
}
// conversion functions
Stonewt::operator int() const
{
return int(pounds + 0.5);
}
Stonewt::operator double()const
{
return pounds;
}
客户（未完成）：
// main.cpp -- Exercising the revised Stonewt class: state member, operator overloadings (operator<<()
// replacing the show methods, operator+(), operator-(), operator*()) as friend functions.
#include <iostream>
#include "stonewt1.h"
#include <string>
int main()
{
using std::cout;
using std::cin;
using std::string;
cout << "***********************************************************************"
"*********";
cout << "*\n*\n*";
cout.width(35);
cout << "Menu:\n";
(cout << "*\n*").width(10);
(cout << "a. Reset").width(20);
(cout << "b. Select").width(20);
(cout << "c. Change mode").width(20);
(cout << "d. Show").width(0);
(cout << "\n*").width(10);
(cout << "e. Sum").width(20);
(cout << "f. Subtract").width(20);
(cout << "g. Multiply").width(20);
cout << "h. Menu";
cout << "\n*\n*\n";
cout << "***********************************************************************"
"*********\n\n";
Stonewt test1;
Stonewt test2;
Stonewt &sel = test1;
char ch {'z'};
cin.get(ch);
switch (ch)
{
case 'A' :
case 'a' : if (sel.mode_val() == 3 || sel.mode_val() == 2)
{
cout << "Enter the pounds: ";
double p {0.0};
cin >> p;
sel.reset(p);
}
else if (sel.mode_val() == 1)
{
cout << "Enter the stones: ";
int s {0};
cin >> s;
cout << "Enter the remaining pounds: ";
double p {0.0};
cin >> p;
sel.reset(s, p);
}
else
cout << "Wrong mode.";
break;
case 'B' :
case 'b' : {
cout << "Select object (1 for test1, 2 for test2): ";
int temp;
cin >> temp;
if (temp == 1)
sel = test1;
else
sel = test2;
break;
}
case 'C' :
case 'c' : {
cout << "Select the desired mode (STN, FLBS or ILBS): ";
string temp;
cin >> temp;
if (temp == "STN")
sel.set_mode(Stonewt::Mode::STN);
else if (temp == "ILBS")
sel.set_mode(Stonewt::Mode::ILBS);
else if (temp == "FLBS")
sel.set_mode(Stonewt::Mode::FLBS);
else
cout << "Wrong mode. " << sel.mode_val() << " retained.";
break;
}
case 'D' :
case 'd' : cout << sel;
break;
case 'E' :
case 'e' : cout << "Summing both weights: " << test1 + test2;
break;
case 'F' :
case 'f' : cout << "Subtracting the second weight from the first one: " << test1 - test2;
break;
case 'G' :
case 'g' : {
cout << "Choose a factor: ";
double temp;
cin >> temp;;;
sel = sel * temp;
break;
}
}
return 0;
}
答案 0 :(得分：7)
您不能将非const引用绑定到临时引用，因此您需要ostream运算符来获取const引用：
ostream & operator<<(ostream &os, const Stonewt &st);
为什么呢？因为当你这样做时：
cout << "Summing both weights: " << test1 + test2;
test1 + test2返回Stonewt个临时值，您的运算符会尝试通过非const引用来获取它。这是有效的，因为test3不是临时的：
Stonewt test3 = test1 + test2;
cout << "Summing both weights: " << test3;
答案 1 :(得分：2)
您的operator<<应该使用const引用：std::ostream& operator<<( std::ostream& dest, Stonewt const& object );