if(a==b||c){...}

oder

if(a==(b||c){...}

oder

if(a==(b|c)){...}

vd im Voraus

if((a==b)||(a==c))

wollt ich nur versuchen zu kürzen.
Ist ja OK wenns nicht geht.
Wollts nur wissen...
Danke

würde nicht gehen, weil da noch was fehlt (Klammer). Alle drei Überprüfungen machen völlig unterschiedliche Sachen (über die du dich informieren solltest).
Abgesehen vom Weglassen der Klammer jeweils um a==b und a==c kannst du da nicht viel kürzen.

aha, ähmm...
was machts den so?

Nun, erst einmal holen wir uns eine Tabelle in der die Operatorproritäten stehen:
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence

Wir sehen, dass == vor || kommt. Das bedeutet, der Ausdruck a==b||c wird so ausgewertet: (a==b) || c. Der Rückgabewert von == ist entweder true oder false, je nachdem ob a gleich b oder nicht. Dieses Ergebnis wird dann mit dem Wert von c verodert. Damit das Funktioniert, wird c zuerst implizit in einen bool umgewandelt, das heißt wenn c gleich 0 war, wird es false und ansonsten true.

Der Ausdruck a==(b||c) ist durch die Klasmmerung anders: Hier werden zuerst b und c verodert. Gleiches vorgehen wie oben, das heißt das Ergebnis ist true, falls einer von den beiden ungleich 0 war und false, falls beide 0 waren. Dieses true/false Ergebnis wird dann mit a verglichen.

Und der letzte Ausdruck macht wiederum ganz etwas anderes. Das bitweise oder hat nicht viel mit dem logischen oder zu tun.

if((a==d)or(a==e)or(a==f))
schreiben?

P.S.: Ja, stimmt, ich mach nen haufen if bedingungen für Sudoku.

...
    if (check(a, b, c))
        //do smth.
...

inline bool check(int a, int b, int c)
{
    if ((a > 0 && a != b && a != c) || a+b <= 1)
        return true;
    else
        return false;
}

inline bool check(int a, int b, int c)
{
    if ((a > 0 && a != b && a != c) || a+b <= 1)
        return true;
    else
        return false;
}

Warum nicht

return a > 0 && a != b && a != c || a + b <= 1;

?

und wozu muss da inline rein ...?

Muss nicht. Das ist ein optionaler Hinweis für Compiler, der heutzutage aber mehr oder weniger ignoriert wird^*.

ist inline nicht für eine schnellere ausführung der funktion?

Möchtest du es denn nicht schnell haben?

^*: Inline hat noch eine andere Funktion, aber die spielt hier keine Rolle.

@Bashar: wie auch immer. Das war nicht der Kernpunkt meines Vorschlags.

Der Code ist aber unnötig umständlich, daher halte ich einen Hinweis durchaus für angebracht. An der Semantik ändert sich ja nichts, die ist auch nicht kritisiert worden.

Hacker schrieb:

und wozu muss da inline rein ...?

Ich würds weglassen, das brauchst du eigentlich nicht. Es sei denn, du willst Funktionen im Header definieren.

den Hinweis von Athar bzgl. Arrays solltest du Ernst nehmen, ansonsten programmierst du dir nämlich einen Wolf... (s. z.B. http://www.c-plusplus.net/forum/232907)

Wenn du nicht weißt, wie man bei Sudoku vernünftig Arrays einsetzt, dann such einfach mal in diesem Sub-Forum nach "Sudoku".

Der Code ist aber unnötig umständlich, daher halte ich einen Hinweis durchaus für angebracht.

Den Code kann doch unmöglich als unnötig umständlich bezeichnen. Für einen Unerfahrenen ist es dadurch sogar leichter/schneller zu erkennen, was der Code macht. Daher ist das in diesem konkreten Fall belanglos.

Du schreibst ja auch nicht

bool b = a > 0 && a != b && a != c || a + b <= 1;
if (b)
    return true;
else
    return false;

Warum sollte das also anders sein, wenn du b direkt einsetzt?

Das andere, was oft unnötig umständlich gelöst wird, ist if (b == true) . Aber so konsistent zu sein und if ((y > 3) == true) zu schreiben, tut merkwürdigerweise niemand.

Daher finde ich es wichtig, dass man gerade Anfängern zeigt, wie sie ihren Code vereinfachen können, ohne dass er weniger übersichtlich ist. Schlussendlich können sie immer noch selbst entscheiden, wie sie ihren Code formulieren, aber wenigstens kennen sie mehrere Möglichkeiten und nicht nur die umständliche.

template<typename Type> bool is_one_of(Type elem, Type first_comp_value, Type... other_comp_values);

template<typename Type> bool is_one_of(Type elem, Type last_comp_value)
{
    return elem == last_element;
}

template<typename Type> bool is_one_of(Type elem, Type first_comp_value, Type... other_comp_values)
{
    return (elem == first_comp_value) || is_one_of(elem, other_comp_values...);
}