2FP DatosDatosEnteros

UNIVERSIDAD DE
BURGOS
Tema 2: Datos. Datos enteros.

Operaciones con datos enteros.
• Este tema: Objetivos
– Conocer • Conocer:
5 los tipos de datos que pueden manejar los
• un tipo de datos básico ordenadores y las operaciones básicas a
• declarar variables y realizar con cada tipo de datos
6 la sintaxis de un lenguaje de programación
constantes
• Saber
• los operadores aritméticos 9 traducir un algoritmo a un programa
• las funciones aritméticas estructurado
– Hacer los primeros programas 11 elegir los tipos de datos adecuados a la
resolución de un problema
que manejen datos: • Acostumbrarse a:
• pidan datos por teclado 12 leer la documentación de las bibliotecas de
• presenten datos en función funciones
13 generar programas de fácil mantenimiento,
de cálculos sobre datos de la escribiendo la documentación para otras
entrada personas
Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:1

UNIVERSIDAD DE
BURGOS
Tema 2: Datos. Datos enteros.

Operaciones con datos enteros.
0 Introducción.
1 Tipos de datos en C.
2 Clasificación de datos.
3 Números Naturales: ℕ.
4 Números Enteros: ℤ.
5 Operaciones con números
ℕ y ℤ.

UNIVERSIDAD DE
BURGOS
0 Introducción
• Los programas manejan datos. • Los datos se almacenan en el

• Los datos son valores de un ordenador en formato interno,
conjunto de valores posibles en bits.
(tipos de datos). • El número de bits y el
significado de cada bit
depende del tipo de datos.

UNIVERSIDAD DE
BURGOS
1 Tipos de datos en C
El tipo de datos es un identificador que representa:

– el conjunto de valores que puede tomar un elemento en
memoria,
– el espacio de memoria que necesita,
– la forma de interpretar la secuencia de bits donde se almacena y
– las operaciones que se pueden realizar.
Dos formas fundamentales de clasificar los tipos de datos:

– Simples / Derivados.
– Predefinidos / Definidos por el usuario.

UNIVERSIDAD DE
BURGOS
1.1 Tipos de datos derivados

– Los tipos de datos derivados son construidos a partir
de los tipos de datos simples.
– Tipos derivados:
» Registros
» Uniones
» Tablas
(algunos se verán en próximos temas)

UNIVERSIDAD DE
BURGOS
2 Clasificación de datos
en función de su uso
• Los datos pueden variar a lo • Hay datos que se muestran por

largo del programa o no pantalla, otros que se leen de
(variables/constantes). teclado (entrada/salida).
• Y otros que son para
operaciones intermedias
(cálculos).

UNIVERSIDAD DE
BURGOS
2.1 Datos constantes (I)

1 Ctes. literales
Las constantes literales son valores de cualquier tipo que se utilizan como tal.
Aparecen en el lugar donde se necesitan.
Suma
Suma == Suma
Suma ++ 11 ++ 01
01 ++ 0x1;
2 Ctes. del preprocesador 11es
0x1;
esuna
una
Son identificadores que el precompilador sustituye
constante
constante
donde
literal
literal
aparezca
de valor
valor1.1.
pordesus
literales asociados.
#define ident literal<fl>
Se definen al principio del programa y se usa el identificador donde se
necesitan.
El convenio entre programadores de C es que los identificadores de constantes
se escriben usando letras mayúsculas.
#define
#define M_PI
M_PI 3.14
3.14
area=
area= 10
10 ** 10
10 ** M_PI;
M_PI;
M_PI
M_PIesesuna
unaconstante
constantedel
del
preprocesador
preprocesadorde
devalor
valor3.14.
3.14.
UNIVERSIDAD DE
BURGOS
2.1 Datos constantes (y II)

3 Ctes. declaradas
Son identificadores que se asocian a zonas de la memoria que contienen un
valor que no cambia en toda la vida del programa.
const tipo ident = valor;
Se definen al principio del programa y se usa el identificador donde se
necesitan.
El convenio entre programadores de C es que los identificadores de constantes
se escriben usando letras mayúsculas.
const
const int
int ANCHO=50,
ANCHO=50, ALTO
ALTO == 50;
50;
const
const int superficie = ANCHO ** ALTO;
int superficie = ANCHO ALTO;
Es
Esuna
unaconstante
constantecon
connombre
nombreaalalaque
queseseleleasigna
asignaun
unvalor,
valor,
que es una expresión que se evalúa en tiempo de ejecución.
que es una expresión que se evalúa en tiempo de ejecución.

UNIVERSIDAD DE
BURGOS
2.2 Datos variables (I)

• Las variables son objetos de un programa cuyo valor puede variar
durante la ejecución del mismo.
• Este cambio se produce mediante sentencias ejecutables.
• Una variable se compone de un identificador, denominado nombre
de la variable, y del valor almacenado en la posición de memoria
correspondiente, denominado valor de la variable.
• Una declaración de variable asocia un tipo de datos especificado
a una variable.

UNIVERSIDAD DE
BURGOS
2.2 Datos variables (y II)

• Sintaxis de declaración de variables:
tipo identif ( ,identif );
tipo tipo de la variable (char, int, short, float...)
identif es un identificador que indica el nombre de la variable
• El convenio entre programadores de C es que los identificadores
de variables se escriben usando letras minúsculas (al menos la
primera).
• Todas las variables de un programa en C deben ser declaradas
antes de ser utilizadas.
• Las declaraciones de variables del programa han de hacerse después de
la { (del main) y antes de la primera sentencia ejecutable .

UNIVERSIDAD DE
BURGOS
3 Números Naturales: ℕ
Base 2 8 16 10 Base 2 8 16 10
0000 0000 00 00 0 1111 1111 377 FF 255
0000 0001 01 01 1 1111 1110 376 FE 254
0000 0010 02 02 2 1111 1101 375 FD 253
0000 0011 03 03 3 1111 1100 374 FC 252
0000 0100 04 04 4 1111 1011 373 FB 251
0000 0101 05 05 5 1111 1010 372 FA 250
0000 0110 06 06 6 1111 1001 371 F9 249
0000 0111 07 07 7 1111 1000 370 F8 248
0000 1000 010 08 8 1111 0111 367 F7 247
0000 1001 011 09 9 1111 0110 366 F6 246
0000 1010 012 0A 10 1111 0101 365 F5 245
0000 1011 013 0B 11 1111 0100 364 F4 244
0000 1100 014 0C 12 1111 0011 363 F3 243
0000 1101 015 0D 13 1111 0010 362 F2 242
0000 1110 016 0E 14 1111 0001 361 F1 241
0000 1111 017 0F 15 1111 0000 360 F0 240
0001 0000 020 10 16 1110 1111 357 EF 239
0001 0001 021 11 17 1110 1110 356 EE 238
0001 0010 022 12 18 1110 1101 355 ED 237

UNIVERSIDAD DE
BURGOS
3.1 Tipos de datos naturales

• Llevan la palabra reservada
• Son tipos de datos simples
– unsigned
predefinidos
• Las variables que almacenan
• Representan un subconjunto
estos datos pueden ocupar 1,
de los números positivos sin
2, 4 ó 8 bytes de memoria
decimales
– unsigned char
• Almacenan los datos en base
2 – unsigned short
– unsigned long
– unsigned long long

UNIVERSIDAD DE
BURGOS

almacenamiento en base 2
• Natural corto • Natural muy corto
– 2 bytes (16 bits) – 1 byte (8 bits)
– Valor mínimo: 0 – Valor mínimo: 0
– Valor máximo: 216-1, – Valor máximo: 28-1,
1111 1111 1111 1111 1111 1111
65 535 255
01 77777 0377
0xFFFF 0xFF
– Nombre del tipo – Nombre del tipo
unsigned short [int] unsigned char
Ver ejemplo de funcionamiento de la base 2 con 6 bits

http://www.youtube.com/watch?v=GcDshWmhF4A
UNIVERSIDAD DE
BURGOS

almacenamiento en base 2
• Natural largo estándar C99
– 4 bytes (32 bits) • Natural muy largo
– Valor mínimo: 0 – 8 bytes (64 bits)
– Valor máximo: 232-1, – Valor mínimo: 0
11111111 11111111 11111111 11111111
– Valor máximo: 264-1,
4 294 967 295L 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111
03 77777 77777L 18 446 744 073 709 551 615LL

0xFFFF FFFFL 017 77777 77777 77777 77777LL
– Nombre del tipo 0xFFFF FFFF FFFF FFFFLL
unsigned long [int] – Nombre del tipo
unsigned [int] unsigned long long

UNIVERSIDAD DE
BURGOS
4 Números Enteros: ℤ
Base 2 8 16 10 Base 2 8 16 10
0 000 0000 00 00 0 1 111 1111 377 FF -1
0 000 0001 01 01 1 1 111 1110 376 FE -2
0 000 0010 02 02 2 1 111 1101 375 FD -3
0 000 0011 03 03 3 1 111 1100 374 FC -4
0 000 0100 04 04 4 1 111 1011 373 FB -5
0 000 0101 05 05 5 1 111 1010 372 FA -6
0 000 0110 06 06 6 1 111 1001 371 F9 -7
0 000 0111 07 07 7 1 111 1000 370 F8 -8
0 000 1000 010 08 8 1 111 0111 367 F7 -9
0 000 1001 011 09 9 1 111 0110 366 F6 -10
0 000 1010 012 0A 10 1 111 0101 365 F5 -11
0 000 1011 013 0B 11 1 111 0100 364 F4 -12
0 000 1100 014 0C 12 1 111 0011 363 F3 -13
0 000 1101 015 0D 13 1 111 0010 362 F2 -14
0 000 1110 016 0E 14 1 111 0001 361 F1 -15
0 000 1111 017 0F 15 1 111 0000 360 F0 -16
0 001 0000 020 10 16 1 110 1111 357 EF -17
0 001 0001 021 11 17 1 110 1110 356 EE -18
0 001 0010 022 12 18 1 110 1101 355 ED -19

UNIVERSIDAD DE
BURGOS
4.1 Tipos de datos enteros

• Llevan la palabra reservada (por
• Son tipos de datos simples defecto)
predefinidos
– signed
• Representan un subconjunto
de los números positivos y • Las variables que almacenan
negativos sin decimales estos datos pueden ocupar 1,
2, 4 ó 8 bytes de memoria
• Almacenan los datos en
complemento a 2 – signed char
– signed short
– signed long
– signed long long

UNIVERSIDAD DE
BURGOS

almacenamiento en base 2 con complemento a 2
• Entero corto • Entero muy corto
– 2 bytes (16 bits) – 1 byte (8 bits)
– Valor mínimo: -215 – Valor mínimo: -27
– Valor máximo: 215-1, – Valor máximo: 27-1,
0111 1111 1111 1111 0111 1111
32 767 127
0 77777 0177
0x7FFF 0x7F
– Nombre del tipo – Nombre del tipo
[signed] short [int] [signed] char
Ver el ejemplo suponiendo que el peso del sexto bit es -32

http://www.youtube.com/watch?v=GcDshWmhF4A
UNIVERSIDAD DE
BURGOS

almacenamiento en base 2 con complemento a 2
• Entero largo estándar C99
– 4 bytes (32 bits) • Entero muy largo
– Valor mínimo: -231 – 8 byte (64 bits)
– Valor máximo: 231-1, – Valor mínimo: -263
01111111 11111111 11111111 11111111
– Valor máximo: 263-1,
2 147 483 647L 01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111
01 77777 77777L 9 223 372 036 854 775 807LL

0x7FFF FFFFL 07 77777 77777 77777 77777LL
– Nombre del tipo 0x7FFF FFFF FFFF FFFFLL
[signed] long [int] – Nombre del tipo
signed [int] [signed] long long
int

UNIVERSIDAD DE
BURGOS
5 Operaciones con números ℕ y ℤ
• Declarar variables • Salida de datos

– Naturales y enteras – naturales y enteros
• Lectura de datos
– naturales y enteros
• Asignación de variables
enteras
• Expresiones enteras

UNIVERSIDAD DE
BURGOS
5.1 Declarar variables ℕ y ℤ

• naturales: • enteras
unsigned char c1, c2; signed char c3;
Básicos
unsigned short int n1; signed short int i1;

Tipos
unsigned long int m1; signed long int j1;

unsigned long long l; signed long long k1;
unsigned short n2; int
signed short i2;
unsigned long m2; opcional
signed long j2;
char c4;
short int i3;
singed long int j5;
Sinónimos
opción long long k2;

por defecto short i4;
de compilación long j6;
unsigned int m3; signed int j3;
unsigned m4; long signed j4;
opción int j7;
por defecto
de compilación
UNIVERSIDAD DE
BURGOS
5.2. /S de datos por pantalla

función printf() x
Permite la salida de datos con formato
#include<stdio.h>
int printf(literal cadena formato [, lista de argumentos ...]);
formato Especifica como va a ser Especificaciones de formato de los

la salida. Esta formado por argumentos:
caracteres, secuencias de escape y %[FLAGS][ANCHO][.PRECISION]{f/n/h/l/L}]tipo
especificaciones de formato entre Cada argumento tiene que tener su
comillas dobles. correspondiente especificación y en el
mismo orden. Si hay más argumentos que
argumentos Representan el valor o especificaciones de formato, los
valores a escribir. argumentos en exceso se ignoran. Si hay
valor de retorno Entero de menos se ven valores no deseados.
correspondiente al número de datos
escritos

UNIVERSIDAD DE
BURGOS i

/S básica: printf()
%[FLAGS][ANCHO][.PRECISION]{f/n/h/l/L}]tipo • .Precisión
Ø por defecto: mínimo 1 dígito
significativo
.n mínimo n dígitos significativos
• Tipos: .0 aplica el defecto
%...u natural en decimal * la precisión es el argumento precedente
%...o natural en octal
%...X natural en hexadecimal • Ancho
(con letras mayúsculas) n muestra al menos n caracteres,
rellenando con blancos si son necesarios
%...x natural en hexadecimal 0n muestra al menos n caracteres,
(con letras minúsculas) rellenando con ceros si son necesarios
* el ancho es el argumento precedente
%...d entero en decimal
• Flags
Ø ajusta los caracteres a la derecha del
%...i igual al %d en salida ancho
- ajusta los caracteres a la izquierda del
ancho
• Modificadores de tamaño + añade siempre el signo (+ ó -)
Ø por defecto blanco añade hueco para el signo (blanco ó -)
h indica que los argumentos son # con el tipo o añade un 0 delante
short int con los tipos X ó x añade un 0x delante
l indica que los argumentos son
long int

UNIVERSIDAD DE Ejemplos de
BURGOS naturales y enteros
Ej. /S de datos enteros <1>

<1>
<1>
<1>
Ejemplo de enteros < 1> < 1>
Inicio 1 1 1 1 1 1 1 1 1 < 1> < 1>
<0001> <0001>
1 1 1 1 1 1 1 1 1 < 001> < 001>
/*-------------------------------------------+
|Nombre: 24entero.c |Fin < +1>
+1> <
|Sinopsis: El programa muestra números en la | <1 > > <1
| pantalla | < 1>1> <
|Descripción de la ejecución del programa: |
| c:>24entero |
|Directivas de compilación: |
| Compilar en modo ansi, con todos los |
/*Directiva al preprocesador*/
|avisos activos, compilado con bcc |
#include<stdio.h>
|Lista de códigos de salida de la aplicación:|
/*Definición de la función ppal.*/
| Devuelve 0. |
int main(){
|Organización: LSI.IC.UBu |
printf("Ejemplos de enteros\n");
|Autor: CPA |
printf("<1>\t<1>\n");
|Fecha: 18-jul-2003 |
printf("<%u>\t<%d>\n",1,1);
|Versión: v1.0 |
printf("< 1>\t< 1>"\n);
|Lista de versiones: |
printf("<%3u>\t<%3d>\n",1,1);
| v2.0 oct-09 natural/enteros |
printf("<%04u>\t<%04d>\n",1,1);
| v1.0 18-jul-03 versión inicial |
printf("<%5.3u>\t<%5.3d>\n",1,1);
|Información del copyright del programa: |
printf("<%+6u>\t<%+6d>\n",1,1);
| Programa pertenece a CPA.LSI.IC.UBu |
printf("<%-7u>\t<%-7d>\n",1,1);
| Este programa puede (debe) difundirse |
printf("<\t%u>\t<\t%d>\n",1,1);
|entre los alumnos para aprender C |
}
+-------------------------------------------*/
UNIVERSIDAD DE
BURGOS
Ej. Tablas de multiplicar del 5

