advance/lifetime/static

[giscus[bot]]

advance/lifetime/static

https://course.rs/advance/lifetime/static.html

[siu91]

从正常的设计逻辑上看let string = "Hello World!"; string 是局部变量，不是应该变量被释放，值也应该被释放？为何不释放，释放了应该也不会引发什么问题吧？困惑 😖

[walijoy]

所以如果大量使用 &str 会引起内在泄漏？

[Endermanbugzjfc]

所以如果大量使用 &str 会引起内在泄漏？
不会，就算真的出问题也会在编译就察觉到…

[wtgodk]

我也不理解，这样岂不是会有很多定义的字符串在内存停留吗？如果不会出现相同的使用不就是内存泄漏吗

[LanYebo]

这个是静态的，编译期就已经确定了，直接引用的硬编码里面的值。c里面也一样啊，如果是直接char *str="Hello World!"，同样也不能修改str，因为这个直接指向了一个不可变的内存空间。运行时不可能分配这种变量的。

[juilletVent]

新手，用我自己的理解说一下，说错了的话，轻喷 🤣🤣

对于像上述提到这种字符串字面量：

let string1 = "Hello World!";
let string2 = "Hello World!";
let string3 = "Hello World!";

编译器在编译阶段会将字面量存储到二进制文件的静态数据区段中，这个数据随程序启动，一同被加载到内存中，如果存在多个相同的字符串，实际上索引的将会是同一个内存地址（因为不可变，所以是静态的）。

为什么不会进行所谓的“释放”？

首先我们要明白，为什么会有“释放”，变量存储的位置一般来说有两个：栈、堆

• 存储在栈上的数据：典型就是局部变量，局部变量的“申请”就是压栈，释放对应的操作就是弹栈（栈回退），在 Rust 中对应的就是生命周期结束。
• 动态数据：存储在堆上的数据，变量的申请就是内存的动态申请（比如 String::from("Hello World!")），释放对应的操作就是生命周期结束或者引用计数归零。

搞明白了“申请”与“释放”，我们再来看看静态数据的存放位置，不知道各位有没有汇编基础，我不幸在大学的时候学习了一点点汇编用于逆向学校的网络客户端（Netkeeper，简直毒瘤！！！）

通过 CE 附加调试程序，搜索程序中的字符串，然后反汇编查看，你会发现，当程序在使用静态字符串（也就是开发时就写在源代码里面的字符串）时，程序都是通过指针引用的，然后，我们继续观察指针指向什么位置，最终你会发现，指针指向的是一个常量区（观察内存段也会发现这一片内存的读写属性是只读属性），这个常量区在程序启动时就被加载到内存中，并且不会被释放，而且这个地址永远不会变化（除非你玩儿花活儿）。

你会发现，这些静态变量压根就没有“申请”这个动作，这些大佬在盘古开天地时就已经存在了，所以也就跳出三界之外，不在五行之中了，自然就不会，也无法进行所谓的“释放”。

不知道我这样解释有没有讲明白，如果有说的不对的地方，请大佬指正，我也学习学习 😄😄

[mxismean]

还是没明白 &'static 和 T: 'static 他俩的区别 😂

[mxismean]

完了，已经学废了

[sunface]

要不就当做不同的用法吧，哈哈。。

[duanyuluo]

&'static 声明变量指向的内存，是具有static lifetime的。但是这个变量本身还会在超出block时被释放。
T：‘static 声明的是T这个类型的lifetime是被static约束的，当然也就比static长。
注意，T可能是&类型。

[kaixinbaba]

'static : 我没有针对谁，我只是说在座的都是 XX

[giveahug]

都是高手啊。学到了好多东西

[amber0515]

我还是没太理解什么是泛型和程序活的一样久，还是指的这个入參的值本身是吧？那我也不理解 &T 这个引用符合的是哪个生命周期？

[amber0515]

然后我也没理解 &T 这个限制 static，但貌似输入的值是不是static无所谓？

[Leo-Lionni]

