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*> ;

但最后一步不起作用。 clang完成告诉我

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

但由于B来自A，这应该是可能的吗？我见过人们使用的例子

B bObj;
A *aObj = &bObj ;

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

我完成这一切的原因是因为我有class C和class D，与class B完全相同，唯一的区别是#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需要虚拟析构函数，否则通过B*删除A*是未定义的行为。

Answer 3

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

Clang说实话。

但由于B来自A，这应该是可能的吗？

不对。

我见过人们使用
的例子

B bObj;
A *aObj = &bObj ;

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

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

您正尝试将指向std::vector<B*>的指针指向std::vector<A*>的指针。 std::vector<A*> 不是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())会怎么样？您的Base*向量中不能有Derived*。

有关将Derived*视为Base*所涉及的问题的详细解释，请参阅this answer to "Converting std::function<void(Derived*)> to std::function<void(Base*)>"背后的原因，这是同一个问题的另一种形式。

制作指向基类指针的std :: vector的指针指向派生类指针的{std :: vector}

4 个答案: