正在看《The Ruby Programming Language》，书中说到 clone 是浅拷贝，于是做了如下测试
irb(main):007:0> class Klass
irb(main):008:1> attr_accessor :str
irb(main):009:1> end
=> nil
irb(main):010:0> s1 = Klass.new
=> #<Klass:0x7f301a290d50>
irb(main):011:0> s1.str = "Hello"
=> "Hello"
irb(main):012:0> s2 = s1.clone
=> #<Klass:0x7f301a281e90 @str="Hello">
irb(main):013:0> s1
=> #<Klass:0x7f301a290d50 @str="Hello">
irb(main):014:0> s2
=> #<Klass:0x7f301a281e90 @str="Hello">
irb(main):015:0> s2.str[1,4] = "i"
=> "i"
irb(main):016:0> s1
=> #<Klass:0x7f301a290d50 @str="Hi">
irb(main):017:0> s2
=> #<Klass:0x7f301a281e90 @str="Hi">
以上 s1 的内容随着 s2 的改变而改变，说明 clone 是一个浅拷贝
irb(main):018:0> a = Array.new
=> []
irb(main):019:0> a.push(1).push(2).push(3)
=> [1, 2, 3]
irb(main):020:0> a
=> [1, 2, 3]
irb(main):021:0> b = a.clone
=> [1, 2, 3]
irb(main):022:0> a
=> [1, 2, 3]
irb(main):023:0> b
=> [1, 2, 3]
irb(main):024:0> b.push(4)
=> [1, 2, 3, 4]
irb(main):025:0> a
=> [1, 2, 3]
问题：为什么这里 a，b 两个数组的内容不一样？
不同的类，实现的 clone 方法不一样。Array 对第一层对象做深度拷贝，但是嵌套的对象还是 shadow copy。试试这个：
ruby-1.9.2-p0 > a = Array.new
[]
ruby-1.9.2-p0 > a << ['first']
[
[0] [
[0] "first"
]
]
ruby-1.9.2-p0 > b = a.clone
[
[0] [
[0] "first"
]
]
ruby-1.9.2-p0 > b[0] << 'second'
[
[0] "first",
[1] "second"
]
ruby-1.9.2-p0 > a
[
[0] [
[0] "first",
[1] "second"
]
]
我的理解，浅拷只拷到第一层内置变量。 class Klass attr_accessor :str end 上面这个 str 是方法，不是变量。
变量是这样的，比如 RString 中的 ptr
struct RString {
653 struct RBasic basic;
654 union {
655 struct {
656 long len;
657 char *ptr;
658 union {
659 long capa;
660 VALUE shared;
661 } aux;
662 } heap;
663 char ary[RSTRING_EMBED_LEN_MAX + 1];
664 } as;
665 };
#1 楼 @daqing @loveky 其实不是这样的。 在 Ruby 里，我们所说的变量等实际都是对 对像的引用。浅拷贝只是拷贝引用而已，不是拷贝引用所指的对象。
m = ['a','b'] # ["a", "b"]
n = m.clone # ["a", "b"]
m.object_id == n.object_id # false
m[0].object_id == n[0].object_id # true
m[1].object_id == n[1].object_id # true
代码中 n 是由 m 克隆来的。指向一个新对象，所以 id 不同。 但是，m 和 n 中的元素都是指向相同的对象，对象本身并没有进行拷贝。所以 id 是相同的。 当然，这和 Array 的第 1 层或是第几层也没关系。
想实现深 copy，可以自行实现 initialize_copy 来达到深 copy 的目的。
#4 楼 @skandhas +1 initialize_copy 是正解 还可以用序列化的方式：http://www.iteye.com/topic/407957
#12 楼 @loveky 你是指你的第二个关于数组的例子吗？ 大体流程：
-
b = a.clone会产生一个新的 Array 对象 b（其实是引用） a 中包含的原有的对象引用也被拷贝到 b。注意是引用，不是对象。如下例中 m 的‘a’这个对象引用。 -
b.push(4)是对 b 所引用的对象进行操作，这个对象和 a 所引用的对象不一样，当然不会改变 a。
为了你不迷糊，缩小一下叙述范围，如果一个对象内部含有对其他对象的引用，在浅拷贝时，先创建一个新对象，然后再拷贝内部包含的其他对象 (比如说是实例变量) 的引用 (这些是引用，而不是对象)。
m=['a']
n=m.clone # 克隆产生一个新对象。
n[0] << 'b' # n[0]和m[0]都指向都一个对象，对其修改，m[0]和n[0]都会改变
p n # ["ab"]
p m # ["ab"]
n << 'c' #对n 所引用的对象进行操作
p m # ["ab"] m没有变化
p n # ["ab","c"] n 增加了一个元素
建议你看看@hooopo 的帖子。其实，关于对象引用的问题，给你画个图你就能明白了。写字反而容易让人迷糊。
@loveky 应该了解 c 语言吧。
我觉得也可以这样理解： 你的 a，b 两个数组例子类似
int a[4] = { 1, 2, 3, 4 };
// clone
int *b = (int *)malloc(sizeof(a);
memcpy(b, a, sizeof(a));
如果写 b[1] = 8; 则 a[1] 仍然为 2.
而如果写成如下的代码
int *a[4];
int e1 = 1, e2 = 2, e3 = 3, e4 = 5;
a[0] = &e1;
a[1] = &e2;
a[2] = &e3;
a[3] = &e4;
// clone
int *b[4];
memcpy( b, a, sizeof(a) );
如果写 (b[1]) = 8; 则(a[1]) 会变成 8
语言不一样，道理类似。