const struct object 访问成员函数（以及运算符重载问题）

Question

I tried to overload the << operator for my custom struct , but encountered error C2662 , code as follows:

struct HP{
    int max_hp;
    int hp;
    HP(int max_hp){
        this->max_hp=max_hp;
        this->hp=max_hp;
    }
    // this const declarative doesn't support const HP& obj argument
    const string repr(){
        stringstream hp_stats;
        hp_stats << this->hp << "/" << this->max_hp; 
        return hp_stats.str();
    }
    // This is fine with const HP& obj argument
    const string repr(){
        stringstream hp_stats;
        hp_stats << this->hp << "/" << this->max_hp; 
        return hp_stats.str();
    } 
};

// would cause error C2662
ostream& operator<<(ostream& out, const HP& obj){
    out<<obj.repr();
    return out;
}

I've found that this is because the implicitly access of this pointer, and const attempts to convert *this into const *this and thus fails. But as I changed from const string repr() to string repr() const , it magically worked and compiled successfully.

1. What's the difference between a const T func(){} and T func() const , which makes a const struct object invoking feasible?

2. I read it on cppreference.com, but still unsure why << overloading has to be declared outside a class scope.

3. Suppose I have repr() member function for struct HP , struct Shield , etc. I tried to make the << overloading a template function, but it turns that I am overloading << at global scope. Can I specify the T I am about to apply, OR apply the overloading across several classes with same member function, WITHOUT classes defined under one base class?

// complier thinks such overloading is global on <<
template <typename T>
ostream& operator<<(ostream& out, const T& obj){
    out<<obj.repr();
    return out;
}

Answer 1

1. const T func() {} means that the return type is const T and the function might mutate the object. Whereas, T func() const {} means that the return type is non-const but the object is unaltered ( const ). You can also have both or neither const .

2. It doesn't have to be declared outside the class, it can be declared inside as a friend (non-member) function. That works here as well. However, for a member function: since operator<<() 's first parameter is ostream& , you could only declare it in ostream and not HP , which won't work. Remember, member operators are like *this as the first argument of non-member operators.

3. Yes, you can do this. The easiest is to delegate to a common print function; the more elegant way is to use std::enable_if , eg:

template <typename T>
std::enable_if_v<std::is_same_v<T, HP> || std::is_same_v<t, Shield>, ostream&>
operator<<(ostream& out, const T& obj)
{
    out<<obj.repr();
    return out;
}

You can also write the conditions as a template and then re-use it:

template<typename T>
using is_printable_v = std::is_same_v<T, HP> || std::is_same_v<T, Shield>;

template <typename T>
std::enable_if_v<is_printable_v<T>>, ostream&>
operator<<(ostream& out, const T& obj) { ... }