Re: problem with nested switches
In article <jgbq5sn82t.fsf@micah.cowan.name>, micah@hollister.bcsweb.com
says...
[ ... ]
AFAICT, the reason switch statements are rarer in C++ than in C is
that most in most of the use cases for it in C, polymorphic typing is
the better idiom in C++. However, for cases such as selecting on a
character value read on input (like this one), it seems like the most
straightforward approach, and I at least would find it more readable
than the equivalent in if/else-if.
There is also the fact that unlike C, C++ has things like std::map built
in, so you could do a job like this using code something like:
#include <iostream>
#include <map>
#include <string>
int i_add(int x, int y) { return x+y; }
int i_sub(int x, int y) { return x-y; }
int i_mul(int x, int y) { return x*y; }
int i_div(int x, int y) { return x/y; }
int main() {
int x, y;
std::string o;
typedef int (*op)(int, int);
std::map<std::string, op> ops;
ops["+"] = i_add;
ops["-"] = i_sub;
ops["*"] = i_mul;
ops["/"] = i_div;
std::cin >> x >> o >> y;
std::cout << "The result is: " << ops[o](x,y);
return 0;
}
Of course, this isn't anything like production code -- it's clearly
lacking in error checking and such, but you get the idea; the switch
statement is gone, and the code is (at least arguably) somewhat more
cleanly extensible.
In this case, you can do the job pretty easily without std::map though.
It's basically a sparse array type, but in the case of type char, you
can normally use a dense array without a major problem:
#include <iostream>
#include <map>
#include <limits.h>
int i_add(int x, int y) { return x+y; }
int i_sub(int x, int y) { return x-y; }
int i_mul(int x, int y) { return x*y; }
int i_div(int x, int y) { return x/y; }
int bad(int, int) { std::cout << "Error: Wrong input\n"; return 0; }
int main() {
int x, y;
char o;
typedef int (*op)(int, int);
op ops[CHAR_MAX];
for (int i=0; i<CHAR_MAX; i++)
ops[i] = bad;
ops['+'] = i_add;
ops['-'] = i_sub;
ops['*'] = i_mul;
ops['/'] = i_div;
std::cin >> x >> o >> y;
std::cout << "The result is: " << ops[o](x,y);
return 0;
}
In theory#include <iostream>
#include <map>
#include <limits.h>
int i_add(int x, int y) { return x+y; }
int i_sub(int x, int y) { return x-y; }
int i_mul(int x, int y) { return x*y; }
int i_div(int x, int y) { return x/y; }
int bad(int, int) { std::cout << "Error: Wrong input\n"; return 0; }
int main() {
int x, y;
char o;
typedef int (*op)(int, int);
op ops[CHAR_MAX];
for (int i=0; i<CHAR_MAX; i++)
ops[i] = bad;
ops['+'] = i_add;
ops['-'] = i_sub;
ops['*'] = i_mul;
ops['/'] = i_div;
std::cin >> x >> o >> y;
std::cout << "The result is: " << ops[o](x,y);
return 0;
}
Of course, if you happen to have a 64-bit char, this could be a bit of a
problem...
--
Later,
Jerry.
The universe is a figment of its own imagination.