Checking the RTTI

Question

I have the following classes and methods:

//Base class
class Node {
    public:
        virtual ~Node() {};
        Node() {};
    private:
        // Private things for my implementation.
};

class Element : public Node {
    public:
        // Returns the name of the element.
        const xml::String &name() const {
            return eleName;
        }

        static bool is_Element(const Node *base) {
            Element *p = NULL;
            p = dynamic_cast<Element*>(base);
            return (p!=NULL);
        }

        static const Element *to_Element(const Node *base) {
            return dynamic_cast<Element*>(base);   
        }

    private:
        s_namespace eleNamespace;
        xml::String &eleName;
        // Private things for my implementation.
};

Here when I dynamic cast it says the following compile error. How to correct it? One method is to simple remove the const of the parameters. But I donot think that is the correct method.

oops.cpp: In static member function ‘static bool xml::Element::is_Element(const xml::Node*)’: oops.cpp:208:44: error: cannot dynamic_cast ‘base’ (of type ‘const class xml::Node*’) to type ‘class xml::Element*’ (conversion casts away constness) oops.cpp: In static member function ‘static const xml::Element* xml::Element::to_Element(const xml::Node*)’: oops.cpp:213:47: error: cannot dynamic_cast ‘base’ (of type ‘const class xml::Node*’) to type ‘class xml::Element*’ (conversion casts away constness)

Cast it to `const Element*`. Because casting it to `Element*` casts away the constness. — Drew Dormann, Mar 03 '13 at 16:33
@footy Using `dynamic_cast` to find out the dynamic type of an object is usually a sign of bad design. Why do you need to know if your `Node` is an `Element`? You should be able to use an `Element` as though it were a `Node`. — Joseph Mansfield, Mar 03 '13 at 16:34
This has nothing to do with the problem, but `is_Element` should return `p != NULL`, not `base != NULL`. — Pete Becker, Mar 03 '13 at 16:38
@Flexo Hmm.. Probably not since I Alexander's answer is what I was looking for. — footy, Mar 03 '13 at 16:38
@PeteBecker Thanks! That was a typo in the question. Not intentional. I fixed it. — footy, Mar 03 '13 at 16:40

score 8 · Accepted Answer · answered Mar 03 '13 at 16:34

8

Use dynamic_cast<const Element*> instead.

You can also make your class const-correct, by implementing two different functions for a const-Argument and a non-const Argument:

    static const Element *to_Element(const Node *base) {
        return dynamic_cast<const Element*>(base);   
    }

    static Element *to_Element(Node *base) {
        return dynamic_cast<Element*>(base);   
    }

So if the caller has a non-const Node he probably also wants a non-const Element and now he can get it...

answered Mar 03 '13 at 16:34

Alexander Tobias Bockstaller

4,657
4
36
58

This is exactly what I wanted achieve! You read my mind. Thanks :) – footy Mar 03 '13 at 16:37
Trying to understand here: In the solution above, is function to_Element() overloaded ? But I had read functions don't become overloaded just by making arguments const in one and non-const in other. How does this particular soln. work? – goldenmean Mar 06 '13 at 16:07

score 2 · Answer 2 · answered Mar 03 '13 at 16:34

2

Try this:

static bool is_Element(const Node *base) {
    const Element *p = NULL; // Add a const keyword here
    p = dynamic_cast<const Element*>(base); // Add a const keyword here
    return (base!=NULL);
}

And the same for to_Element

answered Mar 03 '13 at 16:34

masoud

55,379
16
141
208

`p` is `Element*` which cannot hold `Element const*`. – Nawaz Mar 03 '13 at 16:35

Checking the RTTI

2 Answers2