Tablas de multiplicar del 5
en base 10 en base 8 en base 16
0 * 5 = 0 0 * 5 = 0 0 * 5 = 0
1 * 5 = 5 1 * 5 = 5 1 * 5 = 5
2 * 5 = 10 2 * 5 = 12 2 * 5 = A
3 * 5 = 15 3 * 5 = 17 3 * 5 = F
4 * 5 = 20 4 * 5 = 24 4 * 5 = 14
5 * 5 = 25 5 * 5 = 31 5 * 5 = 19
6 * 5 = 30 6 * 5 = 36 6 * 5 = 1E Inicio
7 * 5 = 35 7 * 5 = 43 7 * 5 = 23
8 * 5 = 40 8 * 5 = 28
9 * 5 = 45 9 * 5 = 2D Tabla *
A * 5 = 32 del 5
B * 5 = 37
C * 5 = 3C
D * 5 = 41 Fin
E * 5 = 46
F * 5 = 4B
UNIVERSIDAD DE
BURGOS

/*Directivas al preprocesador*/
#include<stdio.h>
#define N 5 /*cte.*/
int main(){ /*Definición de la función ppal.*/

printf("\tTablas de multiplicar del %d\nen base 10\ten base 8\ten base 16\n",N);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X *%2X =%4X\n", 0,N,0, 0,N,0, 0,N,0);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", 8,N,40, 8,N,40);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", 9,N,45, 9,N,45);
printf( "\t\t" "\t\t%X *%2X =%4X\n", 10,N,50);
return 0;
}

UNIVERSIDAD DE
BURGOS
5.3 E/ de datos desde teclado (I)

• Cada vez que se pide un dato se mira una zona de memoria
que denominaremos buffer de teclado,
para leer datos de esa,
hasta completar la instrucción de entrada.
• Si no hay suficientes datos en el buffer de entrada (está vacío)
se pedirá al usuario que introduzca una línea de caracteres que se
almacenará en el buffer.

UNIVERSIDAD DE
BURGOS
5.3 E/ de datos desde teclado (II)

Una
Unaoperación
operaciónde
deentrada
entradase
seemplea
empleapara
paraque
que
La operación básica un programa lea datos durante su ejecución.
un programa lea datos durante su ejecución.
de entrada de datos es:
#include <stdio.h> Argumentos representan las direcciones de
int scanf(literal cadena formato memoria de las variables donde escribir
[, lista de argumentos ...]); los valores leídos.
formato Especifica como va ser la entrada. Cada argumento ha de ser pasado por
Esta formado por caracteres, secuencias de referencia usando el operador &
escape y especificaciones de formato entre el operador de dirección (&) es unario de
comillas dobles. Interpreta cada dato de entrada. precedencia 2 y asociativo de derecha a izquierda
Si un carácter de la entrada no se corresponde valor de retorno entero correspondiente al
con la especificación, se interrumpe la entrada. número de campos leídos y almacenados
Cada argumento tiene que tener su
especificación correspondiente y en el mismo
en variables. Cuando se intenta leer
orden. después del fin de fichero retorna EOF.
Si hay más argumentos que especificaciones de La función espera a que se pulse intro antes
formato, los argumentos en exceso se ignoran. de cargar los valores en las direcciones de
Si hay de menos se darán valores no deseados. memoria mientras tenga argumentos por
leer.

UNIVERSIDAD DE
BURGOS
5.3 E/ de datos desde teclado (y III)

Especificaciones de formato de cada • Tipos:
argumento: %...u natural en decimal &(unsiged)
%[*][ANCHO]{f/n}{h/l/L}]tipo %...U natural en decimal&(unsiged long)
%...o natural en octal &(int)
• Modificadores de tamaño %...O natural en octal &(long)
Ø por defecto %...x natural en hexadecimal &(int)
h con d, i, o, u ó x indica que los argumentos
son short int %...X natural en hexadecimal &(long)
l con d, i, o, u ó x indica que los argumentos
son long int %...d entero en decimal &(int)
l con e, f ó g indica que los argumentos son
double %...D entero en decimal &(long)
L con e, f ó g indica que los argumentos son
long double %...i entero en decimal, octal o
• Ancho
hexadecimal &(int)
n especifica el máximo número de caracteres %...I entero en decimal, octal o
a leer, parando antes si se encuentra un hexadecimal &(long)
separador o un carácter no convertible
• Asterisco
* Identifica la entrada de un campo pero no
lo salta sin asignar a ningún argumento

UNIVERSIDAD DE
BURGOS
Tabla de precedencia de operadores
Categoría Operadores Precedencia Asociatividad

1
Unarios & 2 
3
4 
5
6
7
8
9
10
11
12
13
14
15
16

UNIVERSIDAD DE
BURGOS
Ej. E/S: 21Echo
• Programa que muestra en • Ejecuta el programa con las

varios formatos un dato leído siguientes entradas:
(en modo %i) – 123
– 0123
– 0x123
– 78
Inicio – 078
– 4A
– 04A
X – 0x4A
El nº
introducido Fin
es el
X X X X

UNIVERSIDAD DE
BURGOS =
5.4 Sentencia de Calculo

• Una sentencia en C es:
– cualquier expresión aritmética acabada en ;
• Las expresiones aritméticas se utilizan para hacer dar el
valor a una constante o dar un nuevo valor a una variable
(expresión de asignación)
• El valor puede ser:
– un literal
– el valor de un identificador de constante o variable
– el valor que devuelva una función
– el resultado de una expresión aritmética

UNIVERSIDAD DE
BURGOS =
5.4 Expresiones de Asignación

• Una expresión de – Las declaraciones de
asignación es aquella en constantes deben
inicializarse con una
la que interviene un
expresión de asignación
operador de asignación
– Las declaraciones de
f(exp)
variables pueden
X  exp expresión de asignación
– Las de variables deben
• La expresión de f(X)
asignación produce expresión de asignación
como resultado el valor antes de ser evaluadas
asignado
UNIVERSIDAD DE
BURGOS =
5.4 Operador de Asignación en C (II)

Valor long
char short long
Variable long
char char ¿8 bits menos significativos?
¿16 bits menos
short short significativos?
long long ¿32 bits?
• Reglas: long long long long

• La operación de asignación es una operación destructiva.
• Una variable en el lado derecho de una sentencia de asignación debe
tener un valor antes de que la sentencia de asignación se ejecute.
• En la parte izquierda de una sentencia de asignación sólo puede existir
una variable.
• Cuidado con el operador de comparación de igualdad (= =) que se
explicará con las operaciones lógicas.
• Tiene precedencia 15 y se asocia de derecha a izquierda

UNIVERSIDAD DE
BURGOS
5.4 Operador de Asignación en C (y III)

• Convertir tipo:
char c = 10;
short i;
long l;
i = c; /*añade ceros no significativos*/
l = (long) i; /*añade ceros no significativos*/
i = l; /*AVISO posible perdida dígitos
significativos*/
c = (char) i; /*pierde dígitos más significativos*/

UNIVERSIDAD DE
BURGOS

1
Unarios & 2 
3
4 
5
6
7
8
9
10
11
12
13
14
Asignación = 15 
16
c = b = a = 0; Equivale a: a = 0;
b = a;
c = b;
UNIVERSIDAD DE
BURGOS /
5.5 Expresiones Aritméticas

Una expresión aritmética es un conjunto de datos o funciones,
numéricas unidos por operadores aritméticos.
• Operadores de signo
en C: + , -
• Operadores aritméticos
en C: + , -, * , / , %
• Operadores de desplazamiento con signo
en C: << , >>

UNIVERSIDAD DE
BURGOS -
5.5.1 Operadores de signo

• Son operadores unarios (un único operando)
• El operador + devuelve el valor del operando con el
mismo signo
• El operador - devuelve el valor del operando con el signo
cambiado
• Tienen precedencia 2 y se asocian de derecha a izquierda
+ - + - + - 2

UNIVERSIDAD DE
BURGOS

1
Unarios & + - 2 
3
4 
5
6
7
8
9
10
11
12
13
14
16

UNIVERSIDAD DE
BURGOS /
5.5.2 Operadores aritméticos (I)

• Son operadores binarios (dos operandos)
Operador Significado Ejemplo Resultado
+ Suma a1 + a2 Suma de a1 y a2
- Resta a1 -a2 Diferencia de a1 y a2
* Multiplicación a1 * a2 Producto de a1 por a2
/ División a1 / a2 Cociente de a1 entre a2
% Módulo. a1 % a2 Resto de a1 entre a2
• Los operadores / %:
– No pueden usarse si el divisor es 0, ya que el resultado no está definido

UNIVERSIDAD DE
BURGOS /
5.5.2 Operadores aritméticos (y II)

Valor 1 long
char short long
Valor 2 + - * / % long
char char
short short
long long
long long long long
• Los operadores aditivos tienen precedencia 5 y se ejecutan de

izquierda a derecha
• Los operadores multiplicativos tienen precedencia 4
y se ejecutan de izquierda a derecha

UNIVERSIDAD DE
BURGOS

1
Unarios & + - 2 
3
* / % 4 
Aritme-
Multiplicativos
ticos
Aditivos + - 5 
6
7
8
9
10
11
12
13
14
16

UNIVERSIDAD DE /*-------------------------------------------+
|Nombre: 32tMult5.c |
BURGOS |Sinopsis: El programa muestra las tablas de |

| multiplicar del número 5 en base decimal,(I) |
| en base octal y en base hexadecimal
|Descripción de la ejecución del programa:
|
|
Inicio Tablas
| de multiplicar del 5
c:>32tMult5 |
en base 10|Directivasendebase
compilación:
8 en base 16 |
0 * 5 = | 0avisos activos,
0 * 5 compilado
= 0 con bcc0 * 5 = |0
Tablas 1 * 5 = |Lista
5 de 1
códigos
* 5 de = salida
5 de la1 aplicación:|
* 5 = 5
| Devuelve 0. |
* del 5 2 * 5 = 10 2 * LSI.IC.UBu
|Organización: 5 = 12 2 * 5 = |A
en bases 3 * 5 = |Autor: CPA
15 3 * 5 = 17 3 * 5 = || F
|Fecha: 1-sep-2002
4 * 5 = 20
|Versión: 4 * 5 = 24
v2.9 4 * 5 = |14
5 * 5 = |Lista de 5
25 versiones:
* 5 = 31 5 * 5 = ||19
Fin | v2.9 1-sep-02 usar expresiones
6 * 5 = 30
| 6 * 5 =usar36
v2.0 22-ago-02 % y ctes:6 22Mult5.c
* 5 = |1E
7 * 5 = |
35 v1.0 21-ago-02
7 * 5 =comentado
43 prg:7 12Mult5.c
* 5 = ||23
| v0.1 20-ago-02 versión inicial
8 * 5 = 40 8 * 5 = |28
|Información del copyright del programa:
| Programa pertenece a CPA.LSI.IC.UBu
9 * 5 = 45
|
9 * 5 = ||2D
Este programa puede (debe) difundirse
| entre los alumnos para aprenderA C * 5 = |32
+-------------------------------------------*/
B * 5 = 37
C * 5 = 3C
D * 5 = 41
E * 5 = 46
F * 5 = 4B
UNIVERSIDAD DE
BURGOS
Ej. Tablas de multiplicar del 5 (II)

