假设我有一节课:
class NumberCollection
{
public:
typedef std::set<int> SetType;
typedef SetType::iterator iterator;
void insert(int n);
iterator begin();
iterator end();
size_t size() const;
iterator difficultBegin();
iterator difficultEnd();
size_t difficultSize() const;
private:
SetType easySet_, difficultSet_;
}
在哪里insert()添加元素easySet_.difficultSet_成员的变化取决于成员easySet_.
我遇到的问题是,多次插入意味着difficultSet_不断重新计算.所以我想difficultSet_将懒洋洋地计算(即,只有当difficultBegin(),difficultEnd()或者difficultSize()被称为).问题是,那么我实际上必须做成difficultSet_一个mutable因为否则difficultSize()无法操作它.
所以现在我的班级宣言看起来像
class NumberCollection
{
public:
typedef std::set<int> SetType;
typedef SetType::iterator iterator;
void insert(int n);
iterator begin();
iterator end();
size_t size() const; …我需要option<T>在F#中创建一个可变类型.我试过写作
let x = ref None
然后写作
x := Some(z)
但它不起作用.救命!
我写了一个与此非常类似的函数:
def writeMyEl (x: TypeA, y: TypeB, z : TypeC) {
if (myMutableHashMap.contains((x, y)))
myMutableHashMap(x, y) = z else
myMutableHashMap += (x, y) -> z
}
在实际代码中,类型A和B是枚举,C是案例类.myMutableHashMap被定义为与函数在同一类中val的类型.scala.collection.mutable.HashMap[(TypeA, TypeB), TypeC]writeMyEl
Scala(2.8)编译器说:
error: too many arguments for method update: (key: (TypeA, TypeB),value: TypeC)Unit
我究竟做错了什么？
我有一个类,它包含指向类外的常量VARIANT值的指针,但有时我想更改此指针以引用类本身的VARIANT成员对象.
这个类的大多数实例都是const,所以我必须将指针声明为可变的.
在Visual C++中,此代码似乎可以执行我想要的操作:
VARIANT mutable const* m_value;
但是,因为mutable是指针的属性而不是指针对象,我认为这是正确的语法:
VARIANT const * mutable m_value;
类似于如何定义常量指针(而不是指向const对象的指针).但是,Visual C++不接受此变体.
警告C4518:'mutable':这里意外的存储类或类型说明符; 忽视
Visual C++是对的,还是我错过了什么？另一个更符合标准的编译器可以表现不同吗？
我想要使用的方法gem来源于此处(第17-42行):https://github.com/rails/rails/blob/master/railties/lib/rails/generators/actions.rb
如你所见,name被分配到第19行的第一个arg,然后message被分配到name第23行,最后message在第26行被变异<<.遗憾的是,这意味着我作为第一个参数传入的字符串在方法之外发生了变异.
我有一个数组的哈希,并按如下方式迭代它们:
groups = { foo: %w(foo, bar), bar: %w(foobar) }
groups.each do |group, gems|
gems.each do |name|
gem(name, "42")
end
end
之后我的哈希看起来像是由于内部的突变gem:
groups => { foo: ["foo (42)", "bar (42)"], bar: ["foobar (42)"] }
如何防止这些字符串(以及散列及其数组)发生变异但不破坏方法？
MArray类提供了通用函数,用于在ST和IO上下文中处理各种类型的可变数组.我无法找到一个类似的类来处理STRefs和IORefs.这样的事情存在吗？
这个问题是相关的，但是它更涵盖了为什么编译器在从 返回可变引用时无法推断安全生命周期的原因Iterator::next，我想我理解。
我的问题是：
在设计自己的迭代器以生成可变引用时，您可以采取哪些具体步骤？最终，我希望有一个尽可能简洁、分步、注释的示例，说明 aIterator及其next实现，当他们遇到这种情况时，我（和任何人）可以将其作为明确的参考。unsafe例子很好，我想它们可能是必要的！
注意：我知道这MutItems通常是推荐的示例，但是它的实现可能很难遵循，因为没有关于 1. 标记在那种情况下如何工作以及 2.iterator!宏扩展到什么以及它如何工作的任何文档。如果你用MutItems你的例子，你能澄清这些事情吗？
I created a list in f# named tickets that contains 10 records called Ticket.The records are all initialized with their specific seat number and empty customer name.
type Ticket = {seat:int; customer:string}
let mutable tickets = [for n in 1..10 -> {Ticket.seat = n; Ticket.customer = ""}]
I want to write a function to book a specific seat in the list(add a customer name to the seat). How can i edit an item in the list and have other items …
获得访问权限的最有效方法是什么&mut [u8]？现在我从 Vec 借用，但更直接地分配缓冲区会更容易。
我现在能做的最好的事情是预先分配一个向量，然后推出它的长度，但这不可能是惯用的。
let mut points_buf : Vec<u8> = Vec::with_capacity(points.len() * point::POINT_SIZE);
for _ in (0..points_buf.capacity()) {
points_buf.push(0);
}
file.read(&mut points_buf[..]).unwrap();
在Tyler Jennings的演讲"Groupon的引导Clojure"中,从25:14到28:24,他讨论了一个separate函数的两个实现,都使用了瞬态:
(defn separate-fast-recur [pred coll]
(loop [true-elements (transient [])
false-elements (transient [])
my-coll coll]
(if (not (empty? my-coll))
(let [curr (first my-coll)
tail (rest my-coll)]
(if (pred curr)
(recur (conj! true-elements curr) false-elements tail)
(recur true-elements (conj! false-elements curr) tail)))
[(persistent! true-elements) (persistent! false-elements)])))
(defn separate-fast-doseq [pred coll]
(let [true-elements (transient [])
false-elements (transient [])]
(doseq [curr coll]
(if (pred curr)
(conj! true-elements curr)
(conj! false-elements curr)))
[(persistent! true-elements) (persistent! false-elements)]))
(这些都是逐字复制的,包括第二行最后一行的单一缩进.)
他指出,在他使用的基准测试中,上面的第一个函数需要1.1秒,而上面的第二个函数需要0.8秒,因此注意第二个函数优于第一个函数.但是,根据 …