专栏简介：本专栏作为Rust语言的入门级的文章，目的是为了分享关于Rust语言的编程技巧和知识。对于Rust语言，虽然历史没有C++、和python历史悠远，但是它的优点可以说是非常的多，既继承了C++运行速度，还拥有了Java的内存管理，就我个人来说，还有一个优点就是集成化的编译工具cargo，语句风格和C++极其相似，所以说我本人还是比较喜欢这个语言，特此建立这个专栏，作为学习的记录分享。

日常分享：每天努力一点，不为别的，只是为了日后，能够多一些选择，选择舒心的日子，选择自己喜欢的人！

---

结构体的定义和实例化

和c++/c语言一样，Rust语言也有结构体，和元组一样，结构体中的变量数据类型是可以不同的，而且只需要引用符就可以得到其中的数据。

struct Buffer{
  length:usize,
  width:usize,
  flag:bool,
  name:String,
}

fn main() 
{
  let mut buffer = Buffer{
    length:90,
    width:100,
    flag:true,
    name:String::from("test"),
  }; 
  println!("{}", buffer.length);
}

在数据结构中，c/c++语言均可以用结构体数据类型定义函数，作为函数的返回值类型，在Rust中，也可以作为函数的返回类型。

fn return_Buffer(length:usize,flag:bool)->Buffer {
  Buffer{
    length:length,
    width:100,
    flag:flag,
    name:String::from("test"),
  }
}

 这里的函数就是返回结构体类型，但是重复写了length,flag等字段，可以采用字段初始化简写语法，也就是不用写具体的变量值，只需要写字段名，但前提是参数和字段名是一样的。

fn return_Buffer(length:usize,flag:bool)->Buffer {
  Buffer{
    length,
    width:100,
    flag,
    name:String::from("test"),
  }
}

结构体更新语法

struct Buffer{
  length:usize,
  width:usize,
  flag:bool,
  name:String,
}

fn main() 
{
  let mut buffer = Buffer{
    length:90,
    width:100,
    flag:true,
    name:String::from("test"),
  }; 
  let mut buffer_two=Buffer{
    length:buffer.length,
    width:50,
    flag:false,
    name:buffer.name,
  };
  let mut buffer_three = Buffer{
    flag:true,
    ..buffer_two
  };
  println!("{}", buffer.length);

}
fn return_Buffer(length:usize,flag:bool)->Buffer {
  Buffer{
    length,
    width:100,
    flag,
    name:String::from("test"),
  }
}

上面这段例子就是指的是 利用其他的结构体变量来创建一个新的结构体变量。虽然代码看起来比较简单，但是这其中却有很多的知识。比如，在Buffer结构体中定义了一个String数据类型的变量，那么我们在利用buffer创建buffer_two后，buffer就失去了作用，这一点在前面的数据类型章节中已经讲过了。同样的道理，在创建buffer_three变量的时候，我们先是定义了flag字段的值，然后剩于字段全部使用buffer_two变量，由于也使用了name字段，所以buffer_two变量失去作用，但是如果只是使用其他的字段，则依然有效。如下：

  let mut buffer_three = Buffer{
    name:String::from("alice"),
    ..buffer_two
  };
  println!("{}",buffer_two.name);

这里声明一下，虽然buffer已经丧失作用，这只是代表这个变量不再有作用，但是他当中的非string类型字段还有作用，因为他们本身就已经是变量了。

使用没有命名字段的元组结构体来创建不同的类型

元组结构体，利用元组来对结构体进行定义，或者说是以元组的方式来进行定义结构体。

struct Bufferlines(i32,i32,i32);
struct Bufferline(u32,u32,u32);
let mut buffer_fine=Bufferline(32,34,45);
  let mut buffer_fine_two = Bufferlines(32,34,45);
  println!("{}",buffer_fine.1);

没有任何字段的类单元结构体

在Rust语言中，有一种结构体叫做类单元结构体，其实这个大概意思就是说定义一个结构体，但是不包含任何的数据类型，也就相当于一个空壳。

struct Bufferclong; //定义一个类单元结构体
let mut buffer_four=Bufferclong; //定义一个类单元结构体变量。

结构体示例程序

结构体的使用在很多的方面都可以使用，在c语言中的数据结构的学习中就用到了结构体，结构体的实用性在于它可以存储很多数据类型的变量，使得代码简介，增强代码的完整性。

//定义一个结构体
struct Rectangle
{
  width: usize,
  height: usize,
}

