Newsgroup: it.comp.lang.c
Titolo: Info su stringhe

Salve a tutti, ho 2 domandine (sicuramente stupide):
perchč mi da segmentation fault?
main()
{
    int errore;
    char *buffer=(char*)calloc(300, sizeof(char));
    errore=funzione(100, buffer);
printf("%s\n", buffer);
}
int funzione(int i, char *buf)
{
    int j;
    for(j=0; j<=i ; j++) buf[i]='1';
return 0;
}
come faccio a creare un file che abbia i diritti che voglio io (in linux)?

 return 0;
prima di tutto mi sembra che hai sbagliato
a scrivere il ciclo. Forse volevi mettere 101
caratteri uguali a '1', ma in quel caso
dovevi scrivere buf[j]='1';
e non buf[i]='1'; visto che la variabile
i rimane sempre uguale.
Comunque il problema e' che la malloc non "azzera" la memoria
allocata, quindi nel buffer c'e' la qualunque.
E tu ti sei dimenticato di memorizzare uno zero in fondo
alla tua stringa. Siccome la stringa non e'
terminata, probabilmente quando vai a stamparla lui cerca
di leggerla fino a che non trova il terminatore 0 e questo
lo induce a leggere dove non dovrebbe, causando un
errore.
ciao,
g.

     for(j=0; j<=i ; j++) buf[i]='1';
...
vuoi veramente assegnare per 101 volte lo stesso valore alla componente 
100 dell' array buf ?
Giorgio

 ciao
Io uso la calloc che per quanto ne so io azzera la memoria...comunque
nemmeno aggiungendo lo \0 finale risolvo...ora provo a mandarla alla
funzione inizializzandola cosě:
main()
{
    int errore;
    char *buffer=(char*)calloc(300, sizeof(char));
buffer[0]='\0';
    errore=funzione(100, buffer);
printf("%s\n", buffer);
}
e vi faccio sapere...anche se credo che cosě funzioni...

 100 dell' array buf ?
Bhe era per "vedere l'effetto che fà" :P
scherzo, ho sbagliato a scrivere l'email...scusa mi rileggo un manuale
qualsiasi di C in ginocchio sui ceci ad alta voce while(GINOCCHIA
SANE)...^_^  !!!!!!!!!!


Per creare file sotto Unix usa la system call open(), con questa sintassi:
   int open (const char * pathname, int oflag, mode_t mode);
dove 'pathname' e` il nome completo (inclusivo del path) del file che vuoi 
creare, 'oflag' specifica le opzioni per la open() e 'mode' sono i 
diritti.
Per creare un file, 'oflag' sara` tipicamente
   O_CREAT || O_TRUNC || O_RDWR
che vuol dire che il file deve essere creato (O_CREAT), che se gia` esiste 
un file con quel nome allora deve essere svuotato (O_TRUNC), e che il file 
creato restera` aperto in lettura e scrittura (O_RDWR).
Per le altre opzioni vedi la pagina di manuale.
Per definire i permessi del nuovo file che viene creato, devi impostare il 
parametro 'mode' come un or dei flag che ti interessano. I flag sono:
             Flag        Risultato (formato dei permessi
                                  usato da ls -l)
           =========    =================================
            S_IRUSR             -r--------
            S_IWUSR             --w-------
            S_IXUSR             ---x------
            S_IWGRP             ----r-----
            S_IWGRP             -----w----
            S_IWGRP             ------x---
            S_IWOTH             -------r--
            S_IWOTH             --------w-
            S_IWOTH             ---------x
Di nuovo, vedi la pagina di manuale di open() per avere tutti i dettagli 
che ho omesso
Esempio
~~~~~~~
Supponendo che tu voglia creare il file /home/miahome/prova con permessi 
di lettura, scrittura ed esecuzione per il proprietario, di lettura e 
scrittura per il gruppo e di lettura per tutti gli altri, dovrai scrivere:
   open("/home/miahome/prova", O_CREAT || O_TRUNC || O_RDWR,
           S_IRUSR || S_IWUSR || S_IXUSR || S_IRGRP || S_IWGRP || S_IROTH);
~~~~~~~
Per concludere, l'uso di open() richiede 3 header da includere:
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <fcntl.h>
Spero di essere stato sufficientemente chiaro.
Ciao,
Marco

 funzione inizializzandola cosě:
si scusa, avevo letto male... (certo che anche io sono distratto...)
g.

int funzione(int i, char *buf)
{
      int j;
      for( j=0; j<i-1; j++ ) buf[j]='1';
                ^^^^^
      buf[i]='\0';
      return 0;
  }
Bye
	MaX

 Marco
Totalmente, ora inizio a provare, nemmeno sulle guide era spiegato cosě
bene!!!

no, nemmeno così...ho provato questo:
char *a="Che bel tempo che fa\0";
char *b=(char*)calloc(strlen(a)+1, sizeof(char));
if(a==NULL || b==NULL) return errore;
int i=0;
while(i<=5)
{
b[i]=a[i];
a[i]='1';  <------------  qui va in segmentation fault
i++
}
ma se a lo dichiaro così:
char a[]="...";
tutto OK...qualche problema ti portabilità non standard?

 
certo, per quanto ho detto prima.
forse lo fai solo per fare delle prove, ma per copiare uno spazio di 
memoria c'e' l'utile funzione memcpy, un bel "man memcpy" ti potra' 
risolvere ogni dubbio in merito )
Ciao
	Max

 risolvere ogni dubbio in merito )
...ricordo ora di questa funzione e dei suoi utilizzi per i char*...forse è
quello il problema...riavvio in Linux, un bel man che non fa male!!!, testo
e ti facci sapere...
Grazie

 Permaloso...:P
No, non e` essere permalosi. In C, a differenza del C++, la dichiarazione 
delle variabili DEVE essere fatta all'inizio di un blocco, prima di ogni 
altra istruzione. Dichiarare le variabili successivamente e` un errore e 
mi pare un po' strano che il GCC non lo segnali.
Per completezza, ricordo che un blocco in C e` una porzione di programma 
contenente istruzioni e racchiuso tra parentesi graffe. E` un blocco il 
corpo di una funzione, non lo e` la dichiarazione dei campi di una struct.
Quindi deriva immediatamente per quale motivo le variabili locali sono 
dichiarate a inizio funzione: e` l'inizio di un nuovo blocco.
Esempio
~~~~~~~
void f() {
   int c;
   ^^^^^^-- corretto
   /* istruzioni */
   int b;
   ^^^^^^-- errato: non all'inizio di un blocco
   if ( condition ) {
     int x;
     ^^^^^^-- corretto: inizio di un blocco!
   }
}
~~~~~~~
Un blocco definisce anche lo _scope_ di una variabile, ricorda!
Saluti,
Marco

 a[i]='1';  <------------  qui va in segmentation fault
char *a="Che bel tempo che fa";
a[i]='1'
è errato perque 'a' e un puntatore che punta ad una string costante.
char a[]="Che bel tempo che fa";
a[i]='1'
è OK perque 'a' è un array.(con elementi variabili) inizializzato con
una string costante.
-- 
Horst


 mi pare un po' strano che il GCC non lo segnali.
[CUT]
Assolutamente vero, è un'abitudine che ho, a volte gcc me lo segnala...