En Pascal contamos con una serie de operadores para realizar sumas, restas, multiplicaciones y otras operaciones no tan habituales. Algunos de ellos ya los habíamos comentado. Vamos a verlos ahora con más detalle. Son los siguientes:
| Operador | Operación | Operandos | Resultado |
| + | Suma | enteros
reales |
entero
real |
| - | Resta | enteros
reales |
entero
real |
| * | Multiplicación | enteros
reales |
entero
real |
| / | División | enteros
reales |
real |
| div | División entera | enteros | entero |
| mod | Resto | enteros | entero |
En operaciones como +, - y * supongo que no habrá ninguna duda: si sumo dos números enteros obtengo un número entero, si resto dos reales obtengo un número real, y lo mismo pasa con la multiplicación. Los problemas pueden venir con casos como el de 10/3. Si 10 y 3 son números enteros, ¿qué ocurre con su división? En otros lenguajes como C, el resultado sería 3, la parte entera de la división. En Pascal no es así: el resultado sería 3.333333, un número real. Si queremos la parte entera de la división, deberemos utilizar div. Finalmente, mod nos indica cual es el resto de la división. El signo - se puede usar también para indicar negación. Allá van unos ejemplillos:
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Prueba de operaciones }
{ elementales }
{ OPERAC.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{ - Turbo Pascal 5.0 }
{ - Surpas 1.00 }
{--------------------------}
program operaciones;
var
e1, e2: integer; (* Numeros enteros *)
r1, r2, r3: real; (* Números reales *)
begin
e1:=17;
e2:=5;
r1:=1;
r2:=3.2;
writeln('Empezamos...');
r3:=r1+r2;
writeln('La suma de r1 y r2 es :', r3);
writeln(' o también ', r1+r2 :5:2); (* Indicando el formato *)
writeln('El producto de r1 y r2 es :', r1 * r2);
writeln('El valor de r1 dividido entre r2 es :', r1 / r2);
writeln('La diferencia de e2 y e1 es : ', e2 - e1);
writeln('La división de e1 entre e2 : ', e1 / e2);
writeln(' Su división entera : ', e1 div e2);
writeln(' Y el resto de la división : ', e1 mod e2);
writeln('El opuesto de e2 es :', -e2);
end.
Supongo que no habrá ninguna duda. O:-) De todos modos, experimentad. Y ojo con el formato de "mod", porque se parece bastante poco como se diría "el resto de dividir e1 entre e2" a la notación "e1 mod e2". Aun así, todo fácil, ¿verdad?
Ejercicio propuesto: Crea un programa que pida al usuario dos números reales y muestre cuando es el resultado de su división (sólo la parte entera) y el resto de la división. Por ejemplo, si se indican los números 21 y 5, el programa debería responder que el resultado de la división es 4 y que el resto es 1
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Concatenar cadenas }
{ con "+" }
{ CONCAT.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{ - Tmt Pascal Lt 1.20 }
{--------------------------}
Program Concat;
var
texto1, texto2, texto3: string;
begin
texto1 := 'Hola ';
texto2 := '¿Cómo estás?';
texto3 := texto1 + texto2;
writeln(texto3); (* Escribirá "Hola ¿Cómo estás?" *)
end.
(Más adelante se dedica un apartado al manejo de cadenas de texto).
Cuando tratemos tipos de datos más avanzados, veremos que +, - y * también se pueden utilizar para conjuntos, e indicarán la unión, diferencia e intersección. (Esto lo veremos más adelante, en el tema 9).
Ejercicio propuesto: Crea un programa que pida al usuario su nombre y su apellido, cree una cadena formada por el apellido, una coma y el nombre (por ejemplo si el usuario introduce Nacho como nombre y Cabanes como apellido, la cadena contendrá "Cabanes, Nacho"), y finalmente escriba esa cadena.
Podremos encadenar proposiciones de ese tipo (si A y B entonces C) con:
and (y), or (ó), not (no) y los operadores
relacionales,que se usan para comparar y son los siguientes:
| Operador | Operación |
| = | Igual a |
| <> | No igual a (distinto de) |
| < | Menor que |
| > | Mayor que |
| <= | Menor o igual que |
| >= | Mayor o igual que |
(No haremos ejercicios todavía sobre estos operadores, sino que los aplicaremos en el siguiente tema, cuando aprendamos a comprobar condiciones.
Igual que antes, algunos de ellos (>=, <=, in) los utilizaremos también en los conjuntos, más adelante.
| Operador | Operación |
| not | Negación |
| and | Producto lógico |
| or | Suma lógica |
| xor | Suma exclusiva |
| shl | Desplazamiento hacia la izquierda |
| shr | Desplazamiento a la derecha |
Explicar para qué sirven estos operadores implica conocer qué es eso de los bits, cómo se pasa un número decimal a binario, etc. Supondré que se tienen las nociones básicas, y pondré un ejemplo, cuyo resultado comentaré después:
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Operaciones entre }
{ bits }
{ BITOPS.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{ - Tmt Pascal Lt 1.20 }
{--------------------------}
program BitOps; { Operaciones entre bits }
const
a = 67;
b = 33;
begin
writeln('La variable a vale ', a);
writeln('y b vale ', b);
writeln(' El complemento de a es: ', not(a));
writeln(' El producto lógico de a y b es: ', a and b);
writeln(' Su suma lógica es: ', a or b);
writeln(' Su suma lógica exclusiva es: ', a xor b);
writeln(' Desplacemos a a la izquierda: ', a shl 1);
writeln(' Desplacemos a a la derecha: ', a shr 1);
end.
Veamos qué ha ocurrido. La respuesta que nos da Turbo Pascal 7.0 es la siguiente:
- - - - - - - - - - - - - - - - - - - - - - - - - - -
La variable a vale 67
y b vale 33
El complemento de a es: -68
El producto lógico de a y b es: 1
Su suma lógica es: 99
Su suma lógica exclusiva es: 98
Desplacemos a a la izquierda: 134
Desplacemos a a la derecha: 33
- - - - - - - - - - - - - - - - - - - - - - - - - - -
Para entender esto, deberemos convertir al sistema binario esos dos números:
67 = 0100 0011
33 = 0010 0001
- En primer lugar complementamos "a", cambiando los ceros por unos:
1011 1100 = -68
- Después hacemos el producto lógico de A y B,
multiplicando
cada bit,
de modo que 1*1 = 1, 1*0 = 0, 0*0 = 0
0000 0001 = 1
- Después hacemos su suma lógica, sumando cada bit, de modo que
1+1 = 1, 1+0 = 1, 0+0 = 0
0110 0011 = 99
- La suma lógica exclusiva devuelve un 1 cuando los dos bits son distintos:
1 xor 1 = 0, 1 xor 0 = 1, 0 xor 0 = 0
0110 0010 = 98
- Desplazar los bits una posición a la izquierda es como
multiplicar
por
dos:
1000 0110 = 134
- Desplazar los bits una posición a la derecha es como
dividir
entre
dos:
0010 0001 = 33
¿Y qué utilidades puede tener todo esto? Posiblemente, más de las que parece a primera vista. Por ejemplo: desplazar a la izquierda es una forma muy rápida de multiplicar por potencias de dos; desplazar a la derecha es dividir por potencias de dos; la suma lógica exclusiva (xor) es un método rápido y sencillo de cifrar mensajes; el producto lógico nos permite obligar a que ciertos bits sean 0; la suma lógica, por el contrario, puede servir para obligar a que ciertos bits sean 1...
Ejercicio propuesto: Crea un programa que pida al usuario un número entero, le aplique una operación XOR 21 y muestre el resultado, aplique nuevamente una operación XOR 21 sobre dicho resultado y muestre el valor final obtenido
Para terminar este tema, debemos conocer la precedencia (o prioridad) de los operadores:
| Operadores | Precedencia | Categoría |
| @ not | Mayor (1ª) | Operadores unarios |
| * / div mod
and shl shr |
2ª | Operadores de multiplicación |
| + - or xor | 3ª | Operadores de suma |
| = <> < >
<= >= in |
Menor (4ª) | Operadores relacionales |
Esto quiere decir que si escribimos algo como 2+3*4, el ordenador primero multiplicará 3*4 (la multiplicación tiene mayor prioridad que la suma) y luego sumaría 2 a ese resultado, de modo que
obtendríamos 14. Si queremos que se realice antes la suma, que tiene menor nivel de precedencia, deberíamos emplear paréntesis, así:
(2+3)*4
Y queda como ejercicio hallar (y tratar de entender) el
resultado
de este programita:
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Prueba de prioridad }
{ en las operaciones }
{ elementales. }
{ EJT04.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Turbo Pascal 7.0 }
{ - Turbo Pascal 5.0 }
{ - Surpas 1.00 }
{--------------------------}
Program EjT04;
begin
writeln('Allá vamos... ');
writeln( 5+3+4*5*2 );
writeln( (5+3)*4+3*5-8/2+7/(3-2) );
writeln( 5 div 3 + 23 mod 4 - 4 * 5 );
end.