blocks|key|438036|text|通常-+ruby变量保存引用，而不是指向值的指针。当你分配：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|438037|a+=+[3]
b+=+a|code-block|syntax|javascript|438038|b引用与a相同的数组。字符串也是一样的。|offset|length|style|CODE|438039|值得一读：https://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/|438040|编辑：|438041|a+=+[1]
b+=+a
b
#+=>+[1]
a+=+[2]
a
#+=>+[2]
b
#+=>+[1]|438042|entityMap|0|LINK|mutability|MUTABLE|url|https://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/^0|0|0|0|1|4|1|0|5|27|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@$I|18|J|19|1|1A]]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

In general - ruby variables hold references, not pointers to the values. When you assign:

<pre><code>a = [3]
b = a
</code></pre>

<code>b</code> references the same array as <code>a</code>. It's the same with strings.

Worth reading:
<a href="https://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/" rel="nofollow noreferrer">https://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/</a>

EDIT:

<pre><code>a = [1]
b = a
b
# =&gt; [1]
a = [2]
a
# =&gt; [2]
b
# =&gt; [1]

</code></pre>

blocks|key|2652336|text|我已经很久没有做过任何ruby编程了，但我记得:简而言之，int是按值存储的，复杂类型是通过指针存储的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2652337|例如：|2652338|a=3|code-block|syntax|javascript|2652339|这将创建一个内存位置保持器，其中存储类型'int‘的任何id，并且存储值本身(3)。|2652340|同时：|2652341|a="Toto"|2652342|这将使用类型为"string“的id和指向另一个持有"Toto”的内存的指针初始化位置持有人。|2652343|这就是为什么：|2652344|a=3
b=a
a=6|2652345|A为6，b为3(未被指令a=6更改)|2652346|2652347|a="Toto"
b=a
a.upcase!|2652348|A和b将是相同的字符串。|2652349|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1C|8|@]|9|@]|A|$]]|$1|W|3|L|5|6|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|Z|3|10|5|6|7|1F|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|12|$]]

It's been a long time since I've done any ruby programming, but for what I remember:
For short, int are stored by value, complex type are stored by pointer

For exemple:

<pre><code>a=3
</code></pre>

This will create a memory place holder where any id for the type 'int' is stored and the value itself is stored aswell (3).

While:

<pre><code>a="Toto"
</code></pre>

This will initialize the place holder with the id of the type "string" and a pointer to another memory holding "Toto"

This is why:

<pre><code>a=3
b=a
a=6
</code></pre>

a will be 6 and b will be 3 (not changed by the instruction a=6)

While:

<pre><code>a="Toto"
b=a
a.upcase!
</code></pre>

a and b will be the same string

blocks|key|3186229|text|为什么在ruby中数组被看作是指针，它是如何工作的？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|3186230|在Ruby中没有“指针”这样的东西。|unstyled|3186231|b是否像在C%2B%2B中那样指向a的地址？|offset|length|style|CODE|3186232|在Ruby中没有像“地址”这样的东西。语言规范指出，当您取消引用一个变量时，它的计算结果是分配给该变量的最后一个对象。语言实现是如何做到这一点的，这是完全不相关的，您不应该，实际上也不可能知道。它可以使用指向内存位置的指针。可能需要一本字典。它可以把价值打印在纸上，然后传真到东亚的一家血汗工厂，儿童奴隶在那里解释它。(这将是极不道德、不道德和非法的，但这将是一个完全有效的实施。)|3186233|是什么使变量改变了它所指向的？|3186234|赋值，而且只有赋值才能更改变量的绑定。|3186235|例如:如果a+=+b，什么时候a+!=+b？|3186236|当!=方法被重写以便这么说的时候。这可能是个糟糕的主意，但尽管如此：|3186237|class+Foo
++def+!=(*)
++++false
++end
end

a+=+Foo.new
b+=+a

