22. Rust 제네릭

제네릭 은 런타임에 데이터 유형을 지정할 수 있는 메커니즘입니다.

제네릭 의 가장 큰 장점 은 하나의 코드 세트를 여러 유형에 적용할 수 있다는 것입니다. 예를 들어, 벡터는 정수 벡터일 수도 있고 문자열 벡터일 수도 있습니다.

제네릭은 데이터 보안과 유형 안전성을 보장할 뿐만 아니라 코드 양도 줄일 수 있습니다. 그러므로 패러다임이 없는 현대 언어는 전혀 쓸모가 없습니다.

Rust 언어의 제네릭에는 주로 일반 컬렉션 , 일반 구조 , 일반 함수 , 일반 열거형 및 특성이 포함됩니다 .

22.1 Rust 언어의 제네릭

Rust 데이터 유형을 지정하여 일반적인 것을 구현하는 구문입니다. 여기서 T는 모든 데이터 유형이 될 수 있습니다.

예를 들어, 다음 두 가지 유형

1. age: i32
2. age: String

제네릭을 사용하면 다음과 같이 직접 선언할 수 있습니다.

1. age:T

그런 다음 사용 중에 T 유형을 i32 또는 String 으로 지정하십시오 .

22.2 일반 컬렉션

일상적으로 사용하는 경우 가장 일반적인 일반 애플리케이션은 collection 입니다 .

예를 들어, 우리가 사용한 벡터 Vec입니다. 문자열 벡터일 수도 있고 정수 벡터일 수도 있습니다.

다음 코드에서는 정수 벡터를 선언합니다.

1. fn main(){
2. let mut vector_integer: Vec<i32> = vec![20,30];
3. vector_integer.push(40);
4. println!("{:?}",vector_integer);
5. }

위의 Rust 예제를 컴파일하고 실행하면 출력 결과는 다음과 같습니다.

1. [20, 30, 40]

정수가 아닌 매개변수를 정수 벡터에 전달하면 오류가 보고됩니다.

1. fn main() {
2. let mut vector_integer: Vec<i32> = vec![20,30];
3. vector_integer.push(40);
4. vector_integer.push("hello");
5. //오류[E0308]: 유형 불일치
6. println!("{:?}",vector_integer);
7. }

위의 코드에서 볼 수 있듯이 정수 벡터에는 정수 매개변수만 추가할 수 있습니다. 문자열 매개변수를 추가하려고 하면 오류가 보고됩니다.

어떤 면에서 제네릭은 컬렉션을 더욱 다양하고 안전하게 만듭니다.

22.3 일반 구조

또한 구조를 일반으로 선언할 수도 있습니다. 일반 구조는 주로 구조의 멤버 유형이 일반일 수 있음을 의미합니다.

일반 구조의 정의 구문은 다음과 같습니다.

1. struct struct_name<T> {
2. field:T,
3. }

예를 들어, 멤버 값이 하나만 있고 유형이 제네릭인 일반 구조 Data를 정의할 수 있습니다.

1. struct Data<T> {
2. value:T,
3. }

일반 구조 구문과 일반 구조 인스턴스 데이터를 함께 비교하면 일반 구조와 일반 구조의 차이점을 쉽게 구분할 수 있습니다.

22.3.1 예

다음 예에서는 방금 정의한 일반 구조 Data를 사용하여 일반 구조를 사용하는 방법을 보여줍니다.

1. fn main() {
2. // 제네릭은 i32입니다.
3. let t:Data<i32> = Data{value:350};
4. println!("value is :{} ",t.value);
5. // 일반은 문자열입니다.
6. let t2:Data<String> = Data{value:"Tom".to_string()};
7. println!("value is :{} ",t2.value);
8. }
9.  
10. struct Data<T> {
11. value:T,
12. }

위의 Rust 예제를 컴파일하고 실행하면 출력 결과는 다음과 같습니다.

1. value is :350
2. value is :Tom

22.4 특성

Rust 언어에는 클래스 개념이 없으므로 인터페이스 개념도 취소되었습니다.

그러나 인터페이스 없이 두 구조 간의 관계를 어떻게 증명할 수 있습니까?

이를 위해 Rust는 Traits 개념을 제공합니다 .

우리가 계란볶음밥을 이야기하는 이유는 많은 언어에 특이성이라는 개념이 있기 때문입니다.

Rust는 여러 구조에 걸쳐 일련의 표준 동작(메서드)을 구현하는 데 사용되는 특성 개념을 제공합니다.

어떤 면에서 Rust 언어에는 인터페이스 개념이 없지만 특성은 실제로 인터페이스입니다.

22.4.1 특성 정의 구문

Rust 언어는 특성을 정의하기 위한 특성 키워드를 제공합니다 .

특성은 실제로 메소드 프로토타입 세트입니다. 구문 형식은 다음과 같습니다

1. trait some_trait {
2.  
3. // 구현이 필요 없는 가상 메서드
4. fn method1(&self);
5.  
6. // 특정 구현을 사용한 일반적인 방법
7. fn method2(&self){
8. //메소드의 특정 코드
9. }
10. }

문법 형식에서 기능에는 구체적인 메서드(구현이 있는 메서드) 또는 추상 메서드(특정 구현이 없는 메서드)가 포함될 수 있습니다.

특성을 구현하는 구조 간에 메서드 정의를 공유하려면 구체적인 메서드를 사용하는 것이 좋습니다.

특성을 구현하는 구조 자체에서 메서드 정의를 정의하려면 추상 메서드를 사용하는 것이 좋습니다.

메서드가 구체적인 메서드인 경우에도 구조가 메서드를 재정의할 수 있습니다.

22.4.2 impl 특성 구현하기

이전에 말했듯이 Rust의 특성은 다른 언어의 인터페이스 와 동일합니다 .

Java와 같은 다른 언어는 Implement 키워드를 사용하여 인터페이스를 구현합니다.

그러나 Rust는 이를 수행하지 않지만 impl에 대해 보다 의미론적인 구문을 제공합니다 .

특정 구조(struct)에 대한 특정 특성을 구현하려면 impl for 문을 사용해야 합니다.

impl은 Implement의 약어입니다. impl for의 의미는 이미 매우 명확합니다. 이는 xxx에 대해 xxx를 구현한다는 의미입니다.

impl for 문의 구문 형식은 다음과 같습니다.

1. impl some_trait for structure_name {
2. // method1()을 구현하기 위한 특정 코드
3. fn method1(&self ){
4. }
5. }

참고: 특성 메소드는 구조의 멤버 메소드이므로 첫 번째 매개변수는 &self입니다.

22.4.3 예: impl의 간단한 사용

다음 예에서는 먼저 Book 구조와 Printable 특성을 정의합니다.

그런 다음 impl for 문을 사용하여 Printable for Book 특성을 구현합니다.

1. fn main(){
2. //Book 구조의 인스턴스를 생성합니다.
3. let b1 = Book {
4. id:1001,
5. name:"Rust in Action"
6. };
7. b1.print();
8. }
9.  
10. //구조 선언
11. struct Book {
12. name:&'static str,
13. id:u32
14. }
15. // 특성 선언
16. trait Printable {
17. fn print(&self);
18. }
19. // 특성 구현
20. impl Printable for Book {
21. fn print(&self){
22. println!("Printing book with id:{} and name {}",self.id,self.name)
23. }
24. }

위의 Rust 예제를 컴파일하고 실행하면 출력 결과는 다음과 같습니다.

1. Printing book with id:1001 and name Rust in Action

22.5 일반 함수

제네릭은 함수에서도 사용할 수 있습니다. 제네릭 함수를 사용하는 함수를 호출합니다.

일반 함수는 주로 함수의 매개변수가 일반이라는 것을 의미합니다.

참고: 일반 함수에서는 모든 매개변수가 일반화되어야 하는 것은 아니지만 단 하나의 매개변수만 일반화되어야 합니다.

일반 함수의 정의 구문은 다음과 같습니다.

1. fn function_name<T[:trait_name]>(param1:T, [other_params]) {
2.  
3. //함수 구현 코드
4. }

예를 들어, 어떤 유형이든 인쇄할 수 있는 일반 함수 print_pro를 정의합니다.

1. fn print_pro<T:Display>(t:T){
2. println!("Inside print_pro generic function:");
3. println!("{}",t);
4. }

구문과 예제를 비교해 보면 일반 함수의 정의는 매우 간단합니다.

22.5.1 예

다음 예에서는 방금 정의한 일반 함수 print_pro()를 사용하여 전달된 매개변수를 인쇄합니다.

전달된 매개변수는 Display 특성을 구현하는 모든 유형이 될 수 있습니다.

1. use std::fmt::Display;
2.  
3. fn main(){
4. print_pro(10 as u8);
5. print_pro(20 as u16);
6. print_pro("Hello TutorialsPoint");
7. }
8.  
9. fn print_pro<T:Display>(t:T){
10. println!("Inside print_pro generic function:");
11. println!("{}",t);
12. }

위의 Rust 예제를 컴파일하고 실행하면 출력 결과는 다음과 같습니다.

1. Inside print_pro generic function:
2. 10
3. Inside print_pro generic function:
4. 20
5. Inside print_pro generic function:
6. Hello TutorialsPoint

현재 콘텐츠 저작권은 chapin666 또는 그 계열사에 있습니다.