Confusão sobre a inicialização do array em C

Na linguagem C, se inicializar uma matriz como esta:

int a[5] = {1,2};

então, todos os elementos da matriz que não foram inicializados explicitamente serão inicializados implicitamente com zeros.

Mas, se eu inicializar uma matriz como esta:

int a[5]={a[2]=1};

printf("%d %d %d %d %d\n", a[0], a[1],a[2], a[3], a[4]);

resultado:

1 0 1 0 0

Não entendo, por que a[0]imprime em 1vez de 0? É um comportamento indefinido?

Nota: Esta pergunta foi feita em uma entrevista.

TL; DR: Não acho que o comportamento de int a[5]={a[2]=1};está bem definido, pelo menos em C99.

A parte engraçada é que a única parte que faz sentido para mim é a parte sobre a qual você está perguntando: a[0] está definida como 1porque o operador de atribuição retorna o valor que foi atribuído. É tudo o mais que não está claro.

Se o código fosse int a[5] = { [2] = 1 }, tudo teria sido fácil: essa é uma configuração de inicializador designada a[2]para 1e todo o resto para 0. Mas com { a[2] = 1 }temos um inicializador não designado que contém uma expressão de atribuição e caímos em uma toca de coelho.

Aqui está o que descobri até agora:

• a deve ser uma variável local.

  6.7.8 Inicialização

  4. Todas as expressões em um inicializador para um objeto que tem duração de armazenamento estático devem ser expressões constantes ou literais de string.

  a[2] = 1não é uma expressão constante, portanto, adeve haver armazenamento automático.

• a está no escopo em sua própria inicialização.

  6.2.1 Escopos de identificadores

  7. As tags de estrutura, união e enumeração têm escopo que começa logo após o aparecimento da tag em um especificador de tipo que declara a tag. Cada constante de enumeração tem um escopo que começa logo após o aparecimento de seu enumerador definidor em uma lista de enumeradores. Qualquer outro identificador tem escopo que começa logo após a conclusão de seu declarador.

  O declarador é a[5], portanto, as variáveis ​​estão no escopo em sua própria inicialização.

• a está vivo em sua própria inicialização.

  6.2.4 Durações de armazenamento de objetos

  4. Um objeto cujo identificador é declarado sem ligação e sem o especificador de classe de armazenamentostatic tem duração de armazenamento automática .

  5. Para um objeto que não tem um tipo de matriz de comprimento variável, seu tempo de vida se estende desde a entrada no bloco ao qual está associado até a execução desse bloco terminar de alguma forma. (Inserir um bloco fechado ou chamar uma função suspende, mas não termina, a execução do bloco atual.) Se o bloco for inserido recursivamente, uma nova instância do objeto é criada a cada vez. O valor inicial do objeto é indeterminado. Se uma inicialização for especificada para o objeto, ela será realizada toda vez que a declaração for alcançada na execução do bloco; caso contrário, o valor se torna indeterminado cada vez que a declaração é alcançada.

• Existe um ponto de sequência depois a[2]=1.

  6.8 Declarações e blocos

  4. Uma expressão completa é uma expressão que não faz parte de outra expressão ou de um declarador. Cada um dos seguintes é uma expressão completa: um inicializador ; a expressão em uma declaração de expressão; a expressão de controle de uma declaração de seleção ( ifou switch); a expressão de controle de uma declaração whileou do; cada uma das expressões (opcionais) de uma fordeclaração; a expressão (opcional) em uma returninstrução. O final de uma expressão completa é um ponto de sequência.

  Note-se que por exemplo int foo[] = { 1, 2, 3 }no{ 1, 2, 3 } parte é uma lista anexa-cinta de inicializadores, cada um dos quais tem um ponto sequência após ele.

• A inicialização é realizada na ordem da lista de inicializadores.

  6.7.8 Inicialização

  17. Cada lista de inicializadores entre chaves possui um objeto atual associado . Quando nenhuma designação está presente, os subobjetos do objeto atual são inicializados em ordem de acordo com o tipo do objeto atual: elementos de array em ordem crescente de subscrito, membros de estrutura em ordem de declaração e o primeiro membro nomeado de uma união. [...]

   

  19. A inicialização deve ocorrer na ordem da lista de inicializadores, cada inicializador fornecido para um subobjeto particular substituindo qualquer inicializador listado anteriormente para o mesmo subobjeto; todos os subobjetos que não são inicializados explicitamente devem ser inicializados implicitamente da mesma forma que os objetos que têm duração de armazenamento estático.

• No entanto, as expressões do inicializador não são necessariamente avaliadas em ordem.

  6.7.8 Inicialização

  23. A ordem em que os efeitos colaterais ocorrem entre as expressões da lista de inicialização não é especificada.

No entanto, isso ainda deixa algumas perguntas sem resposta:

• Os pontos de sequência são relevantes? A regra básica é:

  6.5 Expressões

  2. Entre o ponto de sequência anterior e o próximo um objeto deve ter seu valor armazenado modificado no máximo uma vez pela avaliação de uma expressão . Além disso, o valor anterior deve ser lido apenas para determinar o valor a ser armazenado.

  a[2] = 1 é uma expressão, mas a inicialização não é.

  Isso é ligeiramente contradito pelo Anexo J:

  J.2 Comportamento indefinido

  • Entre dois pontos de sequência, um objeto é modificado mais de uma vez, ou é modificado e o valor anterior é lido de outra forma que não para determinar o valor a ser armazenado (6.5).

  O Anexo J diz que qualquer modificação conta, não apenas modificações por expressões. Mas, dado que os anexos não são normativos, provavelmente podemos ignorar isso.

• Como as inicializações de subobjeto são sequenciadas em relação às expressões do inicializador? Todos os inicializadores são avaliados primeiro (em alguma ordem) e, em seguida, os subobjetos são inicializados com os resultados (na ordem da lista de inicializadores)? Ou eles podem ser intercalados?

Acho que int a[5] = { a[2] = 1 }é executado da seguinte forma:

1. O armazenamento para aé alocado quando o bloco que o contém é inserido. O conteúdo é indeterminado neste momento.
2. O (único) inicializador é executado ( a[2] = 1), seguido por um ponto de sequência. Isso armazena 1em a[2]e retornos 1.
3. Isso 1é usado para inicializar a[0](o primeiro inicializador inicializa o primeiro subobjeto).

Mas aqui as coisas ficam confuso porque os elementos restantes ( a[1], a[2], a[3], a[4]) são supostamente para ser inicializado para 0, mas não está claro quando: isso acontece antes a[2] = 1é avaliado? Se sim, a[2] = 1"ganharia" e substituiria a[2], mas essa atribuição teria comportamento indefinido porque não há ponto de sequência entre a inicialização zero e a expressão de atribuição? Os pontos de sequência são relevantes (veja acima)? Ou a inicialização zero ocorre depois que todos os inicializadores são avaliados? Se for assim, a[2]deve acabar sendo 0.

Como o padrão C não define claramente o que acontece aqui, acredito que o comportamento é indefinido (por omissão).

Não entendo, por que a[0]imprime em 1vez de 0?

Provavelmente a[2]=1inicializa a[2]primeiro, e o resultado da expressão é usado para inicializara[0] .

De N2176 (rascunho C17):

6.7.9 Inicialização

23. As avaliações das expressões da lista de inicialização são sequenciadas indeterminadamente umas em relação às outras e, portanto, a ordem em que ocorrem os efeitos colaterais não é especificada. ¹⁵⁴⁾

Então, parece que a saída 1 0 0 0 0 também teria sido possível.

Conclusão: não escreva inicializadores que modifiquem a variável inicializada em tempo real.

Acho que o padrão C11 cobre esse comportamento e diz que o resultado não é especificado , e não acho que o C18 tenha feito alterações relevantes nesta área.

A linguagem padrão não é fácil de analisar. A seção relevante do padrão é §6.7.9 Inicialização . A sintaxe é documentada como:

initializer:
                assignment-expression
                { initializer-list }
                { initializer-list , }
initializer-list:
                designationopt initializer
                initializer-list , designationopt initializer