我也不是很理解:

1. 测试输入 Stiring 类型的值 ,
   fn print_it<T: Debug + 'static>( input: T) {
   println!( "符合 T:'static is: {:?}", input );
   }

fn print_it_1<T: Debug + 'static>( input: &T) {
println!( "符合 T:'static is: {:?}", input );
}

let s1 = "你好".to_string();
print_it_1(&s1); //ok
print_it(s1); //ok

2. 文中:
   T: 'static 与 &'static 有相同的约束：T 必须活得和程序一样久
   fn print_it<T: Debug + 'static>( input: T) {
   println!( "'static value passed in is: {:?}", input );
   }

fn print_it1( input: impl Debug + 'static ) {
println!( "'static value passed in is: {:?}", input );
}

3. 我的测试:

use std::fmt::Debug;

fn main() {

let s = "helo".to_string();
// print_it(s);
print_it1(s);

let s  =" world".to_string();
print_it(s);

}
fn print_it<T: Debug + 'static>( input: T) {
println!( "'static value passed in is: {:?}", input );
}

fn print_it1( input: impl Debug + 'static ) {
println!( "'static value passed in is: {:?}", input );
}
4. 我的疑问:
好像 在 2 那儿的话 , String 类型的s 没有与程序活的一样久, 也 ok 了呀?
在 1 那儿使用 String 的引用(&String)和 String 自己 ,都是 OK 的呀!
那么 T:'static 和 'static 我感觉对 String 没有区别呀?

[mumumusuc]

T:'static这种语法属于特征约束，Rust By Example里讲得很明白，但中文版还没更新:(。
对于类型T的约束T:'static意味着T不包含任何非'static引用；对于接收方来说可以安全地持有T直到自己将其drop。

fn main(){
    fn print_it<T: Debug + 'static>(input: T) {
        println!( "符合 T:'static is: {:?}", input );
    }
    // 显式标注生命周期
    fn print_it_1<'a, T: Debug + 'static>( input: &'a T) {
        println!( "符合 T:'static is: {:?}", input );
    }

    let s1 = "你好".to_string();
    // String不包含非'static引用，Ok
    // &String符合'a的约束，Ok
    print_it_1(&s1); //ok
    // s1的所有权转移到print_it，print_it可以安全的持有它直至函数结束，这种非引用的转移默认是满足'static约束的
    print_it(s1);       //ok

    #[derive(Debug)]
    struct Bad<'a>(&'a String);
    let s1 = String::from("1");
    let s2 = Bad(&s1);
    print_it_1(&s2); // Bad
    print_it(s2);    // Bad
}

[snailset]

我觉得这个章节对T: 'static的描述有误

[首先，在以下两种情况下，T: 'static 与 &'static 有相同的约束：T 必须活得和程序一样久。]
T: 'static 的意思是对T约束 拥有所有权 或者 不包含非'static生命周期的引用

[这段代码竟然不报错了！原因在于我们约束的是 T，但是使用的却是它的引用 &T，换而言之，我们根本没有直接使用 T，因此编译器就没有去检查 T 的生命周期约束！它只要确保 &T 的生命周期符合规则即可，在上面代码中，它自然是符合的。]
我觉得此处约束是生效的，编译器检查了T， T是i32，拥有所有权，所以让它通过了

[lihongtao1024]

感觉@snailset的理解更有说服力

[ghost]

你是对的，带生命周期的可变借用 跟 带生命周期的泛型约束 这两章写得都不好。

[duanyuluo]

@snailset正解，我觉得这里之所以乱，是因为deref把代码搞得太magic了。

[Pro741]

看了一圈感觉还是老哥比较靠谱, 毕竟 生命周期 就是防止出现 垂悬指针/垂悬引用 实现的, 如果输入不是引用, 那检查它的生命周期有啥意义?

按层主老哥解释, T: 'static 为 T 涉及引用时的额外限制条件, 那就说得通了

