Can't Break From User Input Early Based On Character?

Question

I have a question that has evolved from one of my previous (Conditionally Breaking A Long Sequence Of Inputs?), but so far, no one has been able to give me a satisfactory answer, and all my efforts have failed.

I am trying to allow the user to break early from entering input if they don't need to. i.e., for the code below:

cout << '\n' << "Monster A's name is: ";
cin >> nameA;
cout << '\n' << "Monster A rolled: ";
cin >> rollM_A;
cout << '\n' << "Monster A's Dex is: ";
cin >> DexA;
cout << '\n' << "Monster A's Mod is: ";
cin >> ModA;
cout << '\n' << "Monster A's Level is: ";
cin >> LvlA;

//etc.

Up to 12 monsters are actually supported. If the user wants to use only, say, 3-4 of them, I'd like them to be able to skip the rest and save themselves a lot of keystrokes. I've already made sure to initialize all the variables to 0, and have a function to remove 0 elements from the storage vector later. All that's missing is getting away from this input chain. I have tried various forms of a while loop wrapping, like this:

while(cin.get() != '#') {
   cout << '\n' << "Monster A's name is: ";
   cin >> nameA;
   //etc...
}

But upon entering the desired character, the code simply outputs all the prompts ("Monster A's name is:" , etc.) over and over again, without moving on or accepting further input. It's like the code is stuck in an infinite loop, even though it should be leaving the loop on # input.

Any ideas? Been really stuck on this for a while and would be very grateful if anyone could offer an alternate solution, or at least let me know the flaw in my own.

Thanks!

Answer 1

Your piece of code provoke an infinite loop because std::cin's operator >> does not take the "End of line" character (the enter key), so it's still in the stream.

So when you arrive to the cin.get() the second time, there is still a character in the buffer (enter from when you validated the name of the monster). cin.get() takes it, see that it is not '#', and go to the next std::cin, which do the same. You can fix this behavior by ignoring a char :

while(cin.get() != '#')
{
   cout << '\n' << "Monster A's name is: ";
   cin >> nameA;
   //etc...
   cin.ignore();
}

Answer 2

I just tested this set of code and it seems to work how you would like. Of course you will have to modify it to fit your original application.

std::string in;

while (true) {
    std::cout << "Enter a name\n";
    std::cin >> in;
    if (in == "#")
        break;
    std::cout << "\nMonster A's name is: " << in << "\n";
}

In order to incorporate the limit of the number of monsters, rather than having the true parameter passed into the while loop, simply add a counter to how many monsters are created and break on that condition:

int num_monsters = 0;
while (num_monsters <= 12) {
    ...
    num_monsters++;
}

Hope this helps.

Answer 3

Object-orientation and the stdlib to the rescue:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Monster {
  string name;
  int rolled, dex, mod, level;

  template<class input, class output, class container>
    friend input& read_monster(input& i, output& o, container &c) {
      string n;
      o << "\nMonster's name is: " << flush;
      i >> n;
      if( !i || (n == "#") ) {
        o << "\nEnd of monster list";
        i.setstate(ios::failbit);
        return i;
      }
      Monster m;
      m.name = n;
      o << "\nMonster's rolled is " << flush;
      i >> m.rolled;
      if( !i ) return i;
      o << "\nMonster's dex is " << flush;
      i >> m.dex;
      if( !i ) return i;
      o << "\nMonster's mod is " << flush;
      i >> m.mod;
      if( !i ) return i;
      o << "\nMonster's level is " << flush;
      i >> m.level;
      if( !i ) return i;
      o << "\n";
      c.push_back(m);
      return i;
    }

  template<class output>
    friend output& operator<<(output& o, Monster&m) {
      return o << "Monster('" << m.name <<"', R/" << m.rolled
        << ", D/" << m.dex << ", M/" << m.mod << ", L/" << m.level
        << ")\n";
    }

  Monster() : name(), rolled(), dex(), mod(), level() {}
};

int main(int, char**) {
  vector<Monster> v;
  while( read_monster(cin, cout, v) && (v.size() <= 12) )
    ;

  for( auto m: v )
    cout << m;
  return 0;
}

Answer 4

Since you're doing line oriented input, you really should be using std::getline to read. And since the line oriented input consists of blocks of lines, each defining an object, you should create a class, and read it. (And in addition, you'll need a lot more error handling, since you need to handle errors in any of the intermediate lines.)

Obviously, each of these concerns should be separated into a separate function:

std::string
getLineFromPrompt( std::string const& prompt )
{
    std::string results;
    std::cout << prompt;
    std::getline( std::cin, results );
    return results;
}

template <typename T>
bool
tryGetValueFromPrompt( std::string const& prompt, T& value )
{
    std::string line = getLineFromPrompt( prompt );
    std::istringstream parser( line );
    return parser >> value >> std::ws && parser.get() == EOF;
}

template <typename T>
void
getValueFromPrompt( std::string const& prompt, T& value )
{
    while ( ! tryGetValueFromPrompt( prompt, value ) ) {
        std::cout << "Illegal input, try again" << std::endl;
    }
}

class Monster
{
    std::string name;
    int roll;
    int dexterity;
    int mod;
    int level;
public:
    Monster( std::string const& name )
        : name( name )
    {
        getValueFromPromt( name + " rolled:", roll );
        getValueFromPromt( name + " dexterity:", dexterity );
        getValueFromPromt( name + " mod:", mod );
        getValueFromPromt( name + " level:", level );
    }
};

bool
isEndFlag( std::string const& line )
{
    return line.empty() || line[0] == '#';
}

And finally, the loop:

std::vector <Monster> monsters;
std::string nextName = getLineFromPrompt();
while ( ! isEndFlag( nextName ) ) {
    monsters.push_back( Monster( nextName ) );
    nextName = getLineFromPrompt();
}

As you can see, factoring out each individual concern into a separate function results in far simpler code.

Answer 5

Can you cout the info, e.g. 'press # to skip this question'? Instead of let user guess which key to skip the question?