How to create a multidimensional array using references in Perl?

Creating multidimensional arrays in Perl is a common task that involves using references, as Perl’s native arrays are one-dimensional. Unlike some other languages with built-in multidimensional arrays, Perl uses references to build complex data structures like arrays of arrays.

What are References in Perl?

References are scalars ($-prefixed variables) that hold the address of another variable (such as an array, hash, or scalar). This lets you nest data structures—for example, an array holding references to other arrays.
The sigil for the variable hints at the data type it references:

• $arrayref - reference to an array
• $hashref - reference to a hash
• $scalarref - reference to a scalar

Why use References for Multidimensional Arrays?

Perl arrays are one-dimensional. To create a two-dimensional array (an array of arrays), you store references to arrays inside another array. This concept extends naturally to more dimensions.

Example: Create and Access a 2D Array Using References

use strict;
use warnings;

# Create a 2D array (array of array references)
my @matrix = (
    [1, 2, 3],   # First row is an anonymous array reference
    [4, 5, 6],   # Second row
    [7, 8, 9],   # Third row
);

# Access elements using -> and [ ]
print "Element at row 0, col 1: ", $matrix[0]->[1], "\n";  # prints 2
print "Element at row 2, col 0: ", $matrix[2]->[0], "\n";  # prints 7

# Modify an element
$matrix[1]->[2] = 42;

# Print the entire matrix
for my $row (@matrix) {
    print join(" ", @$row), "\n";
}

This script creates a 3x3 matrix by storing anonymous arrays inside the main array @matrix. Each row is an array reference. We access an element by first indexing the main array ($matrix[0]), which gives an array reference, then dereferencing it with ->[1].

Key Perl Concepts Illustrated

• Sigils: Scalar $ sigil for references; array @ for arrays. When accessing elements from a referenced array, you must use the scalar sigil ($) because you are working with a single scalar reference.
• Anonymous Arrays: Square brackets [] create an anonymous array reference.
• Dereferencing: Use -> to dereference array or hash references. Example: $arrayref->[index].
• Context: Inside join, @$row dereferences the entire array to a list context.

Common Pitfalls

• Forgetting to dereference the array reference when accessing nested elements will cause errors.
• Using the wrong sigil can result in unexpected behaviors; remember the sigil corresponds to the type of data you expect at that point.
• Using bare arrays inside arrays will flatten rather than create multidimensional structures, so anonymous arrays or references are needed.

Alternative: Using refs and Dynamic Creation

You can create a multidimensional array dynamically with references like this:

my @grid;
for my $i (0 .. 2) {
    for my $j (0 .. 2) {
        $grid[$i][$j] = $i * 3 + $j + 1;
    }
}

This works because Perl auto-vivifies the array references during assignment to $grid[$i][$j]. It’s a convenient form but under the hood, Perl is creating the array references automatically.

Summary

In Perl, multidimensional arrays are arrays of references. Use anonymous arrays ([]) to define rows, store them in a parent array, and access elements by dereferencing. Understanding sigils and dereferencing is key to handling complex structures confidently.