Question

doing some exercise from a book I’ve come across a doubt. I’ve defined some operator overloadings as friend functions for a class (Stonewt). The problem comes with prototypes like these:

friend ostream & operator<<(ostream &os, Stonewt &st);
friend Stonewt operator+(Stonewt &st1, Stonewt &st2);

If I rely on the constructor to do an implicit conversion and let the compiler do the work, like in the following (test1 and test2 are class objects):

cout << "Summing both weights: " << test1 + test2;

I get error messages like these:

cannot bind ‘std::basic_ostream’ lvalue to ‘std::basic_ostream&&’

initializing argument 1 of ‘std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits; _Tp = Stonewt]’

OTOH, If I do the following, I don’t get any error:

Stonewt test3 = test1 + test2;
cout << "Summing both weights: " << test3;

It’s like if the compiler gets a Stonewt object, it can make the conversion to Stonewt& (that is what the function expects). But if it gets other thing, it can’t make the steps till reaching Stonewt&. (This same thing happens in other instances with other operator overloadings like operator*, if I put a double and expect the compiler to convert it to Stonewt through the constructor and then to Stonewt&, it doesn’t work. I have to put a Stonewt object).

Is this a correct behavior? Any help?

I’ll put the whole program just in case you need it:

Class definition:

// 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

Methods + friend functions + conversion functions implementation:

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

Client (unfinished):

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

Answer 1

You cannot bind a non-const reference to a temporary, so you need your ostream operator to take a const reference:

ostream & operator<<(ostream &os, const Stonewt &st);

Why? because when you do this:

cout << "Summing both weights: " << test1 + test2;

test1 + test2 returns a Stonewt temporary, and your operator tries to take it by non-const reference. This works because test3 is not a temporary:

Stonewt test3 = test1 + test2;
cout << "Summing both weights: " << test3;