Newsgroup: it.comp.lang.c
Titolo: Passaggio di puntatori: dove sbaglio ?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void f(char* c)
{
    c = (char*) malloc(sizeof(char)+5);
    strcpy(c, "ciao");
}
int main(void)
{
    char* H;
    f(H);
    printf("%s\n", H);
}
perche' nella printf nel main non mi stampa "ciao" ?
Grazie
ciao

 }
Non è necessario il cast prima del malloc ed il tipo char ha
dimensione 1 bite, quindi non serve il sizeof. Prova così:
void f(char* c)
{
    c = malloc( 5 );
    strcpy(c, "ciao");
}
Ricordati di testare sempre se malloc ha ritornato NULL prima di
utilizzare cio' che hai allocato.
Ciao!



Ops, scusa ma mi sono scordato di dire un altra cosa... malloc assegna al
puntatore un indirizzo, ovviamente l'indirizzo che si ritrova il puntatore
c nella funzione non è lo stesso di H nel void... Devi passare il
puntatore al puntatore per poterlo ritrovare :) così:
void f(char** c)
{
    *c = malloc(5);
    strcpy(*c, "ciao");
}
int main(void)
{
    char* H;
    f(&H);
    printf("%s\n", H);
}
Saluti!

 non è lo stesso di H nel void...
Stasera non ci sono con la testa... volevo dire nel main... basta, esco
che mi fa bene :D

Giuseppe Tinaglia ha scritto:

Nella function f dovresti usare un puntatore a puntatore ( ** )

Manuel wrote:

o, alternativamente,
fare l'allocazione nel main, quindi passare
un riferimento ad una zona gia' allocatta:
siccome il riferimento non cambiera' non
ci sara' bisogno del doppio puntatore.
void f(char *c)
{
   strcpy(c,"sono il nano bagonghi!");
}
int main()
{
   char *H;
   H = malloc(100);
   f(H);
   printf("%s\n",H);
   free(H); /* <- in questo caso inutile */
   return 0;
}
ciao,
g.

 
Perchè in C i parametri vengono passati per valore. Devi passare il 
puntatore alla variabile che vuoi modificare, non il suo valore.
Da un punto di vista sintattico sono solo 3 '*' ed 1 '&'! :)
  void f(char **c)
  {
     *c = malloc(sizeof(char)*5); /* <- Che senso ha sizeof(char)+5 ??
                                  **    Forse volevi allocare abbastanza
                                  **    spazio per 5 caratteri, giusto?
                                  **    Ho modificato anche questo. */
     strcpy(*c, "ciao");
  }
  int main(void)
  {
     char *H;
     f(&H);


 }
Ma poi avro' la certezza (in codice moltomoltomolto piu' vasto) che 
l'area di memoria puntata da H rimanga sempre valida e non venga 
sovrascritta da altro ?
Grazie
Ciao

 sovrascritta da altro ?
si a meno che non chiami free passandogli quel puntatore.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

                                   **    Ho modificato anche questo. */
sizeof(char) non ha senso in C :)
sizeof restituisce sempre la dimensione di ciò che passi espressa in char!
è chiaro che sizeof(char) restituisce sempre 1...
poi il fatto che su qualsiasi macchina char orientativamente sarà sempre 1
byte è un altro discorso :)
su *qualsiasi* macchina, il codice
malloc(sizeof(char)*5);
equivale esattamente a
malloc(5);
:)
ciao


 malloc(5);
Vero, ma mettercelo non costa niente (conto sull'ottimizzazione del 
compilatore per eliminare l'espressione costante) e per chi ha dubbi su 
come funziona la malloc è sicuramente piu' chiaro cosi'. Idem per il 
cast sulla malloc (anche se quello l'ho tolto).
Meglio concentrarsi su una cosa per volta (in questo caso il passaggio 
di parametri per valore).
Speravo che la domanda sulla necessità di mettere o meno sizeof(char) 
venisse in mente a lui.
R.D.