Inheritance and Double Pointers

Because a pointer to a pointer to derived is not convertable to a pointer to a pointer to base. In other words, a Tiger array is not convertable to a Cat array, and adding a pointer doesn''t change that.

A warning - while the initial thing you wrote did work, the following will not:
ppCat[1]->Meow();
Because it will use the size of a Cat, rather than the size of a tiger to index into the array. So you''ll end up with

this 

pointing to half of two tiger objects.


May I suggest a different approach?

#include <vector>
using std::vector;
class Cat;
class Tiger : Cat;
vector<Tiger*> tigers;
//fill up tigers

tigers.push_back(new Tiger());
tigers.push_back(new Tiger());

vector<Cat*> cats(tigers.begin(),tigers.end()); //use a range constructor, which will copy every element of tigers into cats

for(int i=0; i < cats.size(); i++)
{  
  cats[i]->Meow();
}

Cat **ppCat;
Tiger **ppTiger = new Tiger*[MAX_TIGERS]; 
//(then allocate for each ptr...)

ppCat = ppTiger; //COMPILE ERROR!

(*ppCat)->Meow();

Think about it this way: Pointers to base classes can point to objects of derived classes (nothing new here), but when you use double indirection, you specify the exact type the first level of indirection points to. To clarify, ppCat can only point to a pointer to cat (the first level), but *ppCat (the second level) is just a pointer to cat, so it can also point to derived classes.

quote:

---

Original post by fallenang3l

Think about it this way: Pointers to base classes can point to objects of derived classes (nothing new here), but when you use double indirection, you specify the exact type the first level of indirection points to. To clarify, ppCat can only point to a pointer to cat (the first level), but *ppCat (the second level) is just a pointer to cat, so it can also point to derived classes.

---

I came across this issue when I had a function that needed a double pointer as a parameter, something like:

HRESULT Makebuffer( Bufferbase **ppBB, DWORD flags )
{
//...allocate memory stuff...

   switch(flags) {
      case FLAG1: *ppBB = new Flag1Buffer; 
                  break;
      //etc.

   }
}

//Somewhere else...

Bufferbase *pBB;
Makebuffer( &pBB, flags );

...and on a whim one time I tried to pass in an inherited class instead of a base class.

In some experimenting I also discovered this:

   

void CatsMeow( Cat* pCat )
{
    pCat->Meow();
}
   
void CatsMeowRef( Cat*& pCat )
{
    pCat->Meow();
}

int main(void)
{
    Cat *mycat = new Cat;
    Tiger *mytiger = new Tiger;  //tiger derived from cat


    CatsMeow(mycat);//legal

    CatsMeow(mytiger);//legal


    CatsMeowRef(mycat); //legal

    CatsMeowRef(mytiger); //illegal

    
    return 0;
}

edit: typos...

[edited by - Scint on April 16, 2004 1:53:14 AM]