Hogy kell függvényt deklarálni és meghívni C-ben?

Ahhoz, hogy meghívhasd a függvényt, előbb deklarálnod kell.

Ahogy a változókat is.

Ez nem neked kell, hanem a fordítónak, hogy hozzá tudjon rendelni a függvény belépési pontjához egy memóriacímet. Így a meghíváskor bárhonnan is van meghívva a függvény, tudni fogja hova kell ugrani. Ezért a deklaráció.

A pointeres kérdés elég messzire vezet, arra ilyen röviden nem lehet válaszolni.

Egy függvény, az nem más, mint egy alprogram ami csinál valamit. Mondjuk összead két számot.

A függvénynek valahogy oda kell passzolni azt a két számot, amivel műveletet végez. Erre kell a paraméter, ami nem más, mint az összeadandó számok.

A függvénynek ezen túl van egy olyanja, hogy visszatérési érték. Ez az az érték, amit a függvény kiszámol (esetünkben összead), ha meghívják. Ennek tipusát a függvény deklarációs részében definiálni kell. Mondjuk esetünkben ez integer.

Pszeudóban, kb az alábbi.

Deklaráció:

integer I;

Integer Fuggveny(a,b: integer);

Itt az első integer a függvény tipusa, az a és a b pedig a feldolgozandó (összeadandó) számok, amelyek szintén integer tipusúak.

Ha pedig meghívod, akkor így néz ki:

I = Fuggveny(34,65);

Ahol I megint egy integer, amibe a függvény által kiszámolt érték (99) kerül. A 34 és a 65 meg a két összeadandó.

[link]

Itt eléggé érthetően le van írva minden

Amikor deklarálsz egy függvényt, akkor a zárójelen belül a paramétereket adod meg. A "kifejtés" az megint más, van, hogy külön deklarálsz és definiálsz egy függvényt, de lehet egyből definíciót adni, szerintem az a könnyebb eset, most vegyük azt.

A "paraméter" az egy olyan dolog, aminek nincs konkrét értéke, majd akkor lesz, ha meghívod a függvényt. Amiket ekkor átadsz neki, az az "argumentum". Itt ez a paraméter, matekból: sin(x)

--"És, hogy ez hogyan változik meghíváskor, deklaráláskor"

Talán egy másik nézőpont segíteni fog (nem biztos, hogy mindenki így gondolja, de hátha megérted).

Szerintem nálad az a baj, hogy nem a különbség kavar meg, hanem a hasonlóság. A deklarációnak és a hívásnak nem sok köze van egymáshoz; hasonlóan néznek ki. Mondhatnám úgy is, hogy "az a zárójel, az nem az a zárójel". Könnyebb lesz egy pointeres példa, ott nincs még az sem:

int *x = 0;

if (x == 0); // igaz

*x = 5; // runtime error

Az első csillag azt jelzi, hogy pointer típusú változóról van szó.

A második csillag a "dereference operator", azzal egy műveletet végzel.

Az első esetben nem tehetsz mindenféle operátort, amit akarsz, mert nem lehet:

int *&x = 0; // szintaktikai hiba

*&x = 0; // működik

Lehetne így is az egész:

int pointer x = 0;

*x = 5;

Nincs két csillag, nincs félreértés sem.

Hát mivel itt nincs semmilyen pointer, ezért simán:

f(c);

f(int c) { ... }