小编lou*_*ear的帖子

当比较取决于数据而不是比较项目的一部分时,如何实现Ord?

我有一个只包含以下内容的小结构i32:

struct MyStruct {
   value: i32,
}
Run Code Online (Sandbox Code Playgroud)

我想实现Ord,以便存储MyStruct一个BTreeMap或任何其他需要您拥有Ord其元素的数据结构.

在我的例子中,比较两个实例MyStruct并不依赖value于它们中的s,而是要求另一个数据结构(字典),并且该数据结构对于BTreeMap我将创建的每个实例都是唯一的.理想情况下,它看起来像这样:

impl Ord for MyStruct {
    fn cmp(&self, other: &Self, dict: &Dictionary) -> Ordering {
        dict.lookup(self.value).cmp(dict.lookup(other.value))
    }
}
Run Code Online (Sandbox Code Playgroud)

然而,这是不可能的,因为Ord实现只能访问两个实例MyStruct,仅此而已.

一种解决方案是存储指向字典的指针,MyStruct但这样做太过分了.MyStruct应该是一个简单的包装器,指针会增加一倍.另一个解决方案是使用静态全局,但这也不是一个好的解决方案.

在C++中,解决方案很简单:大多数STL算法/数据结构允许您传递比较器,它可以是具有某种状态的函数对象.所以我相信Rust会有一个成语来以某种方式匹配它,有什么方法可以实现这一点吗?

traits rust

11
推荐指数
2
解决办法
359
查看次数

为什么不同的标题具有相同的名称?

我有几个副本,比方说,stddef.h我的系统,一个在路径中/usr/include/linux/stddef.h,看起来像这样:

#ifndef _LINUX_STDDEF_H
#define _LINUX_STDDEF_H

#undef NULL
#if defined(__cplusplus)
#define NULL 0
#else
#define NULL ((void *)0)
#endif

#endif
Run Code Online (Sandbox Code Playgroud)

另一个是在路径中/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5/include/,那是我说的时候使用的那个#include <stddef.h>.一个人的内容是从第一个很不一样的,包含的定义ptrdiff_t,size_t等等.

我的问题是:据我所知,C/C++标准要求size_t应该放置定义stddef.h,但第一个不遵循.那个显然不是C/C++标准提到的那个.如果该文件出于某些其他目的,为什么这两个文件都被命名为stddef.h,如果它们有不同的名称,它们会不会更安全/更清晰?

c gcc

7
推荐指数
1
解决办法
1253
查看次数

延迟评估期间的记忆

计算机程序的结构和解释一书介绍了一个记忆过程如下:

(define (memo-proc proc)
  (let ((already-run? false) (result false))
    (lambda ()
      (if (not already-run?)
          (begin (set! result (proc))
                 (set! already-run? true)
                 result)
         result))))
Run Code Online (Sandbox Code Playgroud)

在提出延迟执行的定义的同时,(delay <exp>)(memo-proc (lambda () <exp>))。可以使用以下过程强制延迟对象:

(define (force delayed-object)
  (delayed-object))
Run Code Online (Sandbox Code Playgroud)

在给出这些定义的章节中,计算是使用流完成的。每个流都是一对,有一个头部和一个延迟尾部。

但是,我不知道如何在不使用查找表或其他累积先前调用的数据结构的情况下实现记忆化。

包括这些定义的章节在这里

当我们用各种参数记住单个过程时,查找表会很有用。然后,我们将参数作为键,将过程的结果作为值。在这种情况下,我们有空过程,因此我们不需要查找表。我们所需要的只是我们迄今为止创建的一组延迟对象。但是,这里使用了闭包。

根据memo-proc上面的定义,每个延迟对象实际上是一个带有值already-run?和的闭包result,它们都初始化为false。但是,由于调用中的每个延迟对象proc都有自己的闭包和自己的本地already-run?result,因此修改它们不会更改调用树中的其他对象。因此,我觉得任何其他程序都不会再读取记忆值。

所以我的问题是,我在想什么,或者对一切如何运作的正确解释是什么?

scheme stream memoization sicp delayed-execution

6
推荐指数
1
解决办法
484
查看次数

为什么我的结构不够长寿?

在Rust中,我收到以下错误:

<anon>:14:9: 14:17 error: `mystruct` does not live long enough
<anon>:14         mystruct.update();
                  ^~~~~~~~
<anon>:10:5: 17:6 note: reference must be valid for the lifetime 'a as defined on the block at 10:4...
<anon>:10     {
<anon>:11         let initial = vec![Box::new(1), Box::new(2)];
<anon>:12         let mystruct = MyStruct { v : initial, p : &arg };
<anon>:13         
<anon>:14         mystruct.update();
<anon>:15         
          ...
<anon>:12:59: 17:6 note: ...but borrowed value is only valid for the block suffix following statement 1 at 12:58
<anon>:12         let mystruct = MyStruct …
Run Code Online (Sandbox Code Playgroud)

lifetime rust

5
推荐指数
1
解决办法
517
查看次数

这个功能复杂吗?

我不确定以下问题:

对于常数a,b,是否在O(log b(n a))中记录a(n b)?

complexity-theory

3
推荐指数
1
解决办法
161
查看次数

函数"mem_fun_t"的名称

mem_fun_tSTL 的"t"前缀代表什么?

mem_fun和之间的区别在于mem_fun_t第一个是返回第二个对象的函数,但它与"类"有什么关系?

c++ stl

0
推荐指数
1
解决办法
200
查看次数