static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
    let a = 42;
    let b = &B;
    let c = &C;
    println!("a: {}, b: {:p}, c: {:p}", a, b, c);
}

運行

point_demo on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base
? cargo run
Compiling point_demo v0.1.0 (/Users/qiaopengjun/rust/point_demo)
Finished dev [unoptimized + debuginfo] target(s) in 0.44s
Running `target/debug/point_demo`
a: 42, b: 0x1023dc660, c: 0x1023dc66a

point_demo on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base
?

一個更加逼真的例子
- 使用更復雜的類型展示指針內(nèi)部的區(qū)別

use std::mem::size_of;
static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
    // let a = 42;
    // let b = &B;
    // let c = &C;
    // println!("a: {}, b: {:p}, c: {:p}", a, b, c);
    let a: usize = 42;
    let b: Box<[u8]> = Box::new(B);
    let c: &[u8; 11] = &C;
    println!("a (unsigned 整數(shù)):");
    println!("  地址: {:p}", &a);
    println!("  大小:    {:?} bytes", size_of::<usize>());
    println!("  值:  {:?}\n", a);
    println!("b (B 裝在 Box 里):");
    println!("  地址:  {:p}", &b);
    println!("  大小:    {:?} bytes", size_of::<Box<[u8]>>());
    println!("  指向:  {:p}\n", b);
    println!("c (C 的引用):");
    println!("  地址:  {:p}", &c);
    println!("  大小:  {:?} bytes", size_of::<&[u8; 11]>());
    println!("  指向:  {:p}\n", c);
    println!("B (10 bytes 的數(shù)組):");
    println!("  地址:  {:p}", &B);
    println!("  大小:  {:?} bytes", size_of::<[u8; 10]>());
    println!("  值:  {:?}\n", B);
    println!("C (11 bytes 的數(shù)字):");
    println!("  地址:  {:p}", &C);
    println!("  大小:  {:?} bytes", size_of::<[u8; 11]>());
    println!("  值:  {:?}\n", C);
}

運行

point_demo on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base
? cargo run
Compiling point_demo v0.1.0 (/Users/qiaopengjun/rust/point_demo)
Finished dev [unoptimized + debuginfo] target(s) in 0.19s
Running `target/debug/point_demo`
a (unsigned 整數(shù)):
地址: 0x16dda9a08
大小: 8 bytes
值: 42

b (B 裝在 Box 里):
地址: 0x16dda9a10
大小: 16 bytes
指向: 0x12b606ba0

c (C 的引用):
地址: 0x16dda9a30
大小: 8 bytes
指向: 0x10208d7ba

B (10 bytes 的數(shù)組):
地址: 0x10208d7b0
大小: 10 bytes
值: [99, 97, 114, 114, 121, 116, 111, 119, 101, 108]

C (11 bytes 的數(shù)字):
地址: 0x10208d7ba
大小: 11 bytes
值: [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0]

point_demo on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base
?

對 B 和 C 中文本進行解碼的例子
- 它創(chuàng)建了一個與前圖更加相似的內(nèi)存地址布局

use std::borrow::Cow;
use std::ffi::CStr;
use std::os::raw::c_char;
static B: [u8; 10] = [99, 97, 114, 114, 121, 116, 111, 119, 101, 108];
static C: [u8; 11] = [116, 104, 97, 110, 107, 115, 102, 105, 115, 104, 0];
fn main() {
  let a = 42;
  let b: String;
  let c: Cow<str>;
  unsafe {
    let b_ptr = &B as * const u8 as *mut u8;
    b = String::from_raw_parts(b_ptr, 10, 10);
    let c_ptr = &C as *const u8 as *const c_char;
    c = CStr::from_ptr(c_ptr).to_string_lossy();
  }
  println!("a: {}, b: {}, c: {}", a, b, c);
}

Raw Pointers（原始指針）

