[C] "Stringa" di bit

[mrYellow]

Ciao a tutti.

Il mio problema è questo:
ho un programma che riceve da tastiera una "stringa" formata da una serie di 0 e 1 ( ad esempio 010001000111100 ).
E' possibile salvare questa stringa usando un bit di memoria per ogni cifra?

Grazie.

[Lardoman]

Umh... :master:

Ricevendo in input una stringa, viene salvata come insieme di caratterei. Quindi se viene inserito 0101 lo 0 e l'1 vengono interpretati come il carattere ASCII che li codifica. Pertanto occupano molto + spazio di un bit.

Non credo nemmeno che esista una funzione che la converta, perchè nn esiste un tipo "bit"..

Anche allocando la memoria nn credo sia possibile perchè comunque sarebbero sempre char e quidi anche se assegnassi ad ogni carattere un solo bit andrebbe in buffer overflow.

In definitiva credo che in C nn sia possibile., ma bisogna operare aancora + a basso livello (ASM)

[pdpmpd]

la tipo più leggero in C è il char.

[I'mtheleader]

non penso che sia possibile neanche con assembly che è quello di più basso livello...

Ti conviene se ci riesci entrare fisicamente nella cpu aspettare un bus dati, tirargli una mazzata cambiargli i bit che vuoi e poi aspetti che si riprenda...

Con me ha sempre funzionato...

Ciao a all

[LeleFT]

Invece esiste il tipo "bit" solo che molti non si ricordano dei famosi campi di bit: un tipo di dato struct che rappresenta un numero arbitrario di bit.

Se la stringa che passi al programma ha sempre lo stesso numeri di cifre binarie, puoi crearti nua struttura ad hoc e salvare, in ogni campo di questa struttura, ogni singolo elemento della stringa di bit passata al programma.

Questo è un esempio di campo di bit che rappresenta, a tutti gli effetti, un char (8 bit):

struct bits {
   unsigned a0 : 1;
   unsigned a1 : 1;
   unsigned a2 : 1;
   unsigned a3 : 1;
   unsigned a4 : 1;
   unsigned a5 : 1;
   unsigned a6 : 1;
   unsigned a7 : 1;
};

Ovviamente puoi espandere la struttura a tuo piacimento, aggiungendo o togliendo bit a seconda delle esigienze.

Dato che la stringa la puoi indicizzare come un array, è sufficiente controllare se l'i-esimo valore della stringa è 1 oppure 0 (ossia se l'i-esimo bit che devi rappresentare è 1 oppure 0).

Questo può essere facilmente reperito utilizzando questa funzione:

unsigned int getBit(char c) { return (c & 1); }

Ovviamente questa funzione ha senso applicarla solamente se ciascun carattere che gli viene passato è '1' oppure '0' altrimenti potrebbe tornare dei valori che non hanno, apparentemente, senso.


Ciao.

[iguana13]

Oppure (+ veloce dei campi di bit) lo memorizzi in un unsigned int o un array.

Con le operazioni cone le potenze in base 2 converti la stringa nel numero corrispondente.

[LeleFT]

Originariamente inviato da iguana13
Oppure (+ veloce dei campi di bit) lo memorizzi in un unsigned int o un array.

Con le operazioni cone le potenze in base 2 converti la stringa nel numero corrispondente.

Questo è vero. Solo che la stringa potrebbe essere troppo lunga per poter essere rappresentata tramite un valore char o int. Comunque, questa soluzione, nel caso i valori siano limitati ad un certo range, è validissima!


Ciao.

[iguana13]

Al massimo ti fai una array di int...
Ma poi rischia di diventare 1 casino

[internet]

Volevo solo aggiungere un particolare all'ottimo post di LeleFT
di norma i compilatori usano per le strutture un allineamento a 4 byte sulle architetture a 32 bit (dal 386 fino al P4, AMD inclusa), per cui quando farete

#include <stdio.h>

struct bits {
  unsigned char a0 : 1;
  unsigned char a1 : 1;
  unsigned char a2 : 1;
  unsigned char a3 : 1;
  unsigned char a4 : 1;
  unsigned char a5 : 1;
  unsigned char a6 : 1;
  unsigned char a7 : 1;
};

int main()
{
  printf("%d\n",sizeof(struct bits));

  return 0;
}

avrete come risultato 4

la soluzione è forzare il compilatore ad utilizzare un allineamento al byte per quella struttura.

In gcc e in cl (visual c) basta utilizzare la direttiva
#pragma pack()

#include <stdio.h>

#pragma pack(1)
struct bits {
  unsigned char a0 : 1;
  unsigned char a1 : 1;
  unsigned char a2 : 1;
  unsigned char a3 : 1;
  unsigned char a4 : 1;
  unsigned char a5 : 1;
  unsigned char a6 : 1;
  unsigned char a7 : 1;
};
#pragma pack()

int main()
{
  printf("%d\n",sizeof(struct bits));

  return 0;
}

ora avrete come risultato 1

quindi se utilizzate un array di queste strutture valutate l'ipotesi di questa direttiva.

Per quale motivo i compilatori usano per le strutture un allineamento a 4 byte sulle architetture a 32 bit?

Per una questione di performance, quindi pesate la vostra scelta tra

1) Consumo di memoria
o
2) Performance

In c++ esiste nella libreria STL la classe bitfield che implementa proprio un "array di bit" a livello astratto tramite operazioni di shift e array di int.

[LeleFT]

Originariamente inviato da internet
Volevo solo aggiungere un particolare all'ottimo post di LeleFT

Adesso... dov'è che era ottimo il mio post? :gren: :gren:
Ringrazio, comunque, per il complimento.

Originariamente inviato da internet
di norma i compilatori usano per le strutture un allineamento a 4 byte sulle architetture a 32 bit (dal 386 fino al P4, AMD inclusa), per cui quando farete

#include <stdio.h>

struct bits {
  unsigned char a0 : 1;
  unsigned char a1 : 1;
  unsigned char a2 : 1;
  unsigned char a3 : 1;
  unsigned char a4 : 1;
  unsigned char a5 : 1;
  unsigned char a6 : 1;
  unsigned char a7 : 1;
};

int main()
{
  printf("%d\n",sizeof(struct bits));

  return 0;
}

avrete come risultato 4

la soluzione è forzare il compilatore ad utilizzare un allineamento al byte per quella struttura.

In gcc e in cl (visual c) basta utilizzare la direttiva
#pragma pack()

#include <stdio.h>

#pragma pack(1)
struct bits {
  unsigned char a0 : 1;
  unsigned char a1 : 1;
  unsigned char a2 : 1;
  unsigned char a3 : 1;
  unsigned char a4 : 1;
  unsigned char a5 : 1;
  unsigned char a6 : 1;
  unsigned char a7 : 1;
};
#pragma pack()

int main()
{
  printf("%d\n",sizeof(struct bits));

  return 0;
}

ora avrete come risultato 1

quindi se utilizzate un array di queste strutture valutate l'ipotesi di questa direttiva.

Per quale motivo i compilatori usano per le strutture un allineamento a 4 byte sulle architetture a 32 bit?

Per una questione di performance, quindi pesate la vostra scelta tra

1) Consumo di memoria
o
2) Performance

In c++ esiste nella libreria STL la classe bitfield che implementa proprio un "array di bit" a livello astratto tramite operazioni di shift e array di int.

Molto interessante. Non conoscevo questa cosa. Bene... se ne impara sempre una di nuova.
Grazie per le precisazioni.

Ciao.