Miért változik meg a tömb értéke?

C-ben a tömb egyenértékű a nulladik elemére mutató mutatóval, azaz a köv. két részlet ekvivalens:
[code:1:6f5afc92f9]
void valami(int *ize)
{
/*...*/
}
[/code:1:6f5afc92f9]
[code:1:6f5afc92f9]
void valami(int ize[])
{
/*...*/
}
[/code:1:6f5afc92f9]
Eszerint a példádban "cím szerint adtad át a tömböt", azaz... szóval igazából a C-ben csak érték szerinti átadás van, és te a tömbödre mutató pointert adtad át érték szerint.

[quote:6c65fb8d32="nzmark"]Biztosan nagyon triviális, -gondolom- de nem értem, hogy a főprogramban a fügvény hívása után miért változik meg a tömb értéke?
Mert ugye nem cím szerint adom át a tömböt. Vagy mégis?

#include <stdio.h>

void fg(int xx[2])
{
printf ("FG_BEN: %d\n",xx[0]);
printf ("FG_BEN: %d\n",xx[1]);
xx[0]=100;
xx[1]=50;

}

int main(void)
{
int x[2];

x[0]=50;
x[1]=100;
printf ("MAIN: %d\n",x[0]);
printf ("MAIN: %d\n",x[1]);
fg(x);
printf ("F_MAIN: %d\n",x[0]);
printf ("F_MAIN: %d\n",x[1]);
}

#./teszt
MAIN: 50
MAIN: 100
FG_BEN: 50
FG_BEN: 100
F_MAIN: 100
F_MAIN: 50

Lehet, hogy nemértem a problémát, de mintha az fg-ben átírnád
az x[0] és az x[1] értékét.

[quote:1730229a58="gsimon"]C-ben a tömb egyenértékű a nulladik elemére mutató mutatóval, azaz a köv. két részlet ekvivalens:
[code:1:1730229a58]
void valami(int *ize)
{
/*...*/
}
[/code:1:1730229a58]
[code:1:1730229a58]
void valami(int ize[])
{
/*...*/
}
[/code:1:1730229a58]
Eszerint a példádban "cím szerint adtad át a tömböt", azaz... szóval igazából a C-ben csak érték szerinti átadás van, és te a tömbödre mutató pointert adtad át érték szerint.

Tapasztalataim szerint nem teljesen ekvivalens - bár lehet, hogy
rosszul emlékszem. Az egyik esetben (int izé[]) közvetlenül lehet
indexelni, a másik esetben pointer aritmetikát kell használni:

izé[3] illetve * (izé+3)

