标签: mutable

我有一个相对昂贵的数据获取操作,我想缓存结果.从const方法调用此操作,大致如下:

double AdjustData(double d, int key) const {
  double factor = LongRunningOperationToFetchFactor(key);
  return factor * d;
}

我想AdjustData保留const,但我想缓存因素,所以我只是第一次获取它.目前我使用的是mutable map<int, double>存储的结果(图被key到factor),但我使用的功能范围的静态可能是一个更好的解决办法思考-这个因素只能通过此功能需要,而且是无关的其他同学.

这似乎是一个好方法吗？还有更好的选择吗？我可以考虑哪些事情,特别是在线程安全方面.

谢谢,

大教堂

我向同事程序员展示了这个结构,他们认为它应该是一个可变类.他们觉得没有空引用和根据需要改变对象的能力是不方便的.我真的想知道是否有任何其他原因使这个变成一个可变类.

[Serializable]
public struct PhoneNumber : IEquatable<PhoneNumber>
{
    private const int AreaCodeShift = 54;
    private const int CentralOfficeCodeShift = 44;
    private const int SubscriberNumberShift = 30;
    private const int CentralOfficeCodeMask = 0x000003FF;
    private const int SubscriberNumberMask = 0x00003FFF;
    private const int ExtensionMask = 0x3FFFFFFF;


    private readonly ulong value;


    public int AreaCode
    {
        get { return UnmaskAreaCode(value); }
    }

    public int CentralOfficeCode
    {
        get { return UnmaskCentralOfficeCode(value); }
    }

    public int SubscriberNumber
    {
        get { return UnmaskSubscriberNumber(value); }
    }

    public int …

在我正在编写的程序中出现了以下模式.我希望它不是太做作,但它设法Foo在const方法中改变一个对象Foo::Questionable() const,而不使用任何const_cast或类似的东西.基本上,Foo存储参考FooOwner,反之亦然,并在Questionable(),Foo设法修改本身在一个const方法通过调用mutate_foo()关于它的主人.问题遵循代码.

#include "stdafx.h"
#include <iostream>
using namespace std;

class FooOwner;

class Foo {
    FooOwner& owner;
    int data;

public:
    Foo(FooOwner& owner_, int data_)
        : owner(owner_),
          data(data_)
    {
    }

    void SetData(int data_)
    {
        data = data_;
    }

    int Questionable() const;       // defined after FooOwner
};

class FooOwner {
    Foo* pFoo;

public:
    FooOwner()
        : pFoo(NULL)
    {}

    void own(Foo& foo)
    {
        pFoo = &foo;
    }

