Este documento describe diferentes temas relacionados con los tipos de datos en C/C++, incluyendo números enteros, reales, lógicos y caracteres. También cubre declaración de variables, entradas y salidas, palabras clave, funciones, arreglos y estructuras. Explica el uso de operadores como sizeof() para determinar el tamaño de los datos, y sentencias de control como if, else, while, for y do while.

1. Universidad Centroamericana
Facultad de ciencia, tecnología y ambiente.
Ingeniería en sistemas de la información
Estudiante:
Pablo Elias Galante.
Docente:
Ing. Elsner Boanerge González.
Carrera:
Ingeniería en sistemas de la información.
Asignatura:
Laboratorio de Programación I
Grupo:
0114
Jueves 25 de Agosto del 2016.

2. CONTENIDO
1. Tipos de datos................................................................................................................ I
1.1 Números enteros.................................................................................................... I
1.2 Números reales ......................................................................................................II
1.3 Lógicos.....................................................................................................................II
2. Juego de caracteres.....................................................................................................III
3. Declaración de variables ............................................................................................IV
4. Entradas y Salidas....................................................................................................... V
4.1 Salida en C ............................................................................................................ V
4.2 Entrada y Salida C++...........................................................................................VI
............................................................................................................................................VI
............................................................................................................................................VI
5. Palabras clave............................................................................................................VIII
6. Funciones......................................................................................................................IX
6.1 Size of ....................................................................................................................IX
Tipos de datos y requerimientos de memoria ................................................................ X
Tratamiento de los tipos por el compilador de C/C++...................................................XI
7. Arreglos ......................................................................................................................XIV
7.1 Concepto ............................................................................................................XIV
7.2 Sintaxis................................................................................................................XIV
8. Estructuras..................................................................................................................XV
8.1 Sintaxis.................................................................................................................XV
9. Ficheros......................................................................................................................XVI
9.1 fopen y fclose.....................................................................................................XVI
9.2 Rename .............................................................................................................XVII
9.3 Remove............................................................................................................. XVIII
9.4 fgetc.....................................................................................................................XIX
.........................................................................................................................................XIX
9.5 fgets.....................................................................................................................XIX
9.6 fread......................................................................................................................XX
9.7 fscanf....................................................................................................................XX

3. 9.8 fwrite ...................................................................Error! Bookmark not defined.
9.9 ftell ........................................................................................................................XX
10 Sentencias de control..........................................................................................XXII
10.1 if.......................................................................................................................XXII
10.2 if else...............................................................................................................XXII
10.3 while................................................................................................................XXII
10.4 for ....................................................................................................................XXII
10.5 do while ......................................................................................................... XXIII

4. I
1. TIPOS DE DATOS
1.1 Númerosenteros
Tipo de
Dato
Descripción Número de
bytes
Rango
short Entero corto 2 De -32768 a 32767
int Entero 4 De -2147483648
a +2147483647
long Entero largo 4 De -2147483648
a +2147483647
char Carácter 1 De -128 a 127
Tipo de Dato Descripción Número
de bytes
Rango
signed short Entero corto 2 De -32768 a 32767
unsigned
short
Entero corto sin
signo
2 De 0 a 65535
signed int Entero 4 De -2147483648 a +2147483647
unsigned int Entero sin signo 4 De 0 a 4294967295
signed long Entero largo 4 De -2147483648 a +2147483647
unsigned
long
Entero largo sin
signo
4 De 0 a 4294967295
signed char Carácter 1 De -128 a 127
unsigned
char
Carácter sin signo 1 De 0 a 255

5. II
1.2 Númerosreales
Tipo de Dato Descripción Número
de bytes
Rango
float Real (Número en
coma flotante)
4 Positivos: 3.4E-38 a
3.4E38
Negativos: -3.4E-38 a -
3.4E38
double Real
doble(Número en
coma flotante de
doble precisión)
8 Positivos: 1.7E-308 a
1.7E308
Negativos: -1.7E-308 a -
1.7E308
long double Real doble largo 10 Positivos: 3.4E-4932 a
1.1E4932
Negativos: -3.4E-4932 a
-1.1E4932
1.3 Lógicos
Tipo
de
Dato
Descripción Número
de bytes
Rango
bool Dato de tipo lógico 1 0, 1

6. III
2. JUEGO DE CARACTERES
El juego de caracteres es la equivalencia carácter a carácter de la codificación de
los caracteres de un lenguaje natural a un sistema de representación.
Este consta de 96 caracteres que pueden usarse en archivos de código
fuente. Este conjunto incluye el carácter de espacio, tabulación horizontal,
tabulación vertical, avance de página y caracteres de control de nueva línea, de
igual forma contiene el siguiente conjunto de caracteres gráficos:
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9
_ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | ~ ! = , " '

7. IV
3. DECLARACIÓN DE VARIABLES
Tipo de la variable, nombre de la variable y su inicialización

8. V
4. ENTRADAS Y SALIDAS
4.1 Salida en C
Se hace uso de printf a la hora de mostrar un mensaje

9. VI
4.2 Entrada y Salida C++

10. VII
Se utiliza cout para mostrar un mensaje y cin para leer datos

11. VIII
5. PALABRAS CLAVE
Las palabras clave son identificadores reservados predefinidos que tienen un
significado especial para el compilador. No se pueden usar como identificadores
en el programa.

12. IX
6. FUNCIONES
6.1 Size of
El operador size of proporciona la cantidad de almacenamiento, en bytes,
necesaria para almacenar un una variable o un tipo de dato específico

13. X
TIPOS DE DATOS Y REQUERIMIENTOS DE MEMORIA
Nº Instrucciones Resultado y Observaciones
1 Escriba el siguiente fragmento de código,
compile y ejecute:
int cantidad;
cantidad=100;
cout<<”valor: “<<cantidad<<endl;
cout<<”tamaño: “<<sizeof(cantidad)<<endl;
Aparece el valor que se le asignó a la
variable “cantidad” y el tamaño (4
bytes) del tipo de dato (entero) de la
variable “cantidad”.
2 Asigne a la variable cantidad el valor
1234567890 e imprima nuevamente la
cantidad de bytes que requiere.
Aparece nuevamente que el tamaño
requerido por la variable cantidad,
cuyo tipo de dato es entero es de 4
bytes.
3 Escriba el siguiente fragmento de código,
compile y ejecute:
float medida;
medida=20.2536;
cout<<”valor: “<<medida<<endl;
cout<<”tamaño: “<<sizeof(medida)<<endl;
Aparece el valor que se le asignó a la
variable “medida” y el tamaño (4
bytes) del tipo de dato (real) de la
variable “medida”.
4 Escriba el siguiente fragmento de código,
compile y ejecute:
char zona;
zona=’X’;
cout<<”valor: “<<zona<<endl;
cout<<”tamaño: “<<sizeof(zona)<<endl;
Aparece el valor que se le asignó a la
variable “zona” y el tamaño (1 byte)
del tipo de dato (real) de la variable
“zona”.
5 Escriba el siguiente fragmento de código,
compile y ejecute:
char ciudad[25];
ciudad=”Managua”;
cout<<”valor: “<<ciudad<<endl;
cout<<”tamaño: “<<sizeof(ciudad)<<endl;
Aparece error “Asignación del arreglo
inválida” debido a que se debe
inicializar la variable cuando esta se
declara en el caso de que se esté
trabajando con dimensiones.
6 Escriba el siguiente fragmento de código,
compile y ejecute:
double temperatura;
temperatura=25.123456789;
cout<<”valor: “<<temperatura<<endl;
cout<<”tamaño:
“<<sizeof(temperatura)<<endl;
Aparece el valor que se le asignó a la
variable “temperatura” y el tamaño (8
bytes) del tipo de dato (doble) de la
variable “temperatura”.
7 Escriba el siguiente fragmento de código,
compile y ejecute:
bool estado;
estado=false;
cout<<”valor: “<<estado<<endl;
cout<<”tamaño: “<<sizeof(estado)<<endl;
Aparece el valor de la variable
“estado” (0) y el tamaño (1 byte) del
tipo de dato (lógico) de la variable
“estado”.

14. XI
TRATAMIENTO DE LOS TIPOS POR EL COMPILADOR DE C/C++
Nº Instrucciones Resultado y Observaciones
1 Escriba el siguiente fragmento de código,compile y ejecute:
int cantidad;
cantidad=100;
cout<<”valor: “<<cantidad<<endl;
Se muestra el valor de la variable
“cantidad”, en este caso 100.
2 Modifique el valor asignado a la variable, compile y ejecute
cantidad=25.8945;
cout<<”valor: “<<cantidad<<endl;
Se muestra el valor de cantidad
pero redondeado, es decir no se
muestra la cifra completa.
3 Modifique el valor asignado a la variable, compile y ejecute
cantidad=’F’;
cout<<”valor: “<<cantidad<<endl;
Se muestra un valor distinto al
asignado, en este caso “70”.
4 Modifique el valor asignado a la variable, compile y ejecute
cantidad=”Completa”;
cout<<”valor: “<<cantidad<<endl;
Aparece que existe un “error:
conversión inválido al de const char
a int”. Es decir, la declaración
correcta sería un const char.
5 Modifique el valor asignado a la variable, compile y ejecute
cantidad=True;
cout<<”valor: “<<cantidad<<endl;
Se muestra el valor como “1”.
6 Escriba el siguiente fragmento de código,compile y ejecute:
float medida;
medida=20.2536;
cout<<”valor: “<<medida<<endl;
Se muestra el valor de la variable
“cantidad”, en este caso 20.2536.
7 Modifique el valor asignado a la variable, compile y ejecute
medida=85;
cout<<”valor: “<<medida <<endl;
Se muestra el valor asignado a la
variable, en este caso “85”.
8 Modifique el valor asignado a la variable, compile y ejecute
medida=’P’;
cout<<”valor: “<<medida <<endl;
Se muestra un valor distinto al
asignado, en este caso “80”.
9 Modifique el valor asignado a la variable, compile y ejecute
medida=”Corta”;
cout<<”valor: “<<medida <<endl;
Aparece que existe un “error:
conversión inválido al de const char
a float”. Es decir, la declaración
correcta sería un const char.
10 Modifique el valor asignado a la variable, compile y ejecute
medida=True;
cout<<”valor: “<<medida <<endl;
Se muestra el valor como “1”.
11 Escriba el siguiente fragmento de código,compile y ejecute:
char zona;
zona=’X’;
cout<<”valor: “<<zona<<endl;
Se muestra el valor asignado a la
variable, en este caso ‘X’.

15. XII
Nº Instrucciones Resultado y Observaciones
12 Modifique el valor asignado a la variable, compile y ejecute
zona=65;
cout<<”valor: “<<zona<<endl;
Se muestra un valor distinto al
asignado, en este caso “A”.
13 Modifique el valor asignado a la variable, compile y ejecute
zona=95.56;
cout<<”valor: “<<zona<<endl;
Se muestra un valor distinto al
asignado, en este caso “_”.
14 Modifique el valor asignado a la variable, compile y ejecute
zona=”Central”;
cout<<”valor: “<<zona<<endl;
Aparece que existe un “error:
conversión inválido al de const char
a char”. Es decir, la declaración
correcta sería un const char.
15 Modifique el valor asignado a la variable, compile y ejecute
zona=False;
cout<<”valor: “<<zona<<endl;
No se muestra ningún valor.
16 Escriba el siguiente fragmento de código,compile y ejecute:
ciudad=”Managua”;
cout<<”valor: “<<ciudad<<endl;
Aparece que la variable “ciudad” no
fue declarada.
17 Modifique el valor asignado a la variable, compile y ejecute
ciudad=25;
cout<<”valor: “<<ciudad<<endl;
Aparece que la variable “ciudad” no
fue declarada.
18 Modifique el valor asignado a la variable, compile y ejecute
ciudad=100.50;
cout<<”valor: “<<ciudad<<endl;
Aparece que la variable “ciudad” no
fue declarada.
19 Modifique el valor asignado a la variable, compile y ejecute
ciudad=’C’;
cout<<”valor: “<<ciudad<<endl;
Aparece que la variable “ciudad” no
fue declarada.
20 Modifique el valor asignado a la variable, compile y ejecute
ciudad=False;
cout<<”valor: “<<ciudad<<endl;
Aparece que la variable “ciudad” no
fue declarada.
21 Escriba el siguiente fragmento de código,compile y ejecute:
double temperatura;
temperatura=25.123456789;
cout<<”valor: “<<temperatura<<endl;
Se muestra el valor de cantidad
pero redondeado, es decir no se
muestra la cifra completa. En este
caso “25.1235”.
22 Modifique el valor asignado a la variable, compile y ejecute
temperatura=30;
cout<<”valor: “<<temperatura<<endl;
Se muestra el valor asignado a la
variable, en este caso “30”.
23 Modifique el valor asignado a la variable, compile y ejecute
temperatura=’T’;
cout<<”valor: “<<temperatura<<endl;
Se muestra un valor distinto al
asignado, en este caso “84”.

