Accessing method of derived class when using ptr_vector - c++

Question

Setup
class Base
{
public:
Base();
virtual ~Base();
int getType();
protected:
int type;
};
class DerivedA : public Base
{
public:
DerivedA() { this->type = 1; };
~DerivedA();
int getA() { return 1;};
};
class DerivedB : public Base
{
public:
DerivedB() { this->type = 2; };
~DerivedB();
int getB() { return 2;};
};
Target
Having a vector containing objects of both derived classes and then be able to access child-specific methods.
Current "solution"
int main()
{
typedef boost::ptr_vector<Base> BasePtr;
BasePtr vec;
// Fill vec with some stuff
vec.push_back(new DerivedA());
vec.push_back(new DerivedB());
vec.push_back(new DerivedA());
vec.push_back(new DerivedB());
typedef BasePtr::iterator BaseIter;
for ( BaseIter it = vec.begin(); it != vec.end(); it++ ) {
if (it->getType() == 1) {
std::cout << it->getA() << '\n';
} else {
std::cout << it->getB() << '\n';
}
}
return 0;
}
Problem
Obviously "it" is not recognised as either DerivedA or DerivedB, so the child-specific method cant be accessed.
Some form of cast is required, so i guess the question is:
How do I properly cast the iterator to the correct derieved class?
Maybe there is a better way to structure this whole scenario?
Edit:
Seems i was a bit unclear. The purpose of the methods in the derived classes is fundamentally different.
Consider the base class Item that have the derived classes Armor and Weapon.
In this example you can see why, for instance, Weapon have a function getDamage() that maybe returns a float.
This function is not needed for Armor and dosn't even have anything similar.
In this example you can see the vector as an Inventory that can contain any number, and types, of items. Maybe even items that have a stack and some use (Potions maybe)

Answer 1

If you have to cast to derived, then it means you have a broken design.
But if you really have to then this would do (put it in the for loop) :
DerivedB * typeB = dynamic_cast< DerivedB * >( &*it );
if ( typeB != nullptr )
{
std::cout << typeB->getB() << '\n';
}
A better approach would be to add getB() to the interface, and implement it in DerivedA (it can return some dummy value, or throw if really needed).

Answer 2

Casting is a pretty ugly solution, and not very C++'y. Instead you should be using virtual functions.
Something like:
class Base
{
public:
virtual int get() = 0;
// ...
};
class DerivedA : public Base
{
public:
int get() { return 1;};
};
class DerivedB : public Base
{
public:
int get() { return 2;};
};
Then there is no need to have an extra type, and you can just call it->get();.

Answer 3

You can use dynamic_cast as below.
for ( BaseIter it = vec.begin(); it != vec.end(); it++ )
{
DerivedA* dA = dynamic_cast<DerivedA*>(it);
if(dA != NULL)
{
// Do whatever for DerivedA
}
// Similarly check for DerivedB
}
There is no easy way out here other than designing your interfaces to utilize the polymorphism. i.e, define function signatures in the base class and implement them in the derived class. The for-loop above, ideally shouldn't try to know what is the type of the container items. It is impossible to comment on this without knowing what is the real functions represented by getA() and getB().