Por que C ++ não permite estruturas anônimas?

Alguns compiladores C ++ permitem uniões e estruturas anônimas como uma extensão do C ++ padrão. É um pouco de açúcar sintático que às vezes é muito útil.

Qual é a lógica que impede que isso faça parte do padrão? Existe um obstáculo técnico? Filosófico? Ou apenas não o suficiente para justificar isso?

Aqui está um exemplo do que estou falando:

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

Meu compilador aceitará isso, mas avisa que "struct / union sem nome" é uma extensão não padrão para C ++ .

Como outros apontaram, uniões anônimas são permitidas no C ++ padrão, mas estruturas anônimas não.

A razão para isso é que C oferece suporte a uniões anônimas, mas não a estruturas anônimas *, portanto, C ++ oferece suporte ao primeiro para compatibilidade, mas não ao último porque não é necessário para compatibilidade.

Além disso, não há muito uso para estruturas anônimas em C ++. O uso que você demonstrar, ter uma estrutura que contém três carros alegóricos que podem ser referidos quer por .v[i], ou .x, .ye .z, eu acredito que resulta em um comportamento indefinido em C ++. C ++ não permite que você escreva para um membro de um sindicato, digamos .v[1], e depois leia de outro membro, digamos .y. Embora o código que faz isso não seja incomum, na verdade não está bem definido.

Os recursos do C ++ para tipos definidos pelo usuário fornecem soluções alternativas. Por exemplo:

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 adiciona estruturas anônimas, portanto, uma revisão futura do C ++ pode adicioná-las.}

Eu direi, você pode limpar sua vector3declaração usando apenas umunion

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

Claro, estruturas anônimas eram uma extensão do MSVC . Mas o ISO C11 permite isso agora, e o gcc permite , assim como o compilador llvm da Apple.

Por que em C11 e não em C ++ 11? Não tenho certeza, mas praticamente falando, a maioria dos compiladores C ++ (gcc ++, MSVC ++ e C ++ da Apple) os suporta.

Não tenho certeza do que você quer dizer. Seção 9.5 da especificação C ++, cláusula 2:

Uma união da forma

union { member-specification } ;

é chamado de união anônima; ele define um objeto sem nome de tipo sem nome.

Você também pode fazer coisas assim:

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 };
}

Nem sempre muito útil ... embora às vezes útil em definições de macro desagradáveis.

Os sindicatos podem ser anônimos; ver a Norma, 9.5 parágrafo 2.

Que propósito você vê como uma estrutura ou classe anônima cumprindo? Antes de especular por que algo não está no padrão, gostaria de ter uma ideia de por que deveria estar, e não vejo um uso para uma estrutura anônima.

Com base na edição, nos comentários e neste artigo do MSDN: Anonymous Structures , arrisco um palpite - ele se encaixa mal com o conceito de encapsulamento. Eu não esperaria que um membro de uma classe mexesse com o namespace da minha classe além de simplesmente adicionar um membro. Além disso, as alterações na estrutura anônima podem afetar minha classe sem permissão.

Seu código

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

é como

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

o que é certamente inválido (em C99 e antes).

A razão é provavelmente para simplificar a análise (em C), porque nesse caso você só precisa verificar se o corpo da estrutura / união tem apenas "declarações do declarador" como

Type field;

Dito isso, gcc e "outros compiladores" suportam campos sem nome como uma extensão.

Editar: estruturas anônimas agora são oficialmente suportadas em C11 (§6.7.2.1 / 13).