Raw Pointers
Unsafe Rust has two new kinds called raw pointers, which are similar to references. They may be immutable or mutable and can be written as:
- *const T (Immutable)
- *mut T (Mutable)
Note: Asterisk “*” is not a dereferencing operator, its part of type name.
Let’s know how to make an immutable and mutable raw pointer from reference.
let mut = 5; let r1 = &num as *const i32; let r2 = &mut num as *i32;
Is something wrong! We didn’t include an unsafe keyword here? Well, it’s okay to create raw pointers outside unsafe but it’s must to include while dereferencing them.
Now, let’s generate a raw pointer whose validity can’t be sure.
fn main ( ) { let address = 0x012345usize; let r = address * const i32; }
The overhead method to access memory is not optional; however, we might see or write this kind of code.
How raw pointers different from references?
- Remain permissible to ignore the borrowing rules by having both immutable and mutable pointers or multiple mutable pointers to the same location
- Aren’t guaranteed to point to valid memory
- Are allowed to be null
- Don’t implement any automatic cleanup
Static variables
- In Rust, global variables are also called static variables
- Static variables are similar to Constants
- Identification style of static variables is in SCREAMING_SNAKE_CASE
- Type footnote for static variables is a must (like constants).
- Rust permits access to read-only static variables (immutable static variables), however doesn’t allow access to immutable static variables.
- Static variables continuously have fixed addresses in memory.
Limitations
- Static variables must be threading safe.
- This means that their type must implement the SyncThis links to the official Rust documentation trait.
- For example, this links to official Rust documentation or RefCellThis links to official Rust documentation can’t be used in a static variable.
- They are not thread-safe as having multiple threads access them at once causes a data race.
- Static variables may mention to other static variables, but only through a reference, not by value.
- Constants can’t refer to a static variable.
Example
fn get(n: usize) -> &'static str { static STRS: &[&str] = &[ "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", ]; STRS[n] }
Using statics or constants
It may be confusing whether or not we should use a constant item or a static item., In general, Constants should be preferred over statics unless one of the following is true:
- Big amounts of data are being stored
- Required the single-address property of statics.
- Inner mutability is obligatory
Mutable static variables
- Static variables may be mutable.
- Since Rust can’t show the absence of data races when accessing a static mutable variable, accessing it is unsafe.
- By using static mutable variables is discouraged, since they are not only unsafe but also very difficult to use correctly.
- It is nearly impossible to prove that no data races occur without synchronization primitives such as MutexThis links to official Rust documentation.
- They are possible to be removed in a future version of Rust; if you need unsafe static mutability use UnsafeCell.