Using private nested type as parameter

Question

I'm getting this strange problem which I don't know why happens. The first and second of the following code snippets compile, while the third does not:

Compiles:

class Foo {
public:
    Foo() { Bar(); }

private:
    class Bar {};
};

Compiles:

class Foo {
    class Bar {};  // Or only forward declare here and define later

public:
    Foo(Bar) {}
}

Does not compile:

class Foo {
public:
    Foo(Bar) {}

private:
    class Bar {};
};

What makes the third fail to compile while the first can?

Answer 1

Normally, in C++, you can only reference declarations that were previously made in the translation unit. However, within a class definition, the definition of member functions are allowed to reference declarations which are made later in the class. Basically, the compiler restructures your in-class definitions so that they work as though they were written just after the class.

But this is only true of the function definitions. The declaration of the function (including parameter types) isn't allowed to do this. They can only reference declarations that have already been made in file order.

So you can do this:

class Test
{
    public:
      void Func(int x) {Inner foo;}

    private:
      class Inner {};
};

But not this:

class Test
{
    public:
      void Func(Inner x) {}

    private:
      class Inner {};
};

Answer 2

First example does not expose anything about private Bar to the outside, while third does.

Third example is pretty much saying, that there exist some class Foo, which has constructor with single argument of type Bar. But Bar is unknown to the outside. Imagine calling such constructor.

Foo f{Foo::Bar{}};

Will result probably in something like Foo::Bar is inaccessible.