专栏简介：本专栏作为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 块中，你可以定义与你的类型相关联的函数，而方法是一种相关联的函数，让你指定结构体的实例所具有的行为。