Question

我有一个基类，它有4个不同的参数向量：HW，SW，FW，High level

每个类派生自基类，并且需要能够从一个参数向量转换为另一个。

Ex：convert（Vector vec1，Vector vec2）;

实现的一种方法是使用16个静态转换案例。然而，虽然目前有4种不同类型的向量，但可以在以后添加更多的向量。

并非所有类都实现了所有16次转换。他们中的很多人将使用默认转换（我希望在基类中实现“无转换定义错误”）;

class A: public baseClass

Class B: public baseClass

Class C: public baseClass

C::Convert(Vector<HW> vec1, Vector<SW> vec2)
{
   vec2[0] = vec1[0] +vec1[1] *1.5;
}
B::Convert(Vector<HW> vec1, Vector<SW> vec2)
{
   vec2[0] = vec1[0] +vec1[1] *3.7;
}
A::Convert(Vector<SW> vec1, Vector<HW> vec2)
{
   vec2[0] = vec1[2] +vec1[1] *9;
}

定义通用转换的好方法是什么？我想也许是矢量模板。

Template<Vector<K>, Vector<T>>
void Convert(const k& vec1, T vec2)

我不能假设存在从每个向量到另一个向量的转换。

Answer 1

确定一个向量，它将成为所有这些向量的基础，比如Base，它们中的每一个都可以自动转换为Base。然后我们要做的就是提供从Base到所有其他人的转换。

因此，对于您添加的每个向量，您需要提供2个函数：从它自动更改为Base，并从Base更改为它。

因此，为了从Vec1转换为Vec2，您只需要一个函数（它只是模板的草图）：

Vec2 Convert<Vec1, Vec2>(Vec1 v1, Vec2 v2) {
    return v1.toBase().toVec2();
}

Answer 2

您可以使用模板方法，请参阅示例：

#include <iostream>
#include <vector>

class Hw {};
class Sw {};

// base class with default converters
class Base {
 public:
  template <class From, class To>
  void convert(const From& from, To& to);
};

// specialize template with default converters
template <>
void Base::convert(const std::vector<Hw>& from, std::vector<Sw>& to) {
  std::cout << "default converter" << std::endl;
}

// specialize forbidden version with runtime error
// (simply don't specialize anything to get link error, which is better)
template <>
void Base::convert(const std::vector<Hw>& from, std::vector<Hw>& to) {
  std::cout << "error converter" << std::endl;
}

// override some default behaviour
class A : public Base {
 public:
  // show you want to use other default converters
  using Base::convert;

  // special (not default) behaviour
  void convert(const std::vector<Hw>& from, std::vector<Sw>& to) {
    std::cout << "special A converter" << std::endl;
  }
};

// converter with defaults
class B : public Base {
};

int main() {
  std::vector<Hw> hw_vector;
  std::vector<Sw> sw_vector;

  A a;
  a.convert(hw_vector, sw_vector); // special A converter
  a.convert(hw_vector, hw_vector); // error converter

  B b;
  b.convert(hw_vector, sw_vector); // default converter
  b.convert(hw_vector, hw_vector); // error converter
  return 0;
}

模板矢量矢量转换功能

2 个答案: