Pomocí prototypů lze kontrolovat datové typy proměnných vstupujících do podprogramu.
21.2.2006 06:00 | Jiří Václavík | přečteno 22525×
Téměř všechny smysluplné podprogramy přijímají nějaké argumenty, které jsou potom v podprogramu přístupné v podobě seznamu. Již z minulého dílu víme, jak argumenty přijímat. Nevíme však, jak si je i vynutit. Právě pomocí prototypů lze určit kolik jakých argumentů má podprogram vyžadovat.
Prototyp obsahuje posloupnost speciálních znaků, podle které se určuje, co za parametry bude podprogram požadovat. Je uveden vždy za názvem podprogramu v jeho deklaraci nebo definici v kulatých závorkách.
sub jméno(prototyp) {
příkazy
}
U podprogramů s prototypem je nutné, aby byla definice nebo deklarace před samotným voláním. V opačném případě nebude na prototyp brán zřetel.
V tabulce jsou znaky, jimiž lze určit prototyp.
| Znak | Význam |
| $ | skalár |
| @ | pole |
| % | hash |
| & | anonymní podprogram |
| * | typeglob |
Znak $ určuje, že bude očekávána hodnota ve skalárním kontextu. Skalární kontext je vynucen - tzn. při předání seznamu je vrácen počet jeho prvků. Pomocí * se dá předat typeglob, což se používá pro přijímání ovladačů. Prototyp pole a hashe spolkne vše až do konce seznamu argumentů.
Pokud definujeme funkci s prototypem $$$$$$, je očekáváno 6 skalárních argumentů. Prototyp $@ zase vyjadřuje skalár a pole v daném pořadí. Pozor na zápisy jako @@. Pole se slijí, protože 1. pole spolkne vše až do konce seznamu a na 2. pole žádné hodnoty nezbydou.
sub f($$$) {
print @_;
}
f(1, 2); #chyba, funkce f požaduje 3 skalární argumenty
f(1, 2, 3); #ok
f(1, 2, 3, 4, 5); #chyba, funkce f požaduje 3 skalární argumenty
Pokud spustíte tento úsek kódu, bude hlásit chyby. Prohoďme pořadí definice a volání funkcí tak, aby volání bylo před definicí.
f(1, 2); #zdánlivě ok
f(1, 2, 3); #ok
f(1, 2, 3, 4, 5); #zdánlivě ok
sub f($$$) {
print @_;
}
Žádné chyby nejsou hlášeny! Jakoby prototypy nebyly specifikovány. Pokud však budete spouštět program s přepínačem -w,
$ perl -w prototyp.pl
tedy zapnutými varováními, zobrazí se pro taková volání funkcí
main::f() called too early to check prototype
Znamená to, že argumenty nebyly zkotrolovány pomocí prototypu. Zabránit se tomu dá, jak již bylo řečeno, buď definicí podprogramů před jejich použitím, nebo dopřednou deklarací podprogramu.
Deklarace popisuje parametry podprogramu před jeho definicí.
sub podprogram;
Deklarace s prototypem pak vypadá následovně:
sub podprogram(prototyp);
Ukažme si, použití v praxi. K poslednímu úseku kódu, který hlásil varování, přidáme deklaraci.
sub f($$$);
f(1, 2); #chyba, funkce f požaduje 3 skalární argumenty
f(1, 2, 3); #ok
f(1, 2, 3, 4, 5); #chyba, funkce f požaduje 3 skalární argumenty
sub f($$$) {
print @_;
}
Teď už byl prototyp normálně aplikován. Jen pozor na to, aby nedošlo ke konfliktu prototypů. V deklaraci musí být stejný prototyp jako v definici.
Protože to, zda bude prototyp volán, záleží i na syntaxi volání podprogramu, rozlišíme si volání na 2 případy podle toho, zda bude prototyp aplikován. Tabulka obsahuje 4 možné zápisy volání:
| Zápis volání | Prototyp? |
| &podprogram(parametry); | není aplikován! |
| &podprogram; (jako &podprogram(@_);) | není aplikován! |
| podprogram(parametry); | ok |
| podprogram; (jako bez parametrů) | ok |
Jinak řečeno, je-li podprogram volán s ampérsandem, prototyp není nikdy aplikován.
Zde jsou další příklady využití prototypů:
sub f(@@); #nemá smysl - pole se slijí
sub f(); #funkce nepřijímá argumenty
sub f($@); #přijme skalár a pole
sub f(&$$$);#přijme anonymní podprogram a 3 skaláry
sub f(*); #přijme ovladač souboru
Zajímavá situace může nastat, pokud voláme funkci příkazem podobným následujícímu:
funkce +10;
Jak je vlastně takový příkaz interpretován? Jako funkce s argumentem 10 nebo jako součet návratové hodnoty funkce s hodnotou 10? Je-li definován prototyp, mělo by to být jasné. V případě prázdného prototypu se příkaz bere jako součet, jinak je číslo parametrem podprogramu.
Před symbolem, označujícím datový typ, může být znak \. To znamená, že podprogram přijímá datový typ, který označuje symbol, ale předává odkaz na něj. V samotném volání podprogramu pak nesmí být konstantní hodnota.
sub f(\@@); #1. pole bude převedeno na odkaz
sub f(\%@); #hash bude převeden na odkaz
sub f(\@\@\@);#pole budou převedena na odkazy
Na posledním řádku funkce přijímá jako parametr 3 pole, které jsou v podprogramu dostupné jako odkazy (skaláry) a neslijí se tak. Pak je možné volat podprogram klidně takto:
sub f(\@\@\@);
@a = (100, 200);
@b = (10, 20, 30);
@c = (1, 2, 3, 4, 5);
f(@a, @b, @c);
sub f(\@\@\@){
print "1. předané pole: ", @{$_[0]};
print "2. předané pole: ", @{$_[1]};
print "3. předané pole: ", @{$_[2]};
}
Nepovinné parametry se od povinných oddělují středníkem. Můžeme tak definovat podprogram, který bude přijímat právě 1 nebo 2 skalární hodnoty.
sub f($;$){print @_;}
f(10); # ok
f(10, 20); # ok
f(10, 20, 30); # chyba
Další možnost, kterou prototypy nabízejí, je specifikace více možných datových typů na tutéž pozici. Podprogram s touto deklarací přijme buď skalár nebo pole:
sub f(\[$@]);
V případech, kdy funkce přijímá velké množství argumentů, z nichž jsou navíc některé povinné a některé ne, je těžké udržet si v nich pořádek. Právě s tímto mohou pomoci pojmenované argumenty. Nejde syntakticky o nic nového, jen použijeme novou filozofii předávání argumentů.
Předáme-li funkci hash s pevně danou strukturou, vytváříme vlastní systém správy argumentů. Je pak už na nás, jak si je ošetříme a zpracujeme.
Argumenty se často uvozují znakem -. Uvedeme si jednoduchý příklad.
vypis_jmeno("-jmeno" => "Josef", "-prijmeni" => "Adamec");
sub vypis_jmeno(%){
my %args = @_;
print "Jméno: ", $args{"-jmeno"}, "\n";
print "Příjmení: ", $args{"-prijmeni"}, "\n";
}
Příští díl se bude zabývat rozsahy platnosti proměnných.