designation:
                designator-list =
designator-list:
                designator
                designator-list designator
designator:
                [ constant-expression ]
                . identifier

Observe que um dos termos é expressão de atribuição e , como a[2] = 1é indubitavelmente uma expressão de atribuição, é permitido dentro de inicializadores para matrizes com duração não estática:

§4 Todas as expressões em um inicializador para um objeto que tem duração de armazenamento estático ou thread devem ser expressões constantes ou literais de string.

Um dos parágrafos principais é:

§19 A inicialização deve ocorrer na ordem da lista de inicializadores, cada inicializador fornecido para um subobjeto particular substituindo qualquer inicializador listado anteriormente para o mesmo subobjeto; ¹⁵¹⁾ todos os subobjetos que não são inicializados explicitamente devem ser inicializados implicitamente da mesma forma que os objetos que têm duração de armazenamento estático.

¹⁵¹⁾ Qualquer inicializador para o subobjeto que é sobrescrito e, portanto, não usado para inicializar aquele subobjeto pode não ser avaliado.

E outro parágrafo importante é:

§23 As avaliações das expressões da lista de inicialização são sequenciadas indeterminadamente umas em relação às outras e, portanto, a ordem em que os efeitos colaterais ocorrem não é especificada. ¹⁵²⁾

¹⁵²⁾ Em particular, a ordem de avaliação não precisa ser igual à ordem de inicialização do subobjeto.

Tenho quase certeza de que o parágrafo §23 indica que a notação na questão:

int a[5] = { a[2] = 1 };

leva a um comportamento não especificado. A atribuição a a[2]é um efeito colateral, e a ordem de avaliação das expressões são sequenciadas indeterminadamente uma em relação à outra. Consequentemente, não acho que haja uma maneira de apelar para o padrão e alegar que um compilador específico está lidando com isso correta ou incorretamente.

Meu entendimento é a[2]=1retorna o valor 1, então o código se torna

int a[5]={a[2]=1} --> int a[5]={1}

int a[5]={1}atribuir valor para um [0] = 1

Portanto, imprime 1 para um [0]

Por exemplo

char str[10]={‘H’,‘a’,‘i’};


char str[0] = ‘H’;
char str[1] = ‘a’;
char str[2] = ‘i;

Tento dar uma resposta curta e simples para o quebra-cabeça: int a[5] = { a[2] = 1 };

1. Primeiro a[2] = 1é definido. Isso significa que a matriz diz:0 0 1 0 0
2. Mas eis que, dado que você fez isso nos { }colchetes, que são usados ​​para inicializar o array em ordem, ele pega o primeiro valor (que é 1) e o define como a[0]. É como se int a[5] = { a[2] };fosse ficar, onde já chegamos a[2] = 1. A matriz resultante é agora:1 0 1 0 0

Outro exemplo: int a[6] = { a[3] = 1, a[4] = 2, a[5] = 3 };- Embora a ordem seja um tanto arbitrária, supondo que vá da esquerda para a direita, ela seguiria estas 6 etapas:

0 0 0 1 0 0
1 0 0 1 0 0
1 0 0 1 2 0
1 2 0 1 2 0
1 2 0 1 2 3
1 2 3 1 2 3

A atribuição a[2]= 1é uma expressão que possui o valor 1e você essencialmente escreveu int a[5]= { 1 };(com o efeito colateral a[2]atribuído 1também).

Acredito que int a[5]={ a[2]=1 };seja um bom exemplo para um programador atirando em si mesmo no próprio pé.

Posso ficar tentado a pensar que o que você quis dizer foi int a[5]={ [2]=1 };qual seria um inicializador designado C99 definindo o elemento 2 para 1 e o resto para zero.

No caso raro em que você realmente quis dizer int a[5]={ 1 }; a[2]=1;, essa seria uma maneira engraçada de escrever. De qualquer forma, seu código se resume a isso, embora alguns aqui tenham apontado que ele não está bem definido quando a gravação a[2]é realmente executada. A armadilha aqui é que a[2]=1não é um inicializador designado, mas uma atribuição simples que tem o valor 1.