Thread: anonymous unions

>Are anonymous unions standard C?
No.

Right, so one person says yes, and the other says no.

I'd be inclined to believe Prelude is right - but I have a feeling it may be "confusion" about the concept of anonymous struct/union's here:

Code:

struct {
   // stuff goes here
} blah;

Is definitely allowed in the standard [I just looked it up]. Which is what I think tabstop meant.

However, another usage of "anynymous struct/union" is this one:

Code:

struct something 
{
   int x;
   int y;
};

struct someother
{
    struct something;    
    int z;
};

...
   struct someother a;
   a.x = 1;
   a.y = 2;
   a.z = 3;

This isn't allowed in the standard, but several mainstream compilers (gcc, MS) support this.

--
Mats

>I have a feeling it may be "confusion" about the concept of anonymous struct/union's
Quite likely. I was referring to the actual anonymous union extension in your second example. The first example I would call unnamed rather than anonymous. I'd also accept "anonymous" as a variant term for a compound literal in C99:

Code:

foo ( (struct bar) { .a = 0, .b = 1 } );

But that's a bit of a stretch.

Here's another fun one, the infamous struct hack:

Code:

#include <stdio.h>
#include <stdlib.h>

struct foo {
  int a;
  int b[1];
};

int main ( void )
{
  struct foo *p = malloc ( sizeof *p + 10 * sizeof ( int ) );
  int i;

  p->a = 10;

  for ( i = 0; i < p->a; i++ )
    p->b[i] = i * i;

  for ( i = 0; i < p->a; i++ )
    printf ( "%d\n", p->b[i] );

  free ( p );

  return 0;
}

Sadly, this abomination has been standardized in C99:

Code:

#include <stdio.h>
#include <stdlib.h>

struct foo {
  int a;
  int b[];
};

int main ( void )
{
  struct foo *p = malloc ( sizeof *p + 10 * sizeof ( int ) );
  int i;

  p->a = 10;

  for ( i = 0; i < p->a; i++ )
    p->b[i] = i * i;

  for ( i = 0; i < p->a; i++ )
    printf ( "%d\n", p->b[i] );

  free ( p );

  return 0;
}

Code:

  struct foo *p = malloc ( sizeof *p + 10 * sizeof ( int ) );

In your first example, should that be:

Code:

  struct foo *p = malloc ( sizeof *p + 9 * sizeof ( int ) );

??


--
Mats

>In your first example, should that be:
Not if you want to be absolutely safe across all implementation. I've seen a case where the implementation assumes a trailing array of size 1 is the struct hack (stupid, I know), and doesn't include it in the result of sizeof.

>And does "int b[]" contribute anything to the "sizeof *p" under C99?
No, "sizeof ( struct foo )" is equivalent to "offsetof ( struct foo, b )".

Originally Posted by KIBO

Are anonymous unions standard C?

Anonymous unions are standard C++, but not standard C.

Code:

#include <iostream>

int main() {
    union {
        int n;
        char c;
    };
    
    std::cin >> c;
    std::cout << n;

    return 0;
}

Basically, you declare a union with no tag and no instances, and you can access all members of the union by name with no prefix. In addition, the members behave like ordinary union members in that they occupy the same memory.