Newsgroup: it.comp.lang.c
Titolo: rabbia: strutture balorde

Il seguente programma funziona.
ma se commento la riga 10 ho segmentation fault.
eppure la variabile intera n non viene mai usata.
cloc3@wlan0 ~/cc $ cat struttura.c -n
     1	#include<stdio.h>
     2
     3	int main() {
     4
     5	  struct {
     6	    int i;
     7	  } *intero;
     8
     9
    10	  int *n;
    11
    12	  intero->i = 3;
    13
    14	  printf("Contenuto di lista->i: %i\n", intero->i);
    15	  printf("\n");
    16
    17	  return 0;
    18	}
    19
cloc3@wlan0 ~/cc $
perché?

     12          intero->i = 3;
Qui stai usando un puntatore non inizializzato. Il comportamento del
programma sarà indefinito.
Ripassare il capitolo sui puntatori.
Max


grazie.
infatti il mio problema viene proprio da lì.
non capivo nè il fatto del comportamento indeterminato nè l'obbligo di
inizializzare (lo prendevo che fosse una facoltà).
ora, la mia mente malata si afanna intorno ad una cosa ancora più
intricata.
vorrei una struttura con un contatore e un vettore di stringhe, che
possa essere allungato automaticamente e poi riavvolto.
un po' come funzionano i programmi con main(argc, *argv[]).
fino ad ora ho trovato esempi che insegnano ad usare il parametro
*argv[], ma non a costruire qualcosa di analogo per mettere in
comunicazione due funzioni.
sapresti indicarmi dei link su di questo?
fino ad ora, ipotizzavo un robo di sto genere:
struct {
  int i;
  char *(*buffer)[1];
} *lista;
alcune simulazioni mi davano dei falsi positivi, con gli stessi
problemi del programma elementare sopra.
e naturalmente, i miei esperimenti non inizializzano correttamente il
buffer.

ok.
mentre attendevo, ho curato un altro misconcetto relativo alla
distinzione tra caratteri e stringhe.
in pratica, ritenevo che il tipo char fosse riferito genericamente a
una stringa, mentre definisce esclusivamente i singoli caratteri.
le stringhe sono locuzioni verbali associati ai vettori di caratteri.
di conseguenza credo che nessuno sia in grado di capire quello che ho
scritto in precedenza.
ma ringrazio lo stesso perché intanto ho capito due cose in più che
avevo bisogno.
:)

 le stringhe sono locuzioni verbali associati ai vettori di caratteri.
...
Ancora meglio sarebbe "le strighe C sono array  di char terminati dal 
terminatore di stringa ( '\0' )" è  più  corretto e  ti eviterà  un 
sacco di cattive sorprese...
Giorgio

 sapresti indicarmi dei link su di questo?
/* codice non testato */
int argc;
char *argv[];
argv=malloc(3*sizeof(char *));
argv[0]=malloc(6);
strcpy(argv[0],"pippo");
argv[1]=malloc(6);
strcpy(argv[1],"pluto");
argv[2]=malloc(9);
strcpy(argv[3],"topolino");
argc=3;
/* E. */

 le stringhe sono locuzioni verbali associati ai vettori di caratteri.
Le stringhe in C non esistono. Ti sembrerà strano ma è così. Sono appunto
vettori di caratteri terminati, per convenzione, dal carattere nullo.
Il linguaggio prevede solo delle facilitazioni sintattiche, tipo il fatto
di poter scrivere:
char s[] = "pippo";
In tutto e per tutto, questa scrittura equivale a:
char s[] = {'p','i','p','p','o','


grazie mille.
ma non si regala il codice pronto ai nubbi.
si danno istruzioni e che pedalino soli ... :)
vedo che il tuo codice prevede una molplicazione per 3 che
implicherebbe la conoscenza a priori del numero di parole.
non sono sicuro, al momento, che si possa generalizzare dinamicamente
ad un numero indeterminato di parametri.
nel frattempo, ho ideato, nel topic su malloc, una struttura ricorsiva
che mi sembra convincente.
penso che, per il mio lavoro, proverò dapprima a implementare quella,
che è farina del mio sacco e poi a confrontarla con la tua per vedere
quale delle due è più semplice.


mi rispondo solo:
probabilmente, ad ogni nuova parola, bisogna riallocare il vettore
aumentando si uno la dimensione.

 quale delle due č piů semplice.
Io farei come hai fatto tu, una bella lista. Anzi ultimamente in questi 
casi decido che č meglio utilizzare il C++. Solo che tu hai chiesto una 
struttura come quella di argc/argv e quella ti ho fatto...
E.

 casi decido che è meglio utilizzare il C++. 
Questa è una cosa filosofica su cui un giorno mi piacerebbe aprire un
bel dibattito, a patto di non flammare (se ti chiedi chi sono, sono
crxor). 
Mi spiego meglio, ultimamente sto facendo un bel po' di cosette in C
(principalmente perchè so che il mio scopo principale è poi usarle da
Python e lavorando in C so anche che mi sarà tutto facilitato in tal
senso). 
La cosa più frustrante del tutto è trovarmi a scrivere codice che sta
chiedendo di avere templates (e proprio uso banale degli stessi, ovvero
strutture dati generiche rispetto al tipo).
Viceversa, non ricordavo che debuggare fosse così "semplice". Senza
nessuna ragione apparente (cioè, pensandoci 10 secondi il "perchè" viene
fuori facile facile), *di fatto* faccio molta meno fatica a debuggare C
che C++. 
La cosa "buffa" è che di tutto l'anbaradan del C++, la cosa che mi manca
maggiormente è proprio la programmazione generica (mentre di classi ed
ereditarietà sento relativamente meno la mancanza) ed eventualmente le
eccezioni.
-- 
-riko

 crxor). 
In questo caso la motivazione sta semplicemente nel fatto che le 
librerie standard del C++ ti mettono a disposizione vector, list, map e 
string. La libreria standard del C non è molto d'aiuto in questo...
E.

 string.
Assolutamente si. Sono comodissime e non dico di no. Ma *di fatto* non
ho visto pochi programmi "generici" e non banali in cui non uso almeno
una volta strutture dati "dinamica" (nel senso di un vector o di una
lista) o non mi farebbe comodo avere le "stringhe".
Pertanto questo argomento porterebbe sostanzialmente ad abbandonare C.
Cosa che tipicamente non avviene (non in tutti i contesti).
Complessivamente insomma vale sempre la pena di fare un discorso (che
non sia un flame) sull'argomento.
-- 
-riko