Report - funkció - számítástechnika, programozás

A szokásos módon, hogy bármit a C ++ programot - az, hogy egy függvény, amely erre nem képes. A függvénydefinícióval módon megkérdezni, hogy hogyan kell csinálni bizonyos tevékenységek. A funkció nem lehet hivatkozni, amíg ez nincs leírva.

A funkció leírása meghatározza a függvény nevét, típusát függvény visszatérési értéke (ha van), és a számát és típusát paramétereket kell lennie függvényhívás.

extern kettős sqrt (dupla);

extern elem * next_elem ();

extern char * strcpy (char * a, const char * a);

extern void exit (int);

Szemantika átviteli paraméterek azonosak szemantikája inicializálás. Paraméter típusok ellenőrizzük, és ha szükséges, tett implicit típusú átalakítás. Például, ha a korábbi meghatározások kaptak, a

kettős SR2 = sqrt (2);

lenne megfelelően lásd a sqrt () funkció az érték a lebegőpontos 2.0. Az érték egy ilyen típusú ellenőrzés és az átalakítás típusát hatalmas.

Funkció Leírás tartalmazhat a paraméter neveket. Ez segíthet az olvasót, hanem a fordító egyszerűen kimarad ezeket a neveket.

Minden funkció, az úgynevezett a programban kell meghatározni valahol (csak egyszer). Függvénydefiníció - ez a leírás a függvény, ami a szervezet működését.

extern void-swap (int *, int *); // leírás

void csere (int * int *) // definíció

Annak elkerülése érdekében, a kiadások egy hívás funkciót, a funkció lehet leírni, mint szövegközi, hogy gyorsabb hozzáférést a paramétereket, akkor lehet leírni, mint egy nyilvántartás. Mindkét eszköz lehet visszaélni, és el kell kerülni, ahol van bármilyen kétség merül fel azok hasznosságát.

Ha ezt a funkciót nevezik, további memóriát alatt formális paraméterek, és minden formális paraméter inicializálja annak megfelelő tényleges érv. Szemantika átviteli paraméterek azonosak szemantikája inicializálás. Különösen a típus az aktuális paraméter van leképezve a típus a formális paraméter, és elvégzi az összes szabványos és bizonyos típusú konvertáló felhasználó. Vannak speciális szabályok az átviteli vektorok, azt jelenti, hogy egy paramétert ellenőrzése nélkül és beállító eszközt az alapértelmezett paraméterekkel.

void f (int Val, int ref)

Amikor az úgynevezett f (), val ++ növeli a helyi másolatot az első aktuális paraméter, mivel ref ++ növeli a második aktuális paraméter.

void f (const nagy arg)

// értéke «arg» nem lehet változtatni

Hasonlóképpen, a leírás arról, hogy az index paraméter const elmondja az olvasónak, hogy az érték az objektum által jelzett pointer funkció nem változik.

extern int strlen (const char *); // a

extern char * strcpy (char * a, const char * a);

extern int strcmp (const char *, const char *);

Annak fontosságát, hogy ez a gyakorlat növeli a méretét a program.

Vegye figyelembe, hogy a paraméter halad szemantika eltér a szemantika feladat. Fontos, hogy a const paraméterek referencia paraméterek és paraméterek néhány felhasználó által definiált típusok.

A függvény, amely nem le, mint egy void, lehet (és kell) visszatérési érték. A visszatérési érték határozza meg a bevallását.

A funkció lehet egynél több piaci szereplő, hogy visszatér:

Ahogy paraméterátadási szemantikáját, szemantikáját funkció visszatérési értékek azonos a szemantikáját inicializálás. A visszatérési érték tekinthető, mint egy változó kezdőérték visszatérési típus. A visszatérési típusú kifejezés ellenőrizzük összhang visszatérési típus és kivégezték az összes szabványos és bizonyos típusú konvertáló felhasználó.

vissza 1; // implicit alakítjuk a kettős (1)

visszatérés &local; // ne csináld

Ez a hiba kevésbé gyakori, mint az egyenértékű hiba, ha referenciák:

visszatérés helyi; // taknedelayte

Szerencsére azok visszatérési értékeit megakadályozza, hogy a fordító.

Itt egy másik példa:

int F () // ne csináld

Ha a funkciók paraméter vektort használunk, akkor a mutató az első elemet.

int strlen (const char *);

char v [] = «vektor»

Más szavakkal, az átviteli, mint a paraméter típusú T [] alakítjuk t *. Következésképpen, a hozzárendelési elem megváltoztatja a paraméter értékét vektor vektor elembe, amely paramétert. Más szavakkal, a vektor különbözik az összes többi típusnál, hogy a vektor nem küldött (vagy adott) értékkel.

