Question

我正在编写一个基本的二叉树结构，我想显示一个节点。看起来Rust在显示泛型类型时遇到了麻烦，我收到了这个错误：

error[E0277]: the trait bound `T: std::fmt::Display` is not satisfied
  --> src/main.rs:55:60
   |
55 |         write!(f, "Node data: {} left: {:?}, right: {:?}", self.data, self.left, self.right);
   |                                                            ^^^^^^^^^ trait `T: std::fmt::Display` not satisfied
   |
   = help: consider adding a `where T: std::fmt::Display` bound
   = note: required by `std::fmt::Display::fmt`

error[E0277]: the trait bound `T: std::fmt::Display` is not satisfied
  --> src/main.rs:62:60
   |
62 |         write!(f, "Node data: {} left: {:?}, right: {:?}", self.data, self.left, self.right);
   |                                                            ^^^^^^^^^ trait `T: std::fmt::Display` not satisfied
   |
   = help: consider adding a `where T: std::fmt::Display` bound
   = note: required by `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);
    }
}

Answer 1

以下是此问题的minimal版本：

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);
}

我们来看看fmt函数：

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    write!(f, "Bob: {}", self.0)
}

我们可以按照以下方式重写它，以便更清晰：

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    write!(f, "Bob: ")?;
    std::fmt::Display::fmt(&self.0, f)
}

使用引号write!中的双括号调用其中一个格式化宏（format!，println!，"{}"等），称为{{1}来自该参数的fmt特征的函数（在这种情况下为Display）。

问题是我们有一些泛型类型self.0，因此编译器不知道是否为它实现了T。

有两种方法可以解决这个问题。

首先，我们可以将约束Display添加到T: std::fmt::Display Display的实施中。这将允许我们使用非Bob类型的结构，但只有在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);仅适用于Bob类型。它限制并限制Display的灵活性，但可能存在需要的情况。

还有其他类似于Bob的特征可以通过在括号中放置不同的标记来调用。完整列表可以在documentation中找到，但是，例如，我们可以使用Display特征与

Debug

只有这样我们才需要确保write!(f, "Bob: {:?}", self.0)是T。

不满足特征绑定`T：std :: fmt :: Display`

1 个答案: