Rust实现单链表用println!打印泛型T提示未实现Debug trait如何解决？

使用{:?}格式化占位符打印变量时，要求变量对应的类型必须实现std::fmt::Debug trait，当前代码所有涉及打印逻辑的泛型约束都未包含Debug，因此编译报错。

具体修改步骤 #

1. 调整println_T函数的泛型约束，增加Debug限制，符合{:?}格式化要求：

fn println_T<T: Ord + std::fmt::Debug>(x: &T) {
    println!("{:?}", x);
}

2. 调整Node实现块的泛型约束，因为Node的see_values方法会调用println_T，需要保证泛型T满足Debug要求：

impl<T: Ord + std::fmt::Debug> Node <T> 

3. 调整List实现块的泛型约束，因为List的see_values方法会调用Node的同名方法，同样需要泛型T满足Debug要求：

impl<T: Ord + std::fmt::Debug> List<T> {

4. 修复隐藏逻辑bug：see_values方法中使用take()会直接移走节点所有权并将原位置设为None，调用一次打印后整个链表就会被清空，仅需将take()替换为as_ref()做只读访问即可：
   • 将Node::see_values中的self.next.take()改为self.next.as_ref()
   • 将List::see_values中的self.head.take()改为self.head.as_ref()

修改后可运行完整代码 #

use std::fmt::Debug;

pub struct List<T> {
    head: Link<T>
}

type Link<T> = Option<Box<Node<T>>>;

struct Node<T> {
    value: T,
    next: Link<T>
}

impl<T: Ord + Debug> Node <T> 
{
    fn new(value: T, next: Link<T>) -> Self {
        Node {value: value, next: next}
    }
    
    fn check_and_put(&mut self, value: T) 
    {
        if self.next.is_none() {
            self.next = Some(Box::new(Node::new(value, None))); 
        }else {
            if compare(&value, &self.value) {
                let mut aux: Link<T> = None;
                self.next.take().map(|node| {
                    aux = Some(node);
                });
                self.next = Some(Box::new(Node::new(value, aux)));
            }else {
                self.next.as_mut().map(|nod| {
                    nod.check_and_put(value);
                });
            }
        }
    }

    fn delete_node(&mut self, value: T) {
        if !self.next.is_none() {
            let mut aux: Link<T> = None;
            self.next.as_mut().map(|node| {
                if &node.value == &value{
                    node.next.take().map(|nod| {
                        aux = Some(nod);
                    });
                }else {
                    if !node.next.is_none(){
                        node.delete_node(value);
                    }
                }
            });
            if !aux.is_none(){
                self.next = aux;
            }
        }
    }

    fn see_values(&self) {
        println_T(&self.value);
        if !self.next.is_none(){
            self.next.as_ref().map(|node| {
                node.see_values();
            });
        }
    }
}

impl<T: Ord + Debug> List<T> {
    fn new() -> Self {
        List {head: None}
    }
    
    fn add_element(&mut self, value: T) {
        if !self.head.is_none(){
            self.head.as_mut().map(|node| {
                node.check_and_put(value);
            });
        }else {
            self.head = Some(Box::new(Node::new(value, None)));
        }
    }

    fn delete_node(&mut self, value: T) {
        if !self.head.is_none(){
            let mut aux: Link<T> = None;
            self.head.as_mut().map(|node| {
                if &value == &node.value{
                    node.next.take().map(|nod| {
                        aux = Some(nod);
                    });
                }else {
                    if !node.next.is_none(){
                        node.delete_node(value);
                    }
                }
            });
            if !aux.is_none(){
                self.head = aux;
            }
        }
    }

    fn see_values(&self){
        if !self.head.is_none(){
            self.head.as_ref().map(|node| {
                node.see_values();
            });
        }
    }
}

fn println_T<T: Ord + Debug>(x: &T) {
    println!("{:?}", x);
}

fn compare<T: PartialOrd>(a: &T, b: &T) -> bool {
    a > b
}

fn main() {
    let mut list = List::new();
    list.add_element(1);
    list.add_element(4);
    list.add_element(2);
    list.delete_node(2);
    list.see_values();
    println!("finish");
}

运行后输出为：

1
4
finish

内容的提问来源于stack exchange，提问作者danixl30 ct