a+!=+b+#=>+false|code-block|syntax|javascript|3186238|为什么整数不指向另一个变量的地址？|3186239|再说一遍，Ruby中没有“指针”或“地址”这样的东西，因此，整数永远不能“指向”“地址”，因为“指向”和“地址”是Ruby中不存在的概念。|3186240|让我们逐行遍历您的代码：|3186241|a+=+[]|3186242|创建一个新的Array对象，并将局部变量a绑定到该新数组对象。|3186243|b+=+a|3186244|现在，将局部变量b绑定到计算表达式a的结果。计算仅由变量名称组成的表达式的结果是什么？变量被取消引用，也就是说，它的计算结果是先前绑定到该变量的对象。|3186245|在本例中，该对象是您在第1行中创建的Array。|3186246|a[0]+=+3|3186247|这一行只是下面一行的语法糖：|3186248|a.[]=(0,+3)|3186249|在这里，您将发送消息[]=，将两个参数0和3传递给取消引用局部变量a的结果。再一次，取消引用局部变量a的计算结果是该变量绑定到最后的任何变量，即第1行中的Array。方法Array#[]=被定义为对其接收器进行变异，以便将第二个参数放置在第一个参数指定的索引上。|3186250|这种方法不需要改变它的接收器。它还可以返回Array的更新副本。(虽然在这种特殊情况下，这是无用的，因为a[0]+=+3语法糖的行为就像赋值一样，因此总是计算到右边。换句话说，除非使用调用语法Array#[]=的显式方法，否则将忽略a.[]=(0,+3)的返回值。)|3186251|p+b|3186252|在这里，我们再次取消对局部变量b的引用，它仍然指向完全相同的对象(从来没有任何重新分配)，它仍然是第1行中的Array。|3186253|在整个代码中只有一个Array。您从未创建过第二个Array，也从未调用将返回一个新的的方法。|3186254|一个确实返回新的Array而不是变异接收器的方法是Array#%2B方法。下面是一个使用Array#%2B的备用示例|3186255|a+=+[]
b+=+a
a+%2B=+[3]|3186256|a+%2B=+[3]等价于a+=+a+%2B+[3]，而后者等价于a+=+a.%2B([3])。因此，我们取消引用a，它从第1行给出Array，然后用单个参数[3]向它发送消息%2B。Array#%2B被定义为返回一个新的Array，它是接收方和参数的级联。最后，我们将这个新的Array分配给局部变量a。|3186257|p+b|3186258|局部变量b仍然绑定到同一个对象，因为我们从未重新分配它。因此，它仍然绑定到第1行的Array上。我们从未更改过这个Array，因此，它会打印[]。|3186259|关于您的第二个例子(这次我会更快一点)：|3186260|c+=+"this+is+a+string"|3186261|创建一个新的String，分配给c。|3186262|d+=+c|3186263|将d绑定到绑定到的任何c，即第1行中的String。|3186264|c.upcase!|3186265|将消息upcast!发送到取消引用c获得的String。String#upcase!被定义为对接收器进行变异。因此，被c和d引用的c现在已经改变了自己。|3186266|c+=+"the+string+has+been+edited"|3186267|创建一个与另一个无关的全新String，并将其分配给c。|3186268|p+d|3186269|d从未被重新分配，因此，它仍然绑定到第1行的String上。|3186270|entityMap^0|0|0|0|1|D|1|0|0|0|0|5|5|F|6|0|1|2|0|0|0|0|0|0|6|5|K|1|0|0|8|1|H|1|0|I|5|0|0|0|0|A|3|J|1|L|1|X|1|1E|1|25|5|2D|9|0|L|5|1G|8|2O|9|38|B|0|0|F|1|1I|5|0|A|5|P|5|0|8|5|P|7|16|7|0|0|0|8|B|B|T|C|1F|1|1O|5|21|3|2A|1|2C|7|2T|5|3L|5|3X|1|0|0|4|1|15|5|1L|5|1Y|2|0|0|0|6|6|G|1|0|0|1|1|B|1|J|6|0|0|3|7|H|1|L|6|S|E|1N|1|1P|1|1T|1|0|0|D|6|Q|1|0|0|0|1|M|6|0^^$0|@$1|2|3|4|5|6|7|2T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2U|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|2V|8|@$G|2W|H|2X|I|J]|$G|2Y|H|2Z|I|J]]|9|@]|A|$]]|$1|K|3|L|5|D|7|30|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|31|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|32|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|33|8|@$G|34|H|35|I|J]|$G|36|H|37|I|J]]|9|@]|A|$]]|$1|S|3|T|5|D|7|38|8|@$G|39|H|3A|I|J]]|9|@]|A|$]]|$1|U|3|V|5|W|7|3B|8|@]|9|@]|A|$X|Y]]|$1|Z|3|10|5|6|7|3C|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|3D|8|@]|9|@]|A|$]]|$1|13|3|14|5|D|7|3E|8|@]|9|@]|A|$]]|$1|15|3|16|5|W|7|3F|8|@]|9|@]|A|$X|Y]]|$1|17|3|18|5|D|7|3G|8|@$G|3H|H|3I|I|J]|$G|3J|H|3K|I|J]]|9|@]|A|$]]|$1|19|3|1A|5|W|7|3L|8|@]|9|@]|A|$X|Y]]|$1|1B|3|1C|5|D|7|3M|8|@$G|3N|H|3O|I|J]|$G|3P|H|3Q|I|J]]|9|@]|A|$]]|$1|1D|3|1E|5|D|7|3R|8|@$G|3S|H|3T|I|J]]|9|@]|A|$]]|$1|1F|3|1G|5|W|7|3U|8|@]|9|@]|A|$X|Y]]|$1|1H|3|1I|5|D|7|3V|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|W|7|3W|8|@]|9|@]|A|$X|Y]]|$1|1L|3|1M|5|D|7|3X|8|@$G|3Y|H|3Z|I|J]|$G|40|H|41|I|J]|$G|42|H|43|I|J]|$G|44|H|45|I|J]|$G|46|H|47|I|J]|$G|48|H|49|I|J]|$G|4A|H|4B|I|J]]|9|@]|A|$]]|$1|1N|3|1O|5|D|7|4C|8|@$G|4D|H|4E|I|J]|$G|4F|H|4G|I|J]|$G|4H|H|4I|I|J]|$G|4J|H|4K|I|J]]|9|@]|A|$]]|$1|1P|3|1Q|5|W|7|4L|8|@]|9|@]|A|$X|Y]]|$1|1R|3|1S|5|D|7|4M|8|@$G|4N|H|4O|I|J]|$G|4P|H|4Q|I|J]]|9|@]|A|$]]|$1|1T|3|1U|5|D|7|4R|8|@$G|4S|H|4T|I|J]|$G|4U|H|4V|I|J]]|9|@]|A|$]]|$1|1V|3|1W|5|D|7|4W|8|@$G|4X|H|4Y|I|J]|$G|4Z|H|50|I|J]|$G|51|H|52|I|J]]|9|@]|A|$]]|$1|1X|3|1Y|5|W|7|53|8|@]|9|@]|A|$X|Y]]|$1|1Z|3|20|5|D|7|54|8|@$G|55|H|56|I|J]|$G|57|H|58|I|J]|$G|59|H|5A|I|J]|$G|5B|H|5C|I|J]|$G|5D|H|5E|I|J]|$G|5F|H|5G|I|J]|$G|5H|H|5I|I|J]|$G|5J|H|5K|I|J]|$G|5L|H|5M|I|J]|$G|5N|H|5O|I|J]|$G|5P|H|5Q|I|J]]|9|@]|A|$]]|$1|21|3|22|5|W|7|5R|8|@]|9|@]|A|$X|Y]]|$1|23|3|24|5|D|7|5S|8|@$G|5T|H|5U|I|J]|$G|5V|H|5W|I|J]|$G|5X|H|5Y|I|J]|$G|5Z|H|60|I|J]]|9|@]|A|$]]|$1|25|3|26|5|D|7|61|8|@]|9|@]|A|$]]|$1|27|3|28|5|W|7|62|8|@]|9|@]|A|$X|Y]]|$1|29|3|2A|5|D|7|63|8|@$G|64|H|65|I|J]|$G|66|H|67|I|J]]|9|@]|A|$]]|$1|2B|3|2C|5|W|7|68|8|@]|9|@]|A|$X|Y]]|$1|2D|3|2E|5|D|7|69|8|@$G|6A|H|6B|I|J]|$G|6C|H|6D|I|J]|$G|6E|H|6F|I|J]]|9|@]|A|$]]|$1|2F|3|2G|5|W|7|6G|8|@]|9|@]|A|$X|Y]]|$1|2H|3|2I|5|D|7|6H|8|@$G|6I|H|6J|I|J]|$G|6K|H|6L|I|J]|$G|6M|H|6N|I|J]|$G|6O|H|6P|I|J]|$G|6Q|H|6R|I|J]|$G|6S|H|6T|I|J]|$G|6U|H|6V|I|J]]|9|@]|A|$]]|$1|2J|3|2K|5|W|7|6W|8|@]|9|@]|A|$X|Y]]|$1|2L|3|2M|5|D|7|6X|8|@$G|6Y|H|6Z|I|J]|$G|70|H|71|I|J]]|9|@]|A|$]]|$1|2N|3|2O|5|W|7|72|8|@]|9|@]|A|$X|Y]]|$1|2P|3|2Q|5|D|7|73|8|@$G|74|H|75|I|J]|$G|76|H|77|I|J]]|9|@]|A|$]]|$1|2R|3|-4|5|D|7|78|8|@]|9|@]|A|$]]]|2S|$]]

<blockquote>
 Why are arrays seen as pointers in ruby and how does it work?
</blockquote>

They aren't. There is no such thing as a "pointer" in Ruby.

<blockquote>
 Is <code>b</code>pointing to <code>a</code>'s address as in C++?
</blockquote>

There is no such thing as an "address" in Ruby. The Language Specification says that when you dereference a variable, it evaluates to the last object that was assigned to that variable. How the language implementation does this is completely and utterly irrelevant, and you shouldn't, and in fact can't know about it. It could use a pointer to memory location. It could use a dictionary. It could print the value out on paper and fax it to a sweat shop in East Asia where child slaves interpret it. (That would be highly immoral, unethical, and illegal, but it would be a perfectly valid implementation.)

<blockquote>
 What makes a variable change what it is pointing to?
</blockquote>

Assignment, and only assignment can change the binding of a variable.

<blockquote>
 For example: if <code>a = b</code> when will <code>a != b</code>?
</blockquote>

When the <code>!=</code> method is overridden to say so. Which would be a terrible idea, but nonetheless:

<pre><code>class Foo
 def !=(*)
 false
 end
end

a = Foo.new
b = a

a != b #=&gt; false
</code></pre>

<blockquote>
 Why are integers not pointing to the address of another variable?
</blockquote>

