CPP重学（六）#

1
class File {
2
    FILE *fp_;
3
public:
4
    File(const char *path) : fp_(fopen(path, "r")) {   // 构造 = 获取资源
5
        if (!fp_) throw std::runtime_error("open failed");
6
    }
7
    ~File() { if (fp_) fclose(fp_); }                  // 析构 = 释放资源
8
    // ... 读写接口
9
};

1
unique_Ptr:
2
auto p = std::make_unique<int> 67;
3
// std::unique_ptr<int> q = p;        // 编译错误：不可拷贝
4
auto q = std::move(p);                // 移动转移所有权，p 变空
5
零开销：与裸指针同尺寸同性能，perf 下无任何额外成本。
6
语义即文档：unique_ptr 传给函数 = "我借给你，用完还我"。
7

8
shared_ptr
9
auto s1 = std::make_shared<int>(42);
10
auto s2 = s1;                 // 引用计数 2
11
s1.reset();                   // 计数 1
12
// s2 离开作用域时计数归 0，自动 delete
13
引用计数线程安全，但控制块额外分配一次内存（性能略低于 unique_ptr）。
14
循环引用会让计数永不归零 → 泄漏，见下文。
15

16
weak_ptr:打破循环引用
17
struct Node {
18
    std::shared_ptr<Node> next;
19
    std::weak_ptr<Node>    parent;   // 用 weak 避免环
20
};
21

22
auto a = std::make_shared<Node>();
23
auto b = std::make_shared<Node>();
24
a->next   = b;         // b 被 a 持有
25
b->parent = a;         // weak：不增加 a 的计数
26
循环引用问题：如果 parent 也用 shared_ptr，a 和 b 互相持有、计数永不归零，内存泄漏。用 weak_ptr 观察但不拥有，打破环。
27
访问weak指向的对象前要先lock
28
    if (auto sp = parent.lock()) {   // lock 成功说明对象还活着
29
    sp->doSomething();
30
}

1
struct Worker : std::enable_shared_from_this<Worker> {
2
    void start() {
3
        // 错误：shared_ptr<Worker>(this) 新建独立控制块 → 双重释放
4
        // register_callback([self = shared_from_this()] { self->on_event(); });
5
        auto self = shared_from_this();   // 正确：复用同一控制块
6
        register_callback([self] { self->on_event(); });
7
    }
8
    void on_event() { /* ... */ }
9
};

1
int  x = 42;    // x 是左值：有名字、可取地址
2
int  y = x;     // x 作为右值使用（被读取）
3
int &&r = 42;   // 42 是右值字面量：临时、不可取地址

1
class Buffer {
2
    char *data_;
3
    size_t size_;
4
public:
5
    // 拷贝构造：深拷贝（昂贵）
6
    Buffer(const Buffer &o) : data_(new char[o.size_]), size_(o.size_) {
7
        std::copy(o.data_, o.data_ + size_, data_);
8
    }
9
    // 移动构造：偷资源（O(1)）
10
    Buffer(Buffer &&o) noexcept : data_(o.data_), size_(o.size_) {
11
        o.data_ = nullptr;   // 让源对象失效，析构安全
12
        o.size_ = 0;
13
    }
14
    ~Buffer() { delete[] data_; }
15
};
16

17
Buffer a(1024);
18
Buffer b = a;             // 拷贝：分配+复制 1024 字节
19
Buffer c = std::move(a);  // 移动：仅搬指针，O(1)

1
template <typename T>
2
constexpr std::remove_reference_t<T> &&move(T &&t) noexcept {
3
    return static_cast<std::remove_reference_t<T> &&>(t);
4
}

1
template <typename T>
2
void wrapper(T &&arg) {          // 万能引用（T&& 在模板里）
3
    inner(std::forward<T>(arg)); // 保持左值/右值属性转发
4
}
5
T&& 在模板中不是右值引用而是万能引用：传左值 → T = A&，传右值 → T = A。
6
std::forward<T>(arg) 按 T 恢复原始值类别：左值转发成左值、右值转发成右值——"完美转发"。

1
std::vector<int> make() { return {1, 2, 3}; }
2
auto v = make();      // C++17 保证：直接构造，零拷贝零移动

1
std::vector<int> make() {
2
    std::vector<int> v(1000000);
3
    return v;                      // NRVO/C++11 起：直接搬家，不拷百万元素
4
}
5
std::vector<int> a = make();       // 接管 make 里的 vector，零拷贝

1
std::string s = "hello"; std::string t = std::move(s);
2
// s 现在为空，不能再假设它有 "hello"，但能安全析构/赋值

1
int x = 1;
2
int &ref = x;
3
int & &ref_ref = ref;   // "引用的引用"？

1
using LRef  = int&;
2
using RRef  = int&&;
3
using A = LRef&;    // int&  &   → int&
4
using B = LRef&&;   // int&  &&  → int&
5
using C = RRef&;    // int&& &   → int&
6
using D = RRef&&;   // int&& &&  → int&&

1
void f(int &&r);        // 右值引用：只能绑右值
2
template <typename T>
3
void g(T &&arg);        // 万能引用：既能绑左值又能绑右值

1
template <typename T>
2
constexpr T&& forward(std::remove_reference_t<T>& t) noexcept {
3
    return static_cast<T&&>(t);   // 把左值 t 转成 T&&
4
}

1
template <typename T>
2
void wrapper(T &&arg) {
3
    inner(std::forward<T>(arg));
4
}

1
template <typename T>
2
void bad_wrapper(T &&arg) {
3
    inner(std::move(arg));   // 错！左值也被转成右值
4
}

1
#include <utility>
2
#include <iostream>
3

4
void take(int &x)  { std::cout << "lvalue: " << x << "\n"; }
5
void take(int &&x) { std::cout << "rvalue: " << x << "\n"; }
6

7
template <typename T>
8
void log_and_take(T &&arg) {
9
    std::cout << "log...\n";
10
    take(std::forward<T>(arg));   // 值类别原样转发
11
}
12

13
int main() {
14
    int a = 10;
15
    log_and_take(a);        // 输出 lvalue: 10（a 仍是左值）
16
    log_and_take(20);       // 输出 rvalue: 20（临时对象保持右值）
17
}

1
template <typename T>
2
T max_of(T a, T b) {
3
    return a > b ? a : b;
4
}
5

6
int    m1 = max_of(3, 7);          // 实例化 int 版本
7
double m2 = max_of(3.14, 2.71);    // 实例化 double 版本

1
template <typename T>
2
class Stack {
3
    std::vector<T> data_;
4
public:
5
    void push(const T &v) { data_.push_back(v); }
6
    T pop() { auto v = data_.back(); data_.pop_back(); return v; }
7
};
8

9
Stack<int>  si;     // Stack<int>
10
Stack<std::string> ss;   // Stack<std::string>：互不相同的类型

1
template <typename T>       // T 是一个类型
2
void f(T x);

1
template <typename T, int N>   // N 是一个编译期整数常量
2
class Array {
3
    T data[N];
4
};
5

6
Array<int, 10> arr;   // 固定大小 10 的数组，N 在编译期确定
7
N 必须是编译期常量（字面量、constexpr、sizeof 结果等），不能是运行时变量。这让数组大小、循环展开等能在编译期优化。

1
template <template <typename> class Container, typename T>
2
class Wrapper {
3
    Container<T> c;
4
};
5

6
Wrapper<std::vector, int> w;   // Container = std::vector, T = int

1
template <typename... Args>      // Args 是一个"类型包"，可含 0~N 个类型
2
void print(Args... args) {       // args 是"参数包"
3
    (std::cout << ... << args);  // C++17 折叠表达式
4
}
5

6
print(1, "hello", 3.14, 'c');    // Args = {int, const char*, double, char}

1
template <typename T>
2
T max_of(T a, T b) { return a > b ? a : b; }
3

4
// 全特化：const char* 比较内容而非指针
5
template <>
6
const char *max_of<const char *>(const char *a, const char *b) {
7
    return std::strcmp(a, b) > 0 ? a : b;
8
}

1
// 指针版本的 Stack
2
template <typename T>
3
class Stack<T *> {
4
    // 专门处理指针：自动 delete 等
5
};

1
template <typename T>
2
void process(T v) {
3
    if constexpr (std::is_integral_v<T>) {
4
        // 仅整型时编译此分支
5
    } else {
6
        // 其他类型时编译此分支
7
    }
8
}

1
template <typename T>
2
auto length(const T &c) -> decltype(c.size()) {   // 只有有 .size() 才匹配
3
    return c.size();
4
}

1
template <typename T>
2
concept HasSize = requires(T t) { t.size(); };
3

4
template <HasSize T>                 // 约束模板参数
5
size_t length(const T &c) { return c.size(); }
6

7
length(std::vector<int>{1,2,3});     // OK：有 size()
8
// length(42);                        // 编译错误：明确提示 int 不满足 HasSize

1
template <typename T>
2
T max_of(T a, T b) {
3
    return a > b ? a : b;
4
}

1
max_of("apple", "banana");  // 比较的是指针，结果随机！

1
#include <cstring>
2

3
// 通用模板
4
template <typename T>
5
T max_of(T a, T b) {
6
    return a > b ? a : b;
7
}
8

9
// 对 const char* 的显式特化
10
template <>
11
const char* max_of<const char*>(const char* a, const char* b) {
12
    return std::strcmp(a, b) > 0 ? a : b;
13
}

1
// 重载：参数类型不同，参与重载决议
2
const char* max_of(const char* a, const char* b) {
3
    return std::strcmp(a, b) > 0 ? a : b;
4
}

1
Pair<int, int>    a;  // 全特化
2
Pair<double, int> b;  // 偏特化 Pair<T, int>
3
Pair<int*, int*>  c;  // 偏特化 Pair<T*, U*>
4
Pair<double, char> d; // 通用模板

1
std::vector<bool> flags(8);
2
flags[3] = true;   // 这里发生了什么？

1
auto b = flags[3];        // b 是代理对象，不是 bool&
2
bool x = flags[3];        // 能隐式转换，OK
3

4
auto &ref = flags[3];     // 编译错误：不能把代理绑到 bool&

1
namespace std {
2
template <>
3
struct hash<MyType> {        // 为自定义类型提供哈希
4
    size_t operator()(const MyType &t) const {
5
        return /* 计算哈希 */;
6
    }
7
};
8
}