javascript

java

python

c#

android

c++

node.js

php

html

jquery

ios

reactjs

css

.net

git

ruby-on-rails

sql

c

ruby

string

锈-将地图与向量配合使用

尽管向量最适合过程编程,但我想在其上使用3006144335285281914880函数。 以下代码段有效:

fn map<A, B>(u: &Vec<A>, f: &Fn(&A) -> B) -> Vec<B> {
    let mut res: Vec<B> = Vec::with_capacity(u.len());
    for x in u.iter() {
        res.push(f(x));
    }
    res
}

fn f(x: &i32) -> i32 {
    *x + 1
}

fn main() {
    let u = vec![1, 2, 3];
    let v = map(&u, &f);
    println!("{} {} {}", v[0], v[1], v[2]);
}

为什么标准库中没有这样的功能? (以及std::collections::LinkedList)。 还有另一种处理方法吗?

trans by 2020-08-11T03:51:14Z

锈-如何为一个简单的结构实现Iterator和IntoIterator?

有人将如何为以下结构实现IteratorIntoIterator特征?

struct Pixel {
    r: i8,
    g: i8,
    b: i8,
}

我尝试了以下各种形式的尝试,但均未成功。

impl IntoIterator for Pixel {
    type Item = i8;
    type IntoIter = Iterator<Item=Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        [&self.r, &self.b, &self.g].into_iter()
    }
}

这段代码给我一个编译错误

error[E0277]: the trait bound `std::iter::Iterator<Item=i8> + 'static: std::marker::Sized` is not satisfied
 --> src/main.rs:7:6
  |
7 | impl IntoIterator for Pixel {
  |      ^^^^^^^^^^^^ the trait `std::marker::Sized` is not implemented for `std::iter::Iterator<Item=i8> + 'static`
  |
  = note: `std::iter::Iterator<Item=i8> + 'static` does not have a constant size known at compile-time
  = note: required by `std::iter::IntoIterator`
trans by 2020-08-11T03:40:09Z

rust-安装rustup后未配置默认工具链

我使用rustup安装了Rust,但是当我尝试在控制台中输入cargorustc之类的Rust命令时,出现以下错误:

error: no default toolchain configured

这是一个已知的问题? 我正在使用Windows 7。

trans by 2020-08-11T02:06:08Z

锈-为什么要尝试!()和? 在不返回Option或Result的函数中使用时无法编译?

为什么此代码无法编译?

use std::{fs, path::Path};

fn main() {
    let dir = Path::new("../FileSystem");

    if !dir.is_dir() {
        println!("Is not a directory");
        return;
    }

    for item in try!(fs::read_dir(dir)) {
        let file = match item {
            Err(e) => {
                println!("Error: {}", e);
                return;
            }
            Ok(f) => f,
        };

        println!("");
    }

    println!("Done");
}

这是我得到的错误

error[E0308]: mismatched types
  --> src/main.rs:11:17
   |
11 |     for item in try!(fs::read_dir(dir)) {
   |                 ^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum `std::result::Result`
   |
   = note: expected type `()`
              found type `std::result::Result<_, _>`
   = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)

我还尝试了问号运算符:

for item in fs::read_dir(dir)? {

哪个有不同的错误:

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
  --> src/main.rs:11:17
   |
11 |     for item in fs::read_dir(dir)? {
   |                 ^^^^^^^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
   |
   = help: the trait `std::ops::Try` is not implemented for `()`
   = note: required by `std::ops::Try::from_error`

Rust的早期版本具有类似的错误,大约为for

我应该避免for?吗? 处理错误的最佳方法是什么? 通常,我这样做是这样的:

match error_prone {
    Err(e) => {
        println!("Error: {}", e);
        return;
    },
    Ok(f) => f,
};

但是如果我必须在for循环中使用它,那就太麻烦了

for i in match error_prone {
    // match code
} {
    // loop code
}
trans by 2020-08-10T08:04:23Z

锈-通过引用将值传递给函数与通过Box传递值之间有什么区别?

通过引用将值传递给函数并将其“按Box”传递给函数有什么区别:

fn main() {
    let mut stack_a = 3;
    let mut heap_a = Box::new(3);

    foo(&mut stack_a);
    println!("{}", stack_a);

    let r = foo2(&mut stack_a);
    // compile error if the next line is uncommented
    // println!("{}", stack_a);

    bar(heap_a);
    // compile error if the next line is uncommented
    // println!("{}", heap_a);
}

fn foo(x: &mut i32) {
    *x = 5;
}

fn foo2(x: &mut i32) -> &mut i32 {
    *x = 5;
    x
}

fn bar(mut x: Box<i32>) {
    *x = 5;
}

为什么将heap_a移到函数中,却没有将bar移入函数中(在foo调用之后的foo语句中仍可使用main)?

取消注释heap_a时的错误:

error[E0502]: cannot borrow `stack_a` as immutable because it is also borrowed as mutable
  --> src/main.rs:10:20
   |
8  |     let r = foo2(&mut stack_a);
   |                       ------- mutable borrow occurs here
9  |     // compile error if the next line is uncommented
10 |     println!("{}", stack_a);
   |                    ^^^^^^^ immutable borrow occurs here
...
15 | }
   | - mutable borrow ends here

我认为可以通过引用生命周期来解释此错误。 对于heap_a,将bar(在main函数中)移至函数foo,但是编译器发现函数foox: &mut i32的参数的生存期在foo的结尾处结束,因此,让我们使用变量 在foo返回之后,在main函数中的stack_a。 在foo2的情况下,stack_a也移至该函数,但我们也将其返回。

为什么heap_a的生命周期不会在bar的末尾结束?

trans by 2020-08-02T14:30:35Z

锈-如何更新可变HashMap中的值?

这是我想做的事情:

use std::collections::HashMap;

fn main() {
    let mut my_map = HashMap::new();
    my_map.insert("a", 1);
    my_map.insert("b", 3);

    my_map["a"] += 10;
    // I expect my_map becomes {"b": 3, "a": 11}
}

但这会引发错误:

锈2015

error[E0594]: cannot assign to immutable indexed content
 --> src/main.rs:8:5
  |
8 |     my_map["a"] += 10;
  |     ^^^^^^^^^^^^^^^^^ cannot borrow as mutable
  |
  = help: trait `IndexMut` is required to modify indexed content, but it is not implemented for `std::collections::HashMap<&str, i32>`

锈2018

error[E0594]: cannot assign to data in a `&` reference
 --> src/main.rs:8:5
  |
8 |     my_map["a"] += 10;
  |     ^^^^^^^^^^^^^^^^^ cannot assign

我真的不明白这意味着什么,因为我将HashMap设为可变。 当我尝试更新vector中的元素时,得到了预期的结果:

let mut my_vec = vec![1, 2, 3];

my_vec[0] += 10;
println! {"{:?}", my_vec};
// [11, 2, 3]

我收到上述错误的HashMap有何不同? 有没有更新值的方法?

trans by 2020-07-31T00:01:53Z

如何下载Rust API文档?

有什么方法可以下载Rust的API库文档或生成它们吗? 我可以在Rust源中找到的唯一文档是rustdoc

我正在运行每晚构建,因此我确定有一种方法可以使用rustdoc以与标准文档相同的方式生成所有文档,但我找不到它!

我正在运行Linux,使用以下命令进行夜间构建:

curl -s https://static.rust-lang.org/rustup.sh | sudo sh
trans by 2020-07-27T18:09:01Z

io-如何在Rust中读取用户输入?

编者注:这个问题是指Rust早于Rust 1.0的部分,但一般概念在Rust 1.0中仍然有效。

我打算做一个标记器。 我需要阅读用户键入的每一行,并在用户按ctrl-D时停止阅读。

我四处搜索,仅在Rust IO上找到一个甚至没有编译的示例。 我查看了io模块的文档,发现29769032199719970049025函数是ReaderUtil接口的一部分,但stdin()返回了Reader

我想要的代码基本上看起来像C ++中的以下代码

vector<string> readLines () {
    vector<string> allLines;
    string line;

    while (cin >> line) {
        allLines.push_back(line);
    }

    return allLines;
}
trans by 2020-07-21T23:42:57Z

Rust如何实现反射?

Rust具有TypeId的特征,但是它也具有“不为不使用的产品付款”政策。 Rust如何实现反射?

我的猜测是Rust使用了惰性标记。 最初未分配每种类型,但是如果以后将该类型的实例传递给期望具有TypeId特征的函数,则会为该类型分配TypeId

或者,Rust在其实例可能传递给该函数的每种类型上都添加了TypeId? 我猜前者会很昂贵。

trans by 2020-07-20T10:12:36Z

锈-什么是typestate?

TypeState在语言设计方面指的是什么? 在有关Mozilla称为Rust的新语言的一些讨论中,我看到了它。

trans by 2020-07-13T07:56:49Z

如何将C字符串转换为Rust字符串并通过FFI返回?

我正在尝试获取C库返回的C字符串,并通过FFI将其转换为Rust字符串。

mylib.c

const char* hello(){
    return "Hello World!";
}

main.rs

#![feature(link_args)]

extern crate libc;
use libc::c_char;

#[link_args = "-L . -I . -lmylib"]
extern {
    fn hello() -> *c_char;
}

fn main() {
    //how do I get a str representation of hello() here?
}
trans by 2020-07-03T10:17:14Z

如何使用字符串成员创建Rust结构?

我希望成员归该结构所有。 很抱歉这个简单的问题,但是我找不到一个例子。 我正在寻找结构和实例化示例的正确声明。

trans by 2020-07-01T17:56:00Z

调试-用于Rust的分步交互式调试器?

如何像在Ruby中使用“撬”一样逐步地逐步调试Rust应用程序?

我希望能够在达到断点时实时查看并最好实时更改变量。 是否有任何生产准备完成的项目?

trans by 2020-06-29T18:27:19Z

时间-俄罗斯的基准测试程序

如何在Rust中对程序进行基准测试? 例如,如何获得以秒为单位的程序执行时间?

trans by 2020-06-26T21:50:40Z

Rust的一生

有时我发现自己想编写可以通过以下两种方式之一调用的函数:

// With a string literal:
let lines = read_file_lines("data.txt");

// With a string pointer:
let file_name = ~"data.txt";
let lines = read_file_lines(file_name);

我的第一个猜测是对参数类型使用借来的指针('self),但是当这种方法不起作用(它只允许我使用&'a str和2933897813618590790722)时,我尝试了以下操作(通过复制Rust库), 工作。

fn read_file_lines<'a>(path: &'a str) -> ~[~str] {
    let read_result = file_reader(~Path(path));
    match read_result {
        Ok(file) => file.read_lines(),
        Err(e) => fail!(fmt!("Error reading file: %?", e))
    }
}

问题是我不明白自己在做什么。 根据我的收集(主要是由于编译器错误),我声明了一个不受限制的生存期,并使用它来描述path参数(意味着可以将任何生存期都作为参数传递)。

所以:

  • 我的理解模糊不清吗?
  • 什么是一生? 在哪里可以了解更多有关它们的信息?
  • 在上面的示例中,'self类型的参数与&'a str类型的参数有什么区别?
  • 而当我坐在那里时,什么是'self

(我正在使用Rust 0.7,如果对答案有所帮助)

trans by 2020-06-22T07:41:17Z

字符串-Rust中的r#“”#运算符是什么?

我在Rust中看到运算符r#"",但找不到它的作用。 它对于创建JSON非常有用:

let var1 = "test1";
let json = r#"{"type": "type1", "type2": var1}"#;
println!("{}", json) // => {"type2": "type1", "type2": var1}

运算符r#""的名称是什么? 如何进行var1评估?

trans by 2020-06-21T16:50:59Z

锈-如何定义仅测试依赖项?

我有一个实现lint插件的Rust库。 我想包括compiletest,但在测试之外不需要它。 指定依赖项仅用于测试的正确方法是什么?

trans by 2020-02-19T23:50:34Z

如何编写一个带迭代器的Rust函数?

我想编写一个接受迭代器并返回一些操作结果的函数。 具体来说,我正在尝试迭代Box的值:

use std::collections::HashMap;

fn find_min<'a>(vals: Iterator<Item=&'a u32>) -> Option<&'a u32> {
    vals.min()
}

