CKTIS / C++
Operador de atribuição com multiplicação (*=)
O operador *= multiplica o valor atual do operando esquerdo pelo operando direito e guarda novamente o resultado. O operando esquerdo é avaliado apenas uma vez, e a conversão do resultado para o seu tipo pode eliminar a parte fracionária.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
lhs *= rhsO operador integrado *= combina multiplicação e atribuição: lhs *= rhs comporta-se como lhs = lhs * rhs, mas lhs é avaliado apenas uma vez. Isto é importante quando há efeitos secundários: values[index++] *= 4 incrementa index apenas uma vez. O operando direito é avaliado antes do esquerdo.
O operando esquerdo tem de ser um lvalue modificável de tipo aritmético, como uma variável int ou double, mas não pode ser um objeto const nem um ponteiro. O operando direito pode ter tipo aritmético ou ser um tipo enumerado sem âmbito. Antes da multiplicação, aplicam-se as conversões aritméticas habituais; em seguida, o resultado é convertido para o tipo do operando esquerdo. Assim, dado int count = 5;, a instrução count *= 1.5; guarda 7: a parte fracionária de 7.5 é descartada.
O overflow durante a multiplicação num tipo inteiro com sinal causa comportamento indefinido. A aritmética num tipo sem sinal opera módulo 2^N, em que N é a largura desse tipo; no entanto, as promoções podem fazer com que a multiplicação ocorra num tipo com sinal. A conversão de um resultado de vírgula flutuante para um tipo inteiro diferente de bool elimina a parte fracionária. Se o valor truncado não puder ser representado no tipo de destino, o comportamento é indefinido. A conversão para bool é booleana: zero converte-se em false e qualquer valor diferente de zero converte-se em true. Se b for do tipo bool e tiver o valor true, b *= 2.0 mantém b com o valor true, sem causar comportamento indefinido.
O resultado do *= integrado é um lvalue que se refere ao operando esquerdo modificado. Os operadores de atribuição agrupam da direita para a esquerda: a *= b *= c significa a *= (b *= c). Para tipos classe, operator*= pode ser sobrecarregado; o seu comportamento não tem necessariamente de corresponder a uma multiplicação e não é gerado automaticamente a partir de operator*. A fonte fornecida é um projeto de norma em evolução, não uma publicação C++23 definitiva.
Exemplos
#include <iostream>
int main() {
int values[] = {6, 9};
int index = 0;
values[index++] *= 4;
int count = 5;
count *= 1.5;
std::cout << values[0] << ' ' << values[1] << ' ' << index << '\n';
std::cout << count << '\n';
}
Resultado
24 9 1 7
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.