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 *= rhslhs *= 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