Newsgroup: it.comp.lang.c
Titolo: gestione stringhe

salve,
premetto che sono un newbye in C,
devo realizzare un programma che faccia una conversione binario->decimale.
siccome le conversioni da effettuare sono diverse [ bin->dec, bin IEE754 ->
dec, bin complemento1 ->dec....]
pensavo di far inserire il numero binario in un array di char [o int] e poi
di gestire l'array per fare le dovute conversioni.
Per essere sicuro di non avere problemi alloco la memoria relativa all'array
poi pero' quando cerco di copiare il carattere preso in input da tastiera il
compilatore [borland C++] mi dice che non puo' fare un casting da "char" a
"char *".
Se non alloco la memoria dell'array invece in fase di lettura mi crasha
tutto o compaiono strani simboli nell'array stesso.
come posso fare???
Enjoy
Fullo
fu...@libero.it
---------------------------
#include <stdio.h>
#include <string.h>
static int num[33];
static char segno;
static int m,e;
char main()
{
char numero, *b[33], k='0';
*b = (char *)calloc(33, sizeof(char));                   // alloco la
memoria
 printf("Immetti il numero che vuoi convertire: \n");
   int le=0;                                                           //
contatore per evitare di avere in input + di 32 valori
   while ((k != '\n') && (le<33))
      k = getchar();                                                //
prendo il carattere da copiare nell'array e controllo che sia valido
    if ((k=='1') || (k=='0'))
      {
        *(b+le) = k;                                                // QUI
DA ERRORE
         le++;                                                          //
aggiorno contatore
      }
      else printf("carattere non valido, immetine un'altro \n");
printf("String is \n");
for (int i=0; i<33; i++)
     printf("%s", *(b+i));
free(b);
 return 0;
}
----------------------------------------------------------------------------
-------
------------°~ Visitate il Rat-Project!!!!!! ~°------------
All Version: [ 
http://ratproject.spedia.net
 ]
All Version: [ 
http://fly.to/rat-man
 ]
Old Version: [ 
http://members.xoom.it/ratproject/index2.html
 ]
ICQ: # 13515051 ~°--------°~ E-Mail: 
fu...@libero.it

 come posso fare???
Come prima cosa vorrei sapere se il programma è scritto in C o C++. Dato
il nome del newsgroup immagino sia C ma allora ci sono alcune cose che
non vanno (le dichiarazioni in mezzo al codice, il commento //). Il mio
consiglio è di compilarlo in modalità giusta (ipotizzo sia C) e cercare
di eliminare uno per uno tutti gli errori e warnings che risultano (char
main() la dovevo ancora vedere...). Poi fatti risentire se alla fine di
tutto questo hai ancora problemi.
EMG

 non vanno (le dichiarazioni in mezzo al codice, il commento file://). Il


 --------------------------------------------------------------------------


non vanno (le dichiarazioni in mezzo al codice, il commento //). 
Sui commenti siamo d'accordo. In quanto alle dichiarazioni, lo
standard C99 consente di adottare la stessa tecnica C++.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

   alla main*/
Con il nuovo standard e' consentito.


 standard C99 consente di adottare la stessa tecnica C++.
Se parliamo di C9X, permette anche i commenti alla C++ // .....
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 Con il nuovo standard e' consentito.
ahhh....questa non la sapevo....grazie!
Però continuerò ad usare il vecchio metodo...
mi sembra più razionale!


 standard C99 consente di adottare la stessa tecnica C++.
Buono a sapersi. E ci sono gią compilatori compliant?
EMG

 mi sembra piů razionale!
Piů razionale sotto quale punto di vista? In realtŕ il fatto di
dichiarare le variabili esattamente dove servono risulta una scelta, a
mio avviso, molto migliore.
EMG

 Buono a sapersi. E ci sono gią compilatori compliant?
No che io sappia; ma lo standard e' approvato e definitivo.


 EMG

 Beh razionale nel senso che se dimentico il significato di una variabile o
come l'ho inizializzata dove me la vado a cercare in un mare di codice?

 del codice stesso.
Secondo me la leggibilita' del codice e' finalizzata alla sua
comprensione.
Non ha senso, a mio avviso, far vedere un nome di variabile che verra'
usata molto piu' in la' nel codice sin dal primo momento. Questione di
punti di vista ;)
--
Posted from root@[194.91.112.199]
via Mailgate.ORG Server - 
http://www.mailgate.org

 come l'ho inizializzata dove me la vado a cercare in un mare di codice?
A parte il fatto che secondo me e' piu' razionale che uno usi una
variabile nel momento in cui serve, 
la possibilita' di dichiarare in qualsiasi punto del codice serve
proprio ad evitare che non vi siano inizializzazioni.


 come l'ho inizializzata dove me la vado a cercare in un mare di codice?
Se uno è disordinato di natura non c'è compilatore che possa aiutarlo.
Se uno invece è ordinato troverà la possibilità (non l'obbligo,
attenzione) di dichiarare le variabili nel punto in cui gli servono
molto comoda.
EMG

 punti di vista ;)
Senza contare che cosě facendo, nella maggior parte dei casi, non puoi
inizializzare la variabile contestualmente alla sua definizione in
quanto in quel punto ancora non hai disponibili i dati necessari.
EMG

 dal primo momento. Questione di punti di vista ;)
  Infatti: se guardi la situazione al contrario, non ha senso andare
