发信人: saka.bbs@bbs.neu.edu.cn (机器猫), 信区: cnlinux
标  题: perl(13)
发信站: 白山黑水BBS (Wed Apr  2 17:34:18 1997)
转信站: Lilac!ustcnews!ustcnews!sjtunews!neubbs
出  处: conger.neu.edu.cn

--------------330A5E66156D
Content-Type: text/plain; charset=us-ascii; name="perllol.txt"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline; filename="perllol.txt"

NAME

perlLoL - Manipulating Lists of Lists in Perl

---------------------------------------------------------------------------

DESCRIPTION

---------------------------------------------------------------------------

Declaration and Access of Lists of Lists

The simplest thing to build is a list of lists (sometimes called an array
of arrays). It's reasonably easy to understand, and almost everything that
applies here will also be applicable later on with the fancier data
structures.

A list of lists, or an array of an array if you would, is just a regular
old array @LoL that you can get at with two subscripts, like $LoL[3][2].
Here's a declaration of the array:

    # assign to our array a list of list references
    @LoL = (
           [ "fred", "barney" ],
           [ "george", "jane", "elroy" ],
           [ "homer", "marge", "bart" ],
    );
    print $LoL[2][2];
  bart

Now you should be very careful that the outer bracket type is a round one,
that is, parentheses. That's because you're assigning to an @list, so you
need parens. If you wanted there not to be an @LoL, but rather just a
reference to it, you could do something more like this:

    # assign a reference to list of list references
    $ref_to_LoL = [
        [ "fred", "barney", "pebbles", "bambam", "dino", ],
        [ "homer", "bart", "marge", "maggie", ],
        [ "george", "jane", "alroy", "judy", ],
    ];
    print $ref_to_LoL->[2][2];

Notice that the outer bracket type has changed, and so our access syntax
has also changed. That's because unlike C, in perl you can't freely
interchange arrays and references thereto. $ref_to_LoL is a reference to an
array, whereas @LoL is an array proper. Likewise, $LoL[2] is not an array,
but an array ref. So how come you can write these:

    $LoL[2][2]
    $ref_to_LoL->[2][2]

instead of having to write these:

    $LoL[2]->[2]
    $ref_to_LoL->[2]->[2]

Well, that's because the rule is that on adjacent brackets only (whether
square or curly), you are free to omit the pointer dereferencing array. But
you need not do so for the very first one if it's a scalar containing a
reference, which means that $ref_to_LoL always needs it.

---------------------------------------------------------------------------

Growing Your Own

That's all well and good for declaration of a fixed data structure, but
what if you wanted to add new elements on the fly, or build it up entirely
from scratch?

First, let's look at reading it in from a file. This is something like
adding a row at a time. We'll assume that there's a flat file in which each
line is a row and each word an element. If you're trying to develop an @LoL
list containing all these, here's the right way to do that:

    while (<>) {
        @tmp = split;
        push @LoL, [ @tmp ];
    }

You might also have loaded that from a function:

    for $i ( 1 .. 10 ) {
        $LoL[$i] = [ somefunc($i) ];
    }

Or you might have had a temporary variable sitting around with the list in
it.

    for $i ( 1 .. 10 ) {
        @tmp = somefunc($i);
        $LoL[$i] = [ @tmp ];
    }

It's very important that you make sure to use the [] list reference
constructor. That's because this will be very wrong:

    $LoL[$i] = @tmp;

You see, assigning a named list like that to a scalar just counts the
number of elements in @tmp, which probably isn't what you want.

If you are running under use strict , you'll have to add some declarations
to make it happy:

    use strict;
    my(@LoL, @tmp);
    while (<>) {

--------------330A5E66156D--

--
※ 来源:．白山黑水站 bbs.neu.edu.cn．[FROM: ygh@rose.dlut.edu.cn]