Perl je poměrně tolerantní vůči datovým typům operandů. Ale pouze do jisté míry. Lze sčítat čísla a řetězce, ale už ne objekty. Přetěžování je cestou, jak to vestavěné operátory naučit.

To je velmi užitečné pro snažší manipulaci s objektem. Představme si nějakou datovou strukturu, se kterou má smysl provádět nějakou operaci. Vezměme si jako příklad matice. Přetěžování nám zajistí, že dva objekty $a a $b typu Matice budeme sčítat příkazem $a + $b, tisknout pomocí print v přehledné tabulce nebo počítat determinant jako abs($a).

Potřeba je k tomu pragma overload a napsání několika podprogramů na obsloužení operátorů.

Syntaxe přetěžování

Pro aktivaci přetěžování je potřeba zavolat pragmu overload s příslušnými parametry. Ty jsou tvořeny dvojicemi v následujícím formátu.

Uveďme si konkrétní příklad použití pragmy overload. Význam operátorů si vysvětlíme později.

use overload
    "+"        => \&plus,
    "-"        => \&minus,
    "nomethod" => sub {die "To neumím."},
    "fallback" => 0;

Jakmile nyní použijeme nad objektem operátor, vyvolá se podprogram, jež tento operátor reprezentuje, a jako parametry mu budou předány operandy prováděné operace (v případě unárního operátoru je druhá hodnota v poli parametrů nedefinovaná) a dále jejich pořadí (pořadí je pravdivá hodnota pro opačné pořadí a nepravdivá pro zachované pořadí).

Postup hledání podprogramu pro operátor

Podívejme se, co se děje po požadavku na provedení operace nad objektem.

1. Pokud byl pomocí pragmy overload nastaven pro danou operaci jako ovladač nějaký podprogram, pak se zavolá právě ten.
2. Pokud jsme prováděné operaci žádný ovladač nepřiřadili, zkusí Perl tento ovladač na základě ostatních námi definovaných operací sám vymyslet. Tento krok lze vynechat pomocí fallback.
3. Jako další v pořadí Perl zkouší volat metodu nomethod.
4. Pokud neuspějeme ani napotřetí, dojde k chybě.

Speciální operátory fallback a nomethod

fallback určuje, jak se bude postupovat v případě, kdy nebyl nalezen ovladač pro danou operaci. To, že Perl v druhém kroku hledání vhodného podprogramu zkouší vymyslet ovladač sám, nemusí být v našem zájmu. Proto je možné takové chování zakázat a druhý krok vynechat. Podívejme se, jaké máme možnosti pro nastavení fallback.

Funkce nomethod je volána tehdy, když není definována ani odvozena požadovaná operace. nomethod dostává stejné parametry jako ostatní operátory a navíc také operátor ve tvaru řetězce.

Seznam operátorů s možností přetížení

Podívejme se, které všechny operátory můžeme přetížit. Všechny takové jsou v proměnné %overload::ops roztříděny přehledně do kategorií. Podívejme se tedy na její obsah.

%overload::ops = {
    '3way_comparison' => '<=> cmp',
    'dereferencing'   => '${} @{} %{} &{} *{}',
    'str_comparison'  => 'lt le gt ge eq ne',
    'with_assign'     => '+ - * / % ** << >> x .',
    'binary'          => '& | ^',
    'iterators'       => '<>',
    'unary'           => 'neg ! ~',
    'special'         => 'nomethod fallback =',
    'num_comparison'  => '< <= >  >= == !=',
    'assign'          => '+= -= *= /= %= **= <<= >>= x= .=',
    'mutators'        => '++ --',
    'func'            => 'atan2 cos sin exp abs log sqrt int',
    'conversion'      => 'bool "" 0+'
};

Nyní se podívejme na vybrané operátory, které Perl buď umí odvodit nebo které si žádají jiný komentář.

Přetěžování a dědičnost

Potomci dědí přetížené operace po svých předcích. Pravidla pro pořadí jsou stejná jako při volání metod.

Příklad - reprezentace vektorů

Uveďme si konkrétní příklad na přetěžování. Budeme mít objekt reprezentující vektor. Pro názornost to bude modul reprezentující pouze třídimenzionální vektory.

Budeme přetěžovat několik operací. Vytvoříme ovladače pro součet, rozdíl, skalární a vektorový součin, násobení skalárem, kopírování, tisk a normu vektoru.

Nejprve tedy uvedeme direktivu autoload s operacemi, které budeme chtít dodefinovat pro vektory.

package Vektor3D;
use overload
    '""'  => \&tisk,
    "-"   => \&minus,
    "+"   => \&plus,
    "="   => \&copy,
    "."   => \&skalarni_soucin,
    "x"   => \&vektorovy_soucin,
    "*"   => \&nasobek,
    "abs"   => \&absolutni_hodnota,
    "nomethod" => sub {die "Operaci ", $_[3], " neumím."};

