tl;dr: Gibt es in C++ ein logisches UND ohne Kurzschluss (ähnlich wie &&)?

Ich habe 2 Funktionen, die ich aufrufen möchte, und verwende die Rückgabewerte, um den Rückgabewert einer dritten zusammengesetzten Funktion herauszufinden. Das Problem ist, dass ich immer möchte, dass beide Funktionen ausgewertet werden (da sie Protokollinformationen über den Zustand des Systems ausgeben).

IE:

bool Func1(int x, int y){
  if( x > y){
    cout << "ERROR- X > Y" << endl;
  }
}
bool Func2(int z, int q){
  if( q * 3 < z){
    cout << "ERROR- Q < Z/3" << endl;
  }
}
bool Func3(int x, int y, int z, int q){
  return ( Func1(x, y) && Func2(z, q) );
}

Natürlich sind die Bedingungen in den Funktionen nicht ganz so einfach, und ja, mir ist klar, dass ich temporäre Variablen verwenden könnte, um die Rückgaben der beiden Funktionen zu speichern und dann die „Kurzschluss“ -Logik für die temporären Variablen auszuführen, aber Ich habe mich gefragt, ob es eine “elegante” Sprachlösung gibt, um die einzeilige Rückgabe in Func3 beizubehalten und gleichzeitig die Protokollmeldungen von beiden Funktionen zu erhalten.

Zusammenfassung der Antworten:

Die “bitweisen” Operatoren | und & können verwendet werden, um den Effekt zu erzielen, aber nur, wenn der Rückgabetyp bool ist. Ich habe keine Erwähnung davon in der ANSI C++-Spezifikation gefunden. Soweit ich das beurteilen kann, funktioniert dies, weil das “Bool” in ein Int (true = 1, False = 0) konvertiert wird und dann der bitweise Operator verwendet wird, dann wird es wieder in ein Bool konvertiert.

Die Operatoren“+” und “*” kann auch verwendet werden. Dies wird in der ANSI C++ Spezifikation nicht erwähnt, funktioniert aber wahrscheinlich aus dem gleichen Grund wie oben. “+” Geben Sie “oder” an, weil wahr in 1 umgewandelt wird und dann alles andere als 0 wieder in wahr umgewandelt wird. “*” funktioniert für “und”, weil 1 (wahr) * 0 (falsch) == 0 (falsch) und 1 (wahr) * 1 (wahr) == 1 (wahr)

Beide scheinen sich auf eine implizite Typkonvertierung in Integer und dann zurück in Bool zu verlassen. Beides wird wahrscheinlich jeden durcheinander bringen, der versucht, den Code zu warten.

Andere Antworten reduzieren sich auf “Nur Provisorien verwenden” oder “Eigene implementieren”, was nicht die Frage war. Das Ziel war zu sehen, ob es dafür bereits einen im C++-Standard implementierten Operator gibt.

Das & Operator führt eine logische “und”-Operation für aus bool Operanden und ist nicht kurzgeschlossen.

Es ist kein Sequenzpunkt. Auf die Reihenfolge der Auswertung der Operanden können Sie sich nicht verlassen. Es ist jedoch sichergestellt, dass beide Operanden ausgewertet werden.

Ich tue nicht empfehlen, dies zu tun. Die Verwendung temporärer Variablen ist eine bessere Lösung. Opfern Sie die Lesbarkeit nicht für “cleveren Code”.

und ja, mir ist klar, dass ich temporäre Variablen verwenden könnte, um die Rückgaben der beiden Funktionen zu speichern und dann die “Kurzschluss” -Logik für die temporären Variablen auszuführen, aber ich habe mich gefragt, ob es eine “elegante” Sprachlösung gibt, um das beizubehalten Einzeilige Rückgabe in Func3, während weiterhin die Protokollmeldungen von beiden Funktionen abgerufen werden.

Das wäre die “elegante” Lösung :). Unter Berufung auf die Nebenwirkungen der Bewertungsreihenfolge wäre alles andere als elegant, fehleranfällig und für den nächsten Entwickler, der in Ihr Projekt eindringt, schwer verständlich. Unter Berufung auf die Nebenwirkungen steht natürlich im Gegensatz zu etwas wie dem folgenden Ausschnitt, der ein völlig logischer und gültiger Anwendungsfall dafür ist, sich allein auf die Auswertungsreihenfolge zu verlassen:

if ( obj != NULL && obj->foo == blah ) { /* do stuff */ }

Ja, dafür gibt es eingebaute Operatoren.
+ macht ein nicht kurzschließendes ODER und * macht ein UND.

☺

#include <iostream>
using namespace std;

void print(bool b)
{
    cout << boolalpha << b << endl;
}

int main() 
{
    print(true + false);
    print(true * false);
}

Ausgabe:

Stimmt

FALSCH

Sie können trivialerweise Ihre eigenen schreiben.

bool LongCircuitAnd( bool term1, bool term2 ) { return term1 && term2; }

bool Func3(int x, int y, int z, int q){
  return LongCircuitAnd( Func1(x,y), Func2(z,q) ); 

Und wenn Sie sehr schick sein wollen, können Sie es sogar inline machen !!!

Okay, Okay, wenn Sie den schrecklichen Mehraufwand für den Aufruf einer Funktion wirklich wirklich vermeiden wollen.

bool Func3(int x, int y, int z, int q){
  return ((int)Func1(x,y)) * ((int)Func2(z,q)); 

Aber elegant finde ich das nicht. Es ist denkbar, dass ein allzu intelligenter Compiler dies kurzschließen könnte …

Wenn Sie die temporären Variablen verwenden möchten, aber die Rückkehr zu einer einzelnen Anweisung beibehalten möchten, können Sie den Kommaoperator verwenden:

return (b1=Func1()), (b2=Func2()), (b1&&b2);

Der Kommaoperator erzwingt einen Sequenzpunkt, sodass jeder seinen linken Operanden auswertet, das Ergebnis verwirft und dann seinen rechten Operanden auswertet.

Eine andere Möglichkeit, von der ich eher abraten würde, wäre, dass die beiden Funktionen einen Typ zurückgeben, der den ‘&&’-Operator überlädt. Da ein überladener Operator eine Funktion aufruft, wird sie immer ausgewertet beide Operanden, selbst in Fällen (wie &&), in denen der eingebaute Operator dies nicht tut – normalerweise ist das ein Problem, aber in diesem Fall ist es genau das, was Sie wollen:

class mybool { 
    bool value;
public:
    bool operator&&(mybool const &other) const { 
        return value && other.value;
    }
};

mybool Func1(int, int);
mybool Func2(int, int);

bool Func3(int x, int y, int z, int q) { 
    return Func1(x, y) && Func2(z,q);
}

Obwohl das funktioniert, scheint es mir ein bisschen zu “clever” zu sein – etwas, das für die meisten Leser überhaupt nicht offensichtlich wäre. Ein anderer Name für mybool könnte helfen, aber spontan fällt mir keine ein, die die Absicht sehr gut widerspiegelt, ohne so ausführlich zu werden, dass es ein Nettoverlust wäre.

Ja. Die überladenen Versionen von operator&& und operator|| nicht kurzschließen — sie werten beide Operanden aus, auch wenn der linke Operand das Ergebnis “bestimmt”… (Quelle)

Davon abgesehen, nicht überladen operator&& oder operator||. Seien Sie nett zu Ihren Wartungsprogrammierern, die sich das ansehen werden && oder || und nehmen an, dass sie einen Kurzschluss machen.

Eine nahezu universelle, aber oft nicht dokumentierte Nicht-Standard-Operator wurde eingeführt genau zu diesem Zweck, nebenbei von GCC entwickelt x ?: y (x wenn nicht Null, sonst y), und das jetzt leider entfernt >? und <? Min/Max-Operatoren und ihre zusammengesetzten Zuweisungsformen (vgl http://gcc.gnu.org/onlinedocs/gcc/Deprecated-Features.html). Leider mit & und && bereits in Gebrauch, scheinen sie den Boden des Fasses abgekratzt zu haben, um eine geeignete Zeichenfolge zu finden, aber das ist nur meine Meinung – würde historische Erklärungen dafür begrüßen, warum dies gewählt worden sein könnte.

Obwohl es derzeit nicht so bekannt ist wie viele andere Betreiber, das >! Operator (richtig, aber langweilig “Long-Circuit and” genannt, aber umgangssprachlich “größerer Knoten” von Kennern) wurde von den meisten C- und C++-Compilern (einschließlich GCC und sogar MSVC++) hinzugefügt, um diese Anforderung zu erfüllen:

bool f1() { ... }
bool f2() { ... }

...
bool f3() { return f1() >! f2(); }

Probieren Sie es aus ;-).