c++ - 在 C++ 中实现相关类型之间自动类型转换的最佳方法是什么？

Question

我正在实现 5 个坐标系(我们称它们为 A、B、C、D、E)，每个坐标系都有自己独特的类型 Coordinates<System>拿着坐标。我希望 C++ 编译器能够在不同系统的坐标之间自动正确转换。坐标变换形成一个图:A-B-C-D 和 C-E。因此，我们只需指定 8 个基本转换，编译器将生成其余的:

enum CoordSys { A,B,C,D,E };
template<CoordSys System> struct Coordinates;
template<> struct Coordinates<A> {  // specialisation for system A
   // ...
   operator Coordinates<B>() const; // implements transformation A -> B
};
template<> struct Coordinates<B> {  // specialisation for system B
   // ...
   operator Coordinates<A>() const; // implements transformation B -> A
   operator Coordinates<C>() const; // implements transformation B -> C
};
template<> struct Coordinates<C> {  // specialisation for system C
   // ...
   operator Coordinates<B>() const; // implements transformation C -> B
   operator Coordinates<D>() const; // implements transformation C -> D
   operator Coordinates<E>() const; // implements transformation C -> E
};
template<> struct Coordinates<D> {  // specialisation for system D
   // ...
   operator Coordinates<C>() const; // implements transformation D -> C
};
template<> struct Coordinates<E> {  // specialisation for system E
   // ...
   operator Coordinates<C>() const; // implements transformation E -> C
};

编译器会计算出任意两个系统坐标之间的转换，例如

double radiusE(Coordinates<E> const&x); // radius is best computed from system E

template<CoordSys Sys> double radius(Coordinates<Sys> const&x)
{ return radiusE(x); }       // implicit type conversion to system E

然而，特化是乏味的，因为 // ...部分可能很长而且基本相同(如果我从一个共同的基础继承它仍然很乏味)。理想情况下，我希望避免特化，而只有一个类模板定义 Coordinates<> - 我怎样才能做到这一点？或者还有其他有用的选择吗？

Answer 1

我会在构造函数中进行隐式转换，而不是作为转换为成员函数。

这样你就可以在你的坐标类型上有一个模板构造函数，如果你不需要全速转换，你可以将所有东西转换为笛卡尔坐标(或其他)，然后再转换为特殊表示:

 template<class X>
 class Coordinate {
     template <class Y>
     Coordinate(Coordinate<Y> that) { setFromCartesian(that.toCartesian()); }

     Coordinate<Cartesian> toCartesian() { ... }

     ....
 }

然后您可以为那些需要专用代码速度的转换专门化该 ctor，但为大多数其他代码保留上述版本。

您还可以使用 enable_if 和 free 函数来确保构造函数正常失败:

   Coordinate<A> convert(Coordinate<B> that) { return ... }       

   template<class X, class Y>
   struct ConvertCheck {
        static const bool ok = False;
   };

   template<>
   struct ConvertCheck<A, B> {
        static const bool ok = True
   };

   ..

   template<class X>
   class Coordinate {  
         typedef Coordinate<X> this_type;

         template <class Y>
         Coordinate(Coordinate<Y> that, boost::enable_if(ConvertCheck<X,Y>::ok) { 
             *this = convert<this_type>(that);
         }

         ...
   }

另一种方法是使用元编程定义转换链并调用正确的序列(使用 boost::mpl 或类似的东西)。那将是一个很好的练习，我现在没有时间充实...