小编tre*_*tcl的帖子

int main()
{
   char myString = NULL;
   realloc(&myString, 5);
   strncpy((char *)&myString, "test", 5);
}

似乎工作正常,但我仍然有点困惑堆栈与堆,这是允许的吗？myString是否需要手动释放,还是在超出范围时释放？

编辑:感谢您的回复,所以我认为这同样是非法的

//I want the code to change myString to "tests"
char myString[5] = "test";
realloc(&myString, strlen(myString)+2);
myString[4] = 's';
myString[5] = '\0';

我正在努力与借阅检查员 - 不知道为什么.

虽然我通过添加一个闭包找到了一个解决方案,但我很好奇是否有其他方法可以结束可变借用,因此下一个语句可以在之后访问绑定.

这是我到目前为止所做的:

let mut canvas: Canvas = Canvas {
    width: 5,
    height: 5,
    array: vec!['x'; 5*5],
};

{
    let mut renderer: CanvasRenderer = CanvasRenderer::new(&mut canvas);

    renderer.render_point('x', 3, 3);
}

println!("The Value in the array is: {}", canvas.array[9]);

我在一个CanvasRenderer对象的绑定周围包裹了一个闭包,在改变了画布并且范围结束之后,可以读取CanvasRenderer模具和我的可变借用canvas或其他任何东西.

这有效 - 但现在我想看到其他解决方案!

我听说过,drop(stuff)但它没有按照我的想法行事.

这样可行:

let hello = "Hello ".to_string();
let world = "world!";

let hello_world = hello + world;

但这不是:

let hello = "Hello ".to_string();
let world = "world!".to_string();

let hello_world = hello + world;

但这样做:

let hello = "Hello ".to_string();
let world = "world!".to_string();

let hello_world = hello + &world;

那是因为String需要一个指向String第二个原始的指针String吗？如果是这样,为什么？

我有一个Vec<i64>，我想知道所有连续的整数组。举个例子：

let v = vec![1, 2, 3, 5, 6, 7, 9, 10];

我期待这样或类似的事情：

[[1, 2, 3], [5, 6, 7], [9, 10]];

视图（向量的向量或者元组或其他东西）真的无关紧要，但我应该得到几个具有连续数字的分组列表。

乍一看，似乎我需要使用 itertools 和该group_by函数，但我不知道如何...

以下程序工作正常：

pub fn foo(_v: &str) -> bool {
    false
}

fn main() {
    let f = "hello world";
    println!("{}", foo(&&&&f)); // note the number of & here
}

事实上，它适用于传递任意数量的&. 我应该如何解释正在发生的事情？

我的锈版：

$ rustc --version
rustc 1.32.0-nightly (13dab66a6 2018-11-05)

我试图写一个有趣的词法分析器,但有些东西一直困扰着我.

let mut chars: Vec<char> = Vec::new();
let mut contents = String::new();
let mut tokens: Vec<&String> = Vec::new();
let mut append = String::new();
//--snip--
for _char in chars {
    append += &_char.to_string();
    append = append.trim().to_string();

    if append.contains("print") {
        println!("print found at: \n{}", append);
        append = "".to_string();
    }
}

任何时候,我想做为一个附加一些简单&str的String我不得不使用它转换.to_string,String::from(),.to_owned,等.

有什么我做错了,所以我不必经常这样做,或者这是追加的主要方式？

当泛型函数需要一个参数为时T，为什么它要使用参数为&mut T？

我试图使用serialize_into和serialize_from在bincode板条箱中将字符串序列化到文件。签名是

pub fn serialize_into<W, T: ?Sized>(writer: W, value: &T) -> Result<()>
where
    W: std::io::Write,
    T: serde::Serialize

和

pub fn deserialize_from<R, T>(reader: R) -> Result<T>
where
    R: std::io::Read,
    T: serde::de::DeserializeOwned

我尝试使用std::BufWriter和进行序列化，BufReader但似乎只能使用&mut BufWriter。

考虑一下：

use bincode;
use std::io::{BufWriter, BufReader};
use std::fs::File;

fn main() {
    let x = String::from("hello");
    let mut f1 = BufWriter::new(File::create("foo.txt").unwrap()); 
    bincode::serialize_into( &mut f1, &x).unwrap();
    let  mut f2 = BufReader::new(File::open("foo.txt").unwrap());
    let  y: …

我想在使用实例时跳过任意数量的字节Read而不进行任何分配。跳过之后，我需要继续阅读后面的数据。

字节数在编译时未知，因此我无法创建固定数组。Read也没有跳过，所以我似乎需要阅读一些内容。我不想使用BufReader和分配不必要的缓冲区，也不想逐字节读取，因为这样效率低下。

还有其他选择吗？

我有以下 Pest ( https://pest.rs ) 语法

name = {ASCII_ALPHA+}
fragment = { "fragment" ~ name }

当我尝试fragment name使用它进行解析时，我收到此错误：

 --> 1:9
  |
1 | fragment name
  |         ^---
  |
  = expected name

我正在寻找构建一个将被复制到 RAM 并发送到 LCD 驱动程序的数组。我希望能够传入一个颜色值 ( color: u16) 并使用它来填充数组。请注意，我正在使用#![no_std]因为这是用于嵌入式应用程序的。

显而易见的简单方法如下：

let mut block: [u8;256] = [0; 256];
for i in (0..block.len()).step_by(2) {
    block[i] = ((color && 0xFF00) >> 8) as u8;
    block[i+1] = (color && 0xFF) as u8;
}

由于我更多的个人经验来自 C，我想知道是否有使用类型转换和转换的更好的解决方案。例如，使用 Rust 初始化 u16 数组并转换为 u8 数组：

let block_u16: [u16; 128] = [color; 128]
let block_u8 = block_u16 as [u8; 256];

作为参考，目标函数原型为：

spi::setup_block(block: &[u8]);