Can C++ use local variables inside a function whose type is automatically inferred from the function return type?

Question

My question: Say I'm defining a function in C++ (or in C). Is there anything similar to C++'s auto or decltype that I can use inside the function definition in order to declare a local variable with type inferred from the return type of the function that I'm defining?

Example: A common coding pattern in C and C++ is

SomeType foo() {
   SomeType x;
   // ... do something to x ...
   return x;
}

And I'm hoping to infer the second SomeType instead of typing it in explicitly. The following doesn't work, but I was hoping I could do something in this spirit

SomeType foo() {
   decltype(return) x;  //<-- infer the function return type, which here is SomeType
   // ... do something to x ...
   return x;
}

For simple return types it's not a big deal, but when return types are complicated (say the return type is a template class with lots of template parameters), it would be nice (and less error-prone) to not have to repeat that type definition inside the function.

I'd also like to not have to change the function definition to accomplish this. So, while in the example above it could work to change SomeType to a macro, or perhaps make foo a template function and SomeType a template parameter, really I'm looking to see if in general I can infer a type specifically from the return type of the surrounding function.

Maybe the answer is "no it's not possible", which is fair, but I'd like to know one way or the other.

Answer 1

In C++11:

SomeType foo()
{
    decltype(foo()) x;

The expression foo() has the same type as the return value of foo.