标签: mutable

在重构我的 F# 代码时，我发现一条记录的字段类型为bool ref：

type MyType =
  {
    Enabled : bool ref
    // other, irrelevant fields here
  }

我决定尝试将其更改为mutable字段

// Refactored version
type MyType =
  {
    mutable Enabled : bool
    // other fields unchanged
  }

另外，我应用了编译代码所需的所有更改（即更改:=为<-、删除incr和decr函数等）。

我注意到更改后，一些单元测试开始失败。由于代码相当大，我无法真正看出到底改变了什么。

两者的实现是否存在显着差异，可能会改变我的程序的行为？

编辑：我在这里编辑了代码，不使用指针，因为有太多不相关的注释

#include <iostream>

struct Foo {
    Foo(const int a) : total(a) {}

    int       index = 0;
    const int total;
};

struct Bar {
    Bar(const int a) : total(a) {}

    mutable int index = 0;
    const int   total;
};

int main() {
    const Foo foo(3);
    for (
        ;
        foo.index < foo.total;
        const_cast<Foo*>(&foo)->index++ // 1. Undefined behavior because foo is const
    )
        std::cout << "Foo " << foo.index << std::endl;

    const Bar bar(3);
    for (
        ;
        bar.index < bar.total;
        bar.index++ // …

我有一个plist,它的根源是一个带有dictonaries的数组.

我从我的资源加载一个plist作为NSMutableArray.

[NSMutableArray arrayWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"Filters" ofType:@"plist"]]

我将它存储到nsuserdefault中,因为它必须在启动之间保持不变.

[[NSUserDefaults standardUserDefaults] setObject:array forKey:@"filters"];

但我不能改变数组中的dictonaries,因为它们不可变.我怎么能让它们变得可变？

a哈希.s是一个数组,我想a迭代地推送哈希.我们的想法是独立地保留每个迭代推送的哈希值.这是我试过的.

a = {:a=> 1, :b=>2}

s = []
s << a
s << a     # => [{:b=>2, :a=>1}, {:b=>2, :a=>1}]
a[:b] = 3
s          # => [{:b=>3, :a=>1}, {:b=>3, :a=>1}]

t = []
t.push(a)    # => [{:b=>3, :a=>1}]
t.push(a)    # => [{:b=>3, :a=>1}, {:b=>3, :a=>1}]
a[:b] = 4
t            # => [{:b=>4, :a=>1}, {:b=>4, :a=>1}]

上面没有给出解决方案:更改a更改先前推送的数组内元素中的值.推后a到s两次,我改变了a[:b]从2到3,所有的元素体现了变化.请给我这个建议.

我的代码崩溃在这一行:

[(NSMutableString *)string replaceCharactersInRange:range withString:@""];

错误尝试改变不可变对象.

这是怎么回事？我该如何解决？

我有代码直接改变矩阵的性能.在我改变它之前,我希望得到一个完整的副本来存储一个新符号,然后由变异过程使用.无论如何,我可以将Clojure符号的内容复制到一个新的符号中,以便第一个可以在不影响第二个的情况下进行变异吗？

这是我失败的尝试之一:

(var mat1 (clatrix/matrix (clatrix/ones 2 2)))
(var mat1)
(intern 'analyzer.core 'mat1 (clatrix/matrix (clatrix/ones 2 2)))
mat1
(intern 'analyzer.core 'mat2 mat1)
mat2
(clatrix/set mat1 0 0 2)
mat1
mat2

当然,这不起作用:

(def mat1 (clatrix/matrix (clatrix/ones 2 2)
(def mat2 mat1)

我也尝试过(但不确定我是否正好在这里做):

(def mat1 (clatrix/matrix (clatrix/ones 2 2)
(def mat2 `mat1)

和

(def mat1 (clatrix/matrix (clatrix/ones 2 2))
(def mat2 ~mat1)

和

(def mat1 (clatrix/matrix (clatrix/ones 2 2))
(def mat2 (.dup mat1))

有任何想法吗？

更新

我对迄今为止提出的答案进行了基准测试.我不确定线条的符号是什么意思.建立:

(def mat1 (clatrix/ones 1000 1000) ; …

可散列的对象需要一个__hash__方法,并且它具有一个在其生命周期内永远不会改变的哈希值.

由于我完全忽略的原因,Python列表不可清除,我想知道以下实现是否正常,或者是否有一些我不知道的故障.

class L(list):
    def __hash__(self):
        return id(self)

 a = range(10)
 l = L(range(10))
 print a
 >> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 print l
 >> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 hash(l)
 >> 41889288
 hash(a) # unsurprisingly it returns an error because a list is not hashable
 >> Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'

 # lets append a value to …

图形可以表示为邻接矩阵或邻接列表.我的Graph对象将图形表示为邻接矩阵.出于性能原因,除非有要求,否则我不会计算邻接表; 但是,一旦提出要求,我想保留清单(以避免重新建立).

是否适合制作邻接列表mutable,以便用户可以为其他const Graph对象生成邻接列表？我问,因为我不相信构建邻接矩阵会被视为"物理"而不是"逻辑"改变状态Graph.我也有一个adjacencyListBuilt方法,因此邻接列表的构建不是"不可见的"(参见https://isocpp.org/wiki/faq/const-correctness#mutable-data-members).

如果我理解正确,声明adjacencyList实例变量mutable将允许任何方法更新它.有没有办法只有buildAdjacencyList方法能够修改对象adjacencyList上的实例变量const？

我的代码中有几个可变变量.除了一个,所有这些都有效!
变量d会出现几个错误

learn.fsx(33,25): error FS0027: This value is not mutable. Consider using the mutable keyword, e.g. 'let mutable d = expression'

问题是当你查看我的代码时,变量显然被定义为一个可变变量.

我认为这是必要的,因为我能想到的唯一能引起问题的是它是变量定义之后的东西,它使它再次变得不可变.

let seq = [2;2;3;3;5;6]
let exp = [[];[]]
let mutable points = 0
let mutable e = 1
let mutable state = ""
let mutable d = 1
let rec guess (x:int) =
   match points with
   |100 -> "learned"
   |_ -> match seq.[x] with
         |d -> match (exp.[((List.length exp)-2)]) with
               |[] -> if state = …

在列表comp.例如,变量是否使用了与let stmt中状态相同的实变量？如果是这样,它实际上是可变的,对吗？它每次都围绕循环被绑定到一个新的东西吧？