Unaire operatoren Unaire min (-) De unaire min-operator voert de rekenkundige ontkenning van zijn operand uit. De operand moet een geheel getal of een zwevende waarde zijn. Er worden standaardoperandconversies uitgevoerd. Het resultaattype is hetzelfde als het geconverteerde type

Bewerkingen De C-taal biedt bitsgewijze logische bewerkingen en schakelbewerkingen. Vervolgens schrijven we de waarden in binair formaat, zodat u kunt zien hoe de bewerkingen worden uitgevoerd. IN echte programma's geheeltallige variabelen of constanten geschreven

Bewerkingen Laten we nu eens kijken naar wat u wel en niet kunt doen met enum-waarden. U kunt een constante toewijzen aan het type enum variabele dat hetzelfde type enum katachtige pet;pet = tijger;Je kunt geen andere toewijzingsbewerkingen gebruiken: pet += cat; /* ongeldig */ Er kan een vergelijking worden gemaakt om te identificeren

4.3. Vergelijking en logische bewerkingen Bediening Symbool Betekenis Gebruik! Logisch NOT!expr kleiner dan exprexpr = Kleiner dan of gelijk aan expr=expr groter dan exprexpr = groter dan of gelijk aan expr=expr == gelijk aan expr==expr != niet gelijk aan expr!=expr logisch

De bewerkingen is en as De bewerking is wordt gebruikt om te controleren of een klassevariabele de opgegeven waarde heeft dynamisch type. Met de operator as kunt u veilig een variabele van het ene klassetype naar een ander klassetype converteren (in tegenstelling tot een expliciete klassencast).

Operators en expressies zijn opgebouwd uit bewerkingen en operanden, die worden gebruikt om een ​​waarde te verkrijgen. Laten we eens kijken naar de basisbewerkingen, die we in de volgende klassen zullen verdelen: unair, toegepast op één operand; binair, toegepast op twee operanden; ternaire operator (enkelvoudig), toegepast op drie operanden. Sommige bewerkingen zullen later eenvoudig worden opgesomd en in meer detail worden besproken.

Unaire bewerkingen:

«-» - "unaire min" wordt toegepast op rekenkundige operanden (gehele getallen, reële variabelen of constanten), het resultaat van de bewerking is de waarde van de operand met het tegenovergestelde teken;

«+» - de “unaire plus”-operatie doet niets, geïntroduceerd vanwege symmetrie met de “unaire min”-operatie;

«*» - "toegang tot het adres", de bewerking wordt toegepast op pointers, het resultaat van de bewerking is de waarde van het object (operand) waarnaar de pointer verwijst;

«&» - “een adres verkrijgen”, het resultaat van de bewerking is het adres van een object (variabel);

«~» - De “bitsgewijze negatie”-operatie is alleen van toepassing op gehele operanden; het resultaat van de operatie is een geheel getal waarin de bits van de originele operand worden omgekeerd;

«!» - “logische negatie” (“logische NOT”), resulteert in de waarde 0 als de operand waar is (niet nul), en de waarde 1 als de operand nul is (in Visual C++ is het resultaattype bool), dit zou zo moeten zijn merkte op dat in de basis-ANSI-standaard C ontbrak uitdrukkelijk een logisch type dat in plaats daarvan twee waarden zou aannemen: "true" en "false". Booleaans type In de regel werd een geheel getal gebruikt, de waarde 0 werd geïnterpreteerd als “false”, elke andere waarde dan 0 was “true”;

(<тип>) – “typeombouwoperatie” is eerder besproken;

"grootte van"– De groottebewerking is bedoeld om de grootte van een object of type in bytes te berekenen en kent twee vormen:

grootte van expressie of groottevan(uitdrukking)

groottevan(type)

Verhogen (verhogen met 1), -- - verlagen (verlagen met 1), hebben twee notatievormen: prefix, wanneer de bewerking vóór de operand wordt geschreven, en postfix. Als de operators afzonderlijk worden gebruikt (er is slechts één operator per operator), dan is er geen verschil tussen de twee formulieren. Als een bewerking binnen een uitdrukking met andere operatoren wordt gebruikt, wordt in de prefix-vorm eerst de operand gewijzigd en vervolgens wordt de nieuwe waarde ervan in de uitdrukking vervangen, en in de postfix-vorm wordt de oude waarde vervangen door de uitdrukking en vervolgens de waarde. van de operand wordt gewijzigd. Bijvoorbeeld,

