问题标签 [mutability]

是否有与 Python 的id()等效的 C# ？如果没有，我如何测试对象是否已更改？例如，在 Python 中，一个不可变对象：

和一个可变的：

编辑 - 到目前为止，大多数答案都是关于比较函数/运算符，但我对正在比较的值更感兴趣。我最初并不清楚这一点，我接受Object.ReferenceEquals了这个答案。

我想翻译 a 中的所有点List<T>。这有效：

但使用List<T>.ForEach不会：

想法？

如果我想调用这样的方法：

一切都很好，除非我调用该方法，它实际上修改了它的参数，是否还有呢？

无论如何要声明 f 以在 java 中保持 l 不变？

我知道我可以对 l 执行深度克隆并通过它，但是在 l 非常大的情况下，这个操作很昂贵。

试图制作一个名为 make-odd-mapper 的方案过程！它应该是一个过程，它接受一个输入，一个过程，并产生一个过程作为输出

前任：

(定义 i4 (mlist 10 2 30 4))

(i4)

{10 2 30 4}

((make-odd-mapper!add-one) i4)

i4

{11 2 31 4}

我知道问题需要改变输入列表和 set-mcar！和 void 是其中的一部分......谁能给我一些合理的代码行来解决这个问题？如果有人想知道突变......并使用它来创建一个将过程作为其输出的过程......这将很有用。

这个问题不是关于受限的技术使用，更多的是关于主观使用。虽然我可能会误认为限制在技术上是如何工作的，但在这种情况下，您应该随时指责我基于错误前提提出问题。

以下是到目前为止我如何使用受限的两个示例：

如果我有一个函数需要一个指向不可变字符序列的指针，我不会说它受到限制，因为其他人可以在函数执行的同时通过他们自己的指针访问数据，例如从另一个并行线。数据没有被修改，所以没问题。

但是，如果函数接受一个指向它可能修改的可变字符序列的指针，我说它是受限制的，因为在执行由于数据可能不一致而导致的函数。它还说明了数据被修改的可能性，因此编码人员知道不要读取过时的数据，并且他们应该在访问时使用内存屏障或其他...

我没有编写太多 C 代码，所以我很容易对我在这里的假设有所误解。这是限制的正确用法吗？在这种情况下值得做吗？

我还假设一旦函数返回时将受限指针从堆栈中弹出，然后可以再次通过任何其他指针自由访问数据，并且限制只持续与受限指针一样长。我知道这依赖于遵循规则的编码器，因为通过“非官方”指针访问受限数据是 UB。

我做对了这一切吗？

编辑：

我想明确一点，我已经知道它绝对不会阻止用户通过多个线程访问数据，而且我也知道 C89 甚至不知道“线程”是什么。

但是考虑到可以通过引用修改参数的任何上下文，很明显在函数运行时不能访问它。这对强制线程安全没有任何作用，但它确实清楚地记录了您在函数执行期间通过自己的指针修改数据，风险自负。

即使线程完全被排除在外，您仍然允许在我认为正确的情况下进行进一步优化。

即便如此，感谢您迄今为止提供的所有权威答案。我是赞成所有我喜欢的答案，还是只赞成我接受的答案？如果接受多于一个怎么办？抱歉，我是新来的，我现在会更彻底地查看常见问题解答...

我遇到了 Java 并发问题。是的，我查看了标题几乎完全相同的问题，但它们似乎都在问微妙的不同问题。是的，我读过Java Concurrency in Practice。是的，我明白为什么它是该主题的实际参考。是的，我已经阅读了专门关于在线程安全类中发布字段的部分。是的，我仍然会问一个关于 Java 的并发问题，尽管我知道有人会简单地将我指向那本书。

这让我很困惑——我知道您可以通过确保具有可变性和/或同步访问的正确读/写顺序以线程安全的方式轻松发布可变原始字段，并且 64 位原语需要具有原子访问由于其读/写操作缺乏原子性。我知道在需要在类字段的特定“快照”上执行的代码块上使用锁。我完全了解带有 AtomicLong<> 等好东西的 atomic 包。

但是我仍然对将非线程安全对象发布为线程安全类中的字段感到困惑。

从我所见，只要您在 getter 中返回对它的引用，您就可以向调用者提供对对象内容的前所未有的访问权限，他们可以在任何时候使用。此外，如果您提供一个 setter，则您允许他们将对象引用设置为他们可以在他们使用 setter 的对象之外潜在地控制的对象。

