Perl (27) - Prototypy

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 18587×

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.

Jednoduché prototypy

V tabulce jsou znaky, jimiž lze určit prototyp.

ZnakVý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ávání odkazů a další vlastnosti

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(\[$@]);

Pojmenované argumenty

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.

Online verze článku: http://www.linuxsoft.cz/article.php?id_article=1102