[C] Estrarre la parte bassa e la parte alta di un tipo a due byte

[rsdpzed]

Mi spiego meglio: ho una funzione che mi ritorna un int.

Io memorizzo questo int in una variabile A
e poi voglio fare due printf che mi stampino rispettivamente la parte alta e la parte bassa della variabile A

printf("%dh",A); //stampa i primi 8 bit
printf("%dl",A); //stampa gli ultimi 8 bit

è possibile?
come si fa?

thx

[LeleFT]

Si usano le union:

union mioByte {
   int A;
   char a0;
   char a1;
} miaVar;

// Assegno il mio int
miaVar.A = <valore intro>;
printf("Primo byte (primi 8 bit): %d\n", miaVar.a0);
printf("Secondo byte (secondi 8 bit): %d\n", miaVar.a1);

Le union permettono a più tipi di dati di condividere la stessa memoria (ossia il minimo di memoria necessario a contenerle tutte!)

Ciao.

[iguana13]

Originariamente inviato da LeleFT

union mioByte {
   int A;
   char a0;
   char a1;
} miaVar;

// Assegno il mio int
miaVar.A = <valore intro>;
printf("Primo byte (primi 8 bit): %d\n", miaVar.a0);
printf("Secondo byte (secondi 8 bit): %d\n", miaVar.a1);

Credo che il tuo codice sia sbagliato, prima di tutto perchè nella union sia a0 cha a1 condividono la stessa area di memoria!!

Più corretto sarebbe:

union mioByte {
   int A;
   struct {
      char a0;
      char a1;
   };
} miaVar;

// Assegno il mio int
miaVar.A = <valore intro>;
printf("Primo byte (primi 8 bit): %d\n", miaVar.a0);
printf("Secondo byte (secondi 8 bit): %d\n", miaVar.a1);

Un'altra cosa è che un char è a 1 byte(8 bit), mentre nei sistemi a 32 bit + diffusi uni int è a 4 byte (32 bit).
Quindi servirebbero almeno 4 campi nella struct.

Un'altro sistema, + flessibile cross-platform, è risolverlo per via matematica.
(Cross-platform significa che quando avremo computer a 512 bit questo codice funzionerà ancora )

Ho messo tutte le variabili come unsigned per rendere + chiari i risultati.
Ecco il codice:

#include <iostream>
#include <math.h>

using namespace std;

void main()
{
	// 32 bit solitamente
	unsigned int intero;
	intero = 123456789;

	cout << "La variabile intera contiane il valore di " << intero << ".\n";
	cout << "Occupa " << sizeof(intero) << " byte, cioe' " << sizeof(intero) * 8 << " bit.\n";

	// Array di tipo char, con numero di elementi = ai byte occupari dall' intero
	unsigned char bytes[sizeof(intero)];

	// contatore
	int i;
	// Copia del numero di partenza
	unsigned int copia_int = intero;
	// Suddivide nei byte
	for(i=sizeof(intero) - 1; i >= 0; i--)
	{
		bytes[i] = copia_int % 255;
		copia_int /= 255;
	}

	// Visualizza l'array
	for(i=0; i<sizeof(intero); i++)
		cout << "Byte numero " << i + 1 << ":\t" << unsigned int(bytes[i]) << endl;
}

Se avete domande, non esitate! :metallica

[LeleFT]

Sì... hai perfettamente ragione!!!

Allora... considerando un int a 16 bit (char sempre a 8 bit), ci vorrebbe anche una struct così composta:

struct intero {
   char a0;
   char a1;
};

Segue il codice corretto:

union mioByte {
   int A;
   struct intero mioInt;
} miaVar

A questo punto cambiano un po' le cose:

miaVar.A = <valore intero>
printf("Valore del primo byte: %d\n", miaVar.mioInt.a0);
printf("Valore del secondo byte: %d\n", miaVar.mioInt.a1);

Spero non ci siano altri errori.


Ciao.

[iguana13]

Credo che non serva definire una nuova struttura.
Se usi le strutture anonime, come nel mio esempio, non potrai più creare oggetti di quel tipo, ma dici al compilatore che devono stare in celle di memoria contigue e non sovrapposte.
Ci guadagna anche la semplicità del codice!