Lenguaje C - Introducción

Palabras Librerías y
reservadas. funciones.

Identificadores.
 if include

void else

for while
stdio.h

conio.h

math.h
Constantes Variables.

Funciones
char float int
 TIPOS DE DATOS
TIPO RANGO Memoria
Requerida

char 0 a 255 8 bits

int -32768 a 32767 o 16 bits
-2,147,483,648 a o
2,147,483,647 32 bits
float 6 dígitos de precisión 32 bits

double 12 dígitos de 64 bits

precisión
 Son los datos de la A..Z
incluyendo minúsculas

Todo el conjunto de caracteres

(código ASCII)

Dígitos (0..9), signos de

puntuación

Caracteres especiales
Limitados por su rango, aunque puede extenderse con los
modificadores de tipo, dependiendo del compilador
trabajarán con 2 o con 4 bytes.

No tienen parte fraccionaria.

1. Flotante
Llamados float, están conformados por una parte entera y
una decimal. Se almacenan en 4 bytes y su rango de
valores va de 1.2E-38 a 3.4E+38
Ejemplo: 8.75
2. Doble precisión
Llamados double, igual que los flotantes pero se
almacenan en 8 bytes, su rango va de 2.3E-308 a
1.7E+308
#include <stdio.h> Sección de Librerías

int main (void) Función Principal

{ Inicio de la función

int n1,n2,sum; Declaración de variables

printf(" Programa que suma dos números: ");
printf(" números: ");
scanf("%d%d" , &n1,&n2);
Desarrollo de la función
sum= n1+ n2;
printf("Suma es: %d",suma);
return 0;
} Fin de la función
 Las variables son un identificador de gran uso en el lenguaje C,
representan un nombre para identificar posiciones de la memoria,
en dichas posiciones está almacenada la información que nos
interesa la cual será del tipo que este especificada la variable.
Nombre de Variables
Este nombre de la variable debe ser un identificador válido, el cual
sigue estas reglas:
» Iniciar con una letra del alfabeto inglés, o con el signo (_)
» No debe contener caracteres especiales, tales como @, $, #
» Después de la primera letra puede contener más letras
del alfabeto inglés, números, o el carácter (_)
» NO DEBE haber espacios en blanco en los identificadores
» C diferencía mayúsculas de minúsculas, entonces no es lo mismo
declarar la variable numero que Numero o NuMeRo
» Existen palabras propias del lenguaje (las palabras reservadas) que
no pueden ser usadas como identificadores ej: if, do
» Una norma no forzada es especificar que todas los nombres de las
variables estén en minúsculas y puedan contener numeros sin
iniciar el nombre con los mismos y si el nombre está conformado
por más de una palabra entonces iniciar cada palabra adicional
con mayúscula. Ej. variable25, miVariable, estaEsMiVariable.
En las variables (posiciones de memoria) se guardan los datos
usados por el programa durante su ejecución.
En lenguaje C TODA variable debe ser DECLARADA antes de poder
ser utilizada.
La declaración de variables en C tiene la siguiente sintaxis:
Tipo_Dato Nombre_Variable [= Valor_Variable];
Ejemplo:
int MiVariable = 5;
Se pueden declarar multiples variables del mismo tipo separadas
por comas.
int MiVariable1, MiVariable2 = 5, MiVariable3;
La declaración de variables del tipo int, long, double y float supone
el manejo de tipos de dato numérico, el alcance y comportamiento
de los mismos dependerá directamente del tipo de dato que se esté
manejando, recordemos nuestra tabla que nos indica el rango y
precisión de estos tipos de datos
 Se tienen de acuerdo a su alcance dentro del programa, 3 tipos de
variables
» Variables globales: Son las que se declaran después del llamado a
las librerías, pero antes de cualquier función, y son útiles para
cualquier parte del programa.
» Variables locales: Son las que se declaran dentro de una función, y
solo sirven para ser usadas dentro de esa función.
» Variables estáticas: Son variables locales dentro de una función
que conservan su valor en distintas llamadas a dicha función.
Para declarar variables globales debemos especificarlas fuera de
las funciones -main incluida- para que su alcance sea global a todo
el programa
//llamado a las librerías
Tipo_dato1 variable1, variable2, … , variable_N;
Tipo_dato2 variable3, variable4, … , variable_X;
//declaración de funciones{…}

