Newsgroup: it.comp.lang.c
Titolo: Funzione malloc

Sto compilando con il Borland C++ sotto windows
quando compilo il programmino qui sotto (manca il main) mi manda errore
sulla riga dove c'è malloc !
Eppure la libreria <stdlib.h> l'ho definita !!!
Non capisco, il programma l'ho preso dalle dispense del mio prof !!!!
Aiuto !!!!!!!
Se il Borland non vede malloc posso pure smettere di studiare informatica !
Il prossimo esonero è tutto su liste , alberi e grafi !!!!
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
struct nodo {
 int info;
   struct nodo *next;
};
struct nodo *leggi_lista (void) {
 struct nodo *p, *primo;
   int x, n, i;
   printf("Numero di elementi: ");
   scanf("%d", &n);
   primo = NULL;
   for (i=0;i<n; i++) {
    scanf("%d",&x);
      p= malloc(sizeof(struct nodo));
      p->info = x;
      p->next = primo;
      primo = p;
   }
   return(primo);
}


A quanto pare, il vostro prof si è dimenticato completamente di accennarvi
dell'esistenza di un'operazione chiamata cast. Non è possibile che un
compilatore noto e efficiente come quello borland (riconosciuto da molti
sviluppatori di software) non accetti malloc(). E' anche strano che il tuo
prof si sia dimenticato di mettere un cast nella riga di codice per la
conversione da void * a struct _nodo *
La versione corretta è questa
  p = (nodo *) malloc(sizeof(nodo));
Come puoi notare, infatti, il compilatore non ritorna come errore
"Undeclared Identifier" (tipico dei casi in cui una funzione non viene
riconosciuta), segnala un più appropriato errore di cast:
error C2440: '=' : cannot convert from 'void *' to 'struct _nodo *'
        Conversion from 'void*' to pointer to non-'void' requires an
explicit cast
Proprio dalla riga dell'malloc
La funzione malloc restituisce un valore void *, ed è necessario convertirlo
in nodo* per poterlo utilizzare come tale. Se usi un compilatore ANSI C /
C++ il cast è obbligatorio, in tutti i casi, mentre nel vecchio C tutto
quanto avveniva automaticamente.
Preferisco la forma con il typedef, è più logica e si sprecano meno
caratteri nella definizione di puntatori e oggetti. Eccoti la versione
corretta e funzionante (segnalalo al tuo prof, è un errore grave
specialmente se è stato lui a consigliarvi il compilatore borland, dato che
una simile sintassi non è più valida):
typedef struct _nodo
{
 int info;
 struct _nodo *next;
} nodo;
nodo *leggi_lista (void)
{
 nodo *p, *primo;
 int x, n, i;
 printf("Numero di elementi: ");
 scanf("%d", &n);
 primo = NULL;
 for (i=0;i<n; i++)
 {
  scanf("%d",&x);
  p = (nodo *) malloc(sizeof(nodo));
  p->info = x;
  p->next = primo;
  primo = p;
 }
 return(primo);
}
void main()
{
 leggi_lista();
}

   p = (nodo *) malloc(sizeof(nodo));
Neanche per sogno! Il professore ha ragione.
EMG

 ha scritto nel messaggio
news:3B0A646A...@flashnet.it...

eheheh :P Ti credo, prova a contraddirlo e vedi quello che ti succede. :-)
Cmq è corretto se usi un vecchio compilatore, magari K & R, ma se ne usi uno
odierno, specie se C++ devi forzatamente specificare il cast per la
conversione.
Il prof ha sbagliato solo se ha detto di compilarlo in ambiente borland c++
senza apportare modifiche, altrimenti ha ragione lui.


in ogni caso, i risultati del compilatore parlano da soli :)

 ha scritto nel messaggio
news:VOuO6.113$w4....@news1.tin.it...

