Associating a string with a derived class

Question

I am using the following code to get a string that is associated with the class of an instance:

std::string gate = 
    dynamic_cast<AND*>(pComponent) != nullptr ? "AND" :
    dynamic_cast<NAND*>(pComponent) != nullptr ? "NAND" :
    dynamic_cast<NOR*>(pComponent) != nullptr ? "NOR" :
    dynamic_cast<NOT*>(pComponent) != nullptr ? "NOT" :
    dynamic_cast<OR*>(pComponent) != nullptr ? "OR" :
    dynamic_cast<XNOR*>(pComponent) != nullptr ? "XNOR" :
    dynamic_cast<XOR*>(pComponent) != nullptr ? "XOR" : ""
;

This works, but I feel like there should be a better way to do this. Perhaps create some kind of map with a reference to the class type of pComponent as key and the related string as value?

All classes (AND, NAND, etc) inherit the same base class, Node. I have been thinking about adding the following code to Node:

virtual std::string get_gate() const = 0;

Then have every derived class implement the method, returning its string and call:

pComponent->get_gate();

Would this solution use memory for every class instance rather than once per class? For example I declare two objects of AND, would both of them allocate memory for the method? Will the compiler do something smart?

Answer 1

Would this solution use memory for every class instance rather than once per class?

Depends on whether your class already contains a vtable pointer or not.

If it does, there will be no additional memory requirements per instance (just another entry in the vtable, which is shared by all instances).

If it doesn't, each class will need an additional vtable pointer (that will be automatically inserted by the compiler to make virtual dispatch work). Also, a vtable will be generated, but those are one per class.

However, since you are already using (and that includes possibly deleting) instances of derived classes via pointer to base class, the base classes destructor (in this case Node::~Node()) should already be marked virtual so the derived classes destructor gets called correctly when deleting the Node*. This means each class should already have a vtable anyways - so no additional per-instance overhead.

Answer 2

Why not:

class Gate
{
    virtual void print(std::ostream& out = std::cout) = 0;
    friend std::ostream& operator<<(std::ostream& stream, Gate const& gate)
    {
        gate->print(stream);
        return stream;
    }
};
class AndGate
{
    virtual void print(std::ostream& out = std::cout) override {out << "AND";}
    .... Stuff
};
.... etc

int main()
{
    AndGate  gate(g1, g2);
    std::cout << gate << "\n";
}

Answer 3

The simplest solution is to do exactly what you suggested. Starting from:

std::string gate = 
    dynamic_cast<AND*>(pComponent) != nullptr ? "AND" :
    dynamic_cast<NAND*>(pComponent) != nullptr ? "NAND" :
    dynamic_cast<NOR*>(pComponent) != nullptr ? "NOR" :
    dynamic_cast<NOT*>(pComponent) != nullptr ? "NOT" :
    dynamic_cast<OR*>(pComponent) != nullptr ? "OR" :
    dynamic_cast<XNOR*>(pComponent) != nullptr ? "XNOR" :
    dynamic_cast<XOR*>(pComponent) != nullptr ? "XOR" : ""
;

You want a virtual method pComponent->get_gate() that evaluates to "AND" in one case, "NAND" in another, and so on. What is the type of "AND", "NAND", and so on? It's const char *. (Yes, yes, technically it's char[4] and char[5] respectively, but not for our purposes here. :)) So:

class Node {
public:
    virtual const char *get_gate() const { return ""; }
};

class AND : public Node {
public:
    const char *get_gate() const override { return "AND"; }
};

std::string gateName(Node *pComponent) {
    return pComponent->get_gate();
}

---

However, there's an even simpler approach, if you just want an identifying string and don't care that it's implementation-defined. Try this:

class Node {
public:
    virtual ~Node() = default;
};

class AND : public Node {};

std::string gateName(Node *pComponent) {
    return typeid(*pComponent).name();
}

On Linux/Unix/OS X platforms using Clang or GCC, this gives the strings "4Node" and "3AND"; that is, it gives the mangled class names. On Visual Studio, it gives the strings "class Node" and "class AND".

Using a virtual function get_gate will be marginally faster than the typeid approach (by literally 1 or 2 machine instructions). So it's just a question of how quick-and-dirty you want to be. Since you care enough to ask here, you should probably spend the extra time and lines-of-code to do the get_gate approach; it'll be easier to understand down the road.

---

Even sticking with the multi-way-branch approach, you'll find that it's much faster to use typeid than to use dynamic_cast, on current library implementations.

std::string gate = 
    typeid(*pComponent) == typeid(AND) ? "AND" :
    typeid(*pComponent) == typeid(NAND) ? "NAND" :
    typeid(*pComponent) == typeid(NOR) ? "NOR" :
    typeid(*pComponent) == typeid(NOT) ? "NOT" :
    typeid(*pComponent) == typeid(OR) ? "OR" :
    typeid(*pComponent) == typeid(XNOR) ? "XNOR" :
    typeid(*pComponent) == typeid(XOR) ? "XOR" : ""
;

This has different behavior from the original if for example NAND inherits from AND; but I'm sure from context that that's not the case.

---

This would be a decent use for X-Macros.

std::string gateName(Node *pComponent) {
    return (
#define X(K) typeid(pComponent) == typeid(K) ? #K :
#include "gate-types.h"
#undef X
        ""
    );
}