• 泛型 T 不涉及引用类型, 那 'static 限制失效
• 泛型 T 涉及引用类型, 那该引用指向的数据必须获得足够久: 'static

按这个思路理一下这几个示例代码:

use std::fmt::Debug;

// 我们传入引用, 那此时表示引用的原值是 'static 的即可了, 解决报错
fn print_it<T: Debug + 'static>( input: &T) {
    println!( "'static value passed in is: {:?}", input );
}

fn print_it1( input: impl Debug + 'static ) {
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    let i = 5;

    // 下面三个都不会报错
    print_it(&i);
	print_it1(i);
    print_it1(&5);
}

1. print_it 要求 T为引用时, 引用的数据得是'static的, 传入参数是&T.
   1. 我们输入&i, 根据模式匹配那个原理, 两个&匹配相当于解引用, T代表的就是i的类型i32, 不是引用类型, 'static 限制失效, 编译通过
2. print_it1 也要求 T为引用时, 引用的数据得是'static的, 但传入参数是T.
   1. 我们输入i, T代表的也是i的类型i32, 不是引用类型, 'static 限制失效, 编译通过
   2. 我们输入&5, 是一个切实的数据(常量(const)), 类型是引用类型, 生命周期是 'static, 编译通过

---

use std::fmt::Debug;
fn print_it<T: Debug + 'static>( input: &T) {
	println!( "'static value passed in is: {:?}", input );
}

fn main(){
    let string = "string".to_string();
    print_it(&string);
    println!("{}",string);
}

print_it 要求传参 &T , 实际传参 &String, 解引用后 T表示String, 不是引用类型, 因此编译通过

---

use std::fmt::Debug;
fn print_it<T: Debug + 'static>( input: &T) {
	println!( "'static value passed in is: {:?}", input );
}

fn main(){
    let stk = vec![1, 2, 3];
    print_it(&stk);
    println!("{:?}",stk);
}

print_it 要求传参 &T , 实际传参 &Vec<_>, 解引用后 T表示Vec<_>, 不是引用类型, 因此编译通过

---

use std::fmt::Debug;

#[derive(Debug)]
struct Test<'a> {
    a: i32,
    b: &'a i32,
}

fn print_it<T: Debug + 'static>(input: &T) {
    println!("'static value passed in is: {:?}", input);
}
fn main() {
    let n = 3;
    let t = Test {a: 3, b: &n};
    print_it(&t);
}

print_it 要求传参 &T , 实际传参 &Test<'a>, 解引用后 T表示Test<'a>, 但Test结构体涉及引用和生命周期约束, 因此, 要想通过编译, 'a 这个生命周期必须为大于等于'static. 很显然&n也就是n的生命周期在main()函数运行结束就释放(drop), 因此生命周期不是'static. 编译失败

如何才能编译通过? 那么给Test一个'static的i32就好啦

use std::fmt::Debug;

#[derive(Debug)]
struct Test<'a> {
    a: i32,
    b: &'a i32,
}

fn print_it<T: Debug + 'static>(input: &T) {
    println!("'static value passed in is: {:?}", input);
}
fn main() {
    const N: i32 = 3;  // const 生命周期是 'static, 此时'a=='static, 通过
    let t = Test {a: 3, b: &N};
    print_it(&t);
}

[Levio-z]

会校验，补充一种更直观的。T是引用类型校验，T不是'static，不通过。

use std::fmt::Debug;
use std::borrow::Borrow;

fn print_it<T: Debug + 'static>( input: &T) {
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    let j = 3;
    let i = &j;
    print_it(&i);
}

结果：

//    |     let j = 3;
//    |         - binding `j` declared here
// 17 |     let i = &j;
//    |             ^^ borrowed value does not live long enough
// 18 |
// 19 |     print_it(&i);
//    |     ------------ argument requires that `j` is borrowed for `'static`

[yoyoLooming]

那, 如果这个函数中, T类型, 一个参数想是'static, 另一个参数没有限制该怎么写呢...

[nzhl]

这时候我理解得直接上2个泛型参数了

