ESTRUCTURA DE UN PROGRAMA EN C:
Este tipo de instrucciones se utilizan para
informar al procesador del espacio que debe reservar en memoria para almacenar
un dato simple o estructurado, teniendo siempre presente que todas las
variables, sean del tipo que sean, deberán ser definidas antes de ser
utilizadas o referenciadas.
Pasos para definir una variable simple:
1- Seleccionar el tipo de dato necesario
2- Seleccionar el nombre para la variable (lo más significativo posible)
3- Utilizar el siguiente formato
<modificador
de tipo>Tipo_basico Nombre_de_Variable
4- Se puede definir más de una variable del mismo tipo en una sentencia
separada por comas
<modificador
de tipo>Tipo_basico Nombre_de_Var1, Nombre_de_Var2, ...
5- se pueden inicializar las variables en las instrucciones de definición
<modificador
de tipo>Tipo_basico Nom1 = Val1, Nom2=Val2.
INSTRUCCIONES DE DEFINICIÓN
El formato de unas instrucción de asignación
es:
NombreVar
= expresión
Edad_media =
suma_edad / n_personas
INSTRUCCIONES DE ENTRADA/SALIDA
Són aquellas que nos permiten introducir
datos desde un periférico a la memoria del ordenador y viceversa.
Todo el conjunto de herramientas se encuentra
en la librería estándar “stdio.h”. (Standard Input
Output Header)
Cuando se ejecuta el programa se abren de
forma simultánea 5 vias de acceso:
Stdin
(Entrada de datos, teclado) stdout (salida de datos pantalla), stderr(salida
estándar de errores, pantalla) stdprn(interfaz serie de comunicaciones
estándar), stdaux (salida estándar de impresora)
FUNCIONES DE ENTRADA (TECLADO)
Int getchar(void) de la cabecera: #include <stdio.h>
#include <stdio.h>
main()
{
int c=0;
while( getchar( ) !=’\n’)
c++;
printf(“La línea tiene %d caracteres. \n,c);
Int scanf(const char *formato, lista de
argumentos) de la cabecera: #include
<stdio.h>
Especificadores de formato para la entrada de
datos que indica el tipo de dato que deberá leer.
%c lee un carácter
%d lee un número entero decimal
%i lee un numero entero decimal
%e lee un valor real
%f lee un valor real
%h lee un entero corto
%o lee un octal
%s lee una cadena de caracteres
%x lee un número hexadecimal
%p lee un puntero
el formato de la cadena será:
scanf(“ ... %formato1 ...%formato2
.......”),&var1, &var2, ..);
FUNCIONES DE SALIDA (PANTALLA)
Int putchar(int ch); incluida en la cabecera “stdio.h”
Devuelve un caracter.
#include <stdio.h>
main()
{
char ch;
do
{
ch=getchar();
putchar(ch);
}
while (ch!=’\n’)
}
Int printf(const char *formato, lista de argumentos); incluida en la
cabecera “stdio.h”
Formato:
Printf(“... %formato1 ...%formato2 ...%formato3...”, valor1, valor2,
valor3,...);
#include <stdio.h>
main()
{
printf(“ y en %d %sdos
se hizo la lu%c”,2+2+1,”segun,’z’);
}
%h imprime un entero corto
%u imprime un unsigned int
%d imprime enteros con signo
%ld imprime un entero largo
%c imprime un caracter
%s imprime una cadena de caracteres
%o imprime un octal sin signo
%x imprime un hexadecimal sin signo
%X imprime un hexadecimal sin signo
%e imprime un valor real en notación
científica
%E imprime un valor real en notación
científica
%g usa %e o %f según el tamaño del valor
%p muestra un puntero
%imprime enteros con signo.
Modificadores de formato.
Printf(“%4.3f\n”,1234.3432) imprime 1234.343
Printf(“peso = %*.*f \n”, ancho, precisión,
peso);
Así puede ser ancho y precisión enteros
cortos short.
ESTRUCTURAS DE CONTROL
Estructuras que se basan en expresiones
condicionales que provocan la ejecución controlada de determinadas acciones.
ESTRUCTURAS DE ALTERNATIVAS
1 Formato para la ejecución de una sola
sentencia
If(expresión_condicional)
Sentencia1;
2 Formato para la ejecución de un bloque de
sentencias:
if
(expresión_condicional)
{
sentencia1;
sentencia2;
...
sentencia3;
}
if(expresión_condicional)
sentencia1;
else
sentencia2;
2 Formato para la ejecución de un bloque de
sentencias
if(expresión_condicional)
{
bloque de sentencias1;
}
else
{
bloque de sentencias2;
}
If(expresión_condicional1)
{
bloque
de sentencias1;
}
else if(expresión condicional2)
{
bloque
de sentencias2;
}
else if(expresión condicional3)
{
bloque
de sentencias3;
}
else
{
bloque de sentencias por defecto;
}
Alternativa múltiple, sentencia switch()
Switch(expresión)
{
case
constante1:
bloque
de sentencia1;
break;
case
constante 2:
bloque de sentencia2;
break;
....
default:
bloque
de sentencias por defecto;
}
ESTRUCTURAS DE REPETITIVAS
Este tipo de estructuras permite una repetición cíclica.
Formato:
1- formato de una sola sentencia:
while(expresión condicional)
sentencia1;
2- formato de bloque de sentencias
while(expresión
condicional)
{
bloque de sentencias;
}
do-while
1 formato:
do
{
sentencia1;
}while(expresión
condicional);
2 formato:
do
{
bloque de sentencias;
}while(expresión condicional);
for
En C, esta estructura o instrucción
repetitiva ofrece una gran potencia y enorme flexibilidad, pues no presenta un
formato fijo:
1- Formato de una sóla sentencia:
For
( inicialización; Expresión Condicional; incremento/decremento)
Sentencia1;
2- Formato para la ejecución de un bloque de sentencias:
For
( inicialización; Expresión Condicional; incremento/decremento)
{
Bloque
de sentencias;
}
La
iniciación normalmente suele ser una sentencia de asignación donde la variable
de control del bluque toma un valor inicial.
La
expresión condicional está constituida por una condición que determina el
momento en que debe finalizar la ejecución del bucle.
#include
<stdio.h>
main()
{
int p, c, n;
p=1;
for ( c= 1: c<=5 ; c++)
{
scanf(“%d”,&n);
p= p*n;
}
printf (“ Producto = %d\n”,p);
}
Existen
otras variantes:
1- For(inic1, Inic2, ...; Expresión Condicional; incr/decr1,
incr/decr2,...)
{
Bloque
de sentencias;
}
2- for(Expresión; expresión Condicional; expresión)
{
Bloque de sentencias;
}
#include <stdio.h>
main()
{
int
c;
for ( c = getchar(); c != EOF; c = getchar())
putchar(c);
}
Bucles Infinitos:
1-
For
(;1;)
{
Bloque
de sentencias;
}
2- For ( ; ; )
{
Bloque de sentencias;
}
3- While(1)
{
Bloque de sentencias;
}
ESTRUCTURAS COMPUESTAS (FUNCIONES)
De todo los módulos y funciones contenidos en
un programa, sólo uno de ellos es considerado como la función principal o
función main(), mientras que el resto son considerados como funciones
secundarias. Por convenio, todo programa en C comienza su ejecución
considerando que forman parte del programa. Las características de construcción
són las mismas tanto para la función principal como para las funciones
secundarias y es importante tener en cuenta que es obligatorio una y sólo una
función principal por programa.
Main()
{
definición
de variables locales;
bloque
de sentencias;
función_uno();
bloque
de sentencias;
}
función_uno(lista de parámetros)
definición de parámetros
{
definición
de variables locales;
bloque
de sentencias;
sentencia
return;
}
SENTENCIA GOTO
Su uso está restringido a la programación estructurada,
pues tiende a generar programas difíciles de entender, esta sentencia requiere
de otra etiqueta o identificativo seguido de dos puntos, teniendo en cuenta que
necesariamente deben estar ubicados dentro de la misma función o módulo.
Area_cuadrado()
{
flota
lg;
flota
area;
inicio:
printf
( “\n Introduce la longitud del lado:”);
scanf
( “ % f ”, & lg);
if (
lg < 0)
goto error;
area
= lg * lg;
printf(
“ El valor del área es : %f\n”, area);
goto
inicio;
error:
printf(“El
valor introducido no es correcto.\n”);
}
SENTENCIA BREAK
Marca el final de una sentencia Case, Switch
o forzar la terminación de un bucle, interrumpiendo la secuencia interna de
ejecución.
Break;
SENTENCIA CONTINUE
Es utilizada en sentencias de control
repetitivas siendo su modo de funcionamiento similar a la sentencia break,
salvo que en lugar de forzar una terminación, fuerza una nueva vuelta o
iteración del bucle.
Continue;
EL PREPROCESADOR
El preprocesador en el lenguaje C es una
herramienta que convierte el programa fuente(fichero con extensión .c) en un
fichero compilable.
Las principales directivas que utiliza el
preprocesador son las siguientes:
Directiva
#define Nombre_constante Expresión: Para definir constantes
sibólicas y macros
#define PI
3.141592
#define Nombre_macro(lista_parámetros)
Expresión_macro
#define
suma(x,y) x+y
...
valor = suma ( 3 , 2.5);
#include <Nombre_fichero>:
Para insertar codigo de otros ficheros fuente en el
directorio
estándar del sistema, el que contiene las librerias, directorio include.
#include “Nombre_fichero” Para insertar código de ficheros que está en el directorio
actual,
si no lo encuentra, lo buscará en el estándar del sistema.
#if, #else, #elif, #ifdef, #ifndef: Para compilación condicional
#error, #line, #pragma: para casos especiales.