Thread: Menu (any default style ? )

You should clear the error flags on std::cin after a failed read (e.g., the user entered letters instead of an integer) and ignore what remains on the buffer otherwise you risk an infinite loop.

Do you prefer using enum or not ?

I think they are fine for what you want to do.

As an alternative, you could try implementing the menu via callback functions. You could create a menu item class that stores the description of the menu item and a function pointer to the function that you want to call if the user selects that option. A menu class could then store a list of menu items and perhaps a heading for the menu. The menu class could have a member function that displays the menu (in a loop, automatically numbering the menu items), handles user input, and then runs the callback function of the selected menu item.

Once you have written these two classes, creating a menu would just involve creating a menu object and adding menu item objects to it. The tradeoff is that this is more initial work in implementing these two classes and you have to create a callback function for each menu option (but for a reasonably complex option, you would write a function for that anyway). On the other hand, you can just create menu objects in those functions so as to have sub-menus.

Clearing input when failed:
http://faq.cprogramming.com/cgi-bin/...&id=1043284392

I've never written C++ classes to support menus, but it shouldn't be hard to do. Perhaps something like this:

Code:

#include <iostream>
#include <string>


class menucontext {
public:
  bool fquit;
  menucontext() : fquit(false) { };
  ~menucontext() {};
};

typedef void (*menufunc)(menucontext &ctxt);


class menuitem {
private:
  std::string   descr;
  char          choice;
  menufunc      func;
public:
  menuitem(const std::string &s, char c, menufunc f): 
    descr(s), choice(c), func(f) 
  {
  };
  ~menuitem() {
  };
  void print() { 
    std::cout << choice << ": " << descr << std::endl;
  };
  void domenu(menucontext &ctxt) {
    func(ctxt);
  };
  bool isChoice(char c) {
    return (c == choice);
  }
};

   

class menu {
private:
  struct menunode {
    menunode *next;
    menuitem *item;
  };
  menunode *head;
  menunode *tail;
public:
  menu() : head(0), tail(0) {
  }
  ~menu() {
    menunode *p, *q;
    for(p = head; p; p = q) {
      q = p->next;
      delete p->item;
      delete p;
    }
  };
  void addmenu(std::string s, char c, menufunc f) {
    menunode *node = new menunode;
    node->item = new menuitem(s, c, f);
    node->next = 0;
    if (!head)
      head = tail = node;
    else {
      tail->next = node;
      tail = node;
    }
  };
  void choose(menucontext &ctxt) {
    char c;
    menunode *p;
    bool choosen = false;
    for(p = head; p; p = p->next) {
      p->item->print();
    }
    do {
      std::cin >> c;
      for(p = head; p; p = p->next) {
	if (p->item->isChoice(c)) {
	  p->item->domenu(ctxt);
	  choosen = true;
	}
      }
      if (!choosen)
	std::cout << "That wasn't a valid choice" << std::endl;
    } while(!choosen);
  };
};


void first(menucontext &ctxt)
{
  std::cout << "In first" << std::endl;
}

void quit(menucontext &ctxt)
{
  std::cout << "Quitting..." << std::endl;
  ctxt.fquit = true;
}


int main() {
  menu m;

  menucontext ctxt;
  m.addmenu("First menu", '1', first);
  m.addmenu("QUit",       'q', quit);

  while(!ctxt.fquit)
    m.choose(ctxt);
  return 0;
}

[That got a lot longer than I expected.]

--
Mats

By the way, I guess it's a good idea to use some STL to make the list of menuitems, e.g. a list or vector.

Code:

#include <list>
...
class menuitem {
private:
  std::string   descr;
  char          choice;
  menufunc      func;
public:
  menuitem(const std::string &s, char c, menufunc f): 
    descr(s), choice(c), func(f) 
  {
  };
  ~menuitem() {
  };
  void print() const { 
    std::cout << choice << ": " << descr << std::endl;
  };
  void domenu(menucontext &ctxt) const {
    func(ctxt);
  };
  bool isChoice(char c) const {
    return (c == choice);
  }
};

   

class menu {
private:
  std::list<menuitem> menuitems;
public:
  menu() {
  }
  ~menu() {
     menuitems.clear();
  };
  void addmenu(std::string s, char c, menufunc f) {
    menuitems.push_back(menuitem(s, c, f));
  };
  void choose(menucontext &ctxt) {
    char c;
    std::list<menuitem>::const_iterator i;
    bool choosen = false;
    for(i = menuitems.begin(); i != menuitems.end(); i++) {
      i->print();
    }
    do {
      std::cin >> c;
      for(i = menuitems.begin(); i != menuitems.end(); i++) {
	if (i->isChoice(c)) {
	  i->domenu(ctxt);
	  choosen = true;
	}
      }
      if (!choosen)
	std::cout << "That wasn't a valid choice" << std::endl;
    } while(!choosen);
  };
};

The above is the changed code, marked in red.

--
Mats

This line is the one that does the actual "eating of any garbage in the inptut".

Code:

while ((ch = cin.get()) != '\n' && ch != EOF);

The purpose is mainly to avoid a whole stream of "invalid input" when you've entered "jkdfhukadshfjghawerihfj" because the cat decided to walk on the keyboard (or my 8m old daughter decided "to help daddy do typing"). When using numeric input (as you do when you read an enum), the input could get into a "stuck" state, in which case you also want to use cout.clear() to clear the error flag that has been set.

And yes, it's a good idea to check for EOF - if you don't, things will sooner or later go into an infinite loop when reading something.

--
Mats

When you see that someone made the wrong choice, just insert that line I posted two posts ago - that will read anything "still waiting to be processed" up to the "enter".

--
Mats

You haven't declared the variable ch.
You probably don't want to pass choice to cin.ignore();

The "reselect" variable in main is never used.

--
Mats

This block of code:

Code:

cout << "Please select :";
cin >> choice;
cin.ignore(choice);
while (choice > Quit || choice < Wake) 
{
    while ((choice = cin.get()) != '\n' && ch != EOF);
    cout << "You wrong! ";
    cout << "Retype: ";
    cin >> choice;
}

Should be:

Code:

cout << "Please select :";
while (!(cin >> choice) || choice > Quit || choice < Wake)
{
    cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
    cout << "You wrong! Retype: ";
}

While the read fails, or if the input is out of range, you inform the user of an error and request for more input. The cin.clear() clears the error flags after a failed read. The cin.ignore() removes remaining characters on the buffer up to and including the new line character. As far as I know, you do not need to worry about EOF here since the user has to press enter to enter input, thus placing a new line on the input buffer. The numeric_limits<streamsize>::max() returns the maximum size of a stream, but you need to #include <limits> to use it.