5 Absolute Beginners – Le operazioni binarie, algebra di Boole e dintorni

Livello: principianti
Prerequisiti: aver completato le lezioni precedent

Chi è il signor Boole?

Il signor George Boole, è un matematico Inglese vissuto a metà dell’800 uno dei tanti geni della rivoluzione industriale. Se volete leggere di più su di lui, George Boole Su Wikipedia ha trascorso la sua breve vita come professore e ha scritto svariati capitoli fondamentali della matematica moderna. Per noi programmatori, una piccola parte del suo lavoro, l’Algebra di Boole, è quello che fa girare buona parte del mondo dell’informatica. Algebra di Boole su Wikipedia

L’algebra di boole stabilisce le regole matematiche fondamentali di interazione dei numeri in notazione binaria. La notazione binaria prevede l’uso delle sole cifre 1 e 0 per descrivere qualsiasi numero (i bit, poi raggruppati in byte, e rappresentanti con i loro soli valori 0 e 1 sono alla base di tutto quello che è la comunicazione e la registrazione digitale moderna) è strano pensare che al giorno d’oggi, usando solo le due cifre 0 e 1 possiamo rappresentare qualsiasi cosa, dalla lista della spesa fino alle immagini inviate dalle sonde spaziali dei pianeti esterni del sistema solare.

L’algebra di Boole definisce una serie di operatori logici ed il loro funzionamento. Gli operatori principali, tramite cui poi per traslazione funziona tutta la logica dei programmi per i computer sono AND, OR, NOT. A cui si aggiunge lo XOR = Or Esclusivo, questi operatori sono utilizzati da tutti i linguaggi di programmazione attualmente in uso per due tipi di azioni:

1. Effettuare operazioni logiche sui numeri binari
2. Utilizzare le regole booleane per effettuare operazioni logiche e gestire logiche decisionali all’interno dei programmi.

In questa lezione analizzeremo gli operatori logici binari.

Bit, Byte e dintorni

L’elettronica digitale, da cui deriva il mondo della comunicazione globale, da cui deriva il termine “nativi digitali” parte dalla definizione del Professor Boole e da due cifre 1 e 0, ovvero il Bit. tramite i bit e la loro associazione possiamo rappresentare la realtà all’interno dei sistemi elettronici.

Che cos’è il Byte, che di certo avete sentito nominare nella definizione delle quantità di memoria di lavoro e della memoria di massa delle vostre device digitali (un telefono da 16 giga[byte]) un PC con 8Giga(byte) di Ram e 1Tera(byte) di hard disk.

Il Byte è una serie di 8 bit che definisce l’unita funzionale di dati di base per i moderni microprocessori, il Byte è un numero che può andare da 0 a 0xFF ovvero da zero a 2E+8 quindi 255. Quando i primi microprocessori sono stati creati, si è partiti dall’usare 4 bit per passare a 8 e da allora non è cambiata l’unità fondamentale utilizzata per la creazione dei dati base funzionali dei processori. Perché 8 bit e non 10? non ne ho la più pallida idea, suppongo si trattasse di qualcosa che era naturalmente facile da utilizzare agli ingegneri che fisicamente progettavano e costruivano i circuiti integrati. Direi che dovreste indagare sul fatto sempre sulla solita Wikipedia e cercare le definizioni di TTL=TransistorTransistorLogic e di C-MOS, MOS-FET e le successive implementazioni dei circuiti su materiale semiconduttore. Di certo era una delle materie che mi piacevano molto quando qualche migliaio di anni fa studiavo a scuola Tecnologia delle costruzioni elettroniche.

Vi ricordo che, la quantità di memoria (volatile o di massa) viene espressa in byte e multipli del byte, mentre la banda di trasmissione digitale, viene espressa in bit e multipli del bit, pertanto mentre 1MegaByte sono 1Milione di bytes, 1Mega in fatto di connessione Internet sono 1 milione di bit, per ottenere i byte bisogna dividere per 8. (Non c’entra con la lezione di oggi, ma così per confondervi un po’). Per inciso, un Megabyte dovrebbe essere 1024 al quadrato quindi 1.048.576 byte, ma i commercianti che dalla notte dei tempi cercano sempre di guadagnare, hanno piegato un po’ le cifre e quindi un mega è diventato 1000 x 1024 che in realtà sono 977 kilo, allo stesso modo quando provate a guardare la dimensione del vostro disco da 1 terabyte vedrete che sono 977 giga e non 1024 come dovrebbero (sto blaterando e lo so ma perdonatemi).

A cosa ci servono queste disquisizioni parlando di algebra di Boole e di programmazione? Per esempio ci servono a imparare le operazioni fondamentali applicate ai bit e capire perché a volte, è facile chiedere ad un computer una cosa sbagliata e quindi lui fa quello che gli chiediamo e non quello che vogliamo e come sempre Non funziona. Non è vero, lui funziona sempre, siamo noi che non sappiamo dirgli le cose giuste. Stampatevelo su un quadretto e leggetevelo ogni mattina se volete fare il programmatore.

I tipi fondamentali di dati che abbiamo visto da quanti byte sono composti?

byte = 1byte

char = 2byte

Una micro parentesi sul char, attenzione, nei vecchi sistemi e nel vecchio C che era nato quando i computer funzionavano a 8 bit, il char rappresentazione binaria di 1 carattere alfanumerico, era lungo un byte, perché i caratteri erano rappresentati nella notazione ASCII (la trovate sulla solita Wikipedia) che prevedeva che i caratteri andassero rappresentati con una cifra compresa fra 0 e 255. Sfortunatamente, se questo può bastare per i caratteri latini, inserendo solo gli accentati di base, questo non basta a rappresentare tutti i linguaggi più complessi che si scrivono nel mondo, ecco perché è stata creata la notazione Unicode (Wikipedia vi racconta tutto in merito) che permette di rappresentare i caratteri di qualsiasi lingua utilizzando 2 byte. Ecco perché i char di C# sono lunghi 2 byte.

short = 2 byte

int = 4 byte

long = 8 byte

float = 4 byte

double = 8byte

decimal = 16byte

Ed ora passiamo alle operazioni di base sui bit che compongono un byte.

L’AND binario Operatore & (ampersand)

L’operazione di AND logico fra due numeri binari, dice che, eseguendo l’ AND fra due bit, il risultato è 1 se entrambi gli elementi sono a 1 ed è 0 altrimenti.

1 & 1 = 1    0 & 0 = 0   0 & 1 = 0   1 & 0 = 0

A cosa mi serve fare le operazioni sui bit? Servirà a tutti coloro che vogliono scrivere programmi per giochi, servirà a chi vuole scrivere programmi per device hardware, servirà a chi vuole scrivere programmi per le macchine utensili e sicuramente vi servirà per divertirvi se volete.

Se invece di fare l’AND (&) su un singolo bit lo facciamo su un numero di bit maggiore?

01011111 & 10001110 = 00001110

Questo è’ l’AND fra 2 byte, ogni byte è rappresentato da 8 bit.

L’ Or binario Operatore | (pipe)

Adesso finalmente sapete a cosa serve il pipe, il carattere che solitamente si trova assieme al tasto \ (backslash) il pipe è l’operatore usato per rappresentare l’ Or binario. Il risultato dell’operazione logica di OR è 1 se almeno uno dei due operandi è 1 ed è 0 altrimenti infatti OR in inglese significa oppure. In realtà la sua funzione quando i dinosauri informatici come me lavoravano in DOS era permettere di concatenare i comandi in modo che l’output di un comando fosse l’input di un altro, da qui il nome Pipe (Tubo) del carattere ma si tratta sempre delle mie chiacchiere da dinosauro, scusatele.

