Can unnamed structures inherit?

Question

The following looks like a compilation error :

struct : Base { };

Yet when used ^[1] it seems to work :

#include <iostream>
using namespace std;

template<bool B>
struct A 
{
    struct : std::integral_constant<bool, B> {
    } members;
};

int main()
{
    A<true> a;    
    cout << a.members.value << endl;
    return 0;
}

In c++ is it valid for unnamed structures to inherit? Are there any examples where this is userful?

^{^[1]Disclaimer: I'm not pretending the provided example is useful. I rarely use unnamed structs, and when I do they're usually bundling together some built-in member variables, in order to provide a cleaner interface for a class. The question came up from the observation that memberspaces need not be nammed structures}

the second example is valid. The use for it? Yet to be determined. — StoryTeller - Unslander Monica, Jun 01 '14 at 12:32
@lorro Wow, quite a throwback. Neat trick, but `std::tie` is the better approach IMO. — StoryTeller - Unslander Monica, Jun 24 '16 at 18:08
@StoryTeller: I don't really like std::tie as it requires you to first construct a possibly invalid object. What if it's a resource, what if we have no default constructor, what if it takes time / allocation to construct? To put it the other way, I hope some day we'll be allowed to declare variables anywhere, including inside std::tie (or make tie). It wouldn't be worse than inside for / if / while... — lorro, Jun 25 '16 at 17:41
@lorro, Rejoice, this seems to have made it into C++17 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf — StoryTeller - Unslander Monica, Jun 27 '16 at 05:57
Yippie :) - albeit I don't like the syntax, it's a quantum leap forward. — lorro, Jun 27 '16 at 07:02

Sergey Kalinichenko · Accepted Answer · 2014-06-01T12:39:40.020

Unnamed classes can inherit. This is useful, for example, in situations when you must inherit in order to override a virtual function, but you never need more than one instance of the class, and you do not need to reference the derived type, because a reference to the base type is sufficient.

Here is an example:

#include <iostream>
using namespace std;

struct Base {virtual int process(int a, int b) = 0;};
static struct : Base {
    int process(int a, int b) { return a+b;}    
} add;
static struct : Base {
    int process(int a, int b) { return a-b;}    
} subtract;
static struct : Base {
    int process(int a, int b) { return a*b;}    
} multiply;
static struct : Base {
    int process(int a, int b) { return a/b;}    
} divide;

void perform(Base& op, int a, int b) {
    cout << "input: " << a << ", " << b << "; output: " << op.process(a, b) << endl;
}

int main() {
    perform(add, 2, 3);
    perform(subtract, 6, 1);
    perform(multiply, 6, 7);
    perform(divide, 72, 8);
    return 0;
}

This code creates four anonymous derivations of Base - one for each operation. When the instances of these derivations are passed to the perform function, the proper override is called. Note that perform does not need to know about any of the specific types - the base type with its virtual function is enough to complete the process.

Here is the output of running the above code:

input: 2, 3; output: 5
input: 6, 1; output: 5
input: 6, 7; output: 42
input: 72, 8; output: 9

Demo on ideone.

score 9 · Answer 2 · answered Jun 01 '14 at 12:30

Your first example, because it doesn't declare anything, shows an attempt at an anonymous struct (which is not allowed - 7/3) rather than an unnamed one (which is).

The grammar in 9/1 of the C++11 standard seems to allow an unnamed class to have a base, so I think your second example is fine.

Can unnamed structures inherit?

2 Answers2

Linked