"error: incomplete type is not allowed"

I've been coding for a long time, and never have I faced this error message before. I am writing a compiler for a language that dynamically compiles itself on other platforms.. while the specifications for that are not the problem, it's an odd problem I got when I tried "modularizing" my applications with C++ and classes.

Code:

---

struct Type ;
  struct Class ;
  struct Function ;
  struct Variable ;
  struct Definition ;
 
  typedef std::deque<std::string> StringList ;
  typedef StringList::iterator RegisteredString;

  typedef std::deque<Type> TypeList ;
  typedef TypeList::iterator RegisteredType;

  typedef std::deque<Class> ClassList ;
  typedef ClassList::iterator RegisteredClass;

  typedef std::deque<Variable> VariableList ;
  typedef VariableList::iterator RegisteredVariable ;

  typedef std::deque<Function> FunctionList ;
  typedef FunctionList::iterator RegisteredFunction ;

  enum Level {
        Private, Public, Protected
  } ;

#include <Type.hpp> // requires class
#include <Variable.hpp> // requires type
#include <Function.hpp> // requires type / variable
#include <Class.hpp> // requires variable / function
#include <Definition.hpp> // requires everything

---

Type.hpp

Code:

---

struct TETRA Type
{
  RegisteredClass rc ;
  dword array_depth ;
  dword flags ;

  operator == (const Type & t) ;
  operator != (const Type & t) ;
} ;

---

Variable.hpp

Code:

---

struct TETRA Variable
{
  RegisteredString name ;
  RegisteredType type ;

  Level level ;

  operator== (const Variable & v) ;
  operator!= (const Variable & v) ;

  operator== (const Function & f) ;
  operator!= (const Function & f) ;

  operator== (const Class & c) ;
  operator!= (const Class & c) ;

  operator std::string () ;
} ;

---

Function.hpp

Code:

---


struct TETRA Function
{
  RegisteredString name ;
  RegisteredType type ;
  Level level ;

  VariableList arguments ;
  VariableList variables ;

  RegisteredVariable AddVariable (const Variable & v) ;
  RegisteredVariable AddArgument (const Variable & v) ;

  operator== (const Variable & v) ;
  operator!= (const Variable & v) ;

  operator== (const Function & f) ;
  operator!= (const Function & f) ;

  operator== (const Class & c) ;
  operator!= (const Class & c) ;

  operator std::string () ;
} ;

---

Class.hpp

Code:

---

struct TETRA Class
{
  RegisteredString name ;

  VariableList members ;
  FunctionList functions ;

  operator== (const Variable & v) ;
  operator!= (const Variable & v) ;

  operator== (const Function & f) ;
  operator!= (const Function & f) ;

  operator== (const Class & c) ;
  operator!= (const Class & c) ;

  operator std::string() ;

  RegisteredVariable AddMember (const Variable & v) ;
  RegisteredFunction AddFunction (const Function & f) ;
}
;

---