1 | 1 = 1    1 | 0 = 1     0 | 1 = 1     0 | 0 = 0

A cosa serve l’OR binario? come l’AND ha un uso specifico per chi costruisce programmi che lavorano a basso livello con i sistemi, si interfacciano con macchinari, sicuramente nei giochi e comunque in applicazioni dove per ottimizzare le cose bisogna compattare al massimo tutti i dati.

Cosa succede se facciamo l’OR su più bit?

01011111 | 10001110 = 11011111

Usando i due byte che abbiamo usato anche per l’AND questo è il risultato.

L’ Exclusive Or XOR Operatore ^

Anche l’ accento circumflesso stranamente ha un uso in C#, l’ operatore XOR esegue un Or esclusivo. Il risultato dell’operazione logica di XOR è 1 se gli operandi sono diversi, altrimenti vale 0.

1 ^ 1 = 0     1 ^ 0 = 1     0 ^ 1 = 1     0 | 0 = 0

A cosa serve lo XOR fisicamente? è sempre un operatore legato ad operazioni effettuate a basso livello o in colloquio con hardware, se vogliamo lavorare su strutture composite in cui ogni bit ha un significato.

Il NOT binario, ovvero negare un bit !

Questo operatore è definito in C# solo per gli operatori booleani (bool o boolean è un tipo di dato che può assumere solo 2 valori true e false 1 o 0) è un operatore unario, quindi ha un solo operando:

!1 = 0    !0 = 1    !true = false    !false = true

Il NOT sui numeri, operatore Complemento ~

L’operatore di complemento unario, funziona ugualmente al NOT ma inverte tutti i bit di un numero intero al loro inverso. lavora sui Bit che compongono i byte, ed anche questo è un operatore unario pertanto:

~11111111 = 00000000     ~10101010 = 01010101

Oltre a questi operatori binari, C# ne definisce altri due che sono prettamente legati al modo in cui sono fatti i computer, quindi a come è fatto il byte. si tratta degli operatori di SHIFT binario:

Gli operatori Left Shift << e Right Shift >>

Gli operatori di Shift, destro e sinistro, data una cifra binaria spostano a sinistra o a destra i bit che li compongono.

10001000 << 2 = 00100000  

In questo caso lo shift a sinistra ha eliminato il bit a uno più significativo ed ha spostato di 2 posti il quarto bit che è passato dal valere 2 alla quarta a 2 alla sesta.

10001000 >> 2 = 00100010

Lo shift destro effettua l’operazione opposta.

Il complemento a 2

Come semplice informazione, nel caso la cosa possa servirvi, quest’ultima definizione, il Complemento a 2 fa sempre parte di quanto stabilito dal signor Boole nell’algebra dei numeri in base due. Il Complemento a 2 viene utilizzato da .Net e da buona parte dei calcolatori elettronici per la rappresentazione dei numeri interi negativi. Pertanto, se guardassimo i bit che rappresentano il numero 2 ed il numero -2 in memoria non troveremmo come potremmo aspettarci

00000010 = 2 e 100000010 = -2

Invece il -2 verrebbe rappresentato come complemento a 2 di 2, cos’ è il complemento a 2? Si complementa un numero binario e gli si somma 1.

00000010 = 2 11111101+1 = 11111110 = -2

Perché usare una notazione così astrusa? un motivo pratico, la notazione con il complemento a 2 permette di effettuare le operazioni di addizione e sottrazione utilizzando sempre lo stesso circuito elettronico, deriva dai tempi in cui i circuiti integrati dovevano essere compatti perché la tecnologia non permetteva di creare che centinaia di componenti per centimetro quadro, invece dell’enorme quantità di componenti che si possono integreare oggi. (Pensate che 1byte sono 8 componenti, uno per ogni bit, quindi provate a contare quanti ne servono nel chip di una chiavetta USB da 8giga).

