C# &&, || unterschied zu &, |?

[Abcd12345]

Hi,

Ich habe lange Zeit immer nur die BEdiengten operatoren verwendet und nicht die logischen.
Nun bin ich auf eine Definition gestossen und wollte mal fragen, ob ich das richtig verstanden habe.

Ist es richtig, dass bei den bediengten Operatoren also (Variabel1 && Variabel 2) und (Variabel1 || Variabel 2) der Wert von Variabel 2 nur dann abgefragt wird wenn dies überhaupt noch dazu führen kann das der ganze Vergleich werden werden kann und bei & und | immer beide Operanden abgefragt werden unabhägig ob der erste Wert nun true oder false ist?

Es ist also eigentlich nur wichtig wenn man mit Funktionen vergleiche anstellt welchen Operatortyp man nimmt oder?

 

[Einhörnchen]

Vielleicht hilft dir das weiter:
http://msdn.microsoft.com/de-de/library/sbf85k1c.aspx
http://msdn.microsoft.com/de-de/library/2a723cdk.aspx

Ich mag die bedingten Operatoren, sind gut geeignet für Dinge wie
if(stringVariable != null && stringVariable.Length > 0)

 

[olampl]

Es ist also eigentlich nur wichtig wenn man mit Funktionen vergleiche anstellt welchen Operatortyp man nimmt oder?

Ich verwende (und kenne) die Operatoren &,| nur zum berechnen. (Wie in der Hilfe beschrieben.)

Vor allem weil es (in meinen Augen) keinen Sinn macht den 2. Operand auszuwerten sobald der 1. Operand die Gesamtbedingung erfuellt (beim || ist der 1. Operand true), oder eben nicht (beim && ist der 1. Operand false, somit ist die Gesamtbedingung false).
Das gilt vor allem wenn Du das ganze mit Methoden machen moechtest, sprich die Operatoren &,| 2 oder mehr Fkt. vergleichen deren result ein bool ist.
Da alle Fkt. ausgefuehrt werden, bevor es weitergeht. (Fehleranfaellig und schlecht wartbar).

Aber ich lasse mich gerne belehren.

Ich mag die bedingten Operatoren, sind gut geeignet für Dinge wie
if(stringVariable != null && stringVariable.Length > 0)

Dafuer verwende ich:
if(!string.IsNullOrEmpty(stringVariable))
{}

 

[Einhörnchen]

Dafuer verwende ich:
if(!string.IsNullOrEmpty(stringVariable))
{}

Hoi, man findet doch auch nach Jahren noch immer neue Funktionen im .NET Framework. Danke für den Tipp .

 

[msycho]

&& und || sind logische Verknüpfungen. & und | sind bitweise Verknüpfungen.

Teste es doch mal aus:

if (myObject != null && !myObject.myProperty)
                Console.WriteLine("Kein Fehler");

            if (myObject != null & !myObject .myProperty)
                Console.WriteLine("Fehler: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt.");

man findet doch auch nach Jahren noch immer neue Funktionen im .NET Framework.

Das Framwork wird ja auch weiterentwickelt. Von ehemals 1.1 sind wir auf 3.5. Wär ja schlimm, wenn es außer der Nummerierung keine Änderungen gäbe, oder?

 

[olampl]

&& und || sind logische Verknüpfungen. & und | sind bitweise Verknüpfungen.

Das ist nicht ganz richtig.

Bitweise verknuepfung mit &,| findet nur bei Integer Values statt. Bei boolschen Values wird dagegen logisch ausgewertet. (Sprich alle anderen Datentypen koennen so nicht getestet/ verarbeitet werden, von daher ist dein Code auch einfach nur falsch . Weil ich habe noch keinen INT mit einem Property gesehen. Du versucht ein object (von irgendwas) mit dessen Property (evtl. ein int) bitweise zu verknuepfen. )
(In den links von IgG , steht das super erklaert)

Uebrigens auf null prueft man lt. MS so:

if (object.ReferenceEquals(myObject , null))
{}

 

[1668mib]

@kreadon: Das ist eine Möglichkeit, aber es geht eher um was anderes...
z.B.

string s1 = "Hallo";
string s2 = "Hallo";
if (s1 == s2) { // sollte true sein }
if (object.RefeenceEquals(s1, s2)) { // sollte false sein }

So, beide Variablen haben den selben Wert sind aber nicht identisch, es sind ja verschiedene Instanzen.

 

[olampl]

Ja, simmt (selber wert aber nicht die selbe Reference)und was hat das mit &,| zu tun? Dann stehe ich wohl auf dem schlauch.

Ist alles true. (habe es gerade debuggt, bei Reference equals verstehe ich es auch noch nciht, werde ich nachlesen muessen)

Aber dennoch msycho liegt mit seiner aussage nicht richtig. Das ist eindeiutig nachzulesen.

EDIT: Interessant

 

[msycho]

In Bezug auf C# ist meine o.g. Aussage stimmt meine Aussage nicht ganz, ja.

Verwendest du & oder | wird jeder Teil der Bedingung überprüft. Mir && und || wird nur so wenig wie möglich, wobei man von links anfängt.
Bei meinem Beispiel überprüfen wir nicht nur ein Objekt sondern auch eines seiner Properties auf NULL. Ist das Objekt bereits NULL, wird das Property garnicht mehr überprüft, bei && und ||.

 

[olampl]

if (myObject != null && !myObject.myProperty)
                Console.WriteLine("Kein Fehler");

            if (myObject != null & !myObject .myProperty)
                Console.WriteLine("Fehler: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt.");

[/QUOTE]

Verwendest du & oder | wird jeder Teil der Bedingung überprüft.

EDIT:
Ebenso wie beim && , oder? -> das ist Falsch, da das && beim ersten Operanden == false keine weiteren ueberprueft (da gesamt bedingung false ist)
/EDIT

Nur beim || , | ergibt sich ein unterschied

QUOTE=msycho;5067755]
Bei meinem Beispiel überprüfen wir nicht nur ein Objekt sondern auch eines seiner Properties auf NULL. Ist das Objekt bereits NULL, wird das Property garnicht mehr überprüft, bei && und ||.[/QUOTE]

Dann sollte aber in beiden zeilen das selbe rauskommen oder?

EDIT:
[klugscheiss]
Lesbarer und verstaendlicher ist es auch in beispilen sprechende namen zu geben.
Im fall des Properties "IsMyPropertyNull" oder sowas in der art.. *duck*
[/klugscheiss]

 

[Abcd12345]

Hab grade nochmal wo nachgeguckt und da wird ständig von Bitweißer Veknüpfung gesprochen (wurde hier ja auch schon erwähnt), was ist damit nun genau gemeint? Klar weiß ich was ein Bit ist aber stehe da trotzdem noch etwas auf dem Schlauch.

 

[olampl]

Hier ist es gut erklaert. mit Beispielen

 

[Limit]

Die Bit-Operatoren arbeiten, wie der Name schon sagt auf einzelnen Bits, nämlich auf Bits beliebiger Ganzzahlen (int, long, ...). Es werden einfach die einzelnen Bits der Zahlen betrachtet.

Beispiele:

3 & 5 -> 0011 & 0101 = 0001 = 1 
5 | 9 -> 0101 | 1001 = 1101 = 13

Man braucht diese Operatoren z.B. bei manchen Verschlüsselungsalgorithmen (XOR = exklusives oder = bitweises "!=") oder wenn man mit Flags / Bitmaps arbeitet. Wobei letzteres eher bei Low-Level-Sachen benutzt wird.

 

[ichhalt123]

Damit kannste aber auch gemütlich z.B. 2 Boolwerte verknüpfen
if (bool1 & bool2) //da müssten beide True sein
if (bool1 | bool2) //da müsste entweder bool1 oder bool2 True sein
usw.

 

[olampl]

if (bool1 | bool2) //da müsste entweder bool1 oder bool2 True sein
usw.

Wie ich schon oben geschrieben habe, was macht es fuer einen sinn bei einer if abfrage alle oder operanden abzufragen ? Es genuegt doch hierbei nur den ersten abzufragen (sofern der true ist), da damit die Gesamtbedingung erfuellt ist! (Das passiert beim ||)

Genauso verhaelt es sich mit dem &, wenn der erste Operand false ist. Ist es ueberfluessig alle nachfolgenden Operanden noch zu Pruefen, da die Gesamtbedingung false ist.
(Das Passiert beim &&)

Fuer Bitoperationen , ok. Aber ansonsten halte ich |,& fuer ungeeignet.

 

[ichhalt123]

Es ging mir ja nur darum aufzuzeigen was möglich wäre

 

[olampl]

Es ging mir ja nur darum aufzuzeigen was möglich wäre

Sry das ich das so sage , aber das war maximal eine Wiederholung , von dem was MyPsycho und ich in den vorhergehenden posts geschrieben haben.
EDIT: Ist aber in Wahrheit auch egal.

 

[ichhalt123]

da is was dran... habs vermutlich überlesen... tut mir ja auch leid

 

[Limit]

[...]was macht es fuer einen sinn bei einer if abfrage alle oder operanden abzufragen ?[...]

Mir fällt da nur eine Sache ein, die allerdings eher unschön ist, nämlich, wenn du eine Funktion hast, die einen Wahrheitswert als Rückgabe hat und gleichzeitig irgendwelche globalen Zustände/Variablen ändert.

 

[olampl]

Mir fällt da nur eine Sache ein, die allerdings eher unschön ist,

Danke, daran habe ich auch gedacht.

Da alle Fkt. ausgefuehrt werden, bevor es weitergeht. (Fehleranfaellig und schlecht wartbar).