丙加·第10章·Jack of All Trades, And Master of All（STL类型和函数）

// 必须为每种类型写重复代码
void sort_int(int arr[], int n);
void sort_double(double arr[], int n); 
void sort_string(char* arr[], int n);
// 最多再来一个手工泛型
#define SORT(arr, n) _Generic((arr), \
 int*: sort_int, \
 double*: sort_double, \
 char**: sort_string \
 )((arr), (n))

// 具体实现就不写了

#include <algorithm>
#include <vector>
#include <list>
#include <string>

// C数组的快排
// 但是需要手工计算大小
int c_array[] = {3, 1, 4, 1, 5};
int size = sizeof(c_array) / sizeof(c_array[0]);

std::sort(c_array, c_array + size);

#include <algorithm>
#include <vector>
#include <deque>
#include <set>

// 新高考，新背景（大雾）
// 要掌握通性通法（弥天大雾）
std::vector<int> vec = {1, 2, 3, 4, 5};
std::deque<int> deq = {1, 2, 3, 4, 5};  
std::set<int> tree = {1, 2, 3, 4, 5};

// 《完 全 一 致》
auto vec_it = std::find(vec.begin(), vec.end(), 3);
auto deq_it = std::find(deq.begin(), deq.end(), 3);
auto tree_it = std::find(tree.begin(), tree.end(), 3);

// 记得 #include <vector>
std::vector<类型> 变量名;

// 比如
// 空数组
std::vector<int> intArray1;
// C风格导入
// 或者说“初始化列表”
std::vector<int> intArray2 = {1, 2, 3, 4, 5};
// 构造器语法1
// 5个元素，每一个都是0（默认值）
std::vector<int> intArray3(5);
// 构造器语法1
// 5个元素，每一个都是42
std::vector<int> intArray4(5, 42);

// 使用push_back在结尾追加
intArray2.push_back(6);

// 九九乘法表
vector<vector<int>> MultiplicationTable;

for (int i = 1; i <= 9; i++) {
    vector<int> row;  // 创建新行
    for (int j = 1; j <= 9; j++) {
        row.push_back(i * j);  // 计算并添加乘积
    }
    MultiplicationTable.push_back(row);  // 将行添加到乘法表
}

// 打印
for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9; j++) {
        cout << i + 1 << " × " << j + 1 << " = " 
             << MultiplicationTable[i][j] << "\t";
    }
    cout << endl;
}

int x = intArray2[0]; // 获取第一个元素
int y = intArray2.at(1); // 获取第二个元素

// 如果你试图修改：
// 空数组
std::vector<int> intArray1;
intArray1[0] = 999;

// 输出：
// 段错误 (核心已转储)

int size = intArray2.size();

std::vector<int> a = {1, 2, 3, 4, 5};
a.back() = a.front();
// -> {5, 2, 3, 4, 5}

// auto推断出的具体类型是：std::vector<int>::iterator 很长，所以我们直接写auto
for (auto it = intArray2.begin(); it != intArray2.end(); it++) {
    std::cout << *it << " ";
}

for (int element : intArray2) {
    std::cout << element << " ";
}

intArray2.push_back(6);
// 返回插入位置的迭代器

std::vector<int> intArray5 = {1, 4, 5};

// insert(m, x)
// 在指定位置m之前（以下统一说“m处”）插入元素x，插入的x就位于了m位置
// 可以使用C风格，但是语义有点不清晰
// intArray5.insert(1, 2);
intArray5.insert(intArray5.begin() + 1, 2);
// -> {1, 2, 4, 5}

// insert(m, n, x)
// 在指定位置m处插入n个元素x
// 也可以使用C风格，我就不写了
intArray5.insert(intArray5.begin() + 2, 4, 3);
// -> {1, 2, 3, 3, 3, 3, 4, 5}

// insert(m, a, b)
// 在m处插入其他容器（只要有数字下标[]都行）a~b之间的元素
// std::array和C数组一样是定长的（只是多了很多成员方法）
// 这里创建了int类型定长为3的数组
std::array<int,3> test = { 1, 4 };
// 所以这里intArray5.begin() + 8 == intArray5.end()，所以就是push_back啦
intArray5.insert(intArray5.begin() + 8, test.begin(), test.end());
// -> {1, 2, 3, 3, 3, 3, 4, 5, 1, 4}

// insert(m, {初始化列表，或者说C数组一样的东西})
intArray5.insert(intArray5.begin() + 1, {1, 4, 5, 1, 4});
// -> {1, 1, 4, 5, 1, 4, 2, 3, 3, 3, 3, 4, 5, 1, 4}

// erase(m)
// 删除m处的元素
intArray5.erase(intArray5.begin() + 6);
// 删掉了2，返回的是第一个3的迭代器
// -> {1, 1, 4, 5, 1, 4, 3, 3, 3, 3, 4, 5, 1, 4}

