面向对象 之 封装带来的好处

DataObj支持int float double三种类型，现在要设计一个less than函数，比较两个DataObj，并将结果存入到result中。一种实现：

        inline void lt_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          (this->*lt_call_table[index])(obj1, obj2, result);
        }

        inline int lt_int_int_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          int64_t int1,int2;
          obj1.get_int(int1);
          obj2.get_int(int2);
          return result.set_int(int1 < int2);
        }
 
        inline int lt_int_float_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          int64_t int1;
          float float2;
          obj1.get_int(int1);
          obj2.get_float(float2);
          return result.set_int(int1 < float2);
        }


        inline int lt_int_double_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          int64_t int1;
          double double2;
          obj1.get_int(int1);
          obj2.get_double(double2);
          return result.set_int(int1 < double2);
        }

        inline int lt_float_int_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          float float1;
          int64_t int2;
          obj2.get_float(float1);
          obj1.get_int(int2);
          return result.set_int(float1 < int2);
        }


        inline int lt_float_float_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          float float1;
          float float2;
          obj2.get_float(float1);
          obj1.get_float(float2);
          return result.set_int(float1 < int2);
        }


        inline int lt_float_double_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          float float1;
          double double2;
          obj2.get_float(float1);
          obj1.get_double(double2);
          return result.set_int(float1 < double2);
        }

 
        inline int lt_double_int_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          double double1;
          int64_t int2;
          obj1.get_double(double1);
          obj2.get_int(int2);
          return result.set_int(double1 < int2);
        }


        inline int lt_double_float_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          double double1;
          float float2;
          obj1.get_double(double1);
          obj2.get_float(float2);
          return result.set_int(double1 < float2);
        }


        inline int lt_double_double_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          double double1;
          double double2;
          obj1.get_double(double1);
          obj2.get_double(double2);
          return result.set_int(double1 < double2);
        }

还好只有三种类型，只写了3*3中组合，如果还有更多类型，那就累死了！如何改进这个过程？封装。

        inline int lt_(const DataObj &obj1, const DataObj &obj2, DataObj &result)
        {
          int err = ERR_SUCCESS;
          bool val;
          if (obj1.can_compare(obj2))
          {
            val = (obj1 < obj2);
            result.set_int((int64_t)val);
          }
          else
          {
            err = ERR_INVALID_ARGUMENT;
          }
          return err;
        }

只要DataObj内部实现比较函数即可。

    bool DataDataj::operator < (const DataDataj &that_obj) const
    {
      bool result = false;
      int err = DATA_SUCCESS;
         _DatajValue this_value;
        _DatajValue that_value;
        DataDatajType type = get_type();
        switch (type)
        {
        case DataIntType:
          err = get_int(this_value.int_val);
          if (DATA_SUCCESS == err)
          {
            err = that_obj.get_int(that_value.int_val);
            if (DATA_SUCCESS == err)
            {
              result = this_value.int_val < that_value.int_val;
            } 
          } 
          break;
        case DataVarcharType:
          err = get_varchar(this_value.varchar_val);
          if (DATA_SUCCESS == err)
          {
            err = that_obj.get_varchar(that_value.varchar_val);
            if (DATA_SUCCESS == err)
            {
              result = this_value.varchar_val < that_value.varchar_val;
            } 
          } 
          break;
        case DataFloatType:
          err = get_float(this_value.float_val);
          if (DATA_SUCCESS == err)
          {
            err = that_obj.get_float(that_value.float_val);
            if (DATA_SUCCESS == err)
            {
              result = this_value.float_val < that_value.float_val;
            }
          }
          break;
        case DataDoubleType:
          err = get_double(this_value.double_val);
          if (DATA_SUCCESS == err)
          {
            err = that_obj.get_double(that_value.double_val);
            if (DATA_SUCCESS == err)
            {
              result = this_value.double_val < that_value.double_val;
            }
          }
          break;
       }
       return result;
    }