C ++模板功能专业化？

Question

I'm trying to make a very simple set of float/double comparison functions that will compare values out to a specified decimal position.

#include "stdafx.h"
#include "CppUnitTest.h"

#include <exception>

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace lqpro
{
  namespace /* anonymous */
  {
    template<typename _type>
    _type myAbs(_type left, _type right)
    {
      throw std::exception("lqpro::myAbs() called with non-float type parameter");
    }

    template<>
    double myAbs(double left, double right)
    {
      return fabs(left - right);
    }

    template<>
    float myAbs(float left, float right)
    {
      return fabsf(left - right);
    }

    template<typename _type>
    static _type quick_pow10(int n)
    {
      static _type pow10[10] = {
        1.0, 10.0, 100.0, 1000.0, 10000.0,
        100000.0, 1000000.0, 10000000.0,
        100000000.0, 1000000000.0
      };

      return pow10[n];
    }

  } // anonymous...

  template<typename _type>
  bool floatCompare(_type left, _type right, const int decimals=5)
  {
    _type _mul = quick_pow10<_type>(decimals);

    _type _left = left * _mul;
    _type _right = right * _mul;

    _type _diff = myAbs(left - right);
    if (static_cast<int>(_diff) == 0)
      return true;

    return false;
  }

  template<>
  bool floatCompare<>(float left, float right, const int decimals);

  template<>
  bool floatCompare<>(double left, double right, const int decimals);

} // lqpro...

namespace lqpro_tests
{       
    TEST_CLASS(FloatCompare_tests)
    {
  public:

        TEST_METHOD(ComparingFloatsZeroToOneReturnsFalse)
        {
      Assert::IsFalse(lqpro::floatCompare(0.0f, 1.0f, 5));
        }

    };
} // lqpro_tests...

My problem is that this won't compile for me. When trying, it get the following error...

1>FloatCompare_tests.cpp
1>   Creating library D:\proj\LottoQuestPro\LottoQuestPro_Solution\Debug\LQPro_tests.lib and object D:\proj\LottoQuestPro\LottoQuestPro_Solution\Debug\LQPro_tests.exp
1>FloatCompare_tests.obj : error LNK2019: unresolved external symbol "bool __cdecl lqpro::floatCompare<float>(float,float,int)" (??$floatCompare@M@lqpro@@YA_NMMH@Z) referenced in function "public: void __thiscall lqpro_tests::FloatCompare_tests::ComparingFloatsZeroToOneReturnsFalse(void)" (?ComparingFloatsZeroToOneReturnsFalse@FloatCompare_tests@lqpro_tests@@QAEXXZ)
1>D:\proj\LottoQuestPro\LottoQuestPro_Solution\Debug\LQPro_tests.dll : fatal error LNK1120: 1 unresolved externals
1>Done building project "LQPro_tests.vcxproj" -- FAILED.
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

I suppose that I could just write the floatCompare() function twice, once for float and once for double but I'd prefer not to duplicate the code...

What am I doing wrong?

Thanks

Answer 1

The following declares specializations (that you don't define )

template<>
bool floatCompare<>(float left, float right, const int decimals);

template<>
bool floatCompare<>(double left, double right, const int decimals);

If you want to instantiate them explicitly, it would be

template
bool floatCompare<float>(float left, float right, const int decimals);

template
bool floatCompare<double>(double left, double right, const int decimals);

but as all usage has access to definition, you can even omit completely those lines.

Answer 2

It looks like you're trying to compare numbers within some specified precision, ie compare with epsilon. This is the function I use to do it:

#include <iostream>     
#include <cmath>

template <typename T0,
          std::enable_if_t<std::is_floating_point<T0>::value>* = nullptr>
bool Equal(T0 a, T0 b, T0 epsilon)
{       
    return std::abs(a - b) <= epsilon;
}

int main()
{
    if (Equal(0.1, 0.15, 0.1))
    {
        std::cout << "They are equal to within 0.1";    
    }
    else
    {
        std::cout << "They are not equal to within 0.1";
    }
}