Accessing Properties/Functions of Subclasses C++ - c++

Question

I am having a design problem in my program because I need to occasionally access properties & methods of subclasses that are all stored in a vector of base class pointers. My code looks something like this:
class B1;
class B2;
class Base {
private:
int id, a, b;
public:
virtual int getA() { return a; }
virtual int getB() { return b; }
virtual B1 *getB1() { return NULL; } //seems like a bad idea
virtual B2 *getB2() { return NULL; } //to have these two functions
Base(int newId) { id = newId; }
};
class B1 : public Base {
private:
int x;
public:
int getX() { return x; }
B1 *getB1() { return this; }
};
class B2 : public Base {
private:
int y;
public:
int getY() { return y; }
B2 *getB2() { return this; }
};
class Thing {
private:
std::vector<Base*> bases;
void addBase(Base *base) { bases.push_back(base); }
void doB1Stuff();
void doB2Stuff();
void setAandB(int ID, int newA, int newB); //set a and b of one of the elements in bases vector based upon the id given
};
The problem is if I need to access x or y in Thing, like this below:
void Thing::doB1Stuff() {
for(std::vector<Base*>::iterator it = bases.begin(); it != bases.end(); ++it) {
if (it->getB1()) {
//do stuff with b1
}
}
}
The code above should work, but if it seems a bad idea because one could easily forget to check if the pointer is null before using B1/B2 properties like this:
void Thing::doB2Stuff() {
for(std::vector<Base*>::iterator it = bases.begin(); it != bases.end(); ++it) {
std::cout << it->getY(); //I believe this will crash the program if a NULL pointer is returned
}
}
My question thus is: what is a good way of accessing subclass properties? I was thinking of having two separate vectors for B1s and B2s in Thing, but that doesn't seem like a good idea either because I need to be able to set a and b easily. Any thoughts?

Answer 1

What you have is perfectly fine: as long as you do not store NULLs in the bases vector of pointers, there is no need to null-check the values returned from the iterator. Unfortunately, a vector of pointers is your only option for containers of polymorphic objects. You can make a vector of shared pointers to simplify dealing with deletions, but the basic idea would remain the same.

Answer 2

You can check whether the item you are accessing is the right subclass type you are looking for although to do this you need run time type information (rtti) included.
Then if it is of a certain type and not null you can cast it to that type and call the correct function.
Also you can use dynamic_cast although for this to work you need rtti again and it is essentially the same as checking yourself and then static casting.

Answer 3

You're right that's not a great way of approaching the problem, you can use dynamic_cast to have a safe way to determine which object to use, but that is bad code smell to me.
What I would do instead to access sub properties is create a virtual function that returns the value you want in the Base class.
Example:
class Base {
private:
int id, a, b;
public:
virtual int getA() { return a; }
virtual int getB() { return b; }
virtual int getSubValue() = 0; //
Base(int newId) { id = newId; }
};
class B1 : public Base {
private:
int x;
public:
int getSubValue() { return x; }
};
class B2 : public Base {
private:
int y;
public:
int getSubValue() { return y; }
};
Then you can just call it->getSubValue() to get the sub value you request.
This is my opinion and there are many ways to handle this, but this is what I would suggest based on the information you've given.