Re: Dynamic menu
Francesco S. Carta <entuland@gmail.com>, on 09/07/2010 22:03:51, wrote:
cpp4ever <n2xssvv.g02gfr12930@ntlworld.com>, on 09/07/2010 20:48:16, wrote:
On 07/09/2010 12:54 PM, Francesco S. Carta wrote:
Hi there,
in it.comp.lang.c++ somebody asked for directions (for a tutorial,
actually) about creating a menu in C++, and I've answered mentioning
pointers to functions and creating a simple example that accepts only
pointers to void functions taking no parameters.
Then I've started fiddling with the idea and I've implemented a more
complex version that accepts pointers to functions that take parameters
too, allowing the client code to pass any kind of function - with a
single parameter but without type restrictions, as the "add_item()"
method is a template).
Here below I paste the complete code with an usage example, I wonder if
there is any simpler way of achieving the same purposes, maybe without
using inheritance.
Any other suggestion or correction about my coding style will be
welcome, I completely avoided to add comments because the code should be
self-explaining even if a bit convoluted.
Thanks for your attention.
<snip old code>
IMHO I think use of inheritance is better than using callback functions.
Each derived menuitem type then has it's own private properties that in
turn can be accessed by descendant classes via protected functions. This
provides far greater flexibility IMHO, and
is easier to implement and understand.
I'm not so sure I understand your point: if I want to allow the client
code to pass functions pointers when creating the menu, so that the menu
can call those functions afterwards, I'm creating callbacks anyway,
regardless of whether I use inheritance or not - or am I
misunderstanding the meaning of "callback"?
I think I'll be able to create the menu I'm aiming to by using a single
class along with function<> and bind(), and I suspect that design will
be more concise and easier to maintain... I'll post the new code after
the dinner - it's 22:00 here, late dinner today :-)
And a long long dinner it was... yawn... all right.
Yes, decisively simpler and cleaner, thanks to Leigh's advice - just one
class and no need for any additional template.
Still susceptible of big improvements, but here it is:
//-------
#include <iostream>
#include <vector>
#include <tr1/functional>
class Menu {
public:
Menu(std::string command = "",
std::string caption = "",
Menu* parent = 0,
std::tr1::function<void()> callback = 0);
void operator()() const;
class Error {
public:
Error(std::string message = "") : message(message) {}
std::string what() const {
return message;
}
private:
std::string message;
};
static std::istream* input;
static std::ostream* output;
private:
std::string command;
std::string caption;
Menu* parent;
std::tr1::function<void()> callback;
std::vector<Menu*> children;
Menu(const Menu&);
Menu& operator=(const Menu&);
};
std::istream* Menu::input = 0;
std::ostream* Menu::output = 0;
Menu::Menu(std::string command,
std::string caption,
Menu* parent,
std::tr1::function<void()> callback)
: command(command),
caption(caption),
parent(parent),
callback(callback) {
if(parent) {
if (!parent->callback) {
for (size_t i = 0; i < parent->children.size(); ++i) {
if(command == parent->children[i]->command) {
throw Error("!!! Duplicated command");
}
}
parent->children.push_back(this);
} else {
throw Error("!!! Parent item is not a container");
}
}
}
void Menu::operator()() const {
using std::endl;
std::ostream& out = output ? *output : std::cout;
std::istream& in = input ? *input : std::cin;
if (callback) {
callback();
return;
}
if (parent) {
parent->operator()();
return;
}
const Menu* m = this;
for (;;) {
out << endl << "-------" << endl;
out << "exit - Exit menu" << endl;
if(m->parent) {
out << "up - Upper menu" << endl;
}
for (size_t i = 0; i < m->children.size(); ++i) {
out << m->children[i]->command << " - ";
out << m->children[i]->caption << endl;
}
out << "Insert command:" << endl;
out << ">";
std::string line;
getline(in, line);
if(line == "up" && m->parent) {
m = m->parent;
continue;
} else if (line == "exit") {
break;
} else {
bool found = false;
for (size_t i = 0; i < m->children.size(); ++i) {
if(line == m->children[i]->command) {
found = true;
if(m->children[i]->callback) {
out << endl;
m->children[i]->callback();
} else {
m = m->children[i];
}
break;
}
}
if(found) continue;
out << endl;
out << "Unrecognized command" << endl;
}
}
}
using namespace std;
using namespace tr1;
void save() {
cout << "Saved" << endl;
}
void discard() {
cout << "Discarded" << endl;
}
void increase(int* i) {
if(i) {
++*i;
cout << "i increased" << endl;
}
}
void decrease(int* i) {
if(i) {
--*i;
cout << "i decreased" << endl;
}
}
void print(int* i) {
if(i) {
cout << "i == " << *i << endl;
}
}
int main() {
Menu menu;
Menu file("f", "File", &menu);
Menu edit("e", "Edit", &menu);
new Menu("s", "Save", &file, save);
new Menu("d", "Discard", &file, discard);
int i = 40;
Menu inc("i", "Increase i", &edit, bind(increase, &i));
new Menu("d", "Decrease i", &edit, bind(decrease, &i));
Menu pri("p", "Print i", &edit, bind(print, &i));
pri();
inc();
inc();
pri();
file();
}
//-------
--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com