Pazi, [tt]x = y[/tt] mijenja [tt]x[/tt] (koji god tip [tt]x[/tt] bio). Ako je [tt]x[/tt] (ne [tt]*x[/tt]!) argument funkcije, on je kopija neceg od tamo gdje je funkcija pozvana (recimo iz [tt]main[/tt]-a, da ne kompliciramo). Dakle, tebi [tt]first = nesto[/tt] mijenja onaj [tt]first[/tt] iz funkcije koji je samo kopija [tt]first[/tt]-a iz [tt]main[/tt]-a. Uopce nije bitno sto su ti [tt]first[/tt]-ovi pointeri.
S druge strane, [tt]*x = y[/tt] i [tt]x->nesto = y[/tt] mijenja ono na sto [tt]x[/tt] pokazuje, a ne sam [tt]x[/tt]. I dalje je [tt]x[/tt] kopija necega, ali ono na sto on pokazuje nije kopija nego original (koji, opcenito, nema kopiju).
Dakle, nisu pointeri "posebni", nego preko njih glumimo ono sto se u drugim jezicima (npr. Pascalu) zove "varijabilni argumenti".
Primjer:
[code:1]void f(int a, int *b, int *c, int **d) {
int tmp = (int *)malloc(sizeof(int));
/* prvo s int i int* */
a = 17; /* a je lokalna kopija varijable e, pa se e ne mijenja */
*b = 17; /* b je lokalna kopija rezultata izraza &f, tj. b pokazuje na f, pa se ovdje mijenja vrijednost od f */
/* identicno vrijedi za int* i int** (pointer na int*) */
c = tmp; /* c je lokalna kopija varijable g, pa se g ne mijenja */
*d = tmp; /* d je lokalna kopija rezultata izraza &h, tj. d pokazuje na h, pa se ovdje mijenja vrijednost od h */
}
...
int main(void) {
int e, f, *g, *h;
f(e, &f, g, &h);
/* ovdje su e i g i dalje neinicijalizirani, tj. e je neki bezvezni broj, a g pointer koji gotovo sigurno pokazuje na nesto nealocirano */
free(h);
return 0;
}[/code:1]
Ako nije jasno, vidi identicni kod:
[code:1]typedef int tip1;
typedef int* tip2;
void f(tip1 a, tip1 *b, tip2 c, tip2 *d) {
int tmp = (tip2)malloc(sizeof(int));
/* prvo s tip1 i tip1* */
a = 17; /* a je lokalna kopija varijable e, pa se e ne mijenja */
*b = 17; /* b je lokalna kopija rezultata izraza &f, tj. b pokazuje na f, pa se ovdje mijenja vrijednost od f */
/* identicno vrijedi za tip2 i tip2* */
c = tmp; /* c je lokalna kopija varijable g, pa se g ne mijenja */
*d = tmp; /* d je lokalna kopija rezultata izraza &h, tj. d pokazuje na h, pa se ovdje mijenja vrijednost od h */
}
...
int main(void) {
tip1 e, f;
tip2 g, h;
f(e, &f, g, &h);
/* ovdje su e i g i dalje neinicijalizirani, tj. e je neki bezvezni broj, a g pointer koji gotovo sigurno pokazuje na nesto nealocirano */
free(h);
return 0;
}[/code:1]
Nadam se da je ovdje jasno da se [tt]a[/tt], [tt]b[/tt], [tt]e[/tt] i [tt]f[/tt] ponasaju identicno kao [tt]c[/tt], [tt]d[/tt], [tt]g[/tt] i [tt]h[/tt] (sve je isto, samo su jedni definirani preko [tt]tip1[/tt], a drugi preko [tt]tip2[/tt]).
Gradivo Prog 1, btw... :)
Pazi, x = y mijenja x (koji god tip x bio). Ako je x (ne *x!) argument funkcije, on je kopija neceg od tamo gdje je funkcija pozvana (recimo iz main-a, da ne kompliciramo). Dakle, tebi first = nesto mijenja onaj first iz funkcije koji je samo kopija first-a iz main-a. Uopce nije bitno sto su ti first-ovi pointeri.
S druge strane, *x = y i x→nesto = y mijenja ono na sto x pokazuje, a ne sam x. I dalje je x kopija necega, ali ono na sto on pokazuje nije kopija nego original (koji, opcenito, nema kopiju).
Dakle, nisu pointeri "posebni", nego preko njih glumimo ono sto se u drugim jezicima (npr. Pascalu) zove "varijabilni argumenti".
Primjer:
Kod: | void f(int a, int *b, int *c, int **d) {
int tmp = (int *)malloc(sizeof(int));
/* prvo s int i int* */
a = 17; /* a je lokalna kopija varijable e, pa se e ne mijenja */
*b = 17; /* b je lokalna kopija rezultata izraza &f, tj. b pokazuje na f, pa se ovdje mijenja vrijednost od f */
/* identicno vrijedi za int* i int** (pointer na int*) */
c = tmp; /* c je lokalna kopija varijable g, pa se g ne mijenja */
*d = tmp; /* d je lokalna kopija rezultata izraza &h, tj. d pokazuje na h, pa se ovdje mijenja vrijednost od h */
}
...
int main(void) {
int e, f, *g, *h;
f(e, &f, g, &h);
/* ovdje su e i g i dalje neinicijalizirani, tj. e je neki bezvezni broj, a g pointer koji gotovo sigurno pokazuje na nesto nealocirano */
free(h);
return 0;
} |
Ako nije jasno, vidi identicni kod:
Kod: | typedef int tip1;
typedef int* tip2;
void f(tip1 a, tip1 *b, tip2 c, tip2 *d) {
int tmp = (tip2)malloc(sizeof(int));
/* prvo s tip1 i tip1* */
a = 17; /* a je lokalna kopija varijable e, pa se e ne mijenja */
*b = 17; /* b je lokalna kopija rezultata izraza &f, tj. b pokazuje na f, pa se ovdje mijenja vrijednost od f */
/* identicno vrijedi za tip2 i tip2* */
c = tmp; /* c je lokalna kopija varijable g, pa se g ne mijenja */
*d = tmp; /* d je lokalna kopija rezultata izraza &h, tj. d pokazuje na h, pa se ovdje mijenja vrijednost od h */
}
...
int main(void) {
tip1 e, f;
tip2 g, h;
f(e, &f, g, &h);
/* ovdje su e i g i dalje neinicijalizirani, tj. e je neki bezvezni broj, a g pointer koji gotovo sigurno pokazuje na nesto nealocirano */
free(h);
return 0;
} |
Nadam se da je ovdje jasno da se a, b, e i f ponasaju identicno kao c, d, g i h (sve je isto, samo su jedni definirani preko tip1, a drugi preko tip2).
Gradivo Prog 1, btw...
_________________ U pravilu ignoriram pitanja u krivim topicima i kodove koji nisu u [code]...[/code] blokovima.
Takodjer, OBJASNITE sto vas muci! "Sto mi je krivo?", bez opisa u cemu je problem, rijetko ce zadobiti moju paznju.
|