Lecture 2: Standard Library: Vectors, Iterators, Sets, and Maps

• A vector is a sequence of objects that are conceptually stored one after the other
• Vectors are implemented with templates, so you can store one kind of object type in the vector container

# Makefile
CXX=g++

main: main.o
        ${CXX} -o main -std=C++17 main.o

clean:
        rm -f *.o main

// main.cpp
#include<vector>

int main() {
  std::vector<int> v; // a vector containing int elements
  return 0;
}

Under-the-hood, vectors are implemented using arrays and behave similar to arrays.

• Vectors can be indexed starting from 0 to \( size - 1 \) yet they're different than arrays.
• Vectors are dynamically-resizable
• Vectors have a size associated with it.
• Arrays do not know their size and the programmer must be aware of it.

// main.cpp
#include<vector>

template <class T>
void printVector(std::vector<T> &v) {
  for (int i = 0; i < v.size(); i++) {
    std::cout << "v[" << i << "] = " << v[i] << std::endl;

  }
  // range-based for loop example
  // for (const T& i : v) {
  //  std::cout << "v[" << index << "] = " << i << std::endl;
  // }

}

int main() {
  std::vector<int> v;
  for (int i = 0; i < 5; i++) // it could be any reasonable size
    v.push_back(i);

  printVector(v);
  return 0;
}

• Like arrays, if you index a vector element that is out of range, you will probably get junk data or make your program crash.
• You can also use the .at() function to access an element. Which is the better option especially for containers other than std::vector. We will talk about why later.
• Unlike operator [], if .at() references an element that the vector doesn't contain, an exception is thrown (more on exceptions later).

std::cout << v.at(4) << std::endl;
std::cout << v.at(5) << std::endl; // EXCEPTION THROWN
std::cout << v1[5] << std::endl; // JUNK

Other supported operations are:

front()

returns the first element

back()

returns the last element

pop_back()

delete the last element

std::cout << "v.front() = " << v.front() << std::endl;
std::cout << "v.back() = " << v.back() << std::endl;
v.pop_back();
printVector(v);

push_back() is one way to create elements in a vector. Though it's not the only way

• You can declare a vector with a size initially
• You can also initialize a vector with a size and default values.

std::vector<int> v1(100); // initializes vector with 100 elements.
std::vector<int> v2(100, 1); //initializes vector with 100 elements = 1

The following code snippet allocates both the vector itself and the contents on the heap. It is usually not what we want. std::vector already allocates the data on the heap so it uses a small space on the stack.

std::vector<int>* v = new vector<int>(10,1); // vector with 10 elements = 1
std::cout << v->size() << std::endl;
printVector(*v);

So, consider the following two vectors:

std::vector<int>* a = new vector<int>(1000,1); // vector with 1000 elements = 1
std::vector<int> b(1000,1); // vector with 1000 elements = 1

Here is where a, *a, and b are allocated on the memory:

 Stack                        Heap
┌────────────────────────┐   ┌────────────────────────┐
│                        │   │                        │
│  ┌─┐                   │   │    ┌───────────┐       │
│  │a├───────────────────┼───┼───►│*a         │       │
│  └─┘                   │   │    │           │       │
│                        │   │    │size: 1000 │       │
│  ┌────────────────┐    │   │    │data:  ────┼────┐  │
│  │b               │    │   │    │           │    │  │
│  │                │    │   │    └───────────┘    │  │
│  │size: 1000      │    │   │                     │  │
│  │data:  ──────┐  │    │   │                     │  │
│  │             │  │    │   │ ┌───────────────────▼┐ │
│  └─────────────┼──┘    │   │ │actual data of *a   │ │
│                │       │   │ │(this is huge)      │ │
│                │       │   │ └────────────────────┘ │
│                │       │   │                        │
│                │       │   │                        │
│                │       │   │  ┌──────────────────┐  │
│                └───────┼───┼─►│actual data of *b │  │
│                        │   │  │(also huge)       │  │
│                        │   │  └──────────────────┘  │
│                        │   │                        │
└────────────────────────┘   └────────────────────────┘

b stores only a pointer to the actual array, and the size on the stack. The 1000-element array is stored on the heap in both cases.

vector<std::string> v2;

v2.push_back("Hello.");
v2.push_back("My");
v2.push_back("name");
v2.push_back("is");
v2.push_back("Batman");

for (vector<std::string>::iterator i = v2.begin(); i < v2.end(); i++) {
    std::cout << *i << " "; // std::string value
    std::cout << i->size() << std::endl; // prints the size of the strings
}

In the above example, we've seen vector functions that deal specifically with iterators.

