Rust 什么是;“未实施大小调整”;什么意思?
我编写了以下代码:Rust 什么是;“未实施大小调整”;什么意思?,rust,Rust,我编写了以下代码: use std::io::{IoResult, Writer}; use std::io::stdio; fn main() { let h = |&: w: &mut Writer| -> IoResult<()> { writeln!(w, "foo") }; let _ = h.handle(&mut stdio::stdout()); } trait Handler<W>
use std::io::{IoResult, Writer};
use std::io::stdio;
fn main() {
let h = |&: w: &mut Writer| -> IoResult<()> {
writeln!(w, "foo")
};
let _ = h.handle(&mut stdio::stdout());
}
trait Handler<W> where W: Writer {
fn handle(&self, &mut W) -> IoResult<()>;
}
impl<W, F> Handler<W> for F
where W: Writer, F: Fn(&mut W) -> IoResult<()> {
fn handle(&self, w: &mut W) -> IoResult<()> { (*self)(w) }
}
为什么需要使用此编写器来实现大小调整
?在我看来,不需要大小的。在保留trait Handler
以获得此泛型参数时,我应该做什么
在Rust 1.0中,类似的代码会产生相同的问题:
use std::io::{self, Write};
fn main() {
handle(&mut io::stdout());
}
fn handle(w: &mut Write) -> io::Result<()> {
handler(w)
}
fn handler<W>(w: &mut W) -> io::Result<()>
where
W: Write,
{
writeln!(w, "foo")
}
Rust的更高版本有此错误
error[E0277]:编译时无法知道'dyn std::io::Write'类型的值的大小
-->src/main.rs:8:13
|
8 |装卸工(w)
|^在编译时没有已知的大小
...
11 | fn处理程序(w:&mut w)->io::Result
|----此绑定在`handler'中需要`
|
=help:trait`std::marker::Sized`未为`dyn std::io::Write'实现`
=注意:要了解更多信息,请访问
首先,请注意,h
属于实现Fn(&mut Writer)->IoResult
的类型
h.handle
正在被调用;因此,这取决于处理程序实现,其中W
是Writer
——请注意:W是Writer
,一种未分级的类型。因此,&mut stdio::stdout()
将被强制转换到&mut Writer
trait对象。这在理论上是非常好的,但是当回到实现时,就会失败。当涉及到约束时,默认情况下会调整它们的大小,因此它会抱怨您试图为W
分配的值Writer
,没有调整大小
这里有两个主要的解决方案:
切换到使用h
上的具体书写器类型,以便处理大小不同的类型:
use std::io::{IoResult, Writer, stdio, LineBufferedWriter};
use std::io::stdio::StdWriter;
fn main() {
let h = |&: w: &mut LineBufferedWriter<StdWriter>| -> IoResult<()> {
writeln!(w, "foo")
};
let _ = h.handle(&mut stdio::stdout());
}
trait Handler<W> where W: Writer {
fn handle(&self, &mut W) -> IoResult<()>;
}
impl<W, F> Handler<W> for F
where W: Writer, F: Fn(&mut W) -> IoResult<()> {
fn handle(&self, w: &mut W) -> IoResult<()> { (*self)(w) }
}
我建议支持一个非大小化的W
,即使在这种情况下不使用它,也没有理由需要调整大小。大小化的特性非常特殊,因此在大多数情况下它是类型参数的默认绑定。它表示编译时已知的具有固定大小的值,如u8
(1字节)或&u32
(在具有64位指针的平台上为8字节)等。这些值非常灵活:它们可以放在堆栈上并移动到堆上,通常按值传递,因为编译器知道值在哪里需要多少空间
未调整大小的类型受到更多的限制,类型Writer
的值也没有调整大小:它抽象地表示实现Writer
的一些未指定类型,而不知道实际类型是什么。由于实际类型未知,因此无法知道大小:一些大类型是Writer
s,一些小类型是Writer
是trait对象的一个示例,目前它只能出现在指针后面的已执行代码中。常见的示例包括&Writer
,&mut Writer
,或框
这就解释了为什么默认设置为size
:这通常是一个人想要的
在任何情况下,对于您的代码,这都会弹出,因为您正在使用handle
和h
,这是一个Fn(&mut Writer)->IoResult
。如果我们将其与实现Handle
的F:Fn(&mut W)->IoResult
类型匹配,我们会发现W=Writer
,也就是说,我们试图对trait对象&mut Writer
使用Handle
,而不是对某些具体类型W
使用&mut W
。这是非法的,因为trait和impl中的W
参数默认具有size
绑定,如果我们手动使用?size
覆盖它,则一切正常:
use std::io::{IoResult, Writer};
use std::io::stdio;
fn main() {
let h = |&: w: &mut Writer| -> IoResult<()> {
writeln!(w, "foo")
};
let _ = h.handle(&mut stdio::stdout());
}
trait Handler<W: ?Sized> where W: Writer {
fn handle(&self, &mut W) -> IoResult<()>;
}
impl<W: ?Sized, F> Handler<W> for F
where W: Writer, F: Fn(&mut W) -> IoResult<()> {
fn handle(&self, w: &mut W) -> IoResult<()> { (*self)(w) }
}
使用std::io::{IoResult,Writer};
使用std::io::stdio;
fn main(){
设h=|&w:&mut Writer |->IoResult{
写!(w,“foo”)
};
let=h.handle(&mut stdio::stdout());
}
特征处理程序,其中W:Writer{
fn句柄(&self,&mut W)->IoResult;
}
F的impl处理程序
其中W:Writer,F:Fn(&mut W)->IoResult{
fn句柄(&self,w:&mut w)->IoResult{(*self)(w)}
}
对于Rust 1.0代码:
use std::io::{self, Write};
fn main() {
handle(&mut io::stdout());
}
fn handle(w: &mut Write) -> io::Result<()> {
handler(w)
}
fn handler<W: ?Sized>(w: &mut W) -> io::Result<()>
where
W: Write,
{
writeln!(w, "foo")
}
使用std::io::{self,Write};
fn main(){
句柄(&mut io::stdout());
}
fn句柄(w:&mut Write)->io::Result{
处理程序(w)
}
fn处理程序(w:&mut w)->io::Result
哪里
W:写,
{
写!(w,“foo”)
}
我还写了一篇关于一般对象和特性的文章,其中有一些更详细的内容。非常感谢。我确认你的代码工作正常。我的理解是,size
实现是必需的,因为rust运行时需要知道它在调用堆栈上占用了多少字节。所以,我打算使用指针避免未知大小的类型,在本例中是&mut
。。。我还不能理解在我的代码中哪里需要size
。它不是必需的,正如第二组代码工作所演示的,这只是一个默认值问题:编译器默认在该类型参数上设置size
绑定,因为这是编译器对几乎所有类型参数的定义。哦。我得到了它!很抱歉,我没有完全理解您的回答:“impl默认使用大小的
绑定”。再次感谢你,巴普!
use std::io::{self, Write};
fn main() {
handle(&mut io::stdout());
}
fn handle(w: &mut Write) -> io::Result<()> {
handler(w)
}
fn handler<W: ?Sized>(w: &mut W) -> io::Result<()>
where
W: Write,
{
writeln!(w, "foo")
}