vektor méret nem áll rendelkezésre a hívó függvény. Lehet, hogy kényelmetlen, de ez nehezen megkerülhető több módszer. Vonal végződő nulla, így a mérete könnyen ki lehet számolni. Más vektorok képes továbbítani egy második paramétert, amely meghatározza a méret, vagy hogy meghatározza a típusú tartalmazó egy mutatót, és a hossza indikátor, és továbbítja azt ehelyett egyszerűen vektor.

void compute1 (int * vec_ptr, int vec_size); // odinsposob

struct VEC

void compute2 (VEC v);

A többdimenziós tömbök minden trükkösebb, de gyakran akkor helyette egy vektor a mutatók, amelyek nem igényelnek különös figyelmet.

«Mon», «K», «sze», «Cs», «P», «ült», «nap»

Másrészt, figyelembe vesszük a meghatározása, hogy a funkció működik kétdimenziós tömböket. Ha a méretek ismert fordítási időben, akkor nincs probléma:

void print_m34 (int m [3] [4])

A (int i = 0; i<3; i++)

A (int j = 0; j<4; j++)

cout <<" " <

cout <<"\n";

Matrix, persze, még mindig telt el, mint egy mutató, és a méreteket használjuk egyszerűen jelölési kényelmét.

Az első dimenzió a tömb nem kapcsolódik a probléma megtalálni a helyzetben az elem. Ezért átadhatók paraméterként:

void print_mi4 (int m [] [4], int Dim1)

Az alapértelmezett beállítások

Gyakran a legáltalánosabb esetben a függvény igényel több paramétert, mint a legegyszerűbb eset, és gyakrabban használják. Például, a könyvtárban áramlás függvénye hex (), így egy string hexadecimális ábrázolása az egész. A második paraméter adható meg a karakterek számát, hogy képviselje az első paraméter. Ha a karakterek száma túl kicsi, hogy képviselje az egész, akkor csonka, ha túl nagy, akkor a húr van zárva üres. Gyakran a programozó nem érdekel a karakterek számát szükséges képviseli az egész, hiszen a karakterek elég. Ezért nullára a második paraméter határozza meg, hogy „használja annyi karaktert, amire szükség van.” Annak elkerülése érdekében, eltömődés a program kihívások, mint hex (i, 0), a funkció leírása a következő:

extern char * hex (hosszú, int = 0);

Initializer második paraméter az alapértelmezett beállítás. Azaz, ha a hívás a csak az egyik lehetőség, mint a második paraméter az alapértelmezett.

cout <<"**" <

cout <<"**" <

Az alapértelmezett beállítás be van jelölve típusú függvény és kiszámítása idején a hívását. Az alapértelmezett beállítás csak akkor lehetséges, kérje a legfrissebb paramétereket, így

int f (int, int = 0, char * = 0); // ok

int g (int = 0, int = 0, char *); // hiba

int f (int = 0, int, char * = 0); // hiba

Figyeljük meg, hogy ebben az összefüggésben a tér között, és * = szignifikáns (* = egy értékadó operátor):

int csúnya (char * = 0); // szintaktikai hiba

Túlterhelés függvény neve

Főszabály, hogy a különböző funkciók különböző nevek - az ötlet jó, de ha néhány funkció ugyanazt a munkát végzik a tárgyak különböző típusú kényelmesebb lehet, hogy nekik ugyanaz a neve. A használata egy nevet a különböző intézkedések különböző típusok úgynevezett túlterhelés (túlterhelés). A módszert már használják a C ++ alapvető műveleteket: amellett, hogy csak egy név, + de lehet használni hozzá az értékek integrált, úszó, és a mutató típusok. Ez az ötlet könnyen kiterjeszthető a feldolgozási műveletek a felhasználó által meghatározott, azaz a funkciókat. Hogy megvédje a programozó véletlenül újra a név, lehet használni egynél több funkciót csak akkor, ha le először a zsúfolt.

Ami a fordító, az egyetlen dolog közös, hogy van egy funkció, az azonos nevű, a neve. Feltehetően ezek bizonyos értelemben hasonló, de a nyelv nem is korlátozhatják a programozó vagy segít neki. Így túlterhelt függvény nevek - többnyire a kényelem bejegyzést. Ez a kényelem sokkal esetében funkciók közös nevek, mint a gyök, print és nyitott. Ha a név szemantikailag lényeges, mivel az eset a műveletek, mint a +, * és <<и в случае конструкторов, это удобство становится существенным.

Ha telefonál egy túlterhelt f (), a fordító meg kell értenie, hogy melyik funkció elemzi f kell alkalmazni. Ez úgy történik, hogy összehasonlítjuk a fajta aktuális paraméterek a fajta hivatalos paraméterei nevű függvény f. Keresési funkciók, hogy meg kell hívni, elvégzett három különálló lépésből áll:

