Why is it possible to use an object as a counter?

You are not using the object as a counter but the de-reference of the object. $self is the object but it's also a reference to a scalar (since that's how you have constructed it). When you de-reference the object therefore you get a scalar and so $$self++ is incrementing the scalar. Since the example you mentioned starts with $active = 0, that's the value from which you will be incrementing.

You are not using the object as a counter but the de-reference of the object

The OP --not you-- has the correct terminology. The thing referenced is the object --the thing that is blessed-- not the reference.

The code in question does indeed increment the object, which is unusually a scalar instead of a hash.

Thanks to point me to the usage of $active in the constructor! By passing it as a reference, it is the scalar I access while dereferencing $self.
Now, as understand whats going on, I will try to use this approach in my implementation, and see wether there will be a notable performance improvement. :-)

Most languages implement objects as "blessed" hashes, and that's also the overwhelming case in Perl.

But in Perl you are free to use any reference as a container for the state of the instance.

And that's what is happening here, you have a blessed scalar (ref)

See bless ...

update

... and perlobj#An-Object-is-Simply-a-Data-Structure

> Objects are merely Perl data structures (hashes, arrays, scalars, filehandles, etc.) that have been explicitly associated with a particular class.

> That explicit association is created by the built-in bless function, which is typically used within the constructor subroutine of the class.

This is a blessed scalar. Something like this:

sub new {
    my ($class, $initial_int) = @_;;
    my $scalar = 0+($initial_int // 0);
    return bless \$scalar, $class;
}
[download]

A more typical constructor would bless a hashref:

sub new {
    my ($class, $args) = @_;
    die "Constructor args must be passed as a hash reference.\n"
        if defined($args) && ref($args) ne 'HASH';
    $args //= {};
    return bless $args, $class;
}
[download]

(Neither of these have a sufficient level of error checking on their input paramaters, and are intended as a demonstration only.)

But we'll look at the blessed scalar reference, as it's what is probably at play here. The last piece is this:

my $o = Foo->new(0);
${$o}++; # dereference $o, then increment the value of the scalar that
+ the scalar reference in $o points to.

# Because the dereferencing sigil binds more closely than the postincr
+ement operator, you can also do this:
$$o++; # dereference $o, then increment the value of the scalar that t
+he scalar reference in $o points to.
[download]

sub add_handle($$)
{
    ...
}
[download]

If this function definition is intended to be a class method (as seems to be the case), then be aware that prototype checking is completely disabled by method invocation with the  -> (arrow; see perlop) operator. Using prototypes in such a case will only serve to confuse you and others. See Prototypes and Far More than Everything You've Ever Wanted to Know about Prototypes in Perl -- by Tom Christiansen.