Templated class member VS Nested class forward declaration - c++

Question

Good evening everyone!
I'm stuck with an itchy problem. Say I have the following code :
#include <iostream>
template <class T>
struct MyTemplate {
int _array[sizeof (T)];
} ;
struct MyStruct {
struct MyNestedStruct {
int foo;
} ;
MyTemplate<MyNestedStruct> _nested;
} ;
int main(int, char **) {
return 0;
}
This example snippet compiles fine. What I would like to do is lift the definition of MyNestedStruct out of MyStruct :
#include <iostream>
template <class T>
struct MyTemplate {
int _array[sizeof (T)];
} ;
struct MyStruct {
struct MyNestedStruct;
MyTemplate<MyNestedStruct> _nested;
} ;
struct MyStruct::MyNestedStruct {
int foo;
} ;
int main(int, char **) {
return 0;
}
Of course this one doesn't compile since I'm requesting the size of a partially declared type (error: invalid application of ‘sizeof’ to incomplete type ‘MyStruct::MyNestedStruct’).
My real use case does need sizeof, but will also use several MyNestedClass-like template parameters in that fashion, each fully declared with constructors and the like. For this reason I don't want MyClass to get bloated. Can I do anything about it, or will I have to resort to an external scope (namespace) to put my "inner" classes in ?
Unless...
struct MyStruct {
#include "MyNestedStruct.h" // Dirty preprocessor to the rescue !
MyTemplate<MyNestedStruct> _nested;
} ;
Ugh.

Answer 1

Essentially we need to defer template instantiation of MyTemplate since that's the one that requires T to be complete. The trick I can see to do that here is to templatize MyStruct.
template <typename T>
struct MyTemplate {
int _array[sizeof(T)];
};
template <typename Dummy = void>
struct MyStruct {
struct MyNestedStruct;
MyTemplate<MyNestedStruct> _nested;
};
template <typename Dummy>
struct MyStruct<Dummy>::MyNestedStruct {
int foo;
};
int main() {}
Now we've deferred the instantiation of MyStruct, but we need to use MyStruct<> instead. If that's unsatisfactory, then just provide a type alias.
#include <iostream>
template <typename T>
struct MyTemplate {
int _array[sizeof(T)];
};
template <typename Dummy = void>
struct MyStructImpl {
struct MyNestedStruct;
MyTemplate<MyNestedStruct> _nested;
};
template <typename Dummy>
struct MyStructImpl<Dummy>::MyNestedStruct {
int foo;
};
using MyStruct = MyStructImpl<>;
int main() {
MyStruct s;
std::cout << sizeof(s._nested._array) << std::endl;
}
Prints 16.
Note: you could also to hide MyStructImpl in a detail namespace or something similar.