c++ - 如何动态确定用于参数化模板的类型并进行比较

Question

如果基于一个或多个类型参数创建类模板，那么在运行时如何查询这些类型？

例如:

template <typename T>
class Foo {
 public:
  typedef T TypeT;

  Foo() {}

  // assume i is in range
  void set(size_t i, T value) { store[i] = value; }
  T get(size_t i) { return store[i]; }

  void fast_copy(T* dest) { memcpy(dest, store, 100 * size_of(T)); }

  // ugly public data member
  T store[100];
};


void main() {
  Foo<double> fd;
  Foo<int> fi;

  // this is not C++!
  if (fd::TypeT == fi::TypeT) {

    // do a fast copy since the types match
    fd.fast_copy(fi.store);

  } else {

    // do a slower item by copy since the types don't match
    // and let the runtime perform the type conversion:
    for (size_t i = 0; i < 100; ++i) {
      fi.set(i, static_cast<fd::TypeT>(fd.get(i)));
    }
  }
}

我之所以要这样做，是因为我有一些运行时对象，它们包含浮点数， double 数或整数数组，并且我想将它们复制到其他类型的数组中，但是我不知道这些类型将是什么它们在运行时确定。在上面的示例中，用于实例化fi和fd的类型是已知的，但在完整示例中，fi和fd将引用多态类，该多态类可以是任何基本数值类型的数组的容器。

此机制旨在成为一组返回浮点数， double 数或整数的数组的函数与另一组需要浮点数， double 数或整数的数组的函数之间的运行时可配置的桥梁，并且这些函数的类型可以相同也可以不同桥的两边。桥接器是很简单的，它还可以做其他一些事情，但是需要采用一种类型的数组(或数组的容器)，并在另一种类型的数组中生成另一种类型的数组(或数组的容器)。最后，在类型相同而又不同的情况下。

注意:这与我的 this previous question有关，如果更有意义，将替换它。

编辑:这是我想要做的更多信息。

我有一个系统，它的一侧由一组返回数值结果的函数组成。有些返回单个浮点数或 double 数，有些返回单个整数，有些则修改(因此“返回”)浮点数， double 数或整数数组。有一大堆。我想将每个对象(实际上只是返回的数据，函数都没有关系)与我称为“源”对象的对象相关联-这可能是 Source<T>，其中T是数字类型。尽管我可能需要 SourceScalar<T>和 SourceVector<T>来处理单个值或数组。无论如何，该对象是“桥”的入口点。每个 Source<T>对象存储在Source对象的异构集合中，并由唯一的“Source Key”引用。例如，一个与源相关的函数可能返回一个32个浮点数的数组，这些数组代表波表振荡器的最新输出。另一个可能会返回一个包含32个 double 数组的数组，这些数组代表32个样本上的峰值检测器输出。

在系统的另一端，我还有另一套功能。这些都将数值作为参数。有些需要单个浮点数或 double 数，有些需要单个int，有些需要相同的数组。这些也很多。我有一个我称为“目标”对象的东西- Dest<T>，或者如上所述的 DestScalar<T>， DestVector<T>。该对象存储一个与这些函数之一绑定(bind)的std::function包装器，以便在必要时可以调用该函数。每个目标对象都存储在不同种类的目标对象集合中，并由唯一的“目标键”引用。例如，一个这样的功能可能是一个数字滤波器，它期望接收大小为32的数组，但其 double 数组不会浮点数。

现在，在运行时，需要一个更高级别的系统(实际上由用户控制)来将任何Source与任何Dest任意关联。用户提供两个键-源和目标-然后系统将一侧的数据“连接”到另一侧的功能。因此，在上面的示例中，它可能尝试将波表振荡器的32浮点数组连接到数字滤波器的32倍数组参数。任何时候都可以删除此关联。如果将峰值检测器中的32-double阵列连接到数字滤波器的32-double阵列参数，则由于阵列的类型相同，因此希望传输/复制尽可能快。

编辑2:这里是一些经过编译的代码，这是我可以构造的最简单的情况，它创建Source和Dest对象的两个集合，并动态地尝试“连接”它们。前两个对 source_collection[1]->set(...)的调用正常工作，但后两个不起作用，最终调用BaseDest基类成员函数 set_item而不是 Dest<T>中的一个。这还使用了这样的观察:如果查询的类型相同，则typeid()返回静态指针，并比较这些指针的值以确定类型是否匹配。这可能是不安全的，最好只使用枚举代替。

这一切让我感到非常恐怖-必须有更好的方法吗？

#include <vector>
#include <typeinfo>
#include <cassert>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>

class Source;    // fwd
class BaseDest;  // fwd

typedef boost::shared_ptr<Source>   SourcePtr;
typedef boost::shared_ptr<BaseDest> BaseDestPtr;

// target function that takes an array of doubles
void target_func_vd(double *array, size_t len) {
  for (size_t i = 0; i < len; ++i) {
    assert(array[i] == i);
  }
}