[yAntPower]

看了收益匪浅，作者大大继续加油！下面有两个小问题

原文：“&'static 对于生命周期有着非常强的要求：一个引用必须要活得跟剩下的程序一样久，才能被标注为 &'static。”
和 Rust By Practice（练习题）里面的这段话“作为一个引用生命周期，&'static 说明该引用指向的数据可以跟程序活得一样久，但是该引用的生命周期依然有可能被强转为一个更短的生命周期。” 对比有歧义，一个说的是引用活的和剩下的程序一样久，另一个说引用指向的数据和程序活的一样久。所以是不是圣经里面是错的？正确的应该是引用指向的数据和程序活的一样久？

另外还有一处拼写错误，在Rust By Practice( Rust 练习实践 )中第一题 题目的最后一个static拼写错误。

[yuhaya]

写了几个月rust转头来看文章和评论收获不小

[xinxin-go]

我迷了，过两天再回过头再看一遍。。。

[chenyuxiaobao]

感觉作者大大在这里把问题讲复杂了，反而让读者云里雾里的。其实T:'static约束的理解很简单，即T类型不持有非'static生命周期的引用。

fn static_bound<T:'static>(t: &T) {}
fn a() {
let s1 = "String".to_string();
// s1 虽然没有 'static 生命周期，但是它依然可以满足 T: 'static 的约束
// 充分说明这个约束是多么的弱。。
//换而言之，我们根本没有直接使用 T，因此编译器就没有去检查 T 的生命周期约束！
//！！！可这里真的不检查嘛？？？检查了，只是s1的类型T(String)不持有非'static生命周期的引用。
static_bound(&s1);//ok
//下面的代码无法编译通过，可按照作者大大的说法，是可以通过的。
struct Test<'a>(&'a String);
let t = Test(&s1);
static_bound(&t);
}

[chenyuxiaobao]

{
//这段代码可以通过编译
static S : String = String::new();
struct Test<'a>(&'a String);
let t = Test(&S);
static_bound(&t);
}

[Kangaxx-0]

我觉得介绍这章的时候需要再次highlight或者强调一个点就是 -> binary static memory，在两种情况下代码会存在这里:

• 声明一个static 常量
• 像字符串literal

涉及到引用生命周期时，凡是像如上两种情况，那必是static。

另外提一点就是上面的陈述反过来不一定成立，即static的lifetime不一定指向static memory区域。从编译器的视角来看，只要你(引用)活的和程序一样久，我就可以认为你是static

用我的这个解释去套用

use std::fmt::Debug;

fn print_it<T: Debug + 'static>( input: T) {
    println!( "'static value passed in is: {:?}", input );
}

fn print_it1( input: impl Debug + 'static ) {
    println!( "'static value passed in is: {:?}", input );
}



fn main() {
    let i = 5;

    print_it(&i);
    print_it1(&i);
}

和以及它下面的， 就很容易理解

[Endermanbugzjfc]

确实， Rust By Example 对 static 的解释是

A possibly mutable variable with 'static lifetime.

可能会变更而带有 'static 生命周期的变数。

与 const 相对

[Endermanbugzjfc]

https://doc.rust-lang.org/rust-by-example/custom_types/constants.html

[youmisun]

use std::fmt::Debug;


fn empty_struct_static<T: Debug + 'static>(t: T) {
    println!("static pass is: {:?}", t);
}

#[derive(Debug)]
struct Empty;

fn main() {
    empty_struct_static(Empty);
}

为什么空结构体是'static生命周期，不是很理解

[Kangaxx-0]

你代码中call function的参数是一个实例，实例就必须初始化，从那个方法的视角来说，在main中的实例就是static

[yuhaya]

use std::fmt::Debug;


fn empty_struct_static<T: Debug + 'static>(t: T) {
    println!("static pass is: {:?}", t);
}

#[derive(Debug)]
struct Empty;

fn main() {
    empty_struct_static(Empty);
}

为什么空结构体是'static生命周期，不是很理解