    void mutate_foo()
    {
        if …

当对象可变时,TreeSet,HashSet或LinkedHashSet如何表现？我无法想象它们会在任何意义上起作用吗？

如果我在添加对象后修改它; 列表的行为是什么？

是否有比链表或数组等可变对象(我需要排序/索引/等)的收集处理,只是通过他们迭代,每次一个更好的选择？

我有一个ivar,它在一个对象的init中被分配:

attString = [[NSMutableAttributedString alloc] init];

在循环中,我想清除attString的内容并重新使用它.我该怎么做呢？

谢谢!

我现在已经实现了另一个 SHA3​​候选者,即Grøstl.这仍然在进行中(非常如此),但目前224位版本通过了所有KAT.所以现在我想知道性能(再次: - >).这次的不同之处在于,我选择更接近地镜像(优化的)C实现,即我创建了一个从C到Haskell的端口.优化的C版本使用表查找来实现该算法.此外,代码主要基于更新包含64位字的数组.因此,我选择在Haskell中使用可变的无盒载体.

我的Grøstl代码可以在这里找到:https://github.com/hakoja/SHA3/blob/master/Data/Digest/GroestlMutable.hs

该算法的简短描述:它是一个Merkle-Damgård构造,只要有512位的消息块,就迭代一个压缩函数(在我的代码中为f512M).压缩函数非常简单:它只运行两个不同的独立512位排列P和Q(我的代码中的permP和permQ)并组合它们的输出.它的这些排列是由查找表实现的.

Q1)困扰我的第一件事是使用可变向量使我的代码看起来非常难看.这是我第一次在Haskell中编写任何主要的可变代码,所以我真的不知道如何改进它.关于如何更好地构建monadic代码的任何提示都将受到欢迎.

Q2)第二是表现.实际上它并不太糟糕,因为目前Haskell代码只慢了3倍.使用GHC-7.2.1并编译如下:

ghc -O2 -Odph -fllvm -optlo-O3 -optlo-loop-reduce -optlo-loop-deletion

Haskell代码使用60秒.输入约为1GB,而C版本使用21-22s.但有一些我觉得奇怪的事情:

(1)如果我尝试内联rnd512QM,代码需要4倍的时间,但如果我内联rnd512PM没有任何反应!为什么会这样？这两个功能几乎相同!

(2)这可能更难.我一直在尝试并行执行两个排列.但目前无济于事.这是我尝试过的一个例子:

f512 h m = V.force outP `par` (V.force outQ `pseq` (V.zipWith3 xor3 h outP outQ))
   where xor3 x1 x2 x3 = x1 `xor` x2 `xor` x3
         inP = V.zipWith xor h m
         outP = permP inP
         outQ = permQ m …

我习惯在C#中编写这样的代码:

SomeObj obj;
try{
    // this may throw SomeException
    obj = GetSomeObj();
}catch(SomeException){
    // Log error...
    obj = GetSomeDefaultValue();
}

obj.DoSomething();

这是我在F#中翻译它的方式(obj是一个列表):

let mutable obj = []
try
    obj <- getSomeObj
with
    | ex ->
        // Log ex
        obj <- getSomeDefaultValue

doSomething obj

有没有办法在不使用可变变量的情况下在F#中执行此操作？是否有一种更"优雅"的方式来处理F#中的这种情况？

谢谢!

如果我有这样的课程:

public class MyObject {
    private int myField = 2;
    public void setMyField(int f) {
        this.myField = f;
    }
}

这类对象是否可变？谢谢!

我正在尝试学习生锈,所以我正在实施一个只评估Collat​​z猜想的小程序.作为这个的一部分,我有一个函数,我递归调用,我想存储正在评估的当前数字,确定它是奇数还是偶数(或如果它只是一个1终止),执行猜想的那个分支然后用新号码打电话给自己.要做到这一点,我想将一个向量传递给这个函数并将当前数字推送到该向量上,但我很难理解如何传递一个可变向量引用.

这是我的代码:

fn evaluate_conjecture(number_to_be_evaluated: u64, mut intermediate_results: &Vec<u64>) -> u64 {
    intermediate_results.push(number_to_be_evaluated);

    if number_to_be_evaluated == 1 {
        0
    } else if number_to_be_evaluated % 2 == 1 {
        let odd_step_result = perform_odd_conjecture_step(number_to_be_evaluated);
        evaluate_conjecture(odd_step_result, intermediate_results) + 1
    } else {
        let even_step_result = perform_even_conjecture_step(number_to_be_evaluated);
        evaluate_conjecture(even_step_result, intermediate_results) + 1
    }
}

fn perform_odd_conjecture_step(_: u64) -> u64 {
    unimplemented!()
}

fn perform_even_conjecture_step(_: u64) -> u64 {
    unimplemented!()
}

这是我主要的相关部分

fn main() {
    let input_number = 42;
    let mut _intermediate_results: Vec<u64>;
    let number_of_steps = evaluate_conjecture(input_number, …

初步说明:我在朱莉娅工作,但这个问题可能适用于许多语言.

设置:我有一个复合类型如下:

type MyType
    x::Vector{String}
end

我写了一些方法来采取行动MyType.例如,我编写了一个允许我插入新元素的方法x,例如function insert!(d::MyType, itemToInsert::String).

问题:应该MyType是可变的还是一成不变的？

我的理解:我已经阅读了关于这个的Julia文档,以及关于Stackoverflow的更一般(和高度投票)的问题(例如这里或这里),但我仍然没有很好地处理它意味着什么从实际角度看可变/不可变(特别是对于不可变复合类型的情况,包含可变类型的可变数组!)

尽管如此,这是我的尝试:如果MyType是不可变的,那么这意味着该字段x必须始终指向同一个对象.该对象本身(字符串的向量)是可变的,因此我可以在其中插入新元素.我不允许做的是尝试改变,MyType以便该字段x指向一个完全不同的对象.例如,执行以下操作的方法是可以的:

MyType.x[1] = "NewValue"
push!(MyType.x, "NewElementToAdd")

但是执行以下操作的方法并不合适:

MyType.x = ["a", "different", "string", "array"]

这是正确的吗？另外,是否认为不可变类型字段值被锁定的对象是在构造函数中创建的对象？

最后一点:如果这似乎与SO上的其他问题重复,我道歉.如上所述,我已经仔细研究过,并且无法理解我所追求的.