Limba C ++ vă permite să atribuiți valorile implicite parametrilor funcțiilor atunci când parametrii nu sunt specificați atunci când este apelată funcția. Valorile implicite sunt setate într-un mod sintactic similar cu inițializarea variabilelor. De exemplu, mai jos este o funcție f (), care are un argument variabil întreg, a cărui valoare implicită este 1:
Acum funcția f () poate fi apelată în două moduri, după cum se arată mai jos:
f (10); // transferul explicit al valorii
f (); // funcția folosește valoarea implicită
În primul caz, valoarea lui i va fi setată la 10. În al doilea caz, voi obține o valoare implicită de 1.
Argumentele implicite în C ++ permit programatorului să scrie un cod mai simplu. Pentru a acoperi multe situații, adesea o funcție conține mai mulți parametri decât este necesar pentru utilizarea cea mai tipică. Folosind argumentele implicite, puteți specifica numai argumente care diferă de valorile implicite în fiecare situație specifică.
Pentru a înțelege mai bine motivele pentru utilizarea argumentelor implicite, luați în considerare următorul exemplu practic. Acesta conține următoarea funcție utilă xyout ():
// tipărește o linie în poziția X, Y
void xyout (char * str, int x = 0, int y = 0)
dacă (! x) x = undex ();
dacă (y y) y = undey ();
gotoxy (x, y);
cout <
Această funcție afișează șirul indicat de variabila str și acest șir este plasat pe ecran în coordonatele x și y. Cu toate acestea, dacă nu este specificată niciuna dintre coordonatele x sau y, linia este afișată la locația ecranului, care corespunde valorilor y actuale. (Vă puteți imagina această funcție ca o versiune îmbunătățită a funcției puts ()). Funcțiile wherex (), wherey () și gotoxy () sunt funcțiile bibliotecii lui Borland C ++. Funcțiile wherex () și wherey () returnează valorile curente ale coordonatelor x și y. Aceste coordonate actuale determină unde vor fi transmise datele. Funcția gotoxy () deplasează cursorul într-un punct cu coordonatele x și y date.
Următorul program scurt demonstrează utilizarea funcției xyout ().
#include
#include
void xyout (char * str, int x = 0, int y = 0)
dacă (! x) x = undex ();
dacă (y y) y = undey ();
gotoxy (x, y);
cout <
int main ()
xyout ("salut", 10, 10);
xyout ("acolo");
xyout ("Îmi place C ++", 40); // încă pe a zecea linie
xyout ("Aceasta este pe linia 11. \ n", 1, 11);
xyout ("Aceasta urmează pe linia 12. \ n");
xyout ("Aceasta urmează linia 13.");
retur 0;
>
Uită-te atent la apelarea funcției xyout () din funcția principal (). Acest program afișează datele după cum se arată mai jos. După cum arată acest program, deși uneori este util să specificați exact unde să afișați datele, puteți adesea pur și simplu să continuați să ieșiți din punctul în care s-a încheiat ieșirea porțiunii de date anterioare. Utilizarea argumentelor implicite vă permite să utilizați aceeași funcție în ambele cazuri, astfel încât nu este nevoie de două funcții separate.
Exemplu de ieșire a funcției xyout ()
salut acolo imi place C ++
E pe linia 11.
Aceasta urmează pe linia 12.
Aceasta urmează pe linia 13.
Rețineți că funcțiile principale () și xyout () sunt apelate cu trei, două sau unu argumente. În cazul unui apel cu un argument, valorile lui x și y sunt setate în mod implicit. Atunci când este apelat cu două argumente, y este setat implicit. Cu toate acestea, nu este posibil să apelați funcția xyout () cu valoarea implicită x și valoarea y specificată atunci când este apelată funcția. În cazul general, când se numește o funcție, argumentele acesteia sunt combinate cu parametrii corespunzători de la stânga la dreapta. După ce toate argumentele folosite pentru a apela funcția sunt puse în corespondență cu parametrii, argumentele rămase sunt atribuite valorile lor implicite.
Atunci când se creează o funcție cu argumente implicite, valorile lor trebuie specificate o singură dată și chiar în momentul în care funcția este declarată pentru prima dată în fișier. De exemplu, dacă funcția xyout () este definită după funcția principal (), atunci argumentele implicite
trebuie să fie declarată în prototipul funcției xyout (), dar aceste valori nu trebuie să se mai repete la definirea funcției xyout (). Următorul program ilustrează ceea ce sa spus:
#include
#include
void xyout (char * str, int x = 0, int y = 0)
int main ()
xyout ("salut", 10, 10);
xyout ("acolo");
xyout ("Îmi place C ++", 40); // încă pe a zecea linie
xyout ("Aceasta este pe linia 11. \ n", 1, 11);
xyout ("Aceasta urmează pe linia 12. \ n");
xyout ("Aceasta urmează linia 13.");
retur 0;
>
/ * Deoarece valorile implicite pentru x și y sunt deja definite în prototipul xyout (), acestea nu pot fi repetate aici * /
void xyout (char * str, int x, int y)
dacă (! x) x = undex ();
dacă (y y) y = undey ();
gotoxy (x, y);
cout <
Dacă încercați din nou să specificați aceleași valori implicite în definiția funcției xyout (), compilatorul va raporta o eroare și nu va continua să compileze programul.
Deși argumentele implicite nu pot fi suprascrise, atunci când funcția este supraîncărcată, fiecare versiune poate include noi valori implicite ale argumentului.
// este incorect!
void xyout (int x = 0, int y = 0, char * str)
Următoare este o încercare incorectă de a utiliza parametrul implicit:
// este incorect!
int (int, int j = 10, int k)
După ce au început parametrii impliciți, parametrii care nu au o valoare implicită nu pot apărea în listă.
De asemenea, puteți utiliza parametrii cu valori implicite în constructorul obiectului. De exemplu, aici este o nouă versiune a constructorului clasei de coadă:
/ * Constructor folosind valoarea implicită * /
coză :: coadă (int id = 0)
sloc = rloc = 0;
care = id;
cout <<"Queue " <
se creează două obiecte - a și b. Valoarea id pentru obiectul a este 0, iar pentru obiectul b este 2.
Articole similare
Trimiteți-le prietenilor: