[C++] Esercizio in C++ e suo funzionamento

[s_p_81]

ciao,sto frequentando un corso di c++ e il professore oggi ha spiegato questo esercizio...controllato al compilatore funziona perfettamente,anke se ci sono alcune coseke mi sn poco chiare....chi mi potrebbe dare una spiegazione un po + precisa di alcune fasi dell'algoritmo ke ho evidenziato in rosso?grazie

//ruotare a destra o a sinistra di n bit

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
void visualizza_in_bit (short , short []);
void ruota_dx(short , short []);
void ruota_sx(short , short []);
void main()
{
short A, bit[16];
int direzione;
printf("inserisci un numero\n");
scanf("%hd", &A);
visualizza_in_bit(A,bit);
printf("\nDigita 1 per shiftare a destra oppure 2 per shiftare a sinistra\n");
scanf("%d", &direzione);
if (direzione==1)
ruota_dx(A, bit);
if (direzione==2)
ruota_sx(A, bit);
printf("\n");
system("PAUSE");
}
void visualizza_in_bit(short num, short b[16]) //function di visualizzazione in bit
{
int conta, a, i;
conta=0;
a=1; <---XKè METTE LA VARIABILE A E LA INIZIALIZZA AD 1
for (i=15;i>=0;i--)
{
b[i]=a&num; <---NELL'ARRAI b COSA METTE I BIT NUM OPPURE I BIT DI a.KE FUNZIONA HA IN QUESTO CASO L' &.
num=num>>1;
}

printf("la rappresentazione in binario e': ");
for (i=0;i<=15;i++)
{
printf ("%d",b[i]);
conta++;
if (conta==4)
{
printf (" ");
conta=0;
}
}
printf("\n");
}
void ruota_dx(short A, short bit[16])
{
short n, B;
printf("\nDi quanti bit vuoi shiftare la sequenza verso destra?\n");
scanf("%hd", &n);
B= (short)pow(2,n)-1; //maschera con tutti zero e tanti 1 quanti sono i bit da shiftare
B= B&A; //copia i primi n bit di A in B
A= A>>n; //shifta A di n posizioni a destra
B= B<<(16-n); //shifta B di 16-n posizioni a sinistra

A= A | B; <----LA OR IN PRATICA KE OPERAZIONE FA...A COSA SERVE QUI.
visualizza_in_bit(A, bit);
}
void ruota_sx(short A, short bit[16])
{

short n,B;
printf("\nDi quanti bit vuoi shiftare la sequenza verso sinistra?\n");
scanf("%hd", &n);

B= (short)pow(2,n)-1; //maschera con tutti zero e tanti 1 quanti sono i bit da shiftare


B=B<<(16-n); //shifta a sinistra in modo da trovarsi gli 1 in posizione più significativa


B= B&A; //copia i primi n bit di A in B


A= A<<n; //shifta A di n bit verso sinistra


B= B>>(16-n); //shifta B di 16-n posizioni a destra

A= A | B;

visualizza_in_bit(A, bit);
}

[fastcoder]

Credo che il senso sia di mettere nell'array b i singoli bit di num. Per far questo eseguo
lo shift a destra di num e ad ogni passo prendo in considerazione sempre il bit meno significativo e se è 1 metto in b[i] 1 se zero ci metto 0. Prendiamo per esempio il numero binario 10011.
Al primo giro (i = 4) faccio questo:
b[i] = a & num
dato che a vale 1 e num vale 10011 in effetti faccio
b[4] = 1 & 10011 = 1
poi shifto a destra 10011 e quindi ottengo 01001.
al giro i = 1 faccio questo:
b[3] = 1 & 01001 = 1
e poi lo shift 01001 -> 00100
poi:
b[2] = 1 & 00100 = 0
00100 -> 00010
b[1] = 1 & 00010 = 0
00010 -> 00001
b[0] = 1 & 00001 = 1
poi mi fermo qua perchè in questo esempio il numero è di 5 bit, nel tuo caso mancano ancora un po' di giri per arrivare ai 16 bit di un unsigned short.
Se vedi i valori di b trovi che è esattamente il numero num. In effetti a è inutile perchè è costante (io ci avrei messo b[i] = num & 1).

Per quanto riguarda A | B, questo è usato per fare l'OR bit a bit di A e B; credo che in questo caso venga usato per far si che lo shift sia uno shift circolare...se usi l'operatore >> il bit meno significativo (quello più a destra) viene perso, invece con l'OR te lo ritrovi a sinistra e quindi 1001 diventa 1100 e non 0001.

Spero di averci azzeccato e di averti chiarito il dubbio