Newsgroup: it.comp.lang.c
Titolo: Passaggio di array di stringhe 2d a funzione?

 
 
 
 
Ho un array di stringhe
 
char *parole[50][50]={{"123", "3048548t", "fd�fkd9ds8","0"," ",...},...}
 
come posso fare per passare l'array ad una funzione?
 
Il prototipo della funzione che ho scritto e questo:
 
 
int scramble (char *ps [][]);
 
quando utilizzo la funzione: scramble ( *parole[][50] );
 
ma non lo accetta!
 
warning: passing arg 1 of `scramble' makes pointer from integer without a
cast
 
 
Vi ringrazio  Ciao
 
 
 
 

 cast
 
Rifletti sulla chiamata, e' li' l'errore.
 
Ti faccio un esempio piu' semplice cosi' capisci la causa del messaggio e dove sta il tuo errore.
 
Se la funzione fosse definita come:
 
int f( char *ps )
 
e tu la chiamerassi con
 
char parole[50];
 
f( *parole );
 
ti direbbe lo stesso identico errore (pointer from integer eccetera)
 
 
ciao
Giacomo
 
 

 
"
Ti faccio un esempio piu' semplice cosi' capisci la causa del messaggio e
dove sta il tuo errore.
 
Se la funzione fosse definita come:
 
int f( char *ps )
 
e tu la chiamerassi con
 
char parole[50];
 
f( *parole );
 
ti direbbe lo stesso identico errore (pointer from integer eccetera)
 
 
ciao
Giacomo
 
 
 
Scusami ma non ho capito.
 
Quello che posso dire e che l'errore mi pare circolare!
Nel senso che, se * e presente sia nell'array che nella funzione
darebbe lo stesso errore?
 
Ciao
 
 
 
 



On 2012-07-24 11:53:20 +0000, Alter said:




Il prototipo della funzione che ho scritto e questo:


int scramble (char *ps [][]);




Questo prototipo non � corretto: va specificata almeno la seconda dimensione:




int scramble (char *ps [][50]);




quando utilizzo la funzione: scramble ( *parole[][50] );




ma non lo accetta!




warning: passing arg 1 of `scramble' makes pointer from integer without a


cast




La funzione accetta un array di array di 50 puntatori a stringhe. Dal momento che il nome di un array decade nel puntatore al suo primo elemento, quando viene passato ad una funzione, questo equivale a dire che la funzione accetta un puntatore a un array di 50 puntatori a stringhe:




#include 
<stdio.h>




