（以下示例为Elixir语言。）
假设我有以下代码：
x = {1, 2}
a1 = {"a", {1, 2}}
a2 = {"a", {1, 2}}
a3 = {"a", x}
{1, 2}。==或===比较任何a变量始终返回true。这是可以预期的，因为这两个运算符仅在比较数字类型（即1 == 1.0与1 === 1.0不同）时有所区别。defmodule Test do
def same?({x, y}, {x, y}), do: true
def same?(_, _), do: false
end
但是调用Test.same?(a1, a3)也会返回true。
我该如何使用指针相等性比较两个结构体，以便确定它们是否是内存中的同一结构体？
谢谢
erts_debug:size/1，它告诉您一个Erlang/Elixir术语占用了多少内存“字”。 这张表格 告诉您各种术语使用多少字。特别是一个元组使用1个字，加上每个元素的1个字，再加上任何“非立即”元素的存储空间。我们正在使用小整数作为元素，它们是“立即数”因此是“自由”的。所以这个检查通过：> :erts_debug.size({1,2})
3
现在让我们创建一个包含这两个元组的元组：
> :erts_debug.size({{1,2}, {1,2}})
9
有道理：两个内部元组各包含3个单词，而外部元组有1+2个单词，总共是9个单词。
但如果我们把内部元组放到一个变量中怎么办？
> x = {1, 2}
{1, 2}
> :erts_debug.size({x, x})
6
看，我们节省了3个单词！这是因为x的内容只计算一次；外部元组在两次指向同一内部元组。
因此，让我们编写一个小函数来帮助我们实现这一点：
defmodule Test do
def same?(a, b) do
a_size = :erts_debug.size(a)
b_size = :erts_debug.size(b)
# Three words for the outer tuple; everything else is shared
a_size == b_size and :erts_debug.size({a,b}) == a_size + 3
end
end
系统工作正常？看起来是的:
> Test.same? x, {1,2}
false
> Test.same? x, x
true
目标达成！
但是如果我们试图从已编译的模块中的另一个函数中调用此函数，而不是从iex shell中调用:
def try_it() do
x = {1, 2}
a1 = {"a", {1, 2}}
a2 = {"a", {1, 2}}
a3 = {"a", x}
IO.puts "a1 and a2 same? #{same?(a1,a2)}"
IO.puts "a1 and a3 same? #{same?(a1,a3)}"
IO.puts "a3 and a2 same? #{same?(a3,a2)}"
end
那会打印：
> Test.try_it
a1 and a2 same? true
a1 and a3 same? true
a3 and a2 same? true
那是因为编译器足够聪明，能够看到这些文字相等，并在编译时将它们合并为一个项。
请注意，当术语被发送到另一个进程或存储在/从ETS表中检索时，此共享术语会丢失。有关详细信息，请参见Erlang效率指南的进程消息部分。
==和===会在内部检测两个子结构是否是同一个内存元素，如果是，则立即将它们比较为true，而不是在比较期间一直遍历相同的子结构。你知道这是真的吗？ - mljrg:erts_debug.size(x)，这对我理解这个主题非常关键。 - mljrg:erts_debug.same/2，它将允许您进行所需的内存指针测试。然而，请注意该函数未记录，并位于名为erts_debug的模块中，因此您应仅在调试和测试时依赖它，而永远不要在生产代码中使用它。让我回答这个问题：
开发者不需要显式地进行指针比较，因为Elixir已经在模式匹配和操作符==和===（通过相应的Erlang操作符）中内部执行了该操作。
例如，给定以下代码：
a1 = {0, {1, 2}}
a2 = {1, {1, 2}}
x = {a1, a2}
s = {1, 2}
b1 = {0, s}
b2 = {1, s}
y = {b1, b2}
在IEx中，我们有以下内容：
Interactive Elixir (1.7.3) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> a1 = {0, {1, 2}}
{0, {1, 2}}
iex(2)> a2 = {1, {1, 2}}
{1, {1, 2}}
iex(3)> x = {a1, a2}
{{0, {1, 2}}, {1, {1, 2}}}
iex(4)> s = {1, 2}
{1, 2}
iex(5)> b1 = {0, s}
{0, {1, 2}}
iex(6)> b2 = {1, s}
{1, {1, 2}}
iex(7)> y = {b1, b2}
{{0, {1, 2}}, {1, {1, 2}}}
iex(8)> :erts_debug.size(x)
15
iex(9)> :erts_debug.size(y)
12
iex(10)> x == y
true
iex(11)> x === y
true
x和y在内容上相等，但是在内存中不同，因为y占用的内存比x少，因为它在内部共享子结构s。==和===都进行内容和指针比较。指针比较是Erlang避免在比较的两侧遍历相同子结构的最有效方法，从而节省了大量时间。a1和a2被压缩为b1和b2的情况。=== 被映射到 Erlang 的 =:=，它会比较类型并在类型相同时委托给 ==。它不能再通过任何方式更加高效，因为它执行了一个额外的操作。 - Aleksei Matiushkin{1.0, 1.0} === {1, 1}是真的，因为它们都是元组，它们的==是真的。相反，它与==一样是递归的，只是有一个单独的不同基本情况：它永远不会将浮点数和整数视为相等。 - Alexey Romanov{1, 2}。但实际上并非如此。Erlang虚拟机足够智能，只需创建一个元组并引用它即可。值得一提的是，这是因为所有内容都是不可变的。如果你发现自己像上面那样完成任务，那么你就错了。