有两种方法：（1）采用重载双目运算符方式
          （2）1.类型转换函数（将类的对象转换为其他数据类型）
2.转换构造函数（将其他类型转换为类的对象）（仍然要配合重载双目运算符的方式，因为最终实现的是类的两个对象相加）

              (注意:类型转换函数和转换构造函数不可同时使用，会出现二义性！)

/*以下程序均以‘+’为例！*/
一：采用重载运算符方式（需要考虑重载符号的左右值顺序，左值为本类对象，则重载函数不需要两个参数；若左值为其他类型，则需要声明为友元函数，
                    同时函数参数个数需要2个，并在类外定义普通的函数。详细如下程序。）
（1）对象+数据 （采用重载运算符方式）
#include <iostream>
using namespace std;
//依据对象数据类型
//假设对象数据是整型，则传进来的double型与对象的数据相加再转为整型
class test
{
public:
    test() {}
    test(int a1) :a(a1) {}
    test operator +(double r)              //当主函数‘+’的左边是对象时，只写一个传进来的参数
    {
        a = a + r;
        return test(a);
    }
    void show()
    {
        cout << a << endl;
    }
private:
    int a;
};
int main()
{
    test t1(1);
    test t2;
    t2 = t1 + 2.3;
    t2.show();
    system("pause");
    return 0;
}

（2）数据+对象 （采用重载运算符方式）
#include <iostream>
using namespace std;
//依据对象数据类型
//假设对象数据是整型，则传进来的double型与对象的数据相加再转为整型
class test
{
public:
    test() {}
    test(int a1) :a(a1) {}
    friend test operator +(double r, test&t);              //当主函数‘+’的左边不是对象而是数据时，需定义友元函数，并且参数个数一定要有2个

    void show()
    {
        cout << a << endl;
    }
private:
    int a;
};
test operator+( double r,test&t)                         //注意普通函数的写法
{
    return (t.a + r);
}
int main()
{
    test t1(1);
    test t2;
    t2 = 2.3 + t1;
    t2.show();
    system("pause");
    return 0;
}

二：采用类型转换函数（符号左右值不需要考虑顺序）
（数据+对象||对象+数据）

#include <iostream>
using namespace std;

class test
{
public:
    test(){}
    test(int a1):a(a1){}
    operator double()               //类型转换函数，将一个类的对象转换成其他数据类型如：类test t->double;
    {
        return a;
    }
    void show()
    {
        cout<<a<<endl;
    }
private:
    int a;
};
int main()
{
    test t1(1);
    test t;
    t=1.2 + t1;            //如无其他转换构造函数，则调用类型转换函数，将t1转换为double类型，t最终也会转换为double类型
    t.show();
    system("pause");
    return 0;
}

三：采用转换构造函数（配合重载双目运算符函数）
#include <iostream>
using namespace std;

class test
{
public:
    test(){}
    test(double r):a(r){}          //定义转换构造函数
    test operator +(test &t)
    {
        a=a+t.a;
        return test(a);
    }
    void show()
    {
        cout<<a<<endl;
    }
private:
    double a;
};
int main()
{  
    test t1(1);
    test t=1.2;                   //调用转换构造函数，将1.2转换为一个类的对象
    test t3=t1 + t;            
    t3.show();
    system("pause");
    return 0;
}