2.6. The vector class

A vector is intended to behave like a dynamically sized array. It is a template, so unlike a string, which is a container for characters only, a vector can serve as a container for any type. More on templates later, for now, we just need to know enough to know how declare a vector.

As with strings, in standard C, the typical way to work with a collection of data is with a ‘raw’ array:

int a[] = {3, 1, 4, 1, 5, 9};

Some downsides to raw arrays are that they:

• Do not know their own size

• Need to have their size specified when declared

• Decay into pointers easily

• Provide no convenience functions

The vector class solves these problems for us and a few others besides. Declaring a vector is quite similar to the string declarations from the previous section. In order to access the STL vector capabilities, use #include <vector>.

To properly declare a vector, the type of data stored in the vector must be declared as a type parameter.

The <int> and <std::string> represent the template parameters passed to the vector. It is these template parameters that allow the vector class to serve as a container for (almost) any type. There are some limits we will cover later, but for now, know that any normal type you already have learned about can be stored in a vector.

// an empty vector of int
vector<int> x;

// initialize and store: "x", "x"
vector<std::string> dos_equis (2, "x");

// C++11 initialization list syntax
vector<int> pi_digits = {3,1,4,1,5,9};

Unlike a fundamental type, the declaration vector<int> x; does not create an uninitialized variable. It creates a fully formed vector with no elements stored in it yet. This is perfectly OK and normal.

However, a common error is to forget to include the template parameter:

vector x;        // compile error

#include <iostream> #include <string> #include <vector> using std::vector; // alias type std::vector int main() { vector<int> x; // empty vector of int for (const auto& value: x) { std::cout << value << ','; } std::cout << '\n'; vector<std::string> dos_equis (2, "x"); // "x", "x" vector<int> pi_digits = {3,1,4,1,5,9}; // C++11 for (const auto& value: pi_digits) { std::cout << value << ','; } std::cout << '\n'; return 0; }

Given a vector declared as:

std::vector<int> v(4);

A container capable of storing 4 integers is created:

Although the vector object is initialized, its contents are not. Many compiler implementations will initialize the contents to zero, but don’t rely on this behavior. Explicitly initialize with a default value, if that is what you want:

std::vector<int> v(4, -1);

A vector comes with a rich assortment of convenience functions. Like an array, the operator[] can be used to access elements without bounds checking. Like a string, the at function provides bounds checking and will throw a std::out_of_range exception if an out of bounds index is used on the vector.

Like arrays, indexes are zero-based.

// read vector elements
std::cout << "First element: " << numbers[0];
std::cout << "First element: " << numbers.at(0);

// write vector elements
numbers[0] = 5;
numbers.at(0) = 5;

A common source of error occurs when printing a vector. A vector feels like a built-in type and this seems like it should work:

// compile error
std::cout << "all numbers: " << numbers;

The vector type does not ‘know’ how to send it’s values to an output stream by default.

Something to consider

Why do you think this feature is not built into the standard library?

This example demonstrates an out of range error.

How can we fix this while changing the least amount of code possible?

#include <iostream> #include <vector> int main() { std::vector<int> numbers {2, 4, 6, 8}; std::cout << "Size: " << numbers.size() << '\n'; std::cout << "Second element: " << numbers[1] << '\n'; numbers.at(0) = 5; numbers.at(4) = numbers[3] + 2; // out of range error. // index 4 is out of bounds std::cout << "All numbers:"; for (const auto& num : numbers) { std::cout << ' ' << num; } std::cout << '\n'; return 0; }

A vector ‘hello world’:

1. Fill a vector in one simple way, using push_back

2. iterate through the vector and print

#include <iostream> #include <string> #include <vector> using std::cout; using std::string; using std::vector; int main() { vector<string> words = { "reach", "clear", "fall", "set", "yard", "liquid", "wise", "badge", "four", "coherent" }; cout << "Word list: \n"; for (string s: words) { cout << s << ", \thas " << s.size() << " letters\n"; } }

The vector class also provides:

front and back

return a reference to the first and last elements

size

return the number of elements

empty

return true if the container is empty

Although there are more functions, these are the ones we need to worry about for now. We will be looking more at memory management in vectors in The std::vector class.

Something to consider

What is the difference between a std::string and std::vector<char>?

Why did the developers of the STL decide it was important to include both?

Comparisons between vectors are also automatically handled by the class. In the case of a vector, operator==, or an equality comparison between two vectors a and b, means the two vectors are equal if a.size() == b.size() and each element in a compares equal with each element in b in the same position in the vector.

Vectors support the same syntax as the built in types.

// declare 2 vectors, one empty and one not

std::vector<int> x {2, 4, 6, 8};
std::vector<int> y;

bool test = (x == y);   // test is false

y = x;

#include <vector> #include <iostream> int main() { std::vector<int> x {2, 4, 6, 8}; std::vector<int> y; if (x == y) { std::cout << "x and y are equal\n"; } else { std::cout << "x and y differ\n"; } y = x; // copy all data from x into y if (x == y) { std::cout << "x and y are equal\n"; } else { std::cout << "x and y differ\n"; } return 0; }

Try This!

Create two vectors of strings containing the same values and check them for equality.

#include <iostream> int main() { }

2.6.1. Adding data to a vector

How do we solve the out_of_range exception from a few examples ago? How do we dynamically add data to a vector?