#include<stdio.h> /*Directivas al preprocesador*/

printf("\tTablas de multiplicar del %d\nen base 10\ten base 8\ten base 16\n",N);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X *%2X =%4X\n", 0,N,0*N, 0,N,0*N, 0,N,0*N);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", 8,N,8*N, 8,N,8*N);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", 9,N,9*N, 9,N,9*N);
printf( "\t\t" "\t\t%X *%2X =%4X\n", 10,N,10*N);
return 0;
}

UNIVERSIDAD DE
BURGOS <<
5.5.3 Operadores de desplazamiento
con signo
• Son operadores de bajo nivel
• Realizan un movimiento de bits
<< operador desplazamiento a la izquierda
Es decir:
• Añaden 0 a la derecha
• Equivale a multiplicar por potencias de 2
a<<b => a*2b
>> operador desplazamiento a la derecha
Es decir:
• Añaden 0 a la izquierda si el número es positivo (signed o unsigned)
• Añaden 1 a la izquierda si el número es negativo (signed)
• Equivale a dividir entre potencias de 2
a>>b => a/2b
• Tienen precedencia 6 y se ejecutan de izquierda a derecha
UNIVERSIDAD DE
BURGOS <<
5.5.3 Operadores de desplazamiento
con signo
unsigned char c=42; unsigned char c=170;
/* 00101010 */ /* 10101010 */
c = c<<2; c = c>>2;
/* 10101000 (168)*/ /* 00101010 (42) */
signed char c=10; signed char c=86;
/* 00001010 */ /* 01010110 */
c = c<<2; c = c>>2;
/* 00101000 (40)*/ /* 00010101 (21) */
unsigned char c=-10; signed char c=-86;
/* 11110110 */ /* 10101010 */
c = c<<2; c = c>>2;
/* 11011000 (-40)*/ /* 11101010 (-22) */
UNIVERSIDAD DE
BURGOS

1
Unarios & + - 2 
3
Multiplicativos * / % 4 
Aritme-
ticos
Aditivos + - 5 
Desplazamientos << >> 6 
7
8
9
10
11
12
13
14
16

UNIVERSIDAD DE
BURGOS +=
5.6 Expresiones Aritméticas Acumulativas

Una expresión aritmética acumulativa es una expresión que
realiza una operación aritmética y modifica una variable.
• Operadores incrementales
++ , --
• Operaciones acumulativas aritméticas y de desplazamiento
+= , -= , *= , /= , %= , <<= , >>=

UNIVERSIDAD DE
BURGOS ++
5.6.1 Operadores de incrementales (I)

• Son operadores unarios (un único operando)
• Se pueden usar
– a la izquierda (preincremento o predecremento) y
– a la derecha (prostincremento o prostdecremento)
de una variable
• Abrevia operaciones muy habituales y permite que el
encadenar operaciones
• Tienen precedencia 2 y se asocian de derecha a izquierda

UNIVERSIDAD DE
BURGOS ++
5.6.1 Operadores de incrementales (y II)

• A la izquierda de la • A la derecha de la
variable el resultado es el variable el resultado es el
valor de la variable valor de la variable antes
después de realizar la de realizar la operación:
operación:
++i => i = i + 1; (i) i++ => (i); i = i + 1;
--i => i = i – 1; (i) i-- => (i); i = i – 1;
i +1
n = i++; =>
= exp2
n = i; i = i + 1;
++i int i=0;
printf("%d, ", i++);
n = ++i; => i = exp2
printf("%d, ", i++);
n = i = i + 1; => printf("%d, ", ++i);
i = i + 1; n = i; printf("%d.", ++i);
UNIVERSIDAD DE
BURGOS

1
Unarios & + - ++ -- 2 
3
Aritme-
ticos
Aditivos + - 5 
7
8
9
10
11
12
13
14
16

UNIVERSIDAD DE
BURGOS +=
5.6.2 Operadores acumulativos

• Son operadores binarios
• El operando de la izquierda ha de ser una variable
Operador Significado Ejemplo Resultado
*= multiplicación a *= b a igual al producto de a por b
/= división a /= b a igual al cociente de a entre b
%= resto/módulo a %= b a igual al resto de a entre b
+= acumula a += b a igual a añadir el valor de b al de a
-= subtrae a -= b a igual a restar el valor de b del de a
<<= desplaza a la izquierda a <<= b a igual desplazarse b veces a la izquierda
>>= desplaza a la derecha a >>= b a igual desplazarse b veces a la derecha
a * exp
• Tienen precedencia 15 y = exp2
se ejecutan de derecha a izquierda a *= exp
• Reducen expresiones a = exp2
a*= expr; => a=a*(expr);

UNIVERSIDAD DE
BURGOS =
Ejemplos de sentencias de asignación
x+=2; /*x=x+(2);*/
x*=n-3; /*x=x*(n-3);*/
x++; /*x+=1;*/
++x; /*x+=1;*/
x=--n; /*--n; x=n;*/
x=n--; /*x=n; --n;*/
x<<=3; /*x*=8;*/
a*8
= exp2
a<<=3
a = exp2