Definition.hpp ( I don't think it matters, but whatever. )

Code:

---

struct TETRA Definition
{
  StringList strings ;
  TypeList types ;
  ClassList classes ;

  Definition () ;

  RegisteredType AddType (const Type & t) ;

  inline idx GetTypeIndex (const RegisteredType rt) {
        return (idx) (rt - types.begin()) ;
  }
 
  void ReadTypes (std::istream & is, dword count) ;
  void WriteTypes (std::ostream & os) ;

  RegisteredString AddString (const std::string & s) ;
 
  inline idx GetStringIndex (const RegisteredString rs) {
        return (idx) ( rs - strings.begin () ) ;
  }

  void WriteStrings (std::ostream & os) ;
  void ReadStrings (std::istream & is, dword count) ;

  RegisteredClass AddClass (const Class & c) ;

  RegisteredClass FindClass (const std::string & s) ;
  RegisteredClass FindClass (const RegisteredString s) ;

  void Read (std::istream & is, dword flags) ;
  void Write (std::ostream & os, dword flags) ;

  ~Definition () ;
} ;

---

I get about ~60 error messages from the headers, usually something like

Compiling with Intel C++ 8.0
String.cpp
c:\Program Files\Microsoft Visual Studio .NET\Vc7/include/deque(59): error: incomplete type is not allowed
_DEQUESIZ = sizeof (_Ty) <= 1 ? 16
^
detected during instantiation of class "std::deque<_Ty, _Ax> [with _Ty=Tetra::Type, _Ax=std::allocator<Tetra::Type>]" at line 49 of "D:\tetra\runtime\Tetra.hpp"

I can paste them all if necessary, I don't want the flood this topic however. Any help is appreciated, and if you have questions about what I am doing in the code just ask. My forte is C and lowish level stuff, I'm really just now starting to dabble in STL and C++.

Thanks in advance.

The problem is that std::deque<C>::deque probably requires the definition of C to be present. For instance, it might have code such as C* c = new C[45]. The compiler cannot allocate memory without knowing the size of C. And without knowing the full type of C, the compiler doesn't know what fields C has.

Everytime i've encountered something with circular references before, forward declarations have fixed it. Why not in this example?

Quote:

---

Everytime i've encountered something with circular references before, forward declarations have fixed it. Why not in this example?

---

Try this:

Code:

---

class Car;
class Apple;

class Apple
{
        Car aCar;
};

class Car
{
        Apple anApple;
};

int main()
{
       
       

        return 0;
}

---

I don't see where i'm doing that... I assume it's in some STL container that I don't understand.

First file... all the typedefs... then the #includes with the definitions.

It's obviously not the typedefs, since what I was doing there is legal. I wrote a small workaround with the typedefs still in front and it worked. I suppose it must be an oddity in Microsoft's implementation of the STL.

Code:

---

struct Type ;
  struct Class ;
  struct Function ;
  struct Variable ;
  struct Definition ;

  template<class T> struct Registered {
        T * data ;
        idx index ;

        Registered () {        }

        Registered (const Registered<T> & r)
        {
          data = r.data ;
          index = r.index ;
        }

        Registered(T & d, idx i) {
          data = &d ;
          index = i ;
        }

        operator= (const Registered<T> & r)
        {
          data = r.data ;
          index = r.index;
        }

        T & operator* () const { return *data ; }
  } ;
 
  typedef std::deque<std::string> StringList ;
 
  typedef StringList::const_iterator StringIter ;
  typedef Registered<std::string> RegisteredString;

  typedef std::deque<Type> TypeList ;
  typedef Registered<Type> RegisteredType;

  typedef std::deque<Class> ClassList ;
  typedef Registered<Class> RegisteredClass;

  typedef std::deque<Variable> VariableList ;

  typedef Registered<Variable> RegisteredVariable ;

  typedef std::deque<Function> FunctionList ;
  typedef Registered<Function> RegisteredFunction ;

---

Quote:

---

Everytime i've encountered something with circular references before, forward declarations have fixed it. Why not in this example?

---

The preprocessor expands #include "type.hpp" inplace in the file. The definition of Type uses a RegisteredClass. RegisteredClass is a type alias for typedef ClassList::iterator. ClassList is a type alias for std::deque<Class>. Class hasn't been defined before in your source. So, std::deque gets an incomplete type for one of it's template parameters and likely uses this incomplete type.

well since I fixed my problem and it works now i'll stop replying after this post, but forward declarations let you do that ;/ it's defined later in the source so it isn't "incomplete"

Quote:

---

well since I fixed my problem and it works now i'll stop replying after this post, but forward declarations let you do that ;/ it's defined later in the source so it isn't "incomplete"

---

The forward declaration only let's you use the type in certain ways, for instance, as a pointer. But some uses of an incomplete type aren't permited. For instance, you can't use sizeof(T) if T is incomplete. You can't define a variable of type T if T is incomplete. These rules make it possible for C++ translation unit to be compiled in one pass. By incomplete, I mena at that specific point in the source. Eventually the type gets fully defined. Other languages such as Java don't hav this restriction.