Direi che è ora di scrivere un pochino di codice.

Una mini calcolatrice binaria

Questo progetto è un programma WPF che mostra il risultato delle 4 operazioni fondamentali sui numeri binari quindi AND, OR, XOR e Complemento a 1 non utilizzo nulla di quello che sono le tecniche specifiche di WPF solo il minimo indispensabile per poter mostrare i risultati.

la soluzione contiene solo i file standard creati da Visual studio.

Quando completato, l’aspetto della Window aperta dal programma è quello dell’immagine qui sopra. Abbiamo 2 caselle di testo ove inserire gli operandi, 4 bottoni per le operazioni e una terza casella di testo dove verrà mostrato il risultato.

<Window x:Class="BinaryCalculator.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:BinaryCalculator"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
		<Grid.RowDefinitions>
			<RowDefinition Height="Auto"/>
			<RowDefinition Height="50*"/>
			<RowDefinition Height="Auto"/>
			<RowDefinition Height="50*"/>
			<RowDefinition Height="Auto"/>
			<RowDefinition Height="50*"/>
			<RowDefinition Height="Auto"/>
			<RowDefinition Height="Auto"/>
		</Grid.RowDefinitions>
		<TextBlock
			Margin="4,2,4,2"
			Grid.Row="0"
			Text="First Operand"/>
		<TextBox
			Name="txtFirstOperand"
			Grid.Row="1"
			Margin="4,2,4,2"
			HorizontalAlignment="Stretch"
			HorizontalContentAlignment="Right"
			VerticalAlignment="Center"
			Text="0"/>
		<TextBlock
			Margin="4,2,4,2"
			Grid.Row="2"
			Text="Second operand"/>
		<TextBox
			Name="txtSecondOperand"
			Grid.Row="3"
			Margin="4,2,4,2"
			HorizontalAlignment="Stretch"
			HorizontalContentAlignment="Right"
			VerticalAlignment="Center"
			Text="0"/>
		<TextBlock
			Margin="4,2,4,2"
			Grid.Row="4"
			Text="Result"/>
		<TextBox
			Name="txtResult"
			Grid.Row="5"
			Margin="4,2,4,2"
			HorizontalAlignment="Stretch"
			HorizontalContentAlignment="Left"
			VerticalAlignment="Stretch"
			TextWrapping="Wrap"
			VerticalScrollBarVisibility="Auto"
			Text=""/>
		<TextBlock
			Margin="4,2,4,2"
			Grid.Row="6"
			Text="Insert 2 numbers between 0 and 255 NOT uses only the First Operand"/>
		<StackPanel
			Grid.Row="7"
			Orientation="Horizontal"
			FlowDirection="RightToLeft">
			<Button Margin="4,2,4,2"
					Padding="10,4,10,4"
					Content="Complement"
					Click="Complement_Click"/>
			<Button Margin="4,2,4,2"
					Padding="10,4,10,4"
					Content="XOR"
					Click="Xor_Click"/>
			<Button Margin="4,2,4,2"
					Padding="10,4,10,4"
					Content="OR"
					Click="Or_Click"/>
			<Button Margin="4,2,4,2"
					Padding="10,4,10,4"
					Content="AND"
					Click="And_Click"/>
		</StackPanel>
	</Grid>
</Window>

Possiamo vedere come, nella parte XAML della MainWindow, abbiamo inserito un tag Grid dal nome anche chi non ha mai usato XAML può intuire si tratti di una griglia con delle celle, in questo caso una sola colonna con otto righe, all’interno delle righe abbiamo inserito uncontrollo TextBlock che, come il suo nome suggerisce, permette di inserire un blocco di testo con la descrizione della casella sottostante e un controllo TextBox che permette di inserire una casella in cui scrivere del testo per inserire il testo oppure, nel caso dell’ultima per visualizzare il risultato, ho usato una TextBox per il risultato perché la TextBox può automaticamente scorrere se il testo fosse troppo lungo per essere visualizzato.

