It would have been very weird if we had a type that hide your data and then couldn't recover it, that would be the sort of thing that shouldn't end up in the standard. Good thing that is not what happened.
Lest be charitable and assume you mean this code:
```
template<typename T>
void foo() { cout <<typeid(T).name()<<endl;}
auto useType(effdecltype(foo) f)
{
using T = __get_ortho_at__<0>(f);
f();
return T(0);
}
template<typename T>
void consumeType(T t)
{ cout << typeid(t).name(); }
int main()
{
vector<effdecltype(foo)> vec;
vec.push_back(&foo<int>);
vec.push_back(&foo<double>);
vec.push_back(&foo<float>);
for(int i=0; i<5; ++i)
vec.push_back(&foo<char>);
for(const auto& F: vec)
consumeType(useType(F));
}
```
It can be easy fixed by helper:
```
template<typename T>
void consumeTypeHelper()
{
foo<T>();
return consumeType(T{});
}
int main()
{
vector<void(*)()> vec;
vec.push_back(&consumeTypeHelper<int>);
vec.push_back(&consumeTypeHelper<double>);
vec.push_back(&consumeTypeHelper<float>);
for(int i=0; i<5; ++i)
vec.push_back(&consumeTypeHelper<char>);
for(const auto& F: vec)
F();
}
```
Done. Problem fixed in C++11
Very good... nice try.
Unfortunately you miss the point.
I showed a loop over a set of functions returning many types.
Imagine you have a container of slots, which returns different types ( i already said that many times)
Given the current state of C++ you can store them only as. Let say.
vector<std::any(*)(int, double)>
How can you tell what type the called function returned before it was hiden inside std::any?
Is it clear?