fn main(){
  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  println!("The area is {}",area(&rect));

}
fn area(rect: &Rectangle) ->usize { 
  return rect.width * rect.height;  //如果不使用return关键字，则不需要分号
}

这里我们定义了一个结构体，定义了width和height两个字段 ，类型定义的时usize（无论是32位的还是64位的电脑都可以跑），然后就是创建了一个实体，并对字段赋值。然后调用已经定义好的求面积函数。在这里要特别说明一下，定义函数的时候，参数是结构体的引用类型了，这个原因和前面讲解的所有权属性有关。如果我们不使用引用，则在传参后原本定义的结构体实例对象就无法再使用了。所以这里使用引用也是为了后面可以继续使用该对象。

通过派生trait增加实用功能

我们在使用println!()宏的时候，虽然可以输出绝大多数的数据内容，但是却无法直接输出结构体实体对象。那么有什么方法嘛？

我们先来看一下使用println!()会报什么错误。

`Rectangle` doesn't implement `std::fmt::Display`
  --> src/main.rs:14:17
   |
14 |   println!("{}",rect);
   |                 ^^^^ `Rectangle` cannot be formatted with the default formatter
   |
   = help: the trait `std::fmt::Display` is not implemented for `Rectangle`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)

上面的这段报错，我们可以看到报错给出了解决方法，我们尝试使用报错给出的解决方法试试：

println!("{:#?}",rect);
   |                    ^^^^ `Rectangle` cannot be formatted using `{:?}`

我们发现还是报错，不过报错给出了一个信息，增加一个Debug。

//定义一个结构体
#[derive(Debug)]
struct Rectangle
{
  width: usize,
  height: usize,
}

fn main(){
  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  println!("The area is {}",area(&rect));
  println!("{:#?}",rect);

}
fn area(rect: &Rectangle) ->usize { 
  return rect.width * rect.height;  //如果不使用return关键字，则不需要分号
}

通过 上面增加的显示代码，我们已经可以打印出结构体了。那么还有没有其他的简单的方法？

dbg!宏

dbg！宏和println!宏有点不一样的是，dbg！宏接受的是表达式的所有权，而println！接受的是引用。这个如果不理解的话，下面看一个例子。

//定义一个结构体
#[derive(Debug)]
struct Rectangle
{
  width: usize,
  height: usize,
}

fn main(){
  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  println!("The area is {}",area(&rect));
  println!("{:#?}",rect); //第一次打印
  println!("{:?}",rect);//第二次使用println！打印
  //使用dbg！打印
  dbg!(rect); //第一次打印
  dbg!(rect);//第二次打印,此时运行错误，rect已经便不再具有所有权。


}
fn area(rect: &Rectangle) ->usize { 
  return rect.width * rect.height;  //如果不使用return关键字，则不需要分号
}

上面使用println！宏可以连续打印，但是使用dbg！宏只能打印一次，此后这个变量就不再具有所有权。所有权已经转移。所以运行上述代码就会出现报错。

