Rust 데이터 타입

/////////////////스칼라 타입
/*
//매크로
const MAX_POINTS: u32 = 100_1000;
fn main() {
    
    //let만 사용하면 불변이며 mut을 추가하면 가변이 된다.
    let mut x = 5;
    println!("x의 값 : {}",x);

    x = 6;
    println!("x의 값 : {}",x);

    println!("MAX_POINTS의 값 : {}", MAX_POINTS);
}*/


//변수 가리기
/*fn main()
{
    //똑같은 변수 이름을 선언하면 그 전에 선언된 변수는 가려진다.
    let x = 5;

    let x = x + 1;

    let x = x * 2;

    
    println!("x의 값 : {}",x);
}*/


/*
//let과 let mut의 차이
fn main()
{
    //let은 데이터 가리기를 사용할 때 데이터 타입을 바꿀 수 있지만
    let spaces = "     ";
    let spaces = spaces.len();
    
    println!("spaces len  : {}", spaces);

    //let mut은 바꾸지못한다.
    let _spaces = 4;
    let mut _spaces = 5;

    println!("num : {}",_spaces);


}*/


/*
//정수 타입
//디폴트로 i32를 쓴다.
//isize와 usize
fn main()
{
    //isize와 usize사용
    //isize와 usize는 해당 컴퓨터에 해당하는 아키텍쳐 환경에 따라
    //64bit 아니면 32bit로 자동으로 바뀐다.

    //isize는 부호가있으며
    let _isize : isize = match "-64".parse(){

        Ok(num) => {
            println!("isize로 변환된 정수 : {} ",num);
            num
        }
        Err(_) => {
            println!("변환에러입니다.0을 반환합니다.");
            0
        },
        
    };

    //usize는 부호가 없다.
    let _usize : usize = match "64".parse(){

        Ok(num) =>{
            println!("usize로 변환된 정수 : {} ",num);
            num
        }
        Err(_) => {
            println!("변환 에러입니다. 0을 반환합니다.");
            0
        }
    };
}*/


/*
//부동 소수점 타입
fn main()
{
    //디폴트로 f64를 쓴다.
    let x = 2.0;        //f64

    let y : f32 = 3.0;  //f32

    println!("x(f64) = {}\r\ny(f32) = {}",x,y);
}*/

/*
//사칙연산
fn main()
{
    //덧셈
    let sum = 5 + 10;
    println!("5  + 10 = {}", sum);
    
    //뺄셈
    let difference = 95.5 - 4.3;
    println!("95.5 - 4.3 = {}",difference);

    //곱셈
    let product = 4 * 38;
    println!("4 * 38 = {}",product);

    //나눗셈
    let quotient = 56.7 / 32.2;
    println!("56.7 / 32.2 = {}",quotient);

    //나머지
    let remainder = 43 % 5;
    println!("43 % 5 = {}",remainder);
}
*/

/*
//불리언 타입
fn main()
{
    let t = true;

    let f : bool = false; //타입 애노테이션을 사용하는 경우
}*/

/*
//문자 타입
fn main()
{
    //" "은 거의 모든 문자가 된다고 한다.
    //하지만 ' '는 실제 유니코드값이 아니어서 잘못된 것이 출력된다고 하더라
    
    let z = "กิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิิ";
    println!("특수문자! : {}",z);

    let c = 'z';
    println!("문자하나 : {} ", c);

    let smile = "꧁⍢⃝꧂ㄴㅏ므우 *꧁ ꧂*";
    println!("특수문자열 : {}",smile);  

}
*/


/////////////////컴파운드 타입

/*
//튜플
fn main()
{
    //튜플의 크기가 한번 정해지면 다시는 바꾸지 못한다.
    let mut tup: (i32, f64, u8) = (500, 6.4, 1);

    
    //튜플은 mut을 사용해도 변수 가리기가 되넹?
    let tup: (i32,i32,char) = (3,3,'a');

    let (i,f,u) = tup;

    println!("i32 : {}\r\nf64 : {}\r\nu8 : {}",i,f,u);
    

//////////////////////패턴매칭 사용(.뒤에 나오는건 인덱스라고 생각하면 된다.)

    let five_handred = tup.0;
 
    let six_point_four = tup.1;

    let ch = tup.2;

}
*/


//배열 타입
fn main()
{
    //배열과 비슷한 벡터가 있는데 한계가 정해져 있는 
    //데이터를 넣을 때 (일,월)은 배열로 처리하는것이 좋다.
    //나머지는 벡터로 ㄱㄱ
    let a = [1,2,3,4,5];

    //인덱스로도 접근이 가능하다.
    let first = a[0];
    let second = a[1];

    let months = ["January","February","March","April",
                    "May","June","July","August",
                    "September","October","November","December"];



    //i32타입의 배열을 5개생성하겠다는뜻이다.                    
    let b: [i32;5] = [1,2,3,4,5];

    //정수 3을 5개생성하겠다는 뜻이다.
    //ex) let c = [3,3,3,3,3];이랑 똑같다.
    let c = [3;5];

}