Again, there is no such thing as a "pointer" or an "address" in Ruby, therefore, an integer can never "point" to an "address", simply because "pointing" and "address" are not concepts that exist in Ruby.

Let's step through your code line-by-line:

<pre><code>a = []
</code></pre>

You create a new <code>Array</code> object and bind the local variable <code>a</code> to that new array object.

<pre><code>b = a
</code></pre>

Now, you bind the local variable <code>b</code> to the result of evaluating the expression <code>a</code>. What is the result of evaluating an expression that consists solely of the name of a variable? The variable gets dereferenced, i.e. it evaluates to the object that was bound to the variable earlier.

In this case, that object is the <code>Array</code> that you created on line 1.

<pre><code>a[0] = 3
</code></pre>

This line is simply syntactic sugar for the following line:

<pre><code>a.[]=(0, 3)
</code></pre>

Here, you are sending the message <code>[]=</code> passing the two arguments <code>0</code> and <code>3</code> to the result of dereferencing the local variable <code>a</code>. Again, dereferencing the local variable <code>a</code> evaluates to whatever the variable was bound to last, which is the <code>Array</code> from line 1. The method <code>Array#[]=</code> is defined as mutating its receiver such that it places its second argument at the index specified by the first argument.

The method doesn't have to mutate its receiver. It could also return an updated copy of the <code>Array</code>. (Although in this particular case that would be useless since the <code>a[0] = 3</code> syntax sugar behaves like assignment and thus will always evaluate to the right-hand side. In other words, the return value of <code>Array#[]=</code> would be ignored unless you use the explicit method calling syntax <code>a.[]=(0, 3)</code>.)

<pre><code>p b
</code></pre>

Here, we again dereference the local variable <code>b</code>, which still points to the exact same object (there was never any re-assignment), which is still the <code>Array</code> from line 1.

