生命周期

他再也无法明白自己要什么，因为人的生命只有一次，我们既不能把它与我们以前的生活相比较，也无法使其完美之后再来度过。

思考下面的这个例子：

//抛出错误：error[E0106]: missing lifetime specifier
fn main(){
    let line:&str = "lang:en=hello world";
    let lang:&str = "en";
    let v:&str;
    {
        v = skip_prefix(line, lang);
    }
    println!("{}", v);
}

fn skip_prefix(par1:&str, par2:&str) -> &str{//expected lifetime parameter
    par1
}
//this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `par1` or `par2`

对于上面的那个例子，我们的编译器会报错，目前为止我也还是搞不明白。我的困惑就是，既然我们的函数明确指出来了返回的应该是par1这个引用的话，那么为什么报错信息里面还说什么不确定返回的到底是par1还是par2呢？这个问题留到以后更加明白的时候在解决吧。

1.使用生命周期来纠正上面的那个例子

利用生命周期的语法改写上面那个例子的话，那么就不会再报错了。看一下写法究竟是怎么样：

fn main(){
    let line:&str = "lang:en=hello world";
    let lang:&str = "en";
    let v:&str;
    {
        v = skip_prefix(line, lang);
    }
    println!("{}", v);//lang:en=hello world
}

fn skip_prefix<'a, 'b>(par1:&'a str, par2:&'b str) -> &'a str{
    par1
}

但是如果你怎样做的话那么就是不对的了：

//抛出错误：error[E0312]: lifetime of reference outlives lifetime of borrowed content...
fn main(){
    let line:&str = "lang:en=hello world";
    let lang:&str = "en";
    let v:&str;
    {
        v = skip_prefix(line, lang);
    }
    println!("{}", v);
}

fn skip_prefix<'a, 'b>(par1:&'a str, par2:&'b str) -> &'b str{
    //the reference is valid for the lifetime 'b as defined on the body
    par1
}

2.语法

'a读作生命周期a。技术上讲，每一个引用都有一些与之相关的生命周期，不过编译器再通常情况下允许对其进行省略。生命周期的声明需要放在<>里面，<>里面所支持的是一种泛型参数，生命周期也是泛型参数当中的一种。声明周期的使用就直接更在类型前面就OK了。你需要几个声明周期去显式利用，就显式声明多少个，对于函数而言，显示声明的周期的个数与函数参数无关。下面举一个例子：

fn main(){
    let line:&str = "lang:en=hello world";
    let lang:&str = "en";
    let num:i32 = 3;
    let v:&str;
    {
        v = skip_prefix(line, &num);
    }
    println!("{}", v);//lang:en=hello world
}

fn skip_prefix<'a>(par1:&'a str, par2:&i32) -> &'a str{
    par1
}

下面就声明周期的使用举几个例子：

• 1.&'a mut i32：一个带有声明周期'a的i32的可变引用
• 2.&'b str：一个带有声明周期'b的str的不可变引用

3.结构体与生命周期的碰撞

当我们定义结构体时，我们也会需要显式的生命周期。这是为什么呢？假如有一个结构体A的话，那么我们需要确保任何A的引用必须比结构成员活的更短，否则就有可能造成dangling pointer。下面看看具体用法：

fn main(){
  let num:&i32 = &9;
  let struct_obj:Foo = Foo{n: num};
  println!("{}", struct_obj.n);
}
struct Foo<'a>{
  n: &'a i32
}

如果你把生命周期参数给去掉的话，那么将会报错，如下所示：

//报错信息为：error[E0106]: missing lifetime specifier
fn main(){
  let num:&i32 = &9;
  let struct_obj:Foo = Foo{n: num};
  println!("{}", struct_obj.n);
}
struct Foo{
  n: &i32//expected lifetime parameter
}

4.impl块与生命周期的碰撞

当在impl块中使用生命周期的时候应该这样使用：

fn main(){
  let num:&i32 = &9;
  let struct_obj:Foo = Foo{n: num};
  println!("{}", struct_obj.get_n());
}
struct Foo<'a>{
  n: &'a i32
}
impl<'a> Foo<'a>{
  fn get_n(&self) -> &'a i32{self.n}
}

5.理解作用域

从代码的结构来看，我们可以看出变量的作用域所起始的地方也大致能够看出变量的作用域所结束的地方。对于这种问题所需要注意的是我们的变量一般都是存储在栈上的，而对于栈来说它的结构特点是：先进后出，所以说越早定义的变量那么它是最后出的，因此有这么一个需要注意的事项：先定义的变量不能够引用后定义的变量，否则由于后定义的变量会首先被销毁而报错。举个简单的例子：

fn main(){
  let y:&i32 = &9;//y的作用域开始出现
                  //|
                  //|
}                 //y离开它的作用域

分析下面这个例子：

//error: borrowed value does not live long enough
fn main(){
  let num1:&i32;
  {
    let num2:&i32 = &9;
    let foo:Foo = Foo{x: num2};
    num1 = foo.get_x();
  }//temporary value dropped here while still borrowed
}
struct Foo<'a>{
  x: &'a i32
}
impl<'a> Foo<'a>{
  fn get_x(&self) -> &'a i32{self.x}
}

问题就是出在前面提到的那点：先定义的变量引用了后定义的那个变量。由于后定义的变量先一步被销毁，但是先定义的那个变量仍旧需要和其进行绑定，所以报错。
这个问题，如果要修改的话，那么可以利用static关键字：

fn main(){
  let num1:&i32;
  {
    static TEMP:i32 = 9;
    let num2:&i32 = &TEMP;
    let foo:Foo = Foo{x: num2};
    num1 = foo.get_x();
  }
  println!("{}", num1);//9
}
struct Foo<'a>{
  x: &'a i32
}
impl<'a> Foo<'a>{
  fn get_x(&self) -> &'a i32{self.x}
}

6.'static

'static生命作用域是一个特殊的作用域，它具有横跨整个程序的生命周期。下面介绍一下简单用法：

let str:&'static str = "hello world!";
static FOO:i32 = 5;
let num:&i32 = &FOO;

END