Newsgroup: it.comp.lang.c
Titolo: Mallocazione

        char nome[10];    /*qui*/
ripeto che in tutti e due i casi ho risolto il problema ma ora mi sorge una
domanda :
perche' se alloco spazio per una struttura che contiene un puntatore a
carattere devo ripetere l'operazione anche per lo stesso puntatore (Sul mio
libro di C questa cosa non era segnata e... nemmeno negli esempi da me
posseduti)  ???
Per quali tipi di "dato" contenuti in una struttura bisogna ripetere
l'allocazione ??
e ancora ..
perche' definendo la lunghezza dell' array di char (il cui nome e' comunque
un puntatore credo...) non ho bisogno di effettuare alcuna allocazione
supplementare.  ???
P.S.
Per capire meglio la cosa leggere il "trhead" (credo si chiami cosi') "che
strano"..
Grazie per le eventuali risposte (sono un programmatore C alle prime armi
ed ho bisogno di risposte....)..
Antonio de Lucia.

supplementare.  ???
perchè definendo un array e specificando la dimensione, il compilatore
ha tutti i dati per effettuare già l'allocazione. Mentre se scrivo 
char *pippo;
non specifichi al compilatore quanta memoria riservare alla struttura
puntata da pippo, quindi semplicemente riserva spazio in memoria per
la variabile pippo, che tu puoi poi riempire come ti pare, ad esempio
con:
pippo=new char[10];
Ciao.
-----------------------------------------------------------
Christian Salvaneschi
Casarza Ligure, Genova, Italy
e.mail: 
crj...@geocities.com
 (remove 214 for email reply)
web: 
http://www.geocities.com/SiliconValley/Lakes/5139

 strano"..
Si,si chiama cosi :-)
CiauZ!

 Si,si chiama cosi :-)
No, si chiama "thread".
EMG

l'allocazione ??
Dovresti aver capito che l'allocazione non e' *ripetuta* ma
*aggiuntiva* e necessaria solo per i puntatori, se vuoi usare i dati
puntati .
Ti faccio un esempio :
#include <stdio.h>
#include <stdlib.h>
typedef struct {  int a ;
                  int b ;
                  char c [10] ;
               } A_t ;
typedef struct {  int a ;
                  int b ;
                  char * c ;
               } B_t ;
main()
{
    A_t * A ;
    B_t * B ;
    A = malloc ( sizeof * A ) ; /* questa operazione e' ...     */
    B = malloc ( sizeof * B ) ; /* ...equivalente a ...         */
    B->c = malloc ( 10 ) ;      /*                ...queste due */
    printf ( "sizeof * A = %u\n", sizeof * A ) ;
    printf ( "sizeof * B = %u\n", sizeof * B ) ;
    return 0 ;
}

     A_t * A ;
Capisco che lo stile con cui si scrive il sorgente è una cosa del tutto
personale però non sono molto d'accordo sul mettere uno spazio prima e
dopo l'asterisco in quanto mi fa confondere con l'operatore di
moltiplicazione. A te no?
EMG

, 
e.m.gi...@flashnet.it
 
says...

Vero.
Che occhio di falco! :-)
Ciao

EMG


moltiplicazione. A te no?
A me sinceramente no.
Mi confonderei con una moltiplicazione se fosse B = (A_t) * A ;
In questo caso leggendo da destra verso sinistra risulta :
A (prima parte) 
e' un puntatore (seconda parte) 
di tipo A_t (terza parte).

 Mi confonderei con una moltiplicazione se fosse B = (A_t) * A ;
Si, ma tu scrivi anche ( sizeof * A ) e pure questo confonde. No?
EMG

 Gusti...
Chiaramente.
EMG

Si, ma tu scrivi anche ( sizeof * A ) e pure questo confonde. No?
No, perche' sizeof non puo' essere il fattore di una moltiplicazione.

 No, perche' sizeof non puo' essere il fattore di una moltiplicazione.
Si, ma a prima vista non si vede.
EMG



I sorgenti non si leggono "a prime viste" ...
La "confusione" deriva da una certa "ambiguita'" che sinceramente non
riesco a riscontrare...
In ogni caso non credo sia motivo di un dibattito cosi' lungo e
noioso, visto che e' una questione riguardante solo e soltanto lo
stile di scrittura del sorgente.