02 · 值语义与所有权：谁负责释放

# c02_three.py
import sys

# ① Python 的 = ：给同一个对象再挂一个名字
a = [1, 2, 3]
b = a
b.append(4)
print("① Python:  a =", a, " b =", b, " 同一个对象吗:", a is b, " id 相同吗:", id(a) == id(b))

# ② NumPy 的切片：两个不同的对象，共用同一块缓冲区
import numpy as np
x = np.array([1, 2, 3, 4])
y = x[:2]
y[0] = 99
print("② NumPy :  x =", x, " y =", y, " 同一个对象吗:", x is y, " y 借的是谁的内存:", y.base is x)

# ③ 引用计数：Python 自己数
c = []
print("③ refcount 一开始:", sys.getrefcount(c) - 1)   # 减掉传参那一次
d = c
print("   多挂一个名字后:", sys.getrefcount(c) - 1)
del d
print("   del 掉之后    :", sys.getrefcount(c) - 1)

// c02_copy.cpp
// g++ -O2 -std=c++17 c02_copy.cpp -o c02_copy
#include <cstdio>
#include <vector>
#include <string>
#include <utility>

struct Loud {
    std::string name;
    std::vector<double> data;

    Loud(std::string n, size_t k) : name(std::move(n)), data(k, 1.0) {
        std::printf("  [构造]     %s  (%zu 个 double)\n", name.c_str(), data.size());
    }
    Loud(const Loud& o) : name(o.name + "-拷贝"), data(o.data) {
        std::printf("  [拷贝构造] %s  <- %s   ⚠️ 复制了 %zu 个 double\n",
                    name.c_str(), o.name.c_str(), data.size());
    }
    Loud(Loud&& o) noexcept : name(std::move(o.name)), data(std::move(o.data)) {
        std::printf("  [移动构造] %s   ⭐ 只搬了指针，原对象现在有 %zu 个\n",
                    name.c_str(), o.data.size());
    }
    ~Loud() {
        std::printf("  [析构]     %s\n", name.empty() ? "(已被搬空)" : name.c_str());
    }
};

void take_by_value(Loud x)        { std::printf("    -> 函数里拿到 %s\n", x.name.c_str()); }
void take_by_ref(const Loud& x)   { std::printf("    -> 函数里拿到 %s（没拷贝）\n", x.name.c_str()); }

int main() {
    std::printf("① 传值：\n");
    { Loud a("a", 3); take_by_value(a); }

    std::printf("\n② 传 const 引用：\n");
    { Loud b("b", 3); take_by_ref(b); }

    std::printf("\n③ 传值 + std::move：\n");
    { Loud c("c", 3); take_by_value(std::move(c)); }
    return 0;
}

// c02_cost.cpp
// g++ -O2 -std=c++17 c02_cost.cpp -o c02_cost
#include <cstdio>
#include <vector>
#include <chrono>
#include <utility>

using Clock = std::chrono::steady_clock;
static double ms_since(Clock::time_point t) {
    return std::chrono::duration<double, std::milli>(Clock::now() - t).count();
}

int main() {
    const size_t N = 10'000;     // 每个 vector 1 万个 double ≈ 78 KB
    const int    R = 5000;

    // 计时之外先把 5000 个源 vector 都造好，两组用的是同样的东西
    std::vector<std::vector<double>> poolA(R, std::vector<double>(N, 3.0));
    std::vector<std::vector<double>> poolB(R, std::vector<double>(N, 3.0));

    std::vector<std::vector<double>> bag;
    double sink = 0;

    // ① 拷贝：源对象还留着，所以必须重新分配一块再逐字节复制
    bag.clear(); bag.reserve(R);
    auto t = Clock::now();
    for (int i = 0; i < R; ++i) bag.push_back(poolA[i]);              // ⚠️ 拷贝构造
    double t_copy = ms_since(t);
    sink += bag[0][0] + poolA[0].size();       // ⭐ 源还在，size 仍是 N

    // ② 移动：告诉编译器「源我不要了」，于是只搬指针
    bag.clear(); bag.reserve(R);
    t = Clock::now();
    for (int i = 0; i < R; ++i) bag.push_back(std::move(poolB[i]));   // ⭐ 移动构造
    double t_move = ms_since(t);
    sink += bag[0][0];

    std::printf("%d 个 vector，每个 %.0f KB（合计 %.0f MB）\n",
                R, N * sizeof(double) / 1024.0, R * N * sizeof(double) / 1048576.0);
    std::printf("① 拷贝进 bag: %8.2f ms\n", t_copy);
    std::printf("② 移动进 bag: %8.2f ms\n", t_move);
    std::printf("   倍数      : %8.1f x\n", t_copy / t_move);
    std::printf("移动之后，源 poolB[0] 的 size = %zu（被搬空了）\n", poolB[0].size());
    std::printf("拷贝之后，源 poolA[0] 的 size = %zu（还在）\n", poolA[0].size());
    std::printf("(sink=%.1f)\n", sink);
    return 0;
}

Tensor add(const Tensor& self, const Tensor& other, const Scalar& alpha);

// c02_raii.cpp
// g++ -O2 -std=c++17 c02_raii.cpp -o c02_raii
#include <cstdio>
#include <stdexcept>
#include <memory>

struct Guard {                       // 一个最小的 RAII 对象
    const char* what;
    explicit Guard(const char* w) : what(w) { std::printf("  拿到 %s\n", what); }
    ~Guard()                                { std::printf("  还回 %s\n", what); }
};