ramenghi per il codice alla ricerca della dichiarazione di una variabile
(a meno che questa non sia utilizzata solo e soltanto in prossimita`
della sua dichiarazione, i.e. gli indici delle iterazioni). ;)
	Alla prossima,
		Marco

 aiutarlo.
  Il compilatore non deve aiutare il "disordinato" ma il povero cristo
che deve (fare il debug|riutilizzare) il suo codice... ;)
	Alla prossima,
		Marco
PS I love COBOL... :)))

della sua dichiarazione, i.e. gli indici delle iterazioni). ;)
Le dichiarazioni all'interno del codice servono ad evitare bug che
normalmente costringono a "cercare una variabile" per conoscerne il
valore. 


 conoscerne il valore.
  Ci vorrebbe una Ferrarelle... :)
	Alla prossima,
		Marco

 che deve (fare il debug|riutilizzare) il suo codice... ;)
Certo. Ma infatti l'ordinato, trovandosi con una possibilità in più
(quella di dichiarare dove vuole), la sfrutterà nel migliore dei modi e
non ne sarà succube.
EMG

 variabile nel momento in cui serve,
E poi se ricordo bene, le variabili dichiarate all'interno di un blocco
vengono allocate e deallocate solo all'ingresso e uscita del blocco stesso.
Può essere anche un risparmio di memoria e maggiore efficienza.
int main(){
  ...
  if (a==b){
    int vett[1000];
    ...
  }
  ...
}
Se non sbaglio, in questo caso l'array vett viene allocato solo se è
verificata la condizione dell'if, altrimenti ci siamo risparmiati di
allocare e deallocare 1000 interi.
--
________________________________
Togliete NoSpaM per rispondermi
bye Brain

allocare e deallocare 1000 interi.
Ben poco risparmio in verita'.
In molte macchine (quelle con uno stack, con piu' registri e un set di
istruzioni quantomeno "decente") l'allocazione di _tutte_ le variabili
automatiche (dichiarate subito) viene fatta in un colpo solo. E lo stesso la
deallocazione.
Nelle intel in genere si usano tre (o due?) istruzioni per creare il frame e
un paio per distruggerlo, ma mi sembra che dal 286 in poi esista la coppia
enter/leave che piu' o meno fa proprio questo (sebbene io non l'abbia mai
usata).
Solo se non c'e' nessuna variabile automatica si puo' risparmiare di creare
il frame.
E gia' che ci sono dico la mia sul fatto delle variabili messe in mezzo al
codice.
Secondo me peggiorano la leggibilita'. Magari a volte sono comode, se c'e'
da mettere un for "di prova", ma in genere preferisco dichiarare tutto
subito.
Marco

 deallocazione.
Cosa intendi dire con "in un colpo solo"?


Cosa intendi dire con "in un colpo solo"?
Ad esempio con
push bp
mov bp, sp
sub sp, dimensione_di_tutte_le_variabili
viene creato il frame, e poi con
mov sp, bp
pop bp
viene distrutto. Il chiamante, a sua volta, toglie il numero di byte
necessario da sp.
Questo processo, valido solo per le macchine intel (ma comunque, su
architetture non troppo "strane" e' simile dappertutto) e' indipendente
dalla dimensione totale delle variabili automatiche da allocare.
Solo se il valore da allocare e' zero posso evitare di creare e distruggere
i frame.
Tutti i compilatori C (su macchine intel) che conosco usano questo sistema.
E mi pare difficile trovarne uno piu' efficiente, quindi presumo che tutti i
compilatori lo usino.
Maro Fabiani

 necessario da sp.
Ahh.. ho capito cosa volevi dire, ci ho messo un po' ma sono riuscito a
scrollare la ruggine assembler dai miei neuroni. ;-)


 Cosa intendi dire con "in un colpo solo"?
... probabilmente intende che il codice macchina per allocare 1 variabile
int è semplicemente:
sub esp,4
mentre per allocarne 10 è
sub esp,4*10
Ovvero non importa quante variabili dichiari all'interno di una funzione, il
compilatore la risolverà sempre e soltanto con una istruzione del genere.
Non vale ovviamente per le variabili dinamiche :))

 No che io sappia; ma lo standard e' approvato e definitivo.
Sono sicuro al 99,9% che il GCC lo supporta, e da molto prima che fosse standard.
[Linux Maniac Mode ON]
In ogni caso, buttate pure via i cari Borland e Visual C++, andate su Linux e
usate il GCC, che e' gratis, compila 10000 volte meglio e vi da pure tutti i
sorgenti suoi, delle librerie, dei debugger....
[Linux Maniac Mode OFF]
Alceste

 writes:

GCC non supporta ancora C9X.
Qui si parla di nuovi tipi come "bool" e "complex", di nuovi header
files come "fenv.h", di nuovi modifiers come "restrict".
Probabilmente intendi il vecchio standard ANSI-ISO, C8X; questo nuovo
e' nato da poche settimane.


sorgenti suoi, delle librerie, dei debugger....
Ne riparliamo quando esisteranno i tool visuali sotto Linux.

...


 Ne riparliamo quando esisteranno i tool visuali sotto Linux.
  Se e` per questo, ammesso che possano realmente servire a qualcosa, ce
n'e` gia` un bel po'... ;)
	Alla prossima,
		Marco

n'e` gia` un bel po'... ;)
Be', ma non credo che supportino framework in stile VCL, o mi sbaglio
?

Ciao Ippopapero, come va?

  Muble... muble... Sicuramente ce n'e` almeno uno per Motif e
probabilmente ce ne saranno anche per Qt, dato lo sviluppo del toolkit
in questi ultimi due o tre anni. Quasi certamente, invece, non ce n'e`
ne per Athena o per Xtk... e non se ne sente la mancanza. :)
	Alla prossima,
		Marco