C++ 简单类中实现各种操作符的重载

#include <iostream>
using namespace std;
class UInt
{
    public:
        //缺省构造函数，在没有任何构造函数的时候，编译器默认生成缺省构造函数
        UInt(){}

        //这个构造函数可以把int类型隐式转换成UInt类型
        //两种函数允许编译器进行类型转换：但参数构造函数和隐式类型转换运算符
        UInt(const int& i):val(i)
        {
            cout<<"int"<<endl;
        }
        
        //拷贝构造函数 
        UInt(const UInt& i):val(i.val){
            cout<<"UInt"<<endl;
        }

        //析构函数
        ~UInt(){
            cout<<"~UInt"<<endl;
        }

        //赋值运算符
        UInt& operator=(const UInt& i)
        {
            cout<<"operator="<<endl;
            val=i.val;
            return *this; 
        }

        //其他的类型可以赋值给UInt类型，当然该报错的还是得报错(如你传入一个string类型)，总比秘密做了很多你不想要的好吧
        template<typename T>
        UInt& operator=(const T& i)
        {
            cout<<"operator = other"<<endl;
            val=i;
            return *this; 
        }

        //取址运算符
        UInt* operator&()
        {
            return this;
        }
 
        //返回类型是一个常量指针，也就是说接收这个方法返回值的变量必须为常量指针
        //这是一个常量方法，所以不能修改成员变量的值
        const UInt* operator&() const
        {
            return this;
        }

        //返回当前对象的引用，当然你就可以对他进行任何合法的操作
        //返回类型为引用类型或者指针类型就不会有临时变量的构造和析构
        UInt& operator++()
        {
            *this+=1;         //this是一个指针类型，*this为值类型，运算符左侧必须为值类型
            return *this;     //引用类型是对实际数据的引用，只能把值类型赋给引用类型，当然指针类型是不能赋给引用类型的
        }

        //返回的是一个局部变量，你对局部变量的任何操作都是没有意义的，所以返回类型为const
        //大家都知道局部变量在超出他的作用域之后会自动析构，现在却返回一个局部变量，这里其实产生了一个临时变量，用oldVal初始化临时变量,
        //若没有变量接收当前方法的返回值，方法调用完成之后，临时变量会自动析构，
        //若有变量接收当前方法的返回值，临时变量在该变量自动析构之前析构，在栈中先定义后析构，这就是传说中的先进后出！
        const UInt operator++(int)
        {
            UInt oldVal(*this);
            ++(*this);
            return oldVal;
        }

        //加法运算，产生了一个局部变量uint，在函数返回时还会产生一个临时变量，程序要负责两个UInt类型的构造和析构，所以说+=比+效率高
        const UInt operator+(const UInt i)
        {
            UInt uint(*this);
            uint.val+=i.val;
            return uint;
        }

        //UInt类型可以和char、short、int、float、double等类型进行加减乘除运算
        template<typename T>
        const UInt operator+(T t)
        {
            UInt uint(*this);
            uint.val+=t;
            return uint;
        }
     
        //返回当前对象，你可以对他进行任何合法的操作，所以他的类型为non-const
        UInt& operator+=(const UInt& i)
        {
            val+=i.val;
            return *this;
        }

        //UInt类型可以和其他基本类型（能和int类型进行+=运算的所有类型）进行+=运算
        template<typename T>
        UInt& operator+=(const T& i)
        {
            val+=i;
            return *this;
        }

        //乘法 不是指针
        const UInt operator*(const UInt& i)
        {
            cout<<"operator*"<<endl;
            UInt uint(*this);
            uint.val=uint.val*i.val;
            return uint;
        }
 
        template<typename T>
        UInt operator*(const T& i)
        {
            cout<<"operator* other"<<endl;
            UInt uint(*this);
            uint.val=uint.val*i;
            return uint;
        }

        //乘法 不是指针
        UInt& operator*=(const UInt& i)
        {
            val*=i.val; 
            return *this;
        }
 
        template<typename T>
        UInt& operator*=(const T& i)
        {
            val*=i; 
            return *this;
        }
  
        //隐式类型转换，将UInt类型转换成int类型，当出现类型不匹配的时候，编译器会寻找可能进行匹配的类型转换，有时候这个隐式的类型转换可能不是你要的
        //如UInt类型与int类型进行混合运算时，UInt类型会自动转换成int类型
        operator int() const
        {
            return val;
        }

    private :
        int val;
};