Per quel che riguarda il borlandC hai un errore solo se compili in C++ (dove
lo standard dice che il cast e' obbligatorio), mentre se compili in C non da
errori (dove lo standard dice che il cast e' automatico).
Il Borlandc decide se usare l'una o l'altra via a seconda dell'estensione
del file sorgente (se non hai cambiato l'apposita opzione).
Quindi probabilmente l'autore del thread sta compilando un sorgente.cpp
ciao
donCiccio

Nell'introduzione alle dispense del prof. c'è scritto :
" Le soluzioni in linguaggio C riportate in questo volume sono state provate
una ad una, compilandole utilizzando il "gcc" (GNU C Compiler) in ambiente
UNIX. Visto che i programmi proposti non fanno uso di caratteristiche
particolari di questo compilatore , sarà possibile compilarli con successo
su ogni altra piattaforma (ad esempio con il compilatore Borland C/C++ in
ambiente Microsoft DOS o Microsoft Windows). "
Quindi secondo me il prof. si è sbagliato !!!
Menomale che ci siete voi !!! Se no come facevo?
Grazie Roberta.
P.S. Se in UNIX metto la procedura che funziona con il Borland il programma
gira lo stesso?

 Menomale che ci siete voi !!! Se no come facevo?
mi dispiace Roberta il prof. non ha detto nulla di errato :-(
leggi l'altro mio post sempre in questo thread.
ciao
donCiccio


Ciao sono andata a leggere il tuo post(non l'avevo proprio visto! :-))   ):
scrivi :
" Il Borlandc decide se usare l'una o l'altra via a seconda dell'estensione
del file sorgente (se non hai cambiato l'apposita opzione).
Quindi probabilmente l'autore del thread sta compilando un sorgente.cpp"
cioč? intendi dire che c'č un comando che fa decidere al Borland di
compilare in C o in C++?
In effetti i miei programmi vengono salvati con estensione .cpp.
Qual'č questo comando?

 leggi l'altro mio post sempre in questo thread.
Già, ma avrebbe almeno potuto essere più preciso considerato che di fronte
potrebbe avere anche un pubblico di gente poco pratica di programmazione.

 Qual'č questo comando?
nessun comando, devi solo rinominare i tuoi file *.C
e quando salvi o crei nuovi file, chiamali nomefile.C
ciao
donCiccio

 post, pareva proprio che fosse richiesto il c++.
a me pare solo che avesse detto il nome del compilatore
se gli interesseva il C++ avrebbe usato new e non malloc, e avrebbe
postato in it.comp.lang.c++
qui si parla di C.
ciao
donCiccio

 ha scritto nel messaggio
news:keAO6.961$w4.2...@news1.tin.it...

Già scusatemi ... il problema è che anch'io sono MOOOLTO POCO pratica di
programmazione e non avevo pensato a specificare che sto studiando il C e
uso come compilatore il Borland C++.
Cmq i vostri aiuti sono risultati utilissimi.
Infatti credo che vi chiederò molto presto altre cose :-))))
Sto studiando per il mio secondo esonero ... al primo ho preso 23 e vorrei
tanto migliorare !!!
Grazie ancora Robby (<- il mio vero nome) :-)))


beh scusa tanto, allora ero OT. Poi non intendevo mica giustificarmi con te,
che subito hai colto l'occasione per sparare sentenze, dato che ho cercato
solo di aiutarla, mentre a quanto vedo, da parte tua ho letto solo critiche.
Ciao

solo di aiutarla, mentre a quanto vedo, da parte tua ho letto solo critiche.
Il corso e' un corso di C e non di C++. Se fosse stato C++ non
si sarebbe usato senza una giustificazione precisa "malloc" ma
"new" (che non richiede cast in quanto il puntatore tornato e'
gia' del tipo corretto) o anche usandolo non si sarebbe usata
la sconsigliabile forma "(nodo *)..." ma la preferibile in
quanto piu' specifica "static_cast<nodo *>(...)".
Il problema e' che:
  1) Tu accendi la bocca prima di aver verificato
     che il cervello sia collegato.
  2) Parli a vanvera di cose su cui hai le idee
     molto confuse (vedi obbligatorieta' del cast
     su compilatori C).
  3) Tendi a voler difendere l'indifendibile (vedi
     valanga di post inutili al seguito del gia'
     inutile primo post).
C'e' una differenza fra aver detto una cretinata ed essere
un cretino. Insistere a tutti i costi su una cretinata
detta e' uno dei modi di identificarsi come cretino.
Resta inoltre il problema di base di contestare da subito
quanto ha detto il "professore" partendo come prima ipotesi
dal fatto che questi abbia sbagliato. Sicuramente anche i
professori sbagliano (e i libri contengono errori e i
compilatori contengono bug) ma cominciare a indagare sui
problemi partendo da quelle ipotesi e' un modo sicuro di
non arrivare a capire un tubo.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

