C++库开发之道：实践和原则（二）

#include <iostream>
#include <list>
#include <typeinfo>
template <class T, int size = 0>
class GCPtr {
private:
    static std::list<GCPtr> gclist;
    T* addr;
    bool isArray;
    unsigned arraySize;
    typename std::list<GCPtr>::iterator sit;
public:
    GCPtr(T* t = nullptr) {
        static int firstTime = 1;
        if (firstTime > 0) {
            atexit(cleanup);
            firstTime = 0;
        }
        addr = t;
        isArray = size > 0;
        arraySize = isArray ? size : 0;
        gclist.push_front(*this);
        sit = gclist.begin();
    }
    ~GCPtr() {
        gclist.remove(*this);
    }
    static bool collect() {
        bool memfreed = false;
        typename std::list<GCPtr>::iterator it;
        do {
            for (it = gclist.begin(); it != gclist.end(); it++) {
                if (it->refcount() == 0) {
                    gclist.remove(*it);
                    if (it->isArray) {
                        delete[] it->addr;
                    }
                    else {
                        delete it->addr;
                    }
                    memfreed = true;
                    break;
                }
            }
        } while (it != gclist.end());
        return memfreed;
    }
    static void cleanup() {
        if (!gclist.empty()) {
            std::cout << "Cleaning up garbage:\n";
        }
        while (collect()) ;
    }
    // Overload assignment of pointer to GCPtr
    T* operator=(T* t) {
        addr = t;
        gclist.push_front(*this);
        sit = gclist.begin();
        return t;
    }
    // Overload dereferencing operator
    T& operator*() {
        return *addr;
    }
    // Overload member access operator
    T* operator->() {
        return addr;
    }
    // Return reference count for this specific GCPtr
    int refcount() {
        int count = 0;
        typename std::list<GCPtr>::iterator it;
        for (it = gclist.begin(); it != gclist.end(); it++) {
            if (it->addr == this->addr) {
                count++;
            }
        }
        return count;
    }
    // Overload array subscript operator
    T& operator[](int i) {
        return addr[i];
    }
    // Equality and inequality
    bool operator==(GCPtr& rv) {
        return (rv.addr == this->addr);
    }
    bool operator!=(GCPtr& rv) {
        return (rv.addr != this->addr);
    }
};
template <class T, int size>
std::list<GCPtr<T, size>> GCPtr<T, size>::gclist;

#include <memory>
#include <iostream>
// 基础内存分配器类（Base Memory Allocator Class）
class MemoryAllocator {
public:
    virtual void* allocate(size_t size) = 0;  // 分配内存（Allocate Memory）
    virtual void deallocate(void* ptr) = 0;   // 释放内存（Deallocate Memory）
};
// 标准内存分配器类（Standard Memory Allocator Class）
class StandardAllocator : public MemoryAllocator {
public:
    void* allocate(size_t size) override {
        return malloc(size);  // 使用标准 malloc 函数分配内存（Use standard malloc function to allocate memory）
    }
    
    void deallocate(void* ptr) override {
        free(ptr);  // 使用标准 free 函数释放内存（Use standard free function to deallocate memory）
    }
};
// 智能指针内存分配器类（Smart Pointer Memory Allocator Class）
class SmartAllocator : public MemoryAllocator {
public:
    void* allocate(size_t size) override {
        std::shared_ptr<char> ptr(new char[size], std::default_delete<char[]>());  // 使用 shared_ptr 管理内存（Use shared_ptr to manage memory）
        return ptr.get();
    }
    
    void deallocate(void* ptr) override {
        // shared_ptr 自动管理内存，无需手动释放（shared_ptr automatically manages memory, no need to manually deallocate）
    }
};
// 内存池内存分配器类（Memory Pool Allocator Class）
class MemoryPoolAllocator : public MemoryAllocator {
    // 这里只是一个简单的示例，实际的内存池实现会更复杂（This is just a simple example, actual memory pool implementation would be more complex）
public:
    void* allocate(size_t size) override {
        // 预先分配大块内存，然后从中分配小块内存（Pre-allocate a large block of memory, then allocate small blocks from it）
        return nullptr;
    }
    
    void deallocate(void* ptr) override {
        // 将内存块返回到内存池（Return the memory block back to the memory pool）
    }
};
int main() {
    // 使用策略模式选择合适的内存分配器（Use Strategy Pattern to choose appropriate memory allocator）
    MemoryAllocator* allocator = new StandardAllocator();  // 可替换为 SmartAllocator 或 MemoryPoolAllocator（Can replace with SmartAllocator or MemoryPoolAllocator）
    void* memory = allocator->allocate(1024);
    
    // 使用内存（Use the memory）
    allocator->deallocate(memory);
    delete allocator;
    return 0;
}

