소유권

//컴파일 시 크기를 알 수 없는(동적할당)을 사용하는 변수의 데이터 대입법
/*fn main() {
    
    let s1 = String::from("hello");
    let s2 = s1;

    //이렇게 하면 s1은 사용할 수 없을것이다 그 이유는 copy를 한게아니라
    //move를 한것이기 때문이다.
    println!("{}, world!", s1);
    println!("{}, world!",s2);
}*/

/*

//같이 사용하고 싶다면 클론 함수를 사용하여 복사를 할 수 있다.
fn main()
{
    let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {}, s2 = {}",s1,s2);

}
*/


/*
//스택 전용 데이터 : 복사(copy)
fn main()
{
    let x = 5;
    let y = x;

    //이 코드가 제대로 동작하는 이유는 처음 컴파일 할 때
    //이미 크기를 알 기 때문이다.
    println!("x = {}, y = {}",x,y);
}
*/

/*fn main()
{
    let original = String::from("hello");

    //.clone()을 하지않고 넘기면 소유권 자체가 return_string함수의
    //매개변수로 이동해버린다.
    let return_str = return_string(original.clone());

    println!("original : {}",original);
    println!("return_str : {}",return_str);
}

fn return_string(str:String)->String{

    str
}
*/
/*
fn main()
{
    let s1 = String::from("hello");

   
    let(s2,len) = calculate_length(s1);

    println!("'{}'의 길이는 {}입니다.",s2,len);
}

fn calculate_length(s:String) -> (String,usize)
{
    let length = s.len();

    (s,length)
}*/




/*
//'&'참조를 이용하면 소유권을 지켜내면서 "대여"를 해주 수있다.
fn main()
{
    let s1 = String::from("hello");

    let s1_len = immutability_str_len(&s1);

    println!("s1 : {}, s1_len : {}",s1,s1_len);


    let mut s2 = String::from("hello");
    let s2_len = variable_str_len(&mut s2);

    println!("s2 : {}, s2_len : {}",s2,s2_len);
    

}

fn immutability_str_len(s1: &String) -> usize
{
    //s1.push('1'); <- 대여한 변수는 기본적으로 불변이다.
    s1.len()
}

//"& mut을 사용하면 가변의 대여를 할 수 있다."
fn variable_str_len(s2 :& mut String) -> usize
{
    s2.push_str(" world");
    s2.len()
}
*/


/*
fn main()
{
    let mut s = String::from("hello");

    let r1 = &mut s;
    //let r2 = &mut s;  <- 특정 범위 내에는 가변참조를 한번밖에 할 수 없는 제약이있다.
    그럼 당연히 대여해준 매개변수도 카운터로 들어가니 매개변수로 넘어간 해당 함수에서는 사용할 수 없다.
    println!("{}",r1);
}
*/
/*
fn main()
{
    let s = String::from("hello");

    //불변은 여러번 참조해도 상관없다.
    let immut1 = &s;
    let immut2 = &s;
    let immut3 = &s;

    //let variable = &mut s; <-다른곳에서 불변으로 이미 참조하고 있기때문에 불가능?

}*/

/*
//{}으로 구역을 나누면 가변참조를 여러번 사용할 수 있다.
fn main()
{
    let mut var_s = String::from("hello");

    {
        let var1 = &mut var_s;
        

        println!("var1 : {}",var1);
    }
    
    {
        let var2 = &mut var_s;
        println!("var2 : {}",var2);
    }

    let var3 = &mut var_s;
    println!("var3 : {}",var3);

}*/