Also, note that you're taking the first argument to cleararray and throwing it away, and then referring to a global. It might be better (depending on your program design) to pass in $radiovar. If you want to call cleararray as a class method, you can do this:

sub cleararray
{
  my $class = shift; # ignored
  my $radiovar = shift;
  ...
}
# then call as:
PATTERNS->cleararray($someRadioVar);
[download]

or if you are always calling it from within the same package it's defined in, perhaps:

sub cleararray
{
  my $radiovar = shift;
  ...
}
# then call as:
cleararray($someRadioVar);
[download]

I believe I have heard that the prototyping in Perl is not really worth the effort; Especially when using OO because they are not checked in OO code.

sub cleararray {
    my $self = shift;
    for ( $i = 0; $self->radiovar(); $i++ ) {
        for ( $j = 0; $self->radiovar(); $j++ ) {
            @{$self->array()}[$i][$j] = undef;
        }
    }
}
[download]

• one to return or set the value of $radiovar
• one to return a reference to the @array

sub radiovar {
    my ( $self, $newval ) = @_;

    $self->{'radiovar'} = $newval if defined( $newval );

    return $self->{'radiovar'};
}

sub array {
    my ( $self, $newval ) = shift;
    $self->{'array'} = $newval if defined( $newval );
    return $self->{'array'};
}
[download]

Now if your situation calls for only one $radiovar value per class you could make it a class attribute pertaining to all object of Class X. Which would look something like:

package X;
...
my $radiovar;
...
sub radiovar {
   my $newval = shift;

   $radiovar = $newval if defined( $newval );
   return $radiovar;
}
[download]

Since you already made some great points about calling and global variables, I'd like to add a bit about the algorithm. First the cleararray sub can be shortened:

sub cleararray {
    my $self = shift;
    @{$self->array()}[$_] = [(0) x $self->radiovar()]
           for 0 .. $self->radiovar() - 1;
}
[download]

Second, it may not be necesary to use $self->radiovar() if $self->array() is already defined for size:

sub cleararray {
    my $self = shift;
    @{$self->array()}[$_] = [(0) x @{$self->array()}]
           for 0 .. @{$self->array()} - 1;
}
[download]


HTH,
Charles K. Clarkson

sub cleararray{
#code
}
[download]

will do fine.

So as it stands, even if you did call it like:

cleararry($radiovar);
[download]

it still won't work, because the variable that you're popping off the argument list goes to $class, which is not what you want, because you wouldn't do anything with it. Also, the way it is now, you're just using a global variable ($radioval), so passing it isn't necessary. I am not saying that this is good!! I haven't done too much OO myself, but I think I would do it like this, but keep in mind, TMTOWTDI:

sub clear_array{
    my($self, $var) = @_;
    my @array;
    for(my $i = 0; $i < $var; $i++){
           for(my $j = 0; $j < $var; $j++){
                  $array[$i][$j] = 0;
           }
    }
    return @array;
}
[download]

I'm sure there's an easier way to do it. There's probably a function that will do this for you already. My version keeps all variables local to the function, which is usually a good practice (I think). But anyway, since it's like this, it returns a two-dimensional array with all of its values set to 0. So to call it:

my $leroy = patterns->new(); #or my $leroy = new patterns;
@array_to_be_cleaned = $leroy->clear_array($radioval);
[download]

If there really isn't any special reason that you're passing in $radioval, then you could just use foreach, I think. I hope this helps, and that I didn't mess up and confuse you more.

happy coding,
Derek

$array = [ ] ;

is sufficient. This will effectively "clear" the array. Depending on your requirements, $i=[ 0 ] , $i=undef ], and $i may be all equivalent.

Remember that undef is actually an array element. I have caught myself thinking that @array = (undef) is an empty array. Nope. It is a single-element array with the element undef!

$array = [ ] ;
[download]

is sufficient. This will effectively "clear" the array.

Nope, it will not clear the array!
Instead it will create a new, empty anonymous array and store a reference to that in $array.

# populate the array with zeroes

sub cleararray
{
    my ($class, $radiovar) = @_;
    my @array;
    push @array, [ (0) x $radiovar ] for 1 .. $radiovar;
    return \@array;
}
[download]