16. XIII
Nº Instrucciones Resultado y Observaciones
24 Modifique el valor asignado a la variable, compile y ejecute
temperatura=”Caliente”;
cout<<”valor: “<<temperatura<<endl;
Aparece que existe un “error:
conversión inválido al de const
char a double”. Es decir, la
declaración correcta sería un
const char.
25 Modifique el valor asignado a la variable, compile y ejecute
temperatura=True;
cout<<”valor: “<<temperatura<<endl;
Se muestra el valor como “1”.
26 Escriba el siguiente fragmento de código,compile y ejecute:
bool estado;
estado=false;
cout<<”valor: “<<estado<<endl;
Se muestra el valor como “0”.
27 Modifique el valor asignado a la variable, compile y ejecute
estado=100;
cout<<”valor: “<<estado<<endl;
Se muestra el valor como “1” y no
cómo “100”, los 0 son eliminados
en la salida.
28 Modifique el valor asignado a la variable, compile y ejecute
estado=500.85;
cout<<”valor: “<<estado<<endl;
Se muestra el valor como “1” y no
cómo “500.85”.
29 Modifique el valor asignado a la variable, compile y ejecute
estado=’E’;
cout<<”valor: “<<estado<<endl;
Se muestra el valor como “1”.
30 Modifique el valor asignado a la variable, compile y ejecute
estado=”Aceptado”;
cout<<”valor: “<<estado<<endl;
Aparece que existe un “error:
conversión inválido al de const
char a bool”. Es decir, la
declaración correcta sería un
const char.

17. XIV
7. ARREGLOS
7.1 Concepto
Los arreglos permiten agrupar datos usando un único identificador. Todos los
elementos de un arreglo son del mismo tipo, y para acceder a cada elemento se
usan índices.
7.2 Sintaxis
“Tipo de datos dentro del arreglo” “Nombre del arreglo” [Cantidad de elementos];

18. XV
8. ESTRUCTURAS
Al contrario que los arreglos, las estructuras permiten agrupar varios datos que
mantengan algún tipo de relación, aunque sean de distinto tipo, permitiendo
manipularlos todos juntos usando un mismo identificador, o cada uno por
separado.
Las estructuras son llamadas también muy a menudo registros o en inglés,
records. Tienen muchos aspectos en común con los registros usados en bases de
datos. Cada objeto de una estructura se denomina a campo, o field.
8.1 Sintaxis
struct “identificador”{
[“tipo” “nombre_objeto” [nombre_objeto]];
}”objeto_estructura”[“objeto_estructura”,…];

