# Recipe 11.6 Creating Arrays of Scalar References

#### 11.6.1 Problem

You want to create and manipulate an array of references to scalars. This arises when you pass variables by reference to a function so the function can change their values.

#### 11.6.2 Solution

To create an array, either backslash each scalar in the list to store in the array:

`@array_of_scalar_refs = ( \\$a, \\$b );`

or simply backslash the entire list, taking advantage of the backslash operator's distributive property:

`@array_of_scalar_refs = \( \$a, \$b );`

To get or set the value of an element of the list, use \${ ... }:

`\${ \$array_of_scalar_refs } = 12;         # \$b = 12`

#### 11.6.3 Discussion

In the following examples, @array is a simple array containing references to scalars (an array of references is not a reference to an array). To access the original data indirectly, braces are mandatory.

```(\$a, \$b, \$c, \$d) = (1 .. 4);        # initialize
@array =  (\\$a, \\$b, \\$c, \\$d);     # refs to each scalar
@array = \( \$a,  \$b,  \$c,  \$d);     # same thing!
@array = map { \my \$anon } 0 .. 3;  # allocate 4 anon scalar refs

\${ \$array } += 9;                # \$c now 12

\${ \$array[ \$#array ] } *= 5;        # \$d now 20
\${ \$array[-1] }        *= 5;        # same; \$d now 100

\$tmp   = \$array[-1];                # using temporary
\$\$tmp *= 5;                         # \$d now 500```

The two assignments to @array are equivalentthe backslash operator is distributive across a list. So preceding a list (including a slice or a function's return list, but not an array) with a backslash is the same as applying a backslash to everything in that list. The ensuing code changes the values of the variables whose references were stored in the array.

Here's how to deal with such an array without explicit indexing:

```use Math::Trig qw(pi);              # load the constant pi
foreach \$sref (@array) {            # prepare to change \$a,\$b,\$c,\$d
(\$\$sref **= 3) *= (4/3 * pi);   # replace with spherical volumes
}```

This code uses the formula for deriving the volume of a sphere: The \$sref loop index variable is each reference in @array, and \$\$sref is the number itself, that is, the original variables \$a, \$b, \$c, and \$d. Changing \$\$sref in the loop changes those variables as well. First we replace \$\$sref with its cube, then multiply the resulting value by 4/3p. This takes advantage of the fact that assignment in Perl returns an lvalue, letting you chain assignment operators together as we've done using the **= and *= assignment operators.

Actually, anonymous scalars are pretty useless, given that a scalar value fits in the same space as a scalar reference. That's why there's no explicit composer. Scalar references exist only to allow aliasingwhich can be done in other ways.

#### 11.6.4 See Also

The section on "Assignment Operators" in Chapter 3 of Programming Perl and in perlop(1); the section on "Other Tricks You Can Do with Hard References" in Chapter 8 of Programming Perl   Chapter 1. Strings  Chapter 2. Numbers  Chapter 3. Dates and Times  Chapter 4. Arrays  Chapter 5. Hashes  Chapter 6. Pattern Matching  Chapter 7. File Access  Chapter 8. File Contents  Chapter 9. Directories  Chapter 10. Subroutines  Chapter 11. References and Records  Introduction  Recipe 11.1 Taking References to Arrays  Recipe 11.2 Making Hashes of Arrays  Recipe 11.3 Taking References to Hashes  Recipe 11.4 Taking References to Functions  Recipe 11.5 Taking References to Scalars  Recipe 11.6 Creating Arrays of Scalar References  Recipe 11.7 Using Closures Instead of Objects  Recipe 11.8 Creating References to Methods  Recipe 11.9 Constructing Records  Recipe 11.10 Reading and Writing Hash Records to Text Files  Recipe 11.11 Printing Data Structures  Recipe 11.12 Copying Data Structures  Recipe 11.13 Storing Data Structures to Disk  Recipe 11.14 Transparently Persistent Data Structures  Recipe 11.15 Coping with Circular Data Structures Using Weak References  Recipe 11.16 Program: Outlines  Recipe 11.17 Program: Binary Trees  Chapter 12. Packages, Libraries, and Modules  Chapter 13. Classes, Objects, and Ties  Chapter 14. Database Access  Chapter 15. Interactivity  Chapter 16. Process Management and Communication  Chapter 17. Sockets  Chapter 18. Internet Services  Chapter 19. CGI Programming  Chapter 20. Web Automation  Chapter 21. mod_perl  Chapter 22. XML