<T: 'static> 是用来限制 T 里面包含的数据字段不是引用类型

[Kangaxx-0]

use std::fmt::Debug;


fn empty_struct_static<T: Debug + 'static>(t: T) {
    println!("static pass is: {:?}", t);
}

#[derive(Debug)]
struct Empty;

fn main() {
    empty_struct_static(Empty);
}

为什么空结构体是'static生命周期，不是很理解

<T: 'static> 是用来限制 T 里面包含的数据字段不是引用类型

这个解释不对， 楼上有人说的很清楚了 - T: 'static 的意思是对T约束 拥有所有权 或者 不包含非'static生命周期的引用

[duanyuluo]

和是不是空结构体没有关系，你写成Empty（i32）一样可以的，但是写成Empty(&i32)就不行了。必须显式标注lifetime，Empty<'a>(&'a i32)，但这个时候，你最上面T: 'static的约束就报错了。

use std::fmt::Debug;


fn empty_struct_static<T: Debug + 'static>(t: T) {
    println!("static pass is: {:?}", t);
}

#[derive(Debug)]
struct Empty<'a>(&'a i32);

fn main() {
    let i = 32;
    empty_struct_static(Empty(&i));
}

[JasonkayZK]

关于 &'static T 和 T: 'static 的区别：

• 2) 如果 T: 'static 那么 T 直到程序结束为止都一定是有效的

&'static T 是：一个指向 T 的不可变引用，其中 T 可以被安全地无期限地持有，甚至可以直到程序结束。这只有在 T 自身不可变且保证 在引用创建后 不会被 move 时才有可能。T 并不需要在编译时创建。 我们可以以内存泄漏为代价，在运行时动态创建随机数据，并返回其 'static 引；

T: 'static 是指：T 可以被安全地无期限地持有，甚至可以直到程序结束。 T: 'static 在包括了全部 &'static T 的同时，还包括了全部所有权类型， 比如 String, Vec 等等。 数据的所有者保证，只要自身还持有数据的所有权，数据就不会失效，因此所有者能够安全地无期限地持有其数据，甚至可以直到程序结束。T: 'static 应当视为 “T 满足 'static 生命周期约束” 而非 “T 有着 'static 生命周期”。

[xiandaoyan]

但是，&'static 生命周期针对的仅仅是引用，而不是持有该引用的变量，对于变量来说，还是要遵循相应的作用域规则 :
...

static 到底针对谁？
大家有没有想过，到底是 &'static 这个引用还是该引用指向的数据活得跟程序一样久呢？

答案是引用指向的数据，而引用本身是要遵循其作用域范围的，我们来简单验证下：

@作者，这两句话应该表述有矛盾。

[Ayana-chan]

我不知道是作者写得乱还是写错了，我的理解是这样的：

在下面这个函数里面传入&i32的时候，T = &i32，则 &i32 : Debug + 'static，因此要求传入的得是&'static i32。如果传入的是单纯的i32，则是i32 : Debug + 'static，就会发现编译通过了，因为'static这种生命周期作为模板约束不会干涉普通所有权变量。

fn print_it<T: Debug + 'static>(input: T) {
    println!( "'static value passed in is: {:?}", input );
}

然后，在修改后的函数里面，传入&i32的话，显然T会被推导成i32而不是&i32，所以和上面说的一样不会被'static约束。

fn print_it<T: Debug + 'static>(input: &T) {
    println!( "'static value passed in is: {:?}", input );
}

[hamster0523]

我的理解也是这样

[steveviuv]

原来如此, 模式匹配了

[spockwall]

我整理了這裡的一些回答，加上一些自己的實驗以及想法，有錯歡迎指教😅

Two case：

• case 1:
  • 'static作用於引用，此被引用的對象需outlive整個函式運行，包括該類型底下的子類型為引用時，例如：vec<&i32>。
• case 2:
  • 'static作用於(修飾於)類型，該類型須是Owned類型，且Owned類型是基本類型

Example:

use std::fmt::Debug;

