Nooblet question regarding inheritance

Just a quick question regarding class hierarchy movement... I've googled and looked a tutorials, but just thought a human point-of-view would be more reliable as my exact answer I did not find.

I'm trying to figure out why the following doesn't work.. the dynamic_cast I would think should work, but it complains that the pointer being dynamically cast isn't a polymorphic type. I would think since dynamic_cast is a run-time thing it would recognize that I'm trying to cast from class C up to class B. Anyways my ultimate questions are:

1 - If the pointer is to a base class can I safely use new to have it create a derived class.

Code:

A *test = new C;  // <--- This valid?  I assume it is

2 - If I were to replace the dynamic_cast in the following code with a non-checked cast is it valid?

Code:

A *test = new C;  B *foo = (B*)(test);

Code:

class A{
public:
  void set(int z){a = z;};
  int a;
};

class B : public A{
public:
  int c;
  void hello(){};
  void set(int z){b = z;};
  int b;
};

class C : public B{
public:
  void set(int z){c = z;};
  int c;
};


int main()
{
  A *test = new C;

  B *foo = dynamic_cast<B*>(test);  // I understand why it fails because the pointer is technically of class A, but is this safe?  
  foo->set(1);
  delete test;

  return 0;
}

1 - If the pointer is to a base class can I safely use new to have it create a derived class.

Yes, but if you use new, you should use delete... and if you delete an object of a derived class via a pointer to its base class, the base class destructor must be virtual or the behaviour is undefined.

2 - If I were to replace the dynamic_cast in the following code with a non-checked cast is it valid?

In this case since you know that the underlying object is of a derived class of B, it should work... but why use a C-style cast, and if you do not need it, why use dynamic_cast?

Your classes don't contain virtual functions. In particular, if polymorhism was at work here, all set's should call C::set. Without the virtual keyword they don't.

Code:

#include <iostream>

class A{
public:
  //virtual  //uncomment to see the difference
  void set(int z){std::cout << "A::set\n"; a = z;};
  int a;
};

class B : public A{
public:
  int c;
  void hello(){};
  void set(int z){std::cout << "B::set\n"; b = z;};
  int b;
};

class C : public B{
public:
  void set(int z){std::cout << "C::set\n"; c = z;};
  int c;
};


int main()
{
  A *test = new C;
  test->set(1);
  B *foo = static_cast<B*>(test);  // I understand why it fails because the pointer is technically of class A, but is this safe?
  foo->set(1);
  C *bar = static_cast<C*>(test);
  bar->set(1);
  delete test;

  return 0;
}

However, if that is what you want, it seems that you can create a simple instance and call the desired version of set manually (not that it seems like a really great way to use classes and inheritance):

Code:

#include <iostream>

class A{
public:
  void set(int z){std::cout << "A::set\n"; a = z;};
  int a;
};

class B : public A{
public:
  int c;
  void hello(){};
  void set(int z){std::cout << "B::set\n"; b = z;};
  int b;
};

class C : public B{
public:
  void set(int z){std::cout << "C::set\n"; c = z;};
  int c;
};


int main()
{
  C test;
  test.set(1);
  test.B::set(1);
  test.A::set(1);

  return 0;
}

Unless you are simply experimenting to see how dynamic_cast works, forget about it until you really think you need it. Read about polymorphism and the Liskov Substitution Principle. That is how you should be using public inheritance.

I understand why it fails because the pointer is technically of class A, but is this safe?

If it fails, how can it be safe? But you apparently don't understand why it fails. The reason it fails is that A has no virtual functions and as such is not polymorphic - dynamic_cast simply won't work with it. The compiler should fail to compile this:

Code:

dyn.cpp:14: error: cannot dynamic_cast ‘a’ (of type ‘struct A*’) to type ‘struct B*’ (source type is not polymorphic)