Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Opérateur d’affectation par multiplication (*=)

L’opérateur *= multiplie la valeur actuelle de l’opérande gauche par l’opérande droit et réaffecte le résultat. L’opérande gauche n’est évalué qu’une seule fois, et la conversion du résultat vers son type peut supprimer la partie fractionnaire.

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

Syntaxe

lhs *= rhs

L’opérateur intégré *= combine multiplication et affectation : lhs *= rhs se comporte comme lhs = lhs * rhs, sauf que lhs n’est évalué qu’une seule fois. C’est important en présence d’effets de bord : values[index++] *= 4 n’incrémente index qu’une fois. L’opérande droit est évalué avant l’opérande gauche.

L’opérande gauche doit être une l-value modifiable de type arithmétique, par exemple une variable int ou double, mais pas un objet const ni un pointeur. L’opérande droit peut être de type arithmétique ou de type énumération sans portée. Les conversions arithmétiques usuelles s’appliquent avant la multiplication ; le résultat est ensuite converti vers le type de l’opérande gauche. Ainsi, avec int count = 5;, l’instruction count *= 1.5; stocke 7 : la partie fractionnaire de 7.5 est supprimée.

Un dépassement lors d’une multiplication dans un type entier signé entraîne un comportement indéfini. L’arithmétique dans un type non signé s’effectue modulo 2^N, où N est la largeur de ce type ; toutefois, les promotions peuvent faire effectuer la multiplication dans un type signé. La conversion d’un résultat à virgule flottante vers un type entier autre que bool supprime la partie fractionnaire. Si la valeur tronquée n’est pas représentable dans le type de destination, le comportement est indéfini. La conversion vers bool est une conversion booléenne : zéro devient false et toute valeur non nulle devient true. Si b est de type bool et vaut true, b *= 2.0 laisse b à true sans entraîner de comportement indéfini.

Le résultat de *= intégré est une l-value qui désigne l’opérande gauche modifié. Les opérateurs d’affectation s’associent de droite à gauche : a *= b *= c signifie a *= (b *= c). Pour les types classe, operator*= peut être surchargé ; son comportement n’a pas nécessairement de rapport avec une multiplication et il n’est pas généré automatiquement à partir de operator*. La source fournie est un projet de norme en évolution, et non une publication C++23 figée.

Exemples

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

Résultat

24 9 1
7

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources