how compare a char?

[Cambalinho]

when i do:
IsOperator(strinput[uintStringIndex+1])=='='
why i get these warning:
"comparison of constant ''='' with boolean expression is always false [-Wbool-compare]"
???

[Ganado]

IsOperator, I assume, returns a bool. This can only be true (1), or false (0). '=' is a char, which evaluates to some positive number greater than 1 (in this case, 61).

0 or 1 can never equal 61, so the expression will always be false!

I think you're making this more complicated than necessary. Why not just do,
if (strinput[index+1] == '=') { /* logic... */ }
or
bool isEqualsSign = (strinput[index+1] == '=');

BTW, make sure not to go out of bounds of your string, those +1's can be dangerous.

[Cambalinho]

is much more than sign.
and yes i have changed the function from boolean to char:

char IsOperator(char chr)
{
    if(chr=='=')
        return chr;
    else if(chr=='\\')
        return chr;
    else if(chr=='/')
        return chr;
    else if(chr=='*')
        return chr;
    else if(chr=='+')
        return chr;
    else if(chr=='-')
        return chr;
    else if(chr=='^')
        return chr;
    else if(chr=='[')
        return chr;
    else if(chr==']')
        return chr;
    else if(chr=='{')
        return chr;
    else if(chr=='}')
        return chr;
    else if(chr=='>')
        return chr;
    else if(chr=='<')
        return chr;
    else if(chr=='(')
        return chr;
    else if(chr==')')
        return chr;
    else if(chr=='.')
        return chr;
    else if(chr==',')
        return chr;
    else if(chr==';')
        return chr;
    return 0;
}

zero means false, now i have the control.
thank you so much for all

[Ganado]

That's a really misleading function name, just so you know... usually IsFoo() functions return bools.

Btw, here's a way to simplify a bool IsOperator function (if returning a bool, not char).

// Example program
#include <iostream>
#include <string>
#include <algorithm>

bool IsOperator(char ch)
{
    std::string operators = "=\\/*+-^[]{}<>().,;";
    auto is_operator = [ch](char known_operator){return ch == known_operator;};
    return std::any_of(operators.begin(), operators.end(), is_operator);
}

int main()
{
    if (IsOperator('=')) { std::cout << "= is an operator" << std::endl; }
}

[Cambalinho]

is these case, do you have a better name?

[Ganado]

Well, I'm not sure. I would rework whatever it is you're doing. I don't understand what you're trying to accomplish with such a function, regardless of the name. See edit of a better bool IsOperator, btw.

The way you're using IsOperator seems redundant, I don't see why you don't just do
(strinput[i] == '=').

[Cambalinho]

thank you so much... i don't know too much about strings

[helios]

Ganado: That IsOperator() is terrible.

bool IsOperator(char ch){
    static const char operators[] = "=\\/*+-^[]{}<>().,;";
    static const auto n = sizeof(operators) - 1;
    static const auto beg = operators;
    static const auto end = operators + n;

    return std::find(beg, end, ch) != end;
}

[Cambalinho]

thank you so much.. now it's more easy to understand

[Ganado]

Noted.

Edit: However, I wouldn't say "terrible". std::find is still linear complexity. Sure, my example allocates the string each call, I agree that could be made static. I also agree that "std::find" makes more sense from an English-language point of view than "any_of", but I don't see this as a huge deal. If we really wanted to pre-optimize this, I'd go with binary_search, http://www.cplusplus.com/reference/algorithm/binary_search/ and hardcode the char array as sorted.

[helios]

I just wanted to get rid of the allocation, but if we're really going to optimize, why stop at O(log n)?

class Operators{
    static const auto min = std::numeric_limits<char>::min();
    static const auto max = std::numeric_limits<char>::max();
    static const auto n = max - min + 1;
    
    std::vector<bool> data;
    
    static unsigned to_index(char c){
        return (unsigned)((int)c - (int)min);
    }
public:
    Operators(): data(n, false){
        static_assert(n <= 65536, "Whoa! What kind of chars you got there?");
        
        static const char ops[] = "=\\/*+-^[]{}<>().,;";
        for (auto i = ops; *i; i++)
            data[to_index(*i)] = true;
    }
    Operators(const Operators &) = delete;
    Operators(Operators &&) = delete;
    const Operators &operator=(const Operators &) = delete;
    Operators &&operator=(Operators &&) = delete;
    
    bool operator()(char c) const{
        return data[to_index(c)];
    }
};

Operators IsOperator;

[Ganado]

Brilliant :)