#include <vector>
#include <random>
#include <algorithm>
#include <chrono>
#include <iostream>
#include <execution>
// 使用 std::chrono 库进行性能测试
// Use std::chrono for performance testing
auto start = std::chrono::high_resolution_clock::now();
// 简单的线性搜索
// Simple linear search
int linear_search(const std::vector<int>& data, int value) {
    for (size_t i = 0; i < data.size(); ++i) {
        if (data[i] == value) {
            return i;
        }
    }
    return -1;
}
// 对线性搜索进行优化，使用迭代器
// Optimized linear search using iterators for better cache utilization
int linear_search_optimized(const std::vector<int>& data, int value) {
    for (auto it = data.begin(); it != data.end(); ++it) {
        if (*it == value) {
            return std::distance(data.begin(), it);
        }
    }
    return -1;
}
// 并行化线性搜索，使用 C++17 的 Parallel STL
// Parallelized linear search using C++17's Parallel STL
int linear_search_parallel(const std::vector<int>& data, int value) {
    auto it = std::find(std::execution::par, data.begin(), data.end(), value);
    if (it != data.end()) {
        return std::distance(data.begin(), it);
    }
    return -1;
}
int main() {
    // 创建一个大型数据集
    // Create a large data set
    std::vector<int> data(1e7);
    std::iota(data.begin(), data.end(), 0);
    // 打乱数据集
    // Shuffle the data set
    std::random_device rd;
    std::mt19937 g(rd());
    std::shuffle(data.begin(), data.end(), g);
    // 需要搜索的值
    // The value to search for
    int value = 123456;
    // 测试三种搜索函数的性能
    // Test the performance of the three search functions
    auto start = std::chrono::high_resolution_clock::now();
    int idx = linear_search(data, value);
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "linear_search: " << diff.count() << " s\n";
    start = std::chrono::high_resolution_clock::now();
    idx = linear_search_optimized(data, value);
    end = std::chrono::high_resolution_clock::now();
    diff = end - start;
    std::cout << "linear_search_optimized: " << diff.count() << " s\n";
    start = std::chrono::high_resolution_clock::now();
    idx = linear_search_parallel(data, value);
    end = std::chrono::high_resolution_clock::now();
    diff = end - start;
    std::cout << "linear_search_parallel: " << diff.count() << " s\n";
    return 0;
}

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
// Thread-safe Queue
// 线程安全的队列
class SafeQueue {
private:
    std::queue<int> data_queue;  // Data Queue 数据队列
    std::mutex mtx;  // Mutex 互斥锁
    std::condition_variable cond;  // Condition Variable 条件变量
public:
    // Push Element
    // 插入元素
    void push(int val) {
        std::lock_guard<std::mutex> lock(mtx);  // Automatically lock and unlock 自动加锁和解锁
        data_queue.push(val);
        cond.notify_one();  // Notify waiting thread 通知等待的线程
    }
    // Pop Element
    // 弹出元素
    int pop() {
        std::unique_lock<std::mutex> lock(mtx);  // Manually lock and unlock 手动加锁和解锁
        // Wait until queue is not empty
        // 等待直到队列非空
        cond.wait(lock, [this]{ return !data_queue.empty(); });
        int result = data_queue.front();
        data_queue.pop();
        return result;
    }
};
int main() {
    SafeQueue sq;
    // Producer Thread
    // 生产者线程
    std::thread producer([&](){
        for (int i = 0; i < 10; ++i) {
            sq.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
    });
    // Consumer Thread
    // 消费者线程
    std::thread consumer([&](){
        for (int i = 0; i < 10; ++i) {
            int val = sq.pop();
            std::cout << "Consumed: " << val << std::endl;
        }
    });
    producer.join();
    consumer.join();
    return 0;
}

#include <thread>
#include <mutex>
#include <atomic>
// 线程安全的计数器类
class ThreadSafeCounter {
private:
    std::mutex mutex_;  // 互斥锁用于保护数据
    int count_;  // 计数器
    std::atomic<int> atomic_count_;  // 原子计数器
public:
    ThreadSafeCounter() : count_(0), atomic_count_(0) {}
    // 使用互斥锁保护的计数器增加函数
    void increase() {
        std::lock_guard<std::mutex> lock(mutex_);
        ++count_;
        // 锁自动在函数退出时释放，保证了异常安全性
    }
    // 使用原子操作的计数器增加函数
    void atomic_increase() {
        ++atomic_count_;
        // 无需使用互斥锁，原子操作保证了线程安全
    }
    int get_count() const {
        return count_;
    }
    int get_atomic_count() const {
        return atomic_count_;
    }
};
int main() {
    ThreadSafeCounter counter;
    // 启动多个线程并发增加计数器
    std::thread t1([&]() { for(int i = 0; i < 10000; ++i) counter.increase(); });
    std::thread t2([&]() { for(int i = 0; i < 10000; ++i) counter.increase(); });
    t1.join();
    t2.join();
    // 此时，get_count()的返回值应该是20000，因为increase()是线程安全的
    // 启动多个线程并发增加原子计数器
    std::thread t3([&]() { for(int i = 0; i < 10000; ++i) counter.atomic_increase(); });
    std::thread t4([&]() { for(int i = 0; i < 10000; ++i) counter.atomic_increase(); });
    t3.join();
    t4.join();
    // 此时，get_atomic_count()的返回值应该是20000，因为atomic_increase()是线程安全的
    return 0;
}

#include <thread>
#include <mutex>
#include <iostream>
#include <vector>
// A shared resource that multiple threads may need to access
// 共享资源，多个线程可能需要访问
std::vector<int> shared_resource;
// A fine-grained mutex to protect shared_resource
// 一个细粒度的互斥锁来保护 shared_resource
std::mutex resource_mutex;
void worker(int id) {
    for(int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(resource_mutex); // Lock the mutex
        shared_resource.push_back(i);
        std::cout << "Thread " << id << " added " << i << " to the shared resource\n";
        lock.unlock(); // Unlock the mutex
        // Simulate some work that doesn't involve the shared resource
        // 模拟一些不涉及共享资源的工作
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    // Join the threads to wait for their completion
    // 合并线程，等待它们完成
    t1.join();
    t2.join();
    // Verify that there are no deadlocks by ensuring that all items were added
    // 通过确保所有项都已添加，验证没有死锁
    std::cout << "Total items in the shared resource: " << shared_resource.size() << "\n";
    return 0;
}