// target function that takes an array of floats
void target_func_vf(float *array, size_t len) {
  for (size_t i = 0; i < len; ++i) {
    assert(array[i] == i);
  }
}

// base class for Dest
class BaseDest {
public:
  BaseDest() {}
  virtual ~BaseDest() {}

  virtual void set(float *array, size_t len)  { /* not implemented, but can't be pure */ };
  virtual void set(double *array, size_t len) { /* not implemented, but can't be pure */ };

  virtual void set_item(size_t index, double item) { /* not implemented, but can't be pure */ };
  virtual void set_item(size_t index, float item) { /* not implemented, but can't be pure */ };
  virtual void finished(size_t len) = 0;

  virtual const std::type_info* get_type_info() const = 0;
private:
};

template <typename T>
class DestVector : public BaseDest {
public:
  typedef boost::function<void (T *, size_t)> Callable;

  explicit DestVector(Callable callable) : callable_(callable) { }

  virtual void set(T *array, size_t len) { callable_(array, len); }
  virtual void set_item(size_t index, T item) { buffer_[index] = item; }
  virtual void finished(size_t len) { callable_(buffer_, len); }

  virtual const std::type_info* get_type_info() const { return &typeid(T); };
private:
  Callable callable_;
  T buffer_[256];
};

// 'set' is overloaded by array type
class Source {
public:
  Source() {}
  void connect(const BaseDestPtr& dest) { dest_ = dest; }

  void set(float *array, size_t len) {
    if (dest_->get_type_info() == &typeid(double)) {
      // convert to double
      for (size_t i = 0; i < len; ++i) {
        dest_->set_item(i, array[i]);  // calls the base member function
      }
      dest_->finished(len);
    } else if (dest_->get_type_info() == &typeid(float)) {
      dest_->set(array, len);
    }
  }

  void set(double *array, size_t len) {
    if (dest_->get_type_info() == &typeid(float)) {
      // convert to float
      for (size_t i = 0; i < len; ++i) {
        dest_->set_item(i, array[i]);  // calls the base member function
      }
      dest_->finished(len);
    } else if (dest_->get_type_info() == &typeid(double)) {
      dest_->set(array, len);
    }
  }

private:
  BaseDestPtr dest_;
};


void main() {

  // test arrays
  float float_array[256];
  for (size_t i = 0; i < 256; ++i) {
    float_array[i] = static_cast<float>(i);
  }

  double double_array[256];
  for (size_t i = 0; i < 256; ++i) {
    double_array[i] = static_cast<double>(i);
  }

  // collection of Sources
  std::vector<SourcePtr> source_collection;

  SourcePtr s0(new Source());
  source_collection.push_back(s0);

  SourcePtr s1(new Source());
  source_collection.push_back(s1);


  // collection of Dests
  std::vector<BaseDestPtr> dest_collection;

  BaseDestPtr t0(new DestVector<float>(&target_func_vf));
  dest_collection.push_back(t0);

  BaseDestPtr t1(new DestVector<double>(&target_func_vd));
  dest_collection.push_back(t1);


  // create and invoke connections
  source_collection[0]->connect(dest_collection[0]);
  source_collection[0]->set(float_array, 256);  // this should end up passing float_array to target_func_vf, and it does

  source_collection[0]->connect(dest_collection[1]);
  source_collection[0]->set(double_array, 256); // this should end up passing double_array to target_func_vd, and it does

  source_collection[1]->connect(dest_collection[0]);
  source_collection[1]->set(double_array, 256); // this should end up passing double_array to target_func_vf, but it doesn't

  source_collection[1]->connect(dest_collection[1]);
  source_collection[1]->set(float_array, 256); // this should end up passing float_array to target_func_vd, but it doesn't
}

Answer 1

您可以使用重载。将此添加到您的类(class)

void copy(T & dest)
{
   fast_copy(&dest):
}

template<class U>
void copy(U & dest)
{
   for (size_t i = 0; i < 100; ++i) {
      dest.set(i, static_cast<TypeT>(get(i)));
}

PS:更多的c++方法是定义复制构造函数或赋值运算符

编辑:如果您希望动态mke的东西更加多态

struct BaseDest
{
   virtual void assign(const double * v, size_t cnt) = 0;
   virtual void assign(const float * v, size_t cnt) = 0;
//etc
}

template<class T>
struct DestImpl
{
   void assign(const double * v, size_t cnt)
   {
       assign_impl(v, cnt);
   }
   void assign(const float * v, size_t cnt)
   {
       assign_impl(v, cnt);
   }

   template<class U>
   void assign_impl(const U * v, size_t cnt)
   {
      for (size_t i = 0; i < cnt; ++i) {
         set(i, static_cast<T>(v[i])));
   }

   template<>
   void assign_impl<T>(const T * v, size_t cnt)
   {
      fast_copy(v, cnt);
   }
//stuff
}

struct Source
{
//blah
   template<class T>
   void set(const T * v, size_t cnt)
   {
     dest_->set(v, cnt);
   }

//blah
}