10.1. Funktsioonimalli määratlemine

Vahel võib tunduda, et tugevasti trükitud keel muudab üldse millegi rakendamise keeruliseks. lihtsad funktsioonid. Näiteks kuigi järgmine algoritm Funktsioon min () on triviaalne, tugev tippimine nõuab, et selle variatsioonid rakendataks kõigi võrreldavate tüüpide jaoks:

int min(int a, int b) (

tagastab a b ? a: b;

double min(double a, double b) (

tagastab a b ? a: b;

Ahvatlev alternatiiv iga eksemplari min() selgesõnaliseks määratlemiseks on kasutada eelprotsessoriga laiendatavaid makrosid:

#define min(a, b) ((a) (b) ? (a) : (b))

Kuid selline lähenemine on täis võimalikke ohte. Eespool defineeritud makro töötab õigesti ka min() lihtsate väljakutsetega, näiteks:

min(10,0, 20,0);

kuid see võib tuua üllatusi keerulisematel juhtudel: selline mehhanism ei käitu nagu funktsioonikutse, vaid teostab vaid tekstilist argumentide asendust. Selle tulemusena hinnatakse mõlema argumendi väärtusi kaks korda: üks kord a ja b võrdlemisel ning üks kord makro tagastatud tulemuse arvutamisel:

#include iostream

#define min(a,b) ((a) (b) ? (a) : (b))

const int suurus = 10;

while (min(p++,ia) != ia)

cout "elem_cnt: "elem_cnt

" ootus: " suurus endl;

Esmapilgul loendab see programm elementide arvu täisarvude massiivi ia. Kuid sel juhul laieneb makro min() valesti, kuna suurendamisjärgset toimingut rakendatakse kursori argumendile iga asendamise korral kaks korda. Selle tulemusena prindib programm valedele arvutustele viitava rea:

elem_cnt: 5 ootus: 10

Funktsioonimallid pakuvad mehhanismi, mille abil saame säilitada funktsioonide definitsioonide ja väljakutsete semantika (kapseldades koodilõigu ühte kohta programmis ja tagades, et argumente hinnatakse üks kord), ohverdamata C++ keele tugevat tippimist, nagu on makrode puhul.

Mall annab kasutatud algoritmi automaatne genereerimine funktsiooni eksemplarid koos erinevad tüübid. Programmeerija määrab funktsiooni liideses parameetrid kõik või ainult mõned tüübid (st formaalse parameetri ja tagastusväärtuse tüübid), jättes selle keha muutmata. Funktsioon sobib hästi malliks, kui selle rakendamine jääb muutumatuks teatud eksemplaride hulgas, mis erinevad andmetüüpide poolest, nagu näiteks min() puhul.

Funktsiooni min() mall määratletakse järgmiselt:

malli klassi tüüp

Tüüp min2 (tüüp a, tüüp b) (

tagastab a b ? a: b;

// õige: min(int, int);

// õige: min(double, double);

min(10,0, 20,0);

Kui eelprotsessori asemel on tekstis asendatud makro min(). eelmine programm see muster, siis on tulemus õige:

elem_cnt: 10 ootus: 10

(IN standardne raamatukogu C++-l on funktsioonimallid paljudele sagedamini kasutatavatele algoritmidele, näiteks min(). Neid algoritme kirjeldatakse peatükis 12. Ja selles sissejuhatavas peatükis esitame mõnede standardteegi algoritmide lihtsustatud versioonid.)

Nii funktsioonimalli deklareerimine kui ka määratlus peavad alati algama märksõna malliga, millele järgneb komadega eraldatud identifikaatorite loend, mis on ümbritsetud nurksulgudega " ja ", malli parameetrite loend, mis ei tohi olla tühi. Mallil võivad olla tüübiparameetrid, mis tähistavad tüüpi, ja konstantsed parameetrid, mis esindavad fikseeritud konstantset avaldist.

Tüübiparameeter koosneb klassi märksõnast või tüübinime märksõnast, millele järgneb identifikaator. Need sõnad näitavad alati, et järgmine nimi viitab sisseehitatud või kasutaja määratud tüübile. Malli parameetri nime valib programmeerija. Ülaltoodud näites kasutasime nime Tüüp, kuid oleksime võinud valida midagi muud:

malli klass Glorp

Glorp min2(Glorp a, Glorp b) (

tagastab a b ? a: b;

Malli instantimisel (konkreetse eksemplari loomisel) asendatakse tüübiparameetriga tegelik sisseehitatud või kasutaja määratud tüüp. Iga tüüp int, double, char*, vectorint või listdouble on kehtiv malliargument.

Konstantne parameeter näeb välja nagu tavaline deklaratsioon. See ütleb, et parameetri nime asemel tuleks asendada malli definitsiooni konstantne väärtus. Näiteks suurus on konstantne parameeter, mis tähistab massiivi arr suurust:

malli klass Tüüp, int suurus

Tüüp min(Tüüp (arr) );

Malli parameetrite loendi järel on funktsiooni deklaratsioon või definitsioon. Kui te ei pööra tähelepanu parameetrite olemasolule tüübispetsifikaatide või konstantide kujul, näeb funktsioonimalli definitsioon välja täpselt sama, mis tavaliste funktsioonide puhul:

malli klass Tüüp, int suurus

/* parameetritega funktsioon otsimiseks

* minimaalne väärtus massiivis */

Tüüp min_val = r_massiiv;

jaoks (int i = 1; i suurus; ++i)

if (r_massiiv[i] min_val)

min_val = r_massiiv[i];

Selles näites määrab tüüp Tüüp funktsiooni min() poolt tagastatava väärtuse tüübi, parameetri r_array tüübi ja kohaliku muutuja min_val tüübi; suurus määrab massiivi r_array suuruse. Programmi töötamise ajal funktsiooni min() kasutamisel mis tahes sisseehitatud ja kasutaja määratletud tüübid ja suuruse asemel - teatud konstantsed avaldised. (Tuletame meelde, et funktsiooniga saab töötada kahel viisil: helistada sellele või võtta selle aadress).

Parameetrite tüüpide ja väärtuste asendamise protsessi nimetatakse malli leidmiseks. (Räägime sellest üksikasjalikumalt järgmises jaotises.)

Funktsiooni min() parameetrite loend võib tunduda väga lühike. Nagu on kirjeldatud jaotises 7.3, kui parameeter on massiiv, edastatakse osuti selle esimesele elemendile, kuid tegeliku massiivi argumendi esimene mõõde funktsiooni määratluses on teadmata. Sellest raskusest ülesaamiseks deklareerisime esimese parameetri väärtuseks min() massiivi viitena ja teise selle suuruseks. Selle lähenemisviisi puuduseks on see, et malli kasutamisel koos massiividega sama tippige int, Aga erinevad suurused genereeritakse (või instantseeritakse) funktsiooni min() erinevad eksemplarid.

Parameetri nime on lubatud kasutada malli deklaratsioonis või definitsioonis. Tüübi parameeter toimib tüübi spetsifikaatorina; seda saab kasutada nagu iga sisseehitatud või kohandatud tüüp, näiteks muutujate deklaratsioonides või tüüpide valamisoperatsioonides. Konstantse väärtusena kasutatakse konstantset parameetrit – kus on vaja konstantseid avaldisi, näiteks massiivi deklaratsioonis suuruse määramiseks või loenduselemendi algväärtusena.

// suurus määrab massiivi parameetri suuruse ja lähtestab

// tüüpi muutuja const int

malli klass Tüüp, int suurus

Tüüp min(konst Tüüp (r_massiiv))

const int loc_size = suurus;

Sisestage loc_array;

Kui malliparameetriga sama nimega objekt, funktsioon või tüüp on deklareeritud globaalses ulatuses, siis globaalne nimi osutub peidetuks. Järgmises näites ei ole tmp muutuja tüüp topelt, vaid sama mis parameetri Type template tüüp:

typedef double Tüüp;

malli klassi tüüp

Tüüp min (tüüp a, tüüp b)

// tmp on sama tüüpi, mis malli parameetril Tüüp, mitte antud

// globaalne typedef

Tüüp tm = a b ? a: b;

Funktsioonimalli definitsioonis deklareeritud objektil või tüübil ei tohi olla sama nime kui ühelgi parameetril:

malli klassi tüüp

Tüüp min (tüüp a, tüüp b)

// viga: nime korduv deklaratsioon Nimele vastav tüüp

// malli parameeter

typedef double Tüüp;

Tüüp tmp = a b ? a: b;

Tagastustüübi määramiseks saab kasutada malli tüübi parameetri nime:

// õige: T1 tähistab väärtuse tüüpi, mille tagastab min(),

// ning T2 ja T3 on selle funktsiooni tüübiparameetrid

malli klass T1, klass T2, klass T3

Ühes parameetrite loendis on teatud nime lubatud kasutada ainult üks kord. Näiteks järgmine definitsioon märgitakse kompileerimisveaks:

// viga: vale taaskasuta parameetri nimi Tüüp

malli klass Tüüp, klass Tüüp

Tüüp min(tüüp, tüüp);

Samas võib malli deklaratsioonis või definitsioonis sama nime kasutada mitu korda:

// õige: tüübi nime uuesti kasutamine malli sees

malli klassi tüüp

Tüüp min(tüüp, tüüp);

malli klassi tüüp

Tüüp max(tüüp, tüüp);

Parameetrite nimed deklaratsioonis ja definitsioonis ei pea ühtima. Seega viitavad kõik kolm min() deklaratsiooni samale funktsioonimallile:

// kõik kolm min() deklaratsiooni viitavad samale funktsioonimallile

// mallideklaratsioonid edasi

malli klass T T min(T, T);

malli klass U U min(U, U);

// tegelik malli definitsioon

malli klassi tüüp

Tüüp min (tüüp a, tüüp b) ( /* ... */ )

Sama malliparameetri kuvamiskordade arv funktsiooni parameetrite loendis on piiramatu. Järgmises näites kasutatakse sõna Tüüp kahe esindamiseks erinevad parameetrid:

// õige: Tüüpi kasutatakse malli parameetrite loendis korduvalt

malli klassi tüüp

Tüüp summa(konst vektortüüp , tüüp);

Kui funktsioonimallil on mitu tüübiparameetrit, peab igale neist eelnema märksõna klassi või tüübi nimi:

// õige: tüübinime ja klassi märksõnu saab vahele panna

malli tüübinimi T, klass U

// viga: peab olema tüübinimi T, klass U või

// tüübinimi T, tüübinimi U

malli tüübinimi T, U

Funktsioonimalli parameetrite loendis on märksõnadel tüübinimi ja klass sama tähendus ja seetõttu on need omavahel asendatavad. Mõlemat neist saab kasutada erinevate mallitüüpide parameetrite deklareerimiseks samas loendis (nagu on näidatud funktsiooni miinus() malliga). Tüübi parameetri tähistamiseks tundub esmapilgul loomulikum kasutada märksõna tüübinimi, mitte klass, sest see näitab selgelt, et sellele järgneb tüübinimi. Kuid see sõna lisati keelde alles hiljuti C++ standardi osana, nii et tõenäoliselt näete sõna klassi vanemates programmides. (Rääkimata sellest, et klass on lühem kui tüübinimi ja inimesed on loomult laisad.)

Tüübinime märksõna muudab mallide definitsioonide sõelumise lihtsamaks. (Põhidalt peatume sellel, miks seda vaja oli. Neil, kes soovivad selle kohta rohkem teada saada, soovitame tutvuda Stroustrupi raamatuga “Design and Evolution of C++”.)

Sel viisil sõelumisel peab kompilaator eristama avaldisi, mis on tüüpilised, mittetüüpilistest avaldistest; seda ei ole alati võimalik tuvastada. Näiteks kui kompilaator kohtab malli definitsioonis avaldist Parm::name ja kui Parm on tüübiparameeter, mis esindab klassi, kas siis peaks eeldama, et nimi esindab klassi Parm tüübiliiget?

malli klass Parm, klass U

Parm::nimi * p; // kas see on osuti deklaratsioon või korrutamine?

// Tegelikult korrutamine

Kompilaator ei tea, kas nimi on tüüp, sest Parmi esindatava klassi definitsioon pole saadaval enne, kui mall on instantseeritud. Sellise malli definitsiooni sõelumiseks peab kasutaja ütlema kompilaatorile, millised avaldised sisaldavad tüüpe. Seda tehakse tüübinime märksõna abil. Näiteks kui tahame, et funktsiooni miinus() mallis avaldis Parm::nimi oleks tüübi nimi ja seetõttu käsitletaks kogu rida osuti deklaratsioonina, siis peame teksti muutma järgmiselt:

malli klass Parm, klass U

Parm miinus (Parm* massiiv, U väärtus)

tüübinimi Parm::nimi * p; // nüüd on see osuti deklaratsioon

Tüübinime märksõna kasutatakse ka malli parameetrite loendis, et näidata, et parameeter on tüüp.

Funktsiooni malli saab deklareerida siseseks või väliseks – täpselt nagu regulaarne funktsioon. Täpsustaja paigutatakse parameetriloendi järele, mitte sõna malli ette.

// õige: täpsustaja parameetrite loendi järel

malli tüübinimi Tüüp

Tüüp min(tüüp, tüüp);

// viga: tekstisisene täpsustaja pole paigas

malli tüübinimi Tüüp

Tüüp min(ArrayType, int);

Harjutus 10.1

Tehke kindlaks, milline neist funktsioonimallide määratlustest on vale. Paranda vead.

a) malli klass T, U, klass V

tühi foo (T, U, V);

b) malli klass T

c) malli klass T1, tüübinimi T2, klass T3

d) tekstisisese malli tüübinimi T

T foo(T, unsigned int*);

(e) malli klass myT, klass myT

void foo(myT, myT);

f) malli klass T

g) typedef char Ctype;

malli klassi tüüp

Ctüüp ​​foo(Ctüüp ​​a, Ctüüp ​​b);

Harjutus 10.2

Millised korduvad mallideklaratsioonid on valed? Miks?

a) malli klassi tüüp

Tüübiriba (tüüp, tüüp);

malli klassi tüüp

Tüübiriba (tüüp, tüüp);

b) malli klass T1, klass T2

tühi riba (T1, T2);

malli tüübinimi C1, tüübinimi C2

tühimik (C1, C2);

Harjutus 10.3

Kirjutage mallina ümber funktsioon putValues() jaotisest 7.3.3. Parameetristage see nii, et mallis oleks kaks parameetrit (massiivi elementide tüübi ja massiivi suuruse jaoks) ja üks funktsiooni parameeter, mis viitab massiivile. Kirjutage funktsioonimalli definitsioon.