Potete notare come io abbia dato un nome a ciascuna delle 3 TextBox.

Nell’ultima riga ho inserito un controllo StackPanel, come il suo nome suggerisce, il controllo StackPanel contiene una lista (pila=stack) di altri controlli, in questo caso inseriti orizzontalmente. In esso ho inserito 4 controlli Button, che ci permetteranno di compiere le azioni relative alle 4 operazioni usando il click del mouse, ciascuno di essi ha infatti una Chiamata (si chiamano event handler, ricordatevelo perché sono il pane quotidiano per un programmatore quando scrive interfacce utente) che risponde all’evento Click.

In MainWindow.xaml.cs, troviamo il codice C# delle 4 operazioni, ecco come è fatto:

private void And_Click(object sender, RoutedEventArgs e)
{
	int val1 = 0;
	int.TryParse(txtFirstOperand.Text, out val1);
	if (val1 > 255 || val1 < -255)
	{
		val1 %= 255;
		txtFirstOperand.Text = val1.ToString();
	}
 
	int val2 = 0;
	int.TryParse(txtSecondOperand.Text, out val2);
	if (val2 > 255 || val2 < -255)
	{
		val2 %= 255;
		txtSecondOperand.Text = val2.ToString();
	}
 
	int aval = val1 & val2;
	txtResult.Text = string.Format("AND: {0} & {1} = {2} In binary: {3} & {4} = {5}", val1, val2, aval, Convert.ToString(val1, 2), Convert.ToString(val2, 2), Convert.ToString(aval, 2));
 
}

L’operazione più importante di questo metodo è

int aval = val1 & val2;

Ed è esattamente quello che abbiamo spiegato in questa lezione applicato al codice C#, infatti utilizziamo 3 variabili di tipo int (numero intero a 32bit) per assegnare il valore dell’AND binario dei 2 valori inseriti (val1 e val2) ad una terza variabile aval.

Tutto ciò che è scritto prima di questa riga, serve solo a controllare quello che l’utente ha inserito e preparare il dato per l’operazione. Se vi sembra strano che ci sia tanto codice scritto per controllare l’input e una sola riga per l’effettiva operazione sui dati, vi invito a rassegnarvi al fatto che come programmatori, l’80% del codice che scrivete sarà scritto per controllare quello che fanno gli utenti e per gestire i possibili errori, ed il 20% sarà il codice che effettivamente fa qualcosa di interessante.

Spieghiamo riga per riga cosa abbiamo fatto, anche se è ancora un po’ presto per chi ha appena iniziato, però preferisco dirvi qualcosa in più su quello di cui parleremo estesamente nelle lezioni che verranno.

private void And_Click(object sender, RoutedEventArgs e)

Questa è la dichiarazione del metodo And_Click, ricordo che un metodo è una serie di istruzioni in codice C# che effettua un operazione all’interno di una classe. In questo caso, si tratta di un metodo speciale, chiamato Event Handler (Gestore di Evento) perché viene eseguito dal sistema alla pressione del mouse sul Button AND da noi inserito nella User Interface. Il mouse scatena l’evento Click, il sistema verifica che si trovava sopra al Button AND e verifica che c’è un metodo che deve essere eseguito. Quindi provvede a chiamare il metodo ed eseguire tutte le istruzioni al suo interno. Se vi incuriosiscono i 2 parametri del metodo, vi do 2 input in merito:

1. Tutti i metodi Event Handler hanno 2 parametri, un object che per convenzione viene chiamato sender ed un Argument che è una classe che può essere di tipo diverso in base all’evento e fornisce dati all’evento stesso.
2. Il sender è sempre un object per convenzione ed è sempre il controllo o comunque la classe che ha scatenato l’evento, in questo caso è l’oggetto Button che è stato premuto.
3. L’Event Argument e può essere una classe diversa in base all’evento, se l’evento è un evento scatenato da un componente visuale di WPF (Routed Event) sarà di tipo RoutedEventArgs o una classe da essa derivata. Se l’evento è un semplice evento .Net, (Event) questa classe sarà di tipo EventArgs o una classe da essa derivata.