void output2(char *p[][3]) { // oppure 
void
 output(
char
 *(*p)[
3
]) {


 
int
 i;


 
for
 (i=
0
; i<
2
; i++) {


 
 
int
 j;


 
 
for
 (j=
0
; j<
3
; j++) {


 
 
� � 
printf
(
"p[%d][%d] = \"%s\"\n"
,i,j,p[i][j]);


 
 
}


 
}


}




int
 main (
int
 argc, 
const
 
char
 * argv[]) {


� � 
char
 *a[
2
][
3
] = {{
"00"
,
"01"
,
"02"
},{
"10"
,
"11"
,
"12"
}};


 


 
output
(a);


 


� � 
return
 
0
;


}









 void output2(char *p[][3])
 
questa notazione con MinGW, non funziona.
 
In file included from Scramble.c:34:0:
define.h:25:27: error: array type has incomplete element type
Scramble.c: In function 'main':
Scramble.c:103:29: error: expected expression before ']' token
Scramble.c:103:29: error: type of formal parameter 1 is incomplete
 
 
 
 
{ // oppure void output(char *(*p)[3])
 
 
Scramble.c: In function 'main':
Scramble.c:103:1: warning: passing argument 1 of 'word1' makes pointer
 from integer without a cast
define.h:25:5: note: expected 'char * (*)[]' but argument is of type 'char'
 
Avr� sbagliato qualche cosa?!?
 
Ciao


 Avr� sbagliato qualche cosa?!?
 
Riporta l'intero codice che stai cercando di compilare.
 


 
prototipo della funzione:
int scramble (  char *(*word)[] ,int y, int i);
 
 
la funzione stessa:
int scramble (  char *(*word)[]  ,int y, int i){
 
 
la chiamata della funzione:
scramble( *(*word)[50]  ,10, 3);
 
Ciao
 
 
 
 

 scramble( *(*word)[50]  ,10, 3);
 
Il codice che ti ho scritto � corretto e il modo in cui ho invocato la 
funzione non � questo.
 

 Vi ringrazio  Ciao
 
Ti ha gia' risposto Andrea Laforgia, ti faccio comunque un altro esempio 
come il suo. Ciao.
 
====================================
 
#include <stdio.h>
 
void stampa(char *parole[50][50])
{
     char **curr_row;
     int col, row;
 
     for (row = 0, curr_row = parole[row];
          curr_row[0] != NULL;
          curr_row = parole[++row]) {
         col = 0;
         while (curr_row[col] != NULL) {
             printf("%s ", curr_row[col]);
             col++;
         }
         printf("\n");
     }
}
 
int main()
{
     char *parole[50][50] = {
         { "alfa", "beta", "gamma", NULL },
         { "uno", "due", "tre", NULL },
         { NULL }
     };
 
     stampa(parole);
 
     return 0;
}
 
====================================

 darebbe lo stesso errore?
 
Piu' o meno: quello che volevo evidenziare e' che * ha due significati
diversi nella definizione e nella chiamata:
 
int f(char *p)  // qui indica che P e' un puntatore
 
quando chiami
 
char *q; // qui indica ancora che q e' un puntatore
 
 
f( *q ); // qui il valore di *q non e' un puntatore
 
Se devi passare un puntatore alla funzione f, non
devi usare *q perche *q NON e' un puntatore, ma
e' il char a cui q punta ed ecco perche'
ti da errore.
 
Per passare alla funzione il valore del puntatore q
devi passare q alla funzione
 
f( q );
 
 
La stessa cosa la devi fare nel tuo codice, quando invochi
la funzione togli tutti i * e [] che hai messo perche'
non servono
 
ciao
Giacomo
 
 
 
 
 

 
Da quello che leggo, nel prototipo della funzione si deve specificare la 
grandezza massima di righe/colonne?
 
 
Ciao
 
 
 
 
 


 
Si e corretto, era come invocavo la funzione che non lo era!
 
Un ultima cosa, e possibile fare una cosa di questo tipo con un array di 
stringhe
a 2 dimensioni?
 
char *word[]={" ","xxdffs","hgtutu",",myff","bvntrdtrdt","tytyfgh"};
 
   scramble2 (word[indice]);
 
Oppure, perche con un array a 1 dimensióne e possibile e con 2 no?
 
 
Gràzie
 
Ciao
 
 

 grandezza massima di righe/colonne?
 
Qui trovi un po' tutto quello che ti serve su questo argomento: 
http://www.cplusplus.com/doc/tutorial/arrays/
 
 
Al fondo della pagina:
<< Notice that the first brackets [] are left empty while the following 
ones specify sizes for their respective dimensions. This is necessary in 
order for the compiler to be able to determine the depth of each 
additional dimension. >>
 
Quindi avrei potuto dichiare anche la funzione come:
void stampa(char *parole[][50])
 
ma non:
void stampa(char *parole[][])
 
Ciao

 
Ok, ti ringrāzio
 
ma sai rispondere alla domanda che ho inviato alle ore 11.29?
 
 
Ciao
 
 
 

 ma sai rispondere alla domanda che ho inviato alle ore 11.29?
 
ti riferisci a questa domanda immagino:
====================================================================
Un ultima cosa, e' possibile fare una cosa di questo tipo con un array 
di stringhe a 2 dimensioni?
char *word[]={" ","xxdffs","hgtutu",",myff","bvntrdtrdt","tytyfgh"};
 
scramble2 (word[indice]);
 
Oppure, perche' con un array a 1 dimensione e' possibile e con 2 no?
====================================================================
 
Ti risponderei, ma non ho capito la domanda :)
Cosa intendi con:
 > "e' possibile fare una cosa di questo tipo con un array di stringhe a 
2 dimensioni?"
quale COSA?
 
 > Oppure, perche' con un array a 1 dimensione e' possibile e con 2 no?
Anche qui non ho capito COSA sarebbe possibile con un array a 1 
dimensione, che invece con 2 non si puo'...

 quale COSA?
 
passare ad una funzione, un array 2d con uno dei due indici, quelle delle 
colonne!
 
Ciao
 
 
 

 colonne!
 
Scusa, ma "passare ad una funzione, un array 2d con uno dei due indici" 
non vuol dire nulla.
 
A una funzione non passi "un array con un indice", passi il puntatore al 
primo elemento di un array.
 
Provo a immaginare, intendi passare solo una dimensione dell'array alla 
funzione, come nell'esempio che ti ho fatto che segue?
 
====================================================
#include <stdio.h>
 
void stampa(char *row[50])
{
     int col = 0;
 
     while (row[col] != NULL) {
         printf("%s ", row[col]);
         col++;
     }
     printf("\n");
}
 
int main()
{
     char *parole[50][50] = {
         { "alfa", "beta", "gamma", NULL },
         { "uno", "due", "tre", NULL },
         { NULL }
     };
     int i;
 
     for (i = 0; i < 2; i++)
         stampa(parole[i]);
 
     return 0;
}
====================================================

 Oppure, perche con un array a 1 dimensióne e possibile e con 2 no?
 
A te non è molto chiaro come funzionano array e puntatori. 
Ted Jensen ha scritto un tutorial molto ben fatto: 
http://pw1.netcom.com/~tjensen/ptr/pointers.htm
 
 
Supponi che tu abbia un array di M elementi di tipo T, con T un tipo qualsiasi:
 
T a[M];
 
Quando accedi ad un elemento i, con 0<=i<M, il sistema considera l'indirizzo in cui è memorizzato il primo elemento di a, e aggiunge a questo sizeof(T)*i bytes, per arrivare all'indirizzo in cui è memorizzato l'elemento a[i].
 
Questo discorso vale in qualunque caso, anche se T è un tipo "array di N elementi di tipo X". Il sistema ha SEMPRE bisogno di sapere quant'è grande l'elemento dell'array, per poter accedere ad una determinata posizione.
 
Ora, se T, come supposto, è un tipo array di N elementi di tipo X, quel che hai è:
 
X a[M][N];
 
perché si possa accedere all'elemento a[i], il sistema deve sapere quanto è grande l'elemento dell'array, ovvero quanto è grande l'array di elementi di tipo X. E' per questo che, mentre M può essere omesso, sei OBBLIGATO a specificare N.
 
Chiaro, ora?


 
questo se non erro, è quello che e scritto nel K&R.
 
Ciao
 
 
 

 Ciao
 
 
ho controllato, la pagina e la 142. 2�Ed.
 
Ciao
 
 
 

Ti ringrazio!
 
Quello che volevo dire è, perche con un array ad 1 dimensione si passa
l'indice, che può essere il primo come l'ultimo, ma con un array 2d, si 
passa,
o si deve passare, tutto! l'array! :-)
 
Ciao 
 
 

Quello che mi serve e passare un indice di un *array[50][50]
passare un indice scelto da m�. Se mi serve poter lavorare sulla
stringa che ha indice x, lo passo alla funzione.
 
Non e quello che si f� con l'array a 1 dimensione?
 
 
Ciao 
 
 


Siccome "passare un indice di un array" non si dice, immagino che tu 
voglia dire "passare un elemento di un array come argomento a una funzione".
 
In questo caso e' semplicissimo, riprendiamo il solito esempio:
 
===================================================
#include <stdio.h>
 
void stampa(char *s)
{
     printf("%s\n", s);
}
 
int main()
{
     char *parole[2][50] = {
         { "alfa", "beta", "gamma", NULL },
         { "uno", "due", "tre", NULL },
     };
     int i, n;
 
     for (i = 0; i < 2; i++)
         for (n = 0; n < 3; n++)
             stampa(parole[i][n]);
 
     return 0;
}
===================================================


Non capisco che cosa tu voglia dire con "si passa l'indice".
Non si passa mai TUTTO l'array, ad una funzione, ma sempre il puntatore 
al suo primo elemento.
Se ti spieghi meglio, forse ti si può aiutare meglio.
 

 ===================================================
 
Si, volevo dire passare un indice, ma un indice e un puntatore?, che punta 
ad un
elemento a scelta, dell'array.
 
 
Farlo con un array ad 1 dimensione e semplice, farlo con un array a 2d?
e il modo che hai scritto sopra?
 
Ma quel stampa, e possibile sostituirlo con un printf, quindi i 2 cicli for
scandiscono l'array, e passano l'elemento, ma non i due indici che puntano
ad un elemento scelto.
 
Ciao
 
 
Ciao 
 
 

 ha scritto nel messaggio
news:2012072602483382009-alaforgia@gmailcom...

vi ringrazio, ho capito.
 
Ciao
 
 
 

Quello che vorrei sapere se sia possibile, e, passare
ad una funzione, le coordinate, riga-colonna, o uno
solo delle 2, di un elemento dell'array 2d.
 
Ciao
 
 
 


Le sto provando tutte per capire cosa vuoi dire :)
 
Intendi cosě?
Utilizzo un ciclo for, ma puoi ovviamente scrivere:
stampa(parole, 1, 0);
 
==================================================
#include <stdio.h>
 
void stampa(char *parole[2][3], int row, int col)
{
     printf("%s\n", parole[row][col]);
}
 
int main()
{
     char *parole[2][3] = {
         { "alfa", "beta", "gamma" },
         { "uno", "due", "tre" },
     };
     int row, col;
 
     for (row = 0; row < 2; row++)
         for (col = 0; col < 3; col++)
             stampa(parole, row, col);
 
     return 0;
}
===================================================

 Le sto provando tutte per capire cosa vuoi dire :)
 
