关于Viewport的诡异测试

紫苏

clone 的调用是成功了的，克隆后的对象 id 也不同，只不过通过克隆体调用 set 或者 width= 的时候引用的是本体的变量，而调用本体的 width= 就冇问题了：

1. v = Viewport.new(0,0,12,12)
   
2. 
   
3. a = v.rect
   
4. b = a.clone
   
5. c = b.clone
   
6. 
   
7. a.width = 9999
   
8. 
   
9. p a, b, c

复制代码

可见至少 width 和 height 方法确实返回的是正确克隆后的宽度和高度变量
这个应该还是和 Rect 的属性在 C 中实现有关，因为 Rect 本身没有覆盖 Object 的 clone 方法，而 Sprite啊、Viewport啊之类的都覆盖了的，所以下面 p 出来是 false 的类都应该有这个问题：

1. p "Rect #{Rect.instance_methods(false).include?("clone")}",
   
2.   "Sprite #{Sprite.instance_methods(false).include?("clone")}",
   
3.   "Bitmap #{Bitmap.instance_methods(false).include?("clone")}",
   
4.   "Viewport #{Viewport.instance_methods(false).include?("clone")}",
   
5.   "Plane #{Plane.instance_methods(false).include?("clone")}",
   
6.   "Color #{Color.instance_methods(false).include?("clone")}",
   
7.   "Font #{Font.instance_methods(false).include?("clone")}",
   
8.   "Window #{Window.instance_methods(false).include?("clone")}",
   
9.   "Tilemap #{Tilemap.instance_methods(false).include?("clone")}",
   
10.   "Tone #{Tone.instance_methods(false).include?("clone")}",
    
11.   "Table #{Table.instance_methods(false).include?("clone")}"

复制代码

紫苏

哦，原来覆盖是为了禁止 clone，还真不知道～

……不能 Marshal 确实诡异，无源码无从分析
不过我发现只要不是在 RGSS 类内部（比如 Viewport 的构造函数）分配的某个属性对象，至少 clone 可以正常工作了：

1. a = Rect.new(0, 0, 12, 12)
   
2. v = Viewport.new(0, 0, 1, 1)
   
3. v.rect = a
   
4. 
   
5. b = v.rect.clone
   
6. b.width = 999
   
7. 
   
8. p a, b

复制代码

另外不仅仅是 rect，只要是这些 RGSS 类的对象属性都有这个问题：

1. s = Sprite.new
   
2. 
   
3. a = s.color
   
4. b = a.clone
   
5. 
   
6. b.red = 88
   
7. 
   
8. p a, b

复制代码

1. p = Plane.new
   
2. a = p.color
   
3. 
   
4. b = a.clone
   
5. b.red = 999
   
6. 
   
7. p a, b

复制代码

对象 id 不同，说明在 Ruby 层的克隆成功了，只不过如果这个对象是在 C 层上分配的话，推测就是没有克隆数据，而是克隆了指针（？！）

霜冻之狼

好东西，俺来膜拜下

IamI

如果我这么说阁下觉得可以理解吗

1. def rect
   
2. return Rect.new(x,y,width,height) # 伪代码，实际公式要比这个复杂= =
   
3. end
   
4. def rect=(value)
   
5. # 同
   
6. end

复制代码

这个方法只是为了方便使用而已……临时对象……结果自然可想而知

link006007

.clone方法返回的的确是Viewport.rect的属性的拷贝,
但是clone方法返回的是一个"冻结的,且会感染原实例"的实例(我英文不好-  -!!)...
也就是clone产生的实例被修改了,会影响到原实例. 但是源实例被修改了,则clone产生的实例不会受到影响

1. 
   
2. a = Viewport.new(0,0,12,12)
   
3. b = a.rect.clone
   
4. a.rect.width = 24
   
5. p a.rect, b, "ID:", a.rect.object_id, b.object_id, "Ins:", a.rect.inspect, b.inspect
   
6. b.width = 48
   
7. p a.rect, b, "ID:", a.rect.object_id, b.object_id, "Ins:", a.rect.inspect, b.inspect
   
