2025년 5월 4일 일요일

8-1강: 리눅스 시스템 프로그래밍 (설정)

 

Windows에서 Rust 리눅스 개발 환경 구축하기 (WSL2 + Ubuntu + VSCode)

리눅스 시스템 프로그래밍이나 FFI(C 연동) 등을 Rust로 개발하려면 리눅스 환경이 필요
Windows 사용자가 WSL2 + Ubuntu + VSCode를 통해 Rust 개발 환경을 구축하는 과정을 정리

✅ 1단계: WSL2 활성화

Windows에 리눅스를 실행할 수 있도록 **WSL2 (Windows Subsystem for Linux 2)**를 설치

💻 PowerShell 관리자 권한으로 실행 후 입력:

wsl --install

⚠️ 설치 후 자동으로 Ubuntu가 설치되지 않았다면 다음 명령어로 수동 설치:
wsl --install -d Ubuntu

설치 후 재부팅이 필요
-----------------------------------------------------------------------------------------------------------------------

✅ 2단계: Ubuntu 초기 설정

재부팅 후 Windows 검색창에서 Ubuntu 실행

→ 최초 실행 시 몇 분 소요됨 

→ 사용자 이름 / 비밀번호 설정

---------------------------------------------------------------------------------------------------------------------

✅ 3단계: Rust 설치 (Ubuntu 내부)

Ubuntu 터미널에서 아래 명령어 입력:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

→ 안내에 따라 설치 후, 환경 적용:
source $HOME/.cargo/env

→ 설치 확인:
rustc --version
cargo --version

---------------------------------------------------------------------------------------------
✅ 4단계: VSCode 설치 및 확장 설치
VSCode 실행 후 확장(Extensions) 설치:
    - Remote - WSL
    - Rust Analyzer
    - C/C++ 확장 설치
--------------------------------------------------------------------------------------------
✅ 5단계: VSCode로 Ubuntu 연동
1. VSCode 좌측 하단에 >< 아이콘 클릭 -> WSL: Ubuntu 선택

2. 자동으로 우분투 안에서 vscode 가 열림
---------------------------------------------------------------------------------------------
✅ 6단계: 개발 환경 확인
WSL 내부에서 다음을 입력해 확인:
rustc --version
gcc --version     # C 연동 시 필요

필요시 build-essential 설치:
sudo apt update
sudo apt install build-essential
---------------------------------------------------------------------------------------------
✅ (선택) bindgen 사용 시 필수
C 헤더 바인딩을 자동 생성하는 bindgen을 사용하려면:
sudo apt install libclang-dev clang
작성자: 시간: 댓글 없음:
라벨:

2025년 5월 1일 목요일

7-1-3강 객체 지향(다형성)

러스트는 트레이 객체를 사용해 다형성을 제공한다.

하나의 함수가 다양한 타입을 받아 공통 동작을 할 수 있게 해준다.

// trait 정의
trait Hello {
    fn hello_msg(&self) -> String;
}

// 구조체 정의
struct Student {
    name: String,
}

//trait은 "impl 트레잇 이름 for 구조체 이름" 형식으로 정의 한다.
// Hello 트레잇을 Student 구조체에 구현
impl Hello for Student {
    fn hello_msg(&self) -> String {
        String::from("안녕하세요! 선생님,")
    }
}

// 구조체 정의
struct Teacher {
    name: String,
}

// Hello 트레잇을 Teacher 구조체에 구현
impl Hello for Teacher {
    fn hello_msg(&self) -> String {
        String::from("안녕하세요. 오늘 수업은...")
    }
}

// 다형성을 사용하기 위해서는 trait 객체를 사용해야 한다.
// trait 객체는 "&dyn 트레잇 이름" 형식으로 정의한다.
fn say_hello(say: &dyn Hello) {
    println!("{}", say.hello_msg());
}

fn main() {
    let student = Student { name: String::from("luna") };
    let teacher = Teacher { name: String::from("me") };

    say_hello(&student); // Student 구조체의 hello_msg 메서드 호출
    say_hello(&teacher); // Teacher 구조체의 hello_msg 메서드 호출
}

/*실행결과
안녕하세요! 선생님,
안녕하세요. 오늘 수업은...
*/
작성자: 시간: 댓글 없음:
라벨:

7-1-2강 객체 지향(상속)

러스트는 클래스 상속을 지원하지 않는다.

구성과 트레잇 구현으로 상속처럼 동작하게 만든다.

// Pointable이라는 트레잇(인터페이스)을 정의합니다.
// 이 트레잇을 구현하는 구조체는 x()와 y() 메서드를 가져야 합니다.
trait Pointable {
    fn x(&self) -> i32;
    fn y(&self) -> i32;
}

// Point 구조체는 x, y 좌표를 가지고 있습니다.
struct Point {
    x: i32,
    y: i32,
}

// Point 구조체에 대해 Pointable 트레잇을 구현합니다.
impl Pointable for Point {
    fn x(&self) -> i32 {
        self.x
    }

    fn y(&self) -> i32 {
        self.y
    }
}

// ColorPoint 구조체는 색상(color)과 Point를 포함하는 구조체입니다.
struct ColorPoint {
    color: String,
    point: Point,
}

// ColorPoint에 메서드를 추가합니다.
impl ColorPoint {    
    // 생성자 메서드: 새로운 ColorPoint 인스턴스를 만듭니다.
    fn new(color: String, x: i32, y: i32) -> ColorPoint {
        ColorPoint {
            color: color,
            point: Point { x: x, y: y },
        }
    }

    // 색상을 반환하는 메서드
    fn color(&self) -> &String {
        &self.color
    }
}

// ColorPoint도 Pointable 트레잇을 구현합니다.
// 내부에 있는 Point의 x, y 값을 위임(delegate)하는 방식입니다.
impl Pointable for ColorPoint {
    fn x(&self) -> i32 {
        self.point.x
    }

    fn y(&self) -> i32 {
        self.point.y
    }
}

// Pointable 트레잇을 참조하는 함수.
// 모든 Pointable 타입을 받아서 좌표를 출력합니다.
fn print_pointable(pointable: &dyn Pointable) {
    println!("x: {} y: {}", pointable.x(), pointable.y());
}

fn main() {
    // ColorPoint 인스턴스를 생성합니다.
    let pt = ColorPoint::new(String::from("red"), 1, 2);
   
    // print_pointable 함수에 전달하면 Pointable로 동작합니다.
    print_pointable(&pt);
}

/*실행결과
x: 1 y: 2 */

작성자: 시간: 댓글 없음:
라벨:

7-1-1강 객체 지향(캡슐화)

- 러스트는 기본적으로 객체지향을 언어는 아니다. 고유한 방식으로 구현한다.

1. 캡슐화

구조체의 필드와 메서드에 대한 접근 제어를 통해 캡슐화를 구현한다.

기본적인 모든 필드는 private 다.

pub 키워드를 사용하여 외부에 공개할 수 있다. 

// 트레잇과 같은 형태로 객체지향에 가까운 프로그램을 작성할 수 있다.
pub struct Student {
    id: i32, // private 필드
    pub name: String, // public 필드
    pub email: String, // public 필드
}

impl Student {
    // public 생성자
    pub fn new(id: i32, name: String, email: String) -> Student {
        Student { id, name, email }
    }

    // public 메서드
    pub fn get_name(&self) -> &String {
        &self.name
    }

    // private 메서드
    fn set_name(& mut self, name: String) {
        self.name = name.clone();
    }
}

fn main() {
    let student = Student::new(1, String::from("luna"), String::from("luna@email.me"));
    println!("이름: {}", student.get_name());
}

/*실행결과
이름: luna
*/
작성자: 시간: 댓글 없음:
라벨:
피드 구독하기: 글 (Atom)