Don't feed the troll.
 

 ha scritto nel messaggio
news:2012072623512042352-alaforgia@gmailcom...

BRUOFTL
 
 
 
 

 ===================================================
 
 
 void stampa(char *s)
 dove lo vedi nel prototipo della funzione la parentesi [] che indica la 
possibilit�
di passare una indice, coordinata? di un elemento arbitrario dell'array?
 
Ciao 
 
 

 di passare una indice, coordinata? di un elemento arbitrario dell'array?
 
La funzione chiamata NON riceve l'indice, riceve direttamente l'elemento 
dell'array.
 
Nell'esempio che segue viene stampato "tre".
 
PS Se vuoi passare alla funzione anche l'indice perche' ti serve, devi 
passarlo a parte, come argomento aggiuntivo.
 
======================================================
#include <stdio.h>
 
void stampa(char *s)
{
     printf("%s\n", s);
}
 
int main()
{
     char *parole[2][3] = {
         { "alfa", "beta", "gamma" },
         { "uno", "due", "tre" },
     };
 
     stampa(parole[1][2]);
 
     return 0;
}
======================================================

 passarlo a parte, come argomento aggiuntivo.
 
allora non e possibile passarlo come argomento non aggiuntivo! :-)
 
Ciao


 array 1dimensione.
 
In C non esiste differenza tra array a 1, 2, 3, 4, 5, 6…N dimensioni. 
Un array è un array di elementi di tipo T. Questo tipo T può, a sua 
volta, essere un array.