C++中list的使用场景详解

template <class T>
struct __list_node {
    __list_node* prev;
    __list_node* next;
    T data;
};

// 高频插入删除示例
std::list<Order> order_book;

// 插入新订单（O(1)）
auto it = order_book.begin();
std::advance(it, 100);  // 定位到第100个位置
order_book.insert(it, new_order);

// 删除特定订单（O(1)）
order_book.erase(found_order);

std::list<Player> game_players;
auto player_it = game_players.begin();

// 即使在其他位置插入/删除元素，原有迭代器仍然有效
game_players.push_back(Player());  // 不影响player_it
game_players.pop_front();          // 不影响player_it

// 除非删除该迭代器指向的元素
player_it = game_players.erase(player_it);  // 返回下一个有效迭代器

class LargeObject {
    char data[1024*1024]; // 1MB数据
    // ...其他成员
};

std::list<LargeObject> big_data_store;

// 插入不会导致元素移动（vector会导致重新分配和拷贝）
big_data_store.push_back(LargeObject());

std::list<int> list1 = {1, 3, 5};
std::list<int> list2 = {2, 4, 6};

// 合并两个有序list
list1.merge(list2);  // list1变为{1,2,3,4,5,6}, list2为空

// 转移元素
std::list<int> list3 = {10, 20};
auto it = list1.begin();
std::advance(it, 2);
list1.splice(it, list3);  // list1: {1,2,10,20,3,4,5,6}

// 连续访问list元素（性能较差）
std::list<int> nums(1000000);
int sum = 0;
for (int n : nums) {  // 每次访问都可能cache miss
    sum += n;
}

// 64位系统下
sizeof(std::list<int>::node) == 
    sizeof(int) + 2*sizeof(void*) = 4 + 16 = 20字节（通常对齐到24字节）

// 存储100万个int：
vector内存：~4MB
list内存：~24MB

#include <iostream>
#include <list>
#include <vector>
#include <chrono>

const int SIZE = 1000000;

void test_list_traversal() {
    std::list<int> lst(SIZE, 1);
    
    auto start = std::chrono::high_resolution_clock::now();
    long sum = 0;
    for (auto n : lst) sum += n;
    auto end = std::chrono::high_resolution_clock::now();
    
    std::cout << "list traversal: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count() 
              << "ms\n";
}

void test_vector_traversal() {
    std::vector<int> vec(SIZE, 1);
    
    auto start = std::chrono::high_resolution_clock::now();
    long sum = 0;
    for (auto n : vec) sum += n;
    auto end = std::chrono::high_resolution_clock::now();
    
    std::cout << "vector traversal: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count() 
              << "ms\n";
}

int main() {
    test_list_traversal();
    test_vector_traversal();
    return 0;
}

list traversal: 12ms
vector traversal: 2ms

template <typename K, typename V>
class LRUCache {
    std::list<std::pair<K, V>> items;
    std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator> key_map;
    size_t capacity;
    
public:
    LRUCache(size_t cap) : capacity(cap) {}
    
    void put(const K& key, const V& value) {
        auto it = key_map.find(key);
        if (it != key_map.end()) {
            items.erase(it->second);
            key_map.erase(it);
        }
        
        items.push_front({key, value});
        key_map[key] = items.begin();
        
        if (items.size() > capacity) {
            key_map.erase(items.back().first);
            items.pop_back();
        }
    }
    
    bool get(const K& key, V& value) {
        auto it = key_map.find(key);
        if (it == key_map.end()) return false;
        
        items.splice(items.begin(), items, it->second);
        value = it->second->second;
        return true;
    }
};

class Process {
    int pid;
    int remaining_time;
    // ...其他属性
};

class Scheduler {
    std::array<std::list<Process>, 5> queues; // 5个优先级队列
    
public:
    void add_process(Process&& p, int priority) {
        queues[priority].push_back(std::move(p));
    }
    
    void schedule() {
        for (auto& queue : queues) {
            if (!queue.empty()) {
                auto& process = queue.front();
                // 执行一个时间片
                process.remaining_time--;
                
                if (process.remaining_time <= 0) {
                    queue.pop_front(); // 完成
                } else if (&queue != &queues.back()) {
                    // 降级到下一优先级
                    queues[&queue - &queues[0] + 1].splice(
                        queues[&queue - &queues[0] + 1].end(),
                        queue, queue.begin());
                }
                break;
            }
        }
    }
};

std::list<int> lst = {1, 2, 3};
// 错误：list不支持operator[]
// int x = lst[1];  

// 正确做法
auto it = lst.begin();
std::advance(it, 1);  // O(n)操作
int x = *it;

// 存储小型元素极不划算
std::list<char> char_list;  // 每个char消耗24+字节(64位系统)

std::list<std::string> names;
// O(n)查找 - 性能差
auto it = std::find(names.begin(), names.end(), "Alice");

// 大型对象+频繁插入删除
std::list<Matrix> matrix_pool;
// 小型对象+频繁遍历
std::vector<int> counters;

std::list<ExpensiveObject> obj_list;
obj_list.emplace_back(args...);  // 直接构造，避免拷贝/移动

template <typename T>
class PoolAllocator { /*...*/ };

std::list<int, PoolAllocator<int>> pooled_list;

#include <memory_resource>
std::pmr::list<int> pmr_list{std::pmr::monotonic_buffer_resource()};