// erase(m,n)
// 删除[m, n)这个左闭右开区间的元素
// 注意前面说过`vector.end()`相当于最后一个元素的后面那块
// 不是实际的元素
// 删掉了{5, 1, 4, 3, 3, 3, 3, 4}，返回指向5的迭代器
intArray5.erase(intArray5.begin() + 3, intArray5.begin() + 11);
// -> {1, 1, 4, 5, 1, 4}

intArray5.clear();

std::vector<int> myvector;

// 初始内容设置
for (int i = 1; i <= 10; i++) myvector.push_back(i);

// 调整大小为5，多余的元素被删除
myvector.resize(5);

// 调整大小为8，新元素用100填充
myvector.resize(8, 100);

// 调整大小为12，新元素默认初始化
myvector.resize(12);

std::vector<int> vec = {1, 2, 3};
vec.assign({4, 5, 6, 7});  // 完全替换内容
// 当然，指定迭代器区间assign(xxx.begin() + 5, xxx.end())是完全可以的
// 这是C++ STL的通用语言

template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value)

// 解释：UnaryPredicate 一元谓词
// 指的是接受一个参数，返回true和false的函数
template < class ForwardIterator, class UnaryPredicate, class T >
  void replace_if (ForwardIterator first, ForwardIterator last,
                   UnaryPredicate pred, const T& new_value)

std::sort(myVector.begin(), myVector.end());
// 同样可以传入比较函数
// 这样会反着排
// 更复杂的例子参见6.4.2函数指针
std::sort(myVector.begin(), myVector.end(), [](int a, int b){return a > b;});

// C数组我习惯这样写
// size预先计算好
// +1相当于从最后一个元素推到end()的位置
std::sort(arr, arr + size + 1);

std::vector<int> v = { 1, 9, 19, 8, 10, 233 };

// 返回得到的第一个元素
auto it = std::find(v.begin(), v.end(), key);

// 如果到返回结尾，那肯定是没找到
if (it != v.end()) {
    // 获取位置（从0开始计数）
    // 迭代器相减可以得到元素间的距离
    int position = it - v.begin();
    std::cout << "Element found at position: " << position;

    // 输出具体的值
    std::cout << ", value: " << *it;
}
else {
    std::cout << "Element not found";
}

std::vector<int> v = {1, 1, 4, 5, 1 ,4};

// 返回3
std::count(v.begin(), v.end(), 1);

// 使用默认的相等比较
template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last);

// 使用自定义的二元谓词(自定义“相等”的概念)
template<class ForwardIt, class BinaryPredicate>
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p);

std::list<int> lst1;                  // 空
std::list<int> lst2(5);               // 5个默认元素（0）
std::list<int> lst3(5, 10);           // 5个10
std::list<int> lst4 = {1, 2, 3, 4};   // 初始化列表

#include <map>
#include <string>

std::map<std::string, int> ageMap = {
    {"Alice", 20},
    {"Bob", 25},
    {"Charlie", 30}
};

// 插入元素
ageMap["David"] = 28;
ageMap.insert({"Eve", 22});

// 访问元素
cout << "Alice's age: " << ageMap["Alice"] << endl;
cout << "Bob's age: " << ageMap.at("Bob") << endl;

// 检查键是否存在
if (ageMap.find("Frank") == ageMap.end()) {
    cout << "Frank not found!" << endl;
}

// 假设有一个vector<int> v
auto logic_end = std::remove_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; });
v.erase(logic_end, v.end());
// 等价于v.erase(std::remove_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; }), v.end());

#include <iostream>
#include <memory>

class Test {
public:
    Test(int val) : value(val) {
        std::cout << "Test constructed，value = " << value << std::endl;
    }
    
    ~Test() {
        std::cout << "Test deconstructed，value = " << value << std::endl;
    }
    
    void print() {
        std::cout << "Value: " << value << std::endl;
    }
    
private:
    int value;
};

int main() {
    // 创建
    std::auto_ptr<Test> p1(new Test(10));
    p1->print();
    
    // 转移所有权
    // 此时 p1 变为空，所有权转移给 p2
    std::auto_ptr<Test> p2 = p1;

    if (p1.get() == nullptr) {
        std::cout << "p1 now empty" << std::endl;
    }
    
    p2->print();
 
    return 0;
    // p2 离开作用域，自动释放内存
}

// 且先不讨论 T 能否合法构造，能不能赋值等问题
template<typename T>
void swap(std::auto_ptr<T> a, std::auto_ptr<T> b) {
    T temp;
    temp = *a;
    *a = *b;
	*b = temp;    
}

// 某处
Test p1(1);
Test p2(2);
swap(p1, p2)

