Hi everyone,
I'm trying to accomplish some node-based stuff and i'm trying to set some nodes to allow only some kind of nodes for connection. Now i might have somewhat of a design problem as it seems i can only achieve this behavior by using dynamic_cast<> which i have always heard to be a sign of poor coding design. Here's a small test i've made:
Code:
#include <iostream>
#include <stdexcept>
class nodeA
{
protected:
nodeA *m_node;
public:
virtual void connect(nodeA *node)
{
if (!node) { throw std::runtime_error("nodeA: Null pointer was passed"); }
if (node==this) { throw std::runtime_error("nodeA: Can't connect to itself"); }
m_node = node;
std::cout << "nodeA: Connection to " << node << " performed \n";
}
};
class nodeB : public nodeA
{
float somevar; // to make classes different
double var1;
public:
virtual void connect(nodeA *node)
{
if (!node) { throw std::runtime_error("nodeB: Null pointer was passed"); }
if (node==this) { throw std::runtime_error("nodeB: Can't connect to itself"); }
if (!dynamic_cast<nodeB*>(node)) { throw std::runtime_error("nodeB: Wrong nodetype"); }
m_node = node;
std::cout << "nodeB: Connection to " << node << " performed \n";
}
};
int main()
{
nodeA mNodeA;
nodeA otherA;
nodeB mNodeB;
nodeB otherB;
nodeA *nodePtr = &otherA; // start with an A node type
std::cout << "\n";
std::cout << "mNodeA at " << &mNodeA << "\n";
std::cout << "otherA at " << &otherA << "\n";
std::cout << "mNodeB at " << &mNodeB << "\n";
std::cout << "otherB at " << &otherB << "\n\n";
try {
mNodeA.connect(nodePtr);
std::cout << "A----->A OK!" << "\n";
nodePtr = &otherB;
mNodeA.connect(nodePtr);
std::cout << "B----->A OK!" << "\n";
mNodeB.connect(nodePtr);
std::cout << "B----->B OK!" << "\n";
nodePtr = &mNodeA;
mNodeB.connect(nodePtr);
std::cout << "A----->B OK!" << "\n";
std::cout << "If we got here no node exceptions were thrown so i'll leave while i'm winning...";
std::cout << "\n\n";
exit(0);
} catch (const std::runtime_error& e) {
std::cout << "Runtime error: " << e.what() << "\n\n";
}
return 0;
}
The output i got from running this small test was:
Code:
mNodeA at 0xbfb92c64
otherA at 0xbfb92c5c
mNodeB at 0xbfb92c48
otherB at 0xbfb92c34
nodeA: Connection to 0xbfb92c5c performed
A----->A OK!
nodeA: Connection to 0xbfb92c34 performed
B----->A OK!
nodeB: Connection to 0xbfb92c34 performed
B----->B OK!
Runtime error: nodeB: Wrong nodetype
Which looks exactly like i expected it to and it seems the way i want things to work out. My only doubt here is if using the dynamic_cast<> for this is a poor design and if there's a better way of implementing this behavior of A accepts A, B derives from A but only Accepts A and possibly other nodes derived from A.
Sorry for the long post and thanks in advance for any help.
Cheers