楼上代码有问题，但原理没问题。改善如下：

#include<iostream>
using namespace std;
class Int {
private:
    int n;
public:
    Int(int i) :n(i) {};
    operator int() // 这里就是隐式转换声明，应注意到它与运算符重载的不同之处
    {
        return n;
    }
};
int main()
{
    Int a(5);
    int c = a; // 隐式调用转换函数
    cout << c << endl;
    cout << a << endl; // 由于未重载Int的<<操作符，将隐式调用转换函数
    return 0;
}

在上述教程中，复合赋值运算符重载没有被提到，但这往往也是经常需要用到的，而且对于新人来讲比较容易出错，我来补充一下吧。

复合赋值操作符是指 += ， *= ， -= 这一类由基本算数运算符（ + 、 - 、 * 、 / )或位运算符(| 、 & 、~等）加 = 号构成的运算符。它们把左右操作数进行相应运算后的结果赋值给左操作符。例如：a += b； 意味着  a = a + b；    复合赋值操作符的返回值，默认是左值。比如a += b；中的a。

在进行复合赋值操作符重载定义的时候，需要注意，其返回值，应该为（ * this）<类成员>或者第一个也就是左操作数<非成员函数>。例如：（假设已经自定义算数或位操作运算符）

className & className::operator +=(className & right)
{
    return (*this) = (*this) + right;
}

className& operator +=(className& left, className& right)
{
    return left = left + right;
}

className A = a，B = b;（A，B是对象名，a，b是值）。

A += B; （此时A = a + b，整个表达式返回值是a + b）。

重写复合赋值操作符的时候，一定要记得，要把运算结果赋给左值，再返回左值。如果直接返回结果，我们将不会被调用处看到左值被运算的效果。错误代码：（假设已经自定义算数或位操作运算符）

struct Colour
{
    Colour() = default;
    Colour(const float red, const float green, const float blue) :r(red), g(green), b(blue) {}
    Colour(const Colour& right)
    {
        this->r = right.r;
        this->g = right.g;
        this->b = right.b;
    }
    bool operator ==(const Colour& right)
    {
        if (this->r - right.r <= EPSILON
            && this->g - right.g <= EPSILON
            && this->b - right.b <= EPSILON)
        {
            return true;
        }
        else {
            return false;
        }
    }
    Colour& operator =(const Colour& right)
    {
        if (this == &right)
        {
            return *this;
        }
        this->r = right.r;
        this->g = right.g;
        this->b = right.b;
        return *this;
    }

    Colour ClampColor(Colour& color)
    {
        Clamp(color.r, 0.f, 1.f);
        Clamp(color.g, 0.f, 1.f);
        Clamp(color.b, 0.f, 1.f);
        return color;
    }

    Colour operator /(const float right) {
        Colour result;
        result.r = this->r / right;
        result.g = this->g / right;
        result.b = this->b / right;
        return result;
    }

    Colour operator *(const Colour& right) const
    {
        Colour result;
        result.r = this->r * right.r;
        result.g = this->g * right.g;
        result.b = this->b * right.b;
        return result;
    }

    Colour operator *(const float& right) const
    {
        Colour result;
        result.r = this->r * right;
        result.g = this->g * right;
        result.b = this->b * right;
        return result;
    }

    Colour operator +(const Colour& right)
    {
        Colour result;
        result.r = this->r + right.r;
        result.g = this->g + right.g;
        result.b = this->b + right.b;
        return result;
    }

    Colour operator *=(const Colour& right)
    {
        return (*this) = (*this * right);
    }
    float r, g, b;
};

inline std::ostream& operator <<(std::ostream& os, const Colour& right) {
    os << "r: " << right.r << ";  g: " << right.g << ";  b: " << right.b;
    return os;
}