Rust中能否在编译时判断变量是否为引用及引用类型？

先看你给出的示例代码：

fn main() {
    let a: i32 = 1;
    let b: &i32 = &a;
    let c: String = "hello world".to_string();
    let d: &str = &c[..];
}

先纠正一个概念：String是拥有所有权的堆内存容器类型（属于广义的智能指针范畴），而非“智能引用”；&str是胖指针类型的引用，&i32是瘦指针类型的引用，a是栈上的普通值类型。

下面是几种编译时区分这些类型的方法：

一、内存大小与布局检查（已知工具的进阶用法） #

std::mem::size_of和std::mem::align_of可以在const上下文中使用，实现编译时断言：

• 瘦指针（如&i32）的大小等于目标平台的原生指针大小（64位系统为8字节，32位为4字节）
• 胖指针（如&str、&[T]）的大小是两倍原生指针大小（64位为16字节）
• 拥有所有权的容器（如String）的大小是三倍原生指针大小（64位为24字节，包含指针、长度、容量）
• 普通值类型（如i32）的大小是自身数据宽度（4字节）

示例编译时断言：

use std::mem;

const _: () = assert!(mem::size_of::<i32>() == 4);
const _: () = assert!(mem::size_of::<&i32>() == mem::size_of::<*const ()>());
const _: () = assert!(mem::size_of::<&str>() == 2 * mem::size_of::<*const ()>());
const _: () = assert!(mem::size_of::<String>() == 3 * mem::size_of::<*const ()>());

如果类型不符合预期，编译阶段直接报错。

二、基于Trait的编译时判定 #

Rust的Trait系统可以用来在编译时区分类型特性：

1. 检查是否为固定大小类型（Sized Trait） #

• 普通值类型（i32）、瘦指针（&i32）、胖指针（&str）、String都实现了Sized
• 裸的str、[T]是未固定大小类型（!Sized），可以通过Trait bounds区分引用指向的目标类型：

// 仅接受指向未固定大小类型的胖指针引用
fn accept_fat_ptr<T: ?Sized>(_: &T) {}

// 编译通过：accept_fat_ptr(&"test"[..]);
// 编译错误：accept_fat_ptr(&1i32); // 因为&T的T是Sized，不符合?Sized约束

2. 区分所有权类型与引用类型 #

• 引用类型（&T）不实现Drop trait（因为不拥有数据），而拥有所有权的容器（如String、Vec<T>）实现了Drop
• 可以通过Trait bounds在编译时筛选：

// 仅接受实现Drop的拥有所有权类型
fn accept_owned<T: Drop>(_: T) {}

// 编译通过：accept_owned(String::from("test"));
// 编译错误：accept_owned(&1i32);

3. 自定义标记Trait #

你可以自定义Trait来给不同类型打标签，实现编译时的类型分类：

trait TypeKind {
    const KIND: &'static str;
}

impl TypeKind for i32 {
    const KIND: &'static str = "普通栈值类型";
}

impl<'a, T: Sized> TypeKind for &'a T {
    const KIND: &'static str = "瘦指针引用";
}

impl<'a> TypeKind for &'a str {
    const KIND: &'static str = "胖指针引用（字符串切片）";
}

impl TypeKind for String {
    const KIND: &'static str = "拥有所有权的字符串容器";
}

// 编译时直接获取类型标记
const _: &str = <i32 as TypeKind>::KIND;
const _: &str = <&i32 as TypeKind>::KIND;

三、const函数做编译时类型判断 #

可以编写const函数封装逻辑，在编译时返回类型特性的布尔值：

const fn is_thin_ptr<T>() -> bool {
    std::mem::size_of::<T>() == std::mem::size_of::<*const ()>()
}

const fn is_fat_ptr<T>() -> bool {
    std::mem::size_of::<T>() == 2 * std::mem::size_of::<*const ()>()
}

const fn is_owned_string_like<T>() -> bool {
    std::mem::size_of::<T>() == 3 * std::mem::size_of::<*const ()>()
}

// 编译时断言
const _: () = assert!(is_thin_ptr::<&i32>());
const _: () = assert!(is_fat_ptr::<&str>());
const _: () = assert!(is_owned_string_like::<String>());

内容的提问来源于stack exchange，提问作者Finlay Weber