func createInt() *int {
    i := 42   // int 類型分配在棧上
    return &i // 這里由于返回引用類型，分配到堆上
} 
func main() {
    num := createInt()
    println(*num)  // 程序結(jié)束時，num指向的堆內(nèi)存會被釋放
}

#include <stdio.h>
int* createInt() {
    int i = 42;      // int 類型分配在棧上
    return &i;       // 返回 i 的地址
}                    // ?? 函數(shù)結(jié)束，棧的內(nèi)存會被回收
int main() {
    int* num = createInt();  // 接收了已釋放內(nèi)存的地址（
    printf("%d\n", *num);    // ?? 未定義行為！可能打印 42，也可能打印垃圾值，或者崩潰
    return 0;
}

#include <stdio.h>
#include <stdlib.h>  // 包含malloc/free的頭文件
int* createInt() {
    int* i = (int*)malloc(sizeof(int));  // 分配堆內(nèi)存
    if (i == NULL) {  // 檢查內(nèi)存分配是否成功（必做）
        printf("內(nèi)存分配失敗\n");
        exit(1);
    }
    *i = 42;          // 給堆內(nèi)存賦值
    return i;         // 返回堆內(nèi)存地址（安全）
}
int main() {
    int* num = createInt();
    printf("%d\n", *num);  // 輸出 42（安全）
    free(num);             // 釋放堆內(nèi)存（避免內(nèi)存泄漏）
    num = NULL;            // 置空指針（避免野指針）
    return 0;
}

fn main() {
    let i = create_int();
    println!("{}", i);
}

fn create_int() -> &i32 {
    let s = 32;
    &s
}

error[E0106]: missing lifetime specifier
  --> src/main.rs:12:20
   |
12 | fn create_int() -> &i32 {
   |                    ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
   |
12 | fn create_int() -> &'static i32 {
   |                     +++++++
help: instead, you are more likely to want to return an owned value
   |
12 - fn create_int() -> &i32 {
12 + fn create_int() -> i32 {
   |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `naive` (bin "naive") due to 1 previous error

fn main() {
    let i = create_int();
    let j = create_intptr(); // 會報錯
}

// 32 這個值是變量 s 的，該函數(shù)返回的是 s，誰接收誰能隨便用
// 不管你是堆還是棧分配，所有權(quán)會自動管理
fn create_int() -> i32 {
    let s = 32;
    s
}

// 32 這個值是變量 s 的，該函數(shù)返回的是 s 的引用指針，接收方只能看/改
// 但是，函數(shù)create_intptr執(zhí)行結(jié)束了，s 釋放銷毀了，main函數(shù)中的 j 將變成懸垂引用
fn create_intptr() -> &i32 {
    let s = 32;
    &s
}

let a = 10;                 // a 擁有 10
let s = String::from("hi"); // s 擁有堆上的 "hi"
let v = vec![1, 2, 3];      // v 擁有堆上的數(shù)組
let my_struct = User { name: s }; // my_struct 現(xiàn)在擁有了 name (s 的所有權(quán)轉(zhuǎn)移了)

let a = 10;
let r = &a;            // r 是引用，借用 a，r 的類型是 &i32

let st = "hello";      // 注意：st是引用類型，引用的一個 "hello" 的串，"hello" 這個字符并不屬于變量 st


let s = String::from("hello");
let slice: &str = &s;  // slice 是引用，借用 s 的一部分，類型是 &str

let mut x = 5;
let m = &mut x;        // m 是可變引用，類型是 &mut i32
*m = 10;               // 通過引用修改數(shù)據(jù)

fn main() {
    let st = longest("hello", "world");
    println!("{}", st);
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let st = longest("hello", "world");
    println!("{}", st);
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

struct Excerpt<'a> {
    part: &'a str,
}

// impl 方法實現(xiàn)中也需聲明生命周期: impl<'a> xxx<'a>
impl<'a> Excerpt<'a> {
    fn return_str(&self, announcement: &str) -> &str {
        println!("Announcement: {}", announcement);
        self.part // 返回的是 self 的一部分，生命周期與 self 綁定
    }
}

fn main() {
    let st = Excerpt { part: "hello" };
    println!("{}", st.return_str("world"));
}

fn get_first<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    y // 明確返回的是 x 的切片，與 y 的生命周期無關(guān) 返回x可編譯成功，返回y會編譯失敗
}

fn main() {
    let st = get_first("hello", "world");
    println!("{}", st);
}

// 報錯
fn longest_1() -> &str {
    let s = "world";
    s
}

// 正常
fn longest_2(x: &str) -> &str {
    let y = "world";
    y
}

fn longest_6(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

// 沒顯示聲明，任何生命周期都可以傳 'static 'a 'b
fn partial(s: &str) {
    println!("Static string: {}", s);
}

// 顯示聲明了 static 周期
fn global(s: &'static str) {
    println!("Static string: {}", s);
}