Início / coding / Perguntas / 77975537
Accepted
H.S.
Asked: 2024-02-11 12:00:44 +0800 CST

Esta instrução `arr[i++] += x;` exibe comportamento indefinido?

  • 772

Este é um comportamento indefinido?

arr[i++] += x;       //   [1]

// arr is an array of integer type and x is an integer type variable
// Assumptions - 
// 1. Value of i is a valid index value of array arr and 
//    the result of prefix/postfix increment/decrement of i
//    is also a valid index value of array arr.
// 2. The value of array members and variable x is such that 
//    arithmetic operation (+) does not result in overflow.

gcce clango compilador não fornece nenhuma mensagem de aviso na instrução [1], mas se eu substituir [1]por esta instrução -

arr[i++] = arr[i++] + x;     //  [2]

eles emitem uma mensagem de alerta sobre esta afirmação, que é bastante óbvia -

gcccompilador:

warning: operation on ‘i’ may be undefined [-Wsequence-point]
  arr[i++] = arr[i++] + x;

clangcompilador:

warning: multiple unsequenced modifications to 'i' [-Wunsequenced]
        arr[i++] = arr[i++] + x;
c

2 respostas

  1. À primeira vista, parece que a declaração exibe comportamento indefinido, mas não é .

    De c17#6.5.16.2 $4 [ênfase adicionada]

    3 Uma atribuição composta da forma E1 op= E2 é equivalente à expressão de atribuição simples E1 = E1 op (E2), exceto que o lvalue E1 é avaliado apenas uma vez , e com relação a uma chamada de função com sequência indeterminada, a operação de uma tarefa composta é uma avaliação única. Se E1 tiver um tipo atômico, a atribuição composta é uma operação de leitura-modificação-gravação com semântica de ordem de memória memory_order_seq_cst.115)

    Verifique também a referência 1) abaixo.

    Nesta instrução, o lvalue arr[i++]será avaliado apenas uma vez

    arr[i++] += x;

    Será tratado como

    arr[i] = arr[i] + x;
i++;

    Da mesma forma, se o incremento de prefixo for usado, a instrução

    arr[++i] += x;

    será tratado como

    ++i;
arr[i] = arr[i] + x;

    Portanto, a modificação no valor de inão deixa de ser sequenciada para uma modificação diferente no valor de iou para o uso do valor de ipara computação arr[i]. [ referência 1) ]

    Portanto, a instrução arr[i++] += x; não exibe Comportamento Indefinido .
    [ O mesmo vale para decremento de prefixo/postfix se usado na instrução arr[i++] += x;. ]

    Considerando que, na declaração [2]-

    arr[i++] = arr[i++] + x;

    a avaliação de LHS e RHS i++não é sequenciada: podem ser realizadas em qualquer ordem (dentro de um único thread de execução, o compilador pode intercalar as instruções da CPU que compõem a i++avaliação de LHS e RHS). Se um efeito colateral em um objeto escalar não for sequenciado em relação a outro efeito colateral no mesmo objeto escalar, o comportamento será indefinido e, portanto, o compilador estará avisando sobre ele.

    Observe que as declarações a seguir também exibem comportamento indefinido

    arr[i++] += arr[i];
arr[i] += arr[i++];
arr[i] += i++;
arr[++i] += i;
arr[i++] = i;

    pelo mesmo motivo explicado acima.

    1). Referência:

    c17#6,5$2

    2 Se um efeito colateral em um objeto escalar não for sequenciado em relação a um efeito colateral diferente no mesmo objeto escalar ou a um cálculo de valor usando o valor do mesmo objeto escalar, o comportamento será indefinido. Se houver múltiplas ordenações permitidas das subexpressões de uma expressão, o comportamento será indefinido se tal efeito colateral não sequenciado ocorrer em qualquer uma das ordenações.95)

    c17#6.5.16$3

    3 Um operador de atribuição armazena um valor no objeto designado pelo operando esquerdo. Uma expressão de atribuição tem o valor do operando esquerdo após a atribuição,125), mas não é um lvalue. O tipo de uma expressão de atribuição é o tipo que o operando esquerdo teria após a conversão de lvalor. O efeito colateral da atualização do valor armazenado do operando esquerdo é sequenciado após os cálculos dos valores dos operandos esquerdo e direito. As avaliações dos operandos não são sequenciadas.

    • 4
  2. Best Answer
    arr[i++] += x;

    está bem definido; nenhum objeto é modificado mais de uma vez entre pontos de sequência. É efetivamente equivalente a

    tmp <- i
arr[tmp] <- arr[tmp] + x;
i <- i + 1

    com a ressalva de que as duas últimas atualizações podem ocorrer em qualquer ordem, até mesmo simultaneamente.

    Por contraste,

    arr[i++] = arr[i++] + x;

    resulta em comportamento indefinido porque ié modificado mais de uma vez entre pontos de sequência. Até

    arr[i++] = arr[i] + x;

    e

    arr[i] = arr[i++] + x;

    resulta em comportamento indefinido porque iestá sendo atualizado e usado em um cálculo de valor entre pontos de sequência.

    Não é garantido que as expressões aritméticas sejam avaliadas da esquerda para a direita, nem é garantido que os efeitos colaterais sejam aplicados imediatamente após a avaliação; as expressões acima podem produzir mais de um resultado e, no que diz respeito à definição da linguagem, todos esses resultados diferentes são igualmente corretos.

    Para torná-los bem definidos, separe a atualização ida atualização de arr[i]:

    arr[i] = arr[i] + x;
i++; // or ++i, same result in this context.

    Ou apenas use

    arr[i++] += x;
    • 1

relate perguntas