static & const
Static and constant variables are two different ways to create globally-scoped values that cannot be moved or reallocated during the execution of the program.
const
Constant variables are evaluated at compile time and their values are inlined wherever they are used:
const DIGEST_SIZE: usize = 3; const ZERO: Option<u8> = Some(42); fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] { let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE]; for (idx, &b) in text.as_bytes().iter().enumerate() { digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE].wrapping_add(b); } digest } fn main() { let digest = compute_digest("Hello"); println!("digest: {digest:?}"); }
GemÀà dem Rust RFC Book werden diese bei der Verwendung eingefĂŒgt (inlined upon use).
Only functions marked const
can be called at compile time to generate const
values. const
functions can however be called at runtime.
static
Static variables will live during the whole execution of the program, and therefore will not move:
static BANNER: &str = "Welcome to RustOS 3.14"; fn main() { println!("{BANNER}"); }
As noted in the Rust RFC Book, these are not inlined upon use and have an actual associated memory location. This is useful for unsafe and embedded code, and the variable lives through the entirety of the program execution. When a globally-scoped value does not have a reason to need object identity, const
is generally preferred.
- ErwÀhne, dass sich
const
semantisch Àhnlich wieconstexpr
in C++ verhÀlt. static
hingegen ist einerconst
oder verÀnderlichen (mutable) globalen Variable in C++ viel Àhnlicher.static
provides object identity: an address in memory and state as required by types with interior mutability such asMutex<T>
.- Es kommt nicht sehr hÀufig vor, dass man eine zur Laufzeit ausgewertete Konstante benötigt, aber es ist hilfreich und sicherer als die Verwendung einer statischen.
Properties table:
Property | Static | Constant |
---|---|---|
Has an address in memory | Yes | No (inlined) |
Lives for the entire duration of the program | Yes | No |
Can be mutable | Yes (unsafe) | No |
Evaluated at compile time | Yes (initialised at compile time) | Yes |
Inlined wherever it is used | No | Yes |
More to Explore
Because static
variables are accessible from any thread, they must be Sync
. Interior mutability is possible through a Mutex
, atomic or similar.
Thread-local data can be created with the macro std::thread_local
.