Raw Pointer （原始指針）是沒有 Rust 標準保障的內(nèi)存地址。
- 這些本質上是 unsafe 的
語法：
- 不可變 Raw Pointer：*const T
- 可變的 Raw Pointer：*mut T
- 注意：*const T，這三個標記放在一起表示的是一個類型
- 例子：*const String
*const T 與 *mut T 之間的差異很小，相互可以自由轉換
Rust 的引用（&mut T 和 &T）會編譯為原始指針
- 這意味著無需冒險進入 unsafe 塊，就可以獲得原始指針的性能
例子：把引用轉為原始指針

fn main() {
  let a: i64 = 42;
  let a_ptr = &a as *const i64;
  println!("a: {} ({:p})", a, a_ptr);
}

解引用（dereference）：通過指針從 RAM 內(nèi)存提取數(shù)據(jù)的過程叫做對指針進行解引用（dereferencing a pointer）
例子：把引用轉為原始指針

fn main() {
  let a: i64 = 42;
  let a_ptr = &a as *const i64;
  let a_addr: usize = unsafe {std::mem::transmute(a_ptr)};
  println!("a: {} ({:p}...0x{:x})", a, a_ptr, a_addr + 7);
}

關于 Raw Pointer 的提醒

在底層，引用（&T 和 &mutT）被實現(xiàn)為原始指針。但引用帶有額外的保障，應該始終作為首選使用
訪問 Raw Pointer 的值總是 unsafe 的
Raw Pointer 不擁有值的所有權
- 在訪問時編譯器不會檢查數(shù)據(jù)的合法性
允許多個 Raw Pointer 指向同一數(shù)據(jù)
- Rust 無法保證共享數(shù)據(jù)的合法性

使用 Raw Pointer 的情況

不可避免
- 某些 OS 或第三方庫需要使用，例如與C交互
共享對某些內(nèi)容的訪問至關重要，運行時性能要求高

Rust 指針生態(tài)

Raw Pointer 是 unsafe 的
Smart Pointer（智能指針）傾向于包裝原始指針，附加更多的能力
- 不僅僅是對內(nèi)存地址解引用

Rust 智能指針

名稱	簡介	強項	弱項
Raw Pointer	mut T 和 const T，自由基，閃電般塊，極其 Unsafe	速度、與外界交互	Unsafe
`Box<T>`	可把任何東西都放在Box里。可接受幾乎任何類型的長期存儲。新的安全編程時代的主力軍。	將值集中存儲在 Heap	大小增加
`Rc<T>`	是Rust的能干而吝嗇的簿記員。它知道誰借了什么，何時借了什么	對值的共享訪問	大小增加；運行時成本；線程不安全
`Arc<T>`	是Rust的大使。它可以跨線程共享值，保證這些值不會相互干擾	對值的共享訪問；線程安全	大小增加；運行時成本
`Cell<T>`	變態(tài)專家，具有改變不可變值的能力	內(nèi)部可變性	大小增加；性能
`RefCell<T>`	對不可變引用執(zhí)行改變，但有代價	內(nèi)部可變性；可與僅接受不可變引用的Rc、Arc嵌套使用	大小增加；運行時成本；缺乏編譯時保障
`Cow<T>`	封閉并提供對借用數(shù)據(jù)的不可變訪問，并在需要修改或所有權時延遲克隆數(shù)據(jù)	當只是只讀訪問時避免寫入	大小可能會增大
String	可處理可變長度的文本，展示了如何構建安全的抽象	動態(tài)按需增長；在運行時保證正確編碼	過度分配內(nèi)存大小
`Vec<T>`	程序最常用的存儲系統(tǒng)；它在創(chuàng)建和銷毀值時保持數(shù)據(jù)有序	動態(tài)按需增長	過度分配內(nèi)存大小
`RawVec<T>`	是`Vec<T>`和其它動態(tài)大小類型的基石；知道如何按需給你的數(shù)據(jù)提供一個家	動態(tài)按需增長；與內(nèi)存分配器一起配合尋找空間	不直接適用于您的代碼
`Unique<T>`	作為值的唯一所有者，可保證擁有完全控制權	需要獨占值的類型（如 String）的基礎	不適合直接用于應用程序代碼
`Shared<T>`	分享所有權很難，但他使生活更輕松	共享所有權；可以將內(nèi)存與T的寬度對齊，即使是空的時候	不適合直接用于應用程序代碼