Newsgroup: it.comp.programmare
Titolo: C/C++ riempire un array con stringhe

Ciao a tutti il mio problema e' di definire
un array di char contenente stringhe tutte
di due parole, ad es. "salve gente".
Come faccio? ho guardato su altri thread ma
non ho trovato la soluzione adattabile al mio
problema.
L'array deve essere riempito gia' nel sorgente,
cioe' non deve essere nemmeno modificabile.
Lo dichiaro e lo riempio. Ma non so come fare!!
Per dichiararlo penso di dover fare cosě:
#define MAXCHAR 127
#define INTERV 11
char *A[INTERV];
Ma come riempio i dodici elementi dell'array A[]?
Non posso usare un ciclo, per ogni elemento ho una
stringa diversa...
Qualcuno mi aiuti, se puo'.
Andre

 ha scritto nel messaggio
news:92988777.02110...@posting.google.com...

char *a[] =
{
      "uno pippo"
    , "due pippo"
    , "tre pippo"
};
--
Martino
"...ditemi perché, se la mucca fa MU, il merlo non fa ME?..."
Elio e le storie Tese

 problema.
Dovresti chiedere in it.comp.lang.c o it.comp.lang.c++
a seconda del linguaggio che usi
In C++ puoi fare una cosa così:
#include <vector>
#include <string>
#include <iostream>
std::string stringa;
std::vector<std::string> v;
int main()
{
    while(1)
    {
        std::getline(std::cin, stringa);
        if(stringa=="") break;
        else v.push_back(stringa);
    }
    for(size_t i=0; i<v.size();++i)
    {
        std::cout << v[i] << std::endl;
    }
}
Se invece ti servono le due parole separate si può
pensare anche a soluzioni con
std::vector<std::pair<std::string, std::string> >
--
Gerolamo

 };
grazie per la tua risposta, comunque oggi pomeriggio
sono riuscito a risolvere sto problema da solo:
char 	*a[];
/* qui sotto nota il \0 per far capire al compilatore
 * quando termina una stringa. */
strcpy (a[0], "posizione zero\0");
strcpy (a[1], "posizione uno\0");
strcpy (a[2], "posizione due\0");
/* eccetera */
ciao!

 ciao!
Mi spiace deluderti:
la tua risoluzione sta per farti fare bum!
hai appena riempito di bytes diverse zone di casuali della tua memoria.
Il tuo array a e' un array di puntatori a char, ma questi puntatori a quali
indirizzi puntano?
Manca qualche malloc (c) o new (c++) e nel caso di c++ sarebbe il caso di
usare le string al posto dei char *
come giustamente ti ha suggerito Gerolamo, ma pare che tu non lo abbia
letto.
Bye
Maurus

 letto.
no, infatti non l'avevo letto. Comunque l'allocazione di memoria l'avevo
fatta, eccola qui:
#define MAXCHAR 127
#define INTERV 23
/* nel main() */
char *nome_int[INTERV];
for (int f=0;f<=INTERV;f++) {
	nome_int[f]=malloc( sizeof(char*)*MAXCHAR);
        }
mi spiace deluderti:
il mio codice non ha fatto bum.
ciao!

:

grazie per la tua risposta, quello che hai scritto mi
può tornare comodo una volta o l'altra. Per quello che
riguarda questo caso però non va bene, perché non devo
"riempire" i campi dell'array (o del vettore in c++)
mediante input da tastiera, bensì devo definirli io,
pseudo-programmatore. comunque ho risolto il mio problema
così:
#define MAXCHAR 127
#define INTERV 23
#include <string.h>
/* nel main: */
char 	*a[INTERV];
for (f=0;f<=INTERV;f++) {
	a[f]=malloc( sizeof(char*)*MAXCHAR);
	}
strcpy (a[0], "Semitono\0");
strcpy (a[1], "Tono\0");
strcpy (a[2], "Terza minore\0");
strcpy (a[3], "Terza maggiore\0");
strcpy (a[4], "Quarta\0");
strcpy (a[5], "Tritono\0");
strcpy (a[6], "Quinta\0");
strcpy (a[7], "Sesta minore\0");
strcpy (a[8], "Sesta maggiore\0");
strcpy (a[9], "Settima minore\0");
strcpy (a[10],"Settima maggiore\0");
strcpy (a[11],"Ottava\0");
ciao e grazie!

 ciao e grazie!
Come giustamente ti ha fatto notare Gerolamo, in C++ e' meglio usare le
string al posto dei char * che si usano in C (e vector al posto degli
array).
Per riempire i vari elementi del vettore poi al posto degli strcpy fai i
push_back direttamente con le stringhe che ti interessano ("Semitono",
"Tono", ecc... senza lo \0 finale che e' gia' incluso implicitamente).
Inoltre nel tuo esempio sopra, quando fai il ciclo for,stai cominciando da 0
ed arrivi a INTERV incluso.
Per cui stai riempiendo INTERV+1 elementi, mentre hai allocato spazio per
INTERV elementi.
Per cui il tuo for doveva escludere l'ultimo ciclo(< al posto di <= ).
In poche parole ti suggerirei di riprendere l'aiuto di Gerolamo
riadattandolo al tuo caso, per cui senza getline di mezzo se vuoi farlo in
C++ (conservando header files <vector> e <string>)
Se invece ti interessa farlo in C occhio ai malloc e free ed agli estremi
del tuo for.
Un'ultima cosa:
penso che nella riga dove tu fai
    a[f]=malloc( sizeof(char*)*MAXCHAR);
