小编Kap*_*chu的帖子

在Rust中(与大多数编程语言一样),%运算符执行余数运算,而不是模运算.这些操作对负数有不同的结果:

-21 modulus 4 => 3
-21 remainder 4 => -1

println!("{}", -21 % 4); // -1

但是,我想要模数.

我找到了一个解决方法((a % b) + b) % b,但如果已有功能,我不想重新发明轮子!

考虑以下代码:

fn main() {
    let i = f32::consts::PI;
}

出现以下错误:

$ rustc --version
rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)
$ rustc -
<anon>:2:13: 2:28 error: ambiguous associated type; specify the type using the syntax `<f32 as Trait>::consts` [E0223]
<anon>:2     let i = f32::consts::PI;
                     ^~~~~~~~~~~~~~~
error: aborting due to previous error

1. 为什么会抱怨"相关类型"？我在这里看到的唯一类型是f32,它没有关联.
2. 为什么这个暧昧？我明确指出了f32.
3. 这是什么<f32 as Trait>::consts语法？我以前从未见过它.
4. 而且,显然,我可以做些什么来修复此错误并将我的变量设置为PI？

可以将结构分配给另一个,这会导致将所有值从struct复制到另一个:

struct
{
    int a, b, c;
} a, b;

...
a = b;

但为什么数组不能像这样分配:

int a[3], b[3];
...
a = b;

因为,严格来说,结构只是具有可变大小元素的数组,那么为什么不允许这样呢？无论如何,这种任务尚未使用.当然,似乎只涉及地址,但可以轻松地复制数组("静态").

简单的问题:在哪里sin()？我已经搜索并仅在锈文档发现有类似的特征std::num::Float是需要罪,但没有实现.

我有一个newtype,我想实现Ord:

use std::cmp::{Ord, Ordering};

struct MyType(isize);

impl Ord for MyType {
    fn cmp(&self, &other: Self) -> Ordering {
        let MyType(ref lhs) = *self;
        let MyType(ref rhs) = *other;
        lhs.cmp(rhs)
    }
}

当我尝试比较我的类型的两个变量时,我得到错误:

error[E0277]: the trait bound `MyType: std::cmp::PartialOrd` is not satisfied
 --> src/main.rs:5:6
  |
5 | impl Ord for MyType {
  |      ^^^ can't compare `MyType` with `MyType`
  |
  = help: the trait `std::cmp::PartialOrd` is not implemented for `MyType`

error[E0277]: the trait bound `MyType: std::cmp::Eq` is not satisfied …

使用repeat我可以创建一个重复一个元素的迭代器.但是,如何无限重复多个值？例如:

let repeat_1 = repeat(1); // 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
let repeat_123 = repeat([1, 2, 3]); // 1, 2, 3, 1, 2, 3, 1, 2, ... // or similar

当一个函数将一系列值作为参数时,它被认为是接受Iterator<T>而不是Vec<T>？的好风格？

这样,调用者可以自己决定如何存储系列(在a Vec,a [T; N]或其他任何内容中,实际上Option<T>应该是可能的!).此外,这消除了将所有内容转换为a的需要Vec,并且在应用一些Iterator修饰符后,.collect()不需要!所以它也应该更快!

我错过了什么或这是应该做的方式吗？

我是否正确地假设"减速" Rc的唯一因素是它检查是否在物体掉落时释放它？除此之外,"多少"是解除引用a的开销Rc,即我应该关注它吗？
这两个功能几乎同样快吗？或者速度有明显差异吗？

fn test_with_box() {
    let b = Box::new(1.0);
    let x = b * 2;
}

fn test_with_rc() {
    let rc = Rc::new(1.0);
    let x = rc * 2;
}

由于引用的对象test_with_rc()始终只有一个引用,并且行为类似于Box该函数(从外部查看,当然不在内部查看).

我怀疑Rcs实际上比我想象的要快.

PS:在谈论"快速"时,我的意思是解除引用和分配/解除分配.

简单的问题:当我打电话glGenTextures(0, someptr);,生成零纹理时会发生什么？我有一个函数,它根据参数给出的数字生成纹理,可能是0.我在OpenGL参考页面,谷歌或StackOverflow中找不到任何东西.它是完全未定义的(甚至没有定义为未定义的行为),因此依赖于驱动程序？

如果你在看官方锈病文档,你看到特质Fn来源于FnMut,或实现Fn,你必须实现FnMut(和之后FnOnce,因为FnMut还提炼出来的).

为什么会这样？我根本无法理解.是因为你可以把每个人Fn称为FnOnce或FnMut？

在相同类型的两个可变位置交换值,而不取消初始化或复制任何一个.

use std::mem;

let x = &mut 5;
let y = &mut 42;

mem::swap(x, y);

assert_eq!(42, *x);
assert_eq!(5, *y);

Run Code Online (Sandbox Code Playgroud)

(来自正式的Rust doc)

如何在不复制的情况下交换两个值？价值42是怎么y来的x？这不应该是可能的.

我有一个struct引用一个值(因为它是?Sized或非常大).当然,这个值必须与结构一起使用.
但是,结构不应该限制用户如何实现它.无论用户是否将值包装在一个Box或者包含Rc它中'static,该值都必须与struct一起生存.使用命名生命周期会很复杂,因为引用将被移动并且可能比我们的生命周期更长struct.我正在寻找的是一般指针类型(如果它存在/可以存在).

只要结构存在,结构如何确保引用的值存在,而不指定如何？

示例(is.gd/Is9Av6):

type CallBack = Fn(f32) -> f32;

struct Caller {
    call_back: Box<CallBack>,
}

impl Caller {
    fn new(call_back: Box<CallBack>) -> Caller {
        Caller {call_back: call_back}
    }

    fn call(&self, x: f32) -> f32 {
        (self.call_back)(x)
    }
}

let caller = {
    // func goes out of scope
    let func = |x| 2.0 * x; 
    Caller {call_back: Box::new(func)}
};

// func survives because …

我想重新解释对可变引用的不可变引用（在不安全的块中）并自行负责安全检查，但似乎我不能mem::transmute()这样做。

let map_of_vecs: HashMap<usize, Vec<_>> = ...;
let vec = map_of_vecs[2];
/// obtain a mutable reference to vec here

• 我不想将Vecs包装到Cells 中，因为这会影响使用的所有其他代码区域，map_of_vecs我只需要一行中的可变性。
• 我没有可变访问权限 map_of_vecs