Presentación
El
Presente documento ha sido elaborado con la finalidad, de proveer a los
estudiantes, de un recurso ágil y fácil de comprender por aquellos que inician
su estudio en la programación del lenguaje C.
¿Por qué
decidí escribir este manual?
Sencillo,
cuando en la universidad empezamos a estudiar C, nos
pidieron que, si podíamos, compráramos un libro texto para apoyar las clases, o
buscáramos un manual en la Internet... yo opté por la segunda
opción, ya que como todos sabrán los libros de programación son muy caros
(al menos aquí en El Salvador), pero me encontré con dos grandes problemas:
- Los Manuales que bajaba estaban incompletos, es decir; las explicaciones, los ejemplos y la información en general era muy pobre, por no decir escasa.
- si al dado caso, encontraba algún manual que estuviera completo, tenía muchos errores, en sus ejemplo(errores de sintaxis, de ejecución y hasta de lógica) o en la explicación que se daba. Lo cual al yo cometer esos ejemplos, mis profesores me lo hacían saber.
Por esas
razones decidí escribir mi propio manual, para evitar que, otros estudiantes
les suceda lo mismo que a mí, y así les evitaré gastos en impresiones innecesarios.
Cabe
recalcar que, no soy un experto programador... todavía sigo estudiando, pero
quiero colaborar de una manera desinteresada, a la formación de las personas.
Espero
que, este pequeño manual les sirva de mucho y sobre todo, le saquen mucho
provecho.
Se muy
bien, que usted, querido lector; está muy ansioso por comenzar a programar,
pero considero que es importante; conocer un poco del lenguaje C, tanto de sus orígenes como de
sus ventajas, pero no se preocupen, seré breve en esta introducción teórica. Además que es
importante conocer o recordar algunos conceptos que, son importantes al momento
de programar.
Componentes
de Una Computadora
Hemos
definido una, computadora como una máquina que recibe datos y ordenes, que al ejecutarlas
produce cierta información; dicha información se presenta en un
"idioma" codificado; por que ha de saberse que las computadoras no entienden nuestro idioma, o
cualquier otro en el mundo. Dicho "idioma" está compuesto únicamente
por dos elementos los ceros y los unos. Mejor conocido como código
Binario, con el cual se representan los datos, que arroja la computadora.
En una
forma más general, y creo que más sencilla, una computadora se comprende por
dos grandes grupo: El Hardware y el Software.
Hardware
El
Hardware de un computador es un conjunto de elementos
físicos, que la componen.
Veámoslo
gráficamente:
Podríamos
entrar en detalle de cada una de las partes descritas anteriormente, pero ese,
no es el objetivo de estas insignificantes
páginas; sino que esto es una mera introducción teórica, por ello sólo daré una
breve explicación.
En la
Unidad Central de Proceso (o CPU, por sus siglas en ingles
–Central Proccessing Unit-) se contiene la Unidad de Control, que su función es organizar y clasificar las
instrucciones recibidas; mientras que la Unidad Aritmética y Lógica, Se
encarga de ejecutar dichas instrucciones. Los Buses, son los mecanismos
de interconexión en el CPU.
La memoria Principal, Es el lugar donde se cargan
todas las instrucciones, programas, etc que se están ejecutando.
Software
Debemos
entender el software como la parte lógica de la computadora... ¿un poco difícil de
comprender, verdad?; es decir, que el software, es lo que dota a los
componentes físicos de poder realizar tareas determinadas.
Ejemplo, para poder utilizar una computadora, esta debe tener instalado un sistemas operativo. Para poder imprimir
algún trabajo, aparte de poseer un impresor,
en la computadora, debo tener un software que me permita imprimir dicha acción (generalmente las impresoras traen un cd, son su respectivo software de
instalación).
Aburrido?...
Es
necesario, que empiece con tanta palabrería; por que es necesario, para el
lector tener en claro estos conceptos.
Ahora
vamos a hablar de algo un poco más interesante, como lo es el lenguaje de programación
Un
lenguaje de Programación Es un conjuntos de palabras, reglas, con las
cuales se le indica a la computadora las funciones que debe realizar. Un lenguaje de
programación puede
ser:
- Lenguajes Máquinas: se trata de lenguaje cuyas instrucciones son directamente comprendidas por el ordenador o computador en el que se ejecuta el programa.
- Lenguaje de Bajo Nivel: este tipo de lenguajes, al igual que sucede con los lenguajes máquinas, existe una gran dependencia con el equipo en el que se va a ejecutar. No obstante son algo más fáciles de escribir, quedando ubicados por tanto, según su grado de complejidad; en un nivel intermedio entre el lenguaje máquina y el de alto nivel.
- Lenguaje de Alto Nivel: Disponen de una sintaxis en lenguaje más natural, y un amplio conjunto de funciones internas, que ayudan al programador en distintas situaciones, así como un número determinado de utilidades y asistentes que ahorran tiempo y trabajo al programador. Dentro de estos lenguajes tenemos: Visual Foxpro, Visual Basic. NET.
Programa:
Es un
conjunto de instrucciones que se le dan a la computadora, para que ésta realice
una determinada tarea.
Lenguaje C
El lenguaje C, fue diseñado por Dennies
Ritchie en 1970, en los laboratorios Bell de Estados Unidos.
Este
lenguaje presenta varias características, entre las cuales están:
- Lenguaje de programación de propósitos generales
- Permite la Programación Estructurada
- Abundancia de Operadores y Tipos de Datos
- No está asociado a ningún sistema operativo ni a ninguna máquina
- Popular y Eficaz
- Permite el desarrollo de Sistemas Operativos y programas de aplicación
- Portabilidad
- Existen las librerías en las bibliotecas
- tiene sólo 32 palabras reservadas
*bibliotecas: es el archivo que contiene código objeto de una colección de
rutinas o funciones que realizan tareas determinadas y se pueden utilizar en
los programas.
*Enlazador:
Programa que convierte las funciones de la biblioteca estándar de C, con el código que
ha traducido el compilador .
Estructura de Un programa en C
Ya
estamos apunto de entrar a lo más interesante, a la programación en sí; pero es
necesario, primero; mencionar algunos de los errores típicos al programar, para
que el lector sepa como identificarlos y así los pueda corregir.
- ERROR DE SINTAXIS: Estos errores son producidos, cuando se hace mal uso de las reglas del lenguaje de programación, y se violan las normas de sintaxis, de ese lenguaje (en nuestro caso C); estos errores son fáciles de detectar por que generalmente es el compilador, que los identifica (Y hasta muestra la línea donde se encuentra dicho error, pero eso depende de la versión del compilador que estemos usando). En este curso he usado Turbo C, en su versión 2 y 3.
- ERRORES DE EJECUCIÓN: Estos errores se producen , cuando le indicamos a la computadora, realizar una determinada acción, y esta la comprende, pero no puede ejecutarla. Por ejemplo, indicarle a la computadora una división entre cero, sumar dos variables a las cuales no se les ha signado valor alguno, etc.
- ERRORES DE LÓGICA: Muchas veces, cuando estamos programando, el compilador no nos indica errores de sintaxis, ni de lógica; pero el resultado de nuestro programa, esta fuera del rango esperado, esto es producto de un error de lógica en el código de nuestro programa. Este tipo de errores son muy difíciles de identificar y por supuesto de corregir, ya que generalmente hay que revisar línea por línea de nuestro programa. Ejemplo: El sueldo negativo de un empleado, etc.
La estructura de un programa en C, consta de
algunas partes esenciales: las cuales son uno o más módulos llamadas funciones,
siendo main() la primera función que es llamada cuando empieza la ejecución del
programa .
Cada
función debe contener :
>Directivas
de pre-procesador (instrucciones que se le dan al
compilador
#include
antes de compilar)
#define
ejemplo:
#include
<stdio.h>
Lo que se
le esta indicando, es que de las librerías, "Incluya" en nuestro
programa la directiva stdio.h, la cual contiene las funciones de entrada y
salida de datos (standar input output, en inglés). Si necesitamos las funciones matemáticas, debemos especificarlo con la
declaratoria:
#include <math.h>
Si
necesitamos las funciones de cadenas:
#inlcude <stlib.h>
Es
necesario aclarar que esto se hace al inicio del programa, y las declaratorias
deben llevar el símbolo de numeral (#) seguido de la sentencia
"include", y entre signos de mayor y menor que (<>)
el nombre de la directiva.
>Declaraciones
Globales
pueden ser:
*Prototipos
de Funciones: También llamadas declaraciones de funciones, lo cual se tratará
más adelante
*Declaraciones
de Variables
cabe
destacar, que esto se hace seguido de los #include y los #define.
>Función
Principal main()
Esta es
la función principal de nuestro programa, su cuerpo, por ello NUNCA debe
faltar, ya que en ella van contenidas todas las instrucciones de nuestro
programa.
main()
{
declaraciones
locales /*Comentarios
*/
sentencias
}
la
función main() va al inicio, luego abrimos llaves y dentro de ellas van las
declaraciones de variables, las sentencias de lectura, cálculos, asignaciones e
impresiones, y con la última llave ( } ), le indicamos el final del programa.
Ejemplo 1.1
Programa
que a partir del radio, calcula el área de un circulo
#include <stdio.h>
#include <conio.h>
main()
{
float radio, area;
printf("Radio=\n");
scanf("%f", &radio);
area=3.14159*radio*radio;
printf("El Area es %f\n\n", area);
getch();
return 0;
}
Explicación:
Le
indicamos al compilador, que usaremos las bibliotecas <stdio.h> y
<conio.h>, ¿por qué <conio.h>?, por que esta biblioteca, contiene
las funciones getche(), getch(), etc, y de una de ellas hacemos uso en este
pequeño ejemplo.
Luego, le
indicamos a nuestro programa el incio de nuestro programa (función main() ).
Declaramos,
como valores reales, las variables radio y
area (de esto se hablará más adelante). Luego, con la instrucción printf(),
mostramos en pantalla el mensaje (Radio=) y scanf se encarga de leer el valor
digitado por el usuario. Posteriormente area, es igual al la multiplicación de
pi (3.14159), el radio al cuadrado. Se muestra en pantalla ese resultado, luego
el programa espera que se presiones cualquier tecla (getch() ) y no retorna
ningún valor (return 0).
Ejercicios
Defina
los siguientes conceptos:
- Programa:_____________________________________________________________________________
- CPU:___________________________________________________________________________________
- Software:_________________________________________________________________________________
- Memoria Principal:__________________________________________________________________________________
- Lenguaje de Programación:______________________________________________________________________________
Indique
que tipo de error (Error de sintaxis, error de ejecución o error lógico), en
cada uno de los siguientes enunciados
- Utilizar una variable antes de asignarle un valor:____________________
- asignarle un valor real a una variable declarada como entero:______
- al cometer este error, los resultados arrojados por el programa no son los que se esperaban:______________________________________________
- Un programa no puede ser ejecutado por el computador, mientras tenga este tipo de errores:__________________________________________
- estos errores no son detectados por el compilador, ni tampoco son errores de ejecución:_______________________________________________
Mencione
y Explique, la estructura general de un programa en C:
¿Por qué
programación estructurada?
Si el
lector recuerda, en el capítulo anterior, se hablaba de las características del
lenguaje C, y en una de ellas se decía que, el Lenguaje de Programación C,
permite la programación estructurada. Esto implica que, haremos uso de una
técnica llamada Lógica Estructurada, y esto no es más ni menos que una
de las técnicas básicas y fundamentales de la
programación estructurada, su objetivo es diseñar soluciones "correctas" y
confiables a los problemas, ignorando al principio consideraciones de eficiencia como la minimización del uso de
memoria y el tiempo de su respuesta.
Lo que
significa que, haremos uso de esa técnica para crear programas correctos; esta
es una técnica que ayuda al programador (un tanto a la fuerza), a ser ordenado, al momento de
programar.
Los
frutos de ésta técnica se reflejan cuando, queremos darle mantenimiento al programa, es más fácil
hacerlo ya que hemos programado de una manera lógica y ordenada. Al
igual que al momento de corregir errores de sintaxis y lógica, esta técnica nos
facilita el trabajo.
Ahora
iniciemos, de una vez por todas, lo que el lector está esperando:
Sintaxis de Algunos Elementos de Un Programa en C
- como su nombre lo indica, estos son los nombres, con los que identificamos las variables, constantes, funciones, vectores, etc, de nuestro programa. Para ello debemos tener presente algunas reglas:
>pueden tener de 1 hasta un máximo de 31
caracteres
>Debe de iniciar con una letra o subrayado
Ejemplo:
(Correctos)
c2
_c2
( Incorrectos)
2c
2 c
>No es lo mismo una minúscula que una mayúscula,
ya que c distingue de entre ellas. Ejemplo: BETA ¹ Beta ¹ beta ¹ BeTa
>No son válidos los identificadores de palabras
reservadas. En un inicio hablamos que c posee 32 palabras reservadas, entre
ellas están:
float char while
int else return
Estas palabras no pueden ser utilizadas para
identificar variables, constantes, funciones etc
- identificadores:
En todo programa que estemos diseñando en C (o en
cualquier otro lenguaje de programación); es necesario insertar ciertos
comentarios en el código, para que en posteriores modificaciones y cuando se
realice el mantenimiento, podamos recordar cosas importantes ya que, en los
comentarios, podemos incluir aspectos importantes del programas, explicaciones
del funcionamiento de las sentencias, etc.
El formato de los comentarios en C, es el
siguiente:
/*este es un comentario en C */
/*Podemos colocar mucha información importante
de nuestro Programa */
- Comentarios
Permite que, el pre-procesador, incluya funciones
proporcionadas por el fabricante, a nuestro programa. Ejemplo:
#include <stdio.h> /* le decimos al
compilador que incluya la librería
stdio.h */
- La Directiva #include
permite definir constantes simbólicas. Pero hasta
ahora ha sido poco lo que hemos hablado acerca de las constantes, es por ello
que en aprovechando, este especio; dedicaré unas cuantas líneas para aclarar
ello.
Las variables pueden cambiar de valor, durante la
ejecución del programa, por eso es que se llaman variables. Y las
constantes como su nombre lo indica, son valores que permanecen constantes
durante toda la ejecución del programa, un ejemplo de ello, es el valor de p
(pi) que equivale a 3.14159....
En C existen diferentes tipos de variables, entre
ellas tenemos:
1. Constates Numéricas:
Son valores numéricos, enteros o de reales (de punto
flotante). Se permiten también constantes octales y hexadecimales.
2. Constantes Simbólicas:
las constantes simbólicas tiene un nombre
(identificador), y en esto se parecen las variables. Sin embargo, no pueden
cambiar de valor a lo largo de la ejecución del programa. En C, se pueden
definir mediante el preprocesador.
(Tomado del Manual "Aprenda Lenguaje ANSI C
como si estuviera en Primero" Escuela superior de Ingenieros Industriales.
Universidad de Navarra. Febrero de 1998).
Ejemplo:
#define N 100
#define PI 3.1416
#define B 45
Esta directiva (#define) va, inmediatamente después
de los #include. Se escribe la directiva, se deja un espacio y se escribe el
identificador de la constante, otro espacio y su valor.
- la directiva #define
/ ! % ^ & * () - + {} [] \ ; : <> ¿ .
- Signos de Puntuación y de Separación
Al momento de programar en C, esta es una regla de oro, y la causa por la cual nuestro
programa puede darnos muchos errores de sintaxis, cuando se omite, al final de
cada sentencia un punto y coma (;). Ya que con ello le indicamos al compilador
que ha finalizado una sentencia.
NOTA: el lector no debe confundirse, las
directivas: #include, #define. Main(), no llevan punto y coma, por que no son
sentencias.
Recordemos el ejemplo 1.1, y vea que al final de
cada sentencia lleva su correspondiente punto y coma:
#include <stdio.h>
#include <conio.h>
main()
{
float radio, area;
printf("Radio=\n");
scanf("%f",
&radio);
area=3.14159*radio*radio;
printf("El Area es
%f\n\n", area);
getch();
return 0;
}
- Todas las Instrucciones o sentencias del programa terminan con un punto y coma (;)
Esta consideración toma mayor auge, cuando veamos
las instrucciones anidadas en condiciones, ciclos, etc.
Ejemplo:
{
...
printf("Hola\n\b");
...
}
- Todo Bloque de Instrucciones debe ir entre llaves
- En una línea se pueden escribir más de una instrucción separada por un punto y coma
Esto es
posibles, por que con el punto y coma, le estamos indicando al compilador el
fin de una sentencia o instrucción.
Ejemplo:
b = c +
d; d = 2*k;
Tipos de Datos en C
Un tipo
de dato, se define como un conjunto de valores que puede tener una
variables, junto con ciertas operaciones que se pueden realizar con
ellas.
*TIPOS DE DATOS PREDEFINIDOS
TABLA CON LOS TIPOS DE DATOS PREDEFINIDOS EN C
|
|||
>ENTEROS: numeros completos y sus negativos
|
|||
Palabra
reservada:
|
Ejemplo
|
Tamaño
(byte)
|
Rango de valores
|
Int
|
-850
|
2
|
-32767 a 32767
|
VARIANTES DE ENTEROS
|
|||
short
int
|
-10
|
1
|
-128 a 127
|
unsigned
int
|
45689
|
2
|
0 a 65535
|
long
int
|
588458
|
4
|
-2147483648 a 2147483647
|
unsigned
long
|
20000
|
4
|
0 a 4294967295
|
>REALES: números con decimales o punto
flotante
|
|||
Palabra
reservada:
|
Ejemplo
|
Tamaño
(byte)
|
Rango de valores
|
Float
|
85
|
4
|
3.4x10-38 a 3.4x1038
|
VARIANTES DE LOS REALES
|
|||
Doublé
|
0.0058
|
8
|
1.7x10-308 a 1.7x10308
|
long doublé
|
1.00E-07
|
10
|
3.4x10-4932 a 1.1x104932
|
>CARÁCTER: letras, digitos, símbolos, signos de puntuación.
|
|||
Palabra
reservada:
|
Ejemplo
|
Tamaño
(byte)
|
Rango de valores
|
char
|
'O'
|
1
|
0 ......255
|
TABLA 2.1
NOTA: El
tipo de dato string y bolean NO existen en C. Sin embargo más adelante veremos
una forma de cómo hacer uso de las cadenas de texto.
Declaración de Variables
Una
Variable, como su nombre lo indica, es capaz de almacenar diferentes valores
durante la ejecución del programa, su valor varía. Es un lugar en la memoria el cual, posee un nombre
(identificador), y un valor asociado.
La
declaración de variables en C, se hace en minúsculas.
Formato:
Tipo_de_dato
nombre_de_la_variable;
Ejemplos:
*Declare
una variable de tipo entero y otra de tipo real, una con el nombre de
"x" y otra con el identificador "y":
int x;
float y;
*Declare
una variable de tipo entero llamada moon, e inicialícela con un valor de 20
int x =
20;
*Declare
una variable de tipo real, llamada Pi, e inicialícela con una valor de 3.1415
float
pi=3.1415;
*Declare
una variable de tipo caracrter y asígnele el valor de "M"
char car
= ’M’;
*Declare
una variable llamada nombre, que contenga su nombre:
char
nombre[7]="Manuel";
Explicación:
En el
apartado anterior, se explicó, que C, no tiene el tipo de dato llamado string,
o mejor conocido como cadenas de texto, pero nosotros podemos hacer uso de
ellas, por medio de un arreglo, (de lo cual hablaremos con más detalle,
posteriormente); pero para declarar este tipo de datos colocamos el tipo de
datos, es decir la palabra reservada char luego el nombre, e
inmediatamente abrimos, entre corchetes, va el número de letras, que contendrá
dicha variable. Es muy importante que al momento de declarar el tamaño, sea un
número mayor, al verdadero número de letras; por ejemplo, la palabra
"Manuel", solo tiene 6 letras, pero debemos declararlo para 7 letras
¿Por qué?.
Veámoslo
gráficamente, en la memoria, C crea un variable llammada nombre y esta posee la
palabra Manuel, así:
en realidad,
hay 7 espacios, pero la cuanta llega hasta 6, por que c, toma la primera
posición como la posición cero, y para indicar el final de la cadena lo hace
con un espacio en blanco.
Declaración de Constantes
Las
constantes, como su nombre lo indica, son valores que se mantiene
invariables durante la ejecución del programa.
Su
formato es el siguiente:
const tipo_de_dato nombre= valor;
donde
const, es una palabra reservada, para indicarle al compilador que se esta
declarando una constante.
Ejemplo:
const int dia=7;
const float pi=3.14159;
const
char caracter= ‘m’;
const
char fecha[]="25 de diciembre";
Caso
Especial Constantes Simbólicas
Las
constantes simbólicas, se declaran mediante la directiva #define, como se
explicó anteriormente. Funcionan de la siguiente manera, cuando C, encuentra el
símbolo que representa a la constante, lo sustituye por su respectivo valor.
Ejemplo:
#define N
150
#define
PI 3.1416
#define P
50
NOTA: El
lector debe comprender algunas diferencias fundamentales entre la declaratoria
const y #define; la primera, va dentro del programa, es decir, dentro de la
función main() o alguna función definida por el usuario, mientras que #define
va en el encabezado, después de los #include, por eso estas no llevan al final
el punto y coma (;).
Entrada y Salida Por Consola
Entrada y
Salida por consola: se refiere a las operaciones que se producen en el teclado y en la pantalla de la
computadora. En C no hay palabras claves para realizar las acciones de Entrada/Salida, estas se
hacen mediante el uso de las funciones de la biblioteca estándar (stadio.h).
Para
utilizar las funciones de E / S debemos incluir en el programa el archivo de
cabecera stdio.h, mediante la declaratoria:
#include <stdio.h>
Las
Funciones de E / S más simples son getchar() que lee un carácter del teclado,
espera un retorno de carro (¿ ), es decir un enter y el eco aparece. Es
decir la tecla presionada.
*putchar(): Imprime un carácter en la
pantalla, en la posición actual del cursor.
Algunas
variaciones:
*getche(): Aparece el Eco
*getch(): No aparece el eco
estas
instrucciones se encuentran en la biblioteca conio.h
Veamos un
ejemplo:
Programa
que espera que se presiona una tecla, la muestra en pantalla, y además muestra
el carácter siguiente:
Ejemplo 2.1:
#include <stdio.h>
#include <conio.h>
main()
{
char car;
clrscr();
/*Se encarga de borrar la pantalla por eso se llama claer screen*/
car=getchar();
putchar(car+1);
getch();
return 0;
}
Ejemplo 2.2:
#include <stdio.h>
#include
<conio.h>
main()
{
char x;
/*Declaramos x como caracter*/
printf("Para
Finalizar Presione cualquier Tecla:");
x=
getchar();/*Captura y muestra el caracter presionado*/
getch();/*Espera
a que se presione cualquier otra tecla para finalizar*/
return 0;
}
Entrada /
Salida de Cadenas
Una
Cadena, es una frase, compuesta por varias palabras. En C, podemos hacer uso de
las cadenas, mediante, la sentencia:
*gets(): Lee una cadena de carácter
introducido por el teclado. Se puede introducir caracteres hasta que se de un
retorno de carro, (enter); el cual no es parte de la cadena; en su lugar se
coloca un terminador nulo \0.
*puts(): Imprime en pantalla, el
argumento guardado en la variable que se manda a impresión.
Ejemplo
2.3
Diseñe un
programa en C, que lea su nombre; lo salude y mande a impresión su nombre,
usando gets e y puts
#include <stdio.h>
#include <conio.h>
main()
{
char
nombre[40];
puts("digite
su nombre:");
gets(nombre);
puts("BIENVENIDO:");
puts(nombre);
getch();
return 0;
}
NOTA: No
haré mucho énfasis en estas instrucciones, ya que más adelante, veremos las
instrucciones scanf() y printf(), que son mucho más completas.
Entrada /
Salida Por Consola con Formato
Las
funciones gets, puts, getch, etc; son utilizadas, en una forma un poco
rudimentaria, sin embargo; C posee otra serie de funciones, que son más
completas, las cuales nos permiten leer e imprimir (en pantalla), datos con un
formato determinado, el cual ha sido definido por el programador.
Salida
Hacia Pantalla [printf()]
Se
utiliza para imprimir en pantalla cadenas de texto solas, o mandar a pantalla
el valor de alguna variable, o constante, o una combinación de las anteriores.
Su formato es el siguiente:
Printf("cadena de control",
nombre_de_variables);
En donde:
Cadena de
control: contiene códigos de formato que se asocian con los tipos de datos
contenidos en las variables.
Código
|
Formato
|
%d
|
Un
entero
|
%i
|
Un
entero
|
%c
|
Una
caracter
|
%s
|
Una
cadena
|
%f
|
Un real
|
%ld
|
Entero
largo
|
%u
|
Decimal
sin signo
|
%lf
|
Doble
posición
|
%h
|
Entero
corto
|
%o
|
Octal
|
%x
|
Hexadecimal
|
%e
|
Notación
Científica
|
%p
|
Puntero
|
%%
|
Imprime
Porcentaje
|
TABLA 2.2
Ejemplo:
Int
suma=10;
Printf("La
suma es %d", suma);
Explicación:
Declaramos
primero la variable como entero, con un valor de 10, luego la función printf,
el mensaje va entre comillas dobles, luego en el lugar que queremos que
aparezca el valor, colocamos el formato de la variable, cerramos comillas,
luego una coma y el nombre de la variable. Es importante recalcar, que en la
posición que coloquemos el formato es donde aparecerá el valor de la variable
en este caso, 10.
Ejemplo:
Char
nombre[7]="Manuel";
printf("%s
es en creador de este manual", nombre);
NOTA: el
número de argumentos que tendrá la función printf() es indefinido, por lo que
se puede transmitir cuantos datos sean necesarios.
Ejemplo:
Int x=12,
y=15;
char
z=’D’;
float
v=10.2563;
printf("Estos
son números %d %d %f; y esta es una letra %c", x,y,v,z);
También
podemos hacer algunos arreglos, al formato de salida, por ejemplo, si deseamos
imprimir un número real justificado a la izquierda podemos colocar:
printf("%-f", z);
para
justificar colocarle signo: %+f
%20f
>> Longitud numérica del campo
%.2f
>>Imprime el valor con sólo dos decimales
Secuencias
de Escapes
Indica
que debe ejecutar algo extraordinario.
Carácter
de Escape
|
Explicación
|
\n
|
Simula
un Enter. Se utiliza para dejar una línea de por medio
|
\t
|
Tabulador
horizontal. Mueve el cursor al próximo tabulador
|
\v
|
Tabulador
vertical.
|
\a
|
Hace
sonar la alarma del sistema
|
\\
|
Imprime
un carácter de diagonal invertida
|
\?
|
Imprime
el carácter del signo de interrogación
|
\"
|
Imprime
una doble comilla
|
TABLA 2.3
Ejemplos:
1)
printf("Manuel \n Antonio \n Ortez\n\n);
2) int
x=15;
printf("El
Valor de la variable es %d\n\n", x);
3) float
x=8.5689, pi=3.1416;
printf("El
valor de x es %.2f\t\n",x);
printf("\t
Y el valor de pi es %.2f\n\n", pi);
Entrada
Desde Teclado
Se
realiza mediante la función scanf(), su formato es:
scanf("Cadena de control", Dirección y nombre de la variable);
Ejemplo
2.4
Diseñe un
programa que guarde y muestre la nota del examen final de 3 alumnos
#include <stdio.h>
#include <conio.h>
main()
{
float n1, n2, n3;
char
nom1[10], nom2[10], nom3[10];
printf("Introduzca
el Nombre del Primer alumno:\n");
scanf("%s",
nom1);
printf("Introduzca
la nota de este alumno:\n");
scanf("%f",
&n1);
printf("Digite
el nombre del segundo alumno:\n");
scanf("%s",
nom2);
printf("Su
nota es:\n");
scanf("%f",
&n2);
printf("Finalmente
el ultimo alumno es:\n");
scanf("%s",
nom3);
printf("Y
su nota es:\n");
scanf("%f", &n3);
getch();
return 0;
}
Explicación:
Primero,
iniciamos con las directivas del preprocesador:
#include <stdio.h>
#include <conio.h>
Con la
cual le indicamos al compilador, que de su librería añada a nuestro programa
las funciones estándar de entrada y salida; así como las entradas y salidas por
consola (stadio.h y conio.h, respectivamente).
Luego
declaramos la variables, que contendrán las notas como reales (o de punto
flotante:
float n1,
n2, n3;
Ya que,
las notas pueden ser deciamales, por ejemplo 9.6, 8.5; etc.
Luego
declaramos las variables, que contendrán las notas, caba aclarar que al momento
de las declaraciones las podemos hacer en el orden que deseemos, pueden ser
primeros los tipo char y luego los float, o viceversa, pero teniendo el cuidado
que las variables que contendrán las nombres lleven la longitud máxima entre
corchetes, para nuestro caso, 10. ( [10] ).
Posteriormente,
mostramos en pantalla, un mensaje con el cual le indicamos al usuario que
introduzca los datos respectivos:
printf("Introduzca
el Nombre del Primer alumno:\n");
A
continuación, va la función scanf, primero y entre comillas el tipo de dato que
va a leer:
scanf("%s",
nom1);
como
puede notarse, va a leer la cadena de texto que contendrá la variable nom1.
cabe aclarar, que cuando se van a leer cadenas de texto, no es necesario
colocar la dirección (&), lo cual no sucede con los otros tipos de datos:
scanf("%f",
&n1);
Después
de haber leído los datos, espera a que se presiones cualquier tecla para
finalizar la ejecución del programa.
Ejemplo
2.5
Programa
que imprime dos veces, la cadena de texto que se ha introducido:
#include <stdio.h>
#include <conio.h>
main()
{
char
cadena[15];
printf("Digite
la cadena:\n\n");
scanf("%s",
cadena);
printf("\n\t
LA CADENA ES LA SIGUIENTE:\n\n");
printf("***********************************************\n");
printf("%s\n", cadena);
printf("%s\n", cadena);
printf("***********************************************\n");
getch();
return 0;
}
Es
importante, que el lector, intente correr, en su máquina estos ejemplos, para
que comprenda con mayor facilidad.
NOTA:
Cuando la entrada, es una cadena de carácter, no es necesario el operador
direccional (&). El nombre de la cadena contiene la dirección.
Ejemplo:
scanf(),
finaliza la captación de la cadena al encontrar un espacio en blanco o fin de
línea.
Ejemplo:
char
cadena[15];
printf("Digite
la cadena:\n\n");
scanf("%s",
cadena);
Casos
Especiales
*JUEGO DE INSPECCIÓN: Define Un
conjunto de caracteres que puede leerse utilizando scanf().
Así:
%[ABC]s: A, B y C son los
únicos caracteres que puede leer al encontrar uno diferente, finaliza con un
valor nulo.
%[ A-Z ]s: También pueden
ser rangos de carácter en este caso sólo acepta mayúsculas.
*JUEGO
INVERSO: Aquí se declaran que caracteres NO puede tomar, la función scanf(), se
utiliza el circunflejo (^), que acepta cualquiera menos...
Ejemplo:
%[^\n]s: Acepta cualquier
carácter menos un salto de línea.
%[^0-9]s: Acepta cualquier
carácter menos del 0 al 9.
Ejemplo:
Scanf("%[0-9]s",
&edad);
Cuestionario
- Mencione y Explique que es la lógica estructurada:_______________________________________________________
- Para que sirven las funciones getch() y putchar():_________________________________________________________
- Menciones las diferencias fundamentales entre las funciones de entrada y salida por consola, con las funciones de entrada y salida por consola con formato:_________________________________________________________________________________________
- Escriba algunas restricciones que deben cumplir los Identificadores:___________________________________________________________________________________
- ¿Cuál es la siferencia entre el tipo de dato %c, y el tipo de dato %s?:___________________________________________________________________________________________
- Para que sirve la directiva <stdio.h>:_________________________________________________________________
- ¿Y la directiva <conio.h>?_________________________________________________________________________
- ¿Para que sirve a declaratoria #define?:____________________________________________________________
- Para que sirve el punto y coma (;) en C:_____________________________________________________________
- En C, no existe el tipo de dato string; sin embargo, podemos hacer uso de las cadenas de texto, ¿Por qué?. Explique:___________________________________________________________________________________
Ejercicios:
- Haciendo uso de las funciones gets y puts, diseñe un programa en C, que se lea el nombre del usuario y lo muestre en pantalla junto con un saludo.
- Diseñe un programa en C, que lea y muestre en pantalla el valor de tres variables de tipo Entero.
- Diseñe un programa que muestre, los diferentes tipos de datos, usados en C. Primero, debe indicársele al usuario que introduzca un valor, de un tipo dado; luego y después de haber introducido valores en todas las variables, debe imprimirse el contenido de ellas, junto con un mensaje que indique, el tipo de dato:
4. Diseñe
un programa, en el cual se introduzcan el nombre y el peso y de un alumno, y
luego la muestre en pantalla. El Nombre debe incluir el apellido, y en el campo
del peso, solo deben incluir valores numéricos.
5. Diseñe
un programe en C, en el cual después de haber introducido, una tabla de
multiplicación cualquiera, imprima ésta en forma de tabla:
2x2=4
2x3=6
2x4=8
. .
.
2x10=20
6.
Realice el ejercicio 2.5, tal como se muestra, luego ejecútalo, nuevamente,
pero quitándole al código las sentencias: getch() y return 0. ¿Qué observas?
Realiza tus propias conclusiones de ello y de la importancia de estas dos funciones.
Hasta
ahora, prácticamente hemos visto, como el protocolo esencial, para realizar un
programa en C; y algunas funciones muy importantes, como son las funciones de
lectura e impresión (scanf y printf, respectivamente).
Ahora
veremos, otros aspectos fundamentales, como lo son los operadores, que pueden
ser: lógicos, matemáticos, relacionales, etc. Las
expresiones, y las estructuras: de secuenciación, de selección y de iteración.
Operadores
Un
operador, es un símbolo que indica al compilador que se lleve a cabo ciertas
manipulaciones matemáticas o lógicas.
Operadores
Aritméticos
Operador
|
Propósito
|
+
|
Suma
|
-
|
Resta
|
*
|
Multiplicación
|
/
|
División
|
%
|
Resto
de la división entera
|
TABLA 3.1
Todos
estos operadores se pueden aplicar a constantes, variables y expresiones. El
resultado es el que se obtiene de aplicar la operación correspondiente entre
los dos operandos. (Tomado de "Aprenda Lenguaje ANSII C, como si estuviera
en primero". Pag. 25).
Los
operandos sobre los que actúan los operadores aritméticos deben ser valores Numéricos,
es decir datos enteros, punto flotante o de carácter (Int, float y char,
respectivamente).
Una
aclaración especial, merece el operador "%", que indica el resto de
la división entera. Veámoslo con un ejemplo:
Si
dividimos 30/3, su cociente es 10, y su residuo es 0. Si dividimos 25/3, su
cociente es 8, y tiene un residuo de 1. Entonces de lo que se encarga, este
operador, es de devolvernos el valor del residuo de una división. Cabe aclarar
que los datos deben de ser tipo entero, y su sintaxis es la siguiente:
25%3
NOTA:
Este Operador, NO puede aplicarse a los datos de tipo float.
Una Expresión,
Es un conjunto de variable, constantes y otras expresiones más sencillas,
relacionadas por algún tipo de operador. De las cuales hablaremos con más
detalle, posteriormente.
Operadores
de Relaciónales, Lógicos y Unarios
Estos
Operadores, los podemos dividir, en varios tipos, entre los cuales están:
- OPERADORES UNARIOS: C, incluye una clase de operadores que actúan sobre un solo operador para producir un nuevo valor. Por eso el nombre de unarios, por que para poder funcionar solo necesitan de un operador.
Operador
|
Propósito
|
-
|
Menos
Unario: Es el signo menos que va delante de una variable, constante o
expresión.
|
++
|
Operador
Incremento: Hace que la variable, constante o expresión se aumente en uno.
|
--
|
Operador
Decremento: Hace que su variable, constante o expresión disminuya en uno.
|
TABLE 3.2
Ejemplo:
Int i=1, x=5;
Printf("%d", ++i);
Printf("%d", - -i);
Estos
operadores, el incremento y el decremento, pueden utilizarse de dos maneras,
eso depende del orden de aparición de los mismos:
-Si el
operador precede al operando el valor del operando se modifica antes de ser
utilizado.
-Si el
operador aparece después del operando, este se modifica después de ser
utilizado.
Ejemplo
3.1:
Utilizando
los operadores Unarios:
#include <stdio.h>
#include <conio.h>
main()
{
int x=5;
printf("\tPRIMERO
OBSERVAREMOS EL RESULTADO DE ++X\n\n");
printf("%d\n", ++x);
printf("%d\n", ++x);
printf("%d\n",
++x);
printf("\tAHORA
OBSERVAREMOS EL RESULTADO DE --X\n\n");
printf("%d\n", --x);
printf("%d\n", --x);
printf("%d\n",
--x);
printf("\tEL
RESULTADO DE X++ ES:\n\n");
printf("%d\n", x++);
printf("%d\n", x++);
printf("\tY
EL DE X-- ES:\n\n");
printf("%d\n", x--);
printf("%d\n", x--);
getch();
return 0;
}
- OPERADORES RELACIONALES O DE COMPARACIÓN:
Operador
|
Significado
|
<
|
Menor
que
|
<=
|
Menor o
igual que
|
>
|
Mayor
que
|
>=
|
Mayor o
igual que
|
==
|
Igual
que (Para las comparaciones)
|
! =
|
No
igual a
|
TABLA 3.3
Estos Operadores
se encuentran dentro del mismo grupo de procedencia, que es menor que la de los
Operadores Unarios y aritméticos.
La
Asociatividad de éstos es de izquierda a derecha. Cabe mencionar la diferencia
entre los operadores = y ==, el primero (=), se utiliza para asignaciones de
valores, mientras que el otro (==), se usa para comparaciones. Ejemplo: Si
x>5, entonces x==6.
3.
OPERADORES LÓGICOS: Estos son los que nos permiten unir varias comparaciones:
10>5 y 6==6. Los operadores lógicos son: AND (&&), OR (||), NOT(!).
Operador
&& (AND, en castellano Y): Devuelve un 1 si se cumplen
dos condiciones.
printf(
"Resultado: %i", (10==10 && 5>2 );
Operador
|| (OR, en castellano O): Devuelve un 1 si se cumple una de las dos
condiciones.
Operador
! (NOT, negación): Si la condición se cumple NOT hace que no se cumpla y
viceversa.
Ver el
capítulo Sentencias, sección Notas sobre las condiciones para más información.
(Tomado de "Curso de C" por Gorka Urrutia).
Operadores
de Asignación
Los
Operadores de Asignación, como su nombre lo indica, se encargan de atribuirle,
asignarle, confinarle, etc a una variable, el resultado de una expresión o el
valor de otra variable.
Se
utilizan en forma de expresiones de asignación en los que se asigna en el valor
de una expresión a un identificador. El operador de asignación más utilizado es
"=" y su formato es:
identificador = expresión;
Donde el
identificador representa por lo general una variable y una constante, una
variable o una expresión más compleja.
Si los
dos operandos de la expresión de asignación son de tipo de datos diferentes el
valor de la expresión de la derecha se convertirá automáticamente al tipo de
identificador de la izquierda de ésta forma la expresión de asignación será del
mismo tipo de datos.
Ejemplo:
*Un valor
en coma flotante puede ser truncado, se asigna a un identificador entero.
*Un valor
de doble precisión puede ser redondeado si se asigna a un identificador de coma
flotante.
En C, están
permitidas las asignaciones múltiples, así:
Identificador1
= identificador2 = identificador3.....= identificadorn=expresión
C, posee
además los siguientes operadores de asignación:
Operador
|
Explicación
|
+=
|
Expresión1+=expresión2.
Equivale a: expresión1=expresión1 + expresión2
|
-=
|
i-=1. equivale a: i=i-1
|
*=
|
J*=2.
Equivale a: j=j*2
|
/=
|
K/=m,
equivale a: k=k/m
|
%=
|
P%n.
Equivale a: p=p%n
|
TABLA 3.4
Los
Operadores de asignación tiene menos procedencia que el resto de los operadores
y tienen asociatividad de izquierda a derecha.
Ejemplo
3.2
Programa
que calcula el valor de la expresión X^2+X+1
#include <stdio.h>
#include <conio.h>
main()
{
float x, y, z;
clrscr();
printf("\tPROGRAMA
QUE CALCULA EL VALOR DE LA ECUACION X^2+X+1\n\n");
printf("Introduzaca
el valor de x:\n");
scanf("%f",
&x);
y=x*x;
z=y+x+1;
printf("**************************************\n");
printf("**El
valor de la expresi¢n es: %.2f**\n", z);
printf("**************************************\n");
getch();
return 0;
}
Jerarquía
de Operadores
Categoría
del Operador
|
Operador
|
1.
Operadores Unarios
|
-, ++,
--, !
|
2.Operadores
Aritméticos:
|
*, /, %
+,-
|
3.
Operadores Relacionales
|
<,
<=, >, >=
|
4.
Operadores de Igualdad
|
==, ! =
|
5.
Operadores Lógicos
|
&&
(Y Lógico), || (NO Lógico)
|
6.
Operadores de Asignación
|
=, +=,
-=, *=, /?, %=,
|
TABLA 3.5
REGLAS DE
JERARQUÍA:
- Se ejecuta primero el operador de más alta jerarquía
- Operadores que tienen igual jerarquía se evalúan de izquierda a derecha
- si existen expresiones encerradas entre paréntesis, estas se evalúan primero.
- si existen paréntesis anidados se evalúan primero los paréntesis más internos.
EXPRESIONES
(Tomado
de "Aprenda ANSII C como si estuviera en Primero", Universidad de
Navarra. 1998).
Ya han
aparecido algunos ejemplos del lenguaje C en las secciones precedentes. Una Expresión
es una combinación de variables y/o constantes, y operadores. La expresión es
equivalente al resultado que proporciona al aplicar sus operadores a sus
operandos. Por ejemplo 1 + 5 es una expresión formada por dos operandos (1 y
5)y el operador (el +); esta expresión es equivalente al valor 6, por lo cual
quiere decir que allí donde esta expresión aparece en el programa, en el
momento de la ejecución es evaluada y sustituida por su resultado. Una
expresión puede estar formada por otras expresiones más sencillas, y puede
contener paréntesis de varios niveles agrupando distintos términos. En C,
existen diferentes tipos de expresiones. El cual depende del tipo de operadores
que se estén utilizando. Por ejemplo: Expresiones lógicas, aritméticas, etc
Se debe
hacer hincapié en que, si existen algunas expresiones encerradas entre
paréntesis, estas se evalúan primero. Ejemplo:
9*(8+5)
primero
sumamos 8+5, cuyo resultado es 13, y este lo multiplicamos por nueve, con lo
que la expresión anterior, da cómo resultado: 117.
Si
existen expresiones en paréntesis anidadas, es decir, que uno se encuentra
dentro de otros paréntesis, se evalúan los más internos. Ejemplo:
2*((20/(12-2))+5)
se evalúa
la operación 12-2, que da como resultado 10, luego se divide 20, entre el
resultado anterior, es decir 10. el resultado es 2, y a este número se le suma
5, obteniendo 7. ahora se multiplica por dos, para determinar así que la
expresión anterior es igual a 14.
0 comentarios:
Publicar un comentario