Vector Basics and Element Access

Many programmers first meet vectors as a tidy way to hold a list of things. Along the way they build an intuition from simple variables: assigning one number to another is quick and harmless. It is easy to carry that same intuition over to a vector that holds thousands of records, and that carried-over intuition is where trouble starts.

The belief to examine is this: copying a vector is always inexpensive, so you can initialize or assign vectors freely wherever you like. The source material names this as a misconception directly. A vector is not a single small value. It is a container, and copying it means copying the elements it holds. The number of elements matters a great deal.

Before reading on, test the belief yourself. Suppose one vector already exists, and a second vector is created from it. If you change something through the second vector, what do you expect the first vector to contain? Hold that prediction in mind, because the next sections check it against what actually happens.

A vector can be copied in two situations. In an initialization, a new vector is created with the contents of an existing one. In an assignment, an existing vector receives the contents of another. Both situations are carried out by constructors and assignment operators, which are the same mechanisms that govern how copying and moving of vectors work in general.

Both situations follow the same trace. Start with a vector a that holds elements. Run an initialization such as creating b from a. Now ask what exists in memory. The answer is two containers, each with its own block of element storage. The copy did not just record that b is connected to a. It produced a second set of elements.

The diagram shows the result the source describes. Each vector holds its own copy of every element, so the two containers are independent from the moment the copy finishes. Assignment works the same way: when an existing vector receives the contents of another, the receiving vector ends up with its own copies of the elements.

The key fact is what gets copied. A copy of a vector means copying its elements, not merely recording that one name is connected to the other. Once the copy exists, changes to one container cannot reach the other, because there is no shared storage between them.

Here is the prediction the diagram answers. If you modify b[0] after copying a into b, the element a[0] is unaffected. It still holds its original value, because a and b do not share elements. The two containers are independent from that point on, and that independence is exactly what the copy paid for.

Once a vector holds its elements, you reach an individual element by its index. The expression v[i] selects the element at position i within the vector's storage. The elements are kept in order, so each index maps to one stored element and the indices follow the order in which the elements were stored.

Notice that indexing reads or writes the element that is already stored. It does not create a new vector, which is why element access on its own is not the source of the copying cost. The cost comes from initialization and assignment, where the stored elements are duplicated.

The source warns that assignments and initializations that look innocent can become expensive when a vector holds many elements. The reason follows directly from what a copy does: the work grows with the number of elements being copied. A single line of code can therefore hide a large amount of work, and the line itself gives no visual hint of that cost.

When copying is undesirable, the source names two alternatives. One is to use references or pointers, which allow code to work with an existing vector without creating a new one. The other is to use move operations, which the source places in the discussion of constructors and assignment operators. Both avoid the element-by-element duplication that a copy performs.

The source material also gives guidance on which container to reach for. The standard-library vector is described as very flexible and efficient, and it should be used as the default container. Use another container only when there is a solid reason to do so.

The same discipline applies to copying. Keep the default container, and when a vector is large, decide deliberately between a copy, a reference or pointer, and a move, depending on whether you need two independent containers or only access to one that already exists.