小编oli*_*obk的帖子

以下代码不会在gcc 4.8.2上编译.问题是此代码将尝试复制构造,std::pair<int, A>这是由于struct A缺少复制和移动构造函数而无法发生的.

gcc在这里失败了还是我错过了什么？

#include <map>
struct A
{
  int bla;
  A(int blub):bla(blub){}
  A(A&&) = delete;
  A(const A&) = delete;
  A& operator=(A&&) = delete;
  A& operator=(const A&) = delete;
};
int main()
{
  std::map<int, A> map;
  map.emplace(1, 2); // doesn't work
  map.emplace(std::piecewise_construct,
          std::forward_as_tuple(1),
          std::forward_as_tuple(2)
  ); // works like a charm
  return 0;
}

我正在寻找在Atom编辑器中创建,构建,运行和调试第一个Rust应用程序的分步说明.

到目前为止,我已经安装了Atom编辑器,安装了软件包language-rust,并且毫无结果地试图在编辑器中找到一个选项来创建Rust"项目"或"包",而我的google-fu失败了.

免责声明:我在Windows上,非常熟悉Visual Studio,不熟悉类似*nix的开发环境,但渴望尝试Rust.

如何禁用cargo update或cargo build尝试访问github.com; 但仍然从中下载相应的包crates.io

我的cargo.toml有一个依赖

[dependencies]
chrono = "0.2.14"

运行 cargo build

E:\>cargo build
    Updating registry `https://github.com/rust-lang/crates.io-index`
Unable to update registry https://github.com/rust-lang/crates.io-index

我们在工作时被 github.com 阻止,但不是crates.io.有没有选项,货物仍然可以下载所需的包,而无需更新它的注册表？

let vec1 = vec![1, 2, 3, 4];
let vec2 = vec![Box::new(1), Box::new(2), Box::new(3), Box::new(4)];

他们之间有什么区别？我已经在堆上分配了vec1.那么vec1的所有元素都不在堆上吗？为什么我需要像在vec2中那样在堆上单独分配它们？

我有一个带有一些基准测试和测试的文件,并希望测试稳定,测试版和夜间测试.但是,要么我不使用基准测试或稳定/ beta投诉.有没有办法在使用stable/beta时隐藏所有基准测试部分？

作为示例,本书中的以下代码:

#![feature(test)]

extern crate test;

pub fn add_two(a: i32) -> i32 {
    a + 2
}

#[cfg(test)]
mod tests {
    use super::*;
    use test::Bencher;

    #[test]
    fn it_works() {
        assert_eq!(4, add_two(2));
    }

    #[bench]
    fn bench_add_two(b: &mut Bencher) {
        b.iter(|| add_two(2));
    }
}

我正在使用rustup并希望使用相同的文件来处理所有构建,调用类似于:

rustup run nightly cargo bench --bin bench --features "bench"
rustup run nightly cargo test --bin bench --features "bench"
rustup run beta cargo test --bin bench
rustup run stable cargo test --bin bench

我可以隐藏#![feature(test)] …

假设我正在尝试使用Rust中的一个花哨的零拷贝解析器&str,但有时我需要修改文本(例如,实现变量替换).我真的想做这样的事情:

fn main() {
    let mut v: Vec<&str> = "Hello there $world!".split_whitespace().collect();

    for t in v.iter_mut() {
        if (t.contains("$world")) {
            *t = &t.replace("$world", "Earth");
        }
    }

    println!("{:?}", &v);
}

但当然String归来的t.replace()人活得不够久.这有什么好办法吗？也许有一种类型意味着"理想情况下,&str但如果必要的话String"？或者也许有一种方法可以使用生命周期注释告诉编译器返回String应该保持活动直到结束main()(或具有相同的生命周期v)？

我很难在Rust看到指针.此代码将无法编译,因为:wrong number of lifetime parameters: expected 1, found 0 [E0107].那是什么意思？

struct Planet<'a> {
    name: &'a str,
    radius_km: i32,
    surface_area_km2: i64,
    orbital_period_days: i32,
    distance_from_sun: i64
}

fn mercury() -> Planet {
    Planet {
        name: "Mercury",
        radius_km: 2_440,
        surface_area_km2: 74_800_000,
        orbital_period_days: 88,
        distance_from_sun: 57_910_000
    }
}

fn main() {
    let mercury = Box::new(mercury());
    println!("{}",mercury.name)
}

Vec提供了一种排序方法(通过Deref实现),但LinkedList没有.在Rust标准库中是否存在允许对LinkedLists 进行排序的通用算法？

我正在尝试学习Rust(低级编程中的新手),并希望将一个小的lv2放大器(音频)插件"amp.c"(C代码)从C转换为Rust.我实际上让它工作(这里),但是当主机终止时,valgrind说"1个块中的64个字节肯定会丢失".我想我知道为什么会这样,但我不知道如何解决它.

在你厌倦阅读之前,这是最后一个问题:

如何静态分配包含C字符串的结构？

以下是介绍:

为什么会发生(我认为): 主机加载库并调用lv2_descriptor()

const LV2_Descriptor*
lv2_descriptor()
{
    return &descriptor;
}

它返回一个指向STATICALLY分配的LV2_Descriptor类型结构的指针,

static const LV2_Descriptor descriptor = {
    AMP_URI,
    ...
};

被定义为

typedef struct _LV2_Descriptor {
    const char * URI;
    ...
} LV2_Descriptor;

为什么静态分配？在amp.c中它说:

最好静态定义描述符,以避免泄漏内存和非可移植共享库构造函数和析构函数以正确清理.

但是,我将lv2_descriptor()翻译为Rust:

#[no_mangle]
pub extern fn lv2_descriptor(index:i32) -> *const LV2Descriptor {
     let s = "http://example.org/eg-amp_rust";
     let cstr = CString::new(s).unwrap();
     let ptr = cstr.as_ptr();
     mem::forget(cstr);

     let mybox = Box::new(LV2Descriptor{amp_uri: ptr}, ...);
     let bxptr = &*mybox as *const LV2Descriptor; 
     mem::forget(mybox);
     return  bxptr …

我试图实现IntoIterator的[T; N].我用Default和swap(PlayPen)写了一个完全安全的版本.然后,我把它移植使用uninitialized,ptr::copy,Drop和forget(围栏).我的Iterator结构如下所示:

struct IntoIter<T> {
    inner: Option<[T; N]>,
    i: usize,
}
impl<T> Iterator for IntoIter<T> { ... }

由于我不想为每个值创建一个Iterator结构N,我将结构更改为

struct IntoIter<U> {
    inner: Option<U>,
    i: usize,
}
impl<T> Iterator for IntoIter<[T; N]> { ... }

显然我必须调整Iterator和Drop实现(PlayPen).

但现在我以某种方式介绍了未定义的行为.根据printlns,优化水平或黄道标志发生或不发生恐慌.

thread '<main>' panicked at 'index out of bounds: the len is 5 but …