UNIVERSIDAD DE
BURGOS

1
Unarios & + - ++ -- 2 
3
Aritme-
ticos
Aditivos + - 5 
7
8
9
10
11
12
13
14
= *= /=
Asignación %= += -= 15 
<<= >>=
16

UNIVERSIDAD DE
BURGOS
Ej. Tablas de /*-------------------------------------------+

multiplicar |Sinopsis: El programa muestra las tablas de |

| multiplicar del número 5 en base decimal, |
| en base octal y en base hexadecimal |
del 5 (III) |Descripción de la ejecución del programa:
| c:>32tMult5
|
|
| avisos activos, compilado con bcc |
|Lista de códigos de salida de la aplicación:|
| Devuelve 0. |
|Autor: CPA |
|Fecha: 1-sep-2002 |
|Versión: v3.0 |
| v3.0 1-sep-02 usar expresiones y vari. |
| v2.9 1-sep-02 usar expresiones |
| v2.0 22-ago-02 usar % y ctes: 22Mult5.c |
| v1.0 21-ago-02 comentado prg: 12Mult5.c |
| v0.1 20-ago-02 versión inicial |
| Este programa puede (debe) difundirse |
| entre los alumnos para aprender C |
+-------------------------------------------*/

UNIVERSIDAD DE
BURGOS
Ej. Tablas de multiplicar del 5 (IV)

/*Directivas al preprocesador*/ i++; x+=N; /*6*/
#include<stdio.h> printf("%u *%2u =%4u\t%o *%2o =%4o\t%X"
#define N 5 /*cte.*/ " *%2X =%4X\n", i,N,x, i,N,x, i,N,x);
/*Definición de la función ppal.*/ i++; x+=N; /*7*/
int main(){ printf("%u *%2u =%4u\t%o *%2o =%4o\t%X"
int i=0, x=0; " *%2X =%4X\n", i,N,x, i,N,x, i,N,x);
printf("\tTablas de multiplicar " i++; x+=N; /*8*/
"del %d\nen base 10\t" printf("%u *%2u =%4u\t\t\t"
"en base 8\ten base 16\n",N); "%X *%2X =%4X\n", i,N,x, i,N,x);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X" i++; x+=N; /*9*/
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); printf("%u *%2u =%4u\t\t\t"
i++; x+=N; /*1*/ "%X *%2X =%4X\n", i,N,x, i,N,x);
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
i++; x+=N; /*2*/ i++; x+=N; /*11*/
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X" printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); i++; x+=N; /*12*/
i++; x+=N; /*3*/ printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
i++; x+=N; /*4*/ i++; x+=N; /*14*/
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X" printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); i++; x+=N; /*15*/
i++; x+=N; /*5*/ printf("\t\t\t\t%X *%2X =%4X\n", i,N,x);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X" return 0;
" *%2X =%4X\n", i,N,x, i,N,x, i,N,x); }

UNIVERSIDAD DE
BURGOS
Ej. Tablas de multiplicar del 5 (V)

/*-------------------------------------------------------------------------+
|Sinopsis: El programa muestra las tablas de multiplicar del número 5 |
| en base decimal, en base octal y en base hexadecimal |
|Descripción de la ejecución del programa: |
| c:>32tMult5 |
| Compilar en modo ansi, con todos los avisos activos, no compilado |
|Lista de códigos de salida de la aplicación: |
| Devuelve 0. |
|Autor: CPA |
|Fecha: 12-jun-2003 |
|Versión: v3.1 |
| v3.1 12-jun-03 usar autoexpresiones |
| v3.0 1-sep-02 usar expresiones y vari. |
| v2.9 1-sep-02 usar expresiones |
| v2.0 22-ago-02 usar % y ctes: 22Mult5.c |
| v1.0 21-ago-02 comentado prg: 12Mult5.c |
| v0.1 20-ago-02 versión inicial |
| Este programa puede (debe) difundirse entre los alumnos para aprender C|
+-------------------------------------------------------------------------*/

UNIVERSIDAD DE
BURGOS
Ej. Tablas de multiplicar del 5 (y VI)

#include<stdio.h> /*Directivas al
preprocesador*/

int i=0, x=0;
printf("\tTablas de multiplicar del %d\nen base 10\ten base 8\ten base
16\n",N);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X *%2X =%4X\n", i,N,x, i,N,x, i++,N,x);
printf("%u *%2u =%4u\t%o *%2o =%4o\t%X *%2X =%4X\n", i,N,x+=N, i,N,x, i++,N,x);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", i,N,x+=N, i++,N,x);
printf("%u *%2u =%4u\t" "\t\t%X *%2X =%4X\n", i,N,x+=N, i,N,x);
printf( "\t\t" "\t\t%X *%2X =%4X\n", ++i,N,x+=N);
return 0;
}

UNIVERSIDAD DE
BURGOS ( ... )
5.7 Orden de ejecución de las expresiones

• Cuando hay muchos operadores en una expresión el orden viene
marcado por su precedencia y su asociatibidad:
– Un operador se ejecuta si el operador de su derecha
tiene menos precedencia que él o si tiene la misma y
tiene asociatibidad de izquierda a derecha
– Un operador espera el resultado del operador de su
derecha si este tiene más precedencia o si tiene la
misma y tiene asociatibidad de derecha a izquierda

UNIVERSIDAD DE
BURGOS
5 para k=3  i=4

2
resultado 2
variable operador literal
precedencia y asociatibidad
10
2
-8
4 5
-2
k += j = - 2 * i ++ + 7 / 3 * 5
15 15 2 4 2 5 4 4 fin
UNIVERSIDAD DE
BURGOS ( ... )
5.7.1 Cambios de precedencia

