Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Operatore di assegnazione con moltiplicazione (*=)

L’operatore *= moltiplica il valore corrente dell’operando sinistro per quello destro e memorizza nuovamente il risultato. L’operando sinistro viene valutato una sola volta; la conversione del risultato al suo tipo può eliminare la parte frazionaria.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

lhs *= rhs

L’operatore integrato *= combina moltiplicazione e assegnazione: lhs *= rhs si comporta come lhs = lhs * rhs, con la differenza che lhs viene valutato una sola volta. Questo è importante in presenza di effetti collaterali: values[index++] *= 4 incrementa index una sola volta. L’operando destro viene valutato prima di quello sinistro.

L’operando sinistro deve essere un lvalue modificabile di tipo aritmetico, per esempio una variabile int o double, ma non un oggetto const né un puntatore. L’operando destro può avere tipo aritmetico o essere un tipo enumerato non scoped. Prima della moltiplicazione si applicano le consuete conversioni aritmetiche; il risultato viene poi convertito al tipo dell’operando sinistro. Quindi, con int count = 5;, l’istruzione count *= 1.5; memorizza 7: la parte frazionaria di 7.5 viene eliminata.

Un overflow durante la moltiplicazione in un tipo intero con segno causa comportamento indefinito. L’aritmetica in un tipo senza segno opera modulo 2^N, dove N è l’ampiezza di quel tipo; tuttavia, le promozioni possono far sì che la moltiplicazione avvenga invece in un tipo con segno. La conversione di un risultato in virgola mobile a un tipo intero diverso da bool elimina la parte frazionaria. Se il valore troncato non è rappresentabile nel tipo di destinazione, il comportamento è indefinito. La conversione a bool è invece booleana: zero diventa false e qualsiasi valore diverso da zero diventa true. Se b è di tipo bool e vale true, b *= 2.0 lascia b uguale a true senza causare comportamento indefinito.

Il risultato dell’operatore integrato *= è un lvalue che fa riferimento all’operando sinistro modificato. Gli operatori di assegnazione si raggruppano da destra a sinistra: a *= b *= c significa a *= (b *= c). Per i tipi classe, operator*= può essere sovraccaricato; il suo comportamento non deve necessariamente rappresentare una moltiplicazione e non viene generato automaticamente da operator*. La fonte fornita è una bozza di standard in evoluzione, non una pubblicazione C++23 definitiva.

Esempi

#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';
}

Risultato

24 9 1
7

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti