Home > Perl > Object Oriented Programming > Perl Packages - Part 3 (References)
Perl Packages - Part 3 (References)
Written by Philip L Yuson   

Who is this for
This is for those who want to have a brief overview of references.

What you should know
Basic Perl programming

In most high-level languages (ie. Visual Basic, COBOL - yes, this still exists), most variables are accessed through the variable name. In low-level languages (ie, C, C++, Assembler), you can access a variable indirectly, either through an address or reference. Perl allows you to do this through references.

References are values in a variable that references - or points - to a symbol. There are two types of references in Perl: symbolic and hard. This article is about hard references. We will not be discussing symbolic references because these are not used much.

Creating References
References are stored in scalar variable. You can refer to any type of variable, subroutine or value.

You create references by specifying a reverse backslash \ before the symbol being referenced:

Example 1

# Assign reference of $scalar to $ref
$ref = \$scalar;

# Assign reference of @array to $refArr
$refArr = \@array;

# Assign reference of
# element 0 of array @anotherarray
# to $array[1]
$array[1] = \$anotherarray[0];

# Assign reference of %hash to $refHash
$hash{'sample'} = 'This is a sample value';
$refHash = \%hash;

Since the array or hash elements are scalar, you can store references in them. You can in effect create an array of references or hash of references.

How does it work
Once you have referenced the symbol, you have to use it. Since the reference is stored to a scalar variable, the reference is treated as a scalar.

Example 2
You have two scripts:


Script 1

Script 2


$scalar = 1;

$scalar = 1;


$ref = $scalar;

$ref = \$scalar;




Notice that the two scripts are similar except for line 2. Line 2 of Script 1 assigns the value of the $scalar variable to $ref. Line 2 of Script 2 assigns the reference of the $scalar variable to $ref.

On execution of Script 1, the result is 2. On execution of Script 2, the result is not 2 because you are adding 1 to the reference instead of the value 1.

To use the value of the referenced symbol, you have to dereference it. To do this, you use the $ sign. The $ sign is preceeded by the symbol of the variable.

In Example 1


Do This




The first $ signifies that the dereferenced variable is a scalar.



The @ means that the resulting variable is an array.


$$refArr[3] or
the 'cleaner' way: $refArr->[3]

The first $ means that the resulting variable $array[3]is a scalar - even if the variable itself (@array) is an array. The -> means that $refArr is a reference.



The % means that the resulting variable is a hash.


$$refHash{'sample'} or
the 'cleaner' way: $refHash->{'sample'}

The first $ means that the resulting variable is a scalar. The -> sign means that $refHash is a reference.

What is being referenced
There will be times when you want to know what type of symbol is being referenced. You can find out by using the ref function.

Again, using Example 1 above:
ref($ref) produces SCALAR(0x9999999) where 9999999 is any valid hexadecimal number that Perl uses to refer to the variable.

ref($refArr) produces ARRAY(0x9999999)

Why will you use this
References are used specifically when you create packages or objects, to be exact. You can also use this to create multi-dimensional arrays.

This will be discussed further when we get to object-oriented programming.

Copyright: © 2018 Philip Yuson