多态对象的数组

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多态对象的数组相关的知识,希望对你有一定的参考价值。

我经常遇到创建多态对象的数组或向量的需要。我通常更喜欢使用引用而不是智能指针来基类,因为它们往往更简单。

数组和向量被禁止包含原始引用,因此我倾向于使用指向基类的智能指针。但是,也可以选择使用std::reference_wrapperhttps://en.cppreference.com/w/cpp/utility/functional/reference_wrapper

从我从文档中可以看出,这是它的预期用途之一,但是当包含多态对象的数组的主题出现时,常见的建议似乎是使用智能指针而不是std::reference_wrapper

我唯一的想法是智能指针可能能够处理对象的整个生命周期吗?

TL:DR;为什么智能指针,例如std::unique_ptr在创建多态对象数组时似乎比std::reference_wrapper更受欢迎?

答案

用非常简单的术语:

  • unique_ptr是该对象的所有者。它管理拥有对象的生命周期
  • reference_wrapper包装指向内存中对象的指针。它不管理包装对象的生命周期

您应该创建一个unique_ptr(或shared_ptr)数组,以保证在不再需要时释放对象。

另一答案

如果你有足够的动力,你可以写一个poly_any<Base>类型。

poly_any<Base>any,仅限于存储从Base派生的物体,并提供.base()方法,将Base&返回到底层物体。

一幅非常不完整的草图

template<class Base>
struct poly_any:private std::any
{
  using std::any::reset;
  using std::any::has_value;
  using std::any::type;

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

  Base& base() { return get_base(*this); }
  Base const& base() const { return const_cast<Base const&>(get_base(const_cast<poly_any&>(*this))); }

  template< class ValueType,
    std::enable_if_t< /* todo */, bool > =true
  >
  poly_any( ValueType&& value ); // todo

  // TODO: sfinae on ValueType?
  template< class ValueType, class... Args >
  explicit poly_any( std::in_place_type_t<ValueType>, Args&&... args );  // todo

  // TODO: sfinae on ValueType?
  template< class ValueType, class U, class... Args >
  explicit poly_any( std::in_place_type_t<ValueType>, std::initializer_list<U> il,
          Args&&... args ); // todo

  void swap( poly_any& other ) {
    static_cast<std::any&>(*this).swap(other);
    std::swap( get_base, other.get_base );
  }

  poly_any( poly_any&& o ); // todo
  poly_any& operator=( poly_any&& o ); // todo

  template<class ValueType, class...Ts>
  std::decay_t<ValueType>& emplace( Ts&&... ); // todo
  template<class ValueType, class U, class...Ts>
  std::decay_t<ValueType>& emplace( std::initializer_list<U>, Ts&&... ); // todo
private:
  using to_base = Base&(*)(std::any&);
  to_base get_base = 0;
};

然后你只需要拦截将东西放入poly_any<Base>的每种方法并存储一个get_base函数指针:

template<class Base, class Derived>
auto any_to_base = +[](std::any& in)->Base& {
  return std::any_cast<Derived&>(in);
};

一旦你完成了这个,你可以创建一个std::vector<poly_any<Base>>,它是一个多样性来自Base的值类型向量。

请注意,std::any通常使用小缓冲区优化来在内部存储小对象,并在堆上存储较大的对象。但这是一个实现细节。

另一答案

基本上,reference_wrapper是一个可变引用:像引用一样,它不能为null;但就像指针一样,您可以在其生命周期内指定它指向另一个对象。

但是,像指针和引用一样,reference_wrapper不管理对象的生命周期。这就是我们使用vector<uniq_ptr<>>vector<shared_ptr<>>:确保引用的对象被正确处理掉。

从性能角度来看,vector<reference_wrapper<T>>应该和vector<T*>一样快速和记忆效率。但是这些指针/引用都可能变得悬空,因为它们不管理对象的生命周期。

另一答案

我们来试试吧:

#include <iostream>
#include <vector>
#include <memory>
#include <functional>

class Base {
public:
   Base() {
     std::cout << "Base::Base()" << std::endl;
   }

   virtual ~Base() {
     std::cout << "Base::~Base()" << std::endl;
   }
};

class Derived: public Base {
public:
   Derived() {
     std::cout << "Derived::Derived()" << std::endl;
   }

   virtual ~Derived() {
     std::cout << "Derived::~Derived()" << std::endl;
   }
};

typedef std::vector<std::reference_wrapper<Base> > vector_ref;
typedef std::vector<std::shared_ptr<Base> > vector_shared;
typedef std::vector<std::unique_ptr<Base> > vector_unique;

void fill_ref(vector_ref &v) {
    Derived d;
    v.push_back(d);
}

void fill_shared(vector_shared &v) {
    std::shared_ptr<Derived> d=std::make_shared<Derived>();
    v.push_back(d);
}

void fill_unique(vector_unique &v) {
    std::unique_ptr<Derived> d(new Derived());
    v.push_back(std::move(d));
}

int main(int argc,char **argv) {

   for(int i=1;i<argc;i++) {
      if(std::string(argv[i])=="ref") {
    std::cout << "vector" << std::endl;
    vector_ref v;
        fill_ref(v);
    std::cout << "~vector" << std::endl;
      } else if (std::string(argv[i])=="shared") {
    std::cout << "vector" << std::endl;
    vector_shared v;
    fill_shared(v);
    std::cout << "~vector" << std::endl;
      } else if (std::string(argv[i])=="unique") {
    std::cout << "vector" << std::endl;
    vector_unique v;
    fill_unique(v); 
    std::cout << "~vector" << std::endl;
      }
   }
}

使用参数共享运行:

vector
Base::Base()
Derived::Derived()
~vector
Derived::~Derived()
Base::~Base()

运行参数唯一

vector
Base::Base()
Derived::Derived()
~vector
Derived::~Derived()
Base::~Base()

用参数ref运行

vector
Base::Base()
Derived::Derived()
Derived::~Derived()
Base::~Base()
~vector

说明:

  • shared:内存由代码的不同部分共享。在该示例中,Derived对象首先由函数d中的fill_shared()局部变量和向量拥有。当代码退出时,函数对象的范围仍由向量拥有,并且仅当向量最终离开时,对象才会被删除
  • unique:内存由unique_ptr拥有。在该示例中,Derived对象首先由d local var拥有。但是必须将其移动到向量中,转移所有权。与之前相同,当唯一所有者离开时,对象将被删除。
  • ref:没有拥有语义。该对象被创建为fill_ref()函数的局部变量,并且对象的引用可以添加到向量中。但是,向量不拥有内存,当代码离开fill_ref()函数时,对象消失,使向量指向未分配的内存。

以上是关于多态对象的数组的主要内容,如果未能解决你的问题,请参考以下文章

为什么我不能在此片段中生成唯一对象数组?

如何调整动态分配的多态对象数组的大小?

多态对象的数组

如何以多态方式创建对象的动态数组?

web代码片段

Alamofire 文件上传出现错误“JSON 文本未以数组或对象开头,并且允许未设置片段的选项”