有没有一种方法可以在不直接实现调试特性的情况下自定义调试输出？

Question

考虑下面的代码：

#[derive(Debug)]
struct Test {
    int: u8,
    bits: u8,
    hex: u8
}

fn main() {
    let t = Test {
        int: 1,
        bits: 2,
        hex: 3
    };
    println!("{:#?}", t);
}

运行时，它输出以下内容：

Test {
    int: 1,
    bits: 2,
    hex: 3
}

这很酷，我们可以很容易地转储一个结构，但是我的一些数据结构包含位掩码或其他不容易在基数10中读取的数据。对于位字段，读取它会更容易，它们的输出类似于0b00000010。

有没有一种简单的方法可以获得这样的输出，而不直接在结构上实现Debugtrait（在另一种类型上实现Debugtrait就可以了）？

Test {
    int: 1,
    bits: 0b00000010,
    hex: 0x03
}

如果有必要，我可以使用不同的类型，但是我希望保持结构本身的调试特性像#[派生（调试）]一样简单。

Answer 1

有没有一种简单的方法可以获得这样的输出，而不需要直接在结构上实现Debug特性（在另一种类型上使用Debug特性就可以了）

对#[派生（调试）]通过依次对每个成员调用Debug:：Debug来实现Debug。按照如何实现自定义“fmt:：Debug”特性中的说明进行操作？对于您的新类型包装器：

use std::fmt;

#[derive(Debug)]
struct Test {
    int: u8,
    bits: Bits,
    hex: u8,
}

struct Bits(u8);

impl fmt::Debug for Bits {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "0b{:08b}", self.0)
    }
}

在另一个方向上，在主结构上有一个返回另一个结构“用于显示目的”的方法并不奇怪，类似于std:：path:：display。这允许您将复杂的显示逻辑移动到单独的类型，同时允许原始结构不具有可能妨碍您的新类型：

use std::fmt;

#[derive(Debug)]
struct Test {
    int: u8,
    bits: u8,
    hex: u8,
}

impl Test {
    fn pretty_debug(&self) -> PrettyDebug<'_> {
        PrettyDebug {
            int: &self.int,
            bits: Bits(&self.bits),
            hex: &self.hex,
        }
    }
}

#[derive(Debug)]
struct PrettyDebug<'a> {
    int: &'a u8,
    bits: Bits<'a>,
    hex: &'a u8,
}

struct Bits<'a>(&'a u8);

impl fmt::Debug for Bits<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "0b{:08b}", self.0)
    }
}

引用一个u8有点傻，但是引用是这里最通用的解决方案-

您还可以直接为您的PrettyDebug类型实现Debug：

use std::fmt;

#[derive(Debug)]
struct Test {
    int: u8,
    bits: u8,
    hex: u8,
}

impl Test {
    fn pretty_debug(&self) -> PrettyDebug<'_> {
        PrettyDebug(self)
    }
}

struct PrettyDebug<'a>(&'a Test);

impl fmt::Debug for PrettyDebug<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Test")
            .field("int", &self.0.int)
            .field("bits", &format_args!("0b{:08b}", self.0.bits))
            .field("hex", &format_args!("0x{:02x}", self.0.hex))
            .finish()
    }
}