无论如何，如果不将它们全部设为私有/受保护并在类中为所有非线程安全对象的所有方法创建线程安全包装器方法，我就无法从非线程安全对象中组成线程安全类有该类的用户可能想要使用的。这听起来就像一个样板的噩梦。

我的意思是，如果您将 AtomicReference<> 返回到 getter 中的对象，他们可以使用 .get() 再次获得对它的非同步访问。

我考虑的另一种方法是让所有 getter 基于旧对象返回非线程安全对象的新副本，这意味着修改将无关紧要，同样适用于 setter。但是 Java 有一个非常复杂的系统来克隆对象（浅拷贝、深拷贝和特定拷贝等），这让我不太愿意这样做。此外，这效率非常低，以至于它不会比使用像 Clojure 这样为不变性而设计的语言快。事实上，考虑到这种语言允许多条不可变数据在后台共享相同的数据，它可能会慢得多。

那么，如何以可行的方式组合已发布的非线程安全对象的线程安全类？

提前致谢。

在 Google Go 中，我读到字符串是不可变的，好吧，但它是 int 的吗？其他类型呢？作为一个年纪稍大的程序员，我更喜欢可变性，尽管我知道不变性的好处，但我更喜欢危险地生活。

知道哪些类型是可变的或不可变的将非常有帮助。

更新，我最关心的是实际问题取决于类型是可变的还是不可变的。就像 Java 中的典型示例一样，如果您在循环中创建一个字符串并循环 10,000 次，您将获得 10,000 个字符串，这些字符串随后会被垃圾回收。在我工作的一家公司的一个项目中，这实际上是一个严重的问题。

问题是，Go 的不变性在某些情况下会导致同样的问题吗？

它会影响您应该如何对待 var。（或者我认为确实如此）。

再次更新，我也关心其他实际问题。知道某些东西是不可变的意味着我可以编写并行的代码，并且对对象的一个​​引用的更新不应该更新其他引用。但是有时我想做危险的事情，我想要可变性。

这些是可变性与不变性的后果，并影响我如何编写代码。

你好，这里有一个关于 jQuery 的新菜鸟，我想知道 jQuery 对象是否是不可变的。例如：

obj1 和 obj2 的含义相同吗 obj2 会引用 obj1 吗？

更新：

上面的例子有点触及我想知道的表面，一个更准确的问题是：如果我从 jQuery api 链接函数，它们会返回相同的对象还是新的对象（就像 Java 中的字符串一样）？

Here seems to be the two biggest things I can take from the How to Design Programs (simplified Racket) course I just finished, straight from the lecture notes of the course:

1) Tail call optimization, and the lack thereof in non-functional languages:

Sadly, most other languages do not support TAIL CALL OPTIMIZATION. Put another way, they do build up a stack even for tail calls.

Tail call optimization was invented in the mid 70s, long after the main elements of most languages were developed. Because they do not have tail call optimization, these languages provide a fixed set of LOOPING CONSTRUCTS that make it possible to traverse arbitrary sized data.

a) What are the equivalents to this type of optimization in procedural languages that don't feature it? b) Do using those equivalents mean we avoid building up a stack in similar situations in languages that don't have it?

2) Mutation and multicore processors

This mechanism is fundamental in almost any other language you program in. We have delayed introducing it until now for several reasons:

• despite being fundamental, it is surprisingly complex

• overuse of it leads to programs that are not amenable to parallelization (running on multiple processors). Since multi-core computers are now common, the ability to use mutation only when needed is becoming more and more important

• overuse of mutation can also make it difficult to understand programs, and difficult to test them well

But mutable variables are important, and learning this mechanism will give you more preparation to work with Java, Python and many other languages. Even in such languages, you want to use a style called "mostly functional programming".

I learned some Java, Python and C++ before taking this course, so came to take mutation for granted. Now that has been all thrown in the air by the above statement. My questions are:

a) where could I find more detailed information regarding what is suggested in the 2nd bullet, and what to do about it, and b) what kind of patterns would emerge from a "mostly functional programming" style, as opposed to a more careless style I probably would have had had I continued on with those other languages instead of taking this course?

我的理解是 Python 字符串是不可变的。

我尝试了以下代码：

Python不应该阻止分配吗？我可能错过了一些东西。

任何想法？