ich lerne gerade Visual C++ (bringe ich mir selber bei). Um das zu erlernen verändere ich den vorgegebenen Code gern.

Mein Problem ist nun folgendes:

Der normale Code lautet:

if Bedingung1 || Bedingung2 TuWas;

Bedeutet ja wenn eine der beiden Bedingungen wahr ist wird TuWas gemacht. In einem speziellen Fall sind leider beide WAHR, daher sollte TuWas NICHT ausgeführt werden.

Nun meine Frage:

Gibt es eine Möglichkeit && und/oder || umzukehren?
Sollte dann statt 'und' bzw. 'oder' heißen: 'und nicht' bzw. 'oder nicht'!

Es wäre schön, wenn jemand da Rat wüßte

Danke
ein Neuling

if(bed1 || !bed2) tu_was;//ist erfüllt, wenn bed1 wahr oder bed2 NICHT wahr ist
if(bed1 ^ bed2) tu_was; //ist erfüllt, wenn genau eine Bedingungen bed1 oder bed2 wahr ist, aber nicht beide

if(bed1 ^ bed2) tu_was; //ist erfüllt, wenn genau eine Bedingungen bed1 oder bed2 wahr ist, aber nicht beide

Bist du sicher, dass das bitwise exclusive or hier das Richtige macht?

ich danke Euch sehr für die schnelle Antwort!

CStoll schrieb:

if(bed1 ^ bed2) tu_was; //ist erfüllt, wenn genau eine Bedingungen bed1 oder bed2 wahr ist, aber nicht beide

Bist du sicher, dass das bitwise exclusive or hier das Richtige macht?

Solange du mit booleschen Werten hantierst, ja. Einen logischen XOR gibt es afair nicht.

wäre afaik schon problematisch.

if(a != b)

sollte dagegen funktionieren. Es ist nur nicht unbedingt auf den ersten Blick klar, was gemeint ist ...

if(!a ^ !b)

gesehen, allerdings in C-Code. In C++ ist das insofern etwas haariger, als dass man unter Umständen mit dem Safe-Bool-Idiom rechnen muss. Ich würde mir wahrscheinlich eine kleine Funktionsvorlage dafür schreiben:

template<typename T, typename U>
bool logical_xor(T lhs, U rhs) {
  return static_cast<bool>(lhs || (!lhs && rhs));
}

...damit sollte man für alle Eventualitäten abgesichert sein, in denen logisches XOR überhaupt Sinn ergibt (keine Garantien dafür, was passiert, wenn man da Boost.Spirit-Parser reinschmeißt). Mit C++11 wäre

template<typename T, typename U>
auto logical_xor(T lhs, U rhs) -> decltype(lhs || (!lhs && rhs)) {
  return lhs || (!lhs && rhs);
}

eine Überlegung wert (ich denke da in Richtung Tribools).

(lhs && !rhs) || (!lhs && rhs)

sein. Dummer Flüchtigkeitsfehler.

bool logical_xor(T lhs, U rhs) {...}

nicht übersichtlicher?
Oder übersehe ich einfach etwas?

kam grad selbst drauf, daß man && usw. ja auch überladen kann.
Somit ist die Frage hinfällig.

Gruß

Hallo seldon,

kam grad selbst drauf, daß man && usw. ja auch überladen kann.
Somit ist die Frage hinfällig.

Gruß

Das sollte man sehr sparsam tun.
Weil der Leser meist erwartet, daß && und || usw die short-circuit-Auswertung haben. Der Überladene Operatore ist aber nur noch eine normale Funktion und kann den Trick nicht.

Das sollte man sehr sparsam tun.
Weil der Leser meist erwartet, daß && und || usw die short-circuit-Auswertung haben. Der Überladene Operatore ist aber nur noch eine normale Funktion und kann den Trick nicht.

Hallo volkard,

nicht, daß ich soetwas befürworten wollte(Gott bewahre).
Es beantwortet nur meine ursprüngliche Frage.

Gruß

Hallo volkard,
nicht, daß ich soetwas befürworten wollte(Gott bewahre).

Fein. Die Warnung war auch nicht konkret für diesen Thread, sondern irgendwie automatisch, die gehört dazu, wenn man && oder || überlädt.

Caligulaminus schrieb:

Es beantwortet nur meine ursprüngliche Frage.

Die ist mir noch ein Rätsel, muß ich zugeben.

Umkehren von &&? Was kann damit gemeint sein?

statt (Traumfrau)
if(körbchengröße>='D' && gehalt>=45000) heirate();
ein (Monster)
if(!(körbchengröße>='D' && !(gehalt>=45000)) heirate_nicht();
?
Das wäre zu einfach. Dazu einen neuen Operator zu bauen, kann ich gar nicht nachvollziehen.
Es läßt sich übrigens weiterführen zu (Monster)
if(!(körbchengröße>='D' && !(gehalt>=45000)) heirate_nicht();

if(körbchengröße<'D' && gehalt<45000)) heirate_nicht();

Oder war gemeint
statt (Traumfrau)
if(körbchengröße>='D' && gehalt>=45000) heirate();
ein (nicht Traumfrau)
if(!(körbchengröße>='D' && gehalt>=45000)) verlobe();
das läßt sich gut mit deMorgan kleinhacken zu
if(!(körbchengröße>='D') || !(gehalt>=45000)) verlobe();

if(körbchengröße<'D' || gehalt<45000) verlobe();

Das war auch wieder nicht konkret für diesen Thread. Ich weiß ja nicht, was Du vor hast. Ich kann nur für mich sagen, daß ich nie solchen Bedarf hatte, weil deMorgan schon erheblich rockt.

Und da war es wieder: mein immer wiederkehrendes Problem mit der Kommunikation in Foren dieser Machart.

Es sollte eigentlich kein Rätsel sein. Meine erwähnte "ursprüngliche Frage" lautete:

Caligulaminus schrieb:

"trailing-return-type" scheint hier ja wirklich beliebt zu sein, aber wäre in diesem Fall das "alte"

bool logical_xor(T lhs, U rhs) {...}

nicht übersichtlicher?
Oder übersehe ich einfach etwas?

Innerhalb der nächsten Minute sickerte bei mir ein, daß man die erwähnten Operatoren ja auch überladen kann und damit der höhere Schreibaufwand von seldons

auto logical_xor(T lhs, U rhs) -> decltype(lhs || (!lhs && rhs)){...}

an dem ich mich ursprünglich stieß, durchaus gerechtfertigt (schlicht besser/richtiger) ist.

Ich hoffe, ich konnte das Rätsel auflösen.

besten Gruß

C.

~Edit: Interpunktion~

lol, das kann ich fast spiegeln.

Und da war es wieder: mein immer wiederkehrendes Problem mit der Kommunikation in Foren dieser Machart.

Ich hatte Dich (Caligulaminus) mit dem Threadersteller (Neuling2011) gleichgesetzt, weil Ihr beide gute Fragen gestellt hattet. Garbage in, garbage out, Sorry. Bin erheitert.

Spiegel nur, wir leiden alle unter dem selben Problem.

@Caligulaminus
[...]weil Ihr beide gute Fragen gestellt hattet.

Und danke für die Blumen.

~Edit: Interpunktion(schon wieder)~

@volkard: Also C ist doch auch gut. D ist schon fast zu groß, findest du nicht?

Es ist nur ein Exempel zur Verdeutlichung der formalen Codeumformungen; das wird als Übertreibung klarer.
D ist mir ein bißchen zu groß, in beiden Welten, da stimme ich Dir zu. Schönes Wortspiel haste da gefunden.