validate my understanding (polymorphism, inheritance, static class usage, heap and stack usage seperation)

[aylictal]

updated code using std::string types rather than char*. string additionsconcatenations are possible now and I see what you originally meant by dynamic types.

// polymorphism test.cpp : Defines the entry point for the console application.
//

#include <iostream>
using std::cout;
using std::string;

class animal
{
protected:
	string message;
public:
	string name;
	animal()
	{
		this->message = "Hello from ";
		this->name = "SOMEANIMAL. I don't have a name yet :(";
		cout << this->message + this->name + "\n";
	}
	virtual void eats() = 0;
	virtual ~animal()
	{
		this->message = "Goodbye from ";
		if (this->name == "SOMEANIMAL. I don't have a name yet :(")
		{
		    this->name = "SOMEANIMAL.  REALLY? NO ONE EVER GAVE ME A NAME!? :(";
		}
		cout << this->message + this->name + "\n";
	}
};

class dog : public animal
{
public:
	void eats()
	{
		this->message = "dog bones";
		cout << this->name + " loves: " + this->message + "\n";
	}
};

class cat : public animal
{
public:
	void eats()
	{
		this->message = "cat food";
                cout << this->name + " loves: " + this->message + "\n";
	}
};

//a helper class which sets an animals name member
class animalNamer
{
public:
	static void setName(string param, animal *obj)
	{
		obj->name = param;
		cout << "I have a name now! It is: " + obj->name + "\n";
	}
};

int main()
{
	//two animals created on the heap and their names set with the static helper
	dog *Scooby = new dog;
	animalNamer::setName("Scooby", Scooby);
	cat *Garfield = new cat;
	animalNamer::setName("Garfield", Garfield);
	//eats is a pure virtual function which must be implemented in all derived animals
	Scooby->eats();
	Garfield->eats();
	//clean up the heap
	delete Scooby;
	delete Garfield;
	//an animal created on the stack
	dog StackDog;
	StackDog.eats();
	return 0;
}

[keskiverto]

Why is the message a member of the animal? You set it every time that you use it, so you could use a function-local variable or just a string literal:

void dog::eats()
{
  std::string message = "dog bones";
  cout << this->name + " loves: " + message + "\n";
}
// or
void dog::eats()
{
  cout << this->name + " loves: dog bones\n";
}

Use the class initializer list:

animal::animal()
: message("Hello from "), name("SOMEANIMAL. I don't have a name yet :(")
{
  cout << this->message + this->name + "\n";
}

Reconsider the standard library's smart pointers:
http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
http://en.cppreference.com/w/cpp/memory/unique_ptr
http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared
http://en.cppreference.com/w/cpp/memory/shared_ptr

[aylictal]

When you use the class initializer list, how do you know the type of message, or name, as you have written them? Or is that just explicitly defined in the declaration?

shouldn't it be:

animal::animal()
: string message("Hello from "), string name("SOMEANIMAL. I don't have a name yet :(")
{
  cout << this->message + this->name + "\n";
}

[keskiverto]

Those 'message' and 'name' are members of the class.

class animal {
  // member declarations
  std::string message; // message is a string
  std::string name;    // name is a string
public:
  animal() // default constructor
  : message("Hello from "), name("SOMEANIMAL. I don't have a name yet :(")
  {
      cout << this->message + this->name + '\n';
  }

  animal( const std::string & name ) // another constructor
  : message("Hello from "), name( name )
  {
      cout << this->message + this->name + '\n';
  }
};

However, the C++11 did introduce new forms. See http://www.informit.com/articles/article.aspx?p=1852519

class animal {
  // member declarations
  std::string message {"Hello from "};
  std::string name {"SOMEANIMAL. I don't have a name yet :("};
public:
  animal()
  {
      cout << this->message + this->name + '\n';
  }

  animal( const std::string & name )
  : name( name )
  {
      cout << this->message + this->name + '\n';
  }
};