Использование дружественных функций и конструкторов преобразования

#include <iostream>
using namespace std;
 
class fraction {
    int x, y;
public:
    fraction() { x = 0; y = 1; }
    fraction(int _x, int _y) { x = _x; y = _y; }
    fraction(int _x) { x = _x; y = 1; }
    void GetFraction(int & _x, int & _y) { _x = x; _y = y; }
    friend fraction operator+(fraction & ob1, fraction & ob2);
};
 
fraction operator+(fraction & ob1, fraction & ob2)
 {
    fraction TempOb;
    TempOb.x = ob1.x*ob2.y + ob2.x*ob1.y;
    TempOb.y = ob1.x*ob2.y;
    return TempOb;
}
 
int main() {
    int x, y;
    fraction fA(1, 2), fB(1, 5), fC;
    fC = fB + fA; // компилятор трактует как fС = operator+(fA,fB);
    fC.GetFraction(x, y);
    cout << x << "/" << y << endl;
 
    fC = fA + 3; // по идее эту строку компилятор должен трактовать как fC = operator+(fA,fraction(3));
    fC.GetFraction(x, y);
    cout << x << "/" << y << endl;
 
    getchar();
}

friend fraction operator + (const fraction & ob1, const fraction & ob2)

#include <iostream>
 
struct fraction {};
 
fraction foo() { return {}; }
 
void non_const(fraction&) {}
void yes_const(const fraction&) {}
 
int main() {
    
    // ok. const fraction& может биндить временный объект
    yes_const( foo() ); 
    
    // error: invalid initialization of non-const reference of type ‘fraction&’ 
    //        from an rvalue of type ‘fraction’
    non_const( foo() ); 
}

int calc_smth(int& a, int& b)
{
   .....
   b = calc_tt(); // побочный эффект, т.к. функция изменяет внешнюю переменную
   .....
}

std::pair<int, int> calc_smth(const int a, int b) // создаётся копия b
{
   .....
   b = calc_tt(); // нет побочного эффекта, т.к. функция изменяет локальную переменную
   .....
   return make_pair(v, b); // возвращаем значение
}