Keresés funkció pontosan megfelel használni, és ha úgy találja,

Keresse meg a megfelelő funkciót a beépített átalakító és használjon talált funkció; és

Keresés a megfelelő funkciót a konverzió a felhasználó által meghatározott, és ha a beállított transzformációk egyedülálló, használja a talált funkciót.

túlterhelés print (dupla), print (int);

Szabály pontos egyezés biztosítja, hogy a nyomatok F 1, mint egész, és 1,0, mint egy lebegőpontos szám. Zero, char, illetve rövid int paramétert pontosan mérkőzés. Hasonlóképpen, úszó pontosan megfelel kettős.

A paraméterei funkciók túlterhelve nevét a szabványos C ++ átváltási szabályokat nem teljesen. Konverzió, amely képes elpusztítani az adatok nem teljesülnek. Int maradnak hosszú, int a kettős, egy nulla hosszú, és a nulla a kettős konverziós mutató: egy mutatót nulla, nulla void *, és egy mutatót a származtatott osztály, hogy egy mutatót a kiindulási osztályban.

Itt egy példa, amelyben az átalakítás szükséges:

túlterhelés print (dupla), print (hosszú);

Lehet, hogy egy nyomtatott vagy dupla, vagy hogy mennyi ideig. Kétértelműség megoldódott kifejezetten konverziós típusú (vagy nyomtatási (hosszú (a)), vagy a nyomtatási (dupla (a))).

E szabályok értelmében biztosítani tudja, hogy amikor a hatékonyság vagy a pontosság, a számítások típusú használt jelentősen eltér egymástól, az algoritmus fogja használni a legegyszerűbb (funkció).

kétágyas pow (dupla, dupla); // a

komplex pow (dupla, komplex); // a

komplex pow (komplex, int);

komplex pow (komplex, dupla);

komplex pow (komplex, komplex);

Protsesspoiskapodhodyascheyfunktsiiignoriruet előjel nélküli és const.

Meghatározatlan számú paramétert

Egyes funkciók nem adja meg a számát és típusát, az összes paraméter, amely várhatóan a hívást. Ez a függvény írja kitöltésével lista leírásai paraméterek ellipszis (.), Ami azt jelenti „és talán néhány más lehetőség.”

Ez határozza meg, hogy a hívás kell printf legalább egy paraméter, char *, a másik lehet, hogy nem lesz.

printf ( «Moeimya% s% s \ n», first_name, second_name);

printf ( ".. + = \ n.", 2,3,5);

Ez a funkció információkra támaszkodik, amely nem áll a fordító értelmezése során a paraméter listában. Abban az esetben, printf () az első paraméter egy formátum string, amely speciális karaktersorozat, amely lehetővé teszi a printf (), hogy megfelelően kezeli a többi paramétert. % S azt jelenti, „várni paraméter char *» is. azt jelenti, „várni int paramétert.” Azonban a fordító nem tudja, azért nem lehet biztos abban, hogy a várt paramétereket megfelelő típust.

printf ( «A nevem% s% s \ n», 2);

Fordítsd le és a legjobb vezetne valami furcsa kinézetű kérdés.

Nyilvánvaló, hogy ha a paraméter még nem írták le, akkor a fordító nincs információ kell elvégezni rajtuk vizsgálat fajtájától és átalakítás. Ebben az esetben a char és továbbítani a rövid int, float és továbbítani a kettős. Ez nem feltétlenül mi vár a felhasználó számára.

Túlzott használata pontok, mint a vad (.), Teljesen kikapcsolja paraméterérvényesítést típusok, így a programozó nyitott számos problémát, amelyek megszokottak a programozók C. Egy jól megtervezett program előírja, legfeljebb néhány funkciókat milyen típusú beállítások nem teljesen ismert. Hogy vigyázzon az ellenőrzés típusát, akkor a túlterhelt függvények és funkciók az alapértelmezett beállításokkal a legtöbb esetben, amikor egyébként távoznia kell kéretlenül típusú paraméterek. Ellipszis csak akkor szükséges, ha megváltoztatja a paraméterek számát és típusát paramétereit. A leggyakoribb használata a pontok a feladat felület a C könyvtári függvények azonosítottak idején nem volt alternatíva:

extern int fprintf (FILE *, char *.); // a

extern int execl (char *.); // a

extern int abort (.); // a

Vegyük azt az esetet írásban a hibafüggvény, amely felvesz egy egész szám, jelölő paramétert a hiba súlyossága, amely követi egy tetszőleges számú sort. Az ötlet az, hogy a hibaüzenet keresztül történő továbbításáról minden egyes szót külön-paraméter:

fő (int argc, char * argv [])