void may_throw(bool boom) {
    Guard g("锁");                   // ⭐ 出这个函数时一定还锁，不管怎么出去
    std::printf("  干活中…\n");
    if (boom) throw std::runtime_error("中途炸了");
    std::printf("  正常干完\n");
}

struct Node {
    int id;
    explicit Node(int i) : id(i) { std::printf("  Node%d 出生\n", id); }
    ~Node()                      { std::printf("  Node%d 死亡\n", id); }
};

int main() {
    std::printf("① 正常返回：\n");
    may_throw(false);

    std::printf("\n② 抛异常：\n");
    try { may_throw(true); }
    catch (const std::exception& e) { std::printf("  接住了：%s\n", e.what()); }

    std::printf("\n③ unique_ptr（唯一所有者）：\n");
    {
        std::unique_ptr<Node> p = std::make_unique<Node>(1);
        std::unique_ptr<Node> q = std::move(p);          // ⭐ 所有权搬走，不能拷贝
        std::printf("  p 现在是空的吗: %s\n", p ? "不是" : "是");
        std::printf("  q 指着 Node%d\n", q->id);
    }                                                     // ⭐ q 出作用域 -> Node1 死

    std::printf("\n④ shared_ptr（大家共有，最后一个走的关灯）：\n");
    {
        std::shared_ptr<Node> a = std::make_shared<Node>(2);
        std::printf("  持有者 %ld 个\n", a.use_count());
        {
            std::shared_ptr<Node> b = a;                  // ⭐ 拷贝 = 计数 +1，不复制 Node
            std::printf("  多了一个 b，持有者 %ld 个\n", a.use_count());
        }
        std::printf("  b 走了，持有者 %ld 个（Node2 还活着）\n", a.use_count());
    }
    std::printf("  a 也走了 ↑\n");
    return 0;
}

// c02_dangle.cpp
// g++ -O2 -std=c++17 c02_dangle.cpp -o c02_dangle
#include <cstdio>
#include <vector>

int main() {
    std::vector<int> v{10, 20, 30};
    const int* p = v.data();                 // ⚠️ 记住这个地址
    std::printf("push 之前: data=%p  capacity=%zu  p[0]=%d\n",
                (const void*)p, v.capacity(), p[0]);

    for (int i = 0; i < 100; ++i) v.push_back(i);   // 容量不够 -> 换一块更大的地方

    std::printf("push 之后: data=%p  capacity=%zu\n",
                (const void*)v.data(), v.capacity());
    std::printf("地址变了吗: %s\n", p == v.data() ? "没变" : "⚠️ 变了");
    std::printf("v[0] 从新地址读 = %d  (正确)\n", v[0]);
    // ⚠️⚠️ 下面这一行是【未定义行为】：p 指着已经被释放的那块内存
    std::printf("p[0] 从旧地址读 = %d  (💀 未定义行为，本次没崩)\n", p[0]);
    return 0;
}

# c02_buffer.py
buf = bytearray(b"hello")
mv = memoryview(buf)          # ⭐ 有人在看着这块内存了
try:
    buf.extend(b"world")      # 会导致重新分配 —— 正是上面 C++ 那个实验干的事
except BufferError as e:
    print("BufferError:", e)
mv.release()                  # 看完了，松手
buf.extend(b"world")
print("release 之后再 extend 就成功了:", bytes(buf))

// c02_handle.cpp
// g++ -O2 -std=c++17 c02_handle.cpp -o c02_handle
#include <cstdio>
#include <vector>
#include <string>
#include <memory>

// 真正装数据的那个东西
struct Impl {
    std::vector<float> data;
    explicit Impl(size_t n) : data(n, 1.0f) { std::printf("  Impl(%zu) 出生\n", n); }
    ~Impl()                                 { std::printf("  Impl 死亡\n"); }
};

// 外面这层只是一个「把手」：里面就一个指针
struct Handle {
    std::shared_ptr<Impl> impl;
    explicit Handle(size_t n) : impl(std::make_shared<Impl>(n)) {}
    size_t size() const { return impl->data.size(); }
    long   owners() const { return impl.use_count(); }
};

int main() {
    std::printf("sizeof(std::vector<float>) = %zu 字节\n", sizeof(std::vector<float>));
    std::printf("sizeof(std::string)        = %zu 字节\n", sizeof(std::string));
    std::printf("sizeof(std::shared_ptr<Impl>) = %zu 字节\n", sizeof(std::shared_ptr<Impl>));
    std::printf("sizeof(std::unique_ptr<Impl>) = %zu 字节\n", sizeof(std::unique_ptr<Impl>));
    std::printf("sizeof(Handle)             = %zu 字节  ⭐ 和里面装多少数据无关\n\n",
                sizeof(Handle));

    Handle a(1'000'000);                       // 100 万个 float
    std::printf("a 有 %zu 个 float，持有者 %ld\n", a.size(), a.owners());

    Handle b = a;                              // ⭐ 拷贝「把手」，不拷贝那 100 万个 float
    std::printf("b = a 之后，持有者 %ld，b 也有 %zu 个\n", b.owners(), b.size());
    std::printf("a 和 b 指着同一块数据吗: %s\n",
                a.impl->data.data() == b.impl->data.data() ? "是" : "否");
    std::printf("主函数结束 ↓\n");
    return 0;
}

# c02_torch_ptr.py
import torch
x = torch.ones(1000)
y = x
z = x.clone()
print("y = x    -> data_ptr 相同:", x.data_ptr() == y.data_ptr())
print("z = clone-> data_ptr 相同:", x.data_ptr() == z.data_ptr())