Differences

This shows you the differences between two versions of the page.

--- tanszek:oktatas:szamitastechnika:binaris_muveletek [2024/10/08 19:08] – [1. AND művelet] knehez
+++ tanszek:oktatas:szamitastechnika:binaris_muveletek [2024/10/08 19:23] (current) – [1. AND művelet] knehez
@@ Line 3: / Line 3: @@
 A bináris logikai műveletek (**AND**, **OR**, **XOR**) fontos szerepet játszanak a bitek kezelésében, mint például a bitek beállítása, kikapcsolása, illetve megfordítása. Az alábbiakban bemutatjuk, hogyan lehet ezeket a műveleteket felhasználni gyakorlati feladatok megoldására.
-==== 1. AND művelet ====
+==== 1. AND (és) művelet ====
 Az **AND** művelet csak akkor ad 1-es eredményt, ha mindkét bemenet 1. A bitek "kikapcsolására" használhatjuk, mert a 0 hatására minden egyes bitet 0-ra állít.
@@ Line 26: / Line 26: @@
-==== 2. OR művelet ====
+==== 2. OR (vagy) művelet ====
 Az **OR** művelet akkor ad 1-es eredményt, ha legalább az egyik bemenet 1. Ezt a bitek "bekapcsolására" használhatjuk, mert a 0 nem változtatja meg az eredményt, de a 1-es beállítja az adott bitet 1-re.
-  * Példa: Ha egy bitek közül egyet be akarunk állítani, használjuk az OR-t:
-    - `10101101 | 00001000 = 10101101`.
-Ez hasznos, ha egy konkrét bitet szeretnénk 1-re állítani anélkül, hogy a többi bitet megváltoztatnánk.
 **Igazságtábla:**
@@ Line 40: / Line 36: @@
 | 1 | 0 | 1 |
 | 1 | 1 | 1 |
+**Példa**: Ha egy bitek közül egyet be akarunk állítani (pl. jobbról a negyediket), és a többit érintetlenül hagyni, akkor használjuk az OR-t:
+<code>
+  10101101
+| 00001000
+----------
+  10101101
+</code>
+Ez hasznos, ha egy konkrét bitet szeretnénk 1-re állítani anélkül, hogy a többi bitet megváltoztatnánk.
 ==== 3. XOR művelet ====
 Az **XOR** (kizáró vagy) művelet akkor ad 1-et, ha a bemenetek eltérnek. Ezzel biteket kapcsolgathatunk, azaz ha egy bit értéke 1, akkor 0-ra vált, és fordítva.
-  * Példa: Ha az alsó 4 bit értékét akarjuk megváltoztatni:
-    - `10101101 ^ 00001111 = 10100010`.
-Ez a művelet különösen hasznos, ha egy adott bitet meg akarunk "fordítani".
 **Igazságtábla:**
@@ Line 55: / Line 60: @@
 | 1 | 0 | 1 |
 | 1 | 1 | 0 |
+**Példa**: Ha az alsó 4 bit értékét akarjuk megfordítani:
+<code>
+  10101101
+^ 00001111
+----------
+  10100010
+</code>
 ==== Gyakorlati példa: Bitek beállítása és törlése ====
-Tegyük fel, hogy van egy 8 bites regiszterünk: `R = 10101101`.
+Tegyük fel, hogy van egy 8 bites regiszterünk: ''R = 10101101''.
-  - **Egy bit bekapcsolása (pl. 2. bit):**
+**Egy bit bekapcsolása (pl. 3. bit):**
-    * Maszk: `00000100`  (1 << 2)
-    * Művelet: `R | Maszk`
+''R = 10101101''
-    * Eredmény: `10101101 | 00000100 = 10101101` (a 2. bit már 1, nincs változás)
+Maszk legyen: ''00000100''
-  - **Egy bit kikapcsolása (pl. 3. bit):**
-    * Maszk: `11110111`  ~(1 << 3)
+Megjegyzés: a maszkot a gyakorlatban a '<<' biteltolás művelettel adják meg, az ''1 << 2'' művelet az első bitet kettővel balra tolja.
-    * Művelet: `R & Maszk`
-    * Eredmény: `10101101 & 11110111 = 10100101` (a 3. bit 0 lett)
+Művelet: ''R | Maszk''
-  - **Egy bit átkapcsolása (pl. 0. bit):**
+Eredmény:
-    * Maszk: `00000001`  (1 << 0)
+<code>
-    * Művelet: `R ^ Maszk`
+  10101001
-    * Eredmény: `10101101 ^ 00000001 = 10101100` (a 0. bit megfordult)
+| 00000100
+----------
+  10101101 (a 3. bit 1 lett)
+</code>
+**Egy bit kikapcsolása (pl. 4. bit):**
+''R = 10101101''
+Maszk legyen: ''11110111'', a gyakorlatban ezzel adjuk meg: ~(1 << 3)
+Megjegyzés: ~(1 << 3) művelet az első bitet kettővel a negyedik helyre (helyiértékre) tolja, majd a '~'-al negálja, azaz megfordítja biteket.
+Művelet: ''R & Maszk''
+Eredmény:
+<code>
+  10101101
+& 11110111
+----------
+  10100101  (a 4. bit 0 lett)
+</code>
+=== Egy bit átkapcsolása (pl. 0. bit): ===
+Maszk legyen: ''00000001''  (1 << 0)
+Művelet: ''R ^ Maszk''
+Eredmény:
+<code>
+  10101101
+^ 00000001
+----------
+  10101100  (a 0. bit megfordult)
+</code>
 Az igazságtáblák és a fenti példák segítségével megérthető, hogyan manipulálhatók a bitek a logikai műveletek segítségével. Ez alapvető fontosságú az alacsony szintű programozásban és a digitális áramkörök tervezésében.