I am using the standard instantiation process: creating an instance of the parent class and reblessing it as an instance of the subclass.

That sounds quite broken. Perl classes usually have a constructor that takes the class name from the caller, not the package name, and blesses a reference into that class. No reblessing needed:

#!/usr/bin/perl

use strict;
use warnings;

{
    package DemoA;

    sub new
    {
        my $class=shift;
        my $self=bless {},$class;
        return $self;
    }

    sub hello
    {
        my $self=shift;
        print $self->message(),"\n";
    }

    sub message
    {
        my $self=shift;
        return 'Hello World';
    }
};

{
    package DemoB;

    use parent -norequire => 'DemoA';

    sub message
    {
        my $self=shift;
        return 'Shalom';
    }
};

my $obja=DemoA->new();
$obja->hello(); # writes "Hello World"

my $objb=DemoB->new();
$objb->hello(); # writes "Shalom"
[download]

It is possible to use a modified constructor, using the SUPER notation:

sub new
{
    my $class=shift;
    my $self=$class->SUPER::new(@_);
    $self->{'x'}='y';
    return $self;
}
[download]

Still, no reblessing needed.

Alexander

I think what the OP really wants is what pattern afficionados call a "Factory Method". That factory method shouldn't (re)bless at all but dispatch to the appropriate constructor:

package FooParent;
use Carp 'croak';

sub new {
    # Return either a FooSpecial1 or FooSpecial2
    my( $class, %options )= @_;
    if( $options{ special } == 1 ) {
        return FooSpecial1->new( %options, special1_param => 'somethin
+g' );
    } elsif( $options{ special } == 2 ) {
        return FooSpecial2->new( %options, other_special_param => 'som
+ething else' );
    } else {
        croak "Unknown special '$options{special}' requested";
    };
};

package FooSpecial1;

package FooSpecial2;

package main;

my $frobnitz = FooParent->new();
[download]