1) ANATOMIA DE UN PROGRAMA C

El lenguaje de programación C está caracterizado por ser de uso general, con una sintaxis
sumamente compacta y de alta portabilidad. Es común leer que se lo caracteriza como un lenguaje
de "bajo nivel". No debe confundirse el término "bajo" con "poco", ya que el significado del
mismo es en realidad "profundo", en el sentido que C maneja los elementos básicos presentes en
todas las computadoras: caracteres, números y direcciones. Esta particularidad, junto con el
hecho de no poseer operaciones de entrada-salida, manejo de arreglo de caracteres, de asignación
de memoria, etc , puede al principio parecer un grave defecto; sin embargo el hecho de que estas
operaciones se realicen por medio de llamadas a Funciones contenidas en Librerías externas al
lenguaje en sí, es el que confiere al mismo su alto grado de portabilidad, independizándolo del
"Hardware" sobre el cual corren los programas. La descripción del lenguaje se realiza siguiendo
las normas del ANSI C, por lo tanto, todo lo expresado será utilizable con cualquier compilador
que se adopte.

Siguiendo la tradición, la mejor forma de aprender a programar en cualquier lenguaje es editar,

compilar, corregir y ejecutar pequeños programas descriptivos.

2) ENCABEZAMIENTO

La primera línea del programa está compuesta por una directiva: " #include " que implica la orden
de leer un archivo de texto especificado en el nombre que sigue a la misma ( <stdio.h> )
(<conio.h>) y reemplazar esta línea por el contenido de dicho archivo.
Por lo general estos archivos son guardados en un directorio llamado INCLUDE y el nombre de
los mismos está terminado con la extensión .h. La razón de la existencia de estos archivos es
la de evitar la repetición de la escritura de largas definiciones en cada programa.
Nótese que la directiva "#include" no es una sentencia de programa sino una orden de que se
copie literalmente un archivo de texto en el lugar en que ella está ubicada.
FUNCION main() ubicada en la segunda línea indica donde empieza el programa, cuyo cuerpo
principal es un conjunto de sentencias delimitadas por dos llaves, una inmediatamente después
de la declaración main() " { ", esta llave significa inicio y otra que finaliza el listado de sentencias"
} ".
La sentencia printf(argumento) significa imprimir argumento o mensajes que se desean
escribir en la pantalla. Los mismos deben estar delimitados por comillas. “”
La secuencia \n que aparece al final del mensaje es la notación que significa saltar una "nueva
línea" que hace avanzar al cursor a la posición extrema izquierda de la línea siguiente.
La sentencia scanf() está declarado en stdio.h , significa leer una variable ya sea un entero y
guardarlo en la variable "valor_leido" ejemplo: scanf("%d",&valor_leido); en cambio sí deseara
leer un entero y un valor de punto flotante será: scanf("%d %f", &valor_entero,
&valor_punto_flotante) ;
Se debe anteponer el signo & al nombre de la misma para indicar la dirección de su ubicación
en la memoria de la máquina.
NOTESE que cada sentencia de programa queda finalizada por el terminador ; que indica al
compilador el fin de la misma.
En la secuencia de control se indicará que tipo de variable se espera leer, por ejemplo :
%d si se desea leer un entero decimal (int)
%c " " " " " caracter
%f leerá un float
%lf leerá un doublé
La función, clrscr() significa limpiar la pantalla en la ejecución del programa.
La función getche() lee el teclado (similar a getch() , pero con la diferencia que aquella hace
eco del carácter en la pantalla)
La sentencia (return 0) significa que termina el programa y devuelve un valor al Sistema
operativo, por lo general cero si la ejecución fue correcta y valores distintos de cero para indicar
diversos errores que pudieron ocurrir.
Si bien no es obligatorio terminar el programa con un return, es conveniente indicarle a quien lo
haya invocado, sea el Sistema Operativo o algún otro programa, si la finalización ha sido exitosa,
o no.
COMENTARIOS La inclusión de comentarios en un programa es una saludable práctica, como
lo reconocerá cualquiera que haya tratado de leer un listado hecho por otro programador o por sí
mismo, varios meses atrás. Para el compilador, los comentarios son inexistentes, por lo que no
generan líneas de código, permitiendo abundar en ellos tanto como se desee.
En el lenguaje C los comentarios van encerrados entre los símbolos: /* */ . Los comentarios
pueden ocupar uno o más renglones, por ejemplo:
COMENTARIOS
/* este es un comentario corto */
/* este otro
es mucho
más largo
que el anterior */
VARIABLES Y CONSTANTES

