Question

考虑我有一堆指向不同类的不同对象

class1* obj1;
class2* obj2;
class3* obj3;

并且它们都有一个方法getArray()，它返回一个用于后期处理的向量。

如果所有这些指针都存储在某种列表中（无效指针列表）

当我迭代列表时，有没有办法计算可以使用什么类型的指针强制转换？

我知道这可以通过类层次结构解决，并从单个类派生上述类。由于很多遗留代码可以像上面提到的那样做什么？

愚蠢动态不让我存储指针，这是尝试的一件事

Answer 1

如果getArray（）始终具有相同的签名（或类似的足以转换为相同的类型） - 您可以做的是为decorator个duck-typed遗留对象/ DefaultIfEmpty创建一个类层次结构类。您可以使用非模板接口的模板派生类来包装而无需太多的输入工作。

这些方面的东西（更多的防御性编码，可能是传统对象的智能指针等）：

class IDecorator {
  public:
    virtual std::vector<ubyte> GetArray() = 0;
};

template<typename TLegacyType>
class TDecorator : public IDecorator {
   public:
     TDecorator(const TLegacyType *ip_legacy_object)
       : mp_legacy_object(ip_legacy_object) {}
     std::vector<ubyte> GetArray() override {
        return mp_legacy_object->GetArray();
     }

   private:
     const TLegacyType *mp_legacy_object;        
};

Answer 2

template<class R, class Op>
struct any_ptr {
  void* ptr=0;
  R(*f)( void* ) = 0;

  R operate() const { return f(ptr); }
  explicit operator bool() const { return ptr; }
  template<class T>
  T* as() const { return static_cast<T*>(ptr); }

  any_ptr(any_ptr const&)=default;
  any_ptr& operator=(any_ptr const&)=default;
  any_ptr()=default;

  template<class T>
  any_ptr(T* p_in):ptr(p_in),
    f( [](void* ptr)->R{ return Op{}( ptr ); } )
  {}
};

any_ptr支持存储支持Op的任何指针，其中Op是返回R的无状态函数对象类型。

struct get_array_t{
  template<class T>
  auto operator()(T* t)const{ return t->getArray(); }
};
using any_ptr_get_array = any_ptr< std::vector<int>, get_array_t >;

现在any_ptr_get_array可以存储指向支持返回.getArray()的{{1}}的任何类型的指针。

致电vector<int>：

getArray

使用模板生成的vtable，可以将此技术称为手动类型擦除。

检索不同类型的对象指针

2 个答案: