C ++，基类如何将子类作为成员包括在内并调用其方法

Question

I have some experience with Java and C, but only now starting with C++. I am trying to write a kind of logical tree :

All items derive from an abstract base class " Item ". Some items are containers and can contain several items. They derive from class " Block ". A block can contain other blocks (this is recursive). It also has an operator information Other elements are runnables, they don't contain other items.

So far I could build my tree (and incidentally reflect it into/from an xml file using pugixml lib). But now in my application, I would like to easily "move myself" along the tree. The issue is that I need to keep a pointer to the container in which an item is stored, so i can move back. (very first block will have 'nullptr')

so I have : (of course there are #ifdef guardblocks that I don't copy here)

in item.h :

#include "block.h" //issue here!

enum Item_t { ... };

class Item
{
public:
    Item(Block* parentBlock, int order_number, int loop_number=1);
    virtual ~Item();

    virtual Item_t getItemSubClass() const = 0; //just for some kind of reflexivity hack for other function (here in this sample to show this is abstract)

protected:
    Block* m_parentBlock;
    int m_order_number;
    int m_loop_number;
    int m_current_loop=0;
private:
};

and in block.h :

#include "item.h"
#include <string.h>
#include <map>
#include <iostream>

enum Operator { undefined, serial, parallel };

//class Item; // <= forward declaration ? won't work !

typedef std::map<int, Item*>::const_iterator item_iterator_t;

class Block : public Item
{
public:
    Block(Block* parentBlock, int order_number,  std::string op_str, int loop_number=1);
    virtual ~Block();

    void addSubItem(int index, Item* item);
    const Item* getSubItem(int index) const;

    item_iterator_t item_begin() const;
    item_iterator_t item_end() const;

    Operator getOperator(void) const;
    virtual Item_t getItemSubClass() const override;
protected:
private:
    Operator m_op;
    std::map<int, Item*> m_subItems;
};

Issue here :

• Item needs to include block.h, as it has member pointer to it, AND its constructor in cpp file calls block.addSubItem() method.

• Block obviously needs to include item.h as it derives from it.

• forward declaration is not enough when needing to call a method or inherit from a class (so for both cases).

• I could slightly change the design, by not setting parent/child relation into the constructor (this would work fine, but i'm interesting in seeing a solution to this inheritance/recursion issue)

Answer 1

As I was writing my question I found out a solution. My problem was due to my coding style, where I tend to have my class.cpp files only include my corresponding class.h file, and centralize all other include command in the header. (finally it is maybe not a good practice)

• in block.h : (no other choice to inherit)

   #include "item.h" 

• in item.h : use forward declaration

   class SeqBlock; 

• in item.cpp : include both !

   #include "item.h" //optional as included in block.h but make it clear #include "block.h" 

(not sure however this is the best solution or if the original design has a big flaw)