Hallo en welkom. Laten we het hebben over bitsgewijze operators.
We hebben je hier in de vorige lezing een glimp van laten zien toen we het hadden
over toewijzingsoperatoren, omdat toewijzingsoperators al deze samengestelde toewijzingen hebben waar je een
bewerking als een optelling kunt uitvoeren en vervolgens ook kunt toewijzen.
U kunt hetzelfde doen met deze type-operators.
Maar laten we hier meer in detail op ingaan en u precies vertellen wat ze zijn.
Dus c biedt bitsgewijze logische
operatoren en ploegoperatoren. Die termen zijn misschien helemaal geen idee.
Ze zien eruit als logische operatoren, maar ze zijn heel anders. Ze doen geen enkele vorm
van Booleaanse evaluaties. Ze evalueren niet waar of onwaar.
Ze zien eruit als de ampersand ampersand, de 2 ors,
maar ze doen geen enkele Booleaanse evaluatie.
Wat ze doen is dat ze werken op bits, binnen gehele waarden.
En dus vraag je je misschien af waarom je dit in godsnaam zou willen doen? Nou, het wordt niet
gebruikt in de meeste programma's. Het is meer een geavanceerde techniek.
Ook al is dit een beginnerscursus. Ze maken deel uit van de operators en operators zijn een beginnersconcept.
Dus ik ga ze aanspreken, maar we gaan er niet per se op focussen.
Ik zal u enkele voorbeelden geven, u laten zien hoe u ze kunt gebruiken.
Maar daar word je na deze lezing geen expert in.
Maar de manier waarop ze nuttig zijn en waarom je ze eigenlijk zou willen gebruiken, is
omdat je nogal wat gegevens kunt opslaan.
Dus er zijn bitsgewijze operanden genaamd en, ampersand en de bitsgewijze of die een
of slechts een enkele parallelle balk is.
Probeer deze niet opnieuw te verwarren met de logische operatoren.
Logische operatoren hebben er 2, ampersand ampersand, wat een en is.
De bitsgewijze operators hebben er maar één. Dus gewoon een ampersand of gewoon een of.
Dus wat ze gaan doen, is dat ze gaan testen en dat ze individuele bits
in een integer-variabele gaan plaatsen. Wat is een beetje?
We weten dat een bit een manier is om gegevens te meten.
Maar een bit is in wezen gewoon een 0 of 1 waarde.
En 8 daarvan vormen een byte. Dus een bit is een 0 of 1.
En wat je kunt doen is een geheel getal,
onthoud, afhankelijk van het systeem dat je gebruikt, kan het 8 bytes zijn.
En zo kon je elke bit aan- en uitzetten.
En als ik zeg in- of uitschakelen, zeg ik dat je ze gelijk aan 1 of 0 kunt hebben.
En dan kun je die stukjes gebruiken om je iets te vertellen.
U kunt dus veel gegevens opslaan door bits een soort gegevens te laten vertegenwoordigen.
Dat is waarom een van de redenen waarom de computer
bits in 1 en nullen en binaire getallen gebruikt om bewerkingen uit te voeren, omdat je veel
gegevens kunt opslaan. Wat dit
precies betekent, is hier een voorbeeld. U kunt een enkele integer-variabele gebruiken.
Nogmaals, een geheel getal is een getal, een geheel getal vertegenwoordigt 4 tot
8 bytes, afhankelijk van het systeem dat u gebruikt.
Dat betekent dat als er 4 bytes zijn, dat er 32 bits zijn.
Er zijn 32 0s of 1 waarden.
Dus je kunt al die bits gebruiken om iets voor te stellen.
Dus als u bijvoorbeeld individuele karakters van een persoon wilt opslaan, kunt u gewoon 1 bit hebben,
u vertellen of de persoon een man of een
vrouw is door te zeggen dat 1 gelijk is aan mannelijk 0 is gelijk aan vrouwelijk.
Je zet hem gewoon aan of uit.
Dan zou je 3 bits kunnen gebruiken om aan
te geven of de persoon Frans, Duits of Italiaans kan spreken.
Dus de 1-bit zou Frans kunnen vertegenwoordigen. Als het geen 10 is,
dan betekent dat dat ze geen Frans spreken.
Als Duits 0 is, betekent dat dat ze geen Duits spreken.
Als het 1 is, betekent dit dat ze Duits spreken. Dus door deze bits aan en uit te zetten
en ze van 1 op 0 te zetten, kun je veel gegevens weergeven.
Je zou nog een stukje kunnen hebben om vast te leggen of het salaris van de persoon 50.000 of meer is.
Als het 1 is, is het waar, ja, dat is het. 0 vals.
Dus eigenlijk hebben we het hier net gespecificeerd.
Er staat eigenlijk 4, maar we hebben eigenlijk 5 bits aan gegevens gespecificeerd,
slechts 5 van of we 32 of 64 bits hebben,
maar we gebruikten er maar 5 en we kunnen aangeven of
een persoon een vrouw of een man is , of ze nu wel of niet Frans,
Duits of Italiaans spreken of alle 3 of de een of de ander.
En of ze meer dan $ 50.000 verdienen.
We kunnen al die gegevens in onze bits weergeven.
En dit is waar de bitsgewijze operators van pas komen.
Nu we weten hoe we bits kunnen gebruiken om veel verschillende gegevens
op te slaan. Laten we het hebben over die binaire getallen.
We weten dat een binair getal slechts een getal is met enen en nullen.
En daarom is het voordelig om te gebruiken. Bit-operators in een geheel getal, het getal
kan elke lengte hebben.
De volgende zijn voorbeelden van binaire getallen, alleen nullen en enen.
Dus je hebt dit gezien 0 1 0 1 0 1 1 0 1 0 1 0.
En onthoud dat een byte 8 bits is.
Een geheel getal is op de meeste platforms meestal 4 bytes.
Het hangt af van de architectuur, maar meestal 32 bits.
Je hebt dus 32 waarden die je kunt opslaan met enen en nullen om aan of uit te geven.
Binaire getallen, elk binair getal heeft weer een corresponderende decimale waarde, dus
je moet begrijpen hoe je binair naar decimaal kunt converteren.
Voorbeelden hier 1 is gelijk aan 1, 1 0 is 2, 1 1
is 3, dit zijn eenvoudige conversies.
Nogmaals, meestal hebben ze meer bits, 1 0 1 0 1 1 1.
De manier waarop u de binaire getallen naar een decimaal getal
wilt converteren, is dat u elke positie
in de byte wilt bekijken met de bit-corresponderende bit en vervolgens de macht van 2 wilt gebruiken.
Dus voor elk cijfer vermenigvuldig je het cijfer met de positiewaarde
met behulp van de macht van 2. En dan tel je het hele project bij elkaar op om het eindresultaat te krijgen.
Positiewaarden en een binair getal zijn dus de machten van 2.
Dus de eerste positie zou de waarde 2 0 zijn, wat
met andere woorden 1 zou zijn.
En dan zou de tweede positie de waarde zijn van 2 tot de eerste macht die 2 is,
2 tot de 2 zou 4 zijn, 2 tot 3 zou 8 zijn,
2 tot de 4 zou 16 zijn. En dat blijf
je keer op keer doen. En dus is het makkelijker te begrijpen als je een mooi voorbeeld ziet.
En dus hebben we hier een binair getal van 0 1 1 0 1 0 0 1.
Het decimale equivalent daarvan is 105.
De manier waarop u converteert, is dat u voor elke bit aan de
rechterkant begint en vermenigvuldigt tot de macht 2, afhankelijk van of de bit 0 is.
Dus als we helemaal naar rechts beginnen, hebben we 1.
Dus we zeggen 1 keer 1 en we houden die 1. Dan is de volgende 1,
de tweede positie 0 keer 2 0. Dan 0 keer 4, 1
keer 8, 0 keer 16,1 keer 32, 1
keer 64 en 0 keer 28.
En als je die allemaal bij elkaar optelt, krijg je het resultaat van 105.
Dat is 1 manier om te converteren. Je kunt het ook van links naar
rechts converteren door te vermenigvuldigen met 2 en vervolgens 1 toe te voegen of 0
toe te voegen, afhankelijk van wat het volgende bit is. Dus je kunt bijvoorbeeld
ook als je van links naar rechts gaat,
beginnen met 1 omdat 0 er niet toe doet.
Dus het tweede bit dat van links naar rechts gaat, heb je 1.
Het derde bit, je hebt 1 keer 2 plus 1,
dus je hebt 3.
En nogmaals, je vermenigvuldigt met 2, dus je zegt 3 keer 2 plus 0 dat is 6.
6 keer 2 plus 1, dat is 13.
13 keer 2 is 26.
26 keer 2 is 52
keer 2, dat is 104 plus 1.
Dus nog een keer vermenigvuldigen met 2 en dan 1 optellen. Een ander voorbeeld, nogmaals,
van rechts naar links is meestal een beetje makkelijker.
Hier is 1 0 0 1 1 1 0 0.
En dat wordt omgezet in 156, want je zegt opnieuw 0 keer 1,
0 keer 2, 1 keer 4, 1 keer 8, 1 keer 16
enzovoort en dan tel je ze
allemaal bij elkaar op, dat is 4 8 12 16 28 plus 128 is 156 .
En nogmaals, als je van links naar rechts gaat, vermenigvuldig je met 2 en tel je 1.
Dus begonnen we voor 1. Zeg 1
2 4 9, 4
keer 2 plus 1, 9 keer
2 is 18 plus 1 is 19 keer
2, 38 plus 1 is 39 keer 2 wat
78 keer 2 is, wat 156 is.
Dit is dus een snelle demonstratie van hoe u
binair naar decimaal kunt converteren. Nu ik decibel omzet in binair,
gebruik ik meestal gewoon een conversie op internet
als je daar echt in geïnteresseerd bent. Maar je kunt deze binaire getallen nemen en vervolgens
bitsgewijze operatoren uitvoeren. Laten we eens kijken naar de bitsgewijze operatoren.
Dus de bitsgewijze operatoren worden hier samengevat. En nogmaals, nog een mooie tabel die ik
online heb gekregen, maar ze lijken op logische operatoren. Maar nogmaals, verwar ze niet.
Dus de ampersand op zichzelf is een binaire en operator.
En wat dit doet, is dat het een beetje naar het resultaat
kopieert als het in beide operanden bestaat. Dus als ze allebei waar zijn, wordt
het een beetje gekopieerd.
Dus als a en b gelijk zijn aan 12,
krijg je een binaire representatie van 0 0 0 0 1 1 0 0.
Dus a en b zouden
dat getal zijn. We zullen enkele voorbeelden doornemen.
Een binair of kopieert een bit als het in een van beide operands bestaat, dus
a of b kopieert een bit
als het in een van de operands bestaat. Dus als een van de
operanden gelijk is aan 1, zal het een bit kopiëren.
En dan de binaire xor, dit is de exclusieve of.
Dit kopieert de bit als deze is ingesteld in 1 operand, maar niet in beide.
Dus als je een waar hebt, maar slechts 1 waar
en je gebruikt de wortel om dit op je toetsenbord weer te geven,
dan zal het een beetje kopiëren en het zal zeggen
dat het
waar is, binaire 1s-complement.
Dus nogmaals, we krijgen hier de binaire gegevens omdat we het over bits hebben. Dus hopelijk is 1's
complement.
De operator is unair en heeft het effect
dat de bits worden omgedraaid, in feite alleen maar negeert en de monitor eraf haalt.
Dus een voorbeeld hier was als je tilde a
zegt, je de 1s complement-operator toepast.
En als het gelijk is aan -61, is het 1 1 0 0 0 0 1.
Dus als je dat binaire getal daadwerkelijk naar decimaal
zou converteren, wat een negatief getal is en het eerste
getal het teken is. Dus 1 vertelt je dat het een teken is.
En dan zeg je 1 2 4 8 16 33 en
dan 61, dus zo zou het worden weergegeven.
Dus ik zal hier meer concrete voorbeelden van doornemen.
Maar eigenlijk, als je een binair getal hebt, is a in eerste instantie een binair getal dat 0 0 1
1 1 1 0 0 is, wat 60 is en je
levert de flipping in feite gaat het dan veranderen
in min 61, wat 1 1 0 0 0 is 0 0 0 0 0 0 1 1.
Dit zijn dus de resultaten van variabelen die daadwerkelijk zijn ingesteld. Dus nogmaals, ik neem aan
dat a een bepaalde binaire representatie heeft en b een bepaalde binaire representatie.
Dus als a gelijk is aan, nogmaals, 60 en
b gelijk is aan 13, dan is het resultaat van het bij elkaar
optellen van een bitsgewijze uitvoering 0000 11 00, wat 12 is.
Nogmaals, ik zal deze voorbeelden doornemen, maar dit is een poging om een
kleine beschrijving te geven van deze verschillende binaire operatoren.
Het kleiner dan kleiner dan-symbool zal bits naar links verschuiven.
Dus de linker operandwaarde wordt naar links verplaatst met het aantal bits gespecificeerd door de witte operand.
Dus als je iets doet als een
kleiner dan minder
dan 2 en a is eigenlijk gelijk aan je
kent een binair getal, bijvoorbeeld 0 0 1 1 1 1 0 0, dan verschuif
je de bytes met 2.
Dus je gaat de nullen verwijderen en het wordt 1 1 1 1, en die nullen gaan tot het einde.
En hetzelfde geldt voor de juiste shift-operator. Je verschuift ze gewoon naar rechts in plaats van naar links.
Hier gebruik je de groter dan symbolen.
En dus ga ik deze zo even doornemen.
Het andere belangrijke dat u met de bitsgewijze operatoren moet begrijpen, is hoe
u deze a- en b-waarden kunt evalueren. Dus wat evalueren een
1 en een 1 tot een 1, als het
een ampersand is. Als het een of 1
is en 1 evalueert ook naar 1.
Maar een 1 en 1 en een 0 als je een ampersand gebruikt en
een en doet, dat levert 0 false op. Dus ik wilde hier een kleine waarheidstabel
geven die je de waarden laat zien wanneer je het
doet, je gebruikt een en een of een exclusieve of.
Dus hier, als je p0 en q0 hebt, wat betekent dat ze allebei onwaar zijn en
je past een en toe, dan zal het
onwaar zijn omdat ze allebei waar moeten zijn om dat waar te maken.
En dat zie je in rij 3.
Ze zijn allebei waar, dan worden p en q geëvalueerd tot 1, waar.
Als ze niet allebei waar zijn, is het altijd onwaar.
P of q slechts 1 ervan hoeft waar te zijn.
Dus daarom zie je rij 1 en rij 2 gelijk aan 1 en rij 3 gelijk aan 1.
De enige keer dat het onwaar is, is wanneer ze allebei onwaar zijn.
En dan is de exclusieve of is er tenminste 1
waar, en slechts 1.
Dus als p onwaar is en q waar is, zal het waar teruggeven.
En als p waar is en q onwaar, dan geeft het 1.
Dit geeft u dus een idee van hoe het wordt geëvalueerd.
Nogmaals, veel wiskundedingen, maar als we het hebben over binaire cijfers, dan hebben we het daar over.
Laten we dus eens kijken naar enkele concrete voorbeelden en codeblokken. Hopelijk helpt dit een beetje.
Dus hier is onze functie. Ik ga nog een paar variabelen maken.
Ik ga ervoor zorgen dat ze niet ondertekend zijn,
ook al is dat standaard. Dus als ik unsigned int a
zeg en het toewijs aan 60, wordt dat in binair weergegeven als 0
0 1 1 en dan 11 00.
Als ik nog een niet-ondertekende variabele maak en ik zeg int
b en ik wijs dat de waarde
13 toe, dan wordt dat eigenlijk weergegeven als in binair 0 0
00 1 1 0 1. U kunt daar de conversies doen.
Maar wat ik hier wil aantonen, is dat wanneer je deze binaire getallen
instelt, je de bits kunt uitschakelen door de verschillende bitsgewijze operanden te gebruiken.
Dus nu ga ik gewoon een int-resultaat maken, en ik ga zeggen dat
dat gelijk zal zijn aan 0.
E houdt het resultaat van de bitsgewijze bewerking vast.
operatie. Als ik zeg dat c gelijk is
aan a en ik pas de bitsgewijze operand toe en a en b, wat dat
dan zou moeten doen, is dat als a gelijk is aan 1 en b gelijk is
aan 1, dat bits worden ingeschakeld. Dus wat zou je verwachten van het resultaat van deze v.
Nou, je kijkt naar het eerste bit van a en je kijkt naar het eerste bit van
b en ze zijn allebei 0.
Het resultaat wordt dus 0, want als
je het waar doet in a en a b, moeten ze allebei waar zijn om 1 te zijn.
Dus de volgende wordt ook 0. De volgende is 1 en 0, het derde bit.
Dus het is nog steeds 0, 1 en 0 is nog steeds 0. En dan hebben we nu een 1 en een 1.
Dus nu hebben we eindelijk een echte. We hebben nog 1 en 1. We hebben een waar.
En dan wordt 0 en 0 0 en dan worden 0
en 1 0.
Dus het resultaat als ik zou proberen om c af te drukken, het gaat
de waarde in decimaal formaat afdrukken. Als ik zoiets zou doen,
wordt het decimale equivalent van dat binaire getal afgedrukt, wat het
equivalent zou zijn van 0 0 0 0.
En dit alles converteert binair naar decimaal, dus je moet begrijpen hoe je dat
moet doen om dit voorbeeld te begrijpen. Maar 0 0 0 0 1
1 0 0 is eigenlijk 1 3 7, de waarde
is eigenlijk 12, 1 3 6 12.
Dus dit zou twaalf afdrukken als
ik c zou
afdrukken, anders zou het resultaat beter zijn.
Dus als ik dit uitvoer, zul je zien dat de waarde 12 is.
Het ging eigenlijk uit en aan op basis van de ampersand-vergelijking.
Dus nu zeg
ik uitvoeren, we zien dat de waarde in d12 is omdat
het de bits aan en uit zet en het
zal feitelijk worden weergegeven als 0 0 0 1 1
0 0, wat de waarde 12 is omdat we een decimaal afdrukken .
Als ik dit zou veranderen en ik wil nu een
of doen en ik doe nog steeds de of en de of onthoud
is de
parallelle balk naast de enter, nu ga ik alleen bits aanzetten als een
van de 1 is waar. Dus 00, beide
zijn onwaar. Nogmaals, ik vergelijk hier.
Ik vergelijk deze bits voor 16 en 13.
16 wordt weergegeven als binair 0 0 1 1 1 1 0 0.
13 wordt binair weergegeven 0 0 0 0 1 1 0 is 1.
Elk van die getallen staat voor een bit.
Dus het eerste bit in 60 is 0, het eerste bit in 13 is 0.
En als ik die samen bestel, 0 en 0, krijg ik toch 0. Dus dat is het eerste resultaat van het eerste bit.
Tweede bit 00 weer. Het derde bit is 1 voor 60 en
het is 0 voor 13.
Dat betekent dat ik 1 waar moet hebben, dus dat wordt een 1.
Hetzelfde geldt voor bit nummer 4 en 16, 13. Dus nu heb ik weer een 1.
En dan een 1 en 1, ze zijn allebei waar. Dus nogmaals 1, alles wat ik
nodig heb is 1 waar, nog een 1.
Beide onwaar, dus dat zal niet waar zijn. 0, onthoud is niet waar,
1 is waar en 0 11. Dus nu heb ik 0 0 1 1 1 1 0 1.
En de waarde daarvan in decimaal als ik het zou uitprinten,
is dat je opnieuw moet begrijpen hoe je binair naar
decimaal moet converteren, maar het gaat in feite 1 3
7 15 30 61. Dus dit gaat 61 afdrukken.
Beëindig dit programma en herbouw het,
en we zullen een waarde van 61 zien.
Dus dat zijn bitsgewijze operators. En nogmaals, het is een
soort van geavanceerdere programma's, maar het is een leuke manier
om veel gegevens weer te geven door ampersands enzovoort te gebruiken, in wezen door
bits aan en uit te zetten. Hier zou je dus
mee kunnen spelen. Je zou de exclusieve kunnen doen of wat de wortel is.
De wortel staat boven de 6, nummer 6 op het toetsenbord.
Je zou een ander resultaat zien. Als je de tilde zou toevoegen, zou dat in feite alles uitschakelen.
Dus voor a en a is gelijk aan 60, 0 0 1 1 1 1 0 0,
het zal niet gelijk zijn aan 1 1 0 0 0 0 1 1.
Een ander heel cool ding dat je met de binaire operatoren kunt doen,
is verschuiven, naar links en rechts verschuiven. Er zijn een paar belangrijke dingen die je weet
wanneer je naar links of rechts moet schakelen.
Allereerst weten we dat een niet-ondertekend int betekent dat dit alleen
maar positief kan zijn. Het kan niet negatief zijn.
Dus als je daar een negatieve waarde in opslaat, zal het compileren het converteren, het zal langer zijn, het zal veel grootte in beslag nemen.
Onthoud dus dat niet-ondertekende ints betekenen dat u alleen positieve waarden kunt hebben.
Getekende gehele getallen betekenen dat ze negatief of positief kunnen zijn.
Maar als je wilt verschuiven, onthoud
dan dat je naar links moet verschuiven, dus als we zeggen dat resultaat gelijk
is aan en laten we zeggen dat we a, laten we zeggen, met 2
willen verschuiven, is het
andere belangrijke dat je wilt weten wanneer je hebt de gehele
getallen, gehele getallen zijn, onthoud, ze zijn op de
meeste platforms 4 bytes. Het hangt ervan af of u de
grootte kunt krijgen door de grootte van de operator te doen. Dus het gehele getal is
in werkelijkheid 4 is 32 bits, dus het getal
is eigenlijk zoiets als dit. De 16 zoiets als
dat wat is dat 4 8 12 16 20 24.
Dus je waarschijnlijk iets dergelijks en iets dergelijks.
Dat is echt het nummer. Ik liet alleen de laatste
8 bits zien omdat de rest nullen waren. Maar als je dit bekijkt als een
32-bits geheel getal, dat 4 bytes is, dan ziet het er zo
uit in binair, 4 0s 4 0s 4 0s 4 0s 4 0s 4 0s
en dan de 0 0 1 1 1 1 0 0 .
En dus leerde je de maat kennen als je naar links
of rechts schakelt, want als je meer dan 2 verschuift, wordt het niet duidelijk.
Hij valt niet weg of iets dergelijks.
Dus nogmaals, laat me er gewoon voor zorgen dat 48 12 16
20 24 28 32 hetzelfde geldt voor 13.
Dus als je naar links zou verschuiven met een
grotere dan groter dan 2, dan zal je uiteindelijk hebben dat deze
enen ook naar links zullen verschuiven. Dus het resultaat is nog
steeds al die voorgaande nullen, maar
dan krijg je 1 1 1 1 0 0 0 0.
En dat wordt gelijk aan 240.
En als ik een snelle conversie doe, doe ik het in mijn hoofd door 1
3 7 15 30 60 122 40 te zeggen, maar we
kunnen dat bevestigen door te bouwen en te rennen en je zult
zien dat het resultaat 240 is.
En we zien dat het resultaat 240 is.
Dus als je nu echt wilt overschakelen naar mijn meer dan 2 s,
zeg dat je met 4 wilt verschuiven, dan wordt het belangrijk om te begrijpen dat het een 32-bits getal is.
Dus hier zou je eigenlijk enkele van die nullen moeten gebruiken.
Dus als je met 4 wilt verschuiven, zou je
echt zoiets hebben.
En als je ze dan per
4 wilt groeperen, heb
je zoiets. Dus het resultaat hier
zou weer zijn als ik dit in mijn hoofd
doe, je hebt 1 3 7 15 30 60
120 240 480 en dan 960.
Hopelijk heb ik dat goed gedaan. Nogmaals, als we dit uitvoeren en
we zeggen 960, dus dat
verschuift naar links. Als u naar
rechts wilt schuiven, gebruikt u de groter dan-symbolen.
Dus als je naar de rechter binaire rechter shift-operator verschuift,
doe je de grotere dan. Binaire linkerploeg operator, je doet de minder dan.
Dus hier als je naar rechts gaat, wil je naar rechts 4.
En wat gebeurt er als je het einde hier hebt, dus als je je
originele 60 hebt, probeer je 4. Je zult cijfers hebben die gewoon wegvallen.
Dus in plaats van deze laatste 4 hebben we
er oorspronkelijk weer 60. Dus we hebben
0 0 0 1 1 1 1 0 0, we moeten over 4.
Dus we gaan uiteindelijk 2 bits verliezen omdat ze gewoon afvallen.
En waar we mee
eindigen is zoiets als dit
0 0. En dit zou dus gewoon gelijk zijn
aan 3, zoiets, dus je verliest eigenlijk bits omdat je te veel naar rechts verschuift,
je hebt het resultaat van 3. Dus je moet voorzichtig zijn als
je naar links en naar rechts schuift, zorg ervoor dat je die 32
bits 4 bytes opnieuw gebruikt, afhankelijk van je systeem.
Het is een korte samenvatting van bitsgewijze operators.
Wanneer je meer gevorderd bent, moet je begrijpen hoe
je daadwerkelijk kunt controleren of een bepaald bit 1 of 0 is.
Het is vrij eenvoudig. Je doet er gewoon een en op.
Maar je moet wel wat meer code schrijven.
Deze lezing was niet bedoeld als een uitputtende kijk op bitsgewijze operators.
Ik wilde een overzicht
geven, je een goede voorsprong geven. Maar om deze operatoren beter te
begrijpen, moet je behoorlijk wat meer bestuderen en ze gebruiken en oefenen.
Dus ik hoop dat dit nuttig was. Nogmaals, het kan een beetje verwarrend zijn,
dus je wilt het volgen en ermee spelen. Maar nogmaals, wat is de beste manier om te leren,
wat code te schrijven, wat voorbeelden te leren. Dank u.