Occupazione struttura!

[drakend]

Originariamente inviato da cionci
Semplice...fai fare la lettura dell stdin da un'altra funzione... Questa funzione avrà il compito di interpretare i comandi e di estrarre le informazioni...
[...]
Quale principio viola ? L'inserimento si potrebbe in teoria fare meglio... Invece di un bit alla volta si potrebbero inserire tutti i bit contemporaneamente (o quasi tutti)...

Anche io ci avevo pensato, però devo leggere le cifre binarie e metterle al volo dentro la struttura dati, non è che posso crearmi un array in cui mettermi le cifre, anche perché altrimenti perderebbe senso l'uso della struttura dati dinamica, che è ben più laboriosa da gestire.
Quindi tu mi dici che leggendo un pezzo di stdin in una funzione e l'altro nella funzione chiamata è corretto dal punto di vista concettuale? A me potrebbe non fregarmene di meno, però ai professori di algoritmi penso di sì
Inoltre sai come potrei recuperare il bit scartato da uno shift? Il problema mi sorge perché quando acquisisco le stringhe binarie da stdin queste si trovano nell'ordine MSB->LSB. Sommandone due però poi nella struttura ho la cifra in ordine LSB->MSB e quindi sorgono problemi quando devo sommarne una terza. O creo un'altra struttura in cui metto ricreo l'ordine MSB-LSB o faccio in modo di estrarre i bit da sinistra e non da destra (appunto ma come faccio?)
Scusa se stresso, ma non ho mai usato il C con gli operatori bitwise

[cionci]

Originariamente inviato da drakend
Anche io ci avevo pensato, però devo leggere le cifre binarie e metterle al volo dentro la struttura dati, non è che posso crearmi un array in cui mettermi le cifre, anche perché altrimenti perderebbe senso l'uso della struttura dati dinamica, che è ben più laboriosa da gestire.

E perchè perderebbe senso ?!?!!? Fare un vettore di 32 interi è illegale ? In quel vettore di 32 interi ci infilo 128 bit
Fare una lista di interi non ha senso... E' solo un spreco...

Originariamente inviato da drakend
Quindi tu mi dici che leggendo un pezzo di stdin in una funzione e l'altro nella funzione chiamata è corretto dal punto di vista concettuale? A me potrebbe non fregarmene di meno, però ai professori di algoritmi penso di sì

Nell'esempio che ti ho fatto lo stdin viene letto solamente da leggi_input...

Originariamente inviato da drakend
Inoltre sai come potrei recuperare il bit scartato da uno shift? Il problema mi sorge perché quando acquisisco le stringhe binarie da stdin queste si trovano nell'ordine MSB->LSB. Sommandone due però poi nella struttura ho la cifra in ordine LSB->MSB e quindi sorgono problemi quando devo sommarne una terza. O creo un'altra struttura in cui metto ricreo l'ordine MSB-LSB o faccio in modo di estrarre i bit da sinistra e non da destra (appunto ma come faccio?)
Scusa se stresso, ma non ho mai usato il C con gli operatori bitwise

Se leggi LSB e lo metti nella parte LSB di un intero e leggi MSB e lo metti nella parte MSB di un intero...che problema c'è ?

[cionci]

Ma leggi sempre 8 bit alla volta ?

[drakend]

Originariamente inviato da cionci
E perchè perderebbe senso ?!?!!? Fare un vettore di 32 interi è illegale ? In quel vettore di 32 interi ci infilo 128 bit
Fare una lista di interi non ha senso... E' solo un spreco...

Nell'esempio che ti ho fatto lo stdin viene letto solamente da leggi_input...

Se leggi LSB e lo metti nella parte LSB di un intero e leggi MSB e lo metti nella parte MSB di un intero...che problema c'è ?

Allocare 32 interi per contenere la lunghezza massima della cifra binaria praticamente sarebbe la scelta più rapida, tanto non credo che il prof metta mai stringhe così lunghe... il fatto è che quando va a controllare il codice sorgente mi chiede perché ho messo quel limite e lì mi castra, dato che non vuole limitazioni a priori sulla dimensione delle cifre binarie. Da questa considerazione e dalle discussioni in questo post ho dedotto che era il caso di allocare una struttura con un intero e il puntatore alla struttura successiva nel caso di numeri più lunghi di 32 bit. Dell'intero ne faccio un uso molto improprio: lo uso come stack per metterci dentro un bit alla volta!
Ovviamente il primo bit che mi troverei ad estrarre per l'operazione di addizione sarebbe LSB: nel risultato però l'ordine dei bit si capovolgerebbe. Potrei estrarre i bit da sinistra usando una maschera di bit e facendone l'and con il risultato, però quanto deve essere lunga questa maschera? 32 bit? L'unsigned int è sempre di 4 byte in ogni sistema secondo lo standard ANSI?

[drakend]

