How do I stop ..eof from reading the last line of input twice?

[aceadams]

#include <iostream>
#include <queue>
using namespace std;
int main () {
    int n, num, cust;
    char type;
    cin>>n;
    queue <int> q;
    vector <int> desk[10];
    while (!cin.eof()) {
        cin>>type>>num;
        if (type=='C')
        q.push(num);
        else if (type=='D'){
            int cust=q.front();
            q.pop();
            desk[num].push_back(cust);
        }
    }
    for (int i=1; i<=n; i++) {
        for (int j=0; j<desk[i].size(); j++) {
            cout<<desk[i][j]<<" ";
        }
        cout<<endl;
    }
}

[JLBorges]

Check for input failure after (not before) attempted input.

Canonical:

#include <iostream>

int main()
{
    int num ;
    char type ;

    while( std::cin >> type >> num ) {

        std::cout << "type: " << type << "   number: " << num << '\n' ;

        // do whatever with type and num
    }
}

[Albatross]

Protip: as of C++11, you can loop on stream extraction operations, like so:

while(cin >> something) {
    //Code in here only runs if the read in the condition of the loop succeeded.
}

This prevents mistakes wherein someone reads stuff from std::cin but doesn't check whether the read operation succeeded or not, and proceeds through their code using the data that was in their buffer variables from the last run of the loop.

-Albatross

P.S:

cppreference wrote:

[eof()] only reports the stream state as set by the most recent I/O operation; it does not examine the associated data source. For example, if the most recent I/O was a get() which returned the last byte of a file, eof() returns false.

[dutch]

as of C++11, you can loop on stream extraction operations, like so

Couldn't you do that pre C++11 too?

[Albatross]

My mistake, you definitely could (though the way they went around making that possible was a bit strange).

-Albatross

[JLBorges]

> though the way they went around making that possible was a bit strange

Jerry Schwarz did not have much of a choice.

Prior to C++11, the language did not support explicit specifiers for conversion functions;
and the design goal was that a typo like std::cin << x should be caught at compile time.
Voila! operator void*() const;

[mbozzi]

The safe-bool idiom (that is, operator void* in this context) also protects against a number of other mistakes arising from unwanted implicit conversions:
https://www.artima.com/cppsource/safebool.html

[Albatross]

No, I get its purpose, but it still feels like the sort of thing that they could have made unnecessary when C++98 was being put together.

All well, I guess C++98 was, among other things, the language that required us to put spaces between the closing brackets of template argument lists.

-Albatross