fn main() {
    let mut map = HashMap::new();
    map.insert("zero", 0u32);
    map.insert("one", 1u32);
    println!("Min value {:?}", find_min(map.values()));
}

可惜:

error: the `min` method cannot be invoked on a trait object
 --> src/main.rs:4:10
  |
4 |     vals.min()
  |          ^^^

error[E0277]: the trait bound `std::iter::Iterator<Item=&'a u32> + 'static: std::marker::Sized` is not satisfied
 --> src/main.rs:3:17
  |
3 | fn find_min<'a>(vals: Iterator<Item = &'a u32>) -> Option<&'a u32> {
  |                 ^^^^ `std::iter::Iterator<Item=&'a u32> + 'static` does not have a constant size known at compile-time
  |
  = help: the trait `std::marker::Sized` is not implemented for `std::iter::Iterator<Item=&'a u32> + 'static`
  = note: all local variables must have a statically known size

error[E0308]: mismatched types
  --> src/main.rs:11:41
   |
11 |     println!("Min value {:?}", find_min(map.values()));
   |                                         ^^^^^^^^^^^^ expected trait std::iter::Iterator, found struct `std::collections::hash_map::Values`
   |
   = note: expected type `std::iter::Iterator<Item=&u32> + 'static`
              found type `std::collections::hash_map::Values<'_, &str, u32>`

