Operatori logici
Operatori logici
Introduzione al linguaggio C
Operatori logici
Copyright © 1997 by Mario G. Montobbio
All rights reserved. No part of this publication may be reproduced,
stored in a retrieval system, or transmitted, in any form or by any
means, electronic, mechanical, photocopying, recording, or
otherwise, without the prior written permission of the author.
Permission to use, copy and distribute this publication for the
purposes of research or private study without fee is hereby granted,
provided that this copyright notice and this permission notice appear
in all copies.
Mario G. Montobbio
mailto:[email protected]
Introduzione al linguaggio C
Prodotto logico
Prodotto logico
(AND)
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Costruiamo una semplice funzione main ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... che contiene due aree denominate aValore1 ed aValore2.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
In questo esempio inizializziamo le aree aValore1 ed aValore2
combinando le potenze di 16: 16º=1, 16¹=16, 16²=256, 16³=4096.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore1 al valore esadecimale X’FC30’ ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... costruito sommando il valore esadecimale X’F000’, ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... il valore esadecimale X’0C00’, ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... e il valore esadecimale X’0030’.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Il coefficiente di 16º è zero, di conseguenza l’ultima cifra in esadecimale
del valore dell’area aValore1 è X’0’.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore2 al valore esadecimale X’C3F0’ ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... costruito sommando il valore esadecimale X’C000’, ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... il valore esadecimale X’0300’, ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... e il valore esadecimale X’00F0’.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Il coefficiente di 16º è zero, di conseguenza l’ultima cifra in esadecimale
del valore dell’area aValore2 è X’0’.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Calcoliamo il prodotto logico del contenuto di aValore1 ed aValore2
nell’area aRisultato.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Stampiamo le aree di partenza aValore1 ed aValore2; ed il loro
prodotto logico calcolato in aRisultato.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Questi sono i modelli delle linee da stampare.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Ogni % è un segnaposto che sarà sostituito ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... dal contenuto dell’area nel secondo argomento ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... allineato verso sinistra ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... per una lunghezza di 8 cifre ...
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
... in esadecimale.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 & aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
AND = %-.8X\n”, aRisultato);
}
Sulla riga del risultato riportiamo l’operazione logica.
Introduzione al linguaggio C
Compilazione
Compilazione
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova9.c
home/mntmgs/clang>
Abbiamo introdotto il codice simbolico in prova9.c.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova9.c
home/mntmgs/clang>
Richiamiamo il compilatore C con il comando cc.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova9.c
home/mntmgs/clang>
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza
che siano stati emessi messaggi di errore: vuole dire che il codice non
contiene errori.
Introduzione al linguaggio C
Elaborazione
Elaborazione
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha
creato un modulo caricabile-eseguibile chiamato a.out ...
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
... che si trova nella directory corrente.
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i
due valori ed il loro prodotto logico in esadecimale.
Introduzione al linguaggio C
Analisi del risultato
Analisi del risultato
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
Questa tabella riepiloga il funzionamento dell’operatore &.
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
Nell’angolo in alto a sinistra è riportato l’operatore che stiamo applicando.
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
La prima colonna in basso a sinistra contiene tutti i valori (logici) possibili
per il primo operando.
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
Nella prima riga in alto a destra ci sono tutti i valori (logici) possibili per il
secondo operando.
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
Nell’angolo in basso a destra ci sono tutti i possibili risultati ottenuti
combinando gli operandi.
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
0 & 0 = 0
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
0 & 1 = 0
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
1 & 0 = 0
Introduzione al linguaggio C
Prodotto logico
&
0
1
Operando 2
0
0
0
Risultato
1
0
1
1 & 1 = 1
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
Richiamando il modulo caricabile-eseguibile a.out vengono emessi i due
valori ed il loro prodotto logico in esadecimale.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
Analizziamo il risultato applicando la tabella dell’operatore &.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
Il contenuto di aValore1 e di aValore2 è stato scelto in modo da
comprendere tutte le possibili situazioni.
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
0 & 0 = 0
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
0 & 1 = 0
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
1 & 0 = 0
Introduzione al linguaggio C
Prodotto logico
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------AND = 0000C030
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
1100 0000 0011 0000
C
0
3
0
Binario
Esadecimale
aRisultato (AND)
1 & 1 = 1
Introduzione al linguaggio C
Somma logica
Somma logica
(OR)
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Costruiamo una semplice funzione main ...
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
... che contiene due aree denominate aValore1 ed aValore2.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
In questo esempio inizializziamo le aree aValore1 ed aValore2
combinando le potenze di 16: 16º=1, 16¹=16, 16²=256, 16³=4096.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore1 al valore esadecimale X’FC30’.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore2 al valore esadecimale X’C3F0’.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Calcoliamo la somma logica del contenuto di aValore1 ed aValore2
nell’area aRisultato.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Stampiamo le aree di partenza aValore1 ed aValore2; e la loro somma
logica calcolata in aRisultato.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Questi sono i modelli delle linee da stampare.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Ogni % è un segnaposto che sarà sostituito ...
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
... dal contenuto dell’area nel secondo argomento ...
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
... allineato verso sinistra ...
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
... per una lunghezza di 8 cifre ...
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
... in esadecimale.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 | aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
OR = %-.8X\n”, aRisultato);
}
Sulla riga del risultato riportiamo l’operazione logica.
Introduzione al linguaggio C
Compilazione
Compilazione
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova10.c
home/mntmgs/clang>
Abbiamo introdotto il codice simbolico in prova10.c.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova10.c
home/mntmgs/clang>
Richiamiamo il compilatore C con il comando cc.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova10.c
home/mntmgs/clang>
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza
che siano stati emessi messaggi di errore: vuole dire che il codice non
contiene errori.
Introduzione al linguaggio C
Elaborazione
Elaborazione
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha
creato un modulo caricabile-eseguibile chiamato a.out ...
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
... che si trova nella directory corrente.
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i
due valori ed la loro somma logica in esadecimale.
Introduzione al linguaggio C
Analisi del risultato
Analisi del risultato
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
Questa tabella riepiloga il funzionamento dell’operatore |.
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
Nell’angolo in alto a sinistra è riportato l’operatore che stiamo applicando.
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
La prima colonna in basso a sinistra contiene tutti i valori (logici) possibili
per il primo operando.
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
Nella prima riga in alto a destra ci sono tutti i valori (logici) possibili per il
secondo operando.
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
Nell’angolo in basso a destra ci sono tutti i possibili risultati ottenuti
combinando gli operandi.
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
0 | 0 = 0
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
0 | 1 = 1
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
1 | 0 = 1
Introduzione al linguaggio C
Somma logica
|
0
1
Operando 2
0
0
1
Risultato
1
1
1
1 | 1 = 1
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
Richiamando il modulo caricabile-eseguibile a.out vengono emessi i due
valori ed il loro prodotto logico in esadecimale.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
Analizziamo il risultato applicando la tabella dell’operatore |.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
Il contenuto di aValore1 e di aValore2 è stato scelto in modo da
comprendere tutte le possibili situazioni.
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
0 | 0 = 0
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
0 | 1 = 1
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
1 | 0 = 1
Introduzione al linguaggio C
Somma logica
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------OR = 0000FFF0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
aRisultato (OR)
1111 1111 1111 0000
F
F
F
0
Binario
Esadecimale
1 | 1 = 1
Introduzione al linguaggio C
Or esclusivo
Or esclusivo
(XOR)
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Costruiamo una semplice funzione main ...
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
... che contiene due aree denominate aValore1 ed aValore2.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
In questo esempio inizializziamo le aree aValore1 ed aValore2
combinando le potenze di 16: 16º=1, 16¹=16, 16²=256, 16³=4096.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore1 al valore esadecimale X’FC30’.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore2 al valore esadecimale X’C3F0’.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Calcoliamo l’or esclusivo del contenuto di aValore1 ed aValore2
nell’area aRisultato.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Stampiamo le aree di partenza aValore1 ed aValore2; ed il loro or
esclusivo calcolato in aRisultato.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Questi sono i modelli delle linee da stampare.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Ogni % è un segnaposto che sarà sostituito ...
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
... dal contenuto dell’area nel secondo argomento ...
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
... allineato verso sinistra ...
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
... per una lunghezza di 8 cifre ...
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
... in esadecimale.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aValore2 = (12 * 4096) + (3 * 256)
+ (15 * 16);
int aRisultato;
aRisultato = aValore1 ^ aValore2;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“Valore 2 = %-.8X\n”, aValore2);
printf (“-------------------\n”);
printf (“
XOR = %-.8X\n”, aRisultato);
}
Sulla riga del risultato riportiamo l’operazione logica.
Introduzione al linguaggio C
Compilazione
Compilazione
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova11.c
home/mntmgs/clang>
Abbiamo introdotto il codice simbolico in prova11.c.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova11.c
home/mntmgs/clang>
Richiamiamo il compilatore C con il comando cc.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova11.c
home/mntmgs/clang>
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza
che siano stati emessi messaggi di errore: vuole dire che il codice non
contiene errori.
Introduzione al linguaggio C
Elaborazione
Elaborazione
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha
creato un modulo caricabile-eseguibile chiamato a.out ...
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
... che si trova nella directory corrente.
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi i
due valori ed il loro or esclusivo in esadecimale.
Introduzione al linguaggio C
Analisi del risultato
Analisi del risultato
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
Questa tabella riepiloga il funzionamento dell’operatore ^.
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
Nell’angolo in alto a sinistra è riportato l’operatore che stiamo applicando.
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
La prima colonna in basso a sinistra contiene tutti i valori (logici) possibili
per il primo operando.
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
Nella prima riga in alto a destra ci sono tutti i valori (logici) possibili per il
secondo operando.
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
Nell’angolo in basso a destra ci sono tutti i possibili risultati ottenuti
combinando gli operandi.
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
0 ^ 0 = 0
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
0 ^ 1 = 1
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
1 ^ 0 = 1
Introduzione al linguaggio C
Or esclusivo
^
0
1
Operando 2
0
0
1
Risultato
1
1
0
1 ^ 1 = 0
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
Richiamando il modulo caricabile-eseguibile a.out vengono emessi i due
valori ed il loro prodotto logico in esadecimale.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
Analizziamo il risultato applicando la tabella dell’operatore |.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
Il contenuto di aValore1 e di aValore2 è stato scelto in modo da
comprendere tutte le possibili situazioni.
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
0 ^ 0 = 0
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
0 ^ 1 = 1
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
1 ^ 0 = 1
Introduzione al linguaggio C
Or esclusivo
1
2
3
4
5
6
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
Valore 2 = 0000C3F0
------------------XOR = 00003FC0
home/mntmgs/clang>
aValore1
1111 1100 0011 0000
F
C
3
0
Binario
Esadecimale
aValore2
1100 0011 1111 0000
C
3
F
0
Binario
Esadecimale
0011 1111 1100 0000
3
F
C
0
Binario
Esadecimale
aRisultato (XOR)
1 ^ 1 = 0
Introduzione al linguaggio C
Negazione
Negazione
(NOT)
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Costruiamo una semplice funzione main ...
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
... che contiene un’area denominate aValore1.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
In questo esempio inizializziamo l’area aValore1 combinando le potenze
di 16: 16º=1, 16¹=16, 16²=256, 16³=4096.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Inizializziamo l’area aValore1 al valore esadecimale X’FC30’.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Calcoliamo la negazione del contenuto di aValore1 nell’area
aRisultato.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Stampiamo l’area di partenza aValore1 e la sua negazione calcolata in
aRisultato.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Questi sono i modelli delle linee da stampare.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Ogni % è un segnaposto che sarà sostituito ...
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
... dal contenuto dell’area nel secondo argomento ...
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
... allineato verso sinistra ...
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
... per una lunghezza di 8 cifre ...
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
... in esadecimale.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main (void)
{int aValore1 = (15 * 4096) + (12 * 256)
+ (3 * 16);
int aRisultato;
aRisultato = ~ aValore1;
printf (”Valore 1 = %-.8X\n”, aValore1);
printf (“-------------------\n”);
printf (“
NOT = %-.8X\n”, aRisultato);
}
Sulla riga del risultato riportiamo l’operazione logica.
Introduzione al linguaggio C
Compilazione
Compilazione
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova12.c
home/mntmgs/clang>
Abbiamo introdotto il codice simbolico in prova12.c.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova12.c
home/mntmgs/clang>
Richiamiamo il compilatore C con il comando cc.
Introduzione al linguaggio C
Compilazione
1
2
home/mntmgs/clang>cc prova12.c
home/mntmgs/clang>
Dopo la compilazione otteniamo nuovamente il prompt del sistema senza
che siano stati emessi messaggi di errore: vuole dire che il codice non
contiene errori.
Introduzione al linguaggio C
Elaborazione
Elaborazione
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
Poiché non abbiamo specificato un nome scelto da noi, il compilatore ha
creato un modulo caricabile-eseguibile chiamato a.out ...
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
... che si trova nella directory corrente.
Introduzione al linguaggio C
Elaborazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
Richiamando il modulo caricabile-eseguibile a.out ora vengono emessi il
valore originale e la sua negazione in esadecimale.
Introduzione al linguaggio C
Analisi del risultato
Analisi del risultato
Introduzione al linguaggio C
Negazione
~
1
1
0
Questa tabella riepiloga il funzionamento dell’operatore ~.
Introduzione al linguaggio C
Risultato
0
Negazione
~
1
1
0
Risultato
0
Nell’angolo in alto a sinistra è riportato l’operatore che stiamo applicando.
Introduzione al linguaggio C
Negazione
~
1
1
0
Risultato
0
La prima colonna a sinistra contiene tutti i valori (logici) possibili per
l’operando.
Introduzione al linguaggio C
Negazione
~
1
1
0
Risultato
0
Nella colonna di destra ci sono tutti i possibili risultati ottenuti applicando
l’operatore all’operando.
Introduzione al linguaggio C
Negazione
~
1
1
0
~ 0 = 1
Introduzione al linguaggio C
Risultato
0
Negazione
~
1
1
0
~ 1 = 0
Introduzione al linguaggio C
Risultato
0
Negazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
0000 0000 0000 0000 1111 1100 0011 0000
0
0
0
0
F
C
3
0
Binario
Esadecimale
1111 1111 1111 1111 0000 0011 1100 1111
F
F
F
F
0
3
C
F
Binario
Esadecimale
Richiamando il modulo caricabile-eseguibile a.out vengono emessi il
valore originale e la sua negazione in esadecimale.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
0000 0000 0000 0000 1111 1100 0011 0000
0
0
0
0
F
C
3
0
Binario
Esadecimale
1111 1111 1111 1111 0000 0011 1100 1111
F
F
F
F
0
3
C
F
Binario
Esadecimale
Analizziamo il risultato applicando la tabella dell’operatore ~.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
0000 0000 0000 0000 1111 1100 0011 0000
0
0
0
0
F
C
3
0
Binario
Esadecimale
1111 1111 1111 1111 0000 0011 1100 1111
F
F
F
F
0
3
C
F
Binario
Esadecimale
Il contenuto di aValore1 è stato scelto in modo da comprendere tutte le
possibili situazioni.
Introduzione al linguaggio C
Negazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
0000 0000 0000 0000 1111 1100 0011 0000
0
0
0
0
F
C
3
0
Binario
Esadecimale
1111 1111 1111 1111 0000 0011 1100 1111
F
F
F
F
0
3
C
F
Binario
Esadecimale
~ 0 = 1
Introduzione al linguaggio C
Negazione
1
2
3
4
5
home/mntmgs/clang>./a.out
Valore 1 = 0000FC30
------------------NOT = FFFF03CF
home/mntmgs/clang>
0000 0000 0000 0000 1111 1100 0011 0000
0
0
0
0
F
C
3
0
Binario
Esadecimale
1111 1111 1111 1111 0000 0011 1100 1111
F
F
F
F
0
3
C
F
Binario
Esadecimale
~ 1 = 0
Introduzione al linguaggio C
Operatori logici
Copyright © 1997 by Mario G. Montobbio
All rights reserved. No part of this publication may be reproduced,
stored in a retrieval system, or transmitted, in any form or by any
means, electronic, mechanical, photocopying, recording, or
otherwise, without the prior written permission of the author.
Permission to use, copy and distribute this publication for the
purposes of research or private study without fee is hereby granted,
provided that this copyright notice and this permission notice appear
in all copies.
Mario G. Montobbio
mailto:[email protected]
Introduzione al linguaggio C