How to check release / debug builds using cfg in Rust?

In Rust, you can use the cfg attribute to determine whether the compiled version is a release or debug build. The cfg attribute is primarily used for conditional compilation, allowing you to include or exclude code sections based on flags provided during compilation.

Using the cfg Attribute to Check Versions

1. Checking for Debug Builds: Use the debug_assertions flag, which is enabled by default in debug builds and disabled by default in release builds. If you want to add code that runs only in debug builds, you can write it as:

   rust
   #[cfg(debug_assertions)]
   fn perform_debug_tasks() {
       println!("Performing debug tasks");
   }
   ``
   
   The `perform_debug_tasks` function in this code will only be compiled and run in debug mode.
   

2. Checking for Release Builds: You can determine if it's a release build by checking whether the debug_assertions flag is not enabled:

   rust
   #[cfg(not(debug_assertions))]
   fn perform_release_tasks() {
       println!("Performing release tasks");
   }
   ``
   
   Here, the `perform_release_tasks` function will only be compiled and run in release mode.

Practical Application Example

Suppose we are developing an application that needs to log additional information in debug mode but not in release mode to avoid performance issues and prevent potential leaks of sensitive information. We can write the code as follows:

rust
fn main() {
    perform_tasks();
}

#[cfg(debug_assertions)]
fn perform_tasks() {
    println!("Debug mode: Logging detailed information");
    // Other debug-related tasks
}

#[cfg(not(debug_assertions))]
fn perform_tasks() {
    println!("Release mode: Performing standard operations");
    // Performing optimization tasks for release version
}

This way, the perform_tasks function executes different operations based on the compilation mode. In debug builds, it prints detailed log information, whereas in release builds, it only performs necessary operations.

Summary

By using the cfg attribute, Rust can flexibly include or exclude code sections based on the compilation type (debug or release). This enables different strategies and optimizations to be applied during various development stages while keeping the code clean and efficient.