advance/lifetime/static

[giscus[bot]]

advance/lifetime/static

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

[siu91]

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

[fadedzipper]

本来它就是引用，引用走出作用域的时候不会释放掉引用的值。这个和之前所有权是一致的。

[liuzhaomincoding]

可以回顾下进程地址空间的内容，其实如果你去设计的话，也会是这个样子

[duanyuluo]

内存除了heap和stack，这些当然需要释放。还有程序本身加载的内存段，你想释放，只能把进程退掉了。rs我不太清楚，在c里面可以动态的加载和释放dll，程序运行期间，如果unload某个dll，这个dll里面声明的static数据都会被释放掉。参考https://stackoverflow.com/questions/18359297/is-unloading-dll-done-before-making-free-static-memory

[hookover]

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

[Endermanbugzjfc]

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

[mxismean]

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

[mxismean]

完了，已经学废了

[sunface]

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

[JackySu]

&'static表示的是任意一种从头活到尾的类型比如string，实际用途更偏向于指针，表示指向一种生命周期为'static的数据类型，T:'static更偏向于泛型，用于定义一种类型

[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，拥有所有权，所以让它通过了

[youguanxinqing]

我感觉你的理解更正确一些，作者的理解有些说不通。

[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);
}

[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 这个引用还是该引用指向的数据活得跟程序一样久呢？

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

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

[tanielyao]

let s1 = "String".to_string();

// s1 虽然没有 'static 生命周期，但是它依然可以满足 T: 'static 的约束
// 充分说明这个约束是多么的弱。。
static_bound(&s1);

fn static_bound<T: Display + 'static>(t: &T) {
println!("{}", t);
}
这段有问题吧，s1是String类型属于owned data types, 任何owned data type都是符合‘static生命周期的

[yuanzhixiang]

感觉大家理解的差不多了，再给大家上点强度。为什么下面的例子能够编译成功

fn main() {
    fn lifecycle<'a: 'static>(string: &'a Y) {
    }

    let x = &X(&Y());
    lifecycle(x.0);
}

#[derive(Debug)]
struct X<'a>(&'a Y);

#[derive(Debug)]
struct Y();

[ziyoung]

在 特征对象 一节中，如果一个函数的参数是特性，需要写成如下的形式：

fn display(d: &dyn Display) {
  todo!();
}

如果让函数支持泛型的话，就不用 dyn 了。

fn display<T: Display>(d: T) {
  todo!();
}

遇到类似的场景，该如何去选择呢？

[xfront]

个人理解， T: 'static是用来限定T结构体布局的，内部如果有引用，它就得也是'static吧。

[Lixuhuilll]

生命周期就是针对引用的，避免悬空指针，'static 如果作用在引用上，表示引用所指向的数据活的和程序一样久，如果作用在其他的类型上，表示类型不会持有非 'static 的引用

[jiuliyemingzhi]

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

我认为这段话描述是有问题的

我认为可以换成以下描述

fn main() {
    let i = 5;

    print_it(&i);
}

这里传入的是&i所以传入的是&T、类型 原来检查的是传入类型T ，后来检查的是传入类型&T， 传入类型不变 但是对类型额检查变了 &T实在函数内部声明的 所有生命周期只有在函数块内有效 而不是整个生命周期， 而T是代码字面量5而来 是真正的‘static类型

[Lixuhuilll]

T:'static 跟内容从何而来应该没什么关系吧，它限制的要求应该是程序运行的任意时刻，T类型都不会出现悬空引用，比如如下的代码 str 的内容是运行时用户输入而来，可以顺利编译运行。

use std::fmt::Debug;

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

fn main() {
    let mut str = String::new();

    std::io::stdin().read_line(&mut str).unwrap();

    print_it(str);
}

[zcjie1]

不是这样理解的吧，我认为对T: 'static是要分类讨论的（因为生命周期的概念仅仅针对引用有效）：

1. T是引用时，要保证引用的某个对象是static的
2. T不是引用时，直接通过

[Lixuhuilll]

我重新测试了一下，T如果是引用应该保证引用的对象 'static，T如果是对象，则对象内部不能持有非 'static 的引用

use std::fmt::Debug;

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

#[derive(Debug)]
struct MaybeStatic<'a> {
    msg: &'a str,
}

fn main() {
    let has_static = MaybeStatic { msg: "Is is static" };
    
    let str = String::from("Is not static");
    let not_static = MaybeStatic { msg: &str };

    print_it(has_static);
    // print_it(not_static);
}

[Lixuhuilll]

不是这样理解的吧，我认为对T: 'static是要分类讨论的（因为生命周期的概念仅仅针对引用有效）：

1. T是引用时，要保证引用的某个对象是static的
2. T不是引用时，直接通过

你可以看看我刚刚对你的回复，传入的是同一个类型，却因为内部持有的引用生命周期不同，而导致了不同的结果。

[zcjie1]

总结

str，&str和String有什么区别

1. str是字面值，在程序运行过程中不会改变的（但是在定义时，是长度可变的）
2. 由于str在定义时长度可变，编译器无法提前预知str类型的长度，所以有了&str类型。
   &str类型本质上就是一个指针，长度固定
3. String则是为了解决str在程序运行过程中无法改变的痛点，同时满足动态定义和动态改变

&'static解析

首先明确一点，生命周期概念是针对 “引用” 设立的。对于非引用类型（比如普通的i32，u32，String等）都无效了

再看 “&'static” 长的这个鸟样，是不是和上面提到的&str很像。由此可得，'static要求的是str，要求的是被引的对象。
表达得不好，看下面这段示例代码，就可以理解了：

use std::fmt::Display;

fn mian() {
    static A_STATIC: i32 = 1;
    let a = 2;
    {
        let b = 3;
        static_bound(b);        // 正确，不为引用类型
        //static_bound(&b);     // 错误，引用类型，且生命周期不为static
    }
    static_bound(a);            // 正确，不为引用类型
    //static_bound(&a);         // 错误，引用类型，且生命周期不为static
    static_bound(A_STATIC);     // 正确，不为引用类型
    static_bound(&A_STATIC);    // 正确，引用类型，且生命周期为static
}

fn static_bound<T: Display + 'static>(t: T) {
    println!("{t}");
}

T: 'static解析

对于 "T: 'static" ，需要分类讨论：

1. 当T是普通类型（非引用）时，则直接通过要求，不检查static
2. 当T时引用类型时，检查被引用的对象是否为static。static通过，非static打回去

#个人浅薄理解，欢迎指正

[Lixuhuilll]

你的代码里少了一个关键的种类，那就是当一个类型内部持有引用的时候。
这种情况下，即便这个类型传进去的时候不是个引用，并且它持有的那个引用在函数执行的过程中是安全的，只要它持有的引用的生命周期不是'static，就无法通过编译检查。

use std::fmt::Debug;

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

#[derive(Debug)]
struct MaybeStatic<'a> {
    msg: &'a str,
}

fn main() {
    let has_static = MaybeStatic { msg: "It is static" };
    
    let str = String::from("Is not static");
    let not_static = MaybeStatic { msg: &str };

    print_it(has_static);
    // print_it(not_static);
}

[zcjie1]

感谢，我确实没有考虑到复合类型的情况

[777nit]

'static T
表示就算 scope 里的其他数据死完了，T 也活着，可以放心使用，开发者也必须给我这种生命周期的数据。
&‘static T
表示就算 scope 里的其他数据死完了，T 这个引用和 T 引用指向的数据都还活着，可以放心使用，开发者也必须给我这种生命周期的数据。
'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]

我的理解也是这样

[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. 所有权对象

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