fn print1<T: Debug + 'static>(input: T) {
    println!("'static value passed in is: {:?}", input);
}
fn print2<T: Debug + 'static>(input: &T) {
    println!("'static value passed in is: {:?}", input);
}
static STATIC_NUM: i32 = 5;
fn main() {
    // ---------------------------
    let num = 5;

    // case 2: ok
    // 類型Ｔ不包含引用
    // 因為num的所有權交給了print1，
    // 所以print1在該scope可以盡情使用num。
    print1(num);

    // case 1: error
    // 因為類型Ｔ包含引用（就是&num）
    // 需該reference的生命週期outlive整個函式運行.
    print1(&num);

    // case 1: ok
    // 引用為'static，生命週期為整個程式運行
    // print1可以盡情使用 STATIC_NUM。
    print1(&STATIC_NUM);

    // case 2: ok
    // 類型Ｔ不包含引用，因為parament是&T
    // 傳入的&num引用能夠讓print2可以盡情使用num。
    print2(&num);
    //----------------------------

    //----------------------------
    let s_string = String::from("hello");

    // case 2: ok
    print1(s_string);

    // case 1: error
    print1(&s_string);

    // case 2: ok
    print2(&s_string);
    // --------------------------

    //----------------------------
    let s_str = "hello";

    // case 2: ok
    print1(s_str);

    // case 1: error
    // s_str變量不是'static的，只是"hello"存於二進制文件。
    print1(&s_str);

    // case 2: ok
    print2(&s_str);
}

[spockwall]

對於case2，'static並非指的是outlive整個程式運行，而是完整存活於該函數scope即可。

[simon28082]

"到底是 &'static 这个引用还是该引用指向的数据活得跟程序一样久呢？答案是引用指向的数据"
这样如果不断标注static，会不会导致内存不断扩大，因为没有被清理

[yanghyu]

自己测试的例子，相信大家看完会有很清晰认识。只有最后的两个s32的打印是失败的，其他情况都是成功的。

#[cfg(test)]
mod tests {
use std::fmt::Debug;

fn print_it_value<T: Debug + 'static>(input: T) {
    println!( "print_it_value : {:?}", input );
}

fn print_it_borrow<T: Debug + 'static>(input: &T) {
    println!( "print_it_borrow: {:?}", input );
}

#[derive(Debug)]
struct GoodObjWithNoBorrow {
    a: i32,
}

#[derive(Debug)]
struct GoodObjWithStaticBorrow {
    a: i32,
    b: &'static i32,
}

const CONST_INT : i32 = 3;

#[derive(Debug)]
struct BadObjWithStaticBorrow<'a> {
    a: i32,
    b: &'a i32,
}

#[test]
fn test() {
    let s11 = "你好".to_string();
    print_it_borrow(&s11);
    print_it_value(s11);

    let s12 = 1;
    print_it_borrow(&s12);
    print_it_value(s12);

    let s21 = GoodObjWithNoBorrow{ a:1 };
    print_it_borrow(&s21);
    print_it_value(s21);

    let s22 = GoodObjWithStaticBorrow{ a:1, b: &CONST_INT };
    print_it_borrow(&s22);
    print_it_value(s22);

    let s31 = BadObjWithStaticBorrow{ a:1, b: &CONST_INT };
    print_it_borrow(&s31);
    print_it_value(s31);

    let int = 4;

    // let s32 = BadObjWithStaticBorrow{ a:1, b: &int };
    // print_it_borrow(&s32);
    // print_it_value(s32);

//     |
//  60 |         let int = 4;
//     |             --- binding `int` declared here
//  61 |
//  62 |         let s32 = BadObjWithStaticBorrow{ a:1, b: &int };
//     |                                                   ^^^^ borrowed value does not live long enough
//  63 |         print_it_borrow(&s32);
//  64 |         print_it_value(s32);
//     |         ------------------- argument requires that `int` is borrowed for `'static`
//  65 |     }
// |     - `int` dropped here while still borrowed
}

}

[vhtmui]

经过测试，只要解析出来的T不是或不包含引用类型，即&开头的类型，就不会检查变量是不是static的，自己创建的结构体啥的肯定不是static的，都能编译通过。
博主说的原因在于我们约束的是 T，但是使用的却是它的引用 &T，换而言之，我们根本没有直接使用 T，因此编译器就没有去检查 T 的生命周期约束！它只要确保 &T 的生命周期符合规则即可，在上面代码中，它自然是符合的。是误解，实际上对&T传递&Sting类型，会模式匹配将T解析为Sting，这样T就不含有引用了，编译器针对类型T检查发现类型T没有指针，也就没必要继续检查其是否指向非static的数据了。

[vhtmui]

前面一位老哥说的哪里看到：“T:'static约束的理解很简单，即T类型不持有非'static生命周期的引用。”，这句话的隐含意思就是，如T不包含引用，就肯定符合约束。和我的测试结论相同。

[wupeaking]

T: 'static 我的理解是要求T如果是引用类型， 则指向的变量必须是全生命周期的， 如果不是引用类型忽略生命周期约束检查。

fn print_it<T: Debug + 'static>( input: T) {
    println!( "'static value passed in is: {:?}", input );
}

fn print_it2<T: Debug + 'static>( input: &T) {
    println!( "'static value passed in is: {:?}", input );
}

let i = 12;
print_it(&i); // 此时 T == &i32 满足要求，进行生命周期约束检查，i必须是static的 所以编译不通过
print_it(i); // 此时 T == i32 不满足T是引用类型要求，不需要进行生命周期约束检查 编译通过
print_it(&&i); // 此时 T == &&i32 满足要求，检查&i32是否是全生命周期，编译不通过

fn print_it2<T: Debug + 'static>( input: &T) {
    println!( "'static value passed in is: {:?}", input );
}
print_it2(&i); // 此时 T == i32 不需要进行检查 编译通过
print_it2(&&i); // 此时 T == &&i32 满足要求，检查&i32是否是全生命周期，编译不通过
static s_iptr : &i32 = &5;
print_it2(&s_iptr); // s_iptr 是满足static  所以编译通过

[jmjoy]

虽然我写了好几年的Rust，但是我发现我很难总结出Rust的知识点，我写Rust全凭肌肉记忆！

对于T: 'static我是知道怎么才能取悦编译器的，只有两种情况：

1. &'staitc的引用
2. 所有权对象

至于为什么，我试图总结一下，发现无法自洽。

[cctga]

我常常在文章中看到字面字符串，因为打包进二进制文件了所以不会 drop，我感觉，字面量被编译到二进制文件和这个字面量一旦加载到内存就不会 drop 之间没什么关系啊，或许中间还有其他的什么逻辑，但是如果说是直接相关真的难以理解

[xwlcn]

有点懵，下面这代码该如何解释：

use std::fmt::Debug;

fn print_it<T: Debug + 'static>( input: T) {
    println!( "'static value passed in is: {:?}", input );
}

#[derive(Debug)]
struct Test<T>(T);

fn main() {
    let x = 0;
    {
        let test = &Test(5);
        print_it(test); //通过
        let test1 = Test(6);
        let test2 = &test1;
        print_it(test2); //失败 borrowed value does not live long enough
    }
    println!("{}", x)
}

'static标注的对象必须跟剩下的程序一样久？上面代码明显test活不了那么久。上面代码只能表明'static针对的是引用指向的数据（其实这里应该说明一下，指的就是最初定义引用所指向的数据的位置那个变量，后面所有的引用变量都是与最初定义的变量的声明周期做对比），因为test2生命周期明显比test1短所以报错了，但说它活得跟程序一样久？

至于&'static与T: 'static的区别？两者都是针对引用指向的数据，好像也只是字面上的区别（函数参数传值与传址）：

use std::fmt::Debug;

fn print_it<T: Debug + 'static>( input: T) {
    println!( "'static value passed in is: {:?}", input );
}

