Storing data with vectors, a sequence of elements that you can access by an index.





Vectors

`<std::vector>` not only stores the elements; it also stores the size of the vector:

![size](https://content.codecademy.com/courses/learn-cpp/vectors/size.png)

The `.size()` function returns the number of elements in the vector.

For example, suppose we have a `std::string` vector with Sonny's grocery list:

```cpp
std::vector<std::string> grocery = {"Hot Pepper Jam", "Dragon Fruit", "Brussel Sprouts"};
```

It should look something like this:

![https://content.codecademy.com/courses/learn-cpp/vectors/size1.png](https://content.codecademy.com/courses/learn-cpp/vectors/size1.png)

- The string at index `0` is `"Hot Pepper Jam"`.
- The string at index `1` is `"Dragon Fruit"`.
- The string at index `2` is `"Brussel Sprouts"`.


```cpp
std::cout << grocery.size() << "\n";
```

will return

```bash
3
```

Notice how nothing goes in the parentheses.


.size()

So what happens when you want to change each of the values within a vector?

You can use a `for` loop!

For example, suppose we have an `int` vector that looks like this:

![1](https://content.codecademy.com/courses/learn-cpp/vectors/operations1.png)

You can write a `for` loop that iterates from `0` to `vector.size()`. And here's the cool part: you can use the counter of the `for` loop as the index! Woah.

```cpp
for (int i = 0; i < vector.size(); i++) {

  vector[i] = vector[i] + 10;

}
```

This will change the vector to:

![2](https://content.codecademy.com/courses/learn-cpp/vectors/operations2.png)

Here, we incremented `i` from `0` to `vector.size()`, which is 3. During each iteration, we are adding 10 to the element at position `i`:

- When `i = 0`, we added 10 to `vector[0]`
- When `i = 1`, we added 10 to `vector[1]`
- When `i = 2`, we added 10 to `vector[2]`

Operations

The `std::vector` lives in the `<vector>` header. So first, we need to add this line of code at the top of the program:

```cpp
#include <vector>
```

For review, `#include` is a preprocessor directive that tells the compiler to include whatever library that follows. In our case that is the standard `vector` library.

And the syntax to create a vector looks like:

```cpp
std::vector<type> name;
```

So to define a vector of `int`s called `calories_today`:

```cpp
std::vector<int> calories_today;
```

Inside the angle brackets is the data type of the vector. After the angle brackets is the name of the vector.

**Note:** The type of the vector (i.e., what data type is stored inside) cannot be changed after the declaration.

Creating a Vector

Now we know how to create a vector, we can also initialize a vector, giving it values, as we are creating it in the same line.

For example, instead of just creating a `double` vector named `location`:

```cpp
std::vector<double> location;
```

We can create *and* initialize `location` with specific values:

```cpp
std::vector<double> location = {42.651443, -73.749302};
```

Here, we are storing <a href="https://en.wikipedia.org/wiki/Geographic_coordinate_system" target="_blank">a latitude and a longitude</a>.

So it would look something like this:

![Vector](https://content.codecademy.com/courses/learn-cpp/vectors/vectors1.png)

Another way we can initialize our vector is by *presizing*, or setting the size.

Suppose we want to create and initialize a vector with two elements. However, we don't know what values we want to add yet:

```cpp
std::vector<double> location(2);
```

Here, we are creating a `double` vector and setting the initial size to two using parentheses.

It would look something like this:

![presize](https://content.codecademy.com/courses/learn-cpp/vectors/vectors2.png)

Because `0.0` is the default value for `double`.



Initializing a Vector

Now that we have a vector, how do we access an individual element? This is where index comes into play.

An _index_ refers to an element's position within an ordered list. Vectors are 0-indexed, meaning the first element has index 0, the second index 1, and so on.

For example, suppose we have a `char` vector with all the <a href="https://en.wikipedia.org/wiki/Vowel" target="_blank">vowels</a>:

```cpp
std::vector<char> vowels = {'a', 'e', 'i', 'o', 'u'};
```

It should look something like this:

![vowels](https://content.codecademy.com/courses/learn-cpp/vectors/index1.png)

- The character at index `0` is `'a'`. 
- The character at index `1` is `'e'`.
- The character at index `2` is `'i'`.
- The character at index `3` is `'o'`.
- The character at index `4` is `'u'`.

To output each of the elements, we can do:

```cpp
std::cout << vowels[0] << "\n";
std::cout << vowels[1] << "\n";
std::cout << vowels[2] << "\n";
std::cout << vowels[3] << "\n";
std::cout << vowels[4] << "\n";
```

Using the notation `vector[index]` with square brackets after the vector name and the element's index number inside.

This will output:

```bash
a
e
i
o
u
```

Index

Congratulations! You have learned about how to store groups of data into vectors in C++. 🙌

Here are some of the things that we learned:

- Vectors are a sequence of elements that you can access by an index.
```cpp
std::vector<int> even = {2, 4, 6, 8, 10};
```
- The first index in a vector is `0`.

- Some of the functions that come with vectors:
    - `.push_back()`
    - `.pop_back()`
    - `.size()`

- We can use a `for` loop to iterate through a vector.

Review

To do just about anything of interest in a program, we need a group of data to work with.

For example, our program might need:

- A list of Twitter's trending tags
- A set of payment options for a car
- A catalog of eBooks read over the last year

The need for storing a collection of data is endless. 

We are familiar with data types like `int` and `double`, but how do we store a group of `int`s or a group of `double`s?


In this lesson, we will start with one of the simplest, and arguably the most useful, ways of storing data in C++: a vector.

A _vector_ is a sequence of elements that you can access by index.

vector with 1,1,2,3 and corresponding indices 0,1,2,3

Introduction to Vectors

Often, we start with a vector that's either empty or a certain length. As we read or compute data we want, we can grow the vector as needed.

##### .push_back() #####

To add a new element to the "back", or end of the vector, we can use the `.push_back()` function.

For example, suppose we have a vector called `dna` with three letter codes of <a href="https://en.wikipedia.org/wiki/Nucleotide" target="_blank">nucleotides</a>:

```cpp
std::vector<std::string> dna = {"ATG", "ACG"};
```

It would look like:

![1](https://content.codecademy.com/courses/learn-cpp/vectors/adding1.png)

We can add elements using `.push_back()`:

```cpp
dna.push_back("GTG");
dna.push_back("CTG");
```

So now `dna` would look like:

![2](https://content.codecademy.com/courses/learn-cpp/vectors/adding2.png)

##### .pop_back() #####

You can also remove elements from the "back" of the vector using `.pop_back()`.

```cpp
dna.pop_back();
```

Notice how nothing goes inside the parentheses.

The vector would now look like:

![3](https://content.codecademy.com/courses/learn-cpp/vectors/adding3.png)

because `CTG` is removed!

**Note:** If you have programmed in other languages, be aware that `.pop_back()` has no return value in C++.
