CKTIS / C++
Vermenigvuldigings-toewijzingsoperator (*=)
De operator *= vermenigvuldigt de huidige waarde van de linkeroperand met de rechteroperand en slaat het resultaat weer op. De linkeroperand wordt maar één keer geëvalueerd; bij de omzetting van het resultaat naar het type ervan kan het fractionele deel verloren gaan.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
lhs *= rhsDe ingebouwde operator *= combineert vermenigvuldigen en toewijzen: lhs *= rhs gedraagt zich als lhs = lhs * rhs, behalve dat lhs maar één keer wordt geëvalueerd. Dat is van belang bij neveneffecten: values[index++] *= 4 verhoogt index maar één keer. De rechteroperand wordt vóór de linkeroperand geëvalueerd.
De linkeroperand moet een wijzigbare lwaarde van een rekenkundig type zijn, zoals een variabele van het type int of double, maar geen const-object of aanwijzer. De rechteroperand mag een rekenkundig type of een enumeratietype zonder eigen bereik hebben. Vóór de vermenigvuldiging worden de gebruikelijke rekenkundige conversies toegepast; daarna wordt het resultaat omgezet naar het type van de linkeroperand. Bij int count = 5; slaat de instructie count *= 1.5; dus 7 op: het fractionele deel van 7.5 wordt weggelaten.
Overloop bij vermenigvuldiging in een geheelgetaltype met teken leidt tot ongedefinieerd gedrag. Rekenkunde in een type zonder teken werkt modulo 2^N, waarbij N de breedte van dat type is. Door promotie van geheelgetaltypen kan de vermenigvuldiging echter in een type met teken worden uitgevoerd. Bij omzetting van een drijvendekommaresultaat naar een geheelgetaltype anders dan bool wordt het fractionele deel afgekapt. Als de afgekorte waarde niet in het doeltype kan worden weergegeven, is het gedrag ongedefinieerd. Omzetting naar bool is een booleaanse conversie: nul wordt false en elke waarde ongelijk aan nul wordt true. Als b van het type bool is en de waarde true heeft, blijft b na b *= 2.0 gewoon true, zonder ongedefinieerd gedrag.
Het resultaat van de ingebouwde *= is een lwaarde die verwijst naar de gewijzigde linkeroperand. Toewijzingsoperatoren groeperen van rechts naar links: a *= b *= c betekent a *= (b *= c). Voor klassentypen kan operator*= worden overladen; het gedrag hoeft geen vermenigvuldiging voor te stellen en de operator wordt niet automatisch uit operator* gegenereerd. De opgegeven bron is een evoluerend concept van de standaard, geen definitieve C++23-publicatie.
Voorbeelden
#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';
}
Resultaat
24 9 1 7
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.