Getting Base* to act as its actual Derived* type

[vusak]

Im thinking i may be attempting some kind of inbuilt cast or something, ideally i just want to overload the right functions so that the following occurs:
-adding a node of the correct type causes the derived class overloaded virtual function to correctly add the node.
-adding a node of the incorrect type defaults to the base class virtual function which reports a general invalid message.

so my goal is to have a Node* type return an identifying pointer of its Derived type so that the correct function is called from the Derived : Diagram type (using that derived pointer as the indentifier for the function signature).

currently the code always prints - "Error: wrong type of node for this type of diagram" - which indicates it is still being passed as a Node* type and not as a Derived : Node* type or atleast, the virtual function in the Base Diagram class is being called in preference to the Derived Diagram versions.

have i got the wrong idea? will this fail no matter how i attempt it?

Note: i understand i can change to Derived::addNode(Node*), to get something that will add the nodes, however i want to enforce restriction on the type of node added to the particular type of diagram

ERD* diagramERD = new ERD;
DFD* diagramDFD = new DFD;
 
vector<Diagram*> diagramList;
diagramList.push_back(diagramERD);
diagramList.push_back(diagramDFD);
 
vector<Diagram*>::iterator activeDiagram = diagramList.begin();
 
Datastore* myData = new Datastore;
Entity* myEntity = new Entity;
 
Node* myNodeData = new Datastore;
Node* myNodeEntity = new Entity;
 
(*activeDiagram)->addNode(myData->getMyType());
(*activeDiagram)->addNode(myEntity->getMyType());
(*activeDiagram)->addNode(myNodeData->getMyType());
(*activeDiagram)->addNode(myNodeEntity->getMyType());
(*activeDiagram)->addNode(dynamic_cast<Datastore*>(myData));
(*activeDiagram)->addNode(dynamic_cast<Entity*>(myEntity));
(*activeDiagram)->addNode(dynamic_cast<Entity*>(myData));
(*activeDiagram)->addNode(dynamic_cast<Datastore*>(myEntity));
 

class Node {
public:
  virtual void checkMyType() {
    cout << "I am a Node";
  }
  virtual Node* getMyType() {
    return this;
  }
};
 
class Datastore : public Node {
public:
  virtual void checkMyType() {
    cout << "I am a Datastore";
  }
  virtual Datastore* getMyType() {
    return this;
  }
};
 
class Entity : public Node {
public:
  virtual void checkMyType() {
    cout << "I am an Entity";
  }
  virtual Entity* getMyType() {
    return this;
  }
};
 
class Diagram {
public:
  virtual void addNode(Node *newNode) {
    cout << "Error: wrong type of node for this type of diagram" << endl;
  }
};
 
class DFD : public Diagram {
public:
  virtual void addNode(Datastore *newDatastore) {
    cout << "DFD::Adding ("; newDatastore->checkMyType(); cout << ") to nodeList" << endl;
  }
};
 
class ERD : public Diagram {
public:
  virtual void addNode(Entity *newEntity) {
    cout << "ERD::Adding ("; newEntity->checkMyType(); cout << ") to nodeList" << endl;
  }
};
 

[weaknessforcats]

I am curious why you are doing this. I would have thought you would just have a vector of base class pointers and let it go at that.

However, if you need to get the exact type of the derived object, I suggest you design your classes for the Visitor design pattern.

I don't have time today to go through the pattern, but if you have a copy of the Design Patterns book by Erich Gamma, et al. Addison-Wesley 1994, the Visitor pattern is on page 331.

Visitor allows you to add methods to derived classes that are not the base class methiods and be able to call those methods by using a base class pointer.

In your case, you create a DFDVisitor (derived from DiagramVisitor) and call the Diagram Accept method that takes a DiagramVisitor pointer.

The Diagram Accept calls the Diagram DoAccept and passes along the DiagramVisitor pointer.

Diagram DoAccept is overriden by DFD DoAccept which uses the DiagramVisitor pointer to call VisitDFD in the DiagramVisitor class using the "this" pointer of the Diagram (which is really a DFD pointer). VisitDFD is overriden by DFDVisitor and so are really calling VisitDFD using a DFD*. Now you can run any methods on the DFD class regardless of whether they are in the Diagram class or not.

--and you never need to know the type of the pointer.

Check it out.