You can use symbolic references if you switch off "strict refs":

for (1..3) {
    no strict 'refs';
    my $ref = \${'str'.$_}; # this creates a hard reference VIA a symb
+olic reference
    # or:  my $ref = "str$_";  # this is a purely symbolic reference, 
+access is the same as above
    print "The string is $$ref"; 
}
[download]

Note that in your example using a simple array would be much easier, less error-prone and more efficient. Symbolic references are almost only useful these days for creating subroutines / packages at runtime (basically, wherever the only alternative is to use eval STRING).

updated again, added some comments

huh. Thanks. I understand what you mean about the symbolic reference. I just was not seeing it that way. (hence, while I understood the error message, I thought my problem was in the syntax, when all along it was improper referencing.)

Thanks. And re your suggestion, I was going to go the route of an array -- but got hung up on why I couldn't make this work.

Thank you, I can now stop floundering and get back to being productive.

    # or:  my $ref = "str$_";  # this is a purely symbolic reference, 
+access is the same as above
[download]

I don't see how that is a symbolic reference? I think this is (had to think a while to come up with something contrived, here):

my $class = 'CGI';
my $version;
{
    no strict 'refs';
    $version = ${"${class}::VERSION"};
    use strict;
}
print $version # e.g. 3.05 on my machine
[download]

In other words, we construct a variable's name ($CGI::VERSION) out of expanded variables ($class), and expand (it's almost like a string eval()) the result in turn to return the value stored under the constructed variable's name.

...mmmm still not really put elegantly, sorry.

Symbolic references are just names of global variables. That means "str2" is a symolic reference, just like "CGI::VERSION" is.

In other words; "${class}::VERSION"; is a symbolic reference, and ${"${class}::VERSION"}; derefences the reference into the value of $CGI::VERSION. Note that "hard" references use exactly the same syntax to dereference.

"What should it profit a man, if he should win a flame war, yet lose his cool?"

Any time you find yourself wanting to create variables using a string as the name, you want a hash.

Except when you want an array...

I understand hard references wrt using a variable name as a variable. But, if I want to create the variable name on the fly, I can't seem to get the refernce right

...
{
 no stict 'refs';
 for (1..3) {
     my $ref = \${'str'.$_};
     print "The string is $$ref"; 
 }
}
...
[download]

He also needs to use globals, since you can't refer to lexicals via symbolic refs. As I posted above.
"What should it profit a man, if he should win a flame war, yet lose his cool?"

Rule 1: Every time you want to create a variable whose name is decided at runtime, you really want to use a hash;

Rule 2: If you think you know better, you are wrong;

Rule 3: No, really

Against rules 1-3, I always sorta thought of a pointer/reference to a hash object as basically a hash(with certain perks). There don't really seem to be void-ish references.
Perl creates a runtime error if you take
$hash = {}
and try to dereference it as an array or anything else(er well hashes and arrays are about it) such as
@$hash.
Perl seems to think a reference to a hash is still a hash but wants to protect the user a bit in terms of nasty memory issues.
Doing $hash->{ $key } basically acts just like a hash object with slightly different syntax. So $hash->{ 'runtime' . $key } seems like a normal progression.
D