Question

I have two questions but they are interlinked.:

part:a->

I have been trying to display the elements of vector in reverse order. But nothing is working. I have used iterotar like;

for (it=vec.end(); it!=vec.begin(); --it){ 
// it is iterator not reverse_iterator.
// do work
}

P.S I am not much familiar with iterators. I have used them for the first time today to
display elem in reverse order.

also tried;

for (int i=vec.size(); i!=0; i--){
//display
}

No matter what I do it always display the elem in same order as they are present i.e not in the reverse order.

part_b->

Is there any way that I can store the output of a recursive function direct into a vector. like the code is:
I know this does not work. I have tried but just giving you an idea
what I am upto.

#include <iostream>
using namespace std;
#include "vector"

int func(int num);
vector <int> vec;

int main() {
    int num=34;
    // I know this would not work. But is there any possibilitiy that
    // I can store the output in a vector.
    vec = binary(num);                          

    // trying to display the vector.        
    for (int i=vec.size();i!=0;i--) {
        cout<<vec[i]<<" ";
    } // not working for reverse display.
} //main.

int func(int num) {
    if (num==1) {
        //vec.push_back(1);
        return 1;
    }
    else if(num==0) {
        //vec.push_back(0);
        return 0;
    }
    else {
        //vec.push_back(input%2);
        return binary(input/2);
    }
} //func.

I hope you do unnderstand the question. if I am able to do the part b the there is no need to reverse the elem of the vector.

Answer 1

The standard solution uses reverse iterators:

for (auto it = v.rbegin(); it != v.rend(); ++it)
{
    if (it != v.rbegin()) { std::cout << ' '; }
    std::cout << *it;
}

Alternatively, you can use indices, but keep the “reversal” idiom and increment the index:

for (std::size_t i = 0; i != v.size(); ++i)
{
    if (i != 0) { std::cout << ' '; }
    std::cout << v[v.size() - i - 1];
}

Note that reverse iterators are literally just doing something very similar to the explicit loop under the hood. In particular, the base() member function of a reverse iterator gives you the corresponding ordinary iterator offset by one, just as we have a - 1 in the index computation. (E.g. rbegin() is just end() under the hood, but decrements by one upon dereferencing.)