int i=10, j;

j=++i; // Voorvoegsel formulier operaties

Als resultaat van de uitvoering van dit fragment, i En J zal gelijk zijn aan 11 (variabele j krijgt de nieuwe waarde van i toegewezen, verhoogd met 1), als we de vorm van de ++-bewerking veranderen:

int i=10, j;

j=i++; // Postfix-vorm van de bewerking

dan, na het uitvoeren i zal gelijk zijn aan 11, en J zal gelijk zijn aan 10, variabel J de oude waarde wordt aan de variabele toegewezen i, en vervolgens wordt het met 1 verhoogd. De bewerkingen worden meestal toegepast op operanden met gehele getallen, maar ze kunnen ook worden toegepast op echte operanden en zelfs pointers.

Binaire operaties kunnen worden onderverdeeld in de volgende klassen:

Rekenkundig:

«+» - binair plus;

«-» - binair min;

«*» - vermenigvuldiging;

«/» - divisie;

% - het verkrijgen van het restant van de deling.

De eerste vier bewerkingen zijn van toepassing op rekenkundige operanden: gehele of reële bewerkingen «+» En «-» op een beperkte manier kan worden toegepast op verwijzingen. Bediening - «%» is alleen van toepassing op gehele operanden.

Logisch:

«&&» - logische EN;

«||» - logische OF;

«^» - logische exclusieve OR.

De operanden van logische bewerkingen kunnen van een rekenkundig type zijn of pointers zijn, en de operanden in elke bewerking kunnen verschillende soorten. Er worden geen typeconversies uitgevoerd; elke operand wordt geëvalueerd in termen van zijn gelijkwaardigheid aan nul (operand, gelijk aan nul, wordt beschouwd als “onwaar”, niet gelijk aan nul – als “waar”). In Visual C++ is het resultaattype int of bool afhankelijk van het type operanden.

Bitsgewijs:

«&» - bitsgewijze EN;

«|» - bitsgewijze OF;

«^» - bitgewijs exclusieve OR;

«>>» - bitgewijze verschuiving naar rechts;

«<<» - bitsgewijs naar links verschuiven.

Deze bewerkingen zijn alleen van toepassing op gehele operanden en werken op hun binaire representaties. Bij het uitvoeren van bewerkingen «&», «|», «^» operanden worden bitsgewijs afgebeeld (het eerste bit van de eerste operand naar het eerste bit van de tweede, het tweede bit van de eerste operand naar het tweede bit van de tweede, enz.).

Verschuifbewerkingen verschuiven de binaire representatie van de eerste operand naar links of rechts met het aantal binaire cijfers gespecificeerd door de tweede operand. Bij het naar links schakelen «<<» vrijgekomen cijfers worden op nul teruggezet. Bij het schakelen naar rechts «>>» de vrijgekomen bits worden gevuld met nullen als de eerste operand niet ondertekend is, en anders met een ondertekende bit.

Relaties (vergelijkingen):

“==” - is gelijk aan (niet te verwarren met de toewijzingsoperator “=”);

“!=” - niet gelijk;

">" - meer;

«<» - меньше;

“>=” - groter dan of gelijk aan;

«<=» - меньше или равно.

Relationele operatoren vergelijken de eerste operand met de tweede. De operanden kunnen van een rekenkundig type zijn of van pointers. Het resultaat van de bewerking is de waarde ‘true’ (elke waarde die niet gelijk is aan 0, meestal 1) of ‘false’ (0). In Visual C++ is het resultaattype bool.

Opdrachten:

"=" is een eenvoudige opdracht.

De eerste operand moet een L-waarde zijn; het geheugengebied waar het resultaat van de bewerking wordt opgeslagen. de tweede - door expressie. Eerst wordt de uitdrukking aan de rechterkant van de bewerking berekend en vervolgens wordt het resultaat ervan naar het geheugengebied geschreven dat aan de linkerkant wordt aangegeven. De zogenaamde , L-waarde(links geldige waarde, kan links van de toewijzingsbewerking worden gebruikt), dit is de aanduiding van elke expressie die een bepaald geheugengebied adresseert waarin een waarde kan worden opgeslagen.

