Newsgroup: it.comp.lang.c
Titolo: Sull'istruzione return

Sono un ex programmatore Pascal (a livello scolastico) e da poco mi stò
cimentando nel C.
Non riesco a capire alcune cose del listato seguente, esempio che il manuale
da me usato fa riguardo all'istruzione return.
 Il prg. restituisce la pos. della sottostr. contenuta nella str.
ppure  -1.
Qualcuno può darmi qualche delucidazione ?, Grazie.
N.B. I miei dubbi sono descritti di fianco alla parte di codice che non
capisco.
#include <stdio.h>
#include <conio.h>
int find_substr(char *s1, char *s2);
void main(void)
{
 clrscr();
 if (find_substr("Mi piace il C","ac")!=-1)
  printf ("sottostringa presente");
}
// restituisce la prima corrispondenza di s2 in s1
find_substr(char *s1,char *s2)
{
 int register t;
 char *p, *p2;
 for (t=0;s1[t];t++)
 PERCHE' LA CONDIZIONE E' s1[t] ????
 {
  p=&s1[t];   PERCHE' SE p2=s2 FACENDO p=s1[t] (tolgo "&")
  p2=s2;       IL COMPILATORE (BORLAND C) DA COME ERRORE
                    'cannot convert char to *char' ?????
while (*p2&&*p2==*p)   IL CODICE ASSEGNA IL VALORE DI *P
                                         A *P2 E FA *P2 AND *P2 ????
                                         PERCHE' E' IMPOSTATA COSI' LA COND.
  {
   p++;
   p2++;
  }
  if (!*p2) return t;
 }
 return -1;
}

                                         PERCHE' E' IMPOSTATA COSI' LA COND.
E' traducibile con 
finche' il valore puntato da p2 e' diverso da 0 ed e' uguale al valore
puntato da p, allora ...
Il codice non assegna alcun valore a *p2 (il simbolo di assegnazione
e' "=" non "==" che serve invece per i confronti).
&& in C non ha lo stesso significato dell'AND del pascal.
O meglio, in pascal esiste 1 solo AND che funge sia da operatore
booleano che da operatore tra bit.
Il C invece distingue tra && (per le operazioni booleane) e & per le
operazioni tra bit.

                                         PERCHE' E' IMPOSTATA COSI' LA
COND.
Questa è un po' piu' cattivella...allora, dato che p2 è un puntatore a
carattere, con *p2 indici il carattere puntato da t2..in parole povere , p2
è un *char mentre *p2 è un char.
La condizione *p2 la puoi vedere come *p2 != 0x00 ovvero, "fino a che il
carattere puntato da p2 non è il caratere 0x00" (che indica la fine della
stringa).
La seconda parte della condizione, non è un assegnamento (nota l' ==) e si
traduce in "fino a che il carattere puntato da p2 è uguale al carattere
puntato da p").
Alla fine della fiera, "rimani nel while fino a che non finisce la stringa
*p2 e fino a che *p2 e *p sono uguali.
Con le operazioni p2++ e p++, si spostano  in avanti di un carattere i 2
puntatori.
In pratica, questo while serve per verificare se, a partire dal carattere
p1[2], inizia la  sottostringa puntata da p2.
Se questo è vero, all'uscita del while *p2=0x00 perche' è stata raggiunta la
fine della sottostringa e quindi la funzione termina restituendo t che e'
l'indice del carattere a partire dal quale inizia la sottostringa.
Se invece p2!= 0x00 , la sottostringa non e' stata trovata e si va avanti
(ciclo for) con il prossimo carattere di s1.
Se termina il ciclo for, vuol dire che non è stata trovata la sottostringa
nella stringa per cui la fn termina restituendo -1.

condizione diventa falsa.
Una piccola precisazione : s1[t] non *punta* alla fine della stringa,
ma e' semplicemente il carattere t-esimo.
Che, alla fine della stringa, evidentemente assume il valore 0.
Sono convinto che volessi dire esattamente questo, pero' e' bene
chiarire, perche' quel "puntare" puo' essere confuso con una
caratteristica di altri oggetti, che sono appunto i puntatori...
;)

Andrea perchè dici che void main(void) non è corretto?.
Io l'ho inteso così: il void prima di main indica che la funzione non
restituisce nulla, il void all'interno delle parentesi indica che non viene
passato nessun argomento, e in questo caso la main non restituisce niente.
Questo modo di dichiarare la main viene riportato nel manuale della Mc Graw
Hill "C la guida completa" (dal quale viene il prg.) e nel Tricky C,
quest'ultimo è un manuale reperibile in rete.
Dici che il g++ di Linux non compilerebbe un prg. con una main dichiarata in
questo modo ?.
Bye.

questo modo ?.
main.c: In function 'main':
main.c: warning: return type of 'main' is not 'int'
Compilalo pure, ma a tuo rischio e pericolo.

dire computers che non sono pc, ma che vengono largamente usati.
Dove posso trovare le faq di it.comp.lang.c ?
grazie.


--
------------------------------------------------
Eliminare TOGLIMI dall'indirizzo per rispondere.
++++++++++++++++++++++++++++++++++++++++++++++++

Non voglio essere un rompiscatole che vuole la pappa pronta.
E' esattamente questo lo spirito con cui si partecipa al ng.

 int main(int argc, char *argv[]);
Non so se questo valga anche per il C ma se non erro in C++ la notazione
array nei parametri è deprecata.
EMG

 array nei parametri è deprecata.
Stroustrup 3, pag. 117: "main() is given two arguments ... are
character strings, so the type of argv is char* [argc+1]".
Ibid., pag. 118: int main(int argc, char* argv[]).
-- 
Maurizio Loreti                      
http://wwwcdf.pd.infn.it/~loreti/mlo.html
Un. of Padova, Dept. of Physics - Padova, Italy          
lor...@padova.infn.it

array nei parametri è deprecata.
perche' ?

 Ibid., pag. 118: int main(int argc, char* argv[]).
Si, però non è detto che il libro sia aggiornato allo standard
definitivo. Bisognerebbe consultare quello. Qualcuno può farlo?
EMG

 perche' ?
Non saprei. Se solo ricordassi dove l'ho letto...
EMG



Ma, tu parli di notazione "array", questo significa che la scrittura
migliore dovrebbe essere char **argv . giusto ?

 definitivo. Bisognerebbe consultare quello. Qualcuno può farlo?
Ibid., pag. v: at the time of writing, the C++ Standard ... is the
Committee Final Draft Standard.  HOWEVER NO SIGNIFICANT CHANGES TO THE
LANGUAGE OR THE STANDARD LIBRARY ARE ANTICIPATED.
Adesso tocca a te citare qualcosa...


 migliore dovrebbe essere char **argv . giusto ?
Esatto. Sarà vero? Mah...
EMG

 mailto:
gar...@usa.net
 <
- >ICQ UIN# 23780140 <-