Nyní budeme implementovat jednotlivé metody. Je třeba si uvědomit, že téměř každá z předcházejících metod bude zároveň konstruktorem. Musí tedy vracet objekt vytvořený pomocí bless.

Nejprve vytvoříme klasický konstruktor new. Objekt budeme reprezentovat polem.

sub new {
    my($pkg, $r_vektor) = @_;
    return bless $r_vektor, $pkg;
}

Nyní vytvoříme ovladač pro tisk. Chceme, aby se vektor tiskl ve formátu (x;y;z). Vrátíme tedy zformátovaný řetězec.

sub tisk {
     my($self) = @_;
     return sprintf("(%i;%i;%i)", $$self[0], $$self[1], $$self[2]);
} 

Násobení skalárem vytvoří z daného vektoru nový vektor, jehož složky budou vynásobeny skalární hodnotou. Protože výsledkem bude nový vektor, je třeba vrátit objekt. Ať je násobení zapsáno zleva nebo zprava, v podprogramu dostaneme jako první parametr vektor. Násobení skalárem je komutativní a nezajímá nás tedy třetí parametr, který udává pořadí.

sub nasobek {
     my($u, $n) = @_;
     return bless [$n*$$u[0], $n*$$u[1], $n*$$u[2]], ref $u;
}

Obdobně napíšeme také součet dvou vektorů.

sub plus {
    my($u, $v) = @_;
    return bless [$$u[0]+$$v[0], $$u[1]+$$v[1], $$u[2]+$$v[2]], ref $u;
}

Další metody fungují analogicky.

sub skalarni_soucin {
    my($u, $v) = @_;
    return bless [$$u[0]*$$v[0], $$u[1]*$$v[1], $$u[2]*$$v[2]], ref $u;
}

sub vektorovy_soucin {
    my($u, $v) = @_;
    return bless [$$u[1]*$$v[2]-$$u[2]*$$v[1], $$u[2]*$$v[0]-$$u[0]*$$v[2],
    $$u[0]*$$v[1]-$$u[1]*$$v[0]], ref $u;
}

sub copy {
    return bless $_[0], ref $_[0];
}

sub absolutni_hodnota {
    my($u) = @_;
    return sqrt($$u[0]**2 + $$u[1]**2 + $$u[2]**2);
}

Nyní máme k dispozici sadu operátorů pro manipulaci s vektory.

use Vektor3D;

my @p1 = (2,  3,  5);
my @p2 = (4,  8,  5);

$u = Vektor3D->new(\@p1);
$v = Vektor3D->new(\@p2);

my $w = $u + $v; #je vytvořen objekt $w = (6;9;10)
print $w;        #tiskne řetězec (6;9;10)

Všimněme si ještě automatického odvozování operátorů. Pro naše vektory lze využít i operaci +=, ač nebyla definována. Perl si ji totiž odvodil na základě naší definice operátoru +.

Přetěžování a konstanty

Pragma overload poskytuje také funkci constant, kterou využijeme k přetěžování konstant. To znamená možnost upravit jejich výstupní formát.

Podívejme se, které typy konstant je možné přetížit.

Opět budeme definovat nové metody, které ve výsledku upraví výsledný formát konstanty. Zde se to dělá uvnitř funkce import v modulu, kde chceme přetížení zavést. Opět daným typům konstant přiřadíme obslužné podprogramy.

package Pretizeni;
use overload;

sub import {
    overload::constant
        "float" => sub {...},
        "q"     => sub {...}
}

1;

Obslužné podprogramy dostanou jako parametry implicitně hodnotu konstanty, jak byla zapsána a hodnotu, jak ji zpracuje Perl. Pro konstanty typu q a qr se předává ještě 3. parametr a místo použití. Ten může nabývat těchto hodnot.

Jako příklad si napišme dvě metody. První bude zajišťovat, že u desetinných čísel se bude tisknout místo desetinné tečky desetinná čárka. Na druhé si ukážeme, jak a na kterých místech Perl zpracovává řetězce. Tento podprogram s řetězcem nic dělat nebude, ale na místech vyhodnocování vytiskne tento řetězec a typ použití. Uveďme si, jak tedy bude vypada funkce import.

sub import {
    overload::constant
        "float" => sub {
            $_ = shift;
            s/\./,/i;
            return $_;
        },
        "q" => sub {
            print "@_\n";
            return shift;
        }
};

Nyní můžeme modul použít a zkusit nějaký testovací program. V tom našem dojde celkem 4× ke zpracování řetězce.

use Pretizeni;
$x='bez expanze $x'."s expanzi $x";
$x=~tr/abcd/ABCD/;
print 1.59;

Pokud by někoho zajímaly další příklady, pak na perl.com vyšel hezký článek o reprezentaci zlomků. Řada dalších vlastností přetěžování je také v dokumentaci.