Erano 3 e non due, spero non siate arrabbiati per le troppe cose da ricordare. Aggiungo che spesso i due argomenti sono utili a noi per fornirci informazioni sull’evento e permetterci di svolgere azioni diverse all’interno del codice. in questo caso però, li ignoriamo bellamente perché il nostro codice sa perfettamente cosa deve fare per fare un AND.

int val1 = 0;

Creiamo una variabile intera ove inseriremo il primo valore digitato dall’utente, la inizializziamo con il valore 0.

int.TryParse(txtFirstOperand.Text, out val1);

Utilizziamo uno dei metodi della classe int, come abbiamo spiegato nella prima lezione, ogni cosa in C# è una classe, quindi un intero è una classe che ha al suo interno uno spazio per contenere un numero a 32 bit, ma ha anche una serie di metodi che permettono di fornire funzionalità. In questo caso, il metodo TryParse è un metodo (Try Parse = Prova a Convertire) che permette di prendere una stringa e verificare se può essere convertita in un numero intero, se fosse possibile, la stringa viene trasformata ed il suo valore posto nella variabile val1 che abbiamo passato come parametro al metodo con la clausola out.

Importante!

La parola chiave out, posta accanto ad un parametro passato ad un metodo, fa in modo che il metodo stesso possa modificarne il contenuto e chi ha chiamato il metodo possa leggere il valore modificato.

if (val1 > 255 || val1 < -255)

Facciamo un controllo del valore ottenuto, per non complicarci troppo la vita, abbiamo indicato all’utente che deve inserire valori da 0 a 255, anche con segno negativo, ma siccome conosciamo i nostri utenti, facciamo un controllo, se il valore inserito dall’utente non è compreso tra -255 e 255 andiamo a fare qualcosa:

val1 %= 255;
txtFirstOperand.Text = val1.ToString();

ovvero, modifichiamo il valore inserito tenendo solo il resto della divisione per 255, è un operazione arbitraria che ho scelto di fare io, semplicemente per semplificare l’output. Quando faccio questa correzione, la riporto sulla textbox in modo che l’utente sappia che l’ho sgamato.

int val2 = 0;
int.TryParse(txtSecondOperand.Text, out val2);
if (val2 > 255 || val2 < -255)
{
	val2 %= 255;
	txtSecondOperand.Text = val2.ToString();
}

Il valore della seconda TextBox viene processato nello stesso modo del primo.

int aval = val1 & val2;

Effettuo l’operazione di AND e memorizzo il risultato nella terza variabile.

txtResult.Text = string.Format("AND: {0} & {1} = {2} In binary: {3} & {4} = {5}", val1, val2, aval, Convert.ToString(val1, 2), Convert.ToString(val2, 2), Convert.ToString(aval, 2));

Ed ora utilizzo un metodo della classe string per creare una stringa formattata che mostra il risultato.

string.Format è un metodo che prende in input:

• Una stringa contenente uno o più placeholders ove inserire dei valori
• Un numero di parametri pari al numero dei placeholders che provvederà a convertire in stringa e inserire nel posto opportuno.

I Placeholder nelle stringhe C# sono dei numeri fra graffe {n} il numero n parte da 0 (zero) e si incrementa per ognuno dei parametri che vogliamo inserire.

Nel nostro caso, abbiamo rappresentato l’operazione con i numeri normali, e poi, per mostrare l’effetto dell’operazione binaria sui bit effettivi, abbiamo utilizzato la classe Convert, una classe del framework che fornisce un certo numero di metodi per convertire dati in vari formati. In questo caso, abbiamo utilizzato il Convert.ToString, per convertire i nostri numeri interi in numeri binari; l’effetto magico è fornito dal parametro numerico 2, infatti, Convert.ToString è in grado di convertire un numero in una stringa utilizzando una base arbitraria. Potevo utilizzare il 16 per l’esadecimale, l’8 per l’ottale o un altro numero.

