c++ - repetir - crear menús en línea de comando

crear menus en c

Question

¿Cómo se pueden crear menús en el programa de línea de comando? Probé cosas como estas:

cin >> input;
switch (input) {
  case (1):
    // do stuff
  case (2):
    // ...
}

pero luego tuve el problema de los submenús y volví al mismo menú, etc. El primer programa que escribí (aparte de los ejercicios) que intentó usar la idea de switch para los menús tenía declaraciones goto porque la alternativa era montones de (en el momento) bucles complicados.

Answer 1

Puede integrar submenús en su menú con su método:

cin >> input;
switch (input) {
  case (1): 
    cin >> input;
    switch (input) {
       case (1): //do stuff
       case (2): //do stuff
    }
    break;
  case (2):
    break;
}

Es esto lo que estás buscando? De lo contrario: ¿qué quieres resolver exactamente?

Editar: ¿Entonces lo que necesita es un bucle adicional en sus submenús con una condición de interrupción?

do{
    cin >> input;
    switch (input) {
      case (1): 
        do{
          cin >> input;
          switch (input) {
            case (1): //do stuff
            case (2): //do stuff
          }
        }while(input != 3);
        break;
      case (2):
        break;
    }
  }while(true);

Answer 2

Si traté de contar las formas en que se podría crear un menú de 1, 2, 3, los dos estaríamos muertos antes de iterar la mitad de ellos. Pero aquí hay un método que puede intentar para comenzar (no probado, es posible que necesite limpiar un par de cosas):

struct menu_item
{
  virtual ~menu_item() {}
  virtual std::string item_text() const = 0;
  virtual void go() = 0;
};

struct print_hello_item
{
  std::string item_text() const { return "display greeting"; }
  void go() { std::cout << "Hello there, Mr. User."; }
};

struct kill_everyone_item
{
  std::string item_text() const { return "Go on murderous rampage"; }
  void go() { for(;;) kill_the_world(); }
};

struct menu_menu_item
{
  menu_menu_item(std::string const& text) : text_(text), items() {}
  void add_item(std::unique_ptr<menu_item> item) { items.push_back(std::move(item)); }
  void go()
  {
    std::cout << "Choose: /n";
    std::for_each(items.begin(), items.end(), [](std::unique_ptr<menu_item> const& item)
    {
      std::cout << "/t" << item->item_text() << "/n";
    });
    std::cout << "/n/n/tYour choice: ";
    int choice = get_number_from_console();
    if (items.size() > choice) items[choice]->go();
  }
  std::string item_text() const { return text_; }

private:
  std::string text_;
  std::vector<std::unique_ptr<menu_item> > items;
};

int main()
{
  menu_menu_item top_item;
  top_item.add(std::unique_ptr<menu_item>(new print_hello_item));
  top_item.add(std::unique_ptr<menu_item>(new kill_everyone_item));

  top_item.go();
}

Como ejercicio, ¿cómo podría definir los elementos del menú de esta manera?

top_level.add()
  ( "Drive off a cliff", &die_function )
  ( "Destroy the world", &global_thermal_nuclear_war )
  ( "Deeper", submenu()
                ( "Hey, check this shit out!", &gawk ))
;

Se puede hacer con el marco anterior como punto de partida.

Esta es la diferencia entre el diseño OO y lo que podría llamarse "procedural". Creé una abstracción detrás de lo que significa ser una opción de menú (que puede ser otro menú) que se puede extender en varias direcciones. Creo las extensiones que necesito, las junté y digo lo que necesito. Un buen diseño de OO es así ... la parte principal de tu programa consiste en juntar cosas y decirles que se vayan.

La clave a tomar de esto no es necesariamente hacerlo de la manera que acabo de hacerlo, sino pensar en ello de una manera diferente. Si puede obtener la esencia del código anterior, verá que puede agregar nuevos elementos, con nuevos menús, a profundidades arbitrarias, sin tener que lidiar con el tipo de código excesivamente complicado que causa el estilo de cambio.

Answer 3

Acabo de hacer una pregunta similar en Libraries para mostrar un menú de modo de texto? - Parece que ncurses simplificará drásticamente las partes que muestran el menú.