8. 
   
9. c = a.rect.clone
   
10. a.rect.width = 12
    
11. p a.rect, c, "ID:", c.object_id, "Ins:", c.inspect
    
12. c.width = 48
    
13. p a.rect, c, "ID:", c.object_id, "Ins:", c.inspect
    
14. exit
    

复制代码

还有 Viewprot不能被clone,并不一定要重载clone方法
如果Viewport定义的ruby类具有const属性, 那么根据const的原则,是不可以存在一个可以感染它的clone实例,也就是Viewport不能被clone的原因

1. 
   
2. VALUE
   
3. rb_obj_clone(obj)
   
4.     VALUE obj;
   
5. {
   
6.     VALUE clone;
   
7. 
   
8.     if (rb_special_const_p(obj)) {
   
9.         rb_raise(rb_eTypeError, "can't clone %s", rb_obj_classname(obj));
   
10.     }
    
11.    ... ...
    
12.    ... ...
    
13.     return clone;
    
14. }
    

复制代码

以上只是个人理解...  实际还要去看源代码- -

紫苏

clone 只是会拷贝被克隆对象的污染和冻结状态，并不是克隆后必然产生污染和冻结的对象 ^^

1. 
   
2. v = Viewport.new(0, 0, 12, 12)
   
3. a = v.rect
   
4. b = v.rect.clone
   
5. 
   
6. p a.frozen?, b.frozen?
   
7. p a.tainted?, b.tainted?

复制代码

另外即便是污染或者冻结，前者和安全等级有关，禁止了对对象的一些操作；而后者是使对象不可修改，“clone产生的实例被修改了,会影响到原实例. 但是源实例被修改了,则clone产生的实例不会受到影响”这个结论是从何而来？

link006007

“clone产生的实例被修改了,会影响到原实例. 但是源实例被修改了,则clone产生的实例不会受到影响”
紫苏 发表于 2009-9-18 21:07

我前面已经说了 这个只是我的理解...
Copies the frozen and tainted state of OBJ.
也就是第一段代码的运行结果.
a = Viewport.new
b = a.rect.clone
c = a.rect.clone
b或c修改,a的值会改变.   而a的值修改,b与c值不改变
再如

1. 
   
2. class Klass
   
3.    attr_accessor :str
   
4. end
   
5. s1 = Klass.new      #=> #<Klass:0x401b3a38>
   
6. s1.str = "Hello"    #=> "Hello"
   
7. s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
   
8. s2.str[1,4] = "i"   #=> "i"
   
9. s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
   
10. s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
    

复制代码

但是如果单独的Rect.new.clone就不会有这种效果 = =

紫苏

呵呵，我前面也说了，clone 只是拷贝被克隆体的污染和冻结状态而已，如果被克隆体本身就不是污染和冻结状态，克隆之后自然也不是……所以上面给出了调用 tainted? 和 frozen? 方法的代码，就是为了看克隆体是否有这两个状态的～

另外 Klass 这段代码和这贴讨论的不搭界——
首先 s1 是一个 Klass 的实例，并让其 str 成员指向了 "Hello" 对象；s2 是 s1 的克隆体，拷贝了其所有的成员变量，但这是一个浅层拷贝，s2 的 str 成员实际上指向的还是 s1 的 str 对象，也就是之前的那个 "Hello"，换句话说就是这里的浅层拷贝仅仅拷贝的是对象在栈中的引用，而并没有在堆中实际拷贝一份对象的数据（值）～

1. class Klass
   
2.    attr_accessor :str
   
3. end
   
4. 
   
5. s1 = Klass.new
   
6. s1.str = "Hello"
   
7. s2 = s1.clone
   
8. 
   
9. p s1.str.id, s2.str.id    # 对象 id 一致

复制代码

而这贴讨论的 Rect 问题，其属性按理说只有四个整型变量，那么普通的浅层拷贝就能做到值的拷贝了，但实际上还是有我们都看到的这个问题……（所以上面我才猜测可能是和拷贝了指向整型数据的指针有关）