Accessing outer class from inner class without explicitly passing an instance - c++

Question

The following code produces the output
outer::inner::inner, o=00000000
outer
outer::inner::val, o=00000000
outer::print
Can anyone explain how I can access the outer class method print through o without explicitly assigning o's value at construction?
Here o is null, but I can still invoke its methods.
I have tested this with MSVC 2017 and g++ 7.4.0 and the output is same.
#include <iostream>
class outer {
public:
outer() {
std::cout << __func__ << std::endl;
}
class inner {
outer *o = nullptr;
public:
inner() {
std::cout << __FUNCTION__ << ", o=" << o << std::endl;
}
void val() {
std::cout << __FUNCTION__ << ", o=" << o << std::endl;
o->print(); // **call outer class method**
}
};
inner i;
void print() {
std::cout << __FUNCTION__ << std::endl;
}
};
int main()
{
outer o;
o.i.val();
return 0;
}

Answer 1

You can simplify your example to
struct S
{
void f() { std::cout << "hello world\n"; }
};
int main()
{
S* s = nullptr;
s->f();
}
And dereferencing nullptr is UB. So anything can happen.
Why does it appear to work?
Because, in practice, method functions are generally implemented as if there were regular functions with extra parameter:
void S::f() -> void f(S*) (or void f(S&))
and so, code becomes:
void f(S* /*unused*/) { std::cout << "hello world\n"; }
int main()
{
S* unused = nullptr;
f(unused);
}
In that case, compiler transforms UB in valid code, as unused is not used, it doesn't crash and does what you expect.