(Tévedés jogát fenntartom (-::)

[quote:aaeae3d93d="nzmark"]Mert ugye nem cím szerint adom át a tömböt. Vagy mégis?

Ilyen szempontbol a [] ugyanaz, mint a *, a kovetkezok egyenertekuek:

void fg(int xx[2])
void fg(int xx[])
void fg(int* xx)

[quote:cdd8c76c54="lukit"][quote:cdd8c76c54="nzmark"]Mert ugye nem cím szerint adom át a tömböt. Vagy mégis?

Ilyen szempontbol a [] ugyanaz, mint a *, a kovetkezok egyenertekuek:

void fg(int xx[2])
void fg(int xx[])
void fg(int* xx)

Onnan is lehet, tudni, hogy az értékek átíródnak, hogy a fordító
nem ordít a cím feloldhatatlansága miatt.

Ha mar itt tartunk, tud valaki egy jo forraskod formazo (cpp) progit?

[quote:df53f8daba="meditor"]Lehet, hogy nemértem a problémát, de mintha az fg-ben átírnád az x[0] és az x[1] értékét.

Azt hitte, hogy ha nem hasznal pointert, hanem a tombot adja at, akkor az egesz tomb bekerul a stack-be es a tomb masolataval dolgozni a fuggveny.

[quote:4cbfc83e8d="zsoce"]Ha mar itt tartunk, tud valaki egy jo forraskod formazo (cpp) progit?

indent?

[quote:2baafa0542="lukit"][quote:2baafa0542="meditor"]Lehet, hogy nemértem a problémát, de mintha az fg-ben átírnád az x[0] és az x[1] értékét.

Azt hitte, hogy ha nem hasznal pointert, hanem a tombot adja at, akkor az egesz tomb bekerul a stack-be es a tomb masolataval dolgozni a fuggveny.

Hát a paraméterátadás lényege, nem az, hogy a paraméteren végezzük
el függvényműveletet? Képzeld el, ha minden paraméter megduplázódna
és a függvényművelet az árnyékváltozón hajtódna végre! Vért izzadnánk,
míg előkotornánk az eredményt, nem beszélve e cirkalmas eljárás
időigényéről!

[quote:599dfed4ef="meditor"]Hát a paraméterátadás lényege, nem az, hogy a paraméteren végezzük el függvényműveletet?

nem feltetlenul

[quote:e98f0ba31c="meditor"][quote:e98f0ba31c="lukit"][quote:e98f0ba31c="meditor"]Lehet, hogy nemértem a problémát, de mintha az fg-ben átírnád az x[0] és az x[1] értékét.

Azt hitte, hogy ha nem hasznal pointert, hanem a tombot adja at, akkor az egesz tomb bekerul a stack-be es a tomb masolataval dolgozni a fuggveny.

Hát a paraméterátadás lényege, nem az, hogy a paraméteren végezzük el függvényműveletet? Képzeld el, ha minden paraméter megduplázódna és a függvényművelet az árnyékváltozón hajtódna végre! Vért izzadnánk, míg előkotornánk az eredményt, nem beszélve e cirkalmas eljárás időigényéről!

Most minden parameter "megduplazodik", mert megmarad az eredeti peldany es 1 masolatot pedig atadsz a fuggvenynek. Ha megvaltoztatod a parametert, nem valtozik az eredeti.

[quote:5421a48afc="snq-"][quote:5421a48afc="meditor"]Hát a paraméterátadás lényege, nem az, hogy a paraméteren végezzük el függvényműveletet?

nem feltetlenul

Ez igaz. Defolyásolhatják a függvény futását is.

[quote:8f316a695b="lukit"]

Hát a paraméterátadás lényege, nem az, hogy a paraméteren végezzük el függvényműveletet? Képzeld el, ha minden paraméter megduplázódna és a függvényművelet az árnyékváltozón hajtódna végre! Vért izzadnánk, míg előkotornánk az eredményt, nem beszélve e cirkalmas eljárás időigényéről!

Most minden parameter "megduplazodik", mert megmarad az eredeti peldany es 1 masolatot pedig atadsz a fuggvenynek. Ha megvaltoztatod a parametert, nem valtozik az eredeti.

Ezt most nem egészen értem.

[quote:6ea9c1cdb9="meditor"]Ezt most nem egészen értem.

[code:1:6ea9c1cdb9]
#include <stdio.h>

void f(int x)
{
x++;
}

int main(void)
{
int a=0;
f(a);
printf("a: %d\n", a);
return 0;
}
[/code:1:6ea9c1cdb9]

Output:
[code:1:6ea9c1cdb9]
a: 0
[/code:1:6ea9c1cdb9]

Amikor meghivod az f() fuggvenyt, akkor az 'a' valtozo egy masolatat kapja a fuggveny, azzal dolgozik.

Ha az 'a'-t akarnad megvaltoztatni, akkor egy arra mutato pointert kellene atadnod. Ebben az esetben a parameter 1 pointer, amin keresztul tudsz vmit manipulalni. Am ha magat a pointert valtoztatod, szinten nem ersz el semmit.

[quote:06765ecd66="lukit"][quote:06765ecd66="meditor"]Ezt most nem egészen értem.

[code:1:06765ecd66]
#include <stdio.h>

void f(int x)
{
x++;
}

int main(void)
{
int a=0;
f(a);
printf("a: %d\n", a);
return 0;
}
[/code:1:06765ecd66]

Output:
[code:1:06765ecd66]
a: 0
[/code:1:06765ecd66]

Amikor meghivod az f() fuggvenyt, akkor az 'a' valtozo egy masolatat kapja a fuggveny, azzal dolgozik.

Ha az 'a'-t akarnad megvaltoztatni, akkor egy arra mutato pointert kellene atadnod. Ebben az esetben a parameter 1 pointer, amin keresztul tudsz vmit manipulalni. Am ha magat a pointert valtoztatod, szinten nem ersz el semmit.

O.K. értem mire gondolsz. Nagyon lecövekeltem a tömböknél.

[quote:442c963faa="nzmark"][quote:442c963faa="meditor"]

Lehet, hogy nemértem a problémát, de mintha az fg-ben átírnád
az x[0] és az x[1] értékét.

Igen átírom, de az a fügvényen belül az xx tömb értéke. azért is kérdeztem meg, mert mondjuk ha mindezt egy sima int-tel csináltam volna akkor a mainben a fügvény hívása után az eredeti változó értéke nem változott volna meg, mivel nem cím szerint adom át.

ebben az estben:
void fg(int aa)
{
aa=2;;
}

int main(void)
{
int a;

a=1;
fg(a);
printf ("%d\n",a);
}

nem is változik az eredeti a változó értéke hiszen nem cím szerint adom át. a tömbnél akkor mégis miért változik meg??
tehát továbbra sem értem, hogy miért változik meg az eredeti tömb értéke? vagy mégis cím szerinti átadást végzek, mert a tömb ugye x[valami] én meg csak az x-et adom át és lehet, hogy így átadva mint mutató kerül át a fügvénybe?

Már volt, de mégegyszer: CÍMET adsz át.

A tömböket automatikusan címként adja át a C, mert értékként nyelvi szinten nem tudja.
Ha garantálni akarod, hogy az fg nevű függvény ne tudja megváltoztatni a tömb értékeit, akkor ehelyett:
[code:1:77ccf0263f]void fg(int *xx)[/code:1:77ccf0263f]
így deklaráld a függvényt:
[code:1:77ccf0263f]void fg(const int *xx)[/code:1:77ccf0263f]
A const kulcsszó hatására magának az xx pointernek az értékét meg tudod ugyan változtatni a függvényen belül, de az xx által hivatkozott memóriacímeket nem (vagy legalábbis a fordító anyázik nagyot ha be vannak kapcsolva az épeszű warningok: gcc -Wall).