Address of a specific element: an Array containing Array References...

Discussion in 'Perl Misc' started by nmvega, Oct 30, 2008.

  1. nmvega

    nmvega Guest

    Friends:

    I have a syntax question, and I have put together this contrived
    example (with
    running comments), to demonstrate the line of code I need adjusted.
    Sorry
    for the verbosity.

    ##############################################################
    # @tableCellData = will be used to store 2 anonymous array
    references.
    # @table = will be used to store addresses of array *elements*
    (not of arrays).
    ##############################################################
    my (@table, @tableCellData);

    #####################################################
    # Insert 2 anonymous array references into @table.
    # This essentially creates a 2D table, with 2 rows / 0 columns.
    #####################################################
    push @tableCellData, ["foo"]; # use of "foo" twice in a row is ok
    (it's arbitrary).
    push @tableCellData, ["foo"]; # use of "foo" twice in a row is ok
    (it's arbitrary).


    ##################################################################
    # Dynamically expand each anonymous array so that each has two
    elements.

    ##################################################################
    $tableCellData[0][0] = "0,0";
    $tableCellData[0][1] = "0,1";
    $tableCellData[1][0] = "1,0";
    $tableCellData[1][1] = "1,1";

    ################################################################
    # At this point, at run-time the following (test) line will print
    "1,0" (literally).
    ################################################################
    print "$tableCellData[1][0]\n";

    ##########################################################
    # Next, we pouplate the @table array with the both elements of
    the first
    # anonymous array (created above), and also with the both
    elements of
    # the second anonymous array (also created above).
    ##########################################################
    push @table, ("$tableCellData[0][0]\n");
    push @table, ("$tableCellData[0][1]\n");
    push @table, ("$tableCellData[1][0]\n");
    push @table, ("$tableCellData[1][1]\n");

    ##########################################################
    # Thus, at this point, at run-time the following (test) line will
    print:
    # "0,0" "0,1" "1,0" "1,1" each on their own line.
    ##########################################################
    print "@table\n";

    Everything in this contrived example works fine up to this point! In
    fact, again
    my question (up next) is not about debugging but, rather, about
    syntax. Here
    is the question:

    As we can see from the above "print" statement, the four "push"
    statements
    before it, inserted the *CONTENT* of the anonymous array element
    indexed
    (i.e. referenced/positioned) at [x][y].

    But what I need to do instead, is to insert the *ADDRESS* of that
    array *ELEMENT* instead. The reason (if curious) is that each time I
    execute
    statement:

    print "@table\n";

    it's output should dynamically change as I update individual elements
    of the
    two anonymous arrays contained in the named array @tableCellData ...
    (e.g. $tableCellData[1][1] = "hereIsAnUpdate"; <-- would be an
    update that
    should be reflected on the next "print" statement.).

    Thus it's only a slight modification that I seek to the 2nd argument
    of this
    statement (an extra $, @, \, etc., -- but I can't quite get it right):

    push @table, ("$tableCellData[x][y]");
    ^^^^^^^^^^^^^^^^^^^^^^
    That is the line where I need the tip.

    A general way to ask this question is this...
    Given access to an array of anonymous array references (such as
    @tableCellData),
    what is the syntax to get the ADDRESS of a specific element of a
    specific anonymous
    array within it?

    Note: There are multiple ways to do things in PERL, however I'm
    seeking this
    particular way, so sustained focus (to the slight modification I seek)
    would be
    appreciated.

    Thanks In Advance & Regards,
    Noel Milton Vega
     
    nmvega, Oct 30, 2008
    #1
    1. Advertising

  2. nmvega

    Guest

    Re: Address of a specific element: an Array containing Array References ...

    nmvega <> wrote:
    > Friends:
    >
    >
    > ##################################################################
    > $tableCellData[0][0] = "0,0";
    > $tableCellData[0][1] = "0,1";
    > $tableCellData[1][0] = "1,0";
    > $tableCellData[1][1] = "1,1";
    >


    > push @table, ("$tableCellData[0][0]\n");
    > push @table, ("$tableCellData[0][1]\n");
    > push @table, ("$tableCellData[1][0]\n");
    > push @table, ("$tableCellData[1][1]\n");


    First, the double-quote interpolation creates a copy. Then,
    the push creates another copy. So you have two levels of problem.

    >

    ....
    >
    > Everything in this contrived example works fine up to this point! In
    > fact, again
    > my question (up next) is not about debugging but, rather, about
    > syntax. Here
    > is the question:
    >

    ....
    >
    > But what I need to do instead, is to insert the *ADDRESS* of that
    > array *ELEMENT* instead. The reason (if curious) is that each time I
    > execute
    > statement:
    >
    > print "@table\n";



    >
    > it's output should dynamically change as I update individual elements
    > of the
    > two anonymous arrays contained in the named array @tableCellData ...
    > (e.g. $tableCellData[1][1] = "hereIsAnUpdate"; <-- would be an
    > update that
    > should be reflected on the next "print" statement.).
    >
    > Thus it's only a slight modification that I seek to the 2nd argument
    > of this
    > statement (an extra $, @, \, etc., -- but I can't quite get it right):
    >
    > push @table, ("$tableCellData[x][y]");


    You could push the reference,

    push @table, \$tableCellData[x][y];

    But then print @table would print stringified references, because it
    wouldn't automatically dereference.

    You could use push_aliases from the module Array::Splice to circumvent this
    by pushing aliases rather than references. But you would have to drop the
    double quotes, because they would break the alias.

    You could create some kind of tied array that both has the push_aliases
    functionality and will automatically add a \n to the end of fetched
    strings, but that seems more of a problem than a solution.

    Xho

    --
    -------------------- http://NewsReader.Com/ --------------------
    The costs of publication of this article were defrayed in part by the
    payment of page charges. This article must therefore be hereby marked
    advertisement in accordance with 18 U.S.C. Section 1734 solely to indicate
    this fact.
     
    , Oct 30, 2008
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. candide
    Replies:
    65
    Views:
    1,461
  2. John Koleszar

    address of static array element as address constant

    John Koleszar, Jul 7, 2008, in forum: C Programming
    Replies:
    7
    Views:
    646
    John Koleszar
    Jul 15, 2008
  3. mazdotnet
    Replies:
    2
    Views:
    425
    Alexey Smirnov
    Oct 2, 2009
  4. Stanley Rice

    Address of array && address of pointer to array

    Stanley Rice, Sep 14, 2011, in forum: C Programming
    Replies:
    33
    Views:
    1,209
    Keith Thompson
    Sep 20, 2011
  5. Mintcake
    Replies:
    1
    Views:
    103
    Ton Hospel
    Mar 6, 2005
Loading...

Share This Page