Here is an (artificial) example of using a function that returns an anonymous struct and does "something" useful:

#include <iostream>

template<typename T>
T* func( T* t, float a, float b )
{
    if(!t) 
    {
        t = new T;
        t->a = a;
        t->b = b;
    }
    else
    {
        t->a += a;
        t->b += b;
    }
    return t;
}

struct  
{
    float a, b;
}* foo(float a, float b)
{
    if(a==0) return 0;
    return func(foo(a-1,b), a, b);
}

int main()
{
    std::cout << foo(5,6)->a << std::endl;
    std::cout << foo(5,6)->b << std::endl;

    void* v = (void*)(foo(5,6));
    float* f = (float*)(v); //[1] delete f now because I know struct is floats only.

    std::cout << f[0] << std::endl;
    std::cout << f[1] << std::endl;

    delete[] f;

    return 0;
}

There are a few points I would like to discuss:

1. As is apparent, this code leaks, is there anyway I can NOT leak without knowing what the underlying struct definition is? see Comment [1].
2. I have to return a pointer to an anonymous struct so I can create an instance of the object within the templatized function func, can I do something similar without returning a pointer?
3. I guess the most important, is there ANY (real-world) use for this at all? As the example given above leaks and is admittedly contrived.

By the way, what the function foo(a,b) does is, to return a struct containing two numbers, the sum of all numbers from 1 to a and the product of a and b.

EDIT: Maybe the line new T could use a boost::shared_ptr somehow to avoid leaks, but I haven't tried that. Would that work?