quanto piu' specifica "static_cast<nodo *>(...)".
Sicuramente da consigliare a chi è alle prime armi vero? Ci capirà qualcosa
senza meno. Lo sappiamo che sei bravo, non vedo perchè tu tenda a tutti
costi a volerlo dimostrare. Per caso di recente qualcuno lo ha negato? O
soffri di questa paura? Magari volevi solo dire qualcosa, così...
Alcuni risolvono i loro problemi di auto stima, guardandosi allo specchio e
parlando con se stessi, apprezzandosi. Potrebbe essere un'idea.
Concludo con una risata, vedo che come ai vecchi tempi, sia nelle chat che
sui ng ci sono molte persone alienate, arroganti e piene di boria. NOTA: Non
ho detto che lo siano tutti (ci mancherebbe altro), ma tu mi sembri un
principale esponente di questa categoria. Posso anche sbagliarmi (ovviamente
tu no), ma per una stronzata non avresti dovuto prendertela così tanto. Fai
un controllo della pressione, è un consiglio che ti do da amico.
Concludo con altri tre consigli: una camomilla al posto del caffè la
mattina, alcune lezioni di galateo ed una seduta con un bravo psicologo
(nonchè una lunga passeggiata in montagna, ti farà bene). Può essere utile
anche frequentare gente allegra e disponibile, che magari non parla sempre
di codice (è un dettaglio).
Vabe, per oggi è abbastanza, non ho più tempo, vado a fare la terapia.
Auguro a tutti una buona giornata.

sorry per irrisolvibile, avevo fretta. ;) bye

... terapia disintossicante, consiste nel frequentare gente più normale.

 la conversione.
