Re: Covariant virtual function result types
On 2011-11-24 02:40, Lorenzo Caminiti wrote:
Hello all,
When invoking a covariant virtual function, the derived function body
is executed but the result type of the base function is returned. Is
there any way to get C++ to return the result type of the derived
function instead?
It would be great to elucidate the underlying mechanism of the above scenario to
us! There is nothing impossible in the Universe, after all... ;)
For example:
#include <iostream>
struct rx {};
struct ry : rx {};
struct x {
virtual rx* f() {
std::cout << "rx* f()" << std::endl;
return &rx_;
}
rx rx_;
};
struct y : x {
ry* f() {
std::cout << "ry* f()" << std::endl;
return &ry_;
}
ry ry_;
};
int main ( ) {
y yy;
y* yp = &yy;
x* xp = &yy;
ry* ryp = yp->f(); // calls y::f
rx* rxp = xp->f(); // calls y::f but returns rx* instead of ry*
// Nope! calls y::f() (due to a polymorphic behaviour supported by
// the virtual function mechanism combined with an indirect object
// access through a pointer) and interprets the memory layout the
// returned pointer pointed to as that of an object of type rx (due
// to the information available to the compilator, that is the type
// (x*) of the pointer xp and the return type (rx*) of x's member
// function f()).
// ry* nope = xp->f(); // error: calls y::f but returns rx* instead
of ry*
// Now, if we want to access back the rest of what f() actually has
// returned and then assigned to our impish rxp pointer, we may
// well do a couple of things but in order to preserve the spirit of
// that exemplary program either of the following statements work:
ry* yep1 = static_cast<ry*>(xp->f());
ry* yep2 = dynamic_cast<y*>(xp)->f();
return 0;
}
Here both yp->f() and xp->f() actually execute the body of the derived
class y (via dynamic binding). However, the compiler doesn't know that
until run-time so yp->f() returns a ry* but xp->f() returns a rx*
(even if y::f() which returns ry* is executed in both cases). Because
of that the declaration of nope doesn't compile because it uses ry*
instead of rx*.
That statement doesn't compile not because of that engrossing reasoning, but
because of what was commented within the main()'s body above.
Yes, with the invent of the virtual machinery the devil is neither in the detail
nor in the process any longer.
By the way, as you have already guessed, the whole exercise remains valid in the
case of a reference semantics as well.
Regards,
Yordan
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]