What Are Rust Raw Pointers and static variables?

by

 What Are Rust Raw Pointers and static variables?

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.

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

 

Leave a Comment