Scope of class instance variables?

[Ruby Freak]

I am reading Hal Fulton's "The Ruby Way" On page 57 he makes the
statement:
"Class instance variables cannot be referenced from within instance
methods and, in general are not very useful"

huh?..
This , in my feeble mind, contradicts everything else I have ever
read, except that the example he gives is similar to the @y = 7
example below, and in that case, @y is not available to the accessor
or any other method that I have played with.

In the following code, the original assignment of @x = 7 and @y = 5
don't seem to do anything, even with the attr_accessor. I know that
both are read by the compiler as I can assign @y = 5/0 and get a
division by zero error.

So, could someone please explain why the accessor for @y does not work
here. If I hand write a reader and writer for @y, it works just fine.
There are different scopes here, but I had the impression that the
accessor would break down that barrier and make @y available
throughout the class just as the initialize method is able to access
the class variable @x and assign the passed in value. That value is
then available to the @x accessor.

I thought for a while that the @y accessor might work in the singleton
class of Myclass, but it doesn't.

class Myclass
attr_accessor :y, :x

@x = 7
@y = 5

def initialize(new_val= l)
@x = new_val ? new_val : 0
end
end

mc = Myclass.new(3)

puts mc.y #=> Nil
puts mc.x #-> 3

I know I can make the @x and @y class variables available to instance
methods by referencing them inside defined methods and the scope seem
to be class wide, but it just seems like the first assignments above
should work as written.

Thanks in advance

 

[Trans]

I am reading Hal Fulton's "The Ruby Way" On page 57 he makes the
statement:
"Class instance variables cannot be referenced from within instance
methods and, in general are not very useful"

I think that just an out-dated way of looking at things. I expect Hal
would agree that needs to be updated to current trends.

I remember once, Hal and I got in a big argument about floating-point
arithmetic. A tad spiteful I pointed out a flaw in his book. Despite
the heated argument, he took it quite gracefully, saying he was always
happy to receive comments/corrections. That was pretty damn
respectable, IMHO. If he doesn't see this thread, write him directly.

T.

 

[surreal]

[Note: parts of this message were removed to make it a legal post.]

unsuscribe

 

[surreal]

[Note: parts of this message were removed to make it a legal post.]

unsubscribe

 

[Ruby Freak]

[Note: parts of this message were removed to make it a legal post.]

unsubscribe

2008/3/29, surreal <[email protected]>:

unsuscribe

2008/3/29, Trans <[email protected]>:

Thanks Trans.

I guess Harshad didn't like my post!

Anyway, I would still appreciate an explanation for the difference in
scope, or the reason the first assignment doesn't work.

Thanks

 

[Robert Dober]

I am reading Hal Fulton's "The Ruby Way" On page 57 he makes the
statement:
"Class instance variables cannot be referenced from within instance
methods and, in general are not very useful"

huh?..
This , in my feeble mind, contradicts everything else I have ever
read, except that the example he gives is similar to the @y = 7
example below, and in that case, @y is not available to the accessor
or any other method that I have played with.

In the following code, the original assignment of @x = 7 and @y = 5
don't seem to do anything, even with the attr_accessor. I know that
both are read by the compiler as I can assign @y = 5/0 and get a
division by zero error.

So, could someone please explain why the accessor for @y does not work
here. If I hand write a reader and writer for @y, it works just fine.
There are different scopes here, but I had the impression that the
accessor would break down that barrier and make @y available
throughout the class just as the initialize method is able to access
the class variable @x and assign the passed in value. That value is
then available to the @x accessor.

I thought for a while that the @y accessor might work in the singleton
class of Myclass, but it doesn't.

class Myclass

### make this
class << self

attr_accessor :y, :x

end

Now this is an accessor to the singleton class of the class where the
class instance variables are stored (that is not completely correct,
maybe I shall say from where one has access to them).

@x = 7
@y = 5

def initialize(new_val= l)
@x = new_val ? new_val : 0

# and this shall read
self.class.x = new_val || 0

end
end


puts mc.y #=> Nil

Myclass.x --> 7
mc = Myclass::new( 42 )
Myclass.x --> 42
mc = Myclass::new 101010
Myclass.x --> 101010
there is of course no mc.x but please see below.

I do however fear that you confuse instance variables with class
instance variables.
The former exist on an per object base and the later on a per class
base ( a class being an object of course ).
For completeness I'll show you how to use the former

class A
attr_accessor :a
def initialize; @a = 42 end
end
a= A.new
a.a --> 42
b = A.new
a.a = 101010
a.a -> 101010
b.a -> 42

HTH
Robert