Menu sa za určitej okolnosti spustí dva krát – C / C++ – Fórum – Programujte.com

Dobrý deň. Celé menu funguje v poriadku, aj všetky defaultne prípady switchov. Keď zadám hociakú možnosť z menu a potom zadám 4 navrátenie sa späť do hlavého menu, všetko je v poriadku. No keď zadám potom v hlavnom menu iné ako 1,2,3, povedzme 51, namiesto toho aby sa spustil defaultný prípad, spustí sa hlavné menu znova. (Teda presne sa spustí aj defaultný prípad, po ktorom by mal normálne program skončiť, ale spustí sa hlavné menu znova, kde už defaultný prípad funguje)

Ak by stále niekto nerozumel, hneď po spustení programu zadaj nejaké vyššie číslo napríklad 12. Spustí sa defaultný prípad a program sa ukončí. Spusti ho znova, teraz zadaj postupne napríklad 2,4,12  <-- Mal by sa znova spustiť defaultný prípad a ukončiť, ale spustí sa defaultný prípad a hlavné menu znovu. Ak teraz zadám vyššie číslo, už sa korektne spustí defualtný prípad pre iné čísla ako v menu a program sa ukončí.

Klarifikácia: Som začiatočník v C++ a toto menu je iba testovacie, preto sú tam také sprosté odpovede.

https://gist.github.com/TheTask/be4aca796f2e5ac9cb63

Když funkce skončí, tak program pokračuje v místě, odkud jsi tu funkci volal.

Proč v Menu1/2/3 voláš main a Menu? Prostě se z těch funkcí vracej zpátky. A to načítání odpovědi mezi casy switche je nesmysl.

#2 z
Každá z možností v hlavnom mene má svoje podmenu a možnosť vrátiť sa naspäť do hlavného menu. Každé podmenu po zvolení čísla napíše odpoveď a vráti sa naspäť do hlavného menu, tak som to naprogramoval, to je v poriadku, problém som opísal vyššie.

mimochodem menu je podle me naprosto dokonaly pripad pro pouziti objektu a hlavne polymorfizmu...

+ samozrejme nejaky std::bind nebo boost::bind

#3 Task1337
Jasně. Tak si to nakresli.

>>> Start main
    >>> Start MoznostiMenu
        Hlavne menu. Vyber moznost:
        1) Som blbec
        2) Som prasivec
        3) Som krysa
        4) Ukoncit program
    <<< Konec MoznostiMenu
2
    >>> Start Menu
        >>> Start Moznosti2
            Vybral si si cestu prasivu. Ale ako moc?
            1) Ako cukor
            2) Ako povala stareho domu
            3) Ako pust
            4) Navrat do Hlavneho menu
4
        <<< Konec Moznosti2
        >>> Start Menu2
            >>> Start main
                >>> Start MoznostiMenu
                    Hlavne menu. Vyber moznost:
                    1) Som blbec
                    2) Som prasivec
                    3) Som krysa
                    4) Ukoncit program
                <<< Konec MoznostiMenu
12
                Zadal si somarinu, teraz trp!
20
            <<< Konec main
        <<< Konec Menu2
        >>> Start MoznostiMenu
            Hlavne menu. Vyber moznost:
            1) Som blbec
            2) Som prasivec
            3) Som krysa
            4) Ukoncit program
        <<< Konec MoznostiMenu
    <<< Konec Menu
    Zadal si somarinu, teraz trp!
20
<<< Konec main

#5 z
Aha áno, máš pravdu, ďakujem za nakreslenie. Ja som si myslel, že keď zavolám main() znovu, tak sa spustí program odznova, teda z hlavného menu, ale podľa tvojho náčrtu sa spustí main() vnútri main(), to som nevedel. Aké by si navrhol riešenie?

Poriadne som si prešiel tvoj kod, skompiloval a urobil jemné úpravy, ale tá myšlienka je omnoho lepšia ako moja, ďakujem.

 Ja si treba menu predstavuju trosku vic objektove:

#include <iostream>
#include <functional>
#include <string>
#include <map>
#include <memory>

using std::bind;

using std::string;
using std::map;
using std::unique_ptr;


class MenuBase {
  public:
    MenuBase(string name, string choice) : m_name(name), m_choice(choice) {
      std::cout << "setting: " << m_name << " for choice: " << m_choice << std::endl;
    }
    virtual           ~MenuBase() { std::cout << "Exterminate!! "; show(); }
    virtual bool        execute(); // exec action
    virtual void           show(); // show menu

  public:
    string                 m_name;
    string               m_choice;
};


class MenuItem : public MenuBase {
  public:
    typedef std::function<bool ()>  Action;  //  bool action(void);

    virtual bool        execute(); // exec action

    MenuItem(string name, string choice, Action act) : MenuBase(name,choice), m_action(act) {;}
    virtual           ~MenuItem() {;}

  protected:
    Action               m_action;
};


class Menu : public MenuBase {
  public:

    Menu(string name, string choice, std::initializer_list<MenuBase *> list) : MenuBase(name, choice) {
      for (MenuBase * x : list) m_items.insert(make_pair(x->m_choice, unique_ptr<MenuBase>(x)));
    }

    virtual               ~Menu() {;}

    virtual bool        execute(); // exec action

  protected:
    map<string, unique_ptr<MenuBase>> m_items;
};



bool akce(int m, int n, bool opakovat) {
  std::cout << "provadim akci "<< m << "/" << n << "\n";
  return opakovat;
}


int main() {
  unique_ptr<MenuBase> menu { new Menu("Hlavni menu", "-", {
      new MenuItem("Akce 1", "1", bind(akce,0,0,true)),
      new MenuItem("Akce 2", "2", bind(akce,0,1,true)),
      new MenuItem("Akce 3", "3", bind(akce,0,2,true)),
      new MenuItem("Konec", "5", bind(akce,0,5,false)),
      new Menu("Submenu 1","4", {
          new MenuItem("Podakce 1", "1", bind(akce,1,0,true)),
          new MenuItem("Podakce 2", "2", bind(akce,1,1,true)),
          new MenuItem("Podakce 3", "3", bind(akce,1,2,false)) // podakce 3 a navrat do predchoziho menu
          })
      })
  };
  menu->execute();
}


bool MenuBase::execute() {
  return false;
}

bool MenuItem::execute() {
  return m_action();
}

bool Menu::execute() {
  bool cont = true;
  while (cont) {
    std::cout << "\n\nMenu: " << m_name << "\n";
    for (auto & item : m_items) {
      item.second->show();
    }

    std::cout << "Zadejte volbu: ";
    string in;
    std::cin >> in;

    auto item = m_items.find(in);
    if (item != m_items.end()) {
      std::cout << "Nalezeno, spoustim\n";
      cont = (*item).second->execute();
    }
  }
  return true;
}

void MenuBase::show() {
  std::cout << m_choice << ") " << m_name << "\n";
}

S tímhle kdyby na mě někdo vybafl, když jsem začínal, tak se na programování vykašlu ;-)

#10 z
tak je to jen ukazka :D ani sem nedal menu do vlastniho souboru :D

Aj keď tomu kodu od KIIV nerozumiem, motivuje ma to zlepšovať sa aby to bola hračka o pár rokov pre mňa to urobiť tak. Ďakujem vám za vaš čas a nápady, páni!

Zasláno z mobilního telefonu.

Takto sa strasia zaciatocnici  :

#include <iostream>
#include <functional>
#include <string>
#include <map>
#include <memory>
#include <tuple>

template <class Key, class Value>
struct MenuItemBase{
	const Key key;
	Value value;
	
	
	template <class Ostream>
	friend Ostream& operator<<(Ostream& out, const MenuItemBase& x){
		return out << x.key << ") " << x.value << std::endl;
	} 

	virtual bool operator()()=0;
	
	template <class K, class V>MenuItemBase(K&& key, V&& value)
	:key(std::forward<K>(key)), value(std::forward<K>(value)){}
};

template <class Key, class Value, class Action>
struct MenuItem final : MenuItemBase<Key, Value> {
	private:
		using base = MenuItemBase<Key, Value>;
		Action action;
	
	public:
		template <class K, class V>MenuItem(K&& key, V&& value, Action action = Action())
		:base(std::forward<K>(key), std::forward<K>(value)), action(action){}
		
		bool operator()()override{return action();};
	
};


template <int N, class Key, class Value, class... Items>
struct MenuItemGet;
	
template <class Key, class Value, class... Items>
struct Menu final : MenuItemBase<Key, Value>{
	
	template <int N, class K, class V, class... Is>
	friend class MenuItemGet;
	
	protected:
		using base = MenuItemBase<Key, Value>;
		std::tuple<Items...> items;
		std::map<Key, base*> map;
		
		void reg_items(){MenuItemGet<static_cast<int>(sizeof...(Items))-1, Key, Value, Items...>::reg(*this);}
		
	public:
		template <class K, class V, class... Is>Menu(K&& key, V&& value, Is&&... items)
		:base(std::forward<K>(key), std::forward<V>(value)), items(std::forward<Is>(items)...){}
		
		Menu(Menu&& menu)
		:base(std::move(menu.key), std::move(menu.value)), items(std::move(menu.items)){}
		
		bool operator()()override{
		  bool cont = true;
		  while (cont) {
			std::cout << "\n\nMenu: " << base::key << "\n";
			MenuItemGet<static_cast<int>(sizeof...(Items))-1, Key, Value, Items...>::show(std::cout, *this);

			std::cout << "Zadejte volbu: ";
			Key in;
			std::cin >> in;

			if(map.size() != sizeof...(Items))reg_items();
			auto item = map.find(in);
			if (item != map.end()) {
			  std::cout << "Nalezeno, spoustim\n";
			  cont = item->second->operator()();
			}
		  }
		  return true;	
		}
};

template <int N, class Key, class Value, class... Items>
struct MenuItemGet{
	static void reg(Menu<Key, Value, Items...>& menu){
		menu.map[std::get<N>(menu.items).key] = &std::get<N>(menu.items); //menu.reg_item<N>();
		MenuItemGet<N-1, Key, Value, Items...>::reg(menu);
	}
	
	static void reg(MenuItemBase<Key, Value>& item){}
	
	template<class Ostream>
	static void show(Ostream& out, Menu<Key, Value, Items...>& menu){
		out << std::get<sizeof...(Items) - N - 1>(menu.items);
		MenuItemGet<N-1, Key, Value, Items...>::show(out, menu);
	}
	
};

template <class Key, class Value, class... Items>
struct MenuItemGet<-1, Key, Value, Items...>{
	static void reg(Menu<Key, Value, Items...>& menu){}
	static void reg(MenuItemBase<Key, Value>& item){}
	template<class Ostream>
	static void show(Ostream& out, Menu<Key, Value, Items...>& menu){}
	
};


template <class Key, class Value, class... Items>
decltype(auto) make_menu(Key&& key, Value&& value, Items&&... items){
	return Menu<Key, Value, Items...>{std::forward<Key>(key), std::forward<Value>(value), std::forward<Items>(items)...};
}


template <class Key, class Value, class Action>
decltype(auto) make_item(Key&& key, Value&& value, Action action){
	return MenuItem<Key, Value, Action>{std::forward<Key>(key), std::forward<Value>(value), action};
}

bool akce(int m, int n, bool opakovat) {
  std::cout << "provadim akci "<< m << "/" << n << "\n";
  return opakovat;
}


int main(){
	using std::bind;
	using std::string;

	auto menu = make_menu<string, string>("Hlavni menu", "-", 
		make_item<string, string>("1", "Akce 1", bind(akce,0,0,true)),
		make_item<string, string>("2", "Akce 2", bind(akce,0,1,true)),
		make_item<string, string>("3", "Akce 3", bind(akce,0,2,true)),
		make_menu<string, string>("4", "Submenu 1",
			make_item<string, string>("1", "Podakce 1", bind(akce,1,0,true)),
			make_item<string, string>("2", "Podakce 2", bind(akce,1,1,true)),
			make_item<string, string>("3", "Podakce 3", bind(akce,1,2,false)) // podakce 3 a navrat do predchoziho menu
		),
		make_item<string, string>("5", "Konec", bind(akce,0,5,false))
	);

	menu();
	return 0;
	
}

Ja vás mám tak rád :) Už sa teším ako sa to naučím tak ako vy.

Zasláno z mobilního telefonu.

#13 vitamin
nice one :))

Dam sem este upravenu verziu ktora ide skompilovat s c++11 kompilatorom (decltype(auto) vyzaduje c++14). Kod som aj trochu upravyl a dosiahol som zaujimavu vlastnost, cely kod nevyuiva ziadnu dynamicku alokaciu  . S variadic templatmi sa daju robit divy, skoda ze je ten kod tak hnusny.

#include <iostream>
#include <memory>
#include <tuple>
#include <algorithm>
#include <array>

template <class Key>
struct MenuItemBaseKey{
	const Key key;
	using key_t = Key;

	template <class K>MenuItemBaseKey(K&& key)
	:key(std::forward<K>(key)){}

	virtual bool operator()(){}
};

template <class Key, class Value>
struct MenuItemBase : MenuItemBaseKey<Key>{
	Value value;

	template <class Ostream> friend Ostream& operator<<(Ostream& out, const MenuItemBase& x){
		return out << x.key << ") " << x.value << std::endl;
	}

	template <class K, class V>MenuItemBase(K&& key, V&& value)
	:MenuItemBaseKey<Key>(std::forward<K>(key)), value(std::forward<V>(value)){}

	bool operator()()override = 0;
};

template <class Key, class Value, class Action>
struct MenuItem final : MenuItemBase<Key, Value> {
	private:
		using base = MenuItemBase<Key, Value>;
		Action action;

	public:
		template <class K, class V>MenuItem(K&& key, V&& value, Action action = Action())
		:base(std::forward<K>(key), std::forward<V>(value)), action(action){}

		bool operator()()override{return action();};
};


template <int N, class Key, class Value, class... Items>
struct MenuItemGet;

template <class Key, class Value, class I, class... Items>
struct Menu: MenuItemBase<Key, Value>{
	template <int N, class K, class V, class... Is>
	friend class MenuItemGet;

	protected:
		using base = MenuItemBase<Key, Value>;
		using item_key_t = typename I::key_t;

		std::tuple<I, Items...> items;
		std::array<MenuItemBaseKey<item_key_t>*, sizeof...(Items)+1> order;
		bool inicialized = false;

        static bool item_cmp(const MenuItemBaseKey<item_key_t>* a, const MenuItemBaseKey<item_key_t>* b){return a->key < b->key;}

		void reg_items(){
		    MenuItemGet<static_cast<int>(sizeof...(Items)), Key, Value, I, Items...>::reg(*this);
		    std::sort(std::begin(order), std::end(order),item_cmp);
            inicialized = true;
        }

        template <class K>
        MenuItemBaseKey<item_key_t>* find(K&& in){
			if(!inicialized)reg_items();

            MenuItemBaseKey<item_key_t> key{std::forward<K>(in)};
			auto item = std::lower_bound(std::begin(order), std::end(order), &key, item_cmp);
			return (item != std::end(order))?(*item):(nullptr);
        }


	public:
		template <class K, class V, class... Is>Menu(K&& key, V&& value, Is&&... items)
		:base(std::forward<K>(key), std::forward<V>(value)), items(std::forward<Is>(items)...){}

		Menu(Menu&& menu)
		:base(std::move(menu.key), std::move(menu.value)), items(std::move(menu.items)){}

		bool operator()()override{
		    bool cont = true;
            while(cont){
                std::cout << "\n\nMenu: " << base::key << "\n";
                MenuItemGet<sizeof...(Items), Key, Value, I, Items...>::show(std::cout, *this);

                std::cout << "Zadejte volbu: ";
                item_key_t in;
                std::cin >> in;

                if(auto* item = find(in)){
                    std::cout << "Nalezeno, spoustim\n";
                    cont = item->operator()();
                    std::cout << cont << '\n';
                }
            }

            return true;
        }
};

template <int N, class Key, class Value, class... Items>
struct MenuItemGet{
	static void reg(Menu<Key, Value, Items...>& menu){
		menu.order[N] = &std::get<N>(menu.items);
		MenuItemGet<N-1, Key, Value, Items...>::reg(menu);
	}

	template<class Ostream>
	static void show(Ostream& out, Menu<Key, Value, Items...>& menu){
		out << std::get<sizeof...(Items) - N - 1>(menu.items);
		MenuItemGet<N-1, Key, Value, Items...>::show(out, menu);
	}
};

template <class Key, class Value, class... Items>
struct MenuItemGet<-1, Key, Value, Items...>{
	static void reg(Menu<Key, Value, Items...>& menu){}
	template<class Ostream>
	static void show(Ostream& out, Menu<Key, Value, Items...>& menu){}

};

template <class Key, class Value, class... Items>
auto make_menu(Key&& key, Value&& value, Items&&... items)->Menu<Key, Value, Items...>{
	return {std::forward<Key>(key), std::forward<Value>(value), std::forward<Items>(items)...};
}

template <class Key, class Value, class Action>
auto make_item(Key&& key, Value&& value, Action action)->MenuItem<Key, Value, Action>{
	return {std::forward<Key>(key), std::forward<Value>(value), action};
}

template <int m, int n, bool opakovat>
bool akce(){
  std::cout << "provadim akci "<< m << "/" << n << "\n";
  return opakovat;
}

int main(){
	auto menu = make_menu("-", "Hlavni menu",
		make_item(1, "Akce 1", akce<0,1,true>),
		make_item(2, "Akce 2", akce<0,2,true>),
		make_item(3, "Akce 3", akce<0,3,true>),
		make_menu(4, "Submenu 1",
			make_item<long>(1, "Podakce 1", akce<1,1,true>),
			make_item<long>(2, "Podakce 2", akce<1,2,true>),
			make_item<long>(3, "Podakce 3", akce<1,3,false>) // podakce 3 a navrat do predchoziho menu
		),
		make_item(5, "Konec", akce<0,5,false>)
	);

	menu();
	return EXIT_SUCCESS;
}

#16 vitamin
jj .. vznikne ti z toho jeden obrovskej datovej typ presne podle specifikace :)

ja sem napriklad ani nevyuzil placeholderu v bindu, aby se to dalo vyuzit i nejak zajimaveji :)

(no minimalne v implementaci stavovy masiny se to hodi, tady to holt bylo zbytecny zavadet neco jako kontext :D)

Dali ste si súťaž, kto to urobí zložitejšie? Ja som začiatočník :D

Zasláno z mobilního telefonu.

#18 Task1337
ja to delal co nejtrivialnejsi :D  kdyz bys to menu dal do samostatneho souboru, tak ti tam zustane jeden include toho menu a celej main.. + fukce, ktere bys chtel volat...

a vitamin uz predvedl hard core skill se sablonama .. ve kterejch se sice vyznam, ale dohromady bych to asi tak rychle nedal (pokud vubec :D)

Ja som nerozumel skoro ničomu :D Len by ma zaujímalo, prečo nepoužíva namespace std ale všade píše std::cout, std::cin apod. Má to nejaké výhody?

Zasláno z mobilního telefonu.

#20 Task1337
namespace je tam hlavne od toho, aby nekolidovaly stejny nazvy... napriklad z nejakeho duvodu si udelas vlastni promennou  cin nebo cout  a kdyz budes mit using namespace std; tak se to mezi sebou pomlati

dejme tomu ze ve vlastnim programu se to pouzit da, ale jak delas libku, tak hlavne v hlavickovejch souborech takovyhle veci zasadne delat nesmis, protoze pak to zpristupnis i vsude, kde je to includovane a muze to vest k nepredvidatelnym chybam

Aha, ďakujem.

Zasláno z mobilního telefonu.

A hlavne ked vidis std::  tak hned vies ze to je nieco zo standartu a tam vecsinou nemusis hladat bugy a hned vies kde treba hladat dokumentaciu.