"X does not name a type" error in C++

Question

I have two classes declared as below: ``` class User { public: MyMessageBox dataMsgBox; }; class MyMessageBox { public: void sendMessage(Message *msg, User *recvr); Message receiveMessage(); vector<Message> *dataMessageList; }; ``` When I try to compile it using gcc, it gives the following error: MyMessageBox does not name a type

Accepted Answer

When the compiler compiles the class `User` and gets to the `MyMessageBox` line, `MyMessageBox` has not yet been defined. The compiler has no idea `MyMessageBox` exists, so cannot understand the meaning of your class member.

You need to make sure `MyMessageBox` is defined before you use it as a member. This is solved by reversing the definition order. However, you have a cyclic dependency: if you move `MyMessageBox` above `User`, then in the definition of `MyMessageBox` the name `User` won't be defined!

What you can do is forward declare `User`; that is, declare it but don't define it. During compilation, a type that is declared but not defined is called an incomplete type. Consider the simpler example:

```
struct foo; // foo is *declared* to be a struct, but that struct is not yet defined

struct bar
{
    // this is okay, it's just a pointer;
    // we can point to something without knowing how that something is defined
    foo* fp;

// likewise, we can form a reference to it
    void some_func(foo& fr);

// but this would be an error, as before, because it requires a definition
    /* foo fooMember; */
};

struct foo // okay, now define foo!
{
    int fooInt;
    double fooDouble;
};

void bar::some_func(foo& fr)
{
    // now that foo is defined, we can read that reference:
    fr.fooInt = 111605;
    fr.foDouble = 123.456;
}
```

By forward declaring `User`, `MyMessageBox` can still form a pointer or reference to it:

```
class User; // let the compiler know such a class will be defined

class MyMessageBox
{
public:
    // this is ok, no definitions needed yet for User (or Message)
    void sendMessage(Message *msg, User *recvr);

Message receiveMessage();
    vector<Message>* dataMessageList;
};

class User
{
public:
    // also ok, since it's now defined
    MyMessageBox dataMsgBox;
};
```

You cannot do this the other way around: as mentioned, a class member needs to have a definition. (The reason is that the compiler needs to know how much memory `User` takes up, and to know that it needs to know the size of its members.) If you were to say:

```
class MyMessageBox;

class User
{
public:
    // size not available! it's an incomplete type
    MyMessageBox dataMsgBox;
};
```

It wouldn't work, since it doesn't know the size yet.

On a side note, this function:

```
 void sendMessage(Message *msg, User *recvr);
```

Probably shouldn't take either of those by pointer. You can't send a message without a message, nor can you send a message without a user to send it to. And both of those situations are expressible by passing null as an argument to either parameter (null is a perfectly valid pointer value!)

Rather, use a reference (possibly const):

```
 void sendMessage(const Message& msg, User& recvr);
```

"X does not name a type" error in C++

Solution

Problem

Related problems