[C] Chiarimento sull'incremento dell'array e funzione

[Istvan]

Buonasera a tutti, come da topic vorrei chiedere qual è la differenza, nel linguaggio C, tra un incremento del tipo

a[i]++

e uno di tipo

a[i++]

Quest'ultimo incrementa il valore dell'indice dopo aver eseguito l'operazione, ma del primo non ne ho la minima idea.

Poi, qual è l'operazione che devo eseguire, avendo un'istruzione del tipo:

A[1]=f1(A, *p);

Non capisco cosa vuol dire che quell'indice dell'array debba diventare uguale a quei valori.
*p = A + 3 quindi tecnicamente al terzo valore dell'array, quindi A[2].
A invece dovrebbe essere il primo valore quindi A[0], che ha valore 1 secondo il problema.

Sono domande da studente moooolto in erba, ma non riesco proprio ad arrivarci
Spero di aver indovinato la sezione, grazie per l'aiuto.

[MItaly]

Originariamente inviato da Istvan
Buonasera a tutti, come da topic vorrei chiedere qual è la differenza, nel linguaggio C, tra un incremento del tipo

a[i]++

e uno di tipo

a[i++]

Quest'ultimo incrementa il valore dell'indice dopo aver eseguito l'operazione, ma del primo non ne ho la minima idea.

Partiamo dall'inizio.
L'operatore ++ postfisso (ovvero, posto dopo l'operando su cui opera) incrementa l'operando di uno, ma restituisce il valore com'era prima che fosse incrementato.

Nel primo caso, l'operando è a[i]; pertanto, viene incrementato il valore che sta nell'i-esima posizione dell'array a; l'espressione complessivamente restituisce come valore il valore che stava in a[i] prima dell'incremento.
Nel secondo caso, l'operando è i; pertanto, i viene incrementato di 1, ma il valore restituito è il valore di i prima dell'incremento, per cui l'espressione a[i++] restituisce l'elemento corrispondente al valore di i prima dell'incremento.

Mi spiego meglio con un esempio:

