What is the difference between const and static in Rust?

In Rust, the const and static keywords are both used to define constants, but their usage and purposes have important differences:

1. Storage Location and Lifetime:

   • const: Constants are computed at compile time and do not have a fixed memory address. When used, the value is inlined at the point of use, meaning the value may be duplicated multiple times in the compiled code.
   • static: Static variables have a fixed memory address and remain valid throughout the program's execution. Static variables are stored in the data segment of the executable file.

2. Mutability:

   • const: Constants are always immutable, must be initialized at definition, and their values are determined at compile time, making them unmodifiable.
   • static: Static variables can be mutable. Using static mut defines a mutable static variable, but accessing it requires an unsafe block to prevent data races.

3. Usage:

   • const: Typically used in scenarios where a memory address is not needed, only the value is required. For example, using const for configuration items or status codes allows compile-time optimizations for efficiency.
   • static: When a variable needs to persist throughout the program's lifetime, static can be used. For example, it can store program configuration or maintain state across multiple function calls.

Example: Suppose we need to define an API version for the application; using const is a good choice:

rust
const API_VERSION: &str = "1.0";

If we need to track how many times a function is called, we can use static mut since the value needs to be modified at runtime:

rust
static mut CALL_COUNT: i32 = 0;

fn increment_call_count() {
    unsafe {
        CALL_COUNT += 1;
        println!("Function has been called {} times", CALL_COUNT);
    }
}

In this example, CALL_COUNT needs to be tracked throughout the program's execution, hence static was chosen. Additionally, since it needs to be modified, static mut was used, and it is accessed within an unsafe block to handle potential concurrency issues.