DEPARTAMENTO DE CIENCIAS DE LA TIERRA Y LA CONSTRUCCIÓN

INGENIERÍA CIVIL

FUNDAMENTOS DE LA PROGRMACION

Tema: TIPOS DE DATOS

NRC: 3203

Profesor: Fausto Meneses

Nombre:

Madelaine Tayupanda

Nicole Galarza

Jessica Quilumba

Sep19-Feb20
 Índice
2.1. INTRODUCCION ..................................................................................................... 3
2.2. TIPOS DE DATOS ................................................................................................... 3
2.2.1. Tipo char ................................................................................................................ 3
2.2.3. Tipo float ................................................................................................................ 3
2.2.4. Tipo double ............................................................................................................. 4
2.2.5. Tipo void ................................................................................................................. 4
2.3. CONSTANTES ......................................................................................................... 4
2.3.1. Constantes carácter ................................................................................................. 4
2.3.2. Constantes Enteras .................................................................................................. 4
2.3.3. Constantes de Punto Flotante ................................................................................. 4
2.3.4. Constantes Cadena .................................................................................................. 4
2.4 IDENTIFICADORES ................................................................................................. 4
2.5. DECLARACION DE VARIABLES ......................................................................... 5
2.6. VARIABLES CADENAS DE CARACTERES ....................................................... 5
2.7. INICIALIZACION DE VARIABLES ...................................................................... 5
2.8. CONSTANTES SIMBOLICAS ................................................................................ 5
2.9. MODIFICADORES DE ACCESO ........................................................................... 5
2.9.1. El modificador const............................................................................................... 5
2.9.2. El modificador volatile ........................................................................................... 6
2.10. COMENTARIOS .................................................................................................... 6
2.11. OPERADORES ....................................................................................................... 6
2.11.1. Operador de Asignación ....................................................................................... 6
2.11.2. Operadores Aritméticos ........................................................................................ 6
2.11.3. Operadores Relacionales ...................................................................................... 7
2.11.4. Operadores Lógicos .............................................................................................. 8
2.11.5. Operadores a Nivel de Bits ................................................................................... 8
2.11.6. Otros operadores ................................................................................................... 9
2.11.7. Precedencia de operadores : ............................................................................... 11
2.12. EXPRESIONES. EVALUACIÓN DE EXPRESIONES ...................................... 11
2.13. CONVERSIONES DE TIPOS .............................................................................. 12
2.13.1. Automática ......................................................................................................... 12
2.13.2. Moldes (Casting) ................................................................................................ 13
CONCLUSION .............................................................................................................. 13
Bibliografía ..................................................................................................................... 13
 TIPOS DE DATOS

2.1. INTRODUCCION
Los datos se pueden representar mediante constantes o variables.
a) Constantes
Son datos preseleccionados en tiempo de compilación del programa.
b) Variables
Es una posición de memoria con nombre, en donde se guarda su valor.

2.2. TIPOS DE DATOS

El tipo de dato define un conjunto de valores que puede tener una variable, junto con un
conjunto de operaciones que se pueden realizar sobre esa variable.
En C existen cinco tipos de datos básicos:
 char (carácter)
 int (entero)
 float (punto flotante)
 double (punto flotante de doble precisión)
 void (sin valor)
Modificadores. A excepción de tipo void, para rango y signo:
 signed
 unsigned
 long
 short

2.2.1. Tipo char

Representa caracteres definidos por el código ASCII
2.2.2. Tipo int
Almacena enteros de una manera directa y en su representación binaria correspondiente.
a) Enteros con signo. Son los tipos de datos: int, signed int, short int, signed short
int, long int y signed long int. Los valores permitidos para estos tipos son
números enteros positivos, negativos o cero.
b) Enteros sin signo. Son los tipo de datos: unsigned int, unsigned short int, y
unsigned long int; los cuales pueden ser únicamente positivos o cero.

2.2.3. Tipo float

Numero reales que abarcan un rango mayor a los enteros.
Para almacenar un número de tipo float se lo divide en dos partes:
 Parte fraccionaria (precisión del número)
  Parte del exponente (tamaño del número)

2.2.4. Tipo double

Son los mismos números de punto flotante, pero con mayor precisión.

2.2.5. Tipo void

No tiene tipo de dato y se utiliza para: declarar explícitamente una función que no
devuelve valor alguno.

2.3. CONSTANTES

2.3.1. Constantes carácter

Una constante char puede representar un único carácter que normalmente corresponde al
código ASCII, y que va encerrada entre apóstrofes. Puede ser introducido de las dos
formas siguientes:
1. Secuencias de escape. Son caracteres especiales predefinidos, que deben usar una
“barra invertida “y luego su código
2. Uso del número de código ASCII. Indica el carácter correspondiente; debe
escribirse en octal o en hexadecimal, luego de una barra

2.3.2. Constantes Enteras

Especifican números enteros, es decir, sin parte fraccionaria. Pueden ser:
Octal. Comienza por el carácter 0, por ejemplo: 020 (16 en decimal)
Hexadecimal. Comienza por los caracteres 0x, por ejemplo: 0x20 (32 en decimal)

2.3.3. Constantes de Punto Flotante

Requieren el punto decimal seguido de los números de la parte fraccionaria.
NOTA: Por omisión el compilador de C escoge el tipo de dato compatible más pequeño
que pueda albergar a una constante numérica entera.
La excepción es las constantes en “punto flotante”, que se asumen de tipo double.

2.3.4. Constantes Cadena

Es una secuencia de caracteres encerrada entre comillas.

2.4 IDENTIFICADORES

Son los nombres usados para referenciar las constantes simbólicas, variables, funciones,
etiquetas y otros objetos definidos por el usuario. (Granizo, 1999)
El primer carácter siempre debe ser una letra del alfabeto inglés o el carácter subrayado.
En C las letras minúsculas y mayúsculas se tratan como distintas.
2.5. DECLARACION DE VARIABLES

Todas las variables en C deben ser declaradas antes de poder ser usadas.
Existen 3 sitios donde se pueden declarar variables:
a) Variables Locales
Se declaran dentro de un “bloque de código”. Solo existen mientras se ejecuta el bloque
de código en el que ha sido declarada.
b) Parámetros Formales
Si la función usa argumentos, deben declararse las variables que van a aceptar los valores
de esos argumentos.
c) Variables Globales
Se crean declararlas en cualquier parte fuera de una función.

2.6. VARIABLES CADENAS DE CARACTERES

Una cadena en C almacena como un array de tipo char.

La declaración de un array de caracteres se hace de la siguiente manera:
char nombre[35]
dónde: [], identifican la variable nombre como un array
35, indica el número de elementos máximo del array
char, indica el tipo de dato de cada elemento

2.7. INICIALIZACION DE VARIABLES

Consiste en otorgar un valor a dicha variable, en el momento que se compila el programa.

2.8. CONSTANTES SIMBOLICAS

Se utiliza el preprocesador #define.

El preprocesador. Mira el programa antes de compilar el mismo.

2.9. MODIFICADORES DE ACCESO

2.9.1. El modificador const

Ayuda a identificar las variables que nunca cambian de valor
2.9.2. El modificador volatile
Ayuda a identificar las variables que pueden cambiar inesperadamente debido a causas
que escapan del control del programa.

2.10. COMENTARIOS
En C todos los comentarios empiezan con el par de caracteres /* y terminan con */

2.11. OPERADORES
Operador. Es el que realiza una acción sobre uno o más datos.
Operando. Es sobre lo que opera el operador: los datos.
A más del operador de asignación, C define cuatro clases de operadores:
 Aritméticos
 Relacionales
 Lógicos
 A nivel de bits

2.11.1. Operador de Asignación

El operador de asignación (=) se puede usar en cualquier expresión valida y consiste en
dar valores a las variables

2.11.2. Operadores Aritméticos

Los operadores aritméticos en lenguaje C operan de izquierda a derecha, y pueden
aplicarse a casi todos los tipos de datos predefinidos en lenguaje C.
Operador Acción
- Resta o unario de signo
+ Suma
* Multiplicación
/ División
% Residuo
++ Incremento
-- Decremento
Los primeros cinco operadores son binarios y los operadores ++ y – son unitarios.
 Los operadores: -, + y * operan igual que en el álgebra
 La división (/). Funciona de 2 maneras:
a) La división entre números en punto flotante da un resultado en punto flotante.
b) La división entre enteros produce un resultado entero.
 El residuo (%). Determina el residuo de la división entera, solo para números
enteros. Por ejemplo:
13 % 5 ,da un resultado de 3
 Incremento (++). Es un operador unario que incrementa uno al valor de su
operando entero, que debe ser una variable. Existen 2 tipos:
a) Prefijo. El lenguaje C lleva a cabo la operación de incremento antes de utilizar el valor
del operando.
b) Sufijo. El lenguaje C utiliza su valor antes de realizar la operación de incremento.
Prefijo. se asigna a y el valor de 11
x = 10;
y = ++x;
Sufijo y toma el valor de 10
x = 10;
y = x++;
En ambos casos x queda con el valor de 11.
Ventajas:
1. Hace los programas más compactos, elegantes y fáciles de leer.
2. Genera un código compilado más rápido y eficiente.
 Decremento (--). Este operador se comporta en forma similar al
operador incremento, pero éste decremento en 1 al valor de la variable.
NOTAS:
 Para las cuatro operaciones aritméticas, la operación mixta entre operandos
de tipo entero y punto flotante da un resultado en punto flotante.
 Cuando se utiliza el operador de incremento o decremento en solitario en
una sentencia, las sentencias son equivalentes
Abreviaturas. Son una combinación de los operadores aritméticos binarios con el
operador de asignación (=).
La forma general de las abreviaturas es:
Variable operador = expresión;
 variable, se actualiza utilizando el valor de la expresión.
 operador, puede ser un operador aritmético ó un operador lógico.

2.11.3. Operadores Relacionales

En lenguaje C se emplean para hacer comparaciones entre valores del mismo tipo
como: enteros, punto flotante y caracteres. Estos operadores operan de izquierda a
derecha
.
Operador Acción
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor o igual que
== Igual que
!= Diferente que
Observaciones de los operadores relacionales:
Para la comparación de caracteres se emplea el código ASCII.
Las cadenas de caracteres no se pueden comparar (se verá más adelante).
Para comparar números de punto flotante se usan únicamente los operadores < y
>, porque dos números de punto flotante no pueden ser necesariamente iguales,
cuando son resultados de operaciones aritméticas, debido a errores de redondeo o
truncamiento.
Las expresiones que utilizan los operadores relacionales devuelven el valor 1 en caso de
verdadero y 0 en caso de falso.
3>5 el resultado es 0
2 == 9 el resultado es 0
'x' > 0 el resultado es 1 /* Compara el ordinal de x con 0 */

2.11.4. Operadores Lógicos

Combinan dos o más expresiones de relación.
Operador Acción
&& AND
11 OR
! NOT
Los operadores lógicos producen un resultado verdadero (1) o falso (0).
p q p&&q p11q !p
0 0 0 0 1
0 1 0 1 1
1 0 0 1 0
1 1 1 1 0

2.11.5. Operadores a Nivel de Bits

Se refieren a la comprobación, asignación o desplazamiento de los bits individuales que
componen un byte o una palabra de memoria, que a su vez corresponden a los tipos
estándar del lenguaje C: char e int con sus variantes.
No se pueden usar sobre los tipos: float, double, long double y void.
Operador Acción
& AND
| OR
^ OR exclusiva (XOR)
~ Complemento a 1 (NOT)
>> Desplazamiento a la derecha
<< Desplazamiento a la izquierda
Los operadores AND, OR, y NOT a nivel de bits están gobernados por las mismas
tablas de verdad que sus equivalentes lógicos, pero trabajan bit a bit.
La tabla de verdad del operador XOR
 p q p^q
