DEV Community

Cover image for What Are Rust Raw Pointers and static variables?
Mansoor Ahmed
Mansoor Ahmed

Posted on

What Are Rust Raw Pointers and static variables?

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.
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.

fn get(n: usize) -> &’static str {

static STRS: &[&str] = &[

“zero”, “one”, “two”, “three”, “four”,

“five”, “six”, “seven”, “eight”, “nine”,




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.
For more details visit:

Discussion (0)