Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

Atribuição por multiplicação (`*=`) em C

O operador `*=` multiplica o valor atual e guarda o resultado no mesmo objeto. O operando esquerdo é avaliado uma única vez, mas é preciso verificar o limite antes de duplicar uma capacidade.

Versão: ISO C23; implementation support may vary

Sintaxe

lhs *= rhs

lhs *= rhs multiplica o valor atual de lhs por rhs e guarda o resultado no objeto designado por lhs. O operando esquerdo tem de ser um lvalue modificável de tipo aritmético e ambos os tipos têm de ser válidos para *. O operador não aceita ponteiros e C não permite a sobrecarga de operadores. Estas regras dizem respeito à norma ISO C23; o suporte de C23 pode variar entre implementações.

lhs = lhs * (rhs) ilustra a operação, mas não é sempre uma reescrita correta: *= avalia o operando esquerdo uma única vez, pelo que capacities[i++] *= 2 incrementa i uma só vez. Isso não implica que o operando esquerdo seja avaliado antes do direito. A expressão de atribuição tem o valor guardado, mas não é um lvalue. Num objeto atómico, *= é uma operação atómica de leitura, modificação e escrita com ordenação de memória memory_order_seq_cst.

As conversões aritméticas usuais determinam o tipo da multiplicação; em seguida, o produto é convertido para o tipo de destino. Um transbordo na multiplicação de inteiros com sinal provoca comportamento indefinido; na multiplicação sem sinal, o resultado é reduzido módulo o máximo do tipo do resultado mais um. Um destino sem sinal não garante uma multiplicação sem sinal: as promoções de inteiros podem levar a um cálculo em int.

Antes de duplicar uma capacidade de tipo size_t, calcula max_elements = SIZE_MAX / sizeof(element_type), em que element_type é o tipo dos elementos e SIZE_MAX, de <stdint.h>, é o máximo de size_t. Rejeita uma capacidade superior a max_elements / 2 antes de usar *= 2. Assim verificas se o novo número de elementos e o respetivo tamanho em bytes são representáveis, sem garantires que a alocação terá êxito. *= não aloca memória.

Exemplos

#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    size_t capacities[] = {4, 8};
    size_t i = 0;
    const size_t max_elements = SIZE_MAX / sizeof(unsigned char);

    if (capacities[i] > max_elements / 2) {
        return 1;
    }

    capacities[i++] *= 2;
    printf("capacities[0] = %zu, capacities[1] = %zu, i = %zu\n",
           capacities[0], capacities[1], i);
    return 0;
}

Resultado

capacities[0] = 8, capacities[1] = 8, i = 1

O exemplo não aloca nenhum buffer e usa `sizeof(unsigned char)`, que vale 1. A primeira capacidade passa de 4 para 8, a segunda mantém-se em 8 e `i` passa de 0 para 1.

Lições relacionadas

  • C · Lição 74 · Avançado · Versão: 3

Fontes