fn print_it1<T: Debug >( input: &'static T) {
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    let i = 5;
    print_it(i);    //传值，由于`static针对的是引用的数据，所以能够通过

    //print_it(&i);   //把引用当作一个值传入，实际还是传值不是传址参数，相当于新建一个临时变量 let j = &i,然后调用print_it(j); j(&i)与最初定义其指向数据的i做比较，其生命周期比i短，所以报错了

    let x = 6;
    print_it1(&x);  //同上，也相当于传了个临时引用变量

    let y = &7;
    print_it1(y);   //通过

    //综上所诉，函数中标注`&'static`或`T: 'static`约束的，只能传入最早定义的变量或引用，也就是生命周期开始的地方，后续任何地方重新取引用的变量，
    //在传入被标记`&'static`或`T: 'static`约束的函数时，都是将参数T的生命周期与T指向数据（也就是最初定义它的地方）的生命周期做比较
}

[xwlcn]

看了一下前面的评论，&'static与T: 'static的区别好像还有，就是告诉编译器，其检测生命周期的数据类型，这里仅仅是字面意思，说&'static标注检测的是参数中的引用类型参数，T: 'static检测的是普通值类型，但两者实际上都是针对其引用指向的数据来判断的。
举个例子：

use std::fmt::Debug;

fn print_it<T: Debug + 'static>( input: &T) {
    println!( "'static value passed in is: {:?}", input );
}


fn main() {
    let i = 5;
    print_it(&i);   
}

上面代码之所以能够通过，是因为T: 'static约束的是普通T类型的参数，对于&T引用参数是不会进行检查的，如果需要检查&T参数，就需要用&'static的标注方法，下面代码则就不会通过，因为进行了生命周期检测，发现&i的生命周期不够长：

use std::fmt::Debug;

fn print_it<T: Debug>( input: &'static T) {
    println!( "'static value passed in is: {:?}", input );
}

fn main() {
    let i = 5;
    print_it(&i);
}

[xyt-dev]

变量名只有作用域没有周期，变量名只是个标记符号哪来的周期啊

[tjw123hh]

我的理解是T: 'static是

• 若T是一个引用或者是一个有生命周期的结构体，并且T引用的生命周期（其所指向的数据存活的时间）是'static。
• 否则，它的生命周期无论如何都满足'static

在使用泛型时，很多时候并不需要考虑有生命周期的情况，所以可以使用T: 'static来“满足和取悦编译器”

[sage417]

还得翻翻评论区，原文把我看晕了

[zhouzuoji]

我的理解是，T: Debug + 'static，的意思是T要么不包含引用，要么包含的引用生命周期必须长于'static

[loogn]

首先感谢大佬的无私奉献！不过感觉这一章说的不太明白，看下面的代码：

use std::fmt::Debug;
fn print_it<T: Debug + 'static>( input: T) {
println!( "'static value passed in is: {:?}", input );
}
#[derive(Debug)]
struct S;

fn main() {
let s=&S;
print_it(s);
}

下面文章写的比较清楚：
https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md#common-rust-lifetime-misconceptions

[3517277]

“大家有没有想过，到底是 &'static 这个引用还是该引用指向的数据活得跟程序一样久呢？”为什么和前面的"但是，&'static 生命周期针对的仅仅是引用，而不是持有该引用的变量，对于变量来说，还是要遵循相应的作用域规则 :“ ,怎么矛盾了？有点混乱。还有，前面的“get_memory_location”为什么不会立即回收？还能用指针指出？但我写了这段：

let mut p = 0usize;
    {
        let s = String::from("aaa");
        p = s.as_ptr() as usize;
    }let s2 = unsafe { from_raw_parts(p as *const u8, 6) };
let s3 =  String::from_utf8_lossy(s2);
println!("String from pointer: {:x}->{}",p, s3);

它的表现就是s2的内存，准确准时被回收，但我实在不明白，为什么上次我提问时的get_memory_location又不会及时回收的?