in realta' volessi fare
    a[f]=malloc( sizeof(char)*MAXCHAR);
Stai allocando spazio per MAXCHAR bytes ad ogni ciclo e non per MAXCHAR * 4
bytes.
Maurus

 Per cui il tuo for doveva escludere l'ultimo ciclo(< al posto di <= ).
[...]
non capisco, a me sembra di aver fatto bene scrivendo
#define INTERV 11
char *nome_int[INTERV];
for (f=0;f<=INTERV;f++) {
	nome_int[f]=malloc( sizeof(char)*MAXCHAR); /* grazie per la tua correzione qui */
	}          
mi spiego a parole: sono 12 le stringhe che devo memorizzare.
se definisco INTERV 11, nome_int[INTERV] avrà dodici elementi.
E anche il ciclo for eseguirà 12 malloc. o no?
Dimmi se sbaglio,
Andre

 char *nome_int[INTERV];
dichiari un array di puntatori a char di INTERV elementi e non di INTERV+1
elementi.
In sostanza gli indici per l'array nome_int ti andranno da 0 a INTERV-1
Per cui nel for stai facendo un passo in piu' avendo incluso anche l'estremo
superiore.
Maurus

 E anche il ciclo for eseguirà 12 malloc. o no?
esatto, ma le esegue su un array di 11 elementi!
Comunque continuo a pensare che se programmi in C++
ti risparmi tutti questi problemi.
--
Gerolamo

 
[...]
se parte da 0 e arriva a INTERV sono 12!!
guarda, ho sistemato la parte di codice che ci riguarda così:
#define MAXCHAR 32
#define INTERV 11
char 	*nome_int[INTERV];
for (f=0;f<=INTERV;f++) {
	nome_int[f]=malloc( sizeof(char)*MAXCHAR);
	}
strcpy (nome_int[0], "Semitono\0"); /* eccetera fino a nome_int[11] */
free(nome_int);
compilato con MS Visual C++ 1.52 funzia.
Lo so che dovrei passare al C++, ma ormai ho cominciato a 
scrivere in C un sw che mi sono messo in testa di fare...
ciao
Andre

 char *nome_int[INTERV];
significa dichiarare un array di 11 elementi.
Aspetta che te lo riscrivo:
hai dichiarato un array di 11 elementi che vanno da 0 a 10 incluso ovvero da
0 a 11 escluso = 11 elementi ok?
Be' credimi oppure se non mi credi guarda in un manuale di C.
Ora se tu hai un array di 11 elementi e fai un for con 12 cicli, vorra' dire
che nel tuo ultimo ciclo stai riempiendo una zona di memoria che non hai
allocato e quindi stai sforando.
Se per caso il tuo programma non ti ha fatto bum e' per puro culo, come si
suol dire nei circoli di Cambridge.
E cio' non vuol dire che ti funzionera' sempre, magari quando stai mostrando
il tuo programma al tuo migliore amico o quando stai mostrando la tua demo
nel pc di Bill Gates o di Linus Torvalds per essere assunto come
responsabile software, allora il tuo programma provochera' una repentina ed
inesorabile formattazione del loro hard disk, il che, nel primo caso non
sarebbe un male.
Per cui ti consiglio per l'ultima volta di rivedere i limiti del tuo for o
di rivedere l'allocazione statica del tuo array o di guardare un manuale d C
o di C++.
Alla prossima
Maurus

In aggiunta, non avevo letto questa parte:
1) > > strcpy (nome_int[0], "Semitono\0"); /* eccetera fino a nome_int[11]
*/
2) > > free(nome_int);
1) Ti ho gia' spiegato che le stringhe non necessitano della terminazione
che tu aggiungi con \0 perche' la hanno gia' implicitamente.
Per cui basta che tu fai:
strcpy (nome_int[0], "Semitono");
ed avrai alla fine della stringa il carattere di fine stringa
automaticamente.
2) Avendo allocato memoria nel tuo for, per ogni nome_int[f], allora dovrai
liberarla allo stesso modo facendolo stesso numero di free con un for
analogo.
Maurus
p.s.
Scaricati un buon tutorial di C, anche se il tuo prgramma sembra funzionare,
i crash potrebbero sempre saltar fuori nei momenti meno opportuni.

 compilato con MS Visual C++ 1.52 funzia.
Undefined behavior.
Funziona oggi.
Funziona domani.
...
Ma fammi sapere quando ti usciranno i folletti dal floppy...
:-))
--
Gerolamo
"Beware of bugs in the above code;
I have only proved it correct, not tried it."
(Donald Knuth, 1977)