I put all objects in "Object[x]" by using the object superclass. How can I tell "Object[x]" to call the cChild classes after it has been constructor-ed as a cChild object?

Here is my code:

--- EDIT ---
The output is:

"MAIN(): New Objects - cChild"
"Object created"
"Child created"
"Object created"
"Child created"

"MAIN(): Object->something();"
"Object called"
"Object called"

"MAIN(): delete Object[]"
"Object destroyed"
"Object destroyed"

there are some casting operators, like
dynamic_cast and static_cast,

I think that the array of pointers to cObject, cannot use anything from cChild, unless you define virtual methods or use a cast.

Don't you have to make the methods virtual? I think that'll fix it.

How would you make a constructor / destructor 'virtual'?

----- EDIT -----
making the superclass (cObject) void something() virtual, worked. I only need to put this on superclasses right?

I belive so. And maybe make the destructor virtual too... "I think"

class BaseClass {
   public:
      virtual ~BaseClass(); // not sure if thats valid though, I assume it is.
   ...
}

OK, I cannot make constructors virtual but I can make destructors virtual.
Also when I make destructors virtual, then both destructors are called.
So here is the code updated:

Output:
"MAIN(): New Objects - cChild"
"Object created"
"Child Created"

"MAIN(): Object->something();"
"Child called"

"MAIN(): delete Object[]"
"Child destroyed"
"Object destroyed"

Notes:
I put virtual on the superclass
- virtual void something();
- virtual ~cObject();

With constructors, cObject is called first then cChild's.
With destructors, cChild is called first then cObject's.

Code update compared with previous, I am only using 1 object now to make it easier...

1) you can't make constructors virtual since it's completely pointless - how should virtual constructor be different from non-virtual one?
2) base class constructor is always called before derivate class constructor and base class destructor is always called after derivate class destructor, no matter they are virtual or not

maybe I should just leave the constructors and destructors empty for superclasses then

In every destructor you should free memory allocated by that constructor. Don't make your child delete memory which was allocated by the base constructor, because you are likely forget to copy that code in another child destructor, generating a memory leak.

Yeah, use ctors/dtors for what they are useful for. In polymorphism, use them to initialize elements in that class alone.

Destructors should be virtual if you ever delete an object through a pointer-to-base type. Usually I make destructors always virtual if I'm using inheritance, just to be safe.

Quite right.

Also quite right.

At least initialize all member variables. Wise practice.

So the problem is all solved then?

ReyBrujo is right. Some example should help understanding it.

class cBase {
 public:
  char *bunch_of_bytes;

  cBase() { bunch_of_bytes = new char[100]; }
  virtual ~cBase() { delete bunch_of_bytes; }
};

class cDerived : public cBase {
 public:
  char *another_bunch_of_bytes;

  cDerived() { another_bunch_of_bytes = new char[50]; }
  virtual ~cDerived() { delete another_bunch_of_bytes; }
};

Base class allocates some memory. When derived class constructor is called, it can assume that base class is fully initialized, since its constructor was called and allocated the memory. Now, derived class wants to allocate some more memory. Derived class destructor has only to free memory allocated in derived class constructor, since base class destructor gets called automatically after it and will free base class allocated memory.

[edit: forgot ': public cBase' in code]

Just be shure you dont do anything like this with your destructors.

You could also implement the base class functions as pure virtual.

virtual void Jump(int Height) = 0;

Edit : Beaten by a few hours.. ah well.

One more rule: If you have any virtual methods in a class, the destructor must be virtual, too. Otherwise, the child's destructor overwrites the parent's one, and the wrong destructors get called. At least, that's what my C++ book says.

That's right, but for the wrong reason. The destructor should be virtual if you can expect the class to be derived from at some point, and virtual methods are generally a good indicator of that.

You are not required to make a destructor virtual in any circumstance, but it is good style to make the destructor virtual if any of its methods are virtual. But as long as you always know the exact type of an object when you delete it, then you don't need virtual destructors. But, if you are using virtual methods, then you probably don't know the type at delete time, so if you have virtual methods, 99% of the time you'll want virtual dtors as well.