小编Pil*_*lsy的帖子

何时隐式移动构造函数不够好？

我应该把它当作析构函数和复制构造函数来对待它,通常只有在我管理自己的内存时才需要吗？

在这个(非常人为的)场景中隐式移动构造函数是否足够好:

class A
{
private:
    B b;
    std::string name;

public:
    A();
    std::string getName() const {
        return name;
    }

    B getB() const {
        return b;
    }
};

class B
{
private:
    std::vector list;

public: 
    B();
    std::vector getList() const {
        return list;
    }
};

嘿,我一直在寻找在我的框架中添加脚本语言的可能性,我听说过Lisp并认为我会试一试.有没有像Lua和Python这样的Lisp VM,或者我的思维方式错误.我在这里找到了CLISP,http: //clisp.cons.org/ ,但我不确定这是否是我要找的.

谁能指出我正确的方向？

我一直在试图解决C++ 11中的移动语义应该如何工作,而且我很难理解移动对象需要满足的条件.看看这里的答案并没有真正解决我的问题,因为无法看到如何以合理的方式将它应用于pimpl对象,尽管移动语义的参数非常适合pimpls.

我的问题最简单的说明涉及pimpl习语,如下所示:

class Foo {
    std::unique_ptr<FooImpl> impl_;
public:
    // Inlining FooImpl's constructors for brevity's sake; otherwise it 
    // defeats the point.
    Foo() : impl_(new FooImpl()) {}

    Foo(const Foo & rhs) : impl_(new FooImpl(*rhs.impl_)) {}

    Foo(Foo && rhs) : impl_(std::move(rhs.impl_)) {}

    Foo & operator=(Foo rhs) 
    {
        std::swap(impl_, rhs.impl_);

        return *this;
    }

    void do_stuff () 
    {
        impl_->do_stuff;
    }
};

现在,一旦我离开了,我该怎么办Foo？我可以安全地销毁移动的物体,我可以分配给它,这两者都绝对是至关重要的.但是,如果我尝试do_stuff使用我的Foo,它会爆炸.在我为我的定义添加移动语义之前Foo,每个人都Foo满足了它的不变性do_stuff,而现在已不再是这样了.目前似乎并没有被大量的替代品,或者说,因为(例如)将被移至距离Foo …

在Mathematica中,我创建了单链表,如下所示:

