El Lenguaje de Programación C
Indice
- Tiempo de vida de los datos
- Funciones
- Declaración de las funciones
- Paso de parámetros a una función
- Vectores
- Matrices
- Declaración
- Operadores
- Asignación
- Aritmética de direcciones
- Concepto de estructura
- Estructuras y funciones
- Arrays de estructuras
- Typedef
- Apertura
- Cierre
- Escritura y lectura
CARACTERISTICAS DEL LENGUAJE 'C'
El lenguaje 'C' se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan del código fuente para funcionar (P.ej: Basic).Los compilados convierten el código fuente en un fichero objeto y este en un fichero ejecutable. Este es el caso del lenguaje 'C'.
Podemos decir que el lenguaje 'C' es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje ensamblador. Es un lenguaje estructurado, ya que permite crear procedimientos en bloques dentro de otros procedimientos. Hay que destacar que el 'C' es un lenguaje portable, ya que permite utilizar el mismo código en diferentes equipos y sistemas informáticos: el lenguaje es independiente de la arquitectura de cualquier m quina en particular.
ESTRUCTURA DE UN PROGRAMA EN 'C'
Estructura
Todo programa en 'C' consta de una o
más funciones, una de las cuales se llama main.
El programa comienza en la
función main, desde la cual es posible llamar a otras funciones.
Cada función estar formada por la cabecera de la función,
compuesta por el nombre de la misma y la lista de argumentos (si
los hubiese), la declaración de las variables a utilizar y la
secuencia de sentencias a ejecutar.
ejemplo:
declaraciones globales main( ) { variables locales bloque } funcion1( ) { variables locales bloque }
A la hora de programar es
conveniente añadir comentarios (cuantos más mejor) para poder
saber que función tiene cada parte del código, en caso de que
no lo utilicemos durante algún tiempo. Además facilitaremos el
trabajo a otros programadores que puedan utilizar nuestro archivo
fuente.
Para poner comentarios en un programa escrito en 'C' usamos los
símbolos /* y */:
/* Este es un ejemplo de comentario
*/
/* Un comentario también puede
estar escrito en varias líneas */
El símbolo /* se coloca al
principio del comentario y el símbolo */ al final.
El comentario, contenido entre estos
dos símbolos, no ser tenido en cuenta por el compilador.
Existen una serie de indicadores
reservados, con una finalidad determinada, que no podemos
utilizar como identificadores.
A continuación vemos algunas de estas palabras clave:
char | int | float | double | if |
else | do | while | for | switch |
short | long | extern | static | default |
continue | break | register | sizeof | typedef |
Un identificador es el nombre que
damos a las variables y funciones. Está formado por una
secuencia de letras y dígitos, aunque también acepta el
carácter de subrayado _. Por contra no acepta los acentos ni la
ñ/Ñ.
El primer carácter de un identificador no puede ser un número,
es decir que debe ser una letra o el símbolo _. Se diferencian
las mayúsculas de las minúsculas, así num, Num y nuM son
distintos identificadores.
A continuación vemos algunos ejemplos de identificadores
válidos y no válidos:
Válidos | No válidos |
_num1 | 1num |
var1 | número2 |
fecha_nac | año_nac |
En 'C' existen básicamente cuatro tipos de datos, aunque como se verá después, podremos definir nuestros propios tipos de datos a partir de estos cuatro. A continuación se detalla su nombre, el tamaño que ocupa en memoria y el rango de sus posibles valores.
Tipo | Tamaño | Rango de valores |
char | 1 byte | -128 a 127 |
int | 2 bytes | -32768 a 32767 |
float | 4 bytes | 3'4 E-38 a 3'4 E+38 |
double | 8 bytes | 1'7 E-308 a 1'7 E+308 |
Los calificadores de tipo tienen
la misión de modificar el rango de valores de un determinado
tipo de variable.
Estos calificadores son cuatro:
signed char 1 byte -128 a 127 signed int 2 bytes -32768 a 32767
unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a 65535
short char 1 byte -128 a 127 short int 2 bytes -32768 a 32767
Rango de valores en formato largo
(ampliado).
long int 4 bytes -2.147.483.648 a 2.147.483.647 long double 10 bytes -3'36 E-4932 a 1'18 E+4932
También es posible combinar
calificadores entre sí:
signed long int = long int = long unsigned long int = unsigned long 4 bytes 0 a 4.294.967.295
El mayor entero permitido en 'C'
Una variable es un tipo de dato,
referenciado mediante un identificador (que es el nombre de la
variable). Su contenido podrá ser modificado a lo largo del
programa.
Una variable solo puede pertenecer a un tipo de dato. Para poder
utilizar una variable, primero tiene que ser declarada:
[calificador] <tipo> <nombre>;
Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia:
[calificador] <tipo> <nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<nombre4>;
Las variables pueden ser de dos
tipos según el lugar en que las declaremos: globales o locales.
La variable global se declara antes de la main( ). Puede ser
utilizada en cualquier parte del programa y se destruye al
finalizar éste.
La variable local se declara después de la main( ), en la
función en que vaya a ser utilizada. Sólo existe dentro de la
función en que se declara y se destruye al finalizar dicha
función.
El identificador (nombre de la variable) no puede ser una palabra
clave y los caracteres que podemos utilizar son las letras: a-z y
A-Z (ojo! la ñ o Ñ no está permitida), los números: 0-9 y
el símbolo de subrayado _. Además hay que tener en cuenta que
el primer carácter no puede ser un número.
Al contrario que las variables,
las constantes mantienen su valor a lo largo de todo el programa.
Para indicar al compilador que se trata de una constante,
usaremos la directiva #define:
#define <identificador> <valor>
Observa que no se indica el punto
y coma de final de sentencia ni tampoco el tipo de dato.
La directiva #define no sólo nos permite sustituir un nombre por
un valor numérico, sino también por una cadena de caracteres.
El valor de una constante no puede ser modificado de ninguna
manera.
Ciertos caracteres no
representados gráficamente se pueden representar mediante lo que
se conoce como secuencia de escape.
A continuación vemos una tabla de las más significativas:
\n | salto de línea |
\b | retroceso |
\t | tabulación horizontal |
\v | tabulación vertical |
\\ | contrabarra |
\f | salto de página |
\' | apóstrofe |
\" | comillas dobles |
\0 | fin de una cadena de caracteres |
En la programación en 'C' es
posible utilizar funciones que no estén incluídas en el propio
programa. Para ello utilizamos la directiva #include, que nos
permite añadir librerías o funciones que se encuentran en otros
ficheros a nuestro programa.
Para indicar al compilador que vamos a incluir ficheros externos
podemos hacerlo de dos maneras (siempre antes de las
declaraciones).
#include "misfunc.h" #include "c:\includes\misfunc.h"
#include <misfunc.h>
OPERADORES ARITMETICOS Y DE ASIGNACION
Existen dos tipos de operadores aritméticos:
Binarios |
Unarios |
||
+ | Suma | ++ | Incremento (suma 1) |
- | Resta | ||
* | Multiplicación | -- | Decremento (resta 1) |
/ | División | ||
% | Módulo (resto) | - | Cambio de Signo |
Sintaxis |
|||
<variable1><operador><variable2> | <variable><operador> y al revés |
La mayoría de los operadores aritméticos binarios tienen su correspondiente operador de asignación:
= | Asignación simple |
+= | Suma |
-= | Resta |
*= | Multiplicación |
/= | División |
%= | Módulo (resto) |
Con estos operadores se pueden escribir, de forma más breve, expresiones del tipo:
n=n+3 se puede escribir n+=3Habrá que tener en cuenta la precedencia de los operadores a la hora de trabajar con ellos:
( ) Mayor precedencia |
++, - - |
*, /, % |
+, - Menor precedencia |
Las operaciones con mayor
precedencia se realizan antes que las de menor precedencia.
Si en una operación encontramos signos del mismo nivel de precedencia, ésta se realiza de
izquierda a derecha:
a*b+c/d-e
La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla. El prototipo de la sentencia printf es el siguiente:
printf(control,arg1,arg2...);
En la cadena de control indicamos
la forma en que se mostrarán los argumentos posteriores.
También podemos introducir una cadena de texto (sin necesidad de
argumentos), o combinar ambas posibilidades, así como secuencias
de escape.
En el caso de que utilicemos
argumentos deberemos indicar en la cadena de control tantos
modificadores como argumentos vayamos a indicar.
El modificador está compuesto por
el carácter % seguido por un carácter de conversión, que
indica de que tipo de dato se trata.
Los modificadores más utilizados son: |
%c Un único carácter |
%d Un entero con signo, en base decimal |
%u Un entero sin signo, en base decimal |
%o Un entero en base octal |
%x Un entero en base hexadecimal |
%e Un número real en coma flotante, con exponente |
%f Un número real en coma flotante, sin exponente |
%s Una cadena de caracteres |
%p Un puntero o dirección de memoria |
El formato completo de los modificadores es el siguiente:
% [signo] [longitud] [.precisión][l/L] conversión
Signo: indicamos si el valor se
ajustará a la izquierda, en cuyo caso utilizaremos el signo
menos, o a la derecha (por defecto).
Longitud: especifica la longitud
máxima del valor que aparece por pantalla. Si la longitud es
menor que el número de dígitos del valor, éste aparecer
ajustado a la izquierda.
Precisión: indicamos el número
máximo de decimales que tendrá el valor.
l/L: utilizamos l cuando se trata
de una variable de tipo long y L cuando es de tipo double.
La rutina scanf permite entrar
datos en la memoria del ordenador a travs del teclado.
El prototipo de la sentencia scanf es el siguiente:
scanf(control,arg1,arg2...);
En la cadena de control
indicaremos, por regla general, los modificadores que harán
referencia al tipo de dato de los argumentos. Al igual que en la
sentencia printf los modificadores estarán formados por el
carácter % seguido de un carácter de conversión.
Los argumentos indicados serán,
nuevamente, las variables.
La principal característica de la
sentencia scanf es que necesita saber la posición de la memoria
del ordenador en que se encuentra la variable para poder
almacenar la información obtenida. Para indicarle esta posición
utilizaremos el símbolo ampersand (&), que colocaremos
delante del nombre de cada variable.
(Esto no es necesario en los
arrays).
Los operadores relacionales sirven para comparar el contenido de dos variables.
En 'C' existen seis operadores relacionales:
> | Mayor que |
< | Menor que |
>= | Mayor o igual que |
<= | Menor o igual que |
== | Igual que |
!= | Distinto que |
El resultado que devuelven estos
operadores es 1 para Verdadero y 0 para Falso.
Si hay más de un operador se
evalúan de izquierda a derecha. Además los operadores == y !=
están por debajo del resto en cuanto al orden de precedencia.
Este tipo de sentencias permiten
variar el flujo del programa en base a determinadas condiciones.
Existen varias estructuras
diferentes:
Sintaxis:
if (condición)sentencia;
La sentencia solo se ejecuta si se
cumple la condición. En caso contrario el programa sigue su
curso sin ejecutar la sentencia.
Otro formato:
if (condición)sentencia1; else sentencia2;
Si se cumple la condición
ejecutará la sentencia1, sinó ejecutará; la sentencia2.
En cualquier caso, el programa continuará a partir de la
sentencia2.
Otro formato:
if (condición)sentencia1; else if (condición) sentencia2; else if (condición) sentencia3; else sentencia4;
Con este formato el flujo del
programa únicamente entra en una de las condiciones. Si una de
ellas se cumple, se ejecuta la sentencia correspondiente y salta
hasta el final de la estructura para continuar con el programa.
Existe la posibilidad de utilizar
llaves para ejecutar más de una sentencia dentro de la misma
condición.
Esta estructura se suele utilizar
en los menús, de manera que según la opción seleccionada se
ejecuten una serie de sentencias.
Su sintaxis es:
switch (variable){ case contenido_variable1: sentencias; break; case contenido_variable2: sentencias; break; default: sentencias;
Cada case puede tener una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que encuentra un BREAK. La variable evaluada sólo puede ser de tipo entero o carácter. Default ejecuta las sentencias si la opción escogida no existe.
Los operadores lógicos son tres:
&& | AND |
|| | OR |
! | NOT (El valor contrario) |
Estos operadores actúan sobre expresiones lógicas. Permiten unir expresiones lógicas simples formando otras más complejas.
OPERANDOS | AND | OR | |
V | V | V | V |
V | F | F | V |
F | V | F | V |
F | F | F | F |
Los bucles son estructuras que
permiten ejecutar partes del código de forma repetida mientras
se cumpla una condición.
Esta condición puede ser simple o
compuesta de otras condiciones unidas por operadores lógicos.
Su sintaxis es:
while (condición)sentencia;
Con esta sentencia se controla la
condición antes de entrar en el bucle. Si ésta no se cumple el
programa no entrará en el bucle.
Naturalmente, si en el interior
del bucle hay más de una sentencia, éstas deberán ir entre
llaves para que se ejecuten como un bloque.
Su sintaxis es:
do{ sentencia1; sentencia2; }while (condición);
Con esta sentencia se controla la
condición al final del bucle. Si ésta se cumple el programa
vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las
sentencias while y do...while es que con la segunda el cuerpo del
bucle se ejecutar por lo menos una vez.
Su sintaxis es:
for (inicialización;condición;incremento){ sentencia1; sentencia2; }
La inicialización indica una variable (variable de control) que condiciona la repetición del bucle. Si hay más, van separadas por comas:
for (a=1,b=100;a!=b;a++,b- -){
El bucle FOR se ejecuta de la siguiente forma:
Esta sentencia se usa para terminar la ejecución de un bucle o salir de una sentencia SWITCH.
Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente pasada del bucle.
Permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilización. Es una sentencia muy mal vista en la programación estructurada.