调用 swap(p1, p2) 前：
    p1 -> Test(1)
    p2 -> Test(2)

进入 swap 时（参数传递）：
    p1 → nullptr    (所有权给了 a)
    p2 → nullptr    (所有权给了 b)
    a → Test(1)
    b → Test(2)

swap 函数体内：
    a → Test(2)     // 交换了对象内容
    b → Test(1)     // 交换了对象内容

swap 函数结束时：
	a 析构 → 删除 Test(2)
	b 析构 → 删除 Test(1)
	p1 → nullptr    // 空的！
	p2 → nullptr    // 空的！

std::auto_ptr<Test> p(new Test[5]);

// ==================== 创建操作 ====================

// 1. 创建空智能指针
std::unique_ptr<int> up1(nullptr);

// 2. 创建时直接指定管理对象
std::unique_ptr<int> up2(new int(1));
// 也可以 auto up2 = std::make_unique<int>(1)

// 3. 使用自定义删除器替代默认的 std::default_delete<T>
// 注：D 可以是任何函数对象类型 - 普通函数、lambda、重载operator()的类等
std::unique_ptr<int, CustomDeleter> up3(new int(1));          // 使用默认构造的删除器
std::unique_ptr<int, CustomDeleter> up4(new int(1), CustomDeleter()); // 传递删除器实例

// ==================== 所有权管理 ====================

// 4. 释放所有权：返回裸指针，智能指针变为空
// 注意：调用者需要手动管理返回的裸指针的生命周期
int *raw_ptr = up2.release();

// 5. 转移所有权：通过移动语义
std::unique_ptr<int> up5 = std::move(up2);  // up2 变为空指针

// 6. 转移所有权：通过 release + reset 组合
up5.reset(up3.release());  // up3 释放所有权，up5 接管

// ==================== 资源管理 ====================

// 7. 重置管理对象：销毁当前对象，绑定新对象
up5.reset(new int(1));     // 先销毁原对象，再管理新对象

// 8. 显式销毁对象：将智能指针置为空，销毁当前管理对象
up5 = nullptr;             // 等价于 up5.reset()

// ==================== 访问操作 ====================

// 9. 获取裸指针（但不释放所有权）
int* ptr = up5.get();

// 10. 访问管理对象
// 这一点与裸指针完全一致
int value = *up5;          // 解引用
up5->a_method();        // 箭头操作符

// 11. 检查是否为空
if (up5) {                 // 或 up5 != nullptr
    // 非空处理
}

#include <iostream>
#include <memory>

class Resource {
public:
    Resource(int id) : id(id) {
        std::cout << "创建资源 " << id << std::endl;
    }
    ~Resource() {
        std::cout << "销毁资源 " << id << std::endl;
    }
    void use() {
        std::cout << "使用资源 " << id << std::endl;
    }
private:
    int id;
};

int main() {
    // 创建 shared_ptr
    std::shared_ptr<Resource> sp1 = std::make_shared<Resource>(19690714);
    
    // 共享所有权
    std::shared_ptr<Resource> sp2 = sp1;  // 引用计数 +1
    std::shared_ptr<Resource> sp3 = sp2;  // 引用计数再 +1
    
    std::cout << "引用计数: " << sp1.use_count() << std::endl;  // 输出 3
    
    // 所有 shared_ptr 都可以使用资源
    sp1->use();
    sp2->use();
    sp3->use();
    
    // 释放部分引用
    sp2.reset();  // 引用计数 -1
    std::cout << "sp2 释放后引用计数: " << sp1.use_count() << std::endl;
    
    sp3.reset();  // 引用计数 -1  
    std::cout << "sp3 释放后引用计数: " << sp1.use_count() << std::endl;
    
    // 当 sp1 也离开作用域时，引用计数归零，资源被销毁
    return 0;
}

创建资源 19690714
引用计数: 3
使用资源 19690714
使用资源 19690714
使用资源 19690714
sp2 释放后引用计数: 2
sp3 释放后引用计数: 1
销毁资源 19690714

#include <iostream>
#include <memory>

class Wife;  // 嵌套成员需要前向声明，参见 9.2.1 碎碎念

class Husband {
public:
    std::string name;
    std::shared_ptr<Wife> wife_ptr;  // 丈夫持有妻子的 shared_ptr
    
    Husband(const std::string& n) : name(n) {
        std::cout << name << "'s constructor" << std::endl;
    }
    
    ~Husband() { 
        std::cout << name << "'s destructor" << std::endl; 
    }
    
    void setWife(std::shared_ptr<Wife> wife) {
        wife_ptr = wife;
    }
};

class Wife {
public:
    std::string name;
    std::shared_ptr<Husband> husband_ptr;  // 妻子持有丈夫的 shared_ptr
    
