[c] analisi codice con puntatori

[W_As]

Salve, ho dei problemi a fare quest'analisi di codice!

int f(char c, char *cs)                          
{                                                         
     while(*cs!='\0')                              //fino a che finisce il vettore di caratteri
     {
          if(c==*cs) return 1;                   //se il carattere corrisponde esce con 1
          cs++;                                                //altrimenti passa al successivo
     }
     return 0;                                                //se non trova niente ritorna 0...
}

char* g(char* s, char* cs)
{
     while(!f(*s,cs) && *s!='\0')            //...se non ha finito l'altra stringa....
          s++;                                          //...prova col carattere successivo
     return s;                          //qui?? ritorna il carattere che hanno in comune o 
}                                //l'ultimo se non ne hanno? o ritorna più di un carattere?

int main(int argc, char** argv)
{
     char* a[3]={"quare", "id", "faciam"};
     char* b[3]={"aeiou", "qwerty", "quiquoqua"}

     int i;
     for(i=0; i<3; i++)
          printf("%ld\n", g(a[i], b[i])-a[i]);      //qui non capisco la sottrazione...
}

non riesco a capire l'operazione della printf...se qualcuno è così gentile da spiegarmelo...
grazie!

[MItaly]

int f(char c, char *cs)                          
{                                                         
     while(*cs!='\0')                              //fino a che finisce il vettore di caratteri
     {
          if(c==*cs) return 1;                   //se il carattere corrisponde esce con 1
          cs++;                                                //altrimenti passa al successivo
     }
     return 0;                                                //se non trova niente ritorna 0...
}

char* g(char* s, char* cs)
{
     while(!f(*s,cs) && *s!='\0')            //...se non ha finito l'altra stringa....
          s++;                                          //...prova col carattere successivo
     return s;    //restituisce la stringa s dal carattere comune in poi
}

int main(int argc, char** argv)
{
     char* a[3]={"quare", "id", "faciam"};
     char* b[3]={"aeiou", "qwerty", "quiquoqua"}

     int i;
     for(i=0; i<3; i++)
          printf("%ld\n", g(a[i], b[i])-a[i]);      //sottrae al puntatore restituito il puntatore alla prima lettera della stringa in questione, ottenendo così la posizione del carattere puntato nella stringa
}

[W_As]

ah.
quindi poi l'output è

1   //perché trova la u che è la seconda lettera 
2   //perché raggiunge il carattere nullo che sarebbe il terzo
1   //perché trova la a che è seconda

adesso l'output ha un senso^^
però non ho capito ancora cosa succede nella sottrazione...

velocissimo a rispondere! buono a sapersi, perché fra meno di una settimana ho l'esame e ho altri dubbi.

grazie mille!

[MItaly]

Originariamente inviato da W_As
però non ho capito ancora cosa succede nella sottrazione...

La funzione restituisce un puntatore al carattere uguale; ora, se tu sottrai ad esso il puntatore all'inizio della stringa, otterrai il numero di caratteri che separano i due puntatori, ossia il numero del carattere uguale.

velocissimo a rispondere! buono a sapersi, perché fra meno di una settimana ho l'esame e ho altri dubbi.

Chiedi pure.

[W_As]

Stanotte credo di aver avuto l'illuminazione.
In pratica abbiamo che: 'q' è allocata , per esempio, alla posizione 100, 'u' alla 101 ecc.
il puntatore che torna la funzione punta a 'u', quindi a 101, mentre quello che punta all'inizio della stringa ha valore 100. 101-100=1. che poi per renderlo più "leggibile" sarebbe stato meglio sommare 1 al risultato,no?
Fa solo una sottrazione perché sono char, giusto? se no avrebbe dovuto dividere il risultato per sizeof(tipo)?

Grazie! Adesso provo a capire il codice successivo. Se non riesco....^^

[MItaly]

Originariamente inviato da W_As
Stanotte credo di aver avuto l'illuminazione.
In pratica abbiamo che: 'q' è allocata , per esempio, alla posizione 100, 'u' alla 101 ecc.
il puntatore che torna la funzione punta a 'u', quindi a 101, mentre quello che punta all'inizio della stringa ha valore 100. 101-100=1.

Esatto.

che poi per renderlo più "leggibile" sarebbe stato meglio sommare 1 al risultato,no?

Questione di abitudine; programmando da tanto tempo in C++ sono abituato a sapere che il primo elemento ha indice zero.

Fa solo una sottrazione perché sono char, giusto? se no avrebbe dovuto dividere il risultato per sizeof(tipo)?

No. L'aritmetica dei puntatori tiene già conto delle dimensioni del tipo.