int a[10]={0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
int i=5;
printf("%d",a[i]);   /* stampa 50, ossia il contenuto della cella 5 dell'array */
printf("%d",a[i++]); /* stampa ancora 50, ma intanto i è stato incrementato di 1, e vale 6 */
printf("%d",a[i]);   /* infatti ora stampa 60, perché i vale 6 */
printf("%d",a[i]++); /* stampa ancora 60 (i vale 6), ma intanto il valore nella cella 6 dell'array è stato incrementato di 1 */
printf("%d",a[i]);   /* infatti ora stamperà 61 */

Poi, qual è l'operazione che devo eseguire, avendo un'istruzione del tipo:

A[1]=f1(A, *p);

Non capisco cosa vuol dire che quell'indice dell'array debba diventare uguale a quei valori.

L'operando a sinistra non è l'indice dell'array, è il secondo elemento dell'array (A[1]); quell'istruzione memorizza nella posizione 1 dell'array A il valore restituito dalla funzione f1.

[Istvan]

Grazie mille per la spiegazione , mi hai chiarito un grosso dubbio, per quanto banale potesse essere.

Per quanto riguarda la funzione, a cosa serve il puntatore *p all'interno di f1(A, *p) se ciò a cui punta p è stato specificato fuori dalla funzione f1? (cioè A+3)
La funzione f1 mi dà come return a[0] (altra cosa che non mi spiego è la differenza tra a minuscolo e maiuscolo), quindi a sua volta il valore restituito di a[0] deve spostarsi in A[1]?

Chiedo scusa per la confusione...

Edit: ho assegnato il valore di A ad A[1] e così ho risolto l'esercizio... tuttavia non riesco proprio a capire che senso abbia quel puntatore *p = A +3, che ritrovo poi in A[1] = f1 (A, *p)... per come ho lavorato io non mi è stato di nessuna utilità...

[MItaly]

Posta il codice completo.

[Istvan]

Se f1 è definita come:
int f1(int *a, int n) { int i=0;
for (i=0; i<n; i++) if (a[i++] < n) a[i]++;
return a[0];}
Cosa stampa il seguente frammento di codice?
int A[4]={1, 2 ,3, 4}, *p=A+3;
A[1]=f1(A, *p); printf("\n%d,%d,%d",A[1],A[2],A[3]);

Questa è una delle tre tipologie di esercizi che dovremo svolgere...
Su un'altra c'è il while, e sull'altra ancora vengono modificati dei caratteri della parola "pippo".

In generale, per eseguire questi esercizi ci è stato detto di ragionare graficamente, nel senso che dobbiamo disegnare i record di attivazione delle funzioni con le celle, il valore che esce, e il cliente.
Non so se effettivamente è la via più semplice.

Grazie per l'aiuto.

[MItaly]

p = A+3 fa sì che il puntatore punti al quarto elemento di A, che contiene 4. Il puntatore viene poi dereferenziato nella chiamata a f, che riceverà come primo parametro un puntatore al primo elemento di A (ovvero, di fatto, gli si passa l'array A per riferimento) e come secondo parametro 4. f dunque stampa i 4 elementi di A.

[Istvan]

Grazie MItaly, sto riuscendo a fare sia le tipologie con il for che con il while.
Finalmente ci sto raccapezzando qualcosa

Il mio "incubo" adesso è diventata la tipologia con le stringhe, dove, ad essere onesto, non so dove mettere mano. Ti spiego come ho provato a ragionare io:

Se f1 è definita come:
char *f1(char *str1, char *str2) {                  /* *f1 non so cosa di preciso voglia dire; ho rappresentato char *str1, char *str2 come due puntatori, uno alla prima stringa di PLUTO (quindi P?) e l'altro alla seconda (quindi L) */
int i=0, j=0;                                       /* perchè ci sono due indici? per gli int avevo soltanto i = 0, o comunque un solo indice... così è come se avessi due array, no? */
while (str1[i])
if (str1[i++]==str2[j]) {j++; str2--;}              /* non avendo capito perchè ci sono due indici, non capisco cosa devo incrementare con j++; inoltre str2-- vuol dire che da L devo scalare ad una lettera in meno (K)? */
else str1[j]++;                                     /* qui sono proprio all'apice dell'ignoranza, come fa str1[i] a cambiare indice e diventare str1[j]?? */
return str1;}                                   
Cosa stampa il seguente frammento di codice?
char str[]="pluto";
printf("\n%s\n", f1(str, str+2));                   /* adesso perchè non ho più str1, ma solo str? e str+2 cosa stampa? La funzione deve stampare "rnuto" ma anche provando in diversi modi non sono riuscito... */

Chi ha voglia di darmi una mano, è ringraziato già da adesso... mi rendo conto che per chi conosce questo linguaggio perfettamente, sono domande e dubbi noiosi...
Più che l'esercizio in sè, mi interessa capire quei passaggi, e magari quindi come ragionare per le prossime volte...

Se vado contro il regolamento o non sono nella sezione giusta, liberi di chiudere.

Grazie...

[MItaly]

"f1 non so cosa di preciso voglia dire": niente, è il nome della funzione
"uno alla prima stringa di PLUTO (quindi P?) e l'altro alla seconda (quindi L)": al primo e al terzo carattere

Sulla questione degli indici, ti stai facendo troppi problemi; sono due normali variabili int, non c'è nulla che le leghi ad un particolare array.
Il while fa sì che il ciclo continui finché str1[i] non è diversa da zero - ossia, di fatto, finché con l'indice i non si arriva alla fine di str1.
L'if sceglie un blocco o l'altro a seconda che i due caratteri sono uguali o meno; intanto incrementa anche l'indice i.
Il j++ incrementa il secondo indice; str2-- decrementa il puntatore di str2, facendolo puntare quindi al carattere precedente.
Comunque, il j++ e l'str2-- di fatto fanno sì che str2[j] si riferisca sempre allo stesso carattere (ovvero, per come viene chiamata la funzione, a str+2, ossia a 'u'): infatti se decrementi la posizione iniziale del vettore (str2) ma incrementi l'indice (j) ti ritrovi sempre nello stesso posto. D'altra parte l'incremento di j influisce sullo str1[j]++, che incrementa la lettera nella j-esima posizione in str1, facendola diventare la lettera successiva.

Nel tuo caso, comunque, la questione è un po' cervellotica ma si sbroglia facilmente
str1 parte come "pluto", str2 parte come "uto".
Prima iterazione: i=0, j=0, i due caratteri (p e u) sono diversi, viene incrementato str1[j], ovvero p diventa q. str1 è "qluto"
Seconda iterazione: i=1, j=0, i due caratteri (l e u) sono diversi, viene incrementato str1[j], ovvero q diventa r. str1 è "rluto"
Terza iterazione: i=2, j=0, i due caratteri (u e u) sono uguali; j viene incrementato e va a 1, str2 viene decrementato, e dunque str2 "inizia un carattere prima". str1 dunque rimane "rluto", str2 è "luto".
Quarta iterazione: i=3, j=1, i due caratteri (t e u) sono diversi; viene incrementato str1[j], per cui l diventa m. str1 è "rmuto".
Quinta iterazione: i=4, j=1, i due caratteri (o e u) sono diversi; viene incrementato str1[j], per cui m diventa n. str1 è "rnuto".
Quinta iterazione: i=5, str1[i] è il carattere di fine stringa, che vale 0, pertanto il while termina. str1 è il valore restituito dalla funzione, la printf stampa "rnuto".

Tip: per seguire il codice più facilmente, indentalo correttamente

char *f1(char *str1, char *str2)
{
    int i=0, j=0;
    while (str1[i])
        if (str1[i++]==str2[j])
        {
            j++;
            str2--;
        }
        else str1[j]++;
    return str1;
}

char str[]="pluto";
printf("\n%s\n", f1(str, str+2));

e usa un editor con evidenziazione della sintassi, aiuta moltissimo:

[Istvan]

Fantastico!! Sto risolvendo anche tutti gli esercizi con i char!!
Se mi blocco, arrivo al procedimento attraverso il risultato, sperando di non incontrare ambiguità, e quindi il gioco è fatto...

Ho risolto anche il codice qui sotto, anche se sono giunto appunto ad una ambiguità per quanto riguarda il comando str2--.
Ora ti spiego: riesco in entrambi i casi a stampare "pjpqo" però ho un dubbio per quanto riguarda str2--. La seconda stringa parte dal terzo carattere, quindi è "PPO", e facendo lo str2-- ottengo "IPPO". Ora, quando vado a rifarlo, l'indice è J è 1, quindi teoricamente mi rimane sempre "IPPO" e il puntatore mi passa dalla P alla I? Poi J = 2 e devo rifare lo str2--, quindi cambia semplicemente il puntatore che va a dalla terza P alla seconda P? In questo caso, per arrivare la soluzione devo contare anche il sesto carattere "\0", altrimenti terminerei con O = O, senza arrivare alla soluzione.

Oppure, nell'altro caso che ho provato, ogni volta che ho str2--, indipendentemente dal valore dell'indice, scalo di uno la cella, quindi diventa prima "IPPO", poi "PIPPO".
Però in questo caso "sforerei", nel senso che la terza volta che devo eseguire str2--, non ho più celle da decrementare e quindi dovrei ottenere una violazione d'accesso.

Spero di non aver creato troppa confusione...
grazie di tutto MItaly, sei stato gentilissimo e molto disponibile; sei riuscito a farmi risolvere esercizi sui quali non sapevo neanche dove mettere mano :P

Se f1 è definita come:
char *f1(char *str1, char *str2) {
int i=0, j=0;
while (str1[i])
if (str1[i++]==str2[j]) {j++; str2--;}
else str1[j]++;
return str1;}
Cosa stampa il seguente frammento di codice?
char str[]="pippo";
printf("\n%s\n", f1(str, str+2));

[MItaly]

Oppure, nell'altro caso che ho provato, ogni volta che ho str2--, indipendentemente dal valore dell'indice, scalo di uno la cella, quindi diventa prima "IPPO", poi "PIPPO".

È così.

Però in questo caso "sforerei", nel senso che la terza volta che devo eseguire str2--, non ho più celle da decrementare e quindi dovrei ottenere una violazione d'accesso.

No, perché il puntatore così decrementato non lo dereferenzi, ma dereferenzi sempre str2[j], che punta sempre e comunque al terzo carattere (dato che ad ogni str2-- corrisponde un j++).