The reason I say this is that the hash that $framearray->{$frameno}{$drawerno} refers to isnt %framearray, but rather an anonymous hash contained referenced by $framearray

So you have two solutions, change the offending call to $framearray{$frameno}{$drawerno}="foo"; _or_ change the %newhash=%framearray to be %newhash=%$framearray

But as I said this type of error would be instantly indentified by turning on strict.

my %hash;
$hash{foo}{bar}="baz";
my %new=%hash;
print $new{foo}{bar},"\n"; #prints baz

my $hashref;
$hashref->{foo}{bar}='ref';
my %new2=%$hashref;
print $new2{foo}{bar},"\n"; #prints baz
[download]

$new{foo}{baz}='new';
print $hash{foo}{baz},"\n"; #prints new
[download]

HTH

--- demerphq
my friends call me, usually because I'm late....

$framearray->{$frameno}{$drawerno} = $tempno;

Looks like $framearray is a hashref

$framearray{1}{5} = 23

Looks like %framearray is a hash

What do $framearray and %framearray have to do with each other? Nothing.

%newhash = %framearray

Copying HashesofHashes is not that easy, because they work with references, so they'll point to the same values. Have a look at the Storable module and 'dclone'

use Data::Dumper;

my %h1 = qw(foo 1 bar 1 baz 1);
my %h2 = %h1;

print Dumper(\%h2);

__output__

$VAR1 = {
          'foo' => '1',
          'bar' => '1',
          'baz' => '1'
        };
[download]

_________
broquaint

%newhash = %{$framearray};
[download]

my %framearray;
$framearray{$frameno}{$drawerno} = $tempno;
%newhash = %framearray;
[download]

$framearray{$frameno}->{$drawerno} = $tempno;
[download]

Secondly, your %newhash should not be empty after the copy operation, but be advised that it will contain references to the ORIGINAL second level hashes from the first assignment. Example:

use strict;

use Data::Dumper;

my %first;
$first{'foo'}{'bar'} = 1;
$first{'foo'}{'baz'} = 2;
$first{'bah'}{'oof'} = 3;

print "First hash:\n";
print Dumper \%first;

my %second = %first;
print "\nSecond hash\n";
print Dumper \%second;

print "\nFirst nested hash address: $first{'foo'}\n";
print "Second nexted hash address: $second{'foo'}\n";
[download]

output:

First hash:
$VAR1 = {
          'bah' => {
                     'oof' => 3
                   },
          'foo' => {
                     'baz' => 2,
                     'bar' => 1
                   }
        };

Second hash
$VAR1 = {
          'bah' => {
                     'oof' => 3
                   },
          'foo' => {
                     'baz' => 2,
                     'bar' => 1
                   }
        };

First nested hash address: HASH(0x804ee40)
Second nexted hash address: HASH(0x804ee40)
[download]

Thankyou all for your constructive replies. I can see my obvious mistake that the copy of one hash to another is fundamentally flawed in my code and has been pointed out, i'm using numeric values for both keys and values, so I will rewrite the code using arrays.

Again, thanks for the advice.

Cheers.

Sean.

i'm using numeric values for both keys and values

Well, this isnt intrinsically a bad thing. But more often than not it is.

The reason I say this is because if your indexes are sparse, ie 1, 500,623,7439,104029 or the like, then a hash is a much more suitable container type than an array is. (A hash would store the above usin 5 slots in a hash, an array would store at minimum 104029 elements.) However if the array is dense, 1..9,11..19,21..29 etc then an array is a more suitable approach. (Each slot in a hash is bigger than in an array, so even with the 4 wasted slots in the array would still be much smaller than the 26 allocated slots in the hash.)

Also, the difference isnt so much due to what you store in the values, but what you store in the keys.

Good luck and dont forget strict. :-)

--- demerphq
my friends call me, usually because I'm late....

In your case:

use Storable qw/dclone/;
$newhash=dlcone($framearray);
[download]

Hope this helps,

Rodney A. Hampton

$frameno  = "1";
$drawerno = "12";
$tempno   = "44";

# assignment
$framearray->{$frameno}{$drawerno} = $tempno;

# reassignment
%new_hash = %{$framearray};

# or only particular hashes thereof
%some_frame = %{ $framearray->{$frameno} };

# Now if we loop through %some_frame our keys are
# $drawerno and our values are the values assigned above

while ( ($drawer,$val) = each(%some_frame) ) {
   print "$drawer -> $val\n";
}

# would print
# 12 -> 44
[download]

I probably should have given more info to what I was attempting here.
Basically, I have 700+ disks in a NAS environment, contained in 47 drawers within 7 frames. I want to monitor the temp of the drawers, so my array would contain (1-7) for the frames and (1-8) for the no of drawers within the frames (as they don't all contain the same no. of drawers).
Giving as an example, (1,1) would be frame 1, drawer 1 would point to the value 30, or (5,8) would be frame 5, drawer 8 giving a value of 25.

The reason I was copying the array, was that the next time the prog queried the temp, I could compare the arrays and notify me of any changes in the temp from the last run.

Cheers

Sean

I realise it is 17 years later now, but for what it is worth now in 2019, you don't have to use a copy for this, only return a new reference / object in the acquisition function that queriers the data of your hard disks. So, don't use global hashes/arrays with this function. Then, two successive calls of the acquisition function will already return two separate instances of your data and so there is no need to copy this any further.