let mut rect = Rectangle{
   |       -------- move occurs because `rect` has type `Rectangle`, which does not implement the `Copy` trait
...
18 |   dbg!(rect); //第一次打印
   |   ---------- value moved here
19 |   dbg!(rect);//第二次打印,此时运行错误，rect已经便不再具有所有权。
   |        ^^^^ value used here after move

 如果不想让dbg！获取表达式的所有权，那么就在调用dbg！的时候传递引用参数。诸如dbg!(&rect);

impl语法

前面我们定义的area函数，如果需要使用则需要进行传参，重要的是，我们定义的很多函数可能不会调用结构体变量，但是我们在与结构体有关的函数时，就会显得非常麻烦。为了解决这种麻烦，Rust推出了impl语法。

定义方法

我们先来看一个实例：

//定义一个结构体
#[derive(Debug)]
struct Rectangle
{
  width: usize,
  height: usize,
}
impl Rectangle {
  fn area(&self) ->usize { 
    return self.width * self.height;  //如果不使用return关键字，则不需要分号
  }
}

fn main(){
  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  println!("{}", rect.area());

}

 上面的代码中，我们用impl定义了一个快，这个块中的所有内容都将与Rectangle类型相关联。参数使用的是&self,这是用来替代rectangle:&Rectangle。这就表示我们可以使用结构体实例中的属性。每个与结构体关联的函数，第一个参数都必须是&self，后面的参数根据自己需要来添加。

Rust中的自动引用和解引用：

C/C++中有解引用和引用，这两个概念相信很多熟悉c++的小伙伴都知道这个概念，这里就不过多介绍了。

Rust中取消了这种复杂的机制，也就是说我们不需要考虑是否需要解引用，直接用属性操作符就可以了。

 多个参数

//定义一个结构体
#[derive(Debug)]
struct Rectangle
{
  width: usize,
  height: usize,
}
impl Rectangle {
  fn area(&self) ->usize { 
    return self.width * self.height;  //如果不使用return关键字，则不需要分号
  }
  fn hold(&self,other: &Rectangle) -> bool {
    self.width > other.width && self.height > other.height
  }
}

fn main(){
  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  let mut rect2 = Rectangle{
    width:40,
    height:50,
  };
  let mut rect3 = Rectangle{
    width:20,
    height:30,
  };
  println!("{}", rect.hold(&rect2));
  println!("{}", rect2.hold(&rect3));

}

上面这段代码可能很多人没看懂是什么意思，其实简单的看就是，在impl块中又定义了一个比较长宽大小的函数，而比较明显的是，多了一个参数（other:&Rectangle），这是表示我们这里使用另一个Rectangle实例，不再是使用一个结构体实例。那么如果我们要多几个不是结构体实例的参数又该如何？

 fn get_v(&self,length:usize) -> usize {
    self.width * self.height*length
  }

在impl块中增加上述代码，便可以得到长方体的体积，这里新增加的一个参数，使用的是usize类型。为什么不使用other喃？

impl块中函数的多个参数的设定规则：

1、如果要使用多个参数，那么第一个参数必须是&self。

2、如果要使用统一个结构体类型的不同实例，则需要添加other来区分。

3、如果只是增加普通的参数，则直接在后面添加即可。

关联函数

在官方的定义中，所有在impl块中的函数均被称作关联函数，我们前面说，如果要定义一个结构体的关联函数，那么第一个参数必须是&self，但是我们也可以不使用&self作为第一个参数，但是这就不再算是方法，并不能作用于结构体的实例。

不是方法的关联函数经常被用作返回一个结构体新实例的构造函数。这些函数的名称通常为 new ，但 new 并不是一个关键字。

例如：

impl Rectangle{
  fn new(size:usize,length:usize)->Self{
    Self{
      width:size,
      height:length,
    }
  }
}

然后在主函数中调用：

let mut rects = Rectangle::new(34,45);

println!("{}", rects.area());

这里的调用方式不再是使用实例进行调用，而是使用：：进行调用，这个是由于该函数只是被建立在结构体的命名空间中，而未获得实例，所以需要使用::进行调用，后面会细讲。

多个impl块

在Rust语言中，一个结构体是允许存在多个impl块的，就像上述的代码一样，关于这个性能，后面需要的时候再慢慢讲解，初学者只需要指导就好，下面是本节内容的所有代码，如果相对本节知识有所了解的话，可以仔细看一下。

//定义一个结构体
#[derive(Debug)]
struct Rectangle
{
  width: usize,
  height: usize,
}
impl Rectangle {
  fn area(&self) ->usize { 
    return self.width * self.height;  //如果不使用return关键字，则不需要分号
  }
  fn get_v(&self,length:usize) -> usize {
    self.width * self.height*length
  }
  fn hold(&self,other: &Rectangle) -> bool {
    self.width > other.width && self.height > other.height
  }
}

impl Rectangle{
  fn new(size:usize,length:usize)->Self{  //相当于是结构体的构造函数
    Self{
      width:size,
      height:length,
    }
  }
}
fn main(){
  let mut rects = Rectangle::new(34,45);
  println!("{}", rects.area());

  let mut rect = Rectangle{
    width: 30,
    height: 50,
  };
  let mut rect2 = Rectangle{
    width:40,
    height:50,
  };
  let mut rect3 = Rectangle{
    width:20,
    height:30,
  };
  println!("{}", rect.hold(&rect2));
  println!("{}", rect2.hold(&rect3));
  println!("The rect2 体积是：{}",rect2.get_v(20));

}

总结

本节的内容主要就是讲解结构体中的相关知识，通过结构体，我们可以将相关联的数据片段联系起来并命名它们，这样可以使得代码更加清晰。在 impl 块中，你可以定义与你的类型相关联的函数，而方法是一种相关联的函数，让你指定结构体的实例所具有的行为。