In Rust, the term “class” is not used to refer to a particular language construct. Instead, Rust has several other language constructs that can be used to achieve similar goals as classes in other programming languages.
One way to define a type that has both data and behavior in Rust is to use a struct to define the data and a set of methods on the struct to define the behavior. For example:
struct Point {
x: f64,
y: f64,
}
impl Point {
fn new(x: f64, y: f64) -> Point {
Point { x, y }
}
fn distance_from_origin(&self) -> f64 {
(self.x.powi(2) + self.y.powi(2)).sqrt()
}
}
fn main() {
let p = Point::new(3.0, 4.0);
println!("Distance from origin: {}", p.distance_from_origin());
}
In this example, the Point struct represents a 2D point with x and y coordinates. The impl block defines two methods on the Point struct: a constructor method called new that creates a new point, and a method called distance_from_origin that calculates the distance of the point from the origin.
You can also use enums to define types with data and behavior. For example:
enum Shape {
Circle { center: Point, radius: f64 },
Rectangle { top_left: Point, bottom_right: Point },
}
impl Shape {
fn area(&self) -> f64 {
match self {
Shape::Circle { radius, .. } => std::f64::consts::PI * radius.powi(2),
Shape::Rectangle { top_left, bottom_right } => {
(bottom_right.x - top_left.x) * (top_left.y - bottom_right.y)
}
}
}
}
fn main() {
let c = Shape::Circle {
center: Point::new(0.0, 0.0),
radius: 1.0,
};
println!("Circle area: {}", c.area());
let r = Shape::Rectangle {
top_left: Point::new(0.0, 0.0),
bottom_right: Point::new(3.0, 4.0),
};
println!("Rectangle area: {}", r.area());
}
In this example, the Shape enum represents a shape that can be either a circle or a rectangle. The area method is defined in an impl block for the Shape enum and uses a match expression to calculate the area of the shape based on its variant.
here is an example of how you can define a struct to represent a 3D triangle and implement a method to transform the triangle’s vertices using a coordinate transformation matrix:
struct Triangle {
vertices: [Point3D; 3],
}
impl Triangle {
fn new(vertices: [Point3D; 3]) -> Triangle {
Triangle { vertices }
}
fn transform(&self, matrix: [[f64; 4]; 4]) -> Triangle {
Triangle {
vertices: [
self.vertices[0].transform(matrix),
self.vertices[1].transform(matrix),
self.vertices[2].transform(matrix),
],
}
}
}
#[derive(Copy, Clone)]
struct Point3D {
x: f64,
y: f64,
z: f64,
}
impl Point3D {
fn new(x: f64, y: f64, z: f64) -> Point3D {
Point3D { x, y, z }
}
fn transform(&self, matrix: [[f64; 4]; 4]) -> Point3D {
let x = self.x * matrix[0][0] + self.y * matrix[1][0] + self.z * matrix[2][0] + matrix[3][0];
let y = self.x * matrix[0][1] + self.y * matrix[1][1] + self.z * matrix[2][1] + matrix[3][1];
let z = self.x * matrix[0][2] + self.y * matrix[1][2] + self.z * matrix[2][2] + matrix[3][2];
Point3D::new(x, y, z)
}
}
fn main() {
let triangle = Triangle::new([
Point3D::new(-0.5, -0.5, 0.0),
Point3D::new(0.0, 0.5, 0.0),
Point3D::new(0.5, -0.5, 0.0),
]);
let rotation_matrix = [[0.0, 0.0, 1.0, 0.0],
[0.0, 1.0, 0.0, 0.0],
[-1.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 1.0]];
let rotated_triangle = triangle.transform(rotation_matrix);
// Use the transformed triangle to draw or perform some other operation
}
Leave a Reply