There was only ever one single <code>Array</code> in the entire code. You never created a second one, and you never called a method that would return a new <code>Array</code>.

One method that does return a new <code>Array</code> as opposed to mutating the receiver is the method <code>Array#+</code>. Here is an alternate example using <code>Array#+</code>:

<pre><code>a = []
b = a
a += [3]
</code></pre>

<code>a += [3]</code> is equivalent to <code>a = a + [3]</code> which is equivalent to <code>a = a.+([3])</code>. So, we dereference <code>a</code>, which gives the <code>Array</code> from line 1, then we send it the message <code>+</code> with the single argument <code>[3]</code>. <code>Array#+</code> is defined to return a new <code>Array</code> which is the concatenation of the receiver and the argument. Lastly, we assign this new <code>Array</code> to the local variable <code>a</code>.

<pre><code>p b
</code></pre>

The local variable <code>b</code> is still bound to the same object, since we never re-assigned it. So, it is still bound to the <code>Array</code> from line 1. We never changed this <code>Array</code>, ergo, this prints <code>[]</code>.

On to your second example (I'll go a bit faster this time):

<pre><code>c = "this is a string"
</code></pre>

Create a new <code>String</code>, assign to <code>c</code>.

<pre><code>d = c
</code></pre>

Bind <code>d</code> to whatever <code>c</code> is bound to, i.e. the <code>String</code> from line 1.

<pre><code>c.upcase!
</code></pre>

Send the message <code>upcast!</code> to the <code>String</code> obtained by dereferencing <code>c</code>. <code>String#upcase!</code> is defined as mutating the receiver. So, the <code>String</code> that is being referenced by both <code>c</code> and <code>d</code> has now changed itself.

<pre><code>c = "the string has been edited"
</code></pre>

Create a brand-new <code>String</code> that has nothing to do with the other one and assign it to <code>c</code>.

<pre><code>p d
</code></pre>

<code>d</code> was never re-assigned, ergo, it is still bound to the <code>String</code> from line 1.

I am fairly new to ruby but coming from a C/C++ background and I believe I have basic knowledge within how computers and programming work.
In C++ if you would like to create a pointer which will point to a value you will specify it as a pointer: <a href="http://www.cplusplus.com/doc/tutorial/pointers/" rel="nofollow noreferrer">http://www.cplusplus.com/doc/tutorial/pointers/</a>.
Example:
<pre><code>int x = 3;
int *p = &amp;x;
*p = 4;
std::cout &lt;&lt; x;
</code></pre>
Which makes sense to me because now <code>p</code> is pointing to the address of <code>x</code> and therefore when we change the value of <code>p</code>, <code>x</code> will change as well. <code>x</code> will in this case output 4.
But when I run:
<pre><code>a = []
b = a
a[0] = 3
p b
# =&gt; [3]

c = &quot;this is a string&quot;
d = c
c.upcase!
c = &quot;the string has been edited&quot;
p d
# =&gt; THIS IS A STRING
</code></pre>
In ruby, <code>b</code> outputs <code>[3]</code> where it for me should output nothing. And <code>d</code>outputs <code>&quot;THIS IS A STRING&quot;</code> and not <code>&quot;the string has been edited&quot;</code>. <a href="https://stackoverflow.com/questions/6116386/ruby-and-pointers">Ruby and pointers</a> is another question where they go through how you can use pointers in ruby.
My question is: Why are arrays seen as pointers in ruby and how does it work? Is <code>b</code>pointing to <code>a</code>'s address as in C++? What makes a variable change what it is pointing to? For example: if <code>a = b</code> when will <code>a != b</code>? Why are integers not pointing to the address of another variable?

Ruby and pointers compared to other languages?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对ruby相当陌生，但来自C/C++背景，我相信我对计算机和编程的工作原理有基本的了解。在C++中，如果您想要创建指向某个值的指针，您将将其指定为指针：。示例：int x = 3;int *p = &x;*p = 4;std::cout << x;这对我来说很有意义，因为现在p指向x的地址，因此当我们改变p的值时，x...

问与其他语言相比，Ruby和指针？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问与其他语言相比，Ruby和指针？EN