Does Rust have a debug macro?

Question

In C++, I use something like this DEBUG macro:

#ifdef DEBUG
#define DEBUG_STDERR(x) (std::cerr << (x))
#define DEBUG_STDOUT(x) (std::cout << (x))
#else 
#define DEBUG_STDERR(x)
#define DEBUG_STDOUT(x)
#endif

Does Rust have something similar?

Answer 1

Although it makes sense to use something like the log crate as mentioned in DK's answer, here's how to do the direct equivalent of what you asked:

// The debug version
#[cfg(feature = "my_debug")]
macro_rules! debug_print {
    ($( $args:expr ),*) => { println!( $( $args ),* ); }
}

// Non-debug version
#[cfg(not(feature = "my_debug"))]
macro_rules! debug_print {
    ($( $args:expr ),*) => {}
}

fn main() {
    debug_print!("Debug only {}", 123);
}

And in your Cargo.toml, add a [features] section:

[features]
my_debug = []

The output then appears with cargo run --features my_debug, and doesn't with a plain cargo run.

Answer 2

Rust 1.32.0

Rust 1.32.0 stabilized the dbg!() macro, which outputs:

• The file name on which the macro was called.
• The line number on which the macro was called.
• A pretty print of the argument (which must implement the Debug trait).

Note: dbg!() moves its argument, so you may want to pass non-copy types by reference.

Example: Array of Points (Playground)

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let points = [
        Point { x: 0, y: 0 },
        Point { x: 2, y: 3 },
        Point { x: 5, y: 7 },
    ];

    dbg!(&points);
}

Program Output

[src/main.rs:14] &points = [
    Point {
        x: 0,
        y: 0
    },
    Point {
        x: 2,
        y: 3
    },
    Point {
        x: 5,
        y: 7
    }
]

Example: Conditional Compilation (Playground)

The OP expressed a desire to display the debug content only when compiling in debug mode.

The following is a way to achieve this:

#[cfg(debug_assertions)]
macro_rules! debug {
    ($x:expr) => { dbg!($x) }
}

#[cfg(not(debug_assertions))]
macro_rules! debug {
    ($x:expr) => { std::convert::identity($x) }
}

fn main() {
    let x = 4;
    debug!(x);
    if debug!(x == 5) {
        println!("x == 5");
    } else {
        println!("x != 5");
    }
}

Program Output (Debug Mode)

---------------------Standard Error-----------------------

[src/main.rs:13] x = 4
[src/main.rs:14] x == 5 = false

---------------------Standard Output----------------------

x != 5

Program Output (Release Mode)

---------------------Standard Output----------------------

x != 5

Before Rust 1.32.0

You could use the log crate or you could define one yourself.

Answer 3

You could define them yourself, but it would be simpler to use the log crate, which defines several macros for various purposes (see the log documentation).

Note that the crate only provides the frontend for logging; you'll also need to select a backend. There's a basic example in the log documentation, or you could use something like env_logger or log4rs.

Answer 4

Macro based on Chris Emerson answer and CJ McAllister comment

// Disable warnings

#[allow(unused_macros)]

// The debug version

#[cfg(debug_assertions)]
macro_rules! log {
    ($( $args:expr ),*) => { println!( $( $args ),* ); }
}

// Non-debug version

#[cfg(not(debug_assertions))]
macro_rules! log {
    ($( $args:expr ),*) => {()}
}

Using

log!("Don't be crazy");
log!("Answer is {}", 42);

Building by cargo build --release will replace all log!(...) with unit tuple ();

I didn't found the way to replace to nothing but I think compiler will do it.