参考方法：

#include <iostream>
using namespace std;
 
float add(float num1,float num2){return num1+num2;}
float mns(float num1,float num2){return num1-num2;}
float tms(float num1,float num2){return num1*num2;}
float div(float num1,float num2){return num1/num2;}
map<char,(*float)(float,float)>fun;
int main()
{
    char op;
    float num1, num2;
    cout << "输入运算符：+、-、*、/ : ";
    cin >> op;
 
    cout << "输入两个数: ";
    cin >> num1 >> num2;
    
    try
    {
        if(fun.count(op))fun(num1,num2);
        else cout << "Error!  请输入正确运算符。";
    }
    catch(ZeroDivisionError){cout << "Error! 不能除以0。";}
 
    return 0;
}

不使用临时变量，使用异或的方法:

#include <iostream>
using namespace std;
int main()
{
    int a=9, b=4;
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;
    a = a ^ b; b = a ^ b; a = a ^ b;
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;
    return 0;
}

当用用户自定义类型变量向内置类型变量赋值时，可以使用自定义类型的隐式转换。

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

上述代码的输出将为：

5
5

注意谨慎使用隐式转换函数，因为当你在不需要使用转换函数时，这些函数缺可能会被调用运行;这些不正确的程序会做出一些意想不到的事情，而你又很难判断出原因。

递增和递减运算符重载

1、递增和递减一般是改变对象的状态，所以一般是重载为成员函数。

2、重载递增递减，一定要和指针的递增递减区分开。因为这里的重载操作的是对象，而不是指针(由于指针是内置类型，指针的递增递减是无法重载的)，所以一般情况的递增递减是操作对象内部的成员变量。

3、递增和递减分为前置和后置情况，a = ++b;(前置)， a = b++;(后置)。因为符号一样，所以给后置版本加一个int形参作为区分，这个形参是0，但是在函数体中是用不到的，只是为了区分前置后置。例如：

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;
// 例如这里的重载递增就是为了增加pos的值
class ca
{
public:    
    int pos;
    //前置递增就是增加当前对象的pos的值，并且返回当前对象
    ca operator++(){
        pos++;
        return *this;
    }
    //后置递增就是增加当前对象的pos的值，并且返回增加pos之前的该对象
    ca operator++(int){
        ca ret = *this;
        ++*this;        //这个会调用上面的函数，其实这里可以换成pos++;
        return ret;
    }
};
int main()
{
    ca a, b;
    a.pos = 1;
    b = a++;
    cout << "b1:" << b.pos << endl;   // b1:1
    
    b = ++a;
    cout << "b2:" << b.pos << endl;   // b1:3
    
    return 0;
}

输出结果:

b1:1
b2:3

习惯上人们是使用 cin>> 和 cout<< 的，得使用友元函数来重载运算符，如果使用成员函数来重载会出现 d1<<cout; 这种不自然的代码。

下面这个实例展示了如果运用成员函数来重载会出现的情况d1<<cout;

#include <iostream>
using namespace std;
 
class Distance
{
    private:
        int feet;             // 0 到无穷
        int inches;           // 0 到 12
    public:
        // 所需的构造函数
        Distance(){
            feet = 0;
            inches = 0;
        }
        Distance(int f, int i){
            feet = f;
            inches = i;
        }
        ostream& operator<<( ostream & os)
        {
        os<<"英寸："<<feet<<"\n英尺："<<inches;
        return os;
    }
};
int main ()
{
    Distance d1(20,18);
    d1<<cout;//相当于d1.operator<<(cout)
}

运行结果:

英寸：20
英尺：18