Returning anonymous struct

Question

It seems you can return an unnamed struct this way:

auto foo() {
    struct {
        int bar;

        int square() {
            return bar * bar;
        }
    } a { 7 };
    return a;
}

Is there anyway to do this without the redundant variable name a, thus anonymously?

Answer 1

I have no idea what the point of this exercise is, so here is an answer that technically does what you ask for:

auto helper()
{
    struct {
        int x;
    } a {0};
    return a;
}

decltype(helper()) foo()
{
    return {8};
}

https://godbolt.org/z/zA8C1V

• The struct is unnamed.

• foo does not return a named variable.

Of course this is straight up ridiculous - one would just name the struct instead of this decltype tomfoolery.

Answer 2

For starters C++ does not define anonymous structures. I think you mean an unnamed structure.

According ro the C++ Standard the return statement is defined like (8.6 Jump statements)

return expr-or-braced-init-listopt ;

So you may not use a declaration in the return statement. If so then you need prelimary to declare an object of the structure type that will be returned.

Answer 3

No, this is not possible.

The closest you can get is to use a functional-style cast to create a temporary, and use a C99-style scoped-initialiser; GCC allows this in C++ mode, as an extension:

#include <iostream>
#include <string>

auto foo() {
    return (struct {
        int bar;

        int square() {
            return bar * bar;
        }
    }) { 7 };
}

… but this is not portable (and will warn).

Without the braces around 7 the extension is not triggered, and you're back to standard code, in which it is illegal to define a type in a cast.

Instead of writing obtuse code, give your type a name and give your object a name. Your readers will thank you.

Answer 4

None of

struct {/*...*/} foo() { // Illegal
    return {/*...*/};
}

auto foo() {
    return struct { /*...*/ } { /*...*/ }; // Illegal
}

template <typename T = struct { /*...*/ }> // Illegal
T foo() {
    return { /*...*/ };
}

are legal.

You have to, at least, have a named type, or a named instance.

Lambda allows to have neither, but you can only capture and define its operator():

auto foo() {
    return [/*...*/](/*...*/) { /*...*/ }; // Legal
}

Answer 5

Returning anonymous struct

There is no such thing as anonymous struct in C++. That's enough to make it impossible.

There is a - limited - way of returning an object of anonymous type from a function: Returning a lambda.

auto make_square_function() {
    return [bar = 7]() {
        return bar * bar;
    };
}

Lambdas are much more limited than general classes though. The members (captures) are encapsulated and cannot be named from the outside of the lambda and there are no member functions other than the function call overload.

Is there anyway to do this without the redundant variable name a

Only if you give the class a name:

struct Squarer {
    int bar;

    int square() {
        return bar * bar;
    }
};

auto foo() {
    return Squarer{7};
}

Returning an instance of unnamed class is only possible by defining a variable.

Answer 6

Just for fun, another define-the-variable-in-another-function solution (taking inspiration from Max Langhof's answer)

auto foo ()
 {
   return []{ struct{int bar;} a {7}; return a; }();
 }

Answer 7

No, because you need to return an instance of an object, in this case a.

The returned object has to exist somewhere in memory, you can't just return a class definition.

In your example, you don't return an anonymous struct, but you return an instance of that struct.