1. DEFINICION DE VARIABLES Una variable, no es más que un nombre para

identificar una (o varias) posiciones de memoria donde el programa guarda los distintos valores
de una misma entidad. Un programa debe DEFINIR a todas las variables que utilizará, antes de
comenzar a usarlas, a fin de indicarle al compilador de que tipo serán, y por lo tanto cuanta
memoria debe destinar para albergar a cada una de ellas.

2. En las primeras líneas de texto dentro de main() defino mis variables DEPENDIENDO DEL
TIPO como números enteros , es decir del tipo "int", como un número real “float” como un
cadena de carácter “STRING”, como carácter “CHAR” , seguido de un identificador (nombre)
de la misma .

Es conveniente darle a los identificadores de las variables, nombres de fácil lectura del programa.
Los identificadores deben comenzar con una letra. El lenguaje C es sensible al tipo de letra usado;
así tomará como variables distintas a una llamada "variable”, de otra escrita como "VARIABLE".
Se le sugiere a los programadores de C escribir los nombres de las variables y las funciones con
minúsculas, reservando las mayúsculas para las constantes.
El compilador dará como error de "Definición incorrecta" a la definición de variables con
nombres POR EJEMPLO : 4pesos, $variable, !variable etc.
Primero hemos de definirla, de la forma siguiente:
Tipo Nombredelavariable;
Ej:
 int multiplicador; /* defino multiplicador como un entero */
int multiplicando; /* defino multiplicando como un entero */
int resultado; /* defino resultado como un entero */
string nombre;
char a;
float numero;

Una vez la hemos definido podemos usarlas asignándoles

valores y usándolos:
int multiplicador; /* defino multiplicador como un entero */
multiplicador = 1000 ; /* les asigno valores */

NOTA: Los compiladores reservan determinados términos ó palabras claves

(Keywords) para el uso sintáctico del lenguaje, tales como: asm, auto, break, case,
char, do, for, etc. Es aconsejable no usar palabras reservadas del compilador como
nombres de variables.

Veamos en el siguiente ejemplo como actúa la función printf(), ésta nos mostrará la forma de
visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de
control de impresión "%d" que indica, que la variable que vamos a imprimir es un entero, o si
es un carácter “%c”, si es una cadena de caracteres “%s” EJEMPLO:
#include <stdio.h>
main() {
int multiplicador=1000 , multiplicando=2 ;
printf("Resultado = %d\n", multiplicando * multiplicador);
return 0;
}
Así, si compilamos y corremos el programa, obtendremos una salida:
SALIDA DEL EJEMPLO
Resultado = 2000

INICIALIZACION DE VARIABLES
Las variables del mismo tipo pueden definirse separándolas mediante “, " ejemplo:
int multiplicador, multiplicando, resultado;
Las variables pueden también ser inicializadas en el momento de definirse.
int multiplicador = 1000, multiplicando = 2, resultado;

CONSTANTES Aquellos valores que, una vez compilado el programa no pueden ser
cambiados, como por ejemplo los valores literales que hemos usado hasta ahora en las
inicializaciones de las variables (1000, 2, ‘a’, '\n' , etc), suelen denominarse CONSTANTES .

CONSTANTES SIMBOLICAS Para dar un símbolo a una constante bastará, en cualquier

lugar del programa (previo a su uso) poner la directiva: #define, por ejemplo:

#define VALOR_CONSTANTE 342

#define PI 3.1416

OPERADORES
Si analizamos la sentencia siguiente:
var1 = var2 + var3;
Estamos diciéndole al programa, por medio del operador +, que compute la suma del valor de
dos variables, y una vez realizado esto asigne el resultado a otra variable var1. Esta última
operación (asignación) se indica con el signo =
Es por lo tanto válido escribir a = 17 ;
pero no es aceptado , en cambio
17 = a ; /* incorrecto */
De la misma forma que (a + b) es evaluada y su resultado puedo copiarlo en otra
Variable : c = (a + b) ; una asignación (a = b) da como resultado el valor de b , por lo que es
lícito escribir
c=(a=b);
Debido a que las asignaciones se evalúan de derecha a izquierda, los paréntesis son
redundantes, y podrá escribirse entonces:
c = a = b = 17 ;
con lo que las tres variables resultarán iguales al valor de la constante . El hecho de que estas
operaciones se realicen de derecha a izquierda también permite realizar instrucciones del tipo :
a = a + 17 ;
Significando esto que al valor que TENIA anteriormente a , se le suma la constante y LUEGO
se copia el resultado en la variable
Por ejemplo
a += b ; /* equivale : a = a + b */
a -= b ; /* equivale : a = a - b */
a *= b ; /* equivale : a = a * b */
a /= b ; /* equivale : a = a / b */
a %= b ; /* equivale : a = a % b */
TABLA OPERADORES ARITMETICOS
SIMBOLO DESCRIPCION EJEMPLO
+ SUMA a+b
- RESTA a-b
* MULTIPLICACION a * b

