Rust特质trait用法介绍

本文概述

• 特质论证
• 泛型函数的特质界限
• 特质实施规则
• 多重性状界限
• 默认方法
• 遗产

• Rust特质是Rust语言的一种功能, 它描述了它可以提供的每种类型的功能。
• 特质与其他语言中定义的接口的功能相似。
• 特征是一种将方法签名分组以定义一组行为的方法。
• 通过使用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上实现。通过使用结构实例即a.area()可以简单地调用area()函数。

特质论证

性状还可以用作许多不同类型的参数。

上面的示例实现了HasArea特性, 其中包含area()函数的定义。我们可以定义调用area()函数的calculate_area()函数, 并使用实现HasArea特征的类型的实例来调用area()函数。

让我们看一下语法：

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 = "srcmini";
  let result = f.write(str);
}

输出

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

在上述情况下, Rust编译器会抛出一个错误, 即use :: std :: fs :: File;”找不到名为’write’的方法”；名称空间不包含write()方法。因此, 我们需要使用Write特征来消除编译错误。

• 我们要实现的特征必须由我们定义。例如：如果定义HasArea特性, 则可以为i32类型实现此特性。但是, 我们无法实现Rust为i32类型定义的toString特性, 因为类型和特性均未在包装箱中定义。

多重性状界限

• 使用” +”运算符。

如果要绑定多个特征, 可以使用+运算符。

让我们看一个简单的例子：

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





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

输出

Debug: ' "srcmini"'
Display: ' srcmini'

在上面的示例中, 使用” +”运算符将”显示”和”调试”特征限制为” 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 B : A;

让我们看一个简单的例子：

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("srcmini"), second:String::from("tutorial")};
  s.f();
  s.t();
}

输出

srcmini tutorial

在上面的示例中, 我们的程序正在实现’B’特性。因此, 它还需要实现” A”特性。如果我们的程序未实现’A’特征, 则Rust编译器将引发错误。