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

CKTIS / C

Affectation par multiplication (`*=`) en C

L’opérateur `*=` multiplie la valeur courante et stocke le résultat dans le même objet. L’opérande gauche n’est évalué qu’une fois, mais il faut vérifier la limite avant de doubler une capacité.

Version : ISO C23; implementation support may vary

Syntaxe

lhs *= rhs

lhs *= rhs multiplie la valeur courante de lhs par rhs et stocke le résultat dans l’objet désigné par lhs. L’opérande gauche doit être une lvalue modifiable de type arithmétique, et les deux types doivent être valides pour *. Les pointeurs ne sont pas admis et C ne permet pas la surcharge d’opérateurs. Ces règles sont celles d’ISO C23 ; la prise en charge de C23 peut varier selon l’implémentation.

lhs = lhs * (rhs) illustre le calcul, mais ne constitue pas toujours une réécriture correcte : *= n’évalue l’opérande gauche qu’une fois, donc capacities[i++] *= 2 n’incrémente i qu’une fois. Cela n’impose pas d’évaluer l’opérande gauche avant le droit. L’expression d’affectation a la valeur stockée, mais n’est pas une lvalue. Sur un objet atomique, *= réalise une opération atomique de lecture-modification-écriture avec l’ordre mémoire memory_order_seq_cst.

Les conversions arithmétiques usuelles déterminent le type de la multiplication ; le produit est ensuite converti vers le type de destination. Un débordement lors d’une multiplication entière signée entraîne un comportement indéfini ; en non signé, le résultat est pris modulo le maximum du type du résultat plus un. Un type de destination non signé ne garantit pas une multiplication non signée : les promotions entières peuvent conduire à un calcul en int.

Avant de doubler une capacité de type size_t, calcule max_elements = SIZE_MAX / sizeof(element_type), où element_type est le type des éléments et SIZE_MAX, défini dans <stdint.h>, est le maximum de size_t. Rejette toute capacité supérieure à max_elements / 2 avant d’utiliser *= 2. Le nouveau nombre d’éléments et la taille correspondante en octets sont alors représentables, sans garantie que l’allocation réussira. *= n’alloue pas de mémoire.

Exemples

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

Résultat

capacities[0] = 8, capacities[1] = 8, i = 1

L’exemple n’alloue aucun tampon et utilise `sizeof(unsigned char)`, qui vaut 1. La première capacité passe de 4 à 8, la seconde reste à 8 et `i` passe de 0 à 1.

Leçons associées

  • C · Leçon 74 · Avancé · Version : 3

Sources