¿Por qué C ++ no permite estructuras anónimas?

Algunos compiladores de C ++ permiten uniones y estructuras anónimas como una extensión de C ++ estándar. Es un poco de azúcar sintáctico que ocasionalmente es muy útil.

¿Cuál es la razón fundamental que impide que esto sea parte del estándar? ¿Existe un obstáculo técnico? ¿Uno filosófico? ¿O simplemente no es suficiente para justificarlo?

Aquí hay una muestra de lo que estoy hablando:

struct vector3 {
  union {
    struct {
      float x;
      float y;
      float z;
    };
    float v[3];
  };
};

Mi compilador aceptará esto, pero advierte que "estructura / unión sin nombre" es una extensión no estándar de C ++ .

Como otros han señalado, las uniones anónimas están permitidas en C ++ estándar, pero las estructuras anónimas no.

La razón de esto es que C admite uniones anónimas pero no estructuras anónimas *, por lo que C ++ admite la primera por compatibilidad, pero no la última porque no es necesaria para la compatibilidad.

Además, no son de mucha utilidad las estructuras anónimas en C ++. El uso demuestras, que tiene una estructura que contiene tres flotadores de los cuales se puede hacer referencia a cualquiera de .v[i], o .x, .yy .z, creo que da como resultado un comportamiento indefinido en C ++. C ++ no le permite escribir a un miembro de un sindicato, digamos .v[1], y luego leer de otro miembro, digamos .y. Aunque el código que hace esto no es infrecuente, en realidad no está bien definido.

Las facilidades de C ++ para tipos definidos por el usuario proporcionan soluciones alternativas. Por ejemplo:

struct vector3 {
  float v[3];
  float &operator[] (int i) { return v[i]; }
  float &x() { return v[0]; }
  float &y() { return v[1]; }
  float &z() { return v[2]; }
};

_{* C11 aparentemente agrega estructuras anónimas, por lo que una revisión futura de C ++ puede agregarlas.}

Diré que puede limpiar su vector3declaración con solo usar ununion

union vector3 {
  struct { float x, y, z; } ;
  float v[3] ;
} ;

Claro, las estructuras anónimas eran una extensión de MSVC . Pero ISO C11 lo permite ahora y gcc lo permite , al igual que el compilador llvm de Apple.

¿Por qué en C11 y no en C ++ 11? No estoy seguro, pero prácticamente la mayoría de los compiladores C ++ (gcc ++, MSVC ++ y el compilador C ++ de Apple) los admiten.

No estoy seguro de lo que quieres decir. Sección 9.5 de la especificación de C ++, cláusula 2:

Una unión de la forma

union { member-specification } ;

se llama unión anónima; define un objeto sin nombre de tipo sin nombre.

También puedes hacer cosas como esta:

void foo()
{
  typedef
  struct { // unnamed, is that what you mean by anonymous?
    int a;
    char b;
  } MyStructType; // this is more of a "C" style, but valid C++ nonetheless

  struct { // an anonymous struct, not even typedef'd
    double x;
    double y;
  } point = { 1.0, 3.4 };
}

No siempre es muy útil ... aunque a veces es útil en definiciones de macro desagradables.

Los sindicatos pueden ser anónimos; ver la Norma, 9.5 párrafo 2.

¿Qué propósito considera satisfactorio una estructura o clase anónima? Antes de especular por qué algo no está en el Estándar, me gustaría tener una idea de por qué debería estarlo, y no veo un uso para una estructura anónima.

Basándome en la edición, los comentarios y este artículo de MSDN: Estructuras anónimas , me arriesgaré a adivinar: encaja mal con el concepto de encapsulación. No esperaría que un miembro de una clase se meta con el espacio de nombres de mi clase más allá de simplemente agregar un miembro. Además, los cambios en la estructura anónima pueden afectar a mi clase sin permiso.

Tu codigo

union {
  struct {
    float x;
    float y;
    float z;
  };
  float v[3];
};

es como

union Foo {
   int;
   float v[3];
};

que seguramente no es válido (en C99 y antes).

La razón es probablemente para simplificar el análisis (en C), porque en ese caso solo necesita verificar que el cuerpo de estructura / unión solo tenga "declaraciones de declarador" como

Type field;

Dicho esto, gcc y "otros compiladores" admiten campos sin nombre como extensión.

Editar: Las estructuras anónimas ahora se admiten oficialmente en C11 (§6.7.2.1 / 13).