为什么C++ vector没有按索引删除的直接语法？

Great question! Python’s del myvector[5] is such a clean, intuitive way to remove elements, so it makes total sense to wonder why C++ went with the iterator-based erase() approach instead. Let’s break down the key reasons behind this design choice:

• C++ prioritizes explicit control and efficiency
  When you write myvector.erase(myvector.begin() + 5), you’re using an iterator—the core mechanism C++ uses to interact with container elements. This makes the cost of the operation explicit: for vector (a contiguous container), begin() + 5 is an O(1) operation, but for non-random-access containers like list, you’d have to iterate to the 5th element (O(n)). A del-style syntax would hide this underlying cost, which goes against C++’s philosophy of letting programmers understand and optimize every part of their code.

• Iterator-based APIs ensure consistency across all containers
  Nearly every standard C++ container (vector, list, set, map, etc.) uses iterators for insertion, deletion, and traversal. The erase() method works the same way for all of them—pass an iterator to the element you want to remove. This uniformity means once you learn how to delete elements from one container, you can apply that knowledge to any other. An index-based del syntax would only work for random-access containers (like vector and array), breaking this consistent, generic pattern.

• Avoiding ambiguity and hidden behavior
  Imagine if C++ had del myvector[5]: what happens if the index is out of bounds? Python throws a runtime error, but C++ avoids implicit runtime checks by default to keep code fast. Using begin() + 5 makes it clear that you’re responsible for validating the index (or you can use myvector.at(5) to get a bounds-checked iterator if you want safety). Plus, erase() returns an iterator to the next element—critical for operations like removing elements while iterating—something a del syntax wouldn’t easily support without extra complexity.

• Historical design rooted in generic programming
  C++’s container library was built in the 1990s, when generic programming was becoming a cornerstone of the language. Iterators were chosen as the "bridge" between containers and algorithms, allowing functions like sort() or find() to work with any container. Building deletion around iterators fit naturally into this framework, whereas an index-based syntax would have been a special case that didn’t align with the language’s generic goals.

If you want a syntax closer to Python’s, you can wrap the erase logic in a simple helper function:

#include <vector>

template <typename T>
void del_at(std::vector<T>& vec, size_t index) {
    if (index < vec.size()) {
        vec.erase(vec.begin() + index);
    }
    // Uncomment below to throw an error for out-of-bounds indices
    // else {
    //     throw std::out_of_range("Index out of bounds");
    // }
}

Then you can call del_at(myvector, 5) for a more familiar feel, while still retaining C++’s control and efficiency.

内容的提问来源于stack exchange，提问作者user9240949