/ DIVISION a/b
% MODULO a%b
- SIGNO -a
NOTA: Se puede observar que no existen operadores de potenciación, radicación,
logaritmación, etc, ya que en el lenguaje C todas estas operaciones ( y muchas otras ) se
realizan por medio de llamadas a Funciones.

OPERADORES RELACIONALES
Todas las operaciones relacionales dan sólo dos posibles resultados: VERDADERO ó FALSO.
En el lenguaje C, Falso queda representado por un valor entero nulo (cero) y Verdadero por
cualquier número distinto de cero.
TABLA OPERADORES RELACIONALES
SIMBOLO DESCRIPCION EJEMPLO
< menor que (a < b)
> mayor que (a >b)
<= menor o igual que (a < = b)
 >= mayor o igual que ( a >>= b )

== igual que ( a = = b)
!= distinto que ( a != b)

NOTA: Uno de los errores más comunes es confundir el operador relacional IGUAL (= =) con
el de asignación IGUAL A (=). La expresión a=b copia el valor de b en a, mientras que a = = b
retorna un cero, si a es distinto de b o un número distinto de cero si son iguales.

OPERADORES LOGICOS
Hay tres operadores que realizan las conectividades lógicas Y (AND), O (OR) y NEGACION
(NOT)
TABLA OPERADORES LOGICOS
SIMBOLO DESCRIPCION EJEMPLO
&& Y (AND) (a>b) && (c < d)
|| O (OR) (a>b) || (c < d)
! NEGACION (NOT) !(a>b)

NOTA: Los resultados de la operaciones lógicas siempre adoptan los valores CIERTO ó FALSO.
La evaluación de las operaciones lógicas se realiza de izquierda a derecha y se interrumpe cuando
se ha asegurado el resultado. El operador NEGACION invierte el sentido lógico de las
operaciones, así será
!( a >> b ) equivale a ( a < b )
!( a == b ) " " ( a != b )
TABLA OPERADORES DE INCREMENTO Y DECREMENTO
SIMBOLO DESCRIPCION EJEMPLO
++ incremento ++i ó i++
-- decremento --i ó i--
Para visualizar rápidamente la función de los operadores antedichos, digamos que las
sentencias :
a=a+1;
a++ ;
tienen una acción idéntica , de la misma forma que
a=a-1;
a-- ;
es decir incrementa y decrementa a la variable en una unidad.
BLOQUE DE SENTENCIAS conjunto de sentencias individuales incluidas dentro un par de
llaves.
Este conjunto se comportará sintácticamente como una sentencia simple y la llave de cierre del
bloque NO debe ir seguida de punto y coma. Un ejemplo de bloque ya visto, es el cuerpo del
programa principal de la función main() .
main()
{
bloque de sentencias
sentencia 1 ;
sentencia 2 ;
.............
sentencia n ; }
CONDICIONALES O PROPOSICION IF - ELSE
Esta proposición sirve para ejecutar ciertas sentencias de programa, si una expresión resulta
CIERTA u otro grupo de sentencias, si aquella resulta FALSA. Su interpretación literal sería:
SI es CIERTA tal cosa, haga tal cosa, si no sáltela .
El caso más sencillo sería:
if(expresión)
sentencia ;
o
if(expresión) sentencia ;
Cuando la sentencia que sigue al IF es única, las dos formas de escritura expresadas arriba son
equivalentes. La sentencia sólo se ejecutará si el resultado de "expresión" es distinto de cero
(CIERTO), en caso contrario el programa saltará dicha sentencia, realizando la siguiente en su
flujo.
Su aplicación puede verse en el ejemplo siguiente:
if(expresión) if(expresión)
{ {
sentencia 1 ; sentencia 1 ;
sentencia 2 ; sentencia 2 ;
} }
sentencia 3 ; else
sentencia 4 ; {
sentencia 5 ; sentencia 3 ;
sentencia 4 ;
}
sentencia 5 ;

NOTA: En el ejemplo de la izquierda no se usa el ELSE y por lo tanto las sentencias 3, 4 y 5 se

ejecutan siempre. En el segundo caso , las sentencias 1 y 2 se ejecutan solo si la expresión es
CIERTA , en ese caso las 3 y 4 NO se ejecutarán para saltarse directamente a la 5 , en el caso de
que la expresión resulte FALSA se realizarán las 3 y 4 en lugar de las dos primeras y finalmente
la 5 .
La proposición ELSE queda siempre asociada al IF más cercano, arriba de él. Es común
también, en caso de decisiones múltiples, el uso de anidamientos ELSE-IF de la forma indicada
abajo:
if(exp.1)
sentencia1 ;
else if(exp.2)
sentencia2 ;
else if(exp.3)
sentencia3 ;
else
sentencia5 ;
#include <stdio.h>
#include <conio.h>
int main(){
int hora;
printf( "INTRODUZCA LA HORA\n" );
scanf( "%d", &hora );
if ((hora >= 0) && (hora < 12)){
printf( "Buenos dias" );
} else if ((hora >= 12) && (hora < 18)){
printf( "Buenas tardes" );
}else if ((hora >= 18) && (hora < 24)){
printf( "Buenas noches" );
}else {
printf( "Hora no valida" );
}

getch();
}

LA ITERACION WHILE es una de las tres iteraciones posibles en C . Su sintaxis podría

expresarse de la siguiente forma :
while(expresión) {
proposición 1 ;
proposición 2 ;
...............
proposición n ;
}

Esta sintaxis expresada en palabras significaría: mientras (expresión) dé un resultado CIERTO

ejecútese la proposición 1. Por lo general, dentro de la proposición o del bloque de ellas, se
modifican términos de la expresión condicional, para controlar la duración de la iteración.

VEAMOS EL EJEMPLO:
g
Generar la tabla de multiplicar dado un número entero.
#include <stdio.h>
#include <conio.h>

int main() {

int num, cont, tabla,n;

cont = 1; tabla = 0;
printf( "introduzca el numero: " );
scanf( "%d", &num );
while (cont<=10){
tabla=cont*num;
printf( "la tabla de multiplicar es: %d X %d = %d \n", num, cont, tabla );

cont++;
}

getch();
}
LA ITERACION DO - WHILE Su sintaxis será:
do {
proposición 1 ;
 proposición 2 ;
...............
}while (expresión) ;
Esto significa: ejecute las proposiciones, luego repita la ejecución mientras la expresión dé un
resultado CIERTO. La diferencia fundamental entre esta iteración y la anterior es que el DO-
WHILE se ejecuta siempre AL MENOS una vez, sea cual sea el resultado de expresión.
VEAMOS EL EJEMPLO:
#include <stdio.h>
#include <conio.h>
#include <string.h>
int main() {
int cont, opc;
cont = 0;
do {
printf( "DESEA CONTINUAR 1 y SINO DESEAR CONTINUAR 2\n");
printf( "ELIJA SU OPCION \n");
scanf( "%d", &opc );
cont++;

}while (opc != 2);

getch();
}

LA ITERACION FOR es simplemente una manera abreviada de expresar un WHILE, veamos

su sintaxis:
for ( expresión1 ; expresión2 ; expresion3 ) {
proposición1 ;
proposición2 ;
}
La expresión1 es una asignación de una o más variables, (equivale a una inicialización de las
mismas ) , la expresión2 es una relación de algún tipo que , mientras dé un valor CIERTO ,
permite la iteración de la ejecución y expresión3 es otra asignación , que comúnmente varía
alguna de las variables contenida en expresión2 . Todas estas expresiones, contenidas en el
paréntesis del FOR deben estar separadas por PUNTO Y COMA y NO por comas simples.

VEAMOS EL EJEMPLO:
#include <stdio.h>
#include <conio.h>
int main() {

int i;
double porcentaje,suma,salarionuevo,salario;
suma = 0; porcentaje=0;
printf("INTRODUZCA EL SALARIO\n");
scanf("%d",&salario);
for (i = 1 ; i <= 6 ; i++) {
porcentaje=(salario*0.1);
salarionuevo=salario+porcentaje;
suma+=salarionuevo;
printf( "EL SALARIO DE CADA AÑO ES: %d\n",suma);
printf( "El sumatorio es %d\nn", suma );
 }
printf( "EL SALARIO DURANTE LOS 6 AÑOS ES: %d\n",suma);
getch();
}