Checking real variable type in polymorphism (C++)

Question

Suppose we have a class A and class B and C inherit from it. Then we create an array of references to A's, and fill it with B's and C's. Now we decided that we want to eliminate all the C's. Is there a way to check what type each field of the array really holds without doing something redundant like a returnType() function?

Edit: fixed "array of A's" to "array of references to A's".

Answer 1

You can't create an array of As and fill it with Bs and Cs - they will be sliced down to
As. You can create a n array of pointers to A , wich you can populate with pointers to B and pointers to C.

To check the type of something in this situation - use dynamic cast:

    // create B or C randomly
    A * a = rand() % 2 ? new B : new C;

    if ( dynamic_cast <B *> ( a ) ) {
        // it's a B 
    }
    else {
        // it isn't (must be C in this case)
    }

Answer 2

You won't be able to store B's in it. The compiler will moan.

Answer 3

This will only work if the array of A's is actually an array of pointers to A, otherwise you'll get slicing problems.

As for the problem at hand, you're better off giving A a virtual function getClassName, and ovverriding it appropriately in subclasses, then using the result to provide the behaviour you want.

Answer 4

Ideally, you want to figure out what functionality it is that makes you not want the Cs in there. Then add a virtual function that exposes that property. This way when you add class D that also has that same unwanted property, things will continue to behave correctly.

class A
{
public:
    virtual bool IsFrobbable() { return true; }
};

class B : public A
{
};

class C : public A
{
public:
    virtual bool IsFrobbable() { return false; }
};

int main()
{
     vector<A *> vA;
     vA.push_back(new A());
     vA.push_back(new B());
     vA.push_back(new C());

     vA.erase(remove_if(vA.begin(), vA.end(), not1(mem_fun(&A::IsFrobbable))));
     // Now go ahead and frob everything that's left
}

Answer 5

It's not possible to create an array of references in C++.

It is possible to create an array of pointers to A, however. In that case, provided A declares at least 1 virtual function, you could use C++'s run-time type inference (RTTI) mechanism to do what you want to do:

A* arr[10];

fill_with_as_bs_and_cs(arr);

for (int i = 0; i < 10; ++i) {
    if (dynamic_cast<C*>(arr[i])) {
        arr[i] = 0;   // You can't really "remove" things from an array...
    }
}

However, this is not the most maintainable approach -- any time you need to distinguish a C from an A, you'll need to use this if test, and if you wind up deriving more classes from A and you also need to treat them differently, you'll need to update every place in your code where you are performing this "type testing." As your codebase gets bigger, it quickly gets easy to miss places.

Generally, it's much more maintainable to use a virtual function that is overridden in each class as necessary. In this particular case, establish what are the general criteria shared by all A-derived class objects that should be removed from the array -- let's say that an object should be removed if it is blargable -- and then write a virtual function bool isBlargable(), and test that instead.