Can't upcast pointer to pointer argument

Question

I can't understand anything here. I expected that if I can pass a dog pointer to function taking animal pointer, I could also pass the &dog to a function that takes a pointer to pointer of Animal.

struct Animal{};
struct Dog : Animal{};

void ptrToPtr(Animal** arg){}
void refToPtr(Animal*& arg){}
void refToConstPtr(Animal* const & arg){}
void ptrToConstPtr(Animal* const * arg){}

int main(void)
{
    Dog* dog;
    Animal* animal;

    ptrToPtr(&animal); // Works
    ptrToPtr(&dog); // Argument of type Dog** is incompatible with argument of type Animal**

    refToPtr(animal); // Works
    refToPtr(dog);      // A reference of type Animal*& (not const-qualified) cannot be initialized with a value of type Dog*

    ptrToConstPtr(&animal); // Works
    ptrToConstPtr(&dog);    // Argument of type Dog** is incompatible with paramater of type Animal* const*

    refToConstPtr(animal); // Works
    refToConstPtr(dog);  // Works. This is the only one that allows me to send Dog to Animal

    return 0;
}

I just don't get it, can anyone explain what the reasons are for why particular cases work and others don't? Like passing the dog pointer address to the Animal**, that would be an upcast, wouldn't it?

*interconvertible* pointer types are pointers to objects of a derived/base type. A pointer to a pointer isn't *interconvertible* with other types. Same applies to references. — WhiZTiM, Aug 27 '17 at 13:04
If you could do `ptrToPtr`, you could do `*arg = new Cat;` and `dog` would no longer point to a `Dog`. — molbdnilo, Aug 27 '17 at 13:43

WhiZTiM · Answer 1 · 2017-08-27T15:18:23.660

interconvertible pointer types are pointers to objects of a derived/base type. A "pointer to a pointer" isn't interconvertible with other types (with the exception of void*). Same applies to references.

This means that given any hierarchy below:

struct Animal{};
struct Dog : Animal{};

And the following variables:

Dog* dptr;
Animal* aptr;

dptr can be converted to Animal* (even implicitly), likewise aptr can be converted to Dog* (but not implicitly). Because: up-casting in a class hierarchy is always legal, hence this will be done implicitly by ICS. However, down-casting isn't always so, so its never done implicitly)

However:

Dog** ddptr;
Animal** aaptr;

ddptr cannot be implicitly converted to Animal**, likewise aptr cannot be converted to Dog**. Because, they are two different types with no hierarchical relationship.

The above explanation explains why the pointer to pointer overloads fail. That said, let's deal with the reference type overloads. From your code,

refToPtr(animal); // Works
refToPtr(dog);      // A reference of type Animal*& (not const-qualified) cannot be initialized with a value of type Dog*

the second call doesn't work because non-const references of say X can only be bound to an exact glvalue object of X. Since refToPtr takes a non-const reference to a Animal* type, we can only pass it glvalues of Animal* type, which animal is, but dog isn't.

the last one works, and it's legal because

refToConstPtr(animal); // Works
refToConstPtr(dog);    // Works. This is the only one that allows me to send Dog to Animal

const references of say X can be bound to any value catagory of X, including temproaries whose lifetimes are extended. Since since we can convert dog to Animal*. That conversion takes place and a temporary Animal* is produced whose lifetime is extended by the const reference.

When you say cannot be implicitly converted, can you force it? I suppose I can with a void pointer. — Zebrafish, Aug 27 '17 at 13:24
@Zebrafish, yes, you can force it. You don't need to go through the `void*` route. You may use `static_cast(baseObjectPtr)` if you are absolutely sure `*baseObjectPtr` was originally of type `Derived`. Or `dynamic_cast(baseObjectPtr)` if you can't be certain... **But no**, this doesn't apply to your question. Because `Animal**` has no relationship with `Dog**` — WhiZTiM, Aug 27 '17 at 13:28

Can't upcast pointer to pointer argument

1 Answers1