op= (waarbij op een symbool is van een binaire bewerking) is een gecombineerde toewijzing, een combinatie van een binaire bewerking met een toewijzingsbewerking, bijvoorbeeld “+=” is een toewijzing met optelling, naar analogie zijn er bewerkingen: “* =”, “/=”, “-= ", "%=", "&=", "|=", "^=", etc. Gecombineerde bewerkingen werken volgens de volgende regel:

ik+=10; op soortgelijke wijze i=i+10;

Andere binaire bewerkingen, laten we ze gewoon opsommen:

() – functieaanroep;

– toegang tot een array-element;

"." (“dot”) – toegang tot een veld van een variabele van een structuurtype;

“->” - toegang tot een veld van een variabele van een structuurtype via een aanwijzer;

“,” (“komma”) – sequentiële berekening, kan tussen expressies worden geplaatst, expressies worden opeenvolgend berekend, het resultaat van de bewerking is het resultaat van de tweede operand (expressie).

Ternaire werking:

“?:” is een voorwaardelijke bewerking.

Formaat:<операнд1> ? <операнд2> : <операнд3>

De eerste operand heeft een type dat een logische operand vervangt: rekenkunde of aanwijzer heeft de waarde "true", dan is het resultaat van de bewerking de waarde van de tweede operand, en als "false" het resultaat is; van de bewerking is de waarde van de derde operand. Voorbeeld,

y= x>=0 ? x: -x;

aan variabele y wordt de moduluswaarde van variabele x toegewezen.

C gebruikt de volgende notatie voor logische bewerkingen:

|| logische "of" (logische toevoeging)

&& logische "en" (logische vermenigvuldiging)

Logisch "niet" (logische ontkenning)

De logische constanten ‘waar’ en ‘onwaar’ worden aangegeven met waar en onwaar (dit zijn taaltrefwoorden). Voorbeelden van logische expressies:

bool a, b, c, d;

a = b || C; // logische "of"

d = b && c; // logische "en"

a = !b; // logisch "niet"

a = (x == y); // vergelijking aan de rechterkant

a = onwaar; // leugen

b = waar; // WAAR

c = (x > 0 && y != 1); // c is waar wanneer

// beide vergelijkingen zijn waar

Logische negatie heeft de hoogste prioriteit, gevolgd door logische vermenigvuldiging, en logische optelling heeft de laagste prioriteit.

Unaire en binaire bewerkingen

Op basis van het aantal operanden dat bij de bewerking betrokken is, worden bewerkingen onderverdeeld in unair, binair en ternair.

De C-taal heeft de volgende unaire bewerkingen:

Rekenkundige negatie (negatie en optelling);

~ bitsgewijze logische negatie (complement);

Logische ontkenning;

* de-adressering (indirecte adressering);

&adresberekening;

Unair plus;

Verhogen (verhoging);

Verlagen (verlagen);

maat van maat.

Unaire bewerkingen worden van rechts naar links uitgevoerd.

Verhogings- en decrementbewerkingen verhogen of verlagen de waarde van de operand met één en kunnen naar rechts of naar links van de operand worden geschreven. Als het bewerkingsteken vóór de operand ( voorvoegsel vorm), wordt de operand gewijzigd voordat deze in de expressie wordt gebruikt. Als het bewerkingsteken na de operand ( postfix-formulier), wordt de operand eerst in de uitdrukking gebruikt en vervolgens gewijzigd.

Een voorvoegselformulier

A++ postfix-formulier

#erbij betrekken

#erbij betrekken

