Antwoord.

De cirkelverschuiving (rotary/circular shift) is het verschuiven van de bits van een getal over een bepaald aantal posities, waarbij de 'uitgevallen' bits aan de andere kant worden toegevoegd. In de programmeertaal C is er geen ingebouwde operator voor deze taak; deze oplossing is historisch gerelateerd aan de overdraagbaarheid van de standaardbibliotheek en de noodzaak om het gedrag voor verschillende platforms expliciet te definiëren.

Het probleem is dat de standaard verschuivingsoperatoren (<<, >>) de verschuiving niet cirkelvormig maken: ze verschuiven alleen de bits, en de 'uitgevallen' bits worden vervangen door nullen. Voor cirkelverschuiving moet je expliciet de resultaten van twee verschuivingen combineren en het resultaat maskeren met een bepaald aantal bits.

De oplossing is om de cirkelverschuiving handmatig te implementeren. Voor een 32-bits unsigned getal ziet dit er als volgt uit:

uint32_t rotate_left(uint32_t value, unsigned int shift) {
    return (value << shift) | (value >> (32 - shift));
}

uint32_t rotate_right(uint32_t value, unsigned int shift) {
    return (value >> shift) | (value << (32 - shift));
}

Belangrijke kenmerken:

Er is geen ingebouwde operator voor rotary shift in C.
Je moet handmatig twee verschuivingen combineren en maskeren.
De grootte van het gegevenstype (bitgrootte) moet in acht worden genomen voor overdraagbaarheid.

Vragen met een addertje onder het gras.

Kan de operator << of >> een cirkelverschuiving zonder aanvullende bewerkingen uitvoeren?

Nee. Normale verschuivingen vervangen de bits die buiten de grenzen vallen met nullen, in plaats van ze naar de andere kant te verplaatsen.

Wat gebeurt er als je verschuift op de grootte van het type (shift gelijk aan het aantal bits in het getal)?

Het gedrag is niet gedefinieerd (Undefined Behavior volgens de standaard C), je moet altijd de verschuiving modulo de grootte van het type uitvoeren.

Is het veilig om rotary shift voor signed types met deze functies te doen?

Nee, gebruik altijd unsigned types, omdat bitverschuivingen voor signed types verschillend kunnen gedragen afhankelijk van de compiler en architectuur.

Veelvoorkomende fouten en anti-patronen

Gebruik van signed types in plaats van unsigned voor bitverschuivingen.
Geen rekening houden met de grootte van het type (bijvoorbeeld 32 versus 64 bits).
Ontbrekende masking van verschuiving (bijvoorbeeld, geen verschuiving = verschuiving % 32 voor 32-bits getallen).

Voorbeeld uit het leven

Negatieve case

Gebruik van reguliere verschuiving voor cirkelverschuiving:

uint32_t x = 0xFA3C0F00;
uint32_t y = x << 5; // Geen cirkelvormig karakter

Voordelen:

Eenvoudigheid van schrijven.

Nadelen:

Bits gaan verloren, het gedrag komt niet overeen met de verwachtingen, moeilijk te traceren bug in cryptografie en gegevensverwerking.

Positieve case

Gebruik van een handmatige rotary shift-functie met inachtneming van de grootte van het type en bescherming tegen UB:

uint32_t x = 0xFA3C0F00;
uint32_t y = rotate_left(x, 5);