19. XVI
9. FICHEROS
9.1 fopen y fclose
El fopen abre el documento cuyo nombre es especificado en el parámetro y el
fclose cierra el documento.
"r" Lectura: Abre el archivo para operaciones de entrada. El archivo debe
existir.
"w" Escritura: Crea un archivo vacío para operaciones de salida. Si el archivo
con el mismo nombre ya existe, su contenido es borrado y el archivo es
tratado como un archivo nuevo vacío. Es decir, se sobrescribe.
"a" Añadir: Abre un documento para la salida al final de un documento. Las
operaciones de salida siempre escriben datos al final del documento,
expandiéndolo. El documento es creado si no existe.
"r+" Lectura/actualización: Abre un documento para actualización (ambos para
entrada y salida). El documento debe existir.
"w+" Escritura/actualización: Crea un archivo vacío y lo abre para actualización
(ambos para entrada y salida). Si el archivo con el mismo nombre ya
existe, su contenido es borrado y el archivo es tratado como un archivo
nuevo vacío. Es decir, se sobrescribe.
"a+" Añadir/actualización: Abre un archivo para actualización (ambos para
entrada y salida. El archivo es creado si no existe.

20. XVII
9.2 Rename
Se asigna como nuevo nombre de archivo a “new”.

21. XVIII
9.3 Remove
Se elimina el archivo que se renombró anteriormente.

22. XIX
9.4 fgetc
Esta función lee un carácter a la vez del archivo que está siendo señalado con el
puntero *archivo. En caso de que la lectura sea exitosa devuelve el carácter leído
y en caso de que no lo sea o de encontrar el final del archivo devuelve EOF.
9.5 fgets
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1
caracteres o hasta que lea un cambio de línea 'n' o un final de archivo EOF. En
este último caso, el carácter de cambio de línea 'n' también es leído.

23. XX
9.6 fread
Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de un
arreglo de elementos "count", cada uno de los cuales tiene un tamaño definido por
"size". Luego los guarda en el bloque de memoria especificado por "ptr". El
indicador de posición de la cadena de caracteres avanza hasta leer la totalidad de
bytes. Si esto es exitoso la cantidad de bytes leídos es (size*count).
9.7 fscanf
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada
se toma de un fichero en lugar del teclado.
El prototipo correspondiente de fscanf es:
int fscanf(FILE *fichero, const char *formato, argumento, ...);
9.8 fwrite
Esta función está pensada para trabajar con registros de longitud constante y
forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros
de la misma longitud almacenados a partir de una dirección de memoria
determinada. El valor de retorno es el número de registros escritos, no el número
de bytes. Los parámetros son: un puntero a la zona de memoria de donde se
obtendrán los datos a escribir, el tamaño de cada registro, el número de registros
a escribir y un puntero a la estructura FILE del fichero al que se hará la escritura.
9.9 ftell
La función ftell retorna el valor del indicador de posición de fichero para el stream,
si se tiene éxito. Si falla, la función ftell retorna -1L y guarda un valor positivo,
según la definición de la implementación, en errno.

24. XXI

25. XXII
10 SENTENCIAS DE CONTROL
10.1if
La sentencia if («si») ejecuta las instrucciones sólo si se cumple una condición. Si
la condición es falsa, no se hace nada:
if (condición)
{
sentencias
}
10.2if else
La sentencia if-elif-else depende de dos o más condiciones, que son evaluadas en
orden. La primera que es verdadera determina qué instrucciones serán
ejecutadas:
if (condición)
{
sentencias
}
else {
}
10.3while
El ciclo while («mientras») ejecuta una secuencia de instrucciones mientras una
condición sea verdadera:
while (condición)
{
sentencias
}
10.4for
El ciclo for con rango ejecuta una secuencia de sentencias una cantidad fija de
veces.
Para llevar la cuenta, utiliza una variable de control que toma valores distintos en
cada iteración.
for (int i, i<5, i++)
{
sentencias
}

26. XXIII
10.5do while
En un bucle do while, primero se ejecuta el bloque de instrucciones y, después, se
evalúa la condición. En el caso de que ésta sea verdadera, se vuelve a ejecutar el
bloque de instrucciones. Y así sucesivamente, hasta que, la condición sea falsa.
do {
sentecias }
while (condición)

27. XXIV
11. FUNCIONES
Una función es un conjunto de líneas de código que realizan una tarea específica
y puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen
su funcionamiento. Las funciones son utilizadas para descomponer grandes
problemas en tareas simples y para implementar operaciones que son
comúnmente utilizadas durante un programa y de esta manera reducir la cantidad
de código. Cuando una función es invocada se le pasa el control a la misma, una
vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la
función fue llamada.
Ejemplo de sintaxis:
<tipo> [clase::] <nombre> ( [Parámetros] )
{
cuerpo;
}
Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya
sea como constantes literales o como variables, aunque se pueden definir
funciones que reciban parámetros. Existen dos formas en C++ de pasar
parámetros a una función; por referencia o por valor. El hecho es que si en una
declaración de función se declaran parámetros por referencia, a los mismos no se
les podrá pasar valores literales ya que las referencias apuntan a objetos
(variables o funciones) residentes en la memoria; por otro lado, si un parámetro es
declarado para ser pasado por valor, el mismo puede pasarse como una constante
literal o como una variable. Los parámetros pasados por referencia pueden ser
alterados por la función que los reciba, mientras que los parámetros pasados por
valor o copia no pueden ser alterados por la función que los recibe, es decir, la
función puede manipular a su antojo al parámetro, pero ningún cambio hecho
sobre este se reflejará en el parámetro original.
Parámetrospor valor
La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de
parámetros por valor, en ese sentido la función cuadrado() recibe una copia del
parámetro n. En la misma función se puede observar que se realiza un calculo (
n*n ), sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá
siendo cierto aún cuando dentro de la función hubiera una instrucción parecida a n
= n * n; o n*=n;.

28. XXV
Parámetrospor referencia
Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar
el caso de la función cuadrado, salvo que en esta ocasión cambiaremos
ligeramente la sintaxis para definir la misma.