OR, NOT und andere Operatoren

  • Allgemein

Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    OR, NOT und andere Operatoren

    Hey,

    wenn ich mit boolischen Werten arbeite, verstehe ich die Funktion von RO,NOT und AND aber dann hörts auch auf. Ich weiß auch wie sie gerechnet werden, dass zB 1010 OR 1100 = 1000 aber wenn ich dann Funktionen der WinAPI sehe, wo dann zwei Eigenschaften mit OR verknüpft sind muss ich passen.
    Denn ich übersetze mir gern mal Codes "auf deutsch". Wenn ich hab If Picturebox1.Enabled OR Picturebox2.Enabled then.. bedeutet ja wenn die Pic1 oder Pic2 Enabled ist, dann mache das. Aber wenn ich eine Funktion hab:

    SetIrgendwas(removeall OR deleteall)

    Bekomme ich Zustände. Das würde bedeuten. Mache Irgendwas mit "deletall" oder "removeall". Aber wenn ich die Funktion ohne OR und nur mit einer beliebigen Eigenschaft schreibe macht sie schoneinmal nichtmehr das was sie soll.

    Ich denke ihr merkt, dass mich das total verwirrt. Es währe freundlich wenn ihr das möglichst einfach erklären könnt :)

    *Topic verschoben*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    Cubysoft schrieb:

    wenn ich mit boolischen Werten arbeite [...] dass zB 1010 OR 1100 = 1000
    Was denn jetzt? Logische oder bitweise Operatoren ?

    Mir bekannte logische Operatoren:
    And, Or, AndAlso, OrElse
    (C#: &, |, &&, ||)

    Mir bekannte bitweise Operatoren:
    And, Or, Not, Xor
    (C#: &, |, ~, ^)

    msdn.microsoft.com/de-de/library/wz3k228a(v=vs.80).aspx
    Von meinem iPhone gesendet
    Wie gesagt, ich kenne das nur von If NOT naja ich hab mir die Seite angeschaut und ich glaube es sind die bitweisen Operatoren. Nur wie kann man zB die oben genannte Funktion "SetIrgendwas" verstehen, denn darauf will ich ja hinaus. Ich hab auch nicht gewusst dass es unterschiede zwischen dem OR für Booleans und dem für binärische Werte gibt.
    Bitweise Operatoren sind für Bitoperationen
    secure.wikimedia.org/wikipedia/de/wiki/Bitweiser_Operator

    Die "anderen":
    secure.wikimedia.org/wikipedia/de/wiki/Logischer_Operator

    Beide überschneiden sich leider bei der Namensgebung (And/Or).
    Von meinem iPhone gesendet
    @nikeee13: Ich dachte logische Oparatoren sind bitweise Oparatoren.

    1010 OR 1100 ist nicht 1000

    Es handelt sich um einfache bitweise Oparatoren.
    Die bekanntesten Oparatoren sind Not, And und Or.

    Guck' Dir mal diese Tabelle an:


    Zur SetIregendwas Funktion:
    Zahlen werden im Arbeitsspeicher so angelegt: (Beispiel Byte 1)

    Quellcode

    1. 00000001


    Wenn man nun zwei Zahlen bitweise verknüpft (hier 1 und 2) passiert das:

    Quellcode

    1. 00000001
    2. 00000010
    3. OR verknüpft:
    4. 00000011


    Darum werden bei manchen Funktionen Parameter mit Or verknüpft. Meistens sind die Parameter so aufgebaut:
    Enum Irgendwas
    Bla1 = 1 '00000001
    Bla2 = 2 '00000010
    Bla3 = 4 '00000100
    Bla4 = 8 '00001000
    Bla6 = 16 '00010000
    End Enum

    Edit: Achso. Hab jetzt den Unterschied zwischen logischen und bitweisen Oparatoren verstanden.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils
    Nimm als Beispiel die API Funktion SetWindowPos.
    Die Signatur ist diese:

    VB.NET-Quellcode

    1. <DllImport("user32.dll", SetLastError:=True)> _
    2. Public Shared Function SetWindowPos(ByVal hWnd As IntPtr, ByVal hWndInsertAfter As IntPtr, ByVal X As Integer, ByVal Y As Integer, ByVal cx As Integer, ByVal cy As Integer, ByVal uFlags As UInteger) As Boolean
    3. End Function

    Für uFlags können verschiedene Parameter übergeben werden:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Enum uFlags As UInteger
    2. ''' <summary>
    3. ''' If the calling thread and the thread that owns the window are attached to different input queues, the system posts the request to the thread that owns the window. This prevents the calling thread from blocking its execution while other threads process the request.
    4. ''' </summary>
    5. SWP_ASYNCWINDOWPOS = &H4000
    6. ''' <summary>
    7. ''' Prevents generation of the WM_SYNCPAINT message.
    8. ''' </summary>
    9. SWP_DEFERERASE = &H2000
    10. ''' <summary>
    11. ''' Draws a frame (defined in the window's class description) around the window.
    12. ''' </summary>
    13. SWP_DRAWFRAME = &H20
    14. ''' <summary>
    15. ''' Applies new frame styles set using the SetWindowLong function. Sends a WM_NCCALCSIZE message to the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE is sent only when the window's size is being changed.
    16. ''' </summary>
    17. SWP_FRAMECHANGED = &H20
    18. ''' <summary>
    19. ''' Hides the window.
    20. ''' </summary>
    21. SWP_HIDEWINDOW = &H80
    22. ''' <summary>
    23. ''' Does not activate the window. If this flag is not set, the window is activated and moved to the top of either the topmost or non-topmost group (depending on the setting of the hWndInsertAfter parameter).
    24. ''' </summary>
    25. SWP_NOACTIVATE = &H10
    26. ''' <summary>
    27. ''' Discards the entire contents of the client area. If this flag is not specified, the valid contents of the client area are saved and copied back into the client area after the window is sized or repositioned.
    28. ''' </summary>
    29. SWP_NOCOPYBITS = &H100
    30. ''' <summary>
    31. ''' Retains the current position (ignores X and Y parameters).
    32. ''' </summary>
    33. SWP_NOMOVE = &H2
    34. ''' <summary>
    35. ''' Does not change the owner window's position in the Z order.
    36. ''' </summary>
    37. SWP_NOOWNERZORDER = &H2
    38. ''' <summary>
    39. ''' Does not redraw changes. If this flag is set, no repainting of any kind occurs. This applies to the client area, the nonclient area (including the title bar and scroll bars), and any part of the parent window uncovered as a result of the window being moved. When this flag is set, the application must explicitly invalidate or redraw any parts of the window and parent window that need redrawing.
    40. ''' </summary>
    41. SWP_NOREDRAW = &H8
    42. ''' <summary>
    43. ''' Same as the SWP_NOOWNERZORDER flag.
    44. ''' </summary>
    45. SWP_NOREPOSITION = &H200
    46. ''' <summary>
    47. ''' Prevents the window from receiving the WM_WINDOWPOSCHANGING message.
    48. ''' </summary>
    49. SWP_NOSENDCHANGING = &H400
    50. ''' <summary>
    51. ''' Retains the current size (ignores the cx and cy parameters).
    52. ''' </summary>
    53. SWP_NOSIZE = &H1
    54. ''' <summary>
    55. ''' Retains the current Z order (ignores the hWndInsertAfter parameter).
    56. ''' </summary>
    57. SWP_NOZORDER = &H40
    58. ''' <summary>
    59. ''' Displays the window.
    60. ''' </summary>
    61. SWP_SHOWWINDOW = &H40
    62. End Enum



    Die Parameter x und y geben die neue Fensterposition an, die Parameter cx und cy geben die neue Fenstergröße an. Wenn man aber will, dass das Fenster nicht neu positioniert wird, nicht skaliert wird und nicht fokussiert werden kann muss man die Parameter
    uFlags.SWP_NOMOVE '2
    uFlags.SWP_NOSIZE '1
    uFlags.SWP_NOACTIVATE '16
    übergeben; gleichzeitig.
    Wenn man sich die Werte dieser Parameter ansieht erkennt man das oben genannte Schema:

    Quellcode

    1. 00010
    2. 00001
    3. 10000
    4. OR verknüpft:
    5. 10011


    Und wenn man für jede mögliche Kombination (2 ^ n) eine Konstante benötigt wird es extrem unübersichtlich.
    Darum gibt es diese Möglichkeit.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils
    Das sind Bitflags. ;)
    Wenn man verscheidene Optionen kombinieren will, kann man dies über Bitflags machen.

    Z.B:

    const byte GrünesFenster = 1 ' 00000001
    const byte RotesFenster = 2 ' 00000010
    const byte KleineButtons = 4 ' 00000100
    const byte GroßeButtons= 8 ' 00001000

    dann kann man sie so kombinieren:
    RotesFenster Or KleineButtons

    Quellcode

    1. 00000010
    2. | 00000100
    3. = 00000110
    4. = 6 (dez, unwichtig)


    Wenn man andere eigenschaften nehmen will, kann man andere Operatoren kombinieren:
    GrünesFenster Or GroßeButtons

    Quellcode

    1. 00000001
    2. | 00001000
    3. = 00001001
    4. = 9 (dez, unwichtig)


    An dieser Stelle bieten sich Enums an. Enums können mit dem Flags-Attribut versehen werden. Dann kann man die Enum-Member als Bitflags verwenden.


    Edit:
    Niko war schneller ;)
    Von meinem iPhone gesendet
    Logische Operatoren verarbeiten ihre "Parameter" nach ihrem Wahrheitsgehalt. False Or True = True
    Bitweise Opertatoren tun dies pro Bit in den Zahlen (vorausgesetzt 1 = True; 0 = False).
    Beispiel:
    16 Or 5 (dezimal)
    10000 Or 00101 (binär)
    {True, False, False, False, False} Or {False, False, True, False, True} (binär mit der Annahme 1=True, 0=False, als Bool-Array)
    {True Or False, False Or False, False Or True, False Or False, False Or True} (jedes Element des 1. Arrays mit dem entsprechenden Element des 2. Arrays per Or verknüpfen)
    {True, False, True, False, True} (fertig verknüpft)
    10101 (Binär)
    21 (dezimal)

    Bitweise Operatoren führen die logische Operation desselben Names bitweise jeweils für die Elemente mit dem gleichen Index beider Arrays(Stellen beider Integer etc.) aus.
    k?

    lg SeriTools
    | Keine Fragen per PN oder Skype.
    Zur Erläuterung:
    Wenn Du irgendwelche Eigenschaften transportieren willst, die alle unabhängig voneinander gesetzt oder nicht gesetzt sein können und wenn es von diesen Eigenschaften nur eine überschaubare Anzahl gibt (zB. 8, 16, 32, 64 Stück), bietet es sich an, diese zusammenzufassen und über eine Funktion abzuarbeiten.
    Die Eigenschaften bekommen Werte (Kennungen), die den obigen Eigenschaften genügen:
    1, 2, 4, 8, 16 usw. (0001, 0010, 0100, 1000 binär)
    Diese Zahlen hannst Du zusammensetzen und wieder trennen, ohne dass es ein "übersprechen" gibt, wenn sie bitweise mit OR zusammengesetz und mit AND wieder abgefragt werden.
    Damit man das einigermaßen lesen kann, bekommen die einzelnen Eigenschaften (1, 2, 4, 8, 16) wohlklingende Namen.
    Und ob dann (Grün Or Groß Or Segel) oder (Read Or Write) oder so dasteht,
    Mehr ist das nicht. :D
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    RodFromGermany schrieb:

    wenn sie bitweise mit OR zusammengesetz und mit AND wieder abgefragt werden.
    Wie sieht diese Abfrage mit AND dann aus? Spätestens dort muss man dann doch alle möglichen Kombinationen durchgehen oder wie funktioniert das?

    Skybird schrieb:

    Das sind ja Ubisoftmethoden hier !

    Input:

    VB.NET-Quellcode

    1. Wert = (Grün Or Groß Or Segel)
    dort Test:

    VB.NET-Quellcode

    1. If (Wert And Grün) = Grün Then
    2. ' Grün vorhanden
    3. End If
    4. If (Wert And Groß) = Groß Then
    5. ' Groß vorhanden
    6. End If
    7. If (Wert And Segel) = Segel Then
    8. ' Segel vorhanden
    9. End If
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!