Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Assegnazione con moltiplicazione (`*=`) in C

L’operatore `*=` moltiplica il valore corrente e salva il risultato nello stesso oggetto. L’operando sinistro viene valutato una sola volta, ma prima di raddoppiare una capacità bisogna controllarne il limite.

Versione: ISO C23; implementation support may vary

Sintassi

lhs *= rhs

lhs *= rhs moltiplica il valore corrente di lhs per rhs e salva il risultato nell’oggetto designato da lhs. L’operando sinistro deve essere un lvalue modificabile di tipo aritmetico ed entrambi i tipi devono essere validi per *. L’operatore non accetta puntatori e in C non si possono sovraccaricare gli operatori. Queste regole si riferiscono a ISO C23; il supporto di C23 può variare a seconda dell’implementazione.

lhs = lhs * (rhs) illustra l’operazione, ma non è sempre una riscrittura corretta: *= valuta l’operando sinistro una sola volta, quindi capacities[i++] *= 2 incrementa i una volta sola. Ciò non impone di valutare l’operando sinistro prima del destro. L’espressione di assegnazione ha il valore memorizzato, ma non è un lvalue. Per un oggetto atomico, *= esegue un’operazione atomica di lettura, modifica e scrittura con ordinamento della memoria memory_order_seq_cst.

Le usuali conversioni aritmetiche determinano il tipo della moltiplicazione; il prodotto viene poi convertito nel tipo di destinazione. Un overflow nella moltiplicazione tra interi con segno causa un comportamento indefinito; nella moltiplicazione senza segno il risultato viene ridotto modulo il massimo del tipo del risultato più uno. Una destinazione senza segno non garantisce una moltiplicazione senza segno: le promozioni intere possono portare a un calcolo in int.

Prima di raddoppiare una capacità di tipo size_t, calcola max_elements = SIZE_MAX / sizeof(element_type), dove element_type è il tipo degli elementi e SIZE_MAX, da <stdint.h>, è il massimo di size_t. Rifiuta una capacità maggiore di max_elements / 2 prima di usare *= 2. Il controllo garantisce che il nuovo numero di elementi e la relativa dimensione in byte siano rappresentabili, non che l’allocazione riesca. *= non alloca memoria.

Esempi

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

Risultato

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

L’esempio non alloca alcun buffer e usa `sizeof(unsigned char)`, che vale 1. La prima capacità passa da 4 a 8, la seconda resta a 8 e `i` passa da 0 a 1.

Lezioni correlate

  • C · Lezione 74 · Avanzato · Versione: 3

Fonti