C++ Primer 5th Edition exercise 3.24 - iterators in vectors

Question

I just started learning C++ by myself using Lippman, Lajoie & Moo's C++ Primer Fifth Edition (5th printing, may 2014) in september 2014. Some exercises in that book I could do, some I had to look here for help and at this one I'm stuck for days. I searched Google, blogs and other forums and got nothing, so I ask you for help. It is the exercise 3.24 at page 113, which asks the same as the exercise 3.20 in page 105, but using iterators:

Read a set of integers into a vector. Print the sum of each pair of adjacent elements. Change your program so that it prints the sum of the first and last elements, followed by the sum of the second and second-to-last, and so on.

Using iterators as it asked, I could do the first part:

#include <iostream>
#include <vector>

using std::cin; using std::cout; using std::endl; using std::vector;

int main()
{
   vector<int> lista;
   int num_entra = 0;

   while (cin >> num_entra)
       lista.push_back(num_entra);


   cout << "Sum of adjacent pairs: " << endl;
   for (auto it = lista.begin(); it != lista.end() - 1; ++it)
   {
       *it += *(it + 1);
       cout << *it << ' ';
   }

   return 0;
}

The code above works as intended, but the part where I need to sum the first and last, second and second to last... etc. has an issue I just can't solve:

int main()
{
   vector<int> lista;
   int num_entra = 0;

   while (cin >> num_entra)
       lista.push_back(num_entra);


   auto ult = lista.end();

   cout << "Sum of the first and last elements until the center: " << endl;
   for (auto it = lista.begin(); it != lista.end() - 1; ++it)
   {
       *it = *it + *(--ult);
       cout << *it << ' ';
   }

   return 0;
}

If the user enters 1 2 3 4 5 6, the program adds 1 + 6, 2 + 5 and 3 + 4 as it should,
but then it adds the last result (7) with 5 and then with 6 and I can't seem to find a way to stop this behavior. What can I do so the program shows only one sum for each pair until the center of the list? Thank you in advance.

Answer 1

One way to do this would be to use two iterators

auto front = lista.begin();  // start at front and increment
auto back = lista.end() - 1; // start at back and decrement
for (;
     back > front;     // stop when the iterators cross each other
     ++front, --back)
{
    int total = *front + *back;
    std::cout << total << ' ';
}

Answer 2

My five cents. Only instead of the explicitly initialized vector you should enter values for it as you did.

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> v = { 1, 2, 3, 4, 5 };

    if ( !v.empty() )
    {
        auto first = v.cbegin(), last = v.cend();
        do
        {
            std::cout << *first + *--last;
        } while ( first++ != last );
    }

    return 0;
}

The output is

666

This approach you also can use for example with std::list

If you need to skip the middle odd element then the general approach for containers that have no random access iterator is the following

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> v = { 1, 2, 3, 4, 5 };

    for ( auto first = v.cbegin(), last = v.cend(); 
          first != last && first != --last;
          ++first )
    {
        std::cout << *first + *last;
    }

    std::cout << std::endl;

    return 0;
}

As vectors have random acces iterators then the code can be rewritten using operator <

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> v = { 1, 2, 3, 4, 5 };

    if ( !v.empty() )
    {
        for ( auto first = v.cbegin(), last = v.cend(); 
              first < --last;
              ++first )
        {
            std::cout << *first + *last;
        }

        std::cout << std::endl;
    }
    return 0;
}       

In both cases the output will be

66

Answer 3

The problem with your code is that you're modifying the vector as you compute the sums by dereferencing the iterator (might not be a problem but it's a likely unwanted side effect) and you're not even stopping the cycle when you've "surpassed" the middle of the vector.

A simple version could be

auto front = lista.begin();
auto back = lista.end() - 1;
for (; back > front; ++front, --back)
{
    int total = *front + *back;
    std::cout << total << ' ';
}

but this doesn't handle an odd number of elements like 1 2 3 4 5 6 7 (the central 4 isn't printed). If you don't want any "same element" couple, this is fine and this solution will handle every case you need, otherwise go ahead.

A fixed version could be

auto front = lista.begin();
auto back = lista.end() - 1;
for (; back >= front; ++front, --back)
{
    if (front == back)
        cout << *front;
    else {
        int total = *front + *back;
        std::cout << total << ' ';
    }
}

but this doesn't handle a null list [].

This solution handles both although it's more complex:

auto it = lista.begin();
    auto ult = lista.rbegin();
    size_t dist;
    for ( ; it != lista.end() && // I have a valid front iterator
            ult != lista.rend() && // I have a valid back iterator
            (dist = std::distance(it,ult.base()), dist) > 0; // Their distance is greater than 0 (1 is included)
    ++it,++ult ) {
        if (dist == 1)
            cout << *it;
        else
            cout << *it + *ult << ' ';
    }

Answer 4

In addition to incrementing one iterator while decrementing another, I think the best way is to use a reverse iterator.

auto it = list.begin();
auto rit = list.rbegin(); // a "reverse iterator"
while (it < rit.base()) {
  cout << *it++ + *rit++ << ' ';
}

Using a reverse iterator means you don't have to worry about any "off-by-one" adjustments due to the asymmetry between begin and end.

Answer 5

Here is also one approach where mid is an iterator closest to the middle of the array, which is also commonly used in binary search implementation:

  auto e = lista.end() - 1;
  auto mid = lista.end() + (lista.begin() - lista.end()) / 2;
  for (auto i = lista.begin(); i != mid; ++i, --e){
    cout << *i << "+" << *e << " = " << (*i)+(*e) << endl;
  }

Input: 1 2 3 4 5 6 7 8 9;

Positions/index: 0 1 2 3 4 5 6 7 8 9

Where mid = (0 - 10) / 2 => -5 + 10 => 5 The loop stops after reading number five.

And at index 5 is number 6. Therefore the loop stops when it hits the iterator closest to the middle:

i != mid;

 /*Output*/
 1+9 = 10
 2+8 = 10
 3+7 = 10
 4+6 = 10
 5+5 = 10

PS. I recommend you do checks to see if the vector is empty.