Voorbeeld 1:
De code begint hier met het opnemen van het headerbestand “iostream”. Zoals de naam al doet vermoeden, is dit headerbestand bedoeld voor de invoer- en uitvoerfuncties, zoals deze functies erin worden gedeclareerd. Dan hebben we de “namespace std” waarin deze functies zijn gedefinieerd.
Hieronder noemen we de methode “main()”. We initialiseren de “x” variabele van het type “int” en kennen “10” toe aan deze “x”. Vervolgens hebben we nog een variabele, “y”, van het gegevenstype “int” en wijzen we “6” toe. Hierna initialiseren we “r” van het datatype “int”. Hier passen we de “XOR”-bewerking toe op de waarden van de variabelen “x” en “y” door de operator “^” tussen deze variabelen te plaatsen. Deze “XOR”-operator converteert de gehele waarden naar het binaire bestand, past de “XOR”-bewerking toe op de binaire waarden en slaat het resultaat op als de gehele waarde. De uitkomst van deze “XOR”-operator wordt nu opgeslagen in “r”.
Hierna geven we de waarden van deze variabelen afzonderlijk weer en geven vervolgens het resultaat weer dat we krijgen na het toepassen van de ‘XOR’-operator met behulp van ‘cout’.
Code1:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
int X = 10 ;
int En = 6 ;
int R = X ^ En ;
uit << 'De waarde van x : ' << X << eindl ;
uit << 'De waarde van y : ' << En << eindl ;
uit << 'De XOR x ^ y = ' << R << eindl ;
opbrengst 0 ;
}
Uitgang:
Aangezien de binaire waarde van “10” “1010” is en de binaire waarde van “6” “0110” is, retourneert deze “12” na toepassing van de “XOR”-operator en is “1100” de binaire waarde van “12”. Dit laat zien dat het “1” retourneert als beide ingangen verschillend zijn, en “0” retourneert als beide ingangen hetzelfde zijn.
Voorbeeld 2:
Na het toevoegen van het “iostream” headerbestand en de “std” naamruimte, roepen we de “main()” methode aan. Vervolgens initialiseren we twee variabelen, 'X1' en 'X2', en wijzen respectievelijk de gehele waarden '21' en '35' toe aan deze variabelen. Vervolgens drukken we de waarden van beide variabelen af. Hierna passen we de operator “XOR” toe op deze gehele waarden. We passen deze “XOR” -bewerking toe op deze “X1” en “X2” variabelen binnen de “cout”. Het resultaat van deze “XOR” wordt dus ook als uitkomst weergegeven.
Code2:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
int X1 = eenentwintig , X2 = 35 ;
uit << 'X1-waarde = ' << X1 << eindl ;
uit << 'X2-waarde = ' << X2 << eindl ;
uit << 'Het XOR-resultaat is: ' << eindl ;
uit << 'X1^X2 = ' << ( X1 ^ X2 ) << eindl ;
opbrengst 0 ;
}
Uitgang:
De eerste gehele waarde is “21” en de tweede is “35”. Na het toepassen van de “XOR” -bewerking krijgen we het “54” resultaat dat hier wordt weergegeven.
Voorbeeld 3:
We roepen de “main()”-methode aan na het toevoegen van het “iostream” headerbestand en de “std” naamruimte. De variabele “n1” van het type “int” wordt geïnitialiseerd en hieraan wordt “29” toegewezen. Vervolgens wijzen we “75” toe aan een andere variabele, “n2”, die van het datatype “int” is. Vervolgens initialiseren we de waarde van “r1″ en die van het gegevenstype “int”.
Vervolgens passen we de “XOR”-bewerking toe op de waarden van de variabelen “n1” en “n2” door de operator “^” ertussen te plaatsen. De gehele waarden worden geconverteerd naar binair met behulp van deze “XOR”-operator, die vervolgens de “XOR”-bewerking op de binaire gegevens toepast en de uitkomst opslaat als een geheel getal. De variabele “r1” bevat nu de uitkomst van deze “XOR”-bewerking. De waarden van elk van deze variabelen worden vervolgens afzonderlijk weergegeven. We laten ook het resultaat zien van het gebruik van de ‘XOR’-operator met behulp van de ‘cout’-operator.
Code 3:
#includenamespace std; gebruiken ;
int voornaamst ( )
{
int n1 = 29 ;
int n2 = 75 ;
int r1 = n1 ^ n2 ;
uit << 'De eerste waarde: ' << n1 << eindl ;
uit << 'De tweede waarde: ' << n2 << eindl ;
uit << 'De uitkomst van de XOR-operator is: ' << r1 << eindl ;
opbrengst 0 ;
}
Uitgang:
De ingevoerde gehele getallen zijn “29” en “75”, die worden omgezet in binair getal. Vervolgens wordt de “XOR”-bewerking daarop toegepast. Na toepassing van “XOR” is het resultaat “86”.
Voorbeeld 4:
In deze code krijgen we de invoer van de gebruiker en passen vervolgens de 'XOR' -bewerking toe op de invoerwaarden van de gebruiker. De drie variabelen worden hier gedeclareerd met de namen “Xvalue1”, “Xvalue2” en “Xvalue3”. Vervolgens plaatsen we de 'cout' en geven we het bericht 'Voer hier twee waarden in' weer.
Nadat dit bericht is weergegeven, voert de gebruiker de waarden in die we krijgen met de hulp van de cin. Dus plaatsen we “cin” hieronder. Beide waarden worden nu in deze variabelen opgeslagen en worden hier ook weergegeven. Nu moeten we de bewerking “XOR” toepassen, dus voegen we de operator “^” in tussen de variabelen “Xvalue1” en “Xvalue2”.
Nu wordt deze “XOR” -bewerking toegepast op de waarden van deze variabelen. De uitkomst van deze “XOR”-operator wordt vervolgens opgeslagen in de “Xvalue3”-variabele. We geven het ook weer met behulp van de “cout”-methode.
Code 4:
#includenamespace std; gebruiken ;
int voornaamst ( )
{
int Xwaarde1 , Xwaarde2 , Xwaarde3 ;
uit << 'Voer hier twee waarden in: ' << eindl ;
uit << 'Xwaarde1: ' ;
aan het eten >> Xwaarde1 ;
uit << 'Xwaarde2: ' ;
aan het eten >> Xwaarde2 ;
Xwaarde3 = Xwaarde1 ^ Xwaarde2 ;
uit << ' \N Nu, na het toepassen van XOR op beide waarden: ' << eindl ;
uit << 'Xwaarde1 ^ Xwaarde2 = ' << Xwaarde3 << eindl ;
}
Uitgang:
Wanneer we deze code uitvoeren, wordt er een bericht afgedrukt voor het invoeren van twee waarden. We voeren dus ‘14’ in als de waarde van de variabele ‘Xwaarde1’ en ‘45’ als de waarde van de variabele ‘Xwaarde2’. Vervolgens klikken we op 'Enter'. De “XOR”-bewerking wordt vervolgens op deze waarden toegepast, waardoor beide waarden in binair getal worden omgezet en vervolgens het resultaat hier wordt weergegeven.
Voorbeeld 5:
We passen deze 'XOR' -bewerking toe op de tekengegevens. We initialiseren twee “char”-variabelen met de namen “ch_a” en “ch_b”. We kennen respectievelijk “a” en “8” toe aan deze variabelen. Vervolgens plaatsen we de operator '^' tussen 'ch_a' en 'ch_b' en wijzen deze toe aan de variabele 'ch_result', die ook het gegevenstype 'char' is. Deze tekens worden omgezet in binair getal en het resultaat wordt opgeslagen in de variabele “ch_result”. Vervolgens printen we beide variabelen en het resultaat van deze “XOR”-bewerking.
Code 5:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
verkoold ch_a = 'A' ;
verkoold ch_b = '8' ;
verkoold ch_resultaat = ch_a ^ ch_b ;
uit << 'Het eerste teken is: ' << ch_a << eindl ;
uit << 'Het tweede teken is: ' << ch_b << eindl ;
uit << 'Het resultaat is : ' << ch_resultaat << eindl ;
}
Uitgang:
De invoertekens zijn “a” en “8” en het resultaat van “XOR” wordt weergegeven als “Y”, wat we krijgen na het toepassen van de “XOR”-bewerking die “a” en “8” omzet in binair getal en vervolgens de “ XOR”-bewerking.
Conclusie
De “XOR”-operatie wordt hier grondig onderzocht en we hebben uitgelegd dat het een “bitsgewijze” operatie is, omdat deze de binaire waarden gebruikt. We hebben besproken dat alle waarden die we hebben ingevoerd om de “XOR”-bewerking toe te passen, worden omgezet in binaire waarden, en dat vervolgens de “XOR”-bewerking wordt uitgevoerd. We hebben verschillende voorbeelden gedemonstreerd en laten zien hoe de “XOR” -bewerking werkt in C++-programmering.