• Si se necesita usar un orden de evaluación de operadores distinto
se usan los operadores paréntesis ()
• Tienen la máxima precedencia (1): Se ejecutan primero las
subexpresiones entre paréntesis.
• Se ejecutan con asociatibidad de izquierda a derecha (marcada por
el paréntesis de cierre)

UNIVERSIDAD DE
BURGOS ( ... )
5.7.2 Ejemplos de ejecución de expresiones
Ejemplos:
55++AA//22 AA**BB %
% 44 cc++44//(A
(A++BB // 2)
2)**vv--11
+ y / => + espera
/ * / / y ( => / espera
( y + => ( espera
+ + y / => + espera
+ %
/ y ) => ejecuta /
/ + y ) => ejecuta
( y ) => desaparecen
+ y / => + espera * y % => ejecuta *
* / y * => ejecuta /
/ y fin => ejecuta / + y * => + espera
% y fin => ejecuta % +
+ y fin => ejecuta + * y - => ejecuta *
- + y - => ejecuta +
- y fin => ejecuta -

UNIVERSIDAD DE
BURGOS

Agrupar () 1 
Unarios & + - ++ -- 2 
3
Aritme-
ticos
Aditivos + - 5 
7
8
9
10
11
12
13
14
= *= /=
Asignación %= += -= 15 
<<= >>=
16

UNIVERSIDAD DE
BURGOS
Ejercicios
1. Haz un programa que pida 4. Haz un programa que pida

3 datos separados por 5 cantidades de céntimos
comas y diga cuantos ha de € y muestre los € en
leído. columna. 0'00
2. Escribe 10 números en 10'00
1234'56
columna con formato:
12345678'90
entero corto
entero largo 1000 -12345678'90
mínimo 3 dígitos 123445678
con signo 000
-1056
+123456
3. Escribe 10 números flotantes
en columna con formato.
UNIVERSIDAD DE
BURGOS
Ejercicios
Cambios de unidades
2. Haz programas que resuelvan h) pide unas cantidades de semanas, días, horas,
problemas de cambios de unidades: minutos y segundos y muestra su equivalente
a) pide una cantidad en kbytes y en segundos
muestra su equivalente en bytes i) pide una cantidades de segundos y muestra su
b) pide una cantidad en Mbytes y equivalente en minutos y el resto en segundos
muestra su equivalente en bytes j) pide una cantidades de segundos y muestra su
c) pide una cantidad en horas y equivalente en horas y el resto en minutos y
muestra su equivalente en seg segundos
d) pide una cantidad en áreas y k) pide una cantidades de segundos y muestra su
muestra su equivalente en m2 equivalente en días y el resto en horas,
e) pide una cantidad en m3 y muestra minutos y segundos
su equivalente en litros l) pide una cantidades de segundos y muestra su
f) pide unas cantidades de Hectáreas, equivalente en semanas y el resto en días,
áreas y centiáreas y muestra su horas, minutos y segundos
equivalente en m2 m) pide una cantidad en pesetas y muestra su
g) pide una cantidad de m2 y muestra equivalente en euros
su equivalente en Hectáreas, áreas n) pide una cantidad en euros y muestra su
y centiáreas equivalente en pesetas

2FP DatosDatosEnteros

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

2FP DatosDatosEnteros

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD DE

Tema 2: Datos. Datos enteros.

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:1

Tema 2: Datos. Datos enteros.

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:2

• Los programas manejan datos. • Los datos se almacenan en el

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:3

El tipo de datos es un identificador que representa:

Dos formas fundamentales de clasificar los tipos de datos:

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:4

1.1 Tipos de datos derivados

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:5

• Los datos pueden variar a lo • Hay datos que se muestran por

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:6

2.1 Datos constantes (I)

2.1 Datos constantes (y II)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:8

2.2 Datos variables (I)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:9

2.2 Datos variables (y II)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:10

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:11

3.1 Tipos de datos naturales

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:12

3.2 Tipos de datos naturales

Ver ejemplo de funcionamiento de la base 2 con 6 bits

3.2 Tipos de datos naturales

03 77777 77777L 18 446 744 073 709 551 615LL

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:14

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:15

4.1 Tipos de datos enteros

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:16

4.2 Tipos de datos enteros

Ver el ejemplo suponiendo que el peso del sexto bit es -32

4.2 Tipos de datos enteros

01 77777 77777L 9 223 372 036 854 775 807LL

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:18

5 Operaciones con números ℕ y ℤ

• Declarar variables • Salida de datos

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:19

5.1 Declarar variables ℕ y ℤ

unsigned short int n1; signed short int i1;

unsigned long int m1; signed long int j1;

opción long long k2;

5.2. /S de datos por pantalla

formato Especifica como va a ser Especificaciones de formato de los

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:21

5.2 Tipos de datos enteros

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:22

Ej. /S de datos enteros <1>

Ej. Tablas de multiplicar del 5

Ej. Tablas de multiplicar del 5

int main(){ /*Definición de la función ppal.*/

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:25

5.3 E/ de datos desde teclado (I)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:26

5.3 E/ de datos desde teclado (II)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:27

5.3 E/ de datos desde teclado (y III)

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:28

Tabla de precedencia de operadores

Categoría Operadores Precedencia Asociatividad

Curso 2009/10 Área de Lenguajes y Sistemas Informáticos FP:29

int main(){ /Definición de la función ppal./

int main(){ /Definición de la función ppal./

int main(){ /Definición de la función ppal./