A simple way is to use the push_back function.

Given an vector of 3 int’s:

values.push_back(40);

Appends the value 40 to the end of the vector.

push_back appends an element to the end and increases the capacity of the vector, if needed.

pop_back reduces the size of the vector by one. The last element is no longer available.

Note that pop_back does not return a value.

If you need that last element, remember to save it first.

std::vector<char> letters {'a', 'b', 'c'};

letters.push_back('d');  // add 'd' to the end of the vector
letters.pop_back();      // pop_back is the opposite:

#include <vector> #include <iostream> int main() { std::vector<char> letters {'a', 'b', 'c'}; letters.at(0) = 'z'; letters.push_back('d'); // add 'd' to the end of the vector char ch = 'e'; letters.push_back(ch); // add 'e' to the end letters.pop_back(); // pop_back is the opposite: // - removes the end element from the vector std::cout << "All letters:"; for (const auto& c : letters) { std::cout << ' ' << c; } std::cout << '\n'; letters.clear(); // clear all contents from vector return 0; }

2.6.2. Vector capacity

A vector exposes an interface that ‘feels like’ an array, but the underlying storage grows to accommodate new data as required. With an array, you either have to allocate as much memory as you might need in the worst case, even if only a small fraction is used most of the time or you allocate ‘just enough’ and when more memory is required, copy all the data into a new array. A vector does do this also, but the implementation is hidden and you don’t have to worry about it.

Something to be aware of - when pop_back is called, no actual storage is deleted. The memory is still available in the vector and available for reassignment with pop_back.

This extra memory after the current size is referred to as the total capacity of the vector, or just capacity.

Managing the storage capacity in addition to the vector data is one of the things that make vectors efficient.

The ‘phrase-o-matic’ is a port of a fun little java program from Head First Java, 2nd ed. ISBN-13: 978-0596009205

#include <iostream> #include <random> #include <string> #include <vector> int main() { // initialize a random number generator std::random_device r; std::default_random_engine eng(r()); using rand = std::uniform_int_distribution<std::uint64_t>; const char* list_one[] = { "24/7", "multi-tier", "30,000 foot", "B-to-B", "win-win", "front-end", "web-based", "pervasive", "smart", "six-sigma", "critical-path", "dynamic", "extreme", "three-tier", "agile" }; // we prefer vector over arrays const std::vector<std::string> list_two = { "empowered", "sticky", "value-added", "oriented", "centric", "distributed", "clustered", "branded", "outside-the-box", "positioned", "networked", "focused", "leveraged", "aligned", "targeted", "shared", "cooperative", "accelerated" }; const std::vector<std::string> list_three = { "process", "tipping-point", "solution", "architecture", "core competency", "strategy", "mind-share", "portal", "space", "vision", "paradigm", "mission" }; const std::size_t one_size = 14; // arrays don't know their size auto r1 = rand {0, one_size} (eng); auto r2 = rand {0, list_two.size()-1} (eng); // vectors know their size auto r3 = rand {0, list_three.size()-1} (eng); std::string phrase = {list_one[r1]}; phrase += " " + list_two[r2] + " " + list_three[r3]; std::cout << "What we need is a " << phrase << '\n'; // or could have omitted temporary phrase and simply: // std::cout << "What we need is a " << list_one[r1] << ' ' // << list_two[r2] << ' ' // << list_three[r3] << '\n'; return 0; }

A short test program to demonstrate the parts of the vector interface.

What other tests can you make?

#include <iomanip> #include <iostream> #include <string> #include <vector> using std::string; using std::vector; vector<string> make_vector() { return { "reach", "clear", "fall", "set", "yard", "liquid", "wise", "badge", "four", "coherent" }; } void check (const string& name, const string& actual, const string& expected) { std::cout << std::left << std::setfill('.') << std::setw(50) << name << std::setw(7) << std::left; if(actual == expected) { std::cout << " OK \n"; return; } std::cout << " FAILED\n"; std::cout << "\treceived [" << actual << "], but expected [" << expected << "]\n"; exit(1); } // write test cases void test_simple_access(vector<string> words) { check("test at()", words.at(0), "reach"); check("test operator[]", words[0], "reach"); check("test at() end", words.at(9), "coherent"); check("test operator[]", words[9], "coherent"); // foo.at(i) and foo.[i] refer to the same thing for (auto i=0U; i< 3; ++i) { // for (auto i=0U; i< words.size(); ++i) { check("at and operator[] are the same", words.at(i), words[i]); } const string empty; // Try uncommenting these lines to see what happens //check("test at out of bounds", words.at(-1), empty); //check("test at out of bounds", words.at(11), empty); //check("test [] out of bounds", words[-1], empty); //check("test [] out of bounds", words[11], empty); } void test_other_access(vector<string> words) { check("test front()", words.front(), words.at(0)); check("test back()", words.back(), words.at(words.size()-1)); } void test_assignment(vector<string> words) { check("test original value", words[2], "fall"); words[2] = "falldown"; check("test new value", words[2], "falldown"); } // call test cases int main() { auto words = make_vector(); test_simple_access(words); test_other_access(words); test_assignment(words); }

---

More to Explore

• cppreference.com std::vector

• WikiBooks.org C++ Programming STL Containers

You have attempted of activities on this page