C++ vector用法.doc

List 是 .NET 框架中泛型集合的代表，其设计目标与 C++ vector 高度相似：提供动态大小的连续内存存储、支持随机访问、自动扩容机制。与 C++ vector 不同的是，List 基于泛型实现，完全避免了装箱/拆箱操作，同时内置了线程安全检查机制。

List 的构造方式灵活多样，支持多种初始化场景：

// 创建空列表
List numbers = new List();

// 指定初始容量（避免多次扩容）
List names = new List(100);

// 通过集合初始化器
List points = new List
{
    new Point(1, 2),
    new Point(3, 4)
};

// 从现有集合转换
int[] array = { 1, 2, 3 };
List listFromArray = new List(array);

List 提供了多个关键属性用于监控集合状态：

• Count：实际元素数量（只读）
• Capacity：底层数组容量（可读写）

List values = new List();
values.Capacity = 50;  // 预分配空间
Console.WriteLine($"Count: {values.Count}, Capacity: {values.Capacity}");

List 提供了多种添加元素的方式，满足不同场景需求：

List letters = new List();

// 尾部添加（O(1) 平均时间复杂度）
letters.Add('a');

// 指定位置插入（O(n) 时间复杂度）
letters.Insert(0, 'b');  // 在开头插入

// 批量添加
string[] words = { "hello", "world" };
letters.AddRange(words.Select(w => w[0]));

通过索引器或 LINQ 方法实现元素访问：

List dates = new List
{
    new DateTime(2023, 1, 1),
    new DateTime(2023, 2, 1)
};

// 索引访问（O(1)）
DateTime firstDate = dates[0];

// 安全访问（避免索引越界）
if (dates.Count > 1)
{
    DateTime secondDate = dates[1];
}

// LINQ 查询
var futureDates = dates.Where(d => d > DateTime.Now);

删除操作包含多种实现方式，性能特性各异：

List files = new List { "a.txt", "b.txt", "c.txt" };

// 按索引删除（O(n) 移动元素）
files.RemoveAt(0);

// 按值删除（首次匹配）
files.Remove("b.txt");

// 批量删除（条件删除）
files.RemoveAll(f => f.EndsWith(".tmp"));

// 清空集合
files.Clear();

List 内置了多种排序和搜索算法：

List scores = new List { 85, 92, 78, 90 };

// 默认升序排序
scores.Sort();

// 自定义比较器
scores.Sort((x, y) => y.CompareTo(x));  // 降序

// 二分搜索（要求已排序）
int index = scores.BinarySearch(90);

// LINQ 排序（延迟执行）
var orderedScores = scores.OrderByDescending(s => s);

List 与其他数据结构的转换方法：

List people = new List
{
    new Person("Alice", 25),
    new Person("Bob", 30)
};

// 转换为数组
Person[] array = people.ToArray();

// 转换为字典
Dictionary nameAgeDict = people
    .ToDictionary(p => p.Name, p => p.Age);

// 转换为只读集合
IReadOnlyList readOnly = people.AsReadOnly();

在多线程环境下使用 List 的注意事项：

// 非线程安全示例（可能导致异常）
List sharedList = new List();

Parallel.For(0, 100, i => 
{
    // 错误！多线程同时修改会抛出异常
    sharedList.Add(i);
});

// 正确做法1：使用锁
object lockObj = new object();
Parallel.For(0, 100, i => 
{
    lock (lockObj)
    {
        sharedList.Add(i);
    }
});

// 正确做法2：使用并发集合
ConcurrentBag concurrentBag = new ConcurrentBag();
Parallel.For(0, 100, concurrentBag.Add);

合理设置初始容量可显著减少扩容次数：

// 不推荐：频繁扩容
List smallBuffer = new List();
for (int i = 0; i  optimizedBuffer = new List(10000);
for (int i = 0; i 

使用 AddRange 替代多次 Add 调用：

// 低效方式
List paths = new List();
paths.Add("C:\\file1.txt");
paths.Add("C:\\file2.txt");

// 高效方式
string[] newPaths = { "D:\\doc1.txt", "D:\\doc2.txt" };
paths.AddRange(newPaths);

识别并消除性能瓶颈：

List products = GetProducts();

// 低效：每次循环都调用 Count
for (int i = 0; i 

C++ vector 直接管理内存，而 C# List 依赖 CLR 垃圾回收机制：

关键操作的性能基准测试结果（百万级元素）：

public class DataProcessor
{
    private List _buffer = new List(1000);
    
    public void ProcessBatch(IEnumerable newData)
    {
        // 批量添加
        _buffer.AddRange(newData);
        
        // 过滤无效数据
        _buffer.RemoveAll(p => p.Timestamp  x.Value.CompareTo(y.Value));
        
        // 触发处理事件
        OnDataProcessed?.Invoke(_buffer.Take(100).ToList());
    }
    
    public event Action> OnDataProcessed;
}

public class GameWorld
{
    private List _activeObjects = new List(500);
    private List _inactiveObjects = new List();
    
    public void Update(float deltaTime)
    {
        // 激活对象
        foreach (var obj in _inactiveObjects)
        {
            if (obj.ShouldActivate())
            {
                _activeObjects.Add(obj);
                _inactiveObjects.Remove(obj);
                break;
            }
        }
        
        // 更新活动对象
        for (int i = _activeObjects.Count - 1; i >= 0; i--)
        {
            _activeObjects[i].Update(deltaTime);
            if (_activeObjects[i].IsDestroyed)
            {
                _inactiveObjects.Add(_activeObjects[i]);
                _activeObjects.RemoveAt(i);
            }
        }
    }
}

List employees = GetEmployees();

// 方法1：实现 IComparer
public class ByAgeComparer : IComparer
{
    public int Compare(Employee x, Employee y)
    {
        return x.Age.CompareTo(y.Age);
    }
}

employees.Sort(new ByAgeComparer());

// 方法2：使用 Lambda 表达式
employees.Sort((x, y) => x.Department.CompareTo(y.Department));