在generic programming中，我们往往希望自己定义的type在行为上和C++内置的类型尽可能的相似，也就是说，可以参与各种各样的表达式运算而不会有阻碍。C++为我们提供强大的运算符重载机制也就是为了这个目的。不幸的是，重载运算符往往是一件枯燥无聊的事情，我们可以大致统计一下，要完全定一个type，我们需要重载的运算符：
算术运算：+, -, *, /, %, +=, -=, *=, /=, /, %=
比较运算：>, <, ==, !=, >=, <=
位运算：|, &, ^, |=, &=, ^=
自增自减：++, -- 它们放在变量前面和后面是不同的，这就是4个
……
这只是对于该type本身，如果你希望定义这个type和另外一个type的混合运算——例如你定义了一个复数，自然要定义它和int, double, float...之间的运算——那么你就要把上面的运算符再来上那么几次，注意，如果要实现可交换的运算（例如加法，乘法），重载数量还要乘以2……
实际上，我们可以发现，在通常情况下这些运算中的很多都是可以用其他的运算来达到的，例如
>= 可以是 >||=，当然也可以是 !< 等等。
除非你的type的表现比较奇怪（例如matrix的乘法不对称），否则只要实现了一些基本的运算符，其余的就可以用某种机制来自动实现了。boost在operator.hpp中提供了这种机制，它利用了C++强大的继承、模版和宏。
在下面的代码中，尽管没有直接定义MyInt的+和*操作，但是由于从additive和multiplicative派生，所以这些操作都被自动定义了，我们只需要定义+=和*=即可。
#include <boost/operators.hpp>
using namespace boost;
class MyInt
: additive<MyInt, int
, multiplicative<MyInt, int> >
{
public:
int i;
typedef MyInt self;
MyInt(){};
MyInt(const MyInt& mi)
{
i = mi.i;
}
self& operator+=(const int ii)
{
i += ii;
return *this;
}
self& operator*=(const int ii)
{
i *= ii;
return *this;
}
};
#include <iostream>
using namespace std;
void main()
{
MyInt i;
i.i = 10;
int j = 5;
MyInt k = i + j;
MyInt l = j + i;
MyInt m = i * j;
MyInt n = j * i;
}
对于比较和逻辑运算，也有相应的operator基类模版可以继承。值得注意的是继承它们的方法：
class MyInt
: additive<MyInt, int
, multiplicative<MyInt, int> >
这里不是直接的多继承，而是把multiplicative作为additive的第3个模版参数，而additive的实现中，是从第3个模版参数派生的（由于additive是通过macro来定义的，所以这里选了另一个相似的东西less_than_comparable2来作参照）：
template <class T, class U, class B = ::boost::detail::empty_base>
struct less_than_comparable2 : B
换句话说，继承关系可以看成是这样的（实际上还有很多中间层次，这里省略）：
::boost::detail::empty_base
^
mutiplicative
^
additive
^
MyInt
如果采用直接的多继承，也就是如果这样写，
class MyInt
: additive<MyInt, int>
, multiplicative<MyInt, int>
那么继承关系可能是这样的：
::boost::detail::empty_base ::boost::detail::empty_base
^ ^
mutiplicative additive
^ ^
MyInt
多出了一个empty_base，虽说empty_base是空的，这样做可能没有多大的消耗，但是在类层次复杂的时候，也许就会有比较大的浪费了。