Rust 特性

2024 年 8 月 29 日 | 阅读 6 分钟

Rust 特性是 Rust 语言的一个特性，它描述了每种类型可以提供的功能。
特性类似于其他语言中定义的接口的特性。
特性是一种将方法签名分组以定义一组行为的方式。
特性是使用 trait 关键字定义的。

trait 的语法

 trait trait_name
{
     //body of the trait.
}  

在上述情况下，我们声明特性，然后是特性名称。在花括号内，声明方法签名以描述实现该特性的类型的行为。

让我们看一个简单的例子

 struct Triangle
{
  base : f64,
  height : f64,
}
trait HasArea
{
  fn area(&self)->f64;
}

impl HasArea for Triangle
{
  fn area(&self)->f64
  {
    0.5*(self.base*self.height)
  }
}
fn main()
{
  let a = Triangle{base:10.5,height:17.4};
  let triangle_area = a.area();
  println!("Area of a triangle is {}",triangle_area); 
}

输出

Area of a triangle is 91.35

在上面的例子中，声明了一个名为 HasArea 的特性，其中包含 area() 函数的声明。 HasArea 在 Triangle 类型上实现。 area() 函数只需使用该结构的实例即可调用，即 a.area()。

特性作为参数

特性也可以用作许多不同类型的参数。

上面的例子实现了 HasArea 特性，并且它包含 area() 函数的定义。我们可以定义 calculate_area() 函数来调用 area() 函数，而 area() 函数是使用实现 HasArea 特性的类型的实例来调用的。

让我们看一下语法

 fn calculate_area(item : impl HasArea)
{
   println!("Area of the triangle is : {}",item.area());
 } 

通用函数上的特性边界

特性很有用，因为它们描述了不同方法的行为。但是，通用函数不遵循此约束。 **让我们通过一个简单的场景来理解这一点：**

 fn calculate_area<T>( item : T)
{
    println!(?Area of a triangle is {}?, item.area());
}

在上述情况下，Rust 编译器抛出一个“类型 T 中未找到名为的错误”。如果我们将特性绑定到通用 T，则可以克服以下错误

 fn calculate_area<T : HasArea> (item : T)
{
println!("Area of a triangle is {} ",item.area());


}

在上述情况下，<T: HasArea> 意味着“T 可以是任何实现 HasArea 特性的类型”。 Rust 编译器了解到任何实现 HasArea 特性的类型都将具有 area() 函数。

让我们看一个简单的例子

 trait HasArea
{
  fn area(&self)->f64;
}
struct Triangle
{
  base : f64,
  height : f64,
}

impl HasArea for Triangle
{
  fn area(&self)->f64
  {
    0.5*(self.base*self.height)
  }
}
struct Square
{
  side : f64,
}

impl HasArea for Square
{
  fn area(&self)->f64
  {
     self.side*self.side
  }
}
fn calculate_area<T : HasArea>(item : T)
{
  println!("Area is : {}",item.area());
}

fn main()
{
  let a = Triangle{base:10.5,height:17.4};
  let b = Square{side : 4.5};
  calculate_area(a);
  calculate_area(b);
}

输出

Area is : 91.35
Area is : 20.25

在上面的例子中，calculate_area() 函数是通用的，超过“T”。

实现特性的规则

实现特性有两个限制

如果特性未在您的范围内定义，则无法在任何数据类型上实现它。

让我们看一个简单的例子

 use::std::fs::File;
fn main()
{
  let mut f = File::create("hello.txt");
  let str = "javaTpoint";
  let result = f.write(str);
}

输出

error : no method named 'write' found.
           let result = f.write(str);

**在上述情况下，Rust 编译器抛出一个错误，即“未找到名为“write”的方法”，因为** use::std::fs::File; 命名空间不包含 write() 方法。因此，我们需要**使用 Write 特性来删除编译错误**。

我们正在实现的特性必须由我们定义。例如：如果我们定义了**HasArea**特性，那么我们可以在类型 i32 上实现此特性。但是，我们无法为类型 i32 实现 Rust 定义的**toString**特性，因为类型和特性都没有在我们的 crate 中定义。

