Rust 特性绑定'T:std:：fmt:：Display'不满足
我正在写一个基本的二叉树结构，我想显示一个节点。Rust似乎在显示泛型类型时遇到了问题，我得到了以下错误：Rust 特性绑定'T:std:：fmt:：Display'不满足,rust,Rust,我正在写一个基本的二叉树结构，我想显示一个节点。Rust似乎在显示泛型类型时遇到了问题，我得到了以下错误： error[E0277]：不满足特性绑定'T:std:：fmt:：Display' -->src/main.rs:55:60 | 55 |写吧！（f，“节点数据：{}左：{：？}，右：{：？}”，self.data，self.left，self.right）； |^^^^^^^^^^trait`T:std:：fmt:：Display`不满意 | =帮助：考虑添加一个“T：STD：：FMT：
error[E0277]：不满足特性绑定'T:std:：fmt:：Display'
-->src/main.rs:55:60
|
55 |写吧！（f，“节点数据：{}左：{：？}，右：{：？}”，self.data，self.left，self.right）；
|^^^^^^^^^^trait`T:std:：fmt:：Display`不满意
|
=帮助：考虑添加一个“T：STD：：FMT：：显示”绑定
=注意：std:：fmt:：Display:：fmt所需`
错误[E0277]：未满足特性绑定'T:std:：fmt:：Display'
-->src/main.rs:62:60
|
62 |写吧！（f，“节点数据：{}左：{：？}，右：{：？}”，self.data，self.left，self.right）；
|^^^^^^^^^^trait`T:std:：fmt:：Display`不满意
|
=帮助：考虑添加一个“T：STD：：FMT：：显示”绑定
=注意：std:：fmt:：Display:：fmt所需`
struct Node<T> {
data: T,
left: Option<Box<Node<T>>>,
right: Option<Box<Node<T>>>,
}
struct NodeIterator<T> {
nodes: Vec<Node<T>>,
}
struct Tree<T> {
root: Option<Node<T>>,
}
impl<T> Node<T> {
pub fn new(value: Option<T>,
left: Option<Box<Node<T>>>,
right: Option<Box<Node<T>>>)
-> Node<T> {
Node {
data: value.unwrap(),
left: left,
right: right,
}
}
pub fn insert(&mut self, value: T) {
println!("Node insert");
match self.left {
Some(ref mut l) => {
match self.right {
Some(ref mut r) => {
r.insert(value);
}
None => {
self.right = Some(Box::new(Node::new(Some(value), None, None)));
}
}
}
None => {
self.left = Some(Box::new(Node::new(Some(value), None, None)));
}
}
}
}
impl<T> std::fmt::Display for Node<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f,
"Node data: {} left: {:?}, right: {:?}",
self.data,
self.left,
self.right);
}
}
impl<T> std::fmt::Debug for Node<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f,
"Node data: {} left: {:?}, right: {:?}",
self.data,
self.left,
self.right);
}
}
impl<T> Iterator for NodeIterator<T> {
type Item = Node<T>;
fn next(&mut self) -> Option<Node<T>> {
if self.nodes.len() == 0 {
None
} else {
let current: Option<Node<T>> = self.nodes.pop();
for it in current.iter() {
for n in it.left.iter() {
self.nodes.push(**n);
}
for n in it.right.iter() {
self.nodes.push(**n);
}
}
return current;
}
}
}
impl<T> Tree<T> {
pub fn new() -> Tree<T> {
Tree { root: None }
}
pub fn insert(&mut self, value: T) {
match self.root {
Some(ref mut n) => {
println!("Root is not empty, insert in node");
n.insert(value);
}
None => {
println!("Root is empty");
self.root = Some(Node::new(Some(value), None, None));
}
}
}
fn iter(&self) -> NodeIterator<T> {
NodeIterator { nodes: vec![self.root.unwrap()] }
}
}
fn main() {
println!("Hello, world!");
let mut tree: Tree<i32> = Tree::new();
tree.insert(42);
tree.insert(43);
for it in tree.iter() {
println!("{}", it);
}
}
struct节点{
数据：T，
左：选项，
右：选项，
}
结构节点转换器{
节点：Vec，
}
结构树{
根：选项，
}
impl节点{
发布fn新（值：选项，
左：选项，
右：选项）
->节点{
节点{
数据：value.unwrap（），
左:左,，
对:对，
}
}
发布fn插入（&mut self，值：T）{
println！（“节点插入”）；
左配{
一些（参考mut l）=>{
匹配自我，对吗{
一些（参考mut r）=>{
r、 插入（价值）；
}
无=>{
self.right=Some（Box:：new（Node:：new（Some（value），None，None））；
}
}
}
无=>{
self.left=Some（Box:：new（Node:：new（Some（value），None，None））；
}
}
}
}
impl std:：fmt:：节点的显示{
fn fmt（&self，f:&mut std:：fmt:：Formatter）->std:：fmt:：Result{
写！（f，
“节点数据：{}左：{：？}，右：{：？}”，
自我数据，
自左，
自身（对）；
}
}
节点的impl std:：fmt:：调试{
fn fmt（&self，f:&mut std:：fmt:：Formatter）->std:：fmt:：Result{
写！（f，
“节点数据：{}左：{：？}，右：{：？}”，
自我数据，
自左，
自身（对）；
}
}
节点迭代器的impl迭代器{
类型项=节点；
fn下一步（&mut self）->选项{
如果self.nodes.len（）=0{
没有一个
}否则{
让当前：Option=self.nodes.pop（）；
在current.iter（）{
对于其中的n.left.iter（）{
self.nodes.push（**n）；
}
对于其中的n。对。iter（）{
self.nodes.push（**n）；
}
}
回流；
}
}
}
impl树{
pub fn new（）->树{
树{根：无}
}
发布fn插入（&mut self，值：T）{
匹配self.root{
一些（参考mut n）=>{
println！（“根不是空的，插入节点”）；
n、 插入（价值）；
}
无=>{
println！（“根为空”）；
self.root=Some（节点：：new（Some（value），None，None））；
}
}
}
fn iter（&self）->节点转换器{
节点运算符{nodes:vec！[self.root.unwrap（）]}
}
}
fn main（）{
println！（“你好，世界！”）；
让mut-tree:tree=tree:：new（）；
插入（42）；
插入（43）；
因为它在树上{
println！（“{}”，it）；
}
}
struct Bob<T>(T);
impl<T> std::fmt::Display for Bob<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: {}", self.0)
}
}
fn main() {
let x = Bob(4);
println!("{}", x);
}
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: ")?;
std::fmt::Display::fmt(&self.0, f)
}
write！format！println！“{}”Displayself.0fmtTDisplayBobDisplay实现添加约束T:std:：fmt:：Display
。这将允许我们将结构与非Display
类型一起使用，但是Display
仅在与Display
类型一起使用时才会实现
该修复程序如下所示：
impl<T: std::fmt::Display> std::fmt::Display for Bob<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: {}", self.0)
}
}
struct Bob<T: std::fmt::Display>(T);
只有这样，我们才需要确保T
是std:：fmt:：Debug
以下是此问题的一个版本：
struct Bob<T>(T);
impl<T> std::fmt::Display for Bob<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: {}", self.0)
}
}
fn main() {
let x = Bob(4);
println!("{}", x);
}
为了更清晰，我们可以将其改写如下：
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: ")?;
std::fmt::Display::fmt(&self.0, f)
}
调用一个带有双括号的格式化宏（write！
，format！
，println！
，等等），“{}”
，表示从该参数的Display
trait（self.0
）调用fmt
函数
问题是我们有一些泛型类型T
，因此编译器不知道是否为它实现了Display
有两种方法可以解决这个问题
首先，我们可以为Bob
的Display实现添加约束T:std:：fmt:：Display
。这将允许我们将结构与非Display
类型一起使用，但是Display
仅在与Display
类型一起使用时才会实现
该修复程序如下所示：
impl<T: std::fmt::Display> std::fmt::Display for Bob<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Bob: {}", self.0)
}
}
struct Bob<T: std::fmt::Display>(T);
只有这样，我们才需要确保T
是std:：fmt:：Debug
您需要提供其中T: