erreur: commutateur de la quantité et non un entier

Que les autres et le compilateur a commenté, les chaînes ne sont pas autorisées avec switch. Je voudrais juste utiliser if

bool Calculator::is_legal_command() const {
    if(command == TAN) return true;
    if(command == SIN) return true;
    if(command == COS) return true;
    if(command == LOG) return true;
    if(command == LOG10) return true;
    return false;
}

Je ne pense pas que c'est plus compliqué, et c'est à peu près aussi vite qu'il pouvait obtenir. Vous pouvez également utiliser mon commutateur macro, pour la faire ressembler

bool Calculator::is_legal_command() const {
    sswitch(command)
    {
    scase (TAN):
    scase (SIN):
    scase (COS):
    scase (LOG):
    scase (LOG10):
        return true;

    sdefault():
        return false;
    }
}

(ayant break après un return est du code mort, et devrait donc être évité).

Plutôt que d'un interrupteur.

Je voudrais utiliser un modèle de commande. Puis d'utiliser un std::map de la carte le nom de la fonction de l'objet de commande.

Quelque chose comme ceci:

#include <math.h>
#include <map>
#include <string>
#include <iostream>
class Function
{
public:
//Easy public API that just uses the normal function call symantics
double   operator()(double value)   { return this->doWork(value);}
virtual ~Function()     {}
private:
//Virtual function where the work is done.
virtual double doWork(double value) = 0;
};
//A sin/cos function
class Sin: public Function      { virtual double doWork(double value)     { return sin(value); } };
class Cos: public Function      { virtual double doWork(double value)     { return cos(value); } };
//A class that holds all the functions.
//A function name is mapped to a function object.
class FuncMap
{
public:
FuncMap()
{
//Constructor sets up the map
functions["sin"]    = &sinFunc;
functions["cos"]    = &cosFunc;
}
Function*   getFunction(std::string command) const
{ 
//Default result not found.
Function* result    = NULL;
std::map<std::string, Function*>::const_iterator    find;
//Look in the map to see if we find the value.
//If it exists then find will not point at end()
if ((find = functions.find(command)) != functions.end())
{
//Get the pointer to the function
result  = find->second;
}
return result;
}
private:
Sin     sinFunc;
Cos     cosFunc;
std::map<std::string, Function*>    functions;
};
//Declaring it globally for ease of use.
FuncMap     functions;
int main()
{
//SImple example of usage.
Function*   func    = functions.getFunction("sin");
if (func == NULL)
{
std::cout << "No Function sin()\n";
exit(1);
}
std::cout << "Result: " << (*func)(12.34) << "\n";
}

L'erreur du compilateur vous dit tout ce que vous devez savoir. Seulement partie intégrante types peuvent être comparés dans les instructions switch.

Je ne suis pas sûr de la "mighty internet" vous dit le contraire, mais il était puissant mal.