嵌套数据结构及引用

beyes

可以利用指向匿名数据结构的指针形成对更复杂的数据结构进行访问。比如，散列中嵌套散列，散列中嵌套数组，数组中嵌套散列等等。

下面的示例代码演示了这些情况。

1. 列表的列表
列表中可以含有其他列表或列表的集合，该模式可以用来创建多为数组。如下面代码所示：
[code=perl]#!/usr/bin/perl

#匿名数组中还嵌套有一个匿名数组
my $arrays = [ '1', '2', '3', [ 'red', 'blue', 'green' ]];

#打印第一层数组中前 3 个元素
for ($i = 0; $i < 3; $i++) {
        print $arrays->[$i], "\n";
}

#打印里层数组中的各个元素
for ($i = 0; $i < 3; $i++) {
        print $arrays->[3]->[$i], "\n";
}
#打印整个外层数组,遇到里层数组时，打印的是其地址
print "@{$arrays}\n";

#打印里层数组的各个元素
print "--@{$arrays->[3]}--", "\n";[/mw_shl_code]
运行输出：

$ ./comstruct.pl
1
2
3
red
blue
green
1 2 3 ARRAY(0x9393830)

1.1 多维数组
[code=perl]#!/usr/bin/perl

#构造一个多维数组
my $matrix = [
                [0, 2, 4],
                [4, 1, 32],
                [12, 15, 17]
             ];
#打印第3行第2列的元素
print "Row 3 column 2 is $matrix->[2]->[1].\n";

print "Deferencing with two loops.\n";

#使用两层循环遍历整个二维数组
for ($x = 0; $x < 3; $x++) {
        for ($y = 0; $y < 3; $y++) {
                print "$matrix->[$x]->[$y] ";
        }
        print "\n\n";
}
print "\n";

#每一次迭代打印一个一维数组
print "Dereferencing with one loop.\n";
for ($i = 0; $i < 3; $i++) {
        print "@{$matrix->[$i]} ", "\n\n";
}
#$p 是指针的指针,指向$matrix
$p = \$matrix;

print "Dereferencing a reference to reference.\n";
print ${$p}->[1][2], "\n";[/mw_shl_code]
运行输出：

$ ./comstruct2.pl
Row 3 column 2 is 15.
Deferencing with two loops.
0 2 4

4 1 32

12 15 17


Dereferencing with one loop.
0 2 4

4 1 32

12 15 17

Dereferencing a reference to reference.
32

2. 数组中的散列表
在数组中可以有一个或一组散列：
[code=perl]

#!/usr/bin/perl

#构造一个数组,该数组中含有2个散列表
my $petref = [
                { "name"   => "Rover",
                  "type"   => "dog",
                  "owner"  => "Mr. Jones",
                },

                { "name"   => "Sysgaga",
                  "type"   => "cat",
                  "owner"  => "Mrs.Black",
                }
             ];
#打印第一个散列表中的name键的值
print "The first pet's name is $petref->[0]->{name}.\n";

print "Printing an array of hashes.\n";
#for循环遍历了整个数组,each函数取得了每个散列表中的键值对
for ($i = 0; $i < 2; $i++) {
        while (($key, $value) = each %{$petref->[$i]}) {
                print "$key -- $value\n";
        }
        print "\n";
}

print "Adding a hash to the array.\n";

#push函数为数组增加了一个散列表元素
push @{$petref}, { "owner" => "Mrs.Crow", "name" => "Tweety", "type" => "bird" };

while (($key, $value) = each %{$petref->[2]}) {
        print "$key -- $value\n";
}[/mw_shl_code]
运行输出：

$ ./comstruct3.pl
The first pet's name is Rover.
Printing an array of hashes.
owner -- Mr. Jones
name -- Rover
type -- dog

owner -- Mrs.Black
name -- Sysgaga
type -- cat

Adding a hash to the array.
owner -- Mrs.Crow
name -- Tweety
type -- bird

3. 在散列中嵌套散列
散列表里也可以含有一个或多个散列：
[code=perl]#!/usr/bin/perl

#构造一个散列表,它含有两个键,每个键的值又是一个散列表
my $hashref = {
        Math    => {
                        "Anna"  => 100,
                        "Hao"   => 95,
                        "Ritta" => 85,
                  },
        Science => {
                        "Sam"   => 78,
                        "Low"   => 100,
                        "vivi"  => 98,
                  },
};
#打印Math键的值的第一个键的值
print "Anna got $hashref->{'Math'}->{'Anna'} on the Math test.\n";

#改变值并打印
$hashref->{'Science'}->{'Lou'} = 90;
print "Low's grade was changed to $hashref->{'Science'}->{'Low'}.\n";

print "The nested hash of Mathh students and grades is: ";

#将Math键值整个打印(也是个散列表)
print join(" ", %{$hashref->{'Math'}}), "\n";

#foreach循环使用 keys 函数迭代获得外层散列表的键
foreach $key (keys %{$hashref}) {
        print "Outer key: $key \n";
        while (($nkey, $nvalue) = each(%{$hashref->{$key}})) {
                printf "\tInner key: %-5s -- Value: %-8s\n", $nkey, $nvalue;
        }
}[/mw_shl_code]
运行输出：

$ ./comstruct4.pl
Anna got 100 on the Math test.
Low's grade was changed to 100.
The nested hash of Mathh students and grades is: Hao 95 Anna 100 Ritta 85
Outer key: Science
        Inner key: Lou   -- Value: 90
        Inner key: Low   -- Value: 100
        Inner key: vivi  -- Value: 98
        Inner key: Sam   -- Value: 78
Outer key: Math
        Inner key: Hao   -- Value: 95
        Inner key: Anna  -- Value: 100
        Inner key: Ritta -- Value: 85

3.1 将列表嵌套在散列的散列中
散列可以含有嵌套的散列键，并将这些键和一组列表值相关联：
[code=perl]#!/usr/bin/perl

#构造一个散列表,其键的值为一个散列,且该散列的值为一个列表
my $hashptr = {
                "Teacher"   => {
                                 "Subjects"  => [ qw($cience Math English) ]
                               },
                "Musician"  => {
                                 "Instruments"  => [ qw(piano flute harp) ]
                               },
};

print $hashptr -> {"Teacher"}->{"Subjects"}->[0], "\n";

print "@{$hashptr->{'Musician'}->{'Instruments'}}\n";[/mw_shl_code]
运行输出：

]$ ./comstruct5.pl
$cience
piano flute harp