Don't want to define derived class?

[Immortal Nephi]

The rule of inheritance states that you define from top to bottom.
Sometimes, you want to define base class and set reference from
dervied class to base class, but you violate the rule.
Here is an example of my code below.

class A {};
class B : public A {};

int main(void)
{
// A a;
B &b = a; // Compiler cannot compile -- error
// B &b = reinterpret_cast<B&> ( a ); // OK

B b;
A &a = b; // OK

return 0;
}

Please state your opinion. Is it ok to violate the rule? is this
code portable to all different machines?

Nephi

 

[Ian Collins]

The rule of inheritance states that you define from top to bottom.
Sometimes, you want to define base class and set reference from
dervied class to base class, but you violate the rule.
Here is an example of my code below.

class A {};
class B : public A {};

int main(void)
{
// A a;
B &b = a; // Compiler cannot compile -- error
// B &b = reinterpret_cast<B&> ( a ); // OK

B b;
A &a = b; // OK

return 0;
}

Please state your opinion.

You are lying to the compiler and asking for trouble.

Is it ok to violate the rule?
No.

is this code portable to all different machines?

Undefined behaviour is never portable.

 

[acehreli]

        The rule of inheritance states that you define from top to bottom.
Sometimes, you want to define base class and set reference from
dervied class to base class, but you violate the rule.

Sometimes it is possible.

        Here is an example of my code below.

class A {};
class B : public A {};

int main(void)
{
//      A a;
        B &b = a; // Compiler cannot compile -- error
//      B &b = reinterpret_cast<B&> ( a ); // OK

You are downcasting at compile time. Use a static_cast there. BUT! In
order to downcast, you must have a pointer to or a reference to a
base, that is actually pointing to or a reference to the correct
derived type.

For example, if you're doing that cast in a function that takes a
Base&

struct Base
{
virtual ~Base()
{}
};

struct Derived1 : public Base
{};

struct Derived2 : public Base
{};

void foo(Base & b)
{
Derived1 & d = static_cast<Derived1&>(b); // compile time
downcast
}

int main()
{
Derived1 one;
Derived1 two;

foo(one); // fine
foo(two); // undefined behavior in foo
}

Another option is to use dynamic_cast as a question "is this base
actually a Derived1?":

Derived1 * d = dynamic_cast<Derived1*>(&b);

if (d) {
// yes it is
}

Ali

 

[Erik Wikström]

The rule of inheritance states that you define from top to bottom.
Sometimes, you want to define base class and set reference from
dervied class to base class, but you violate the rule.
Here is an example of my code below.

class A {};
class B : public A {};

int main(void)
{
// A a;
B &b = a; // Compiler cannot compile -- error
// B &b = reinterpret_cast<B&> ( a ); // OK

B b;
A &a = b; // OK

return 0;
}

Please state your opinion. Is it ok to violate the rule? is this
code portable to all different machines?

Absolutely not, consider the following code:

class Base
{
public:
virtual ~Base() {}
};

class Derived
{
int i;
public:
void foo() { i = 1; }
};

int main()
{
Base a;
Derived& b = reinterpret_cast<Derived&>(a);

b.foo();
}

When I run foo(), exactly what memory is it that I set to 1? When I run
this in VS2008 I overwrite the vtable pointer but.

You can never cast a class of base type to a class to derived type since
there does not exist a is-a relation in that direction (i.e. which a
derived class is a base class, a base class is not a vehicle. That would
be the same thing as saying that a vehicle is a car just because a car
is a vehicle).

 

[Immortal Nephi]

Absolutely not, consider the following code:

class Base
{
public:
  virtual ~Base() {}

};

class Derived
{
  int i;
public:
  void foo() { i = 1; }

};

int main()
{
  Base a;
  Derived& b = reinterpret_cast<Derived&>(a);

  b.foo();

}

When I run foo(), exactly what memory is it that I set to 1? When I run
this in VS2008 I overwrite the vtable pointer but.

You are correct that vtable pointer is overwritten. For example,
you place member variables in base class. You set reference to
derivd1 class and derived2 class. Then, you try to modify member
variable in derived1 class "AND" derived2 class which they are
inherited from base class. It does not have any problem. Sharing
member variables from base class to both derived classes are fine.
According to my test, both derived1 and derived2 classes can use
member variables from base class without any problem. If you try to
use member variables inside derived1 class and derived2 class, then
yes, you can notice. Attempt to modify derived1's member variables
overwrites derived2's member variable. Member variables in base class
are unaffected.
Friend keyword is the only option if they want to share member
variables in both two base classes. Note--static member variables are
not the option if you want to use friend keyword.

Nephi