如果我尝试通过引用,则会遇到相同的错误; 如果我使用Box,则会收到终身错误。

trans by 2020-02-18T12:57:09Z

语法-将“ mut”放在变量名之前和“:”之后有什么区别?

这是我在Rust文档中看到的两个函数签名:

fn modify_foo(mut foo: Box<i32>) { *foo += 1; *foo }
fn modify_foo(foo: &mut i32) { *foo += 1; *foo }

为什么放置mut不同?

似乎第一个函数也可以声明为

fn modify_foo(foo: mut Box<i32>) { /* ... */ }
trans by 2020-02-16T10:13:16Z

指针-Box,ref和&和*之间的理解和关系

我对指针在Rust中的工作方式有些困惑。 有*let y: i32 = 4; let x = &y as *const i32**,但我不确定它们如何协同工作。

这是我目前的理解:

  1. *并不是真正的指针-这是一种在堆上分配数据并在函数参数中传递大小不一的类型(尤其是特征)的方法。
  2. *用于模式匹配,以借用您匹配的内容,而不是采用它。 例如,

    *
  3. *用于借入(借入的指针)。 如果我有一个函数let y: i32 = 4; let x = &y as *const i32,那么我引用的是我自己,该函数将在函数终止后到期,而不再保留调用者的数据。 通过执行*,我还可以传递要保留所有权的数据。

  4. *用于制作原始指针:例如let y: i32 = 4; let x = &y as *const i32。我了解C / C ++中的指针,但不确定如何将其与Rust的类型系统一起使用以及如何安全使用它们。 我也不确定这种指针的用例是什么。 此外,*符号可用于取消引用事物(什么事物,为什么?)。

有人可以解释指向我的第四种指针,并验证我对其他类型的理解是否正确吗? 我还要感谢任何指出我没有提到的常见用例的人。

trans by 2020-02-09T13:00:26Z

1 2 3 4 5 下一页 共5页