Ejemplo:
#include <stdio.h>
char caracter;
float iva,total_pagar,descuento;
unsigned long pvc,tcd;
void main(){
…
//instrucciones;
...
}
Las variables locales por otro lado deben ser incluidas dentro
de las funciones y solo serán visibles para dicha función
//llamado a las librerías
//declaración de una función
{
Tipo_dato1 variable1, variable2, … , variable_N;
Tipo_dato2 variable3, variable4, … , variable_X;
}

Ejemplo:
#include <stdio.h>
void main(){
int numero,edad,cantidad;
float iva,total_pagar,descuento;
unsigned long pvc,tcd;
//instrucciones;
...
}
Finalmente las variables estáticas se declaran dentro de una
función y se establece la palabra reservada static para señalar que
son de tipo estático
//llamado a las librerías
//declaración de una función
{
static Tipo_dato1 variable1, variable2, … , variable_N;
static Tipo_dato2 variable3, variable4, … , variable_X;
}

Ejemplo:
#include <stdio.h>
void main(){
int numero,edad,cantidad;
static float iva;
float total_pagar,descuento;
unsigned long pvc,tcd;
//instrucciones;
...
}
El siguiente ejemplo muestra el comportamiento de las variables
locales estáticas, no hay que preocuparse ahora mucho del tema
de funciones sino en entender que el valor de una variable static
permanece a pesar de que la función que la contiene no esté
activa.
#include <stdio.h>
int main()
{
calculaValor();
calculaValor();
calculaValor();
return 0;
}
void calculaValor()
{
static int valor = 0;
printf("El valor calculado es %d",valor);
valor ++;
}
Son aquellos valores que, una vez compilado el programa, no pueden ser
cambiados.
Al definir las constantes, debemos tomar en cuenta las siguientes reglas de
conversión de tipos de datos:
1.- Una constante entera (sin parte decimal) es tomada como tal, a menos que
se la añadan las letras F ó L (mayúsculas ó minúsculas) ejemplos :
1 : tomada como entera (int)
12f : tomada como flotante (float)
456L : tomada como doble larga (long double)
2.- Una variable con parte decimal es tomada siempre como DOUBLE, salvo
que se la siga de la letra F ó L
2.0 : tomada como doble (double)
3.56F : tomada como flotante (float)
1.007L : tomada como flotante larga (long float)
3.- Si en cualquiera de los casos anteriores agregamos la letra U o u la
constante queda calificada como UNSIGNED:
86u : tomada como entera sin signo (unsigned int)
32.44632UL : tomada como doble larga sin signo (unsigned long double)
4.- Una variable numérica que comienza con "0" (cero) es tomada
como OCTAL así : 012 equivale a 10 unidades en numeración decimal
5.- Una variable numérica que comienza con "0x" ó "0X" (cero – equis) es
tomada como HEXADECIMAL así : 0x16 equivale a 22 unidades en numeración
decimal
La sintaxis para declarar constantes es:
//llamado a las librerías
#define constante1 valor1;
#define constante2 valor2;
…
//declaración de una función{ ... }

