G'day Doctrin,

It sounds you want code like this which uses references:

$ perl -Mstrict -Mwarnings -E '
    my $r = 300;
    my $r_ref = \$r;
    my $g = "g";
    say $g . $$r_ref;
    $r = 500;
    say $g . $$r_ref;
'
g300
g500
[download]

See perlreftut (a short tutorial) and perlref (the details).

Don't do that :)(String::Defer) do

print $prefix, $suffix, "\n";
[download]

see String::Interpolate/ String::Interpolate::RE , String::Defer, Interpolation, Template,Text::Xslate... Re^2: Write to existing file with character insert, perlrequick

If this is part of a bigger question and you think some extra effort is worthwhile, then using closures is one way.

use strict;
use warnings;

sub stringmaker {
    my( $start, $stringref ) = @_;
    return sub { $start.$$stringref }
}

my $r = 300;
my $g = stringmaker( 'g', \$r );
print $g->()."\n"; #would be 'g300', that's ok
$r = 500;
print $g->()."\n"; #would be 'g500'
[download]

The disadvantage now is that $g is not a string, but a code reference, and that you need a different stringmaker-routine for different types of strings. The latter can be mitigated somewhat by using sprintf and a template:

use strict;
use warnings;

sub stringmaker {
    my( $template, @vals ) = @_;
    return sub { sprintf $template, map { $$_ } @vals }
}

my $r = 300;
my $i = 0;
my $g = stringmaker( '%s: g%s', \$i, \$r );
print $g->()."\n";  # '0: g300'
$r = 500; $i = 10;
print $g->()."\n";  # '10: g500'
[download]

One of the existing packages Anonymous Monk recommended is probably the way to go for any production code. However, if this is a learning exercise, you might start with something like the following:

#!/usr/bin/env perl

use 5.010;
use warnings;

my $suf = 42;
my $my_string = Sillystring->new('Prefix_', \$suf);
say $my_string;
$suf = 31;
say $my_string;

package Sillystring;
use Carp;

use overload 
    '""' => sub { my $self = shift; $self->{prefix} . ${$self->{suffix
+}} };

sub new {
    my ($class, $prefix, $suffix) = @_;
    croak "Suffix must be a SCALAR ref" unless ref($suffix) eq 'SCALAR
+';
    bless { 
        prefix => $prefix,
        suffix => $suffix,
    }, $class;
}

1;
[download]

This will do what you want, although it's pretty terrible OO design, and not all string operations are supported. Concatenation, for instance, will actually replace the object with an unblessed ordinary string. This could be avoided by overloading the concatenation operator.

If efficiency is a concern, realize that any such implementation is going to be far slower than ordinary scalars, but there's not much you can do about that except benchmark.

$ perl -e'
my $g = "g300";
my $r = \substr $g, 1;
print "$g\n";                             
$$r = 500;
print "$g\n";                                    
'
g300
g500
[download]