Vectors

  1. Overview
    1. A vector is a collection of like items that can change in size dynamically (at run-time)
    2. Vectors consume more memory than arrays but the ability to resize dynamically makes them more useful
    3. A vector is an object, a programming construct that combines the data with the functions (called methods) that work on the data
      object.method();
      
    4. The vector library must be included to use vectors
      #include <vector>
      
  2. Declaring a vector
    1. Data type is in angle brackets <type>, and initial size in parenthesis
      // Vector that holds 5 integers (all initially zero)
      vector<int> numbers(5);
      
      // Holds 8 chars (all initially spaces)
      vector<char> gameBoard(8);
      
      // Holds 4 booleans (all initially false)
      vector<bool> coinFlips(4);
      
    2. Initial size is optional; creates size 0 vector
      // Empty vector that holds integers 
      vector<int> numbers;
      
  3. Initializing a vector
    1. Place numbers into a vector directly using at(index) method
      vector<int> scores(5);
      
      scores.at(0) = 88;   // First slot contains 88
      scores.at(1) = 93;   // Second slot contains 93
      scores.at(2) = 68;   // etc...
      scores.at(3) = 50;
      scores.at(4) = 77;
      
    2. Warning: A run-time error occurs if accessing outside bounds of vector
      						// Empty vector
      						vector<int> scores(5);
      						
      						scores.at(5) = 88;   // Run-time error! Only indexes 0-4 are available
      						
    3. push_back(item) method adds an item to the end of the vector and increase its size
      vector<int> scores;
      
      scores.push_back(88);
      scores.push_back(93);
      scores.push_back(68);
      scores.push_back(50);
      scores.push_back(77);
      
    4. { } to initialize to with comma-delimited list
      // Empty vector
      vector<int> scores;
      
      // Vector now holds 5 integers
      scores = { 88, 93, 68, 50, 77 };
      
    5. Copy using =
      vector<int> scores = { 88, 93, 68, 50, 77 };
      
      // exams contains same 5 integers
      vector<int> exams = scores;
      
  4. Other helpful vector methods
    1. size() method return number of elements in the vector
      vector<int> scores = { 88, 93, 68, 50, 77 };
      cout << scores.size();  // 5
      
    2. front() method returns the first element
      // Equivalent
      firstNum = scores[0];
      firstNum = scores.front();
      
    3. back() method returns the last element
      // Equivalent
      lastNum = scores[scores.size() - 1];
      lastNum = scores.back();
      
    4. resize(newSize) method resizes the vector
      // Vector holds only 5 integers 
      vector<int> scores(5);
      
      // Now vector holds 10 integers 
      scores.resize(10);
      
    5. clear() method removes all elements from the vector
      vector<int> scores(5);
      cout << scores.size();   // 5
      scores.clear();
      cout << scores.size();   // 0
      
  5. Looping (iterating) through a vector
    1. Use size() as limit in for loop
      vector<int> scores = { 88, 93, 68, 50, 77 };
      
      // Displays: 88 93 68 50 77
      for (int i = 0; i < scores.size(); i++)
      	cout << scores[i] << " ";
      
    2. for-each loop useful when index number is not important
      // score is assigned each element in scores 
      for (int score : scores)
      	cout << score << " ";
      
    3. Warning: for-each loop makes a copy of each element unless using &
      // scores is unchanged because s is a copy!
      for (int s : scores)
      	s++;
      	
      // Pass-by-reference works
      for (int &s : scores)
      	s++;
      
  6. Passing vectors to functions
    1. Vectors follow pass-by-value and pass-by-reference rules of primitive data types
      // nums is passed by value (copy)
      int Sum(vector<int> nums)
      {
      	int sum = 0;
      	for (int n : nums)
      		sum += n;
      
      	return sum;
      }
      
    2. Passing a vector to a function
      vector<int> powersOfTwo = { 2, 4, 8, 16, 32 };
      int sum = Sum(powersOfTwo);   // 62
      
    3. Example of pass-by-reference
      // coinFlips is set to random true/false values
      void FlipCoins(vector<bool> &coinFlips)
      {
      	for (int i = 0; i < coinFlips.size(); i++)
      		coinFlips[i] = rand() % 2 == 0;
      }
      
    4. Passing a vector by value is computationally expensive, so programmers usually pass vectors by reference but right-protect with const
      // nums is passed by reference but write-protected
      int Sum(const vector<int> &nums)
      {
      	int sum = 0;
      	for (int n : nums)
      		sum += n;
      
      	return sum;
      }
      
    5. A function may return a vector
      // Returns a vector that contains the sum of vectors a and b
      vector<int> Sum(const vector<int> &a, const vector<int> &b) {
      	vector<int> sum(a.size());
      	for (int i = 0; i < a.size(); ++i)
      		sum[i] = a[i] + b[i];
      
      	return sum;
      }
      
      // Calling example
      vector<int> powersOfTwo = { 2, 4, 8, 16, 32 };
      
      // vectorSum contains: 4, 8, 16, 32, 64
      vector<int> vectorSum = Sum(powersOfTwo, powersOfTwo);