begin()

returns an iterator that points to the first element

end()

returns an iterator that points to the last element

++

increments the iterator to the next element

<

compares positions of the iterator

*

dereferences an iterator to get the object

vector<std::string>::iterator i = v2.begin();
std::cout << v2[4] << std::endl;      // Batman
std::cout << i[4] << std::endl;       // Batman
std::cout << *(i + 4) << std::endl;   // Batman

In order to erase items in the vector, there is an erase method that requires iterators to do this

// Removing 2nd index of the vector
v2.erase(v2.begin() + 2); // remove "name"
printVector(v2);

// -- separate example --

// Removing 1st and 2nd index - [1,3)
v2.erase(v2.begin() + 1, v2.begin() + 3);
printVector(v2);

#include <set>

int main() {
  std::set<std::string> s;
  s.insert("Case");
  s.insert("Molly");
  s.insert("Armitage");
  s.insert("Case"); // duplicate (only stored once)
  s.insert("Wintermute");
  // print out the contents
  //
  // question: why is there a `const_` below?
  for (set<std::string>::const_iterator i = s.begin(); i != s.end(); i++) {
    std::cout << *i << std::endl;
  }

  // We can use `auto` to let the compiler infer the type of i. This
  // is useful when dealing with long type names. This is equivalent to above.
  for (auto i = s.begin(); i != s.end(); i++) {
    std::cout << *i << std::endl;
  }
}

Note: We will use std::set in the examples for now, we will talk about another option that usually performs better when we talk about hashing.

Moreover, the standard library sets' design is constrained because they support some operations used rarely. Other C++ libraries such as Abseil support faster, almost-always drop-in replacements.

if (s.find("Case") != s.end()) {
    std::cout << "Case exists!" << std::endl; // prints this
} else {
    std::cout << "Case does not exist" << std::endl;
}

if (s.find("Neuromancer") != s.end()) {
    std::cout << "Neuromancer exists!" << std::endl;
} else {
    std::cout << "Neuromancer does not exist" << std::endl;   // prints this
}

#include <map>
std::map<int, std::string> students; // mapping studentIDs to studentNames

// Use bracket notation for creation
students[0] = "Richert";
students[1] = "John Doe";
students[2] = "Jane Doe";
std::cout << "students[1] = " << students[1] << std::endl;

• Similar to a set, find will look for a specific key and return map.end() if the key does not exist.

// Check if a student id exists
if (students.find(1) == students.end()) {
    std::cout << "Can’t find id = 1" << std::endl;
} else {
    std::cout << "Found student id = 1, Name = " << students[1] << std::endl;
}

map<std::string, double> stateTaxes;

stateTaxes["CA"] = 0.88;
stateTaxes["NY"] = 1.65;

if (stateTaxes.find("OR") == stateTaxes.end()) {
    std::cout << "Can't find OR" << std::endl;
} else {
    std::cout << "Found state OR" << std::endl;
}

• insert() will add a key / value pair to the map.
  • If the key already exists, then .insert() will not replace the existing value.
• [] will map a key to a specific value.
  • If the key already exists, then [] will replace the existing value.
  • If the key does not exist, it first creates a default value.
    • This may be expensive!
  • insert_or_assign() is the better option over [] when you want to insert/update a value but don't know if it is in the map already.
• It is usually better to use .at() over [] when reading
  • It will throw an exception rather than inserting a default value silently.
• It is also better to use .insert() or .insert_or_assign() when inserting rather than [].
• In short, avoid using [] with maps unless you know that the key is already in the map.
• Why are there loads of slightly different ways to do the same thing?
  • C++ is an old language.
  • The standards committee stuck with a behavior for [] and .at(). Rather than changing the behavior and breaking existing programs, they introduce new functions such as .insert_or_assign()

#include <utility> // for std::pair

// ...

students.insert(std::pair<int, std::string>(2, "Flatline")); // does not replace
// you can use curly braces with the pair
students.insert(std::pair<int, std::string>{2, "Flatline"});
// it is OK to drop the name as well, the compiler can figure it out
// most of the time
students.insert({2, "Chris Gaucho"});
students[2] = "Chris Gaucho"; // replaces
std::cout << students[2] << std::endl;

// Erasing by iterator
auto p = students.find(2); // p's type is std::map<int,
                           // std::string>::iterator. It is a
                           // mouthful.
students.erase(p); // erases "Jane Doe"

// Erasing by key
students.erase(0); // erases "Richert"

// print out the entire map.
for (auto i = students.begin(); i != students.end(); i++) {
    std::cout << i->first << ": " << i->second << std::endl;
}