Originariamente inviato da cionci
Ma leggi sempre 8 bit alla volta ?

No, scrivo e leggo 1 bit per volta. Per scrivere dentro il mio "stack" faccio l'or fra il campo intero e il numero binario proveniente da stdin e poi faccio uno scorrimento a sinistra. Per fare il contrario dovrei fare l'and con il campo intero e poi scorrere a destra (o a sinistra, nel caso di ordine ribaltato) il campo stesso.

[cionci]

Originariamente inviato da drakend
Allocare 32 interi per contenere la lunghezza massima della cifra binaria praticamente sarebbe la scelta più rapida, tanto non credo che il prof metta mai stringhe così lunghe... il fatto è che quando va a controllare il codice sorgente mi chiede perché ho messo quel limite e lì mi castra, dato che non vuole limitazioni a priori sulla dimensione delle cifre binarie. Da questa considerazione e dalle discussioni in questo post ho dedotto che era il caso di allocare una struttura con un intero e il puntatore alla struttura successiva nel caso di numeri più lunghi di 32 bit. Dell'intero ne faccio un uso molto improprio: lo uso come stack per metterci dentro un bit alla volta!

Allora non hai guardato il mio codice

Ho messo un vettore di 32 interi...ma non per contenere tutti i possibili valori immessi...

struct bits
{
   unsigned int data[BYTELEN];
   int pos; /*indica il primo libero*/
   struct bits *next;
};

Se noti bene quella è una lista !!! Quando sono finiti gli interi puoi sempre allocare altre strutture (come d'altronde faccio nel codice successivo)...
Allora, se vuoi usare la struttura come uno stack è comuqnue facile...
Comunque mi hai detto tu che dovevi leggere taaanti bit... E questa è la struttura migliore per leggerne tanti (non allocare ogni volta un solo int, che sarebbe uno spreco di spazio, per 32 bit allochi anche 32 bit di puntatore)... Magari per un programma scolastico può anche andare bene... Comunque nel mio prog se metti BYTELEN a 1 ottieni praticamente lo stesso risultato

Gli interi sono a 32 bit su tutti i sistemi a 32 bit (il codice che ho scritto con un piccolo cambiamento può funzionare con qualsiasi dimensione degli interi)...ed anche tu dovresti farlo in grado di funzionare con qualsiasi dimensione degli interi...

Con piccoli cambiamenti si può adattare alla tua situazione...

#define BYTELEN 32
#define LEN BYTELEN*sizeof(int)

struct bits
{
   unsigned int data[BYTELEN];
   int pos; /*indica il primo libero*/
   struct bits *next;
};

/* se vuoi una struttura come stack */
struct bits *alloca_stack(struct bits *next)
{
    struct bits *nuovo;
    int i;
    nuovo = (struct bits *)malloc(sizeof(struct bits *));
    /* le strutture esistenti vengono messe in coda */
    nuovo->next = next; 
    nuovo->pos = 0;
    for(i = 0; i < BYTELEN; ++i)
        nuovo->data[i] = 0;
    return nuovo;
}

int inserisci_bit(struct bits **data, char cbit)
{
    unsiegned int op;
    if(!(cbit == '0' || cbit == '1'))
       return -1;

    if((*data)->pos == LEN) /* è pieno */
       (*data) = alloca_stack(*data);

    /* il bit viene inserito a partire dal LSB dell'int */
    op = 1 << ((*data)->pos)%(sizeof(int)*8);
    if(cbit == '1')
       ((*data)->data[((*data)->pos)/(sizeof(int)*8)] |= op;
    else /*inserimento dello 0*/
       ((*data)->data[((*data)->pos)/(sizeof(int)*8)] &= ~op;
    return 0;
}

int inserisci(struct bits **data, char *sbits)
{
    if(!sbits || !*data)
       return -1;
    while(strlen(sbits) > 0) {
       if(inserisci_bit(data, *sbits))
          return -1;
       ++sbits;
    }
    return 0;
}

int leggi_input(FILE *in = stdin)
{
   struct bits *data;
   data = alloca_stack(NULL);
   /*ora leggi da "in" l'input,
   quando hai trovato il comando e la stringa di bit
   semplicemente richiami: */
   inserisci(data, stringa_bits);
}

[cionci]

Originariamente inviato da drakend
No, scrivo e leggo 1 bit per volta. Per scrivere dentro il mio "stack" faccio l'or fra il campo intero e il numero binario proveniente da stdin e poi faccio uno scorrimento a sinistra. Per fare il contrario dovrei fare l'and con il campo intero e poi scorrere a destra (o a sinistra, nel caso di ordine ribaltato) il campo stesso.

Non importa fare lo shift...basta tenere un contatore...
Altrimenti quando hai una intera lista di interi quando fai uno shift devi farlo su tutti e devi recuperare l'ultimo bit che esce e metterlo nella struttura successiva (un macello)...