У меня есть класс Menu<T>, варианты которого являются элементами типа T, и он может иметь подменю типа Menu<T> (без ограничения глубины вложенных подменю).Структура данных с вариационными шаблонами
template <typename T>
class Menu {
private:
class Option {
const std::string name;
const T item;
Menu<T>* submenu;
Option* next = nullptr;
friend class Menu<T>;
Option (const std::string& itemName, const T& t, Menu<T>* menu = nullptr) : name(itemName), item(t), submenu(menu) {}
~Option() {if (submenu) delete submenu;}
inline T choose() const;
inline void print (int n) const;
};
Option* first = nullptr; // first option in the menu
Menu<T>* parent = nullptr;
Option* parentOption = nullptr;
enum ChoosingType {Normal, Remove};
public:
Menu() = default;
Menu (const Menu<T>&);
Menu& operator = (const Menu<T>&);
~Menu();
inline void insert (const std::string& itemName, const T& t, Menu<T>* submenu = nullptr, int pos = END_OF_MENU);
T choose() const {return chosenItem().first;}
inline int print() const;
private:
inline std::pair<T, int> chosenItem (ChoosingType = Normal) const;
inline Option* deepCopy (const Option*);
};
И я проверил, что он работает правильно, но мой Menu<T> класс выше не поддерживает вложенные меню, элементы которого имеют другой тип, чем T. Эта дополнительная функция будет очень удобно, если, скажем, в главном меню имел Action как тип для своих опций, а затем один из вариантов - «Извлечь оружие», чье подменю в идеале должно было бы иметь Weapon в качестве его параметров, но, как сейчас, подменю снова должно иметь Action, поскольку его варианты.
Моя попытка обобщить с
template <typename T, typename U, typename... Rest>
class Menu { // Menu with T as its option types.
private:
class Option {
const std::string name;
const T item;
Menu<U, Rest...>* submenu; // Submenu with U as its option types.
Option* next = nullptr;
friend class Menu<T, U, Rest...>;
Option (const std::string& itemName, const T& t, Menu<U, Rest...>* menu = nullptr) : name(itemName), item(t), submenu(menu) {}
~Option() {if (submenu) delete submenu;}
inline T choose() const;
inline void print (int n) const;
};
Option* first = nullptr;
// ....
}
int main() {
Menu<int, std::string> menu; // Will not compile.
}
не является правильным, потому что Menu<int, std::string> menu; чего я пытаюсь создать простое меню ИНТ опций с подменю опций строки, даже не компилируется, поскольку тогда подменю типа Menu<std::string>, который не соответствует шаблону класса. Это также не имеет смысла, потому что Menu<int, std::string> должен возвращать int из своей функции choose(), но в свое подменю будет возвращена строка. boost :: variant нужен здесь?
Мне просто нужно указать, с чего начать. Я знаю, что это может показаться частью CodeReview, но там они хотят изучить мой код только в том случае, если он уже работает, но здесь моя попытка обобщить сейчас не работает (еще не началась), поэтому мне нужно обратиться к экспертов здесь, только с чего начать.
Обновление: По предложению gmbeard, я получил это работает со следующим упрощенным кодом (классы реального меню будут связаны список опций, которые пользователь выберет из через вход). Но есть недостатки.
#include <iostream>
#include <string>
struct Visitor {
virtual void visit (int&) = 0;
virtual void visit (std::string&) = 0;
virtual void visit (char& c) = 0;
};
struct ChooseVisitor : Visitor {
std::pair<int, bool> chosenInt;
std::pair<std::string, bool> chosenString;
std::pair<char, bool> chosenCharacter;
virtual void visit (int& num) override {
chosenInt.first = num;
chosenInt.second = true;
}
virtual void visit (std::string& str) override {
chosenString.first = str;
chosenString.second = true;
}
virtual void visit (char& c) override {
chosenCharacter.first = c;
chosenCharacter.second = true;
}
};
template <typename...> struct Menu;
template <typename T>
struct Menu<T> {
struct Option {
T item;
void accept (ChooseVisitor& visitor) {visitor.visit(item);}
};
Option* option; // Assume only one option for simplicity here.
ChooseVisitor choose() const {
ChooseVisitor visitor;
option->accept(visitor);
return visitor;
}
void insert (const T& t) {option = new Option{t};}
};
// A specialization for the Menu instances that will have submenus.
template <typename T, typename... Rest>
struct Menu<T, Rest...> { // Menu with T as its options type.
struct Option {
T item;
Menu<Rest...>* submenu; // Submenu with the first type in Rest... as its options type.
void accept (ChooseVisitor& visitor) {visitor.visit(item);}
};
Option* option;
ChooseVisitor choose() const {
// In reality there will be user input, of course. The user might not choose to enter a submenu,
// but instead choose from among the options in the current menu.
ChooseVisitor visitor;
if (option->submenu)
return option->submenu->choose();
else
option->accept(visitor);
return visitor;
}
void insert (const T& t, Menu<Rest...>* submenu = nullptr) {option = new Option{t, submenu};}
};
int main() {
Menu<int, std::string, char> menu;
Menu<std::string, char> submenu;
Menu<char> subsubmenu;
subsubmenu.insert('t');
submenu.insert ("", &subsubmenu);
menu.insert (0, &submenu);
const ChooseVisitor visitor = menu.choose();
if (visitor.chosenInt.second)
std::cout << "You chose " << visitor.chosenInt.first << ".\n"; // Do whatever with it.
else if (visitor.chosenString.second)
std::cout << "You chose " << visitor.chosenString.first << ".\n"; // Do whatever with it.
else if (visitor.chosenCharacter.second)
std::cout << "You chose " << visitor.chosenCharacter.first << ".\n"; // Do whatever with it.
}
Выход:
You chose t.
Самая большая проблема заключается в том, что ChooseVisitor необходимо постоянно обновляется для всех типов параметров возможно меню (это может закончиться буквально сотни элементов данных и перегрузками), а не упоминайте ужасные if-checks, чтобы получить желаемый возвращенный предмет. Но выбранный элемент нужно хранить, а не просто использовать на короткий срок. Я приветствую идеи для улучшения.
вы должны рассмотреть возможность использования наследования и имеющим базовый класс для '' меню, например, 'BaseMenu', того submenues может быть указатели на этот базовый класс ... –
Nim
ли вы рекомендуете использовать подталкивание :: любого для тип возвращаемого значения для функции select()? – prestokeys
Зачем вам нужно иметь подменю разного типа, в то время как элементы главного меню должны быть одного типа? На самом деле это странный набор ограничений. – Yakk