Why can't a class have a pointer to an instance of another class without forward declaration?

Question

I know it's impossible to do

class foo{
    foo bar;
};

Because the compiler wouldn't know how much memory to prepare for foo. But consider:

class A{
    B::C* foo;
};

class B{
    class C{
    };
};

It seems quite reasonable that the compiler would know exactly the size of A no matter the definition of the C. Why isn't this possible then? (Does the standard forbids that explicitly? for what?)

---

I got a very crude way by-pass the constraint that is to treat foo as a uintptr_t, then reinterpret_cast it back to C, this is just to show that I really don't get the (objective) reason, and I know it's a really really bad practice if used without decent reason.

---

Finally it turns out to be forbidden by the standard.

Answer 1

One big challenge is following:

class other {};

namespace N {
  class foo {
    other* p;
  };

  class other {};
}

Which other* should be considered? Too much of work for compiler. Though we can be explicit by ::other or N::other, it still creates confusion in above case.

Answer 2

TL;DR: That is because the standard dicates the syntax to be so. Unfortunately it's as simple as that.

This is the path I followed:

1. You open standard e.g. c++11 draft.

2. You seek section about classes it's section 9. You immediatietly see it has subsection "9.2 Class members". There is whole syntax defined. After some reading you get to member-declarator. The most important part in our context is declarator.

3. Section 8. Declarators. In p4. you have the syntax for declarator. After going through all the formal definition of the fancy syntaxes supported you will notice that it hinges on id-expression.

4. This is defined in 5.1.1 Primary Expressions. General ([expr.prim.general]). And it has to be a qualified-id of unqualified-id.

So your question could be rephrased to "Why does the namelookup not work like that?" But that is another question.

FWIW, not much I guess, but it's a design decision. It would need to keep track of all failed resolutions for the compilation unit. Doing lazy check in this context comes with quite far reaching implications.

Answer 3

After the example

class foo{
    other* bar;
    ...
};
class other{
    ...
}

… which (1) uses an undeclared name, and (2) lacks a crucial semicolon, you ask

” Why isn't this possible then? (Does the standard forbids that explicitly? for what?)

The Holy Standard requires that every name must be declared before it's used.

Note that in a given C++ implementation, even data pointers can be of different sizes (void* is guaranteed to be able to hold any data pointer), not to mention function pointers.

An alternative to declare-before-first-use requirement could be to adopt a default, like with implicit int in the early C days. E.g. the compiler could assume that other was a class type. But that would not be very helpful in general, and it would complicate the language.

However, in this particular case it's possible to combine the necessary minimum declaration of other with its first use:

class foo{
    class other* bar;
    //...
};

class other{
    //...
};

Alternatively you could use an ordinary forward declaration:

class other;

class foo{
    other* bar;
    //...
};

class other{
    //...
};

Just so the compiler knows that other is a class type, and not e.g. a function, or a synonym for char or void (pointers to these types are the largest, if there is any variability in the size of basic raw data pointers).

---

You then assert:

” The dummy example I posted above may seem have no real meaning. The reason why I want to do without forward declaration is that when you got a nested class, there's no forward declaration that can preserve the encapsulation.

That's wrong.

E.g. this works nicely:

class Foo
{
private:
    class Other;
    Other* bar;

    class Other{};

public:
    Foo(): bar( new Other ) {}
};

However, the shortcut with declaration in the first use, class Other* bar;, doesn't work in this case. That's because it effectively would declare Other as a namespace level class instead of a nested one.