Forward declaration owned my ass apparently...

I have a head ache. -.-

Code:

class ENTITY;
class UNIVERSE
{
public:
	void insert_entity(ENTITY *entity)
	{
		m_entities.push_back(entity);
	}

	void tick()
	{
		for(std::list<ENTITY*>::iterator i=m_entities.begin(); i != m_entities.end(); ++i)
		{
			(*i)->instantiate(); // use of undefined type 'RITZ::PHYS::ENTITY'
		}
	}

private:
	std::list<ENTITY*> m_entities;
};

class ENTITY
{
...
};

It isn't like I've never forward declared a class before... Why is my compiler whining, and why does it have no problem with all the previous uses of the "undefined" class ENTITY.

You can't declare an object of a class until you define it. Forward declaration only allows you to address that you'll have definitions for it later. Until it's defined you can only use the name of the class.

Code:

// This is legal
#include <iostream>

class CLASS2;

class CLASS1 {
   public:
      void myMethod1(CLASS2);
};

class CLASS2 {
   public:
      void myMethod2() { std::cout << "Inside myMethod2"; }
};

void CLASS1::myMethod1(CLASS2 c2Obj) { c2Obj.myMethod2(); }

Code:

// This is illegal
#include <iostream>

class CLASS2;

class CLASS1 {
   public:
      void myMethod1(CLASS2 c2Obj) { // c2Obj is an incomplete type
         c2Obj.myMethod2();
   }
};

class CLASS2 {
   public:
      void myMethod2() { std::cout << "Inside myMethod2"; }
};

This I know. I'm not declaring any instance of the class.

Excuse me for not being positive about std::lists, but isn't

Code:

(*i)->instantiate();

the method instantiate a method of your ENTITY class, not list? That is why you're dereferencing it, correct? I also like that you define your code under the RITZ namespace.

What's wrong with that? I can't call a member function?

...and that's all wonderful, unfortunately, if it's defined in the ENTITY class, the it can't be used before it's declaration. Forward declaration of the class doesn't tell the compile to assume that all methods you address with the class will be defined later.

Code:

// This is still illegal
#include <iostream>
#include <list>

class CLASS2;

class CLASS1 {
   public:
      void myMethod1() { // c2Obj is an incomplete type
         for(std::list<CLASS2*>::iterator i = c2List.begin(); 
             i != c2List.end(); ++i)
         (*i)->myMethod2(); // invalid use of undefined type 'struct CLASS2'
   }
   private:
      std::list<CLASS2*> c2List;
};

class CLASS2 {
   public:
      void myMethod2() { std::cout << "Inside myMethod2"; }
};

int main() {
    CLASS1 c1Obj;
    
    c1Obj.myMethod1();
    
    return 0;
}

Ok, I thought you could still access members. You can use any potential member you want with templates after all and you won't get an error until the code is generated.

I also like that you define your code under the RITZ namespace.

The worst is when headers #define constants so you can't even defeat their duplicate naming with a namespace.

Code:

namespace N
{
    const unsigned long INFINITE = 0xffffffff;
}

If windows.h is included N::INFINITE becomes literally N::0xffffffff.