0 0 0
0 1 1
1 0 1
1 1 1
Las operaciones sobre bits son frecuentemente usadas en aplicaciones de
controladores de dispositivos, tales como programas para modems, rutinas de archivos de
disco y rutinas de impresora. Porque permiten enmarcar ciertos bits.
Descripción de cada operador:
00000101 (5)
AND pone los bits a cero. 5 & 127 & 01111111 (127)
00000101
10000000 (128)
OR pone los bits a uno 128 | 3 | 00000011 (3)
10000011
01111111 (127)
XOR pone los bits a uno,
127 ^ 120 ^ 01111000 (120)
cuando son distintos.
00000111
NOT(complemento a 1),
~ 01111011 (123)
cambia el estado de cada bit ~ 123
10000100
en la variable especificada,
 La expresión de desplazamiento a la derecha es:
variable >> número de posiciones en bits
 La expresión de desplazamiento a la izquierda es:
variable << número de posiciones en bits
char x; x luego de la operación Valor de x
x=7; 00000111 7
x=x<<4; 01110000 112, multiplica por 24 =16
x=x>>2; 00011100 28, divide por 22 = 4
Por último, los operadores a nivel de bits son útiles cuando se decodifica la entrada a
través de dispositivos externos, como Conversores D/A. También, se usan en rutinas para
descifrado, cuando se quiere que el archivo aparezca ilegible.

2.11.6. Otros operadores

a) El operador ?: se denomina "expresión condicional", que abrevia a la sentencia
de control if-else.
Su forma general:
Expresion1 ? Expresion2 : Expresion3
 Si Expresion1 es verdadera (distinta de cero) la expresión total toma el valor
de Expresion2.
 Si Expresion1 es falsa (igual a cero) la expresión total toma el valor de
Expresion3.
Se usa cuando se tiene una variable que puede tomar dos valores posibles.
NOTA: Para mejor claridad del programa en lenguaje C, la condición de las
sentencias va entre paréntesis.
b) Operadores & y *
 Un puntero. Es la dirección de memoria de una variable de cualquier tipo, que
se fija en el momento de la compilación.
 Variable puntero. Es una variable declarada para almacenar un puntero a su tipo
especificado.
Las variables que vayan a contener (punteros), deben declararse como punteros
colocando un * delante del nombre de la variable.
 Tipo base del puntero. Es el tipo de dato al que apunta un puntero, en este caso
int.
Funciones básicas de los punteros en lenguaje C:
1. Pueden proporcionar una rápida forma para referenciar los elementos de un
arreglo.
2. Permiten a las funciones de lenguaje C modificar los parámetros de llamada.
3. Dan soporte a las listas enlazadas y a otras estructuras dinámicas de datos.
Los operadores dirección e indirección se describen a continuación:
 Operador de Dirección &. Es un operador unario que devuelve la "dirección" de
memoria del operando.
 Operador de Indirección *. Es el complementario de &, es un operador
unario que devuelve el "contenido" del operando, que debe ser un puntero.
c) Operador de compilación sizeof
El operador sizeof es un operador unario en tiempo de compilación, que devuelve
la longitud en bytes de la variable, o del especificador de tipo entre paréntesis.
d) La coma como operador
La coma produce una secuencia de operaciones cuando se utiliza en la parte derecha
de una sentencia de asignación.

e) Los Operadores punto y flecha

Los operadores punto (.) y flecha (->) referencian elementos individuales de las
"estructuras" y de las "uniones".
Las "estructuras" y las "uniones" son tipos de datos compuestos que almacenan
distintos tipos de datos, que pueden referenciarse bajo un solo nombre.
 El Operador punto. Se usa cuando se trabaja directamente con la "estructura" o
la "unión".
  El operador flecha. Se aplica cuando se usa un puntero a una "estructura" o una
"unión".
f) Los paréntesis y los corchetes como operadores
 Los paréntesis ( ). Son operadores que aumentan la precedencia de las
operaciones que contienen.
 Los corchetes [ ]. Llevan a cabo la indexación de los elementos de un