L’operazione eseguita usando 12 e 42 da il risultato qui sopra indicato.

Come potete notare, il Convert.Tostring toglie gli zeri iniziali, infatti, se usiamo un numero negativo:

Il risultato è una serie binaria molto più lunga i numeri negativi come avete notato hanno la parte più alta a 1 perché sono rappresentati con il metodo del Complemento a 2 che vi invito ad andare a studiare su Wikipedia, ove è certamente spiegato benissimo.

il codice relativo agli altri button è simile, salvo per il complemento che utilizza solo uno degli operandi.

private void Or_Click(object sender, RoutedEventArgs e)
{
	int val1 = 0;
	int.TryParse(txtFirstOperand.Text, out val1);
	if (val1 > 255 || val1 < -255)
	{
		val1 %= 255;
		txtFirstOperand.Text = val1.ToString();
	}
 
	int val2 = 0;
	int.TryParse(txtSecondOperand.Text, out val2);
	if (val2 > 255 || val2 <-255)
	{
		val2 %= 255;
		txtSecondOperand.Text = val2.ToString();
	}
 
	int oval = val1 | val2;
	txtResult.Text = string.Format("OR: {0} | {1} = {2} In binary: {3} | {4} = {5}", val1, val2, oval, Convert.ToString(val1, 2), Convert.ToString(val2, 2), Convert.ToString(oval, 2));
 
}

Il codice per l’OR.

private void Xor_Click(object sender, RoutedEventArgs e)
{
	int val1 = 0;
	int.TryParse(txtFirstOperand.Text, out val1);
	if (val1 > 255 || val1 < -255)
	{
		val1 %= 255;
		txtFirstOperand.Text = val1.ToString();
	}
 
	int val2 = 0;
	int.TryParse(txtSecondOperand.Text, out val2);
	if (val2 > 255 || val2 < -255)
	{
		val2 %= 255;
		txtSecondOperand.Text = val2.ToString();
	}
 
	int xval = val1 ^ val2;
	txtResult.Text = string.Format("XOR: {0} ^ {1} = {2} In binary: {3} ^ {4} = {5}", val1, val2, xval, Convert.ToString(val1, 2), Convert.ToString(val2, 2), Convert.ToString(xval,2));
 
}

Il codice per lo XOR

private void Complement_Click(object sender, RoutedEventArgs e)
{
	int val = 0;
	int.TryParse(txtFirstOperand.Text, out val);
	if (val > 255 || val < -255)
	{
		val %= 255;
		txtFirstOperand.Text = val.ToString();
	}
 
	int cval = ~val;
	txtResult.Text = string.Format("Complement of {0} = {1} In binary: {2} = {3}", val, cval, Convert.ToString(val,2), Convert.ToString(cval,2));
}

Ed il complemento, dove usiamo un solo operando.

Riepilogo

In questo articolo abbiamo trattato i seguenti argomenti:

• Operatori binari
• Cenni all’algebra di Boole.
• Uso degli operatori binari nel codice.
• Una mini applicazione che mostra come utilizzare le 4 operazioni binarie fondamentali .
• La spiegazione di come si usa un metodo con un parametro di output (out parameter).
• La spiegazione di come si usa il metodo string.Format per comporre una stringa con dei dati inseriti al posto di uno o più placeholders.
• Come convertire un numero in binario utilizzando la classe Convert del framework.

Il progetto di esempio correlato a questo articolo può essere scaricato al link seguente:

Per qualsiasi domanda, approfondimento, richiesta, correzione dubbio usate il link di contatto in cima alla pagina.