(//toont verschillen in uitdrukkingen

printf("a = %d b = %d \n",a,b);

printf("a = %d b = %d \n",a++,++b);

Resultaat

In tegenstelling tot unair binaire operaties, waarvan de lijst in de tabel staat, worden van links naar rechts uitgevoerd.

Tafel

De linkeroperand van de toewijzingsbewerking moet een expressie zijn die verwijst naar een geheugenlocatie (maar niet een object dat is gedeclareerd met het trefwoord const). Dergelijke expressies worden links-toelaatbaar genoemd en omvatten:

Gegevensidentificatoren van integer- en zwevende typen, pointertypen, structuur, unie;

Indexexpressies, met uitzondering van expressies van het array- of functietype;

Elementselectie-expressies (->) en (.) als het geselecteerde element geldig blijft;

Unaire unaddress-operatorexpressies (*), met uitzondering van expressies die verwijzen naar een array of functie;

Een type cast-expressie als het resulterende type de grootte van het oorspronkelijke type niet overschrijdt.

Houd er bij het schrijven van uitdrukkingen rekening mee dat de symbolen (*), (&), (!), (+) een unaire of binaire bewerking kunnen aanduiden.

Type conversie

Bij het uitvoeren van bewerkingen vinden impliciete typeconversies plaats in de volgende gevallen:

Bij het uitvoeren van bewerkingen worden de gebruikelijke rekenkundige transformaties (die hierboven zijn besproken) uitgevoerd;

Als bij het uitvoeren van toewijzingsbewerkingen een waarde van het ene type wordt toegewezen aan een variabele van een ander type;

Bij het doorgeven van argumenten aan een functie.

Bovendien kunt u met C expliciet een waarde van het ene type naar het andere casten.

Bij toewijzingsbewerkingen wordt het type waarde dat wordt toegewezen geconverteerd naar het type variabele dat die waarde ontvangt. Conversies van integer- en drijvende-kommatypen zijn toegestaan, zelfs als een dergelijke conversie tot informatieverlies leidt.

Typen gehele getallen met teken converteren. Een geheel getal met teken wordt geconverteerd naar een geheel getal met een korter teken door de meest significante bits af te kappen. Een geheel getal met teken wordt door middel van tekenvermenigvuldiging omgezet in een langer geheel getal met teken. Bij het converteren van een geheel getal met teken naar een geheel getal zonder teken, wordt het gehele getal met teken geconverteerd naar de grootte van het gehele getal zonder teken en wordt het resultaat behandeld als een waarde zonder teken.

Het converteren van een geheel getal met teken naar een float gebeurt zonder verlies van informatie, behalve bij het converteren van een lange int of een lange int zonder teken naar een float, waarbij precisie vaak verloren kan gaan.

Niet-ondertekende gehele typen converteren. Een geheel getal zonder teken wordt geconverteerd naar een korter geheel getal zonder teken of teken door de meest significante bits af te kappen. Een geheel getal zonder teken wordt geconverteerd naar een langer geheel getal zonder teken of teken door nullen aan de linkerkant op te vullen.

Wanneer een geheel getal zonder teken wordt geconverteerd naar een geheel getal met teken van dezelfde grootte, wordt de bitrepresentatie niet gewijzigd. Daarom verandert de waarde die het vertegenwoordigt als het tekenbit is ingesteld (gelijk aan 1), d.w.z. wanneer het oorspronkelijke geheel getal zonder teken groter is dan het maximale gehele getal met positieve teken van dezelfde lengte.

Niet-ondertekende gehele waarden worden geconverteerd naar een float-type door het niet-ondertekende gehele getal te converteren naar een ondertekende lange waarde en vervolgens de ondertekende lange waarde te converteren naar een float-type. Conversies van niet-ondertekend long naar float, double of lange dubbele worden geproduceerd met verlies van informatie als de waarde die wordt omgezet groter is dan de maximale positieve waarde die kan worden weergegeven voor het lange type.

Zwevende typeconversies. Waarden van het type float worden omgezet naar het type double zonder de waarde te wijzigen. Dubbele en lange dubbele waarden worden met enig verlies aan precisie omgezet naar zwevend. Als de waarde te groot is voor een float, treedt er underflow op en wordt dit tijdens runtime gerapporteerd.

Bij het converteren van een waarde met drijvende komma naar typen met gehele getallen, wordt deze eerst geconverteerd naar een long (het fractionele deel van de waarde met drijvende komma wordt weggegooid) en vervolgens wordt de lange waarde geconverteerd naar het gewenste integer-type. Als de waarde langdurig te groot is, is het resultaat van de conversie ongedefinieerd.

Conversies van float, double of long double naar niet-ondertekend type long wordt geproduceerd met verlies aan precisie als de omgerekende waarde groter is dan de maximaal mogelijke positieve waarde die wordt weergegeven door het lange type.

Conversie van aanwijzertype. Een pointer naar een waarde van het ene type kan worden geconverteerd naar een pointer naar een waarde van een ander type. Het resultaat kan echter onzeker zijn vanwege verschillen in uitlijning en maatvereisten tussen typen.

Wijzer naar typ leegte kan worden geconverteerd naar een pointer naar elk type, en een pointer naar elk type kan zonder beperkingen worden geconverteerd naar een pointer naar type void. De pointerwaarde kan worden geconverteerd naar een geheel getal. De conversiemethode is als volgt afhankelijk van de grootte van de aanwijzer en de grootte van het gehele type:

Als de grootte van de aanwijzer kleiner is dan of gelijk is aan de grootte van het integer-type, wordt de aanwijzer op precies dezelfde manier geconverteerd als een geheel getal zonder teken;

Als de pointer groter is dan de grootte van het integer-type, wordt de pointer eerst geconverteerd naar een pointer met dezelfde grootte als het integer-type en vervolgens geconverteerd naar het integer-type.

Een geheel getaltype kan met behulp van de volgende regels worden geconverteerd naar een adrestype:

Als het gehele type even groot is als de aanwijzer, wordt de gehele waarde eenvoudigweg behandeld als een aanwijzer (een geheel getal zonder teken);

Als de grootte van een geheel getaltype verschilt van de grootte van een aanwijzer, wordt het gehele type eerst geconverteerd naar de grootte van de aanwijzer (met behulp van de hierboven beschreven conversiemethoden) en vervolgens wordt de resulterende waarde behandeld als een aanwijzer.

Transformaties bij het aanroepen van een functie. De conversies die worden uitgevoerd op de argumenten bij het aanroepen van een functie zijn afhankelijk van het feit of er een functieprototype (een voorwaartse declaratie) is gespecificeerd met een lijst met argumenttypedeclaraties.

Als er een functieprototype wordt gegeven en deze argumenttypedeclaraties bevat, worden alleen normale rekenkundige conversies uitgevoerd op de argumenten in de functieaanroep.

Deze conversies worden voor elk argument onafhankelijk uitgevoerd. Waarden van het type float worden geconverteerd naar double, waarden van het type char en short worden geconverteerd naar int, waarden van het type unsigned char en unsigned short worden omgezet naar unsigned int. Impliciete conversies kunnen ook worden uitgevoerd op pointervariabelen. Door functieprototypen op te geven, kunt u deze impliciete conversies overschrijven en de compiler typecontrole laten uitvoeren.

Conversies bij het casten van typen. Expliciete typeconversie kan worden bereikt met behulp van een typecast-bewerking, die het formaat heeft:

(typenaam) operand.

In de volgende notatie specificeert typenaam het type waarnaar de operand moet worden geconverteerd.

int i=2; lang l=2; dubbele d; zweven f; d=(dubbel)i * (dubbel)l; f=(zweven)d; In dit voorbeeld worden de waarden i,l,d expliciet omgezet naar de typen die tussen haakjes staan ​​aangegeven.

Eendimensionale en multidimensionale arrays.

Programma's moeten vaak grote volumes van hetzelfde type gegevens verwerken. Het gebruik van reguliere variabelen hiervoor is erg lastig: stel je 1000 variabelen voor met verschillende namen en hetzelfde type die niet in een lus kunnen worden verwerkt. Dit probleem kan worden opgelost door arrays te gebruiken.

Array– een reeks variabelen (elementen) van hetzelfde type en een gemeenschappelijke naam. Toegang tot array-elementen uitgevoerd door simpelweg het elementnummer op te geven - index.

In de C-taal begint de nummering van array-elementen vanaf nul!

Voorbeelden van array-declaraties:

int a; // Integer array a, grootte – 10 elementen

dubbele vect; // Array echte cijfers vect, het heeft 20 elementen

teken str; // Karakterarray met 1024 elementen

Bij het declareren van een array kunt u onmiddellijk de gewenste waarden aan de elementen ervan toewijzen (d.w.z. de array initialiseren):

int x = (10, 20, 30, 40, 50);

char str = “Hallo!”; // Automatisch

int a = (1, 2, 3); // bepaal de maat

Voorbeelden van toegang tot array-elementen:

printf(“%d\n”,x);

scanf(“%d”, &x);

Er zijn drie bitsgewijze logische bewerkingen in C++:

1. bitsgewijze EN, symbool: &
2. bitsgewijs exclusieve OR, notatie: ^
3. bitsgewijs inclusief OR, aanduiding: |

Ook in C++ zijn er: OR - || ; EN - && . Veel mensen hebben een vraag: “Wat is het verschil tussen de bewerkingen: & en && ; | en || ? Het antwoord op deze vraag kan worden verkregen als u het werkingsprincipe van bitsgewijze logische bewerkingen begrijpt. Ik kan meteen één ding zeggen: de logische bewerkingen && en || worden alleen gebruikt voor het construeren van logische voorwaarden. Terwijl bitsgewijze logische bewerkingen worden gebruikt in binaire rekenkunde. Deze bewerkingen werken met bits van geheugencellen, en de operanden en het resultaat kunnen in een andere vorm worden gespecificeerd, bijvoorbeeld in decimaal. Vervolgens zullen we elk van de bewerkingen in detail bekijken.

Bitsgewijze logische AND-bewerking.
Benamingen: X, Y – operanden; F – uitvoeringsresultaat logische werking

Uit de waarheidstabel kunnen we zien dat het resultaat nul zal zijn als ten minste één van de bits 0 is. Als beide bits 1 zijn, dan is het resultaat 1.
Voorbeeld met cijfers:
Om de berekeningen te vereenvoudigen, nemen we vier bits (4 bits binaire code) positieve operanden. Eerst zetten we de getallen om in binaire code en daarna voeren we de bewerking uit.

1111 = 15 1000 = 8
& 1001 = 9 & 1010 = 10
1001 = 9 1000 = 8
Het resultaat is 9. Het resultaat is 8.

Bitwise exclusief OF .

De waarheidstabel laat zien dat het resultaat nul zal zijn als beide bits gelijk zijn, in alle andere gevallen zal het resultaat 1 zijn.
Voorbeeld met cijfers:

1111 = 15 1000 = 8
^ 1001 = 9 ^ 1010 = 10
0110 = 6 0010 = 2
Het resultaat is 6. Het resultaat is 2.

Bitsgewijs inclusief OF .

De waarheidstabel laat zien dat het resultaat nul zal zijn als beide bits 0 zijn, in alle andere gevallen zal het resultaat 1 zijn.
Voorbeeld met cijfers:

1111 = 15 1000 = 8
| 1001 = 9 | 1010 = 10
1111 = 15 1010 = 10
Het resultaat is 15. Het resultaat is 10.

Alle berekeningen zijn alleen uitgevoerd met positieve cijfers Wat negatieve getallen betreft, wordt het resultaat enigszins anders gevormd, maar dit is het materiaal van het circuitontwerp en niet van programmeren, en om eerlijk te zijn is daar niets ingewikkelds aan. Het volgende is een voorbeeldprogramma dat bitsgewijze logische bewerkingen gebruikt.

// log.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include << "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; system("pause"); return 0; }

// code Code::Blokken

// Dev-C++-code

// log.cpp: Definieert het toegangspunt voor de consoletoepassing. #erbij betrekken naamruimte std gebruiken; int main(int argc, char* argv) ( cout<< "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; return 0; }

Bij gebruik van bitsgewijze logische bewerkingen in logische omstandigheden is het resultaat hetzelfde als bij gebruik van logische bewerkingen && || . En dit is begrijpelijk, aangezien hun logica dezelfde is!!

In C++ komt een valse voorwaarde overeen met een nulwaarde, en een echte voorwaarde met een geheel getal groter dan nul. Dus de constanten waar en onwaar worden geïnterpreteerd als gehele getallen, en vervolgens vormen bitsgewijze logische bewerkingen het resultaat van de voorwaarde, bitsgewijze. Maar het directe doel van bitsgewijze logische bewerkingen is binaire rekenkunde. Het resultaat van het programma (zie figuur 1).

15 & 9 = 9 15 ^ 9 = 6 15 | 9 = 15 Druk op een willekeurige toets om door te gaan. . .

Figuur 1 - C++ bitsgewijze logische bewerkingen