多个特性边界

使用 '+' 运算符。

如果要绑定多个特性，则使用 + 运算符。

让我们看一个简单的例子

 use std::fmt::{Debug, Display};
fn compare_prints<T: Debug + Display>(t: &T)
 {
 println!("Debug: '{:?}'", t);
 println!("Display: '{}'", t);
}





fn main() {
    let string = "javaTpoint";
    compare_prints(&string);
    }

输出

Debug: ' "javaTpoint"'
Display: ' javaTpoint'

在上面的例子中，Display 和 Debug 特性通过使用 '+' 运算符绑定到类型 'T'。

使用 'where' 子句。
- 可以使用 'where' 子句编写一个边界，该子句出现在左括号 '{' 之前。
- 'where' 子句也可以应用于任意类型。
- 当使用 'where' 子句时，它使语法比普通语法更具表现力。

让我们来看看

 fn fun<T: Display+Debug, V: Clone+Debug>(t:T,v:V)->i32
{
     //block of code;
} 

当在上述情况下使用 'where' 时

 fn fun<T, V>(t:T, v:V)->i32
   where T : Display+ Debug, 
              V : Clone+ Debug
{
        //block of code;
}

在上述情况下，我们使用 'where' 子句的第二种情况使程序更具表现力和可读性。

让我们看一个简单的例子

 trait Perimeter
{
  fn a(&self)->f64;
}
struct Square
{
  side : f64,
}
impl Perimeter for Square
{
  fn a(&self)->f64
  {
    4.0*self.side
  }
}
struct Rectangle
{
 length : f64,
 breadth : f64,
}
impl Perimeter for Rectangle

{
 fn a(&self)->f64
 {
   2.0*(self.length+self.breadth)
 }
}
fn print_perimeter<Square,Rectangle>(s:Square,r:Rectangle)
  where Square : Perimeter,
        Rectangle : Perimeter
		{
		  let r1 = s.a();
		  let r2 = r.a();
		  println!("Perimeter of a square is {}",r1);
		  println!("Perimeter of a rectangle is {}",r2);
		}
		fn main()
		{
		  let sq = Square{side : 6.2};
		  let rect = Rectangle{length : 3.2,breadth:5.6};
		  print_perimeter(sq,rect);
		}

输出

Perimeter of a square is 24.8
Perimeter of a rectangle is 17.6

默认方法

如果方法的定义已知，则可以将默认方法添加到特性定义中。

让我们来看看

 trait Sample
{ 
   fn a(&self);
   fn b(&self)
   {
       println!("Print b");
   } 
} 

在上述情况下，将默认行为添加到特性定义中。我们也可以覆盖默认行为。**让我们通过一个例子来看一下这种情况：**

 trait Sample
{
 fn a(&self);
 fn b(&self)
 {
   println!("Print b");
 } 
} 

struct Example
{
 a:i32,
 b:i32,
}



impl Sample for Example
{
  fn a(&self)
  {
    println!("Value of a is {}",self.a);
  }
  
  fn b(&self)
  {
    println!("Value of b is {}",self.b);
  }
}
fn main()
{
  let r = Example{a:5,b:7};
  r.a();
  r.b();  
}

输出

Value of a is : 5
Value of b is : 7

在上面的例子中，在特性中定义的 b() 函数的行为被覆盖。因此，我们可以得出结论，我们可以覆盖在特性中定义的方法。

继承

从另一个特性派生的特性称为继承。有时，实现需要实现另一个特性的特性是必需的。如果要从 'A' 特性派生 'B' 特性，则看起来像

让我们看一个简单的例子

 trait A
{
  fn f(&self);
}
trait B : A
{
  fn t(&self);
}
struct Example
{
  first : String,
  second : String,
}
impl A for Example
{
  fn f(&self)
  {
 
   print!("{} ",self.first);
  }

 }
 impl B for Example
 {
  fn t(&self)
  {
    print!("{}",self.second);
  }
}
fn main()
{
  let s = Example{first:String::from("javaTpoint"),second:String::from("tutorial")};
  s.f();
  s.t();
}

输出