C ++继承问题

Question

这是我的课程：

ParentClass，ParentObj

DerivedClass（继承自ParentClass），DerivedObj（继承自ParentObj）。

ParentClass有一个受保护的成员：

std :: vector <ParentObj *>

DerivedClass仅将DerivedObj *对象分配给此向量。

问题是：

当我使用ParentClass时，我想使用类型的迭代器访问其矢量对象：

std :: vector <ParentObj *> :: const_iterator

当我使用DerivedClass时，我想使用类型的迭代器访问其矢量对象：

std :: vector <DerivedObj *> :: const_iterator

我怎样才能使它工作？

Answer 1

您可以在DerivedClass类中使用虚拟覆盖，返回ParentClass返回类型的子类型...

struct ParentClass {
    virtual ParentObj* get( const size_t index ) {
       return m_objects[index];
    }
 };

 struct DerivedClass : public ParentClass {
    virtual DerivedObj* get( const size_t index ) {
       return dynamic_cast<DerivedObj*>( ParentClass::get(index) );
    }
 };

两个函数都是相同的'vtable'条目，尽管它们的返回类型不同。

或者，您可以使用相同的技术来创建“继承的”迭代器。

DerivedClass ，在DerivedClass对象中有一个DerivedObj*的向量并不是一个坏主意，只要你保证它们也存在于ParentClass的向量中。

Answer 2

我有一个问题： 为什么DerivedClass继承自ParentClass ？

您是否需要多态行为，或者您是否要重用ParentClass的实现？

继承经常被严重滥用。 真。

然后是（典型的）具有容器类的问题，以及如何公开其元素。 不幸的是，迭代器（尽管他们所有的商品）语言支持得不好，不像他们应该模仿的指针。

因此，提醒： 继承是一种is-a的关系，代码重用有成分 。

在这里，您可以完美地编写一个模板类，它将扮演容器的一部分并提供常用方法。

然后，对于公开的问题......你可以编写自己的迭代器，使用正确的基础派生关系，或者你可以选择预先选择一些与用户提供的谓词一起使用的算法（ sort ， foreach ， erase_if ） 。

template <class Value>
class Container
{
public:
  template <class Pred>
  void sort(Pred iPred);

  template <class Pred>
  Pred foreach(Pred iPred); // maybe a const-version ?

  template <class Pred>
  size_t erase_if(Pred iPred); // returns the number of erased
private:
  std::vector<Value> m_data;
};

然后，你的课程：

class ParentClass
{
public:
  virtual void foo() const;
private:
  Container<ParentObj*> m_data;
};

class DerivedClass: public ParentClass
{
public:
  virtual void foo() const;
private:
  Container<DerivedObj*> m_data;
};

尝试将多态性与代码重用分开，问题应该变得更简单。

Answer 3

std::vector< ParentObj* >和std::vector< DerivedObj* >是两个完全不同的类型，因此您不能隐式地将一个转换为另一个。 你可以做的是使用dynamic_cast将每个ParentObj*转换为DerivedObj* 。 但一般来说，这不是一个好习惯。

Answer 4

你不能使用基本的C ++继承来做到这一点。 原因是编译器在DerivedClass使用时不知道向量仅包含指向DerivedObj指针。 关于动态演员的第二个Naveens声明。

你可以使用两个向量std::vector< ParentObj* > mParent和std::vector< DerivedObj* > mDerived和一个虚拟的Add()函数。 基本实现只会添加到mParent 。 DerivedClass的Add函数也会添加到mDerived 。

ParentClass有一个GetParentIterator()函数， DerivedClass有另一个（附加）函数GetDerivedIterator() 。

Answer 5

你的继承设计是错误的。

DerivedClass不能从ParentClass继承。 ParentClass有一个受保护的成员std::vector< ParentObj* > 。 DerivedClass必须有另一个受保护的成员std::vector< DerivedObj* > 。

您可以创建模板类

template<class T>
struct MyClass {
  protected:
    std::vector< T* > m_objects;
};

struct ParentClass : MyClass <ParentObj> {};
struct DerivedClass: MyClass <DerivedObj> {};