# overloading operators

{
package box;

# Define which functions are to run when certain operators
# are called on am object of type box.

use overload
        '==' => "same",
        '*' => "pyle",
        '""' => formatter,
        '+' => "stackem";

# Constructor - nothing special here

sub new {
        my ($class,$x,$y,$z) = @_;
        my %info;
        $info{x} = $x;
        $info{y} = $y;
        $info{z} = $z;
        bless \%info,$class;
        }

# A method that will be used in the standard Perl way
# again, nothing special here

sub volume {
        my $self = shift;
        $$self{x} * $$self{y} * $$self{z};
        }

# The method that is to be used when the + operator is used
# Takes two objects as parameters and return a third new object

sub stackem {
        my $this = shift;
        my $that = shift;
                return new box(
                ($$this{x}>$$that{x}) ? $$this{x} : $$that{x},
                ($$this{y}>$$that{y}) ? $$this{y} : $$that{y},
                $$this{z} + $$that{z} );
        }

# The method that is to be used when the * operator is used
# Takes two parameters. This is set up so that a multiplication
# takes a box object as the left parameter, and a numeric value
# to the right

sub pyle {
        my ($this,$that) = @_;
                return new box(
                        $$this{x}, $$this{y}, $$this{z} * $that);
        }

# Equality testing. Does not need to check if things are identical.
# In this example, checks if the two objects have the same volume.

sub same {
        my ($this,$that) = @_;
                $va = $this->volume();
                $vb = $that->volume();
                $va == $vb;
        }

# What to do when printing out an object variables / expanding it
# within a double quoted string

sub formatter {
        my ($this) = @_;
                $$this{x} . " by " .
                $$this{y} . " by " .
                $$this{z} ;
        }
}

# Test program to demonstrate the above

$first = new box(10,20,15);
$second = new box(20,15,10);
$third = $first + $second;

# Note that * uses the class code above, but the + is in
# an integer context and does a simple, normal addtion:
$fourth = $first * (2 + 3);

print ($first->volume(),"\n");
print ($second->volume(),"\n");
print ($third->volume(),"\n");
print ($fourth->volume(),"\n");

if ($first == $second) {
        print "first and second same (in volume)\n";
} else {
        print "Different volumes - first and second\n";
}

if ($first == $third) {
        print "first and third same (in volume)\n";
} else {
        print "Different volumes - first and third\n";
}

print ("$first is an example\n");

__END__

How it runs:

munchkin:j11pl grahamellis$ perl pover
3000
3000
10000
15000
first and second same (in volume)
Different volumes - first and third
10 by 20 by 15 is an example
munchkin:j11pl grahamellis$