Ejemplo:
#include <stdio.h>
#define PI 3.141592 //constante double
#define OCTAL 017 //constante octal
#define FLOTANTE 14F //constante flotante
Void main(){
…
//instrucciones;
... }
Como pudimos notar en el ejemplo una regla no forzada (puede no seguirse) en
la declaración de constantes es especificar el nombre de las mismas
en mayúsculas con el objeto de no confundirlas con variables que pudieran
llevar incluso el mismo nombre.
Existen otras 2 formas de declarar constantes en C, mediante el uso de las
cláusulas enum y const.
Ejemplo:
#define CONSTANTE_DEFINE 5
Es equivalente a:
enum T_ENUM { CONSTANTE_ENUM = 5 };
const int CONSTANTE_CONST = 5;
La principal diferencia es que la cláusula #define especifica un valor que el
compilador entenderá como una sustitución de un valor por otro más que
una asignación por ejemplo en nuestro caso todas las veces que apareciera
CONSTANTE_DEFINE en nuestro programa el compilador lo interpretará como
un 5, es decir como si fuera un alias, en el caso de enum y const, estos
permiten no solo manejar la equivalencia sino un tipo de dato asociado, en el
caso de enum solamente enteros y const maneja todos los tipos de datos por
lo que es más recomendable manejar constantes con esta última opción
siempre que sea posible.
En lenguaje C no hay palabras reservadas para realizar las acciones
de Entrada/Salida, estas se hacen mediante el uso de las funciones
de la librería estándar (stdio.h).
Para utilizar las funciones de E/S debemos incluir en el programa el
archivo de cabecera de la librería correspondiente, ejemplo:
stdio.h, mediante la declaratoria:
#include <stdio.h>
Función printf()
La principal función de salida es printf(), la cual permite enviar
mensajes a pantalla donde podemos incluir cadenas de texto de
salida así como valores calculados al interior del programa
(variables) para conocer el resultado del mismo.
La forma correcta de escribir una instrucción o en este caso llamar a
una función en lenguaje C se denomina sintaxis, la cual establece
los lineamientos bajo los cuales debe construirse cada instrucción,
si una regla sintáctica no es respetada entonces el compilador del
lenguaje C rechazará dicha instrucción y no permitirá la ejecución
del programa.
La sintaxis para la función printf es:
printf("Mensaje de Texto entrecomillado %e1 .. %en
<\n\t>",Variable_a_mostrar_e1, ...,Variable_a_mostrar_en);
Donde:
De e1 a en son especificadores de formato de salida, los cuales
"mostrarán" los valores que se indiquen en las variables de salida
respetando la posición de aparición, es decir la primera variable se
mostrará en el primer especificador, la segunda variable en el
segundo especificador y así sucesivamente, el carácter de
porcentaje (%) es una obligación sintáctica que le especifica al
compilador que lo que sigue es un especificador de formato.
Marcados como opcionales entre < >, cuando queremos insertar
saltos de línea en algún punto de la cadena de entrada
utilizamos \n para indicarlo, de manera similar al lenguaje C, de
esta misma manera \t nos sirve para insertar tabulaciones.
El formato de los especificadores se muestra en la siguiente tabla:
Cabe señalar que puede haber mensajes de texto sin
especificadores de variables de salida, así como mensajes
compuestos únicamente por especificadores de variables de salida.
Por ejemplo tenemos el siguiente código, que muestra un único
mensaje "Hola Mundo" sin especificadores.
Ahora vemos un ejemplo de un mensaje que especifica una
variable de salida de tipo entero. Como podemos notar se
especifica una salida en formato decimal (%d) y una variable
correspondiente con dicho formato, es decir una variable entera
(num1).
La salida que produce este código es un mensaje a pantalla
indicando: Soy el número 10
Ejemplo de uso de la función de salida printf
Funciones de salida para caracteres y cadenas
Función putchar()
Imprime un carácter en el dispositivo de salida (normalmente la
pantalla) en la posición actual del cursor
La sintaxis es:
putchar(<carácter>);
Función puts()
Escribe una cadena de caracteres de salida a pantalla (más
adelante estudiaremos como se forman las cadenas de caracteres
en C)
La sintaxis es:
puts(<cadena_de_caracteres>);
Así como la biblioteca stdio.h nos provee de funciones de salida,
también nos dota de sus contrapartes para recibir entradas
ingresadas por el usuario desde el teclado.
Función scanf()
Esta función nos permite leer desde el teclado el valor que ha de
asignarse a una variable, su sintaxis es la siguiente:
scanf("%especificador_de_formato",&Variable_Destino);
Donde:
El especificador de formato sigue las mismas reglas que para la
función de salida printf.
El carácter ampersand (&), es una obligación sintáctica que le
especifica al compilador que se leerá el contenido y no la
dirección de una variable, la diferencia entre contenidos y
direcciones se estudiará más adelante en el tema apuntadores,
por el momento nos basta entender que esta regla aplica para
todas las variables excepto cadenas de carácteres y apuntadores
per se, estos casos se estudiarán en temas posteriores del curso.
A continuación un código de ejemplo de la lectura de un dato de
entrada y con el mismo la realización de un cálculo:
Ejemplo de uso de la función de entrada scanf
Aunque aún no vamos a profundizar en el tema de cadenas de
caracteres, es importante saber cómo es que podemos declararlas
y leerlas, aquí un ejemplo para leer un nombre de hasta 20 letras
que acepta espacios y un apodo de hasta 12 letras que no acepta
espacios.
NOTA: Las lecturas en lenguaje C con la función scanf tienen
ciertas particularidades a considerar, por ejemplo, que si al leer
una cadena introducimos un espacio entonces hasta ese punto
se almacenarán los caracteres, es decir scanf() no puede leer
cadenas con espacios, si fuese necesario leer espacios se debe
usar la función gets() descrita más adelante.
El segundo punto a considerar es que al hacer una lectura de datos
el lenguaje C para saber que una cadena ha terminado le agrega un
terminador de cadena (conocido como el carácter '/0') el cual
coincide con el <ENTER>, la inclusión de este terminador muchas
veces es automática por el compilador, por ello cuando tecleamos
<ENTER> se acumulan dos terminadores, el automático y el que
introdujimos con la tecla de entrada, eso afectará nuestra siguiente
lectura la cual considerará que se leyó una cadena vacía pues
encontró el terminador '/0' que teníamos acumulado en el buffer de
entrada, es por ello que es conveniente que antes de cada nueva
lectura con scanf "limpiemos" ese buffer para evitar cualquier
entrada no deseada, para ello utilizamos la función fflush() la cual
puede limpiar el buffer tanto de entrada (stdin) como de salida
(stdout) según lo necesitemos.
Funciones de lectura para cadenas y carácteres
Función getc()
Esta función lee un carácter y retorna el valor entero
correspondiente a su código en ASCII, cabe señalar que como el
lenguaje C no es altamente tipificado (esto es que permite
combinar tipos de datos con cierta holgura) podemos asignar este
valor a un especificador o variable de tipo char y obtendremos el
carácter en lugar del valor entero, pero si lo asignamos a un
especificador o variable entera recibiremos el valor ASCII esperado.
La sintaxis es:
variable_destino=getc(stdin);
Donde:
stdin es la especificación sintáctica de la entrada estándar, pero getc
tiene la particularidad de que puede recibir datos desde otras
entradas adicionales a la estándar
Función getchar()
Lee un carácter y lo devuelve como su valor de salida
Función getche()
Lee un carácter y lo devuelve como su valor de salida mostrándolo
como “eco” en pantalla (está incluida en la librería <conio.h>
Función getch()
Es igual que getche() pero sin eco en pantalla, es decir el carácter
leído no se muestra en la pantalla (está incluida en la librería
<conio.h>)
La sintaxis de las 3 funciones es la misma:
<variable_carácter> = getchar();
Función gets()
Lee una cadena de caracteres de entrada desde el teclado
La sintaxis es:
gets(<variable_cadena>);

La declaración de una variable de tipo cadena sigue la sintaxis:

char nombreVariable[X]
Donde
X es el tamaño de caracteres de la cadena
 Codifique un programa que pida 6 entradas:
» La primera debe ser un entero
» La segunda debe ser un entero largo
» La tercera debe ser un dato de punto flotante
» La cuarta un dato de precisión doble
» La quinta una cadena de texto
» La sexta un carácter
Adicionalmente se deben establecer 3 constantes, la primera con el valor de pi
a 6 digitos con inculde, la segunda el numero de Euler a 5 digitos con const y
finalmente la constante de la aceleración de la gravedad en la tierra con valor
10 con enum
El programa debe guiar al usuario y al final mostrar los valores que han sido
tecleados y los valores de las constantes incluidas
Guardar el programa con el nombre Actividad5.c