    Wife(const std::string& n) : name(n) {
        std::cout << name << "'s constructor" << std::endl;
    }
    
    ~Wife() { 
        std::cout << name << "'s destructor" << std::endl; 
    }
    
    void setHusband(std::shared_ptr<Husband> husband) {
        husband_ptr = husband;
    }
};

int main() {
    auto nasa = std::make_shared<Husband>("Yuzaki Nasa");
    auto tsukasa = std::make_shared<Wife>("Yuzaki Tsukasa");

    std::cout << "=== Yuzaki couple got married ===" << std::endl;
    // 建立婚姻关系 - 创建循环引用
    nasa->setWife(tsukasa);  // tsukasa 引用计数变为 2
    tsukasa->setHusband(nasa);  // nasa 引用计数变为 2
    
    std::cout << nasa->name << "'s reference count: " << nasa.use_count() << std::endl;    // 2
    std::cout << tsukasa->name << "'s reference count: " << tsukasa.use_count() << std::endl; // 2
    
    std::cout << "The Yuzaki couple lived happily..." << std::endl;
    std::cout << nasa->name << " loves his wife " << nasa->wife_ptr->name << std::endl;
    std::cout << tsukasa->name << " loves her husband " << tsukasa->husband_ptr->name << std::endl;
    
    return 0;
}

Yuzaki Nasa's constructor
Yuzaki Tsukasa's constructor
=== Yuzaki couple got married ===
Yuzaki Nasa's reference count: 2
Yuzaki Tsukasa's reference count: 2
The Yuzaki couple lived happily...
Yuzaki Nasa loves his wife Yuzaki Tsukasa
Yuzaki Tsukasa loves her husband Yuzaki Nasa

#include <iostream>
#include <memory>

class Wife;  // 前向声明

class Husband {
// 下面已经定义了完整的 setter 和 getter 了
// 就没必要也最好不把 wife_ptr 做成公有的了
private:
    std::weak_ptr<Wife> wife_ptr;  // 改为弱引用，不增加引用计数

public:
    std::string name;
    
    Husband(const std::string& n) : name(n) {
        std::cout << name << "'s constructor" << std::endl;
    }
    
    ~Husband() { 
        std::cout << name << "'s destructor" << std::endl; 
    }
    
    void setWife(std::shared_ptr<Wife> wife) {
        wife_ptr = wife;
    }

    // 获取妻子指针（可能为空）
    std::shared_ptr<Wife> getWife() {
        return wife_ptr.lock();  // 尝试拿到 shared_ptr
    }
};

class Wife {
private:
    std::weak_ptr<Husband> husband_ptr;  // 改为弱引用，不增加引用计数

public:
    std::string name;
    
    Wife(const std::string& n) : name(n) {
        std::cout << name << "'s constructor" << std::endl;
    }
    
    ~Wife() { 
        std::cout << name << "'s destructor" << std::endl; 
    }
    
    void setHusband(std::shared_ptr<Husband> husband) {
        husband_ptr = husband;
    }

    // 获取丈夫指针（可能为空）
    std::shared_ptr<Husband> getHusband() {
        return husband_ptr.lock();  // 尝试拿到 shared_ptr
    }
};

int main() {
    auto nasa = std::make_shared<Husband>("Yuzaki Nasa");
    auto tsukasa = std::make_shared<Wife>("Yuzaki Tsukasa");
    
    std::cout << "=== Yuzaki couple got married ===" << std::endl;

    // 建立婚姻关系
    nasa->setWife(tsukasa);
    tsukasa->setHusband(nasa);
    
    std::cout << "Yuzaki Nasa's reference count: " << nasa.use_count() << std::endl;    // 1
    std::cout << "Yuzaki Tsukasa's reference count: " << tsukasa.use_count() << std::endl; // 1
    
    std::cout << "The Yuzaki couple lived happily..." << std::endl;
    

    if (auto wife = nasa->getWife()) {
        std::cout << nasa->name << " loves his wife " << wife->name << std::endl;
    }
    
    if (auto husband = tsukasa->getHusband()) {
        std::cout << tsukasa->name << " loves her husband " << husband->name << std::endl;
    }

    return 0;
}

Yuzaki Nasa's constructor
Yuzaki Tsukasa's constructor
=== Yuzaki couple got married ===
Yuzaki Nasa's reference count: 1
Yuzaki Tsukasa's reference count: 1
The Yuzaki couple lived happily...
Yuzaki Nasa loves his wife Yuzaki Tsukasa
Yuzaki Tsukasa loves her husband Yuzaki Nasa
Yuzaki Tsukasa's destructor
Yuzaki Nasa's destructor

if (husband->expired()) {
    // 完结散纸花 (T⌓T)
}