Se usi un compilatore C aderente allo standard il cast non e`
necessario, anzi e` dannoso (ci sono stati molto post - quasi flame - al
riguardo). Se il compilatore e` C++ allora il cast e` necessario.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
La somma dell'intelligenza sulla terra e` una costante.
La popolazione e` in aumento.

paura? Magari volevi solo dire qualcosa, così...
--- Riassumendo ---
Credo che nemmeno ad una tonto con una minima infarinatura
di C++ possa venire il dubbio che quello fosse un listato
presentato in un corso di C++ invece che (come evidente) in
un corso di C.
Se tu hai una minima infarinatura di C++ allora sei, secondo
il mio metro, un po' piu' tonto di un tonto... oppure (molto
piu' probabilmente) stai cercando per qualche strano e oscuro
motivo di difendere qualcosa che non puo' essere difeso (e
allora non e' piu' una questione di intelligenza...)
Occasioni per dire "scusate non avevo capito, il prof ha
ragione (come EMG, donCiccio e Kronos) e il sorgente devi
salvarlo in un file .c" ne hai avute.
Invece niente. Questa non e' la tua forma mentis.
Mi spiace un poco per la fine che rischia di fare chi ti
da credito...
Quello che mi ha dato fastidio non e' certamente il tuo
consiglio errato (errato era errato; e questo non e'
opinabile, ma sbagliare e' umano) ... ma piuttosto come
hai risposto a EMG e donCiccio che hanno inutilmente
cercato di porre rimedio alle cavolate che stavi dicendo.


quanto sia sizeof('a')).
qual'è la differenza nel caso di sizeof('a')?
Anto
--
Antonio Cuni, 19 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

 conversione.
Ti stai confondendo. Il cast è obbligatorio solo in C++. In C standard
non solo non è richiesto ma può essere addirittura dannoso.
EMG

 in ogni caso, i risultati del compilatore parlano da soli :)
Probabilmente l'amico sta compilando un programma C in modalità C++...
EMG

qual'č la differenza nel caso di sizeof('a')?
In "C" sizeof('a')==sizeof(int) mentre in "C++"
sizeof('a')==sizeof(char)==1.


Provate a fare una discussione come questa
lavorando in una azienda privata è verrete declassati
a lustra ceramiche bianche per sanitari .........
;-P

P.S.
comunque comprarsi il K.& R.
vale pių di qualsiasi Compilatore Borland MS o GNU che sia
salutoni ...................

a lustra ceramiche bianche per sanitari .........
Io lavoro in una azienda privata. Cosa intendi dire ?


Qual'č questo comando?
Perfetto. Ora si spiega tutto.
Stai compilando del codice che tu ritieni C, ma dal compilatore viene
ritenuto C++.
Questo e' uno dei motivi che mi fa incazzare quando le persone
affermano che ogni programma C e' anche un valido programma C++.

      p= malloc(sizeof(struct nodo));
Come gia' detto nel precedente messaggio, i cast sono soggetti a
regole diverse a seconda che si compili codice C o C++.
Il C e' abbastanza debole nel controllo dei tipi, la conversione da
void* a puntatore tipizzato avviene in automatico durante
l'assegnazione e non e' quindi necessario utilizzare un cast.
E' importante non utilizzare il cast, perche' immagina di dimenticarti
di includere la stdlib.h.
Se aggiungi un cast, stai forzatamente dicendo al compilatore : non
preoccuparti per la conversione del valore di ritorno di questa
funzione, tu convertimela con questo tipo e basta.
Se invece il cast lo eviti, il compilatore non trovando il prototipo,
assumera' il tipo di ritorno int e ti dara' un errore in compilazione
dicendoti : guarda che questa funzione (di cui non ho trovato il
prototipo) restituisce un valore intero che non posso convertire nel
valore di un puntatore tipizzato (c'e' un type-mismatch).
Ti accorgerai dell'errore e provvederai.
In C++ invece, questo non e' possibile, perche' i prototipi sono
obbligatori e la conversione da void* a puntatore tipizzato non e'
automatica.

void main()
^^^^
Lo standard prescrive :
int main()
non 
void main()

detta e' uno dei modi di identificarsi come cretino.
Si', ma cerca di darti una calmata...

il mio metro, un po' piu' tonto di un tonto...
Griffini, le persone possono sbagliare e possono essere convinte delle
loro idee anche quando sono sbagliate, cercando di difenderle.
Non per questo gli si da' del "cretino" o del "piu' tonto di un
tonto".  Cercate di dare un taglio a questo "flame" per cortesia.

tonto".  Cercate di dare un taglio a questo "flame" per cortesia.
Io ho notato solo che il buon sabin ha detto cose errate... (questo
capita a tutti, me per primo) dando poi dell'incompetente ad un
docente che non aveva commesso errori (gli errori erano suoi) e
dello "sputasentenze" o cercando di ridicolizzare chi, senza essere
pagato per questo, cercava di rimetterlo sulla buona strada.
Non una buona strada opinabile. Non chi cercava di allinearlo ad
una delle possibili visioni della vita. Semplicemente chi cercava
di ricordargli l'oggettivamente corretto.
Tutto qui. Per mostrare intelligenza sarebbe bastato scusarsi.
Arroccarsi a difendere le cretinate dette non e' segno di forza
o di coerenza... semplicemente solamente di imbecillita'.
Non ho visto da parte di sabin nessun tipo di scuse nei confronti
di chi ha ragione e cercava di portarlo a riflettere o di chi
lui aveva inconsciamente depistato (perche' di depistaggio si
trattava).


o di coerenza... semplicemente solamente di imbecillita'.
Va bene.  Sei il piu' bravo di tutti. 
Ora basta con sto flame.

salutoni ...................
Mi spieghi come fai a confrontare un libro con un compilatore ?
Tieni anche presente che su questo argomento, persino il K&R II si
sbaglia.  E' uno dei vari errata corrige che spiega come stanno
esattamente le cose.

}
Per la portabilità mai usare un puntatore per accedere a un elemento di un
array
sul pianeta  XARKON un char è grande 10 byte
saluti
:c)

sul pianeta  XARKON un char è grande 10 byte
Sorry? Che vuol dire non usare mai un puntatore per accedere a un elemento
di un array? Dove sta il problema? Cosa c'entra la dimensione in byte dei
char?
Lanugo

array sul pianeta  XARKON un char è grande 10 byte
???????
Questa me la devi proprio spiegare.
Stai forse affermando che se scrivo :
int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
int *p = &a[3] ;
il mio codice e' poco portabile ?
Se e' cosi', guarda che hai preso un grosso granchio.

int *p = &a[3] ;
Bravo ciusto !
Chiedo scusa ma ho scritto una cosa e ne pensavo un'altra
quello che intendevo dire è che vanno usati con cautela ........
esempio:
/*sulla TERRA */
#include <stdio.h>
void main(void)
{
   char *a="prova di puntatore";
  int x, n, i;
   for (i=0;i<10; i++)
        printf("\n %s",a+i);
}
/*Ecco il risultato sulla TERRA */
 prova di puntatore
 rova di puntatore
 ova di puntatore
 va di puntatore
 a di puntatore
  di puntatore
 di puntatore
 i puntatore
  puntatore
 puntatore
su XARCON stranne la prima riga
il resto uscirebbe tutto scasinato perchè il char è fisicamente di 10 byte
su XARCON e sul resto dell'universo serebbe giusto così
#include <stdio.h>
void main(void)
{
   char *a="prova di puntatore";
  int x, n, i;
   for (i=0;i<10; i++)
        printf("\n %s",a+sizeof(char)*i);
/* ho adottato questa formuletta per muovermi in un framebuffer 14 anni fà
:c) */
}
Per non rompere le Balle agli XARCONIANI sappiate che in Giappone , in Cina
... e non so dove ....... il char è a 16 Bit   invece che 8
Per quanto riguarda il  cast (dopo che avete riletto bene il mio post
..............st ...st...st ..)
 e avete appurato che non mi riferivo ai puntatori
..... tranne che per il buon vecchio MSDOS ........in certi casi
............
Sfido chiunque a non aver mai ....... dovuto usare un intero in una
espressione in cui il risultato è .........
un esempio:
 divertitevi .........
void main(void)
{
   double totale;
  totale=3/2; /* se lo fate con due int invece delle costanti è ugggguale */
  printf("\n totale sbagliato %lf",totale);
  totale=(double)3/(double)2;
  printf("\n totale giusto %lf",totale);
}
Scusate la mia pigriza ma fa caldo .... è l'ultima volta che scrivo in
questo treeeeeeeead
quindi se volete approfittarne per dire l'ultima parola  e darmi del
coglione
approfittatene:
Stupido è chi lo Stupido fà

vedi risposta ad Andrea

il resto uscirebbe tutto scasinato perchè il char è fisicamente di 10 byte
No, l'arimtetica dei puntatori garantisce che se a è un char * allora a++ (o
++a) puntano al char successivo, qualunque sia la dimensione del char sul
sistema.
Non c'è bisogno di andare su XARCON. Sulla Terra ci sono sistemi coi char a
7 bit, ad esempio.
Lanugo

questo treeeeeeeead 
Se continuerai ad insistere in questo modo, sara' meglio per te.
Ti rammento, per concludere, che la forma "void main" e' assolutamente
illegale secondo lo standard.  main DEVE restituire un intero.

Stupido è chi lo Stupido fà
Un altro consiglio spassionato e' quello di smettere di
fumare quella robaccia... ti brucia il cervello ;)


void main(void)
Vabbe', io mi sono fermato qui...
PS: rileggiti il K&R, o anche qualche altro testo (non di Schildt,
perche' mi sembra che hai studiato su uno dei sui libri)
-- 
 (o-  | Un OS per domarli, Un OS per trovarli,
 //\  | Un OS per ghermirli e nel buio incatenarli
 V_/_ | Nella terra di Redmond, ove l'ombra cupa scende...
Tessera 99ers 204           raffaele punto salmaso presso libero punto it

void main(void)
"casa dolce casa ..................."
 E come lo inizieresti un programma da mettere in
un microcontroller o un BIOS
e visto che il mio compilatore con i controlli al massimo
non dà errore
per me va bene .............
non esisteste una verità assoluta ...........
esistono solo mezze verità ..............

esistono solo mezze verità ..............
Appunto, tu (e il tuo compilatore) sbagliate :)
PS: se poi e' l'unico compilatore che supporta quel micro, pazienza,
ma non dire che e' standard una cosa che non lo e' solo perche' lo
supporta il tuo compilatore, altrimenti diventa standard anche __int64


non dà errore per me va bene .............
Non e' un buon motivo per usarlo.
Ci sono tanti comportamenti sui quali il compilatore, con i controlli
al massimo, non si lamenta e poi a run-time generano crash.
Fai bene ad avere un po' piu' di umilta' e andarti a studiare gli
standard.

Se tu programmi in Unix o un qualsiasi ambiente Posix
hai ragione a studiarti le
librerie standard definite in quell'ambiente
main  verrà chiamato dal SO e dovrà dargli delle risposte all'uscita
per chiudere il processo .............
ma nel caso che uno scriva un Bios o applicazioni  messe su ROM, mi spieghi
a chi debbano rendere conto queste .......
io uso il C come sostituto/complemento all'Assembler e credo che
sia lo spirito originario di chi ha inventato questo  linguaggio ........
main è una funzione come le altre ,tranne che per il fatto che viene
chiamata per prima ....  gli argomenti, il ritorno di un valore sono più
problemi del SO che del linguaggio .......
comunque così come è:
void main(void)
{
int a,b;
a=4;
b=a*4;
}
 /* compilato senza errori e warning
 in MS C/C++  5.0
gcc da un warning ma lo compila
*/
Se vuoi ridere :
direttamente dall'help in linea di MS C/C++  5.0
Example
/* PRINTF.C: This program uses the printf and wprintf functions
 * to produce formatted output.
 */
#include <stdio.h>
void main( void )
{
   char   ch = 'h', *string = "computer";
   int    count = -9234;
   double fp = 251.7366;
   wchar_t wch = L'w', *wstring = L"Unicode";
   /* Display integers. */
   printf( "Integer formats:\n"
           "\tDecimal: %d  Justified: %.6d  Unsigned: %u\n",
           count, count, count, count );
   printf( "Decimal %d as:\n\tHex: %Xh  C hex: 0x%x  Octal: %o\n",
            count, count, count, count );
   /* Display in different radixes. */
   printf( "Digits 10 equal:\n\tHex: %i  Octal: %i  Decimal: %i\n",
            0x10, 010, 10 );
   /* Display characters. */
   printf("Characters in field (1):\n%10c%5hc%5C%5lc\n", ch, ch, wch, wch);
   wprintf(L"Characters in field (2):\n%10C%5hc%5c%5lc\n", ch, ch, wch,
wch);
   /* Display strings. */
   printf("Strings in field (1):\n%25s\n%25.4hs\n\t%S%25.3ls\n",
   string, string, wstring, wstring);
   wprintf(L"Strings in field (2):\n%25S\n%25.4hs\n\t%s%25.3ls\n",
       string, string, wstring, wstring);
   /* Display real numbers. */
   printf( "Real numbers:\n\t%f %.2f %e %E\n", fp, fp, fp, fp );
   /* Display pointer. */
   printf( "\nAddress as:\t%p\n", &count);
   /* Count characters printed. */
   printf( "\nDisplay to here:\n" );
   printf( "1234567890123456%n78901234567890\n", &count );
   printf( "\tNumber displayed: %d\n\n", count );
}

direttamente dall'help in linea di MS C/C++  5.0
Microsoft utilizza "void main", perche' non ha necessita' di rendere i
suoi esempi portabili.

clem clem .........
Ti assicuro ....... che sono molto umile 
visto che lurko spesso questo NG:
Spesso trovo cose interessanti ...........
che mi possono aiutare nel mio lavoro
Spesso solo discorsi accademici 
che non mi servono a un Tazzo
Se vi sto sulle palle
ditelo 
torno a lurkare ........ 

Spesso solo discorsi accademici 
Torna a lurkare, leggiti le FAQ di comp.lang.c numero 7.7, 7.8 e 11.12
e poi torna a scrivere nel gruppo.

Grazie ...........!!!!!!!!!!!!!!!
Credo  che tu sia l'unico ad avere un motivo valido
per darmi del pirla .............
è un anno che non esercito e a 35 anni
credo di essere un pò rincoglionito .................
saluti

per darmi del pirla .............
Non do mai del pirla.
Lanugo

Indi per cui, il char non potra' MAI essere lungo 10 byte.
Hmm, questo non l'ho capito. Il fatto che sizeof( char ) == 1 implica che
quell'uno sia per forza un byte? Non potrebbe esistere un sistema che
viaggia a multipli di 10 byte, secondo lo standard?
Lanugo



Il "char" e' SEMPRE di dimensione 1 byte.
Non esiste nessun sistema su cui il char e' lungo 10 byte.

quell'uno sia per forza un byte?
Draft dell'ISO C89 :
       [#2] The sizeof operator yields the size (in bytes)  of  its
       operand,  which  may  be  an expression or the parenthesized
       name of a type.
       ...
       [#3] When applied to an operand that has type char, unsigned
       char,  or  signed char, (or a qualified version thereof) the
       result is 1.         

Pag. 32 del mio K&R
cito:
"la precisione di questi oggetti dipende dal tipo di macchina .......!!"
DEC PDP-11
char       8 bits
Honeywell 6000
char       9 bit                 /*come la mettiamo ? */
mai visto un byte di 9 bit 
;-)

l' ANSI e l'ISO vogliono  i linguaggi tutti Uguali
Gli inventori dei linguaggi li inventano
perchè li vogliono con certe caratteristiche .........
Se gli autori del linguaggio
lo avevano previsto flessibile
perche rompergli gli zebbedei con lacci e lacciuoli
non e colpa dei Cinesi o  degli Arabi  se hanno più
di 256 simboli
e se la civiltà umana si evolvesse ..............
magari ai livelli degli XARKON
Con un char (da 10 byte)
potrebbero esprimere tutto il concetto
espresso in questo post
;-)

 main è una funzione come le altre
No, main NON E' una funzione come le altre, tanto è vero che non può
essere chiamata direttamente.
EMG

;-)
Neanche io. Pero' per lavoro ho a che fare anche con un
processore in cui i byte di bit ne hanno 16.
sizeof(char)==1 e CHAR_BIT vale 16
Perche' questa cosa ti stupisce ? Cosa c'e' secondo
te di tanto magico nel numero 8 ?


essere chiamata direttamente.
Esatto, ne' puo' essere chiamata ricorsivamente...

mha ....... ho sempre assimilato al byte
all'unità più piccola indirizzabile da un processore
sottolineo indirizzabile
Scusa la curiosità ........
se è possibile .........(non vorrei essere responsabile di un crash di
mainframe)
sulla tua macchina
mi proveresti questo codice ;-)
/* memaddr deve essere abbastanza grande per contenere l'indirizzo di
memoria
se sulla tua macchina serve un altro tipo ..cambialo */
#include <stdio.h>
int main ()
{
char *pa,*a="Salve a tutti";
unsigned long memaddr;
memaddr=a;
printf("indirizzo di stringa a 0x%x\n\n stringa a %s \n\n",memaddr,a);
memaddr++;
pa=memaddr;
printf("indirizzo di stringa pa 0x%x\n\n stringa pa %s \n\n",memaddr,pa);
}
OUTPUT :
demo@PIII /home
$ ./a.exe
indirizzo di stringa a 0x401044
 stringa a Salve a tutti
indirizzo di stringa pa 0x401045
 stringa pa alve a tutti
sono molto curioso di sapere il tuo OUTPUT
scusa la rottura di balls

"Andrea Laforgia" <xx...@xxxxx.xx> ha scritto nel messaggio
news:3b20baa8...@news.libero.it...

questo dando retta a cosa dice lo standard o perche' c'e' qualche motivo
pratico/teorico che lo impedisce?
ovviamente cosa fa un singolo compilatore non fa testo, perche' se no il
BC....
ciao
donCiccio

pratico/teorico che lo impedisce?
Dando retta allo standard.

Non esiste nessun sistema su cui il char e' lungo 10 byte.
Ok, lo so, ma non vedo cosa c'entri con la mia domanda.
Quello che voglio sapere è: lo standard vieta che il char sia più lungo di 1
byte (1 byte inteso come lunghezza di 8 bit, o più in generale come minima
quantità di memoria indirizzabile dall'architettura su cui si implementa il
linguaggio C nello specifico)? Il fatto che poi sul 99% dei pc (ed oserei
dire dei computer in generale) il char sia lungo 1 byte ovvero 8 bit non è
importante.
Lanugo

linguaggio C nello specifico)? 
Il byte dallo standard e' inteso con lunghezza MINIMA di 8 bit.
Ma non e' importante quanto sia lungo un byte.
Un char e' sempre lungo 1 byte.

Un char e' sempre lungo 1 byte.
* quindi un byte può essere grande quanto ti pare
a secondo il sistema
1 Gbyte di hard disk
su un sistema in cui il char è 16 bit
quantè ?
;-)
dopo tutti questi standard .............
non riesco a digerire che un byte può essere lungo più di 8 bit
forse c'è un pò di confusione ......
provo a prendere un caffè e rileggere tutto ...........
bisognetebbe istituire
it.comp.lang.c.dibattiti
Vota Antonio alle prossime elezioni del comitato ISO
;-)

printf( "\n %s", a + i ) ;
oltre che folkloristica rischia anche di indurre in errore. Uno
potrebbe pensare di usarla anche nel caso di punatori ad altri tipi
diversi da char. Se ad esempio a è un int* e sizeof(int)==4:
a+sizeof(int)*i
avanzerà di 4 posizioni anziché 1!!
Anto
--
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

torno a lurkare ........ 
non è che ci stai sulle palle. Ma non credi che se 10 persone dicono
una cosa e tu dici il contrario potresti essere tu a sbagliare?


non riesco a digerire che un byte puň essere lungo piů di 8 bit
Fai bene a digerirlo.
"The definitions of object, bit, byte, and alignment reflect a strong
consensus, reached after considerable discussion, about the
fundamental nature of the memory organization of a C environment: 
All objects in C must be representable as a contiguous sequence of
bytes, each of which is at least 8 bits wide.  
A char (or signed char or unsigned char)  occupies exactly one byte.  
(Thus, for instance, on a machine with 36-bit words, a byte can be
defined to consist of 9, 12, 18, or 36 bits, these numbers being all
the exact divisors of 36 which are not less than 8.)  These strictures
codify the widespread presumption that any object can be treated as an
array of characters, the size of which is given by the sizeof operator
with that object's type as its operand." [ANSI C Rationale]

Un char e' sempre lungo 1 byte.
Infatti, perché sizeof torna il valore in byte e per definizione
sizeof(char) == 1, solo che prima di leggere il tuo post non lo sapevo.
Dovrei comprare una copia dello standard, prima o poi. Sai mica quando è
previsto che finiscano i lavori sul C99 (cmq l'ultimo in progress)?
Lanugo

bytes, each of which is at least 8 bits wide.
Che fico ..............
ho trovato riscontro sul K&R
(la dimensione è data in una unità non meglio specificata chiamata byte ,che
equivale in dimensione a un oggetto char)
Questo schiarisce i dubbi dal punto di vista formale ........
ma ne crea altri per chi come me smanetta in assembler
Quindi ............spero........... che il char alias byte (preferirei
chiamarlo wordmachine ;-) )
è l'unità minima indirizzabile dal C
se non fosse così ........
mi cadrebbero un sacco di altre convinzioni ...........
speriamo che
Andrea Griffini
mi faccia l'esperimento ....................

sono molto curioso di sapere il tuo OUTPUT
Nei contesti in cui lo usiamo noi non esiste stdio.h o printf;
in ogni caso lo string literal "Andrea" occupa 7 byte
consecutivi... il primo ad indirizzo 6502 (giusto per dire un
numero a caso ;) ), il secondo 6503 e cosi' via sino al 6508
che contiene '\0'. Ciascuno di questi byte e' grande 16 bit.
Certo che pretendere che non esistano architetture in cui
l'unita' minima indirizzabile sia piu' di 8 bit solo perche'
non se ne e' mai vista una ...


mi cadrebbero un sacco di altre convinzioni ...........
Spero non si siano fatte molto male... anche quella
sull'aritmetica dei puntatori in C devono aver
provocato delle belle sbucciature alle loro ginocchia...
Non so se sono io che sono cattivo (ultimamente me lo
sono sentito dire) ... ma se fossi un docente di C quello
che hai detto sull'aritmetica dei puntatori e sul pianeta
comecavolosichiama sarebbe stato sufficiente a farti
tornare al prossimo appello...


chiamarlo wordmachine ;-) )
Con "parola macchina" non si intende il byte.
Sulla mia macchina, la parola macchina e' lunga 32 bit, ovvero quanto
un intero.

previsto che finiscano i lavori sul C99 (cmq l'ultimo in progress)?
AFAIK, il C99 e' stato gia' approvato.
Sbaglio ?

mai visto un byte di 9 bit 
lo hai appena citato ;-)


importante.
è qui che si sbaglia. La dimensione del byte non è necessariamente 8
bit. Dipende dall'architettura


 Sbaglio ?
So anch'io cosě.
EMG