Creating instance of nested class - c++

Question

I have code like this:
class outer{
int x;
class inner{
int y;
}
void print(int t_x){
std::cout << t_x;
}
}
Is there a way to create only instance of class inner? And if this is possible, will this object have acces to outer::print function ?

Answer 1

Is there a way to create only instance of class inner?
Yes, you can let have outer creating as many instance independent instances (e.g. as static members or local variables in static member functions) of inner as you want.
And if this is possible, will this object have acces to outer::print function ?
No. outer::print() is only available with an instance of outer, so at least a parameter or a local instance of outer will be needed.
The outer and inner class declarations are completely independent regarding instantiation. It's only about the scope:
The inner type is only seen at the private outer class scope (can be circumvented using anonymous auto types outside of outer received through functions)
inner has access to any public, protected and private members of outer (special scope priviledges)
outer has access to any public members of inner as usual (no special priviledges)

Answer 2

That's called a nested class, not an inner class.
The most frequent use case of nested classes are iterators of standard library. Their templates are declared in related container templates.
To create an instance of nested class, one should have access to its declaration. It can be instantiated only from outer class or from a friend of that class.
class outer{
int x;
class inner;
public:
void doThings();
};
class outer::inner
{
public:
void print(class outer *p)
{
std::cout << "x=" << p->x;
}
};
void outer::doThings()
{
outer::inner a;
a. print(this);
}
int main()
{
outer a;
a.doThings();
return 0;
}
Methods of outer::inner will have access to private and protected members of outer
9.7 Nested class declarations [class.nest]
1 A class can be declared within another class. A class declared
within another is called a nested class. The name of a nested class is
local to its enclosing class. The nested class is in the scope of its
enclosing class. [ Note: See 5.1 for restrictions on the use of
non-static data members and non-static member functions. —end note ]
int x;
int y;
struct enclose {
int x;
static int s;
struct inner {
void f(int i) {
int a = sizeof(x); // OK: operand of sizeof is an unevaluated operand
x = i; // error: assign to enclose::x
s = i; // OK: assign to enclose::s
::x = i; // OK: assign to global x
y = i; // OK: assign to global y
}
void g(enclose* p, int i) {
p->x = i; // OK: assign to enclose::x
}
};
};
inner* p = 0; // error: inner not in scope
2 Member functions and static data members of a nested class can be
defined in a namespace scope enclosing the definition of their class.
struct enclose {
struct inner {
static int x;
void f(int i);
};
};
int enclose::inner::x = 1;
void enclose::inner::f(int i) { / ... / }
3 If class X is defined in a namespace scope, a nested class Y may be declared in class X and later defined in the definition of class X
or be later defined in a namespace scope enclosing the definition of
class X.
class E {
class I1; // forward declaration of nested class
class I2;
class I1 { }; // definition of nested class
};
class E::I2 { }; // definition of nested class
4 Like a member function, a friend function (11.3) defined within a
nested class is in the lexical scope of that class; it obeys the same
rules for name binding as a static member function of that class
(9.4), but it has no special access rights to members of an enclosing
class.