实数类型的封装 real template

实数类型一直我们容易误用的东西，特别是在比较大小的时候。
经验丰富的人，可能能很容易写出这样的代码:
if(lear+0.1<3.4 && lear-0.1>3.4) 来表示 lear==3.4 这样一个意思。
但每次都这样写，麻烦，也缺少全局统一。
下面这个real.h文件就是我写的一个 real模版：

#ifndef REAL_TYPE_PIBOYE_HEADER
#define REAL_TYPE_PIBOYE_HEADER

/*
 * file: real.h
 * Author:Piboye
 * Email:piboye@yahoo.com.cn
 * The Date of Created:2006.4.15
 * Vertion: 1.1 Beta
 */
 
namespace piboye
{//Personal Softe Lib Namspace

//Real Class Tempalte Define          
template<typename T =double >
class Real
{
public:
     typedef T base_type;
      //Constructor
     Real(base_type a_num,base_type a_epsilon)
       : i_num(a_num),i_epsilon((a_epsilon>0)?a_epsilon:-a_epsilon){
     };
     // convert to base_type,yet T type;
     operator base_type()const  { return i_num;}
     // fetch epsilon;
     base_type epsilon()const {return i_epsilon;}
     // get the value of based and raw data
     base_type raw()const {return i_num;}
     // set the value of based and raw data
     void raw(base_type a_1) { i_num=a_1;}
     //assignment operate
     template<typename T1>
     Real & operator =(T1 a_2) {
          i_num=a_2;
     }
    
     // algorithm operator with return new object;
#define RealOp(Op) /
template <typename T1> /
     Real operator Op (T1 a_2) const { /
          return Real(i_num Op a_2,i_epsilon); /
     }
     RealOp(+)
     RealOp(-)
     RealOp(*)
     RealOp(/)
#undef RealOp

// agorithm operator for noreturn new object;
#define RealOpS(Op) /
template <typename T1> /
     Real & operator Op (T1 a_2) { /
          i_num Op a_2; /
          return *this;/
     }
     RealOpS(+=)
     RealOpS(-=)
     RealOpS(*=)
     RealOpS(/=)
 #undef RealOpS
    
//Comparision operatorn 
     // equal to
     template<typename T1>
     bool operator==(T1 a_value) const {
          return ( (a_value<(i_num+i_epsilon)) &&
                ( (i_num-i_epsilon)<a_value) );
     }
     // littler than
     template<typename T1>
     bool operator<(T1 a_value) const {
          return (i_num+i_epsilon)<a_value;
     }
     // not equal to
     template<typename T1>
     bool operator!=(T1 a_value) const {
          return ( ( (i_num+i_epsilon)<a_value ) ||
                ( a_value<(i_num-i_epsilon)) );
     }
     // littler or equal
     template<typename T1>
     bool operator<=(T1 a_value) const {
          return a_value<(i_num+i_epsilon);
     }
     // larger or equal
     template<typename T1>
     bool operator>=(T1 a_value) const {
          return !((i_num+i_epsilon)<a_value);
     }
     //lager than
     template<typename T1>
     bool operator>(T1 a_value) const {
          return a_value<(i_num+i_epsilon);
     }
private:
     base_type i_num; // member data for raw data
     base_type const   i_epsilon; //memeber data for epsilon used in comparing
}; //Ended Real Class

// Auxiliary Class for Real

// Epsilon Class
template<typename T=double>
class Epsilon
{
public:
    typedef T base_type;
    //Constructor
    Epsilon(base_type a_epsilon): i_epsilon(a_epsilon){}
    //get epsilon
    base_type get(void)const { return i_epsilon;}
    //set epsilon
    void set(base_type a_epsilon) { i_epsilon=a_epsilon; }
    // make a real object
    template<typename T1>
    Real<base_type>make(T1 a_value) {
          return Real<base_type>(a_value,i_epsilon);
    }
private:
    base_type i_epsilon; // epsilon member data
   
}; //Ended Epsilon Class
// addtional add opertator for expression
template<typename T,typename T1> /
inline   Real<T1> operator + (T a_1,Epsilon<T1> a_2) { /
            return Real<T1>(a_1,a_2.get());
    }

}// Ended piboye namespace
#endif //REAL_TYPE_PIBOYE_HEADER