使指向基类指针std :: vector的指针指向派生类指针的std :: vector

Question

抱歉，标题冗长。 我不知道如何表达这一点。

class A 
{
      bool a1; 
      unsigned int a2 ; 
      virtual bool aFn1(unsigned int t_) = 0 ; 
      virtual void aFn2(unsigned int t_, bool val_) = 0 ;  
      A() 
      {
           a1 = false ; a2 = 0 ; 
      };
}

下一个：

#include <bitset> 
#define MAX_SIZE 500 

class B : public class A 
{
  private: 
     std::bitset<MAX_SIZE> _bmem; 
  public:
     B() : A() {}; 
     using A::aFn1 ;            
     virtual bool aFn1(unsigned int t_) 
        {
           return _bemem[t_] 
        } 
      using A::aFn2;
     virtual void aFn2(unsigned int t_, bool val_)
     {
        _bemem[t_] = val_ ; 

     }
}

下一个：

#include "A.h"
#include "B.h"

std::vector<A*> * vecA; 
vecA = new std::vector<B*> ; 

但是最后一步不起作用。 lang完整告诉我

从不兼容的类型std::vector<B*>分配给std::vector<A*> * std::vector<B*>

但是由于B源自A ，这应该可行吗？ 我看到了人们使用的例子

B bObj;
A *aObj = &bObj ;

那你能告诉我我犯了什么错误吗？

我经历所有这些的原因是因为我拥有class C和class D ，就像class B class D一样，唯一的区别是#define MAX_SIZE是不同的。

我这样做是因为，我需要一个bitset不同大小的，在程序的不同阶段使用。 和bitset要求，需要在编译时存储元件的数量。

Answer 1

您使用了太多的接口和指针。

class A  {
  bool a1 = false; 
  unsigned int a2 = 0; 
  std::vector<bool> values;
  bool aFn1(unsigned int t_) const { return values[t_]; }
  void aFn2(unsigned int t_, bool val_) { values[t_] = val_; }
  void set_size(size_t i){values.resize(i);}
  A() = default;
  static A of_size(size_t i){ A r; r.set_size(i); return r; }
};

然后使用std::vector<A> 。

如果您100个大小为500的元素，请执行std::vector<A> v( 100, A::of_size(500) );

与您的代码相比，此代码将执行更少的分配，使用更少的内存并且具有更少的间接寻址。 使用new是“代码异味”，通常是您犯了一个错误的信号，除非您确实需要寿命非常复杂的对象。

std::vector<bool> values将几乎与std::bitset<500>一样紧凑，并且差异由我消除的其他指针所弥补。

Answer 2

您不能使std::vector<A*>*指向std::vector<B*>* ，它们是不同的类型。

您可以做的就是将B*推入std::vector<A*> ：

std::vector<A*> vec;
B b;
vec.push_back(&b);

当然，您需要注意指针的生命周期。 如果向量应该管理生存期本身，则可能要使用std::unique_ptr 。

还要注意， A需要一个虚拟析构函数，否则通过A*删除B*是未定义的行为。

Answer 3

clang complete告诉我assigning to std::vector<A*> * from incompatible type <A *> assigning to std::vector<A*> * from incompatible type

lang告诉你真相。

但是由于B源自A，这应该可行吗？

不对。

我看到了人们使用的例子

B bObj;
A *aObj = &bObj ;

这些例子是正确的。 他们之所以工作是因为A是B的父母。 子类的指针可以转换为父类的指针。

那你能告诉我我犯了什么错误吗？

你想一个指向指定std::vector<B*>为指针std::vector<A*> std::vector<A*> 不是 std::vector<B*>的父std::vector<B*> 。 就继承而言，它们是完全无关的类。 指向类型的指针不能转换为不相关类型的指针。

Answer 4

归结为

std::vector<Base*> *v = new std::vector<Derived*>;

但是std::vector<Base*>和std::vector<Derived*>是不兼容的类型，出于同样的原因，您不能将Derived*数组用作Base*数组。

例如，在上面，如果编写v->push_back(new Base())什么？ 您的Derived*向量中不能有Base* Derived* 。

有关将Derived*用作Base*的问题的很好的解释，另请参阅此答案的“将std::function<void(Derived*)>为std::function<void(Base*)> ” ，这是同一个问题，但外观不同。