🚀 go-pugleaf

hitz@sim5.csi.uottawa.ca (Martin Hitz) writes:
> struct X {
>         virtual f() { return 1; }
> };
> struct Y : X {
>         f() { return 2; }
> };
>
> main()
> {
>         X x;
>         Y * y = (Y *) &x;
>         cout << y->f();
> }
>
> The ARM explains the usual case, that a call of f() for an object of
> class Y invokes Y::f(), even if it is called via a pointer to X,
> but I couldn't find anything about the above case.

That's because it's an error.  See section 5.4 of E&S: "Such a cast from a
base to a derived class assumes that the object of the base class is a
sub-object of an object of the derived class; the resulting pointer points
to the enclosing object of the derived class.  If the object of the base
class is not a sub-object of an object of the derived class, the cast may
cause an exception."  In other words, the behavior is undefined, and an
implementation under which the program printed -356, or dumped core, or
erased your disk would be perfectly legitimate.

-- William M. Miller, Glockenspiel, Ltd.
   wmm@world.std.com

In article <1991Apr30.024010.4331@csi.uottawa.ca> hitz@sim5.csi.uottawa.ca (Martin Hitz) writes:

> #include <stream.h>

> struct X {
> 	virtual f() { return 1; }
> };

> struct Y : X {
> 	f() { return 2; }
> };

> main()
> {
> 	X x;
> 	Y * y = (Y *) &x;
> 	cout << y->f();
> }

The effects of things like this are undefined.

In this particular example, I expect that many implementations
will print 2, but the assignment

	Y * y = (Y *) &x;

is well-defined only if &x points at an object of class Y --
which, of course, it does not.
-- 
				--Andrew Koenig
				  ark@europa.att.com

In article <1991Apr30.024010.4331@csi.uottawa.ca> hitz@sim5.csi.uottawa.ca (Martin Hitz) writes:
|I wonder if the following is guaranteed to print 1:
|
|#include <stream.h>
|struct X {
|	virtual f() { return 1; }
|};
|struct Y : X {
|	f() { return 2; }
|};
|
|main()
|{
|	X x;
|	Y * y = (Y *) &x;
|	cout << y->f();
|}
|
|The ARM explains the usual case, that a call of f() for an object of
|class Y invokes Y::f(), even if it is called via a pointer to X,
|but I couldn't find anything about the above case. Zortech and g++
|both yield 1 for this example. Is this considered to be the standard
|behaviour?

What would a C++ compiler then do with the following?
[All that I'm aware of act in an ill-defined manner, which is expected
since the ARM prohibits such erroneous down-casts.  Your example just
happens to work on most C++ compilers]

extern "C" int printf(const char*, ...);

class A
{
	private: virtual void illegalToAccess() 
	{ printf("erroneous access of A private method\n"); }
	public: virtual void print() { printf("A\n"); }
};

class B
{
	public: virtual void print() { printf("B\n"); }
	private: virtual void illegalToAccess() 
	{ printf("erroneous access of B private method\n"); }
};

class AB: public A, public B
{
	public: virtual void print() { printf("AB\n"); }
};

main()
{
	A aA;
	B aB;
	A* a = &aA;
	((AB*)a)->print();
	B* b = &aB;
	((AB*)b)->print();

	return 0;
}