0

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

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

例如：转换（向量 vec1，向量 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)

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

4

2 回答 2

1

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

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

所以为了从 Vec1 转换到 Vec2 你只需要一个函数（它只是模板的草图）：

Vec2 Convert<Vec1, Vec2>(Vec1 v1, Vec2 v2) {
    return v1.toBase().toVec2();
}
于 2013-08-18T07:56:34.847 回答
1

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

#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;
}
于 2013-08-18T10:13:05.197 回答