int* alloc_int() {
  Int* i = new Int(); // 直接堆中开辟内存
  assert(i != NULL);
  return &(i->integer); // 引用对象元素地址，i成为悬空指针
}

int n = *alloc_int();
// 可见在这里，alloc_int()函数中内存申请的Int类型的对象，是无法被释放了，函数虽然返回了一个指针，但是仅仅是对象元素的指针，智能用于获取元素值

int* p = alloc_int();
// 如果直接获取元素指针
delete p; // 程序出现异常
// 这里的p指向的仅仅是对象元素的地址，是不可释放的，可以释放的是对象的指针，但是对象指针没有返回

// 这里再定义一个函数
Int* alloc_int() {
  Int* i = new Int(); // 直接堆中开辟内存
  assert(i != NULL);
  return i; // 对象指针
}

Int* p = alloc_int();
// 如果申请了，用完不释放p，是有问题的
delete p; // 这样释放就没有问题了

class Test {
public:
  void doSomething() {}
};

// 演示unique智能指针
void testUnique() {
  // 创建一个unique_ptr智能指针
  std::unique_ptr<Test> uPtr1 = std::make_unique<Test>();

  // 这里可以像普通指针一样使用智能指针
  uPtr1->doSomething();

  // 因为unique智能指针是独占的，只能进行所有者转移操作
  std::unique_ptr<Test> uPtr2 = std::move(uPtr1);

  // uPtr1此时已经不再有效了
  assert(uPtr1 == nullptr);

  // 和上次调用相同
  uPtr2->doSomething();
}

// 演示shared智能指针
void testShared() {
  // 创建一个shared_ptr智能指针
  std::shared_ptr<Test> sPtr1 = std::make_shared<Test>();
  
  // 像普通指针一样使用
  sPtr1->doSomething();
  
  // 复制指针，引用计数加1
  std::shared_ptr<Test> sPtr2 = sPtr1;
  
  // 这里再次调用这个函数，如果在函数里面更新了对象状态，那么它也会到sPtr1的，因为是共享的对象
  sPtr2->doSomething();
  
  // 作用域示例
  {
    // 再复制一次
    std::shared_ptr<Test> sPtr3 = sPtr1;
    
    // 使用共享对象
    sPtr3->doSomething();
    
    // 退出作用域后，sPtr3指向的对象引用计数会减少1
  }
  
  // 退出作用域，sPtr2, sPtr1也会触发计数减1，当计数变为0时，对象就会自动释放
}

class T2;

class T1 {
public:
  std::shared_ptr<T2> sPtr;
};

class T2 {
public:
  std::shared_ptr<T1> sPtr;
};

// 演示weak智能指针
void testWeak1() {
  // weak指针是用于解决shared指针的问题的
  
  // 创建两个共享智能指针
  std::shared_ptr<T1> sPtr1 = std::make_shared<T1>(); // 计数1
  std::shared_ptr<T2> sPtr2 = std::make_shared<T2>(); // 计数1
  
  // 让他们互相引用
  sPtr1->sPtr = sPtr2; // 计数2
  sPtr2->sPtr = sPtr1; // 计数2
  
  // 运行到这里退出函数，将导致内存泄露，因为sPtr1和sPtr2的引用计数全部是1，标记为对象还在被使用
  // 整体释放流程如下：
  // 栈中的sPtr1创建 (1) -> 被sPtr2引用 (2) -> 栈中的sPtr1析构 (1)
  // 栈中的sPtr2创建 (1) -> 被sPtr1引用 (2) -> 栈中的sPtr2析构 (1)
}


// 下面是一个修正版本，演示weak智能指针使用
class T3 {
public:
  std::shared_ptr<T3> sPtr;
};

class T4 {
public:
  std::weak_ptr<T3> sPtr; // 引用但不计数
};

void testWeak2() {
  // 创建两个共享智能指针
  std::shared_ptr<T3> sPtr1 = std::make_shared<T3>();
  std::shared_ptr<T4> sPtr2 = std::make_shared<T4>();
  
  // 让他们互相引用
  sPtr1->sPtr = sPtr2; // 正常计数
  sPtr2->sPtr = sPtr1; // weak智能指针，不增加计数
  
  // 运行到这里退出函数，所以内存都会释放
  // 整体释放流程如下：
  // 栈中的sPtr1创建 (1) -> 被sPtr2观察，不引用 (1) -> 栈中的sPtr1析构 (0)
  // 栈中的sPtr2创建 (1) -> 被sPtr1引用 (2) -> sPtr1析构销毁 (1) -> 栈中的sPtr2析构 (0)
}

// 这个函数每隔一秒打印游戏引擎的状态
func logEngineEveryPeriod() {
  for {
    fmt.Printf("[%v] engine status: %v", time.Now(), engine.GetStatus())
    time.Sleep(time.Millisecond * 100)
  }
}

// 这个函数分配大量内存
func allocImage() *Image {
  // ...
}

// 演示函数
func testGo() {
  // 协程后台异步运行
  go logEngineEverySecond()
  
  for sp := range sprites {
    img := allocImage()
    sp.FitImage(img)
  }
}

// 一个简单的函数，展示所有权转移
fn take_ownership(some_string: String) { // some_string 获取了所有权
    println!("I own this string: {}", some_string);
} // some_string 离开作用域，其内存被自动释放

// 一个函数，展示借用
fn borrow_and_print(some_string: &String) { // some_string 是一个不可变借用
    println!("I'm borrowing this string: {}", some_string);
} // some_string 离开作用域，借用结束

// 一个函数，展示可变借用
fn borrow_and_change(some_string: &mut String) { // some_string 是一个可变借用
    some_string.push_str(" and I was changed!");
} // some_string 离开作用域，借用结束

// 演示函数
fn demo_rust_mem() {
  // --- 1. 所有权示例 ---
  let s1 = String::from("hello world"); // s1 拥有 "hello world" 的所有权
  
  let s2 = s1; // 所有权从 s1 移动(move)到 s2
  // 在这一点之后，s1 不再有效！编译器会报错
  // println!("s1 is: {}", s1); // 编译错误！value borrowed here after move
  println!("s2 is: {}", s2);
  
  // 调用函数，所有权被转移
  let s3 = String::from("take me away");
  take_ownership(s3);
  // println!("s3 is: {}", s3); // 编译错误！s3 的所有权已被转移
  
  // --- 2. 借用示例 ---
  println!("\n--- 借用示例 ---");
  let s4 = String::from("this is a borrowed string");
  borrow_and_print(&s4); // s4 的借用被传递
  println!("s4 is still valid after borrowing: {}", s4); // 借用结束后，s4 仍然有效

  // --- 3. 可变借用示例 ---
  println!("\n--- 可变借用示例 ---");
  let mut s5 = String::from("I am mutable");
  borrow_and_change(&mut s5);
  println!("s5 has been changed: {}", s5);
  
  // --- 4. 借用冲突示例 ---
  println!("\n--- 借用冲突示例 ---");
  let mut s6 = String::from("I have multiple references");

  // 允许多个不可变借用
  let r1 = &s6;
  let r2 = &s6;
  println!("{} and {}", r1, r2);
  
  // 但是，在不可变借用之后，不允许可变借用
  // let r3 = &mut s6; // 编译错误！cannot borrow as mutable...

  // --- 5. 悬空指针（编译器会阻止） ---
  // 下面的函数无法编译，因为它会返回一个悬空引用
  // fn dangle() -> &String {
  //     let s = String::from("dangling"); // s 在这里被创建
  //     &s // 返回 s 的引用
  // } // s 在这里离开作用域并被销毁，其引用变成悬空指针！
  // 编译器会报错：`s` does not live long enough
}