CKTIS / C
Vermenigvuldigende toekenning (`*=`) in C
Met `*=` vermenigvuldig je de huidige waarde en sla je het resultaat op in hetzelfde object. De linkeroperand wordt één keer geëvalueerd, maar controleer vóór het verdubbelen van een capaciteit wel de grens.
Versie: ISO C23; implementation support may vary
Syntax
lhs *= rhslhs *= rhs vermenigvuldigt de huidige waarde van lhs met rhs en slaat het resultaat op in het object dat lhs aanduidt. De linkeroperand moet een wijzigbare lvalue van een rekenkundig type zijn; beide typen moeten geldig zijn voor *. De operator accepteert geen pointers, en C kent geen operatoroverloading. Deze regels gelden voor ISO C23; de ondersteuning voor C23 kan per implementatie verschillen.
lhs = lhs * (rhs) laat zien wat de bewerking doet, maar is niet altijd een geldige herschrijving: *= evalueert de linkeroperand maar één keer, dus capacities[i++] *= 2 verhoogt i één keer. Dat betekent niet dat de linkeroperand vóór de rechteroperand wordt geëvalueerd. De toekenningsexpressie heeft de opgeslagen waarde, maar is geen lvalue. Bij een atomair object is *= een atomaire lees-wijzig-schrijfoperatie met geheugenordening memory_order_seq_cst.
De gebruikelijke rekenkundige conversies bepalen het type van de vermenigvuldiging; daarna wordt het product omgezet naar het doeltype. Overflow bij een vermenigvuldiging van gehele getallen met teken leidt tot ongedefinieerd gedrag. Bij een vermenigvuldiging zonder teken wordt het resultaat genomen modulo één meer dan het maximum van het resultaattype. Een doeltype zonder teken garandeert geen vermenigvuldiging zonder teken: integerpromoties kunnen leiden tot een berekening in int.
Bereken vóór het verdubbelen van een capaciteit van het type size_t eerst max_elements = SIZE_MAX / sizeof(element_type). Hier is element_type het elementtype en SIZE_MAX uit <stdint.h> de grootste waarde van size_t. Weiger een capaciteit groter dan max_elements / 2 voordat je *= 2 gebruikt. Zo controleer je of het nieuwe aantal elementen en de bijbehorende grootte in bytes representeerbaar zijn; het garandeert niet dat geheugenallocatie lukt. *= reserveert zelf geen geheugen.
Voorbeelden
#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;
}
Resultaat
capacities[0] = 8, capacities[1] = 8, i = 1
Het voorbeeld reserveert geen buffer en gebruikt `sizeof(unsigned char)`, dat 1 is. De eerste capaciteit gaat van 4 naar 8, de tweede blijft 8 en `i` gaat van 0 naar 1.
Gerelateerde lessen
- C · Les 74 · Gevorderd · Versie: 3