toLinkedList[x_List] := Fold[pair[#2, #1] &, pair[], Reverse[x]];

fromLinkedList[ll_pair] := List @@ Flatten[ll];

emptyQ[pair[]] := True;
emptyQ[_pair] := False;    

使用paircons单元格的符号具有Flatten安全工作的优点,即使列表包含Mathematica样式List,并允许您使用MakeExpression/ 定义自定义表示法MakeBoxes,这使得一切都更加愉快.为了避免不得不捣乱$IterationLimit,我编写了使用While循环或NestWhile使用递归来处理这些列表的函数.当然,我想看看哪种方法会更快,所以我写了两个候选人,所以我可以看到他们的战斗:

nestLength[ll_pair] := 
 With[{step = {#[[1, -1]], #[[-1]] + 1} &},
  Last@NestWhile[step, {ll, 0}, ! emptyQ@First@# &]];

whileLength[ll_pair] := 
 Module[{result = 0, current = ll},
  While[! emptyQ@current,
   current = current[[2]];
   ++result];
  result];

结果很奇怪.我测试了长度为10000的链表上的函数,whileLength通常快了大约50%,大约0.035秒到nestLength0.055秒.但是,偶尔whileLength需要约4秒钟.我认为可能存在一些缓存行为,所以我开始生成新的随机列表来检查,并且whileLength在第一次运行时使用新列表不一定会很慢; 可能需要几十次才能看到减速,但之后它不会再发生(至少不是我在每个列表中尝试的200次运行).

可能会发生什么？

作为参考,我用于测试的功能是这样的: …

所以,我正在努力自学Scala,而我一直在玩的其中一件事就是Stream上课.我试图使用经典的Haskell版本的Dijkstra解决汉明数字问题的天真翻译:

object LazyHammingBad {
  private def merge(a: Stream[BigInt], b: Stream[BigInt]): Stream[BigInt] =
    (a, b) match {
      case (x #:: xs, y #:: ys) =>
        if (x < y) x #:: merge(xs, b)
        else if (y < x) y #:: merge(a, ys)
        else x #:: merge(xs, ys)
    }

  val numbers: Stream[BigInt] =
    1 #:: merge(numbers map { _ * 2 },
      merge(numbers map { _ * 3 }, numbers map { _ * 5 }))
}

以此为代表解释,导致很快失望: …

如何禁用所有警告sbcl？额外的输出相当烦人.

我试图弄清楚库函数groupBy(来自Data.List)的行为,它声称通过作为第一个参数传入的"相等测试"函数对列表的元素进行分组.类型签名表明,相等性测试只需要具有类型

(a -> a -> Bool)

但是,当我在GHCi 6.6中使用(<)作为"相等测试"时,结果不是我所期望的:

ghci> groupBy (<) [1, 2, 3, 2, 4, 1, 5, 9]
[[1,2,3,2,4],[1,5,9]]

相反,我希望运行严格增加的数字,如下所示:

[[1,2,3],[2,4],[1,5,9]]

我错过了什么？

此问题的灵感来自另一个问题的答案,表明您可以使用定义为以下内容的函数从列表中删除每个元素:

removeall = filter . (/=)

使用铅笔和纸张来处理它的类型filter,(/=)并且(.),该功能有一种类型

removeall :: (Eq a) => a -> [a] -> [a]

这正是你根据合同所期望的.但是,对于GHCi 6.6,我得到了

gchi> :t removeall
removeall :: Integer -> [Integer] -> [Integer]

除非我明确指定类型(在这种情况下它工作正常).为什么Haskell推断出函数的这种特定类型？

是好还是坏,Mathematica提供了丰富的结构,让你做控制的非本地传输,其中Return,Catch/ Throw,Abort和Goto.但是,这些非本地控制转移通常与编写需要确保清理代码(如关闭流)运行的强大程序相冲突.许多语言提供了确保清理代码在各种情况下运行的方法; Java有它的finally块,C++有析构函数,Common Lisp有UNWIND-PROTECT,等等.

在Mathematica,我不知道如何完成同样的事情.我有一个部分解决方案,如下所示:

Attributes[CleanUp] = {HoldAll};
CleanUp[body_, form_] :=
  Module[{return, aborted = False},
   Catch[
    CheckAbort[
     return = body,
     aborted = True];
    form;
    If[aborted,
     Abort[],
     return],
    _, (form; Throw[##]) &]];

这肯定不会赢得任何选美比赛,但它也只能处理Abort和Throw.特别是,它存在失败Return; 我想如果你Goto在Mathematica中使用这种非本地控制你应得的.

我没有看到这方面的好方法.CheckReturn例如,没有,当你接受它时,它Return具有非常模糊的语义.有缺点我不知道吗？

编辑:问题Return及其定义中的模糊性与其与条件的相互作用有关(在某种程度上它不是Mathematica中的"控制结构").一个例子,使用我的CleanUp表单:

CleanUp[
 If[2 == 2,
  If[3 == 3,
   Return["foo"]]];
 Print["bar"],

 Print["cleanup"]]

这将返回"foo"而不打印"cleanup".同样,

CleanUp[
 baz /.
  {bar …

前几天,我遇到了这个结构:

static_cast<size_type>(-1)

在一些示例C++代码中,可能(取决于where的详细信息size_type)等同于以下C:

(size_t)(-1)

据我所知,它的工作原理是二进制补码算术中-1的表示形式,11111...1就像你所拥有的那样多,所以这是获得无符号类型size_t可以容纳的最大值的快速方法.但是,我的理解是C不保证将使用二进制补码; 如果C实现使用一个补码,这将比最大值小1,如果它使用有符号幅度,它将只是最大值的一半.

是否有一些我不知道的皱纹确保无论使用的有符号整数的表示如何都能正常工作？C和C++之间有什么不同(许多令人惊讶的事情都有)？