arreglo mediante un índice.
2.11.7. Precedencia de operadores : Es el orden en el cual se evalúan los operadores.
DESCRIPCIÓN OPERADORES
--------- ( ) [ ] ->
Unarios ! ~ ++ -- - (tipo) * & sizeof
Multiplicativos */%
Aditivos +-
Desplazamiento << >>
Relación < <= > >=
Relación == !=
AND sobre bits &
XOR sobre bits ^
OR sobre bits |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación y abreviaturas = += -= *= /= %=
Coma ,
Observaciones:
 Los operadores: unarios, condicional, de asignación y abreviaturas, se evalúan de
derecha a izquierda.
 El resto de los operadores que tienen el mismo nivel de precedencia son
evaluados de izquierda a derecha.
 Cuando se utiliza operadores lógicos y de relación su resultado es siempre
1 o 0. Además, no se necesitan paréntesis porque los operadores lógicos
tienen menor precedencia que los operadores de relación.

2.12. EXPRESIONES. EVALUACIÓN DE EXPRESIONES

La evaluación de las expresiones se realiza de acuerdo a la precedencia
preestablecida.
6 + ( c = 3 + 8 ) != ( 2 < 3 && 10 )

11 1

c=11 1
 17

1
Nota: El estándar ANSI estipula que las subexpresiones (entre paréntesis) de una
expresión, pueden ser evaluadas en cualquier orden.
Por ejemplo:
x = (a + b) * (c + d);
En esta expresión podrá evaluarse primero (a + b) o (c + d), indistintamente.
Se recomienda no usar el operador incremento en expresiones de este tipo.

2.13. CONVERSIONES DE TIPOS

Cuando en una expresión se mezclan constantes y variables de distintos tipos, todas ellas
se convierten a un tipo único.

2.13.1. Automática
Se realiza la conversión automáticamente de todos los operandos al mismo tipo.
Las reglas básicas son las siguientes: (SCHILDT, 1994)
a) La categoría de los tipos está dado por su tamaño de bytes; el de mayor valor tiene
mayor categoría.
long double
double
float
unsigned long int
long int
unsigned int
int
unsigned char
char
b) El resultado de una "sentencia de asignación" se convierte al tipo de la variable a
la que se asigna el valor de la expresión.
En la "pérdida de rango" los bits más significativos se pierden, de acuerdo:
TIPO TIPO POSIBLE PÉRDIDA DE
DESTINO EXPRESIÓN INFORMACIÓN
signed char char Si valor > 127, destino negativo
char short int 8 bits más significativos
char int 8 bits más significativos
char long int 24 bits más significativos
int long int 16 bits más significativos
int float Parte fraccional
float double Precisión, resultado redondeado
 double long double Precisión, resultado redondeado
c) En cualquier operación que aparezcan dos tipos diferentes de datos, se convierte
el operando de "menor categoría" al de "mayor", y el resultado de la operación
será también del mismo tipo que los dos operandos. Este proceso se denomina
"promoción de tipo".

2.13.2. Moldes (Casting)

Es posible convertir una expresión a un tipo determinado, especificando el tipo
concreto de conversión al que se desee; pero se debe tener en cuenta que el dato que se
convierte al nuevo tipo, debe estar dentro del rango de este tipo.
La forma general de un molde es:
(tipo) expresión
donde:
 tipo, es uno de los tipos estándares del lenguaje C.
 expresión, es una expresión de cualquier tipo.
A menudo los moldes son considerados como operadores unarios.

CONCLUSION
 El lenguaje de programación es una parte fundamental del programa ya que nos
permite traducir ciertas órdenes a un lenguaje que la computadora puede entender
para lo cual se debe principalmente declarar las variables para que el programa
pueda hacer uso de las mismas, todas las variables del programa se declaran de la
misma forma, indicando cada una de ellas el tipo de dato que puede almacenar y
su nombre.

Bibliografía
Granizo, E. (1999). Obtenido de https://es.scribd.com/doc/232419977/Lenguaje-C-
Teoria-y-Ejercicios-Por-Evelio-Granizo-Montalvo