C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++ list使用场景

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

作者：北辰alk

这篇文章主要介绍了C++标准库中的`std::list`容器,包括其内部结构、与其它容器的对比、核心使用场景、性能分析、特殊应用场景、使用陷阱与最佳实践,需要的朋友可以参考下

一、list的基本特性与实现原理

1.1 list的内部结构

C++中的std::list是一个双向链表实现的序列容器，其核心特点是非连续内存存储。每个元素（节点）包含三部分：

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

1.2 与其它序列容器的对比

特性listvectordeque
内存布局非连续连续分段连续
随机访问O(n)O(1)O(1)
头部插入/删除O(1)O(n)O(1)
尾部插入/删除O(1)O(1)O(1)
中间插入/删除O(1)O(n)O(n)
迭代器失效仅删除元素失效多数操作失效部分操作失效
内存开销较高(每个元素额外2指针)低中等

二、list的核心使用场景

2.1 频繁的任意位置插入/删除操作

典型场景：

// 高频插入删除示例
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);

2.2 需要稳定迭代器的场景

典型场景：

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);  // 返回下一个有效迭代器

2.3 大对象存储避免移动开销

典型场景：

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

std::list<LargeObject> big_data_store;

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

2.4 需要特殊操作的场景

list独有的高效操作：

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}

三、性能分析与优化

3.1 内存访问模式

缓存不友好问题：

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

优化方案：

3.2 内存使用效率

内存开销计算：

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

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

3.3 迭代器性能测试

#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

四、特殊应用场景

4.1 LRU缓存实现

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;
    }
};

4.2 多级反馈队列调度

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;
            }
        }
    }
};

五、使用陷阱与最佳实践

5.1 常见陷阱

错误使用随机访问：

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");

5.2 最佳实践

结合使用策略：

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

预分配节点（C++17起）：

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

使用自定义分配器：

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

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

六、总结与决策指南

6.1 何时选择list

优先使用list的情况：

避免使用list的情况：

6.2 现代C++的替代方案

  1. forward_list（C++11）：

    • 单向链表
    • 更小内存开销（每个节点少一个指针）
    • 缺少反向遍历能力

  2. pmr::list（C++17）：

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

通过深入理解list的特性与适用场景，开发者可以更好地在适当的场合使用这一经典数据结构，平衡性能需求与功能需求，编写出更高效的C++代码。

以上就是C++中list的使用场景详解的详细内容，更多关于C++ list使用场景的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文