Introducción Al Lenguaje C

CICLO FORMATIVO DE GRADO SUPERIOR (1º)
Automatización y Robótica Industrial
MÓDULO:
INFORMÁTICA INDUSTRIAL
INTRODUCCIÓN A LA PROGRAMACIÓN
1. HISTORIA DEL LENGUAJE C
El lenguaje C es hoy en día uno de los más extendidos. Podemos asegurar que junto con su
hermano C++ se ha convertido en el lenguaje por excelencia de los ambientes comerciales y
profesionales. Esta popularidad se ve apoyada por la gran cantidad de compiladores, librerías,
generadores de código, libros y artículos en revistas especializadas existentes en el mercado
sobre C.
El lenguaje C fue desarrollado hacia 1972 por Dennis Ritchie en los laboratorios Bell de
AT&T. Ritchie se dedicaba a la programación de sistemas (lenguajes, S.O, software de base, etc.)
y desarrolló C como una herramienta excelente para este tipo de tareas. Sin embargo,
actualmente el C se ha convertido en un lenguaje de propósito general y es utilizado en
desarrollos de distintos tipos (S.O, gráficos, gestión, construcción de compiladores, juegos,
multimedia...).
Es uno de los sistemas operativos más importantes y extendidos, Unix, está escrito en su
totalidad en C y sólo algunos detalles de implementación dependientes de la máquina están
escritos en lenguaje ensamblador. Otros entornos que utilizan C como lenguaje principal son
DOS, Windows, NT, OS/2, X Window... Como podemos ver, se trata de un lenguaje realmente
importante.
El C no pasa de moda. Por ejemplo, C es un lenguaje perfecto para desarrollar programas

multimedia, algo muy en boga hoy día. En fin, que C se adapta a lo que le echen, incluso a la
programación orientada a objetos (POO). Gracias a un señor llamado Bjarne Strouptrup tenemos
C++. C++ es una extensión estricta de C con características de orientación a objeto (clases,
herencia, polimorfismo...). Un lenguaje que se está extendiendo muy aprisa gracias a su gran
aceptación, pero esa es otra historia.
Hay gente que dice que C es un lenguaje muy difícil de aprender, en fin, que tiene símbolos
raros. Sin embargo, esos símbolos no son tantos y en ellos reside gran parte de la potencia de
este lenguaje.
Existe una gran cantidad de entornos en el mercado para desarrollar programas en C. Por
ejemplo, en Unix el compilador de C (cc) se distribuye junto con el sistema operativo de forma
gratuita, como una herramienta más. En los demás sistemas normalmente se debe adquirir como
un paquete aparte. En DOS/Windows existen varios paquetes en el mercado tales como Borland
C++, Microsoft Visual C++, Symantec C++ y Dev-C++.
2 Informática Industrial
2. CARACTERÍSTISCAS DE LENGUAJE C
El lenguaje C es un lenguaje de programación de propósito general y sus principales

características son:
Permite programación estructurada, facilitando, facilitando la representación gráfica del

flujo de control u organigrama de los programas. Las estructuras básicas son:
⇒ Secuencial (Sucesión de acciones).

⇒ Condicionales.
⇒ Repetitivas.
La sentencia GOTO de BASIC va contra los lenguajes estructurados puesto que

no ajusta a los diagramas de flujo de control.
Permite programación modular, es decir permite realizar subprogramas que en realidad

son funciones, que pueden ser utilizadas en cualquier punto del programa.
Una de las grandes bazas del C es su portabilidad. Los programas en C pueden ser
trasladados a cualquier sistema existente tan sólo con recompilar el código.
Naturalmente hablamos de C estándar sin las extensiones propias de cada compilador.
Es un lenguaje compilado. Todos los lenguajes necesitan el empleo de programas

traductores que transformen el programa fuente que esta en lenguaje C (será el
programa realizado con el editor correspondiente) a programa objeto que estará en
código máquina. Dependiendo de cómo se realice la traducción tenemos compiladores e
interpretes.
Interpretes: La traducción de las ordenes de usuario en C a código máquina

se realizan sentencia a sentencia, va ejecutándose cada sentencia traducida.
Por tanto un error detendrá la ejecución del programa. Un ejemplo de lenguaje
interpretado será BASIC.
Compiladores: Este programa traduce de todas las sentencias del programa

fuente en C a la vez dejándolo escrito en lenguaje máquina. Después de la
traducción se ejecuta automáticamente un programa denominado enlazador
encargado de incorporar la bibliotecas del lenguaje utilizado. Si durante la
traducción encuentra algún error de sintaxis el enlace no se realiza y no genera
el ejecutable.
Linkado o
Compilado enlazado
PROGRAMA PROGRAMA PROGRAMA
FUENTE OBJETO ejecutable
Nombreprog.c Nombreprog.obj Nombreprog.exe
I.E.S. “Cavanilles" 3
Distingue perfectamente entre mayúsculas y minúsculas. Por tanto cuando se declaren
variables hay que tener en cuenta de escribirlas exactamente igual. Ejemplo: Las
variables SUma y suma serán distintas. Las instrucciones se escribirán siempre en
minúsculas.
3. ESTRUCTURA DE UN PROGRAMA
La estructura general de un programa en C esta compuesto por las siguientes partes:

encabezamiento y cuerpo.
Estructura de un programa
/*Primer programa en */
Comentarios
/*saludo.c*/
ENCABEZAMIENTO Declaración de ficheros externos # include <stdio.h>

utilizados (include)
#define MSG_SALUDO “Hola buenas
Declaración de constantes (define)
tardes. \n”
main () que es la función principal main()
{ {
Declaración de variables y tipos Int num;
num=1;
CUERPO
printf (MSG_SALUDO);
Instrucciones del programa principal
printf(“Soy un ordenador.\n”);
printf(“Mi numero es el %d. \n “,num);
} }
El orden de las diferentes declaraciones puede variar a gusto del programador, e incluso
pueden hacerse declaraciones de variables entre las instrucciones del programa. Aunque la
estructura anterior se puede seguir para realizar programas sencillos, cuando estos son más
complejos se suelen dividir en varios ficheros con las siguientes extensiones:
♦ Los ficheros de constantes, declaraciones, cabeceras de subprogramas y referencias a

ficheros de librerías del lenguaje tendrán extensión .h. El usuario puede utilizar las librerías
de predefinidas o puede crear librerías de funciones, se suelen guardar en ficheros con
extensión .h.
#include “mifichero.h”
♦ Los ficheros del código fuente, entre los que estaría el programa principal y los ficheros con
los subprogramas del usuario, se almacena con extensión .c.
3.1 COMENTARIOS
A la hora de realizar programas es aconsejable incluir comentarios al inicio del programa

indicando que hace el programa y en que fichero lo hemos almacenado. Los comentarios en C
van precedidos de /* y terminan en */. Lo que este escrito entre estos dos símbolos no será tenido
en cuenta, por tanto si por error solo se pone primero a partir de ahí todas las instrucciones las
considera comentario, por tanto hay que asegurarse de colocar bien el principio y final de
comentario.
/* Es un ejemplo de comentario*/
/* Los comentarios también se puede
poner en varias lineas*/
3.2 DIRECTIVAS PARA EL COMPILADOR
Las directivas para el compilalador no son instrucciones ejecutables sino que sirven para
indicar al compilador, o más concretamente al preprocesador (editor con el que hacemos el
programa), una serie de acciones que se deben realizar durante la compilación. Entre estas
acciones estarían.
La declaración de constantes con la directiva #define.

La inclusión de ficheros con la directiva #include.
Directiva define
La directiva define se utiliza para declaración de constantes que se podrán utilizar siempre
que necesitemos. Su formato es: # define nombre valor.
Por ejemplo: # define MSG_SALUDO “Hola buenas tardes”

# define pi 3,141592
# define DOS 2
Directiva include
Se utiliza para llamar a ficheros. Su formato es: # include nombre_fichero.
El nombre del fichero debe ir entre < > si este forma parte de una librería de compilación o
entre doble comillas “” si se va especificar su ruta o path.
Por ejemplo: # include <stdio.h>

# include “c:\prograC\manos.h”
# include “datos.h”
Dentro de estas librerías tendremos, entre otras cosas, las funciones que vayamos a utilizar
a lo largo del programa. Cabe mencionar que el compilador por s mismo solo reconoce unos
pocos operadores (operadores aritméticos, lógicos, relaciones, etc), el resto de funciones están
incluidas en librerías. Si lo que pretendemos es realizar un programa para que funcione en un
ordenador y que el modo de introducir las entradas sea el teclado y de la salida sea el monitor,
deberemos siempre incluir <stdio.h> como librería, ya que es la que contiene dichas funciones.
3.3 CARACTERES EN C
Los caracteres en C pueden agruparse en letras, dígitos, espacios en blanco, caracteres
especiales, signos puntuación y secuencias de escape.
Los caracteres espacio en blanco, tabulador horizontal, tabulador vertical, avance de página
y nueva línea, son caracteres denominados caracteres en blanco sirven para hacer más legible el
programa. Por ejemplo:
main ()
{
printf ("Hola, que tal estais. \n");
}
Pero si se colocan en exceso los espacios en blanco son ignorados por el compilador. Hay
otros caracteres que tienen una función especial como son los siguientes: ; : “ { } y muchos otros.
Secuencias de escape
Se utilizan para poder sacar por pantalla ciertos elementos que no podemos escribir, como
nueva línea, tabular y para hacer referencia a caracteres no imprimibles. Así mismo, también se
utiliza para sacar por pantalla simbología con función especial. El lenguaje C tiene predefinidas las
siguientes secuencias de escape.
Secuencias de escape
\n Ir al principio de la siguiente línea
\t Tabulador horizontal
\v Tabulador vertical
\b Retroceso
\r Retorno de carro sin avance de línea
\f Alimentación de página
\a Alerta, pitido
\´ Comilla simple
\” Comilla doble
\\ Barra invertida
\ ddd Carácter ASCII. Representación octal
\ xdd Carácter ASCII. Representación hexadecimal
Identificadores
Los identificadores son nombres dados a constante, variables, tipos, funciones y etiquetas
de un programa. Los identificadores constan de uno o más caracteres (letras, dígitos) como norma
nunca debe ser el primer carácter debe ser una letra o un carácter subrayado.
Palabras clave
Existen una serie de identificadores predefinidos que tienen un significado especial para el
compilador, por tanto un identificador definido por el usuario no puede tener el mismo nombre que
una palabra clave.
auto double int struct

break enum long switch
case else register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Ejemplo1 de programa:
/* Uso de las constantes */

/* constan.c/*
#include <stdio.h>
#define pi 3.1416
#define escribe printf
main() /* Calcula el perimetro */
{
int r;
escribe ("Introduce el radio: ");
scanf("%d",&r);
escribe ("El perimetro es: %f",2*pi*r);
}
3.4 TIPOS DE DATOS
En 'C' existen básicamente cuatro tipos de datos, aunque como veremos después‚si
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.
Tipos de datos
Tipo Tamaño en Rango de valores
bits
char 8 -128 a 127
Tipos enteros:
int 16 -32768 a 32767
Float 32 3.4 E-38 a 3.4 E+38

Tipos reales:
double 64 1.7 E-308 a 1.7 E+308
Modificadores de los tipos de datos
Todos los tipos enteros pueden llevar los modificadores signed (con signo) o con unsigned
(sin signo).
También pueden llevar los modificadores: short y long, los tipos int , así tendremos short
int o long int. También se aplica long a double, tendremos long double.
3.4.1 char
Se utiliza para caracteres y almacenan un valor entero entre –128 a 127 cuando la
definimos como char o signed char indistintamente. Cuando la definimos como unsigned char
su valor varía de 0 a 128.
Ejemplo: char car;
signed char c;
unsigned char b;
A continuación si las inicializamos:
car = “z”; /* en código ASCII z es 122 , sería lo mismo car = 122 */
b=‘‘; /* en código ASCII espacio en blanco es 32, equivale a poner b=32 */
3.4.2 int
Un int es la abreviación de signed int, para C es un número sin decimales. El tamaño en

bits depende de la arquitectura del la máquina lo habitual es que sea de 16 bits.
15 15
-32768 a 32767 ( -2 a 2 -1) para int o signed int o signed.
16
0 a 65535 (0a2 –1) para unsigned int o unsigned.
Un short o short int (se puede poner de las dos forma) es un entero de tipo corto, cuyo
valor será menor o igual a int. Así normalmente los valores que toma son:
15 15
-32768 a 32767 ( -2 a 2 -1) para short o signed short ( short int o signed short int).
16
0 a 65535 (0a2 –1) para unsigned short (unsigned short int).
Un long o long int (se puede poner de las dos forma) es un entero de tipo corto, cuyo
valor será mayor o igual a int. Así normalmente los valores que toma son:
31 31
-2147483648 a 2147483647 ( -2 a 2 -1) para long o signed long ( long int o signed long int).
32
0 a 4294967295 (0a2 –1) para unsigned long (unsigned long int).
Notar que los cualificadores de tipo (short y long) pueden variar de formato (nº de
bytes usados) dependiendo del compilador. Normalmente se utilizará int y cuando el
rango nos exceda, podremos utilizar el long int. Siempre se podrá recurrir a un float,
aunque no utilicemos decimales, pero ocupará más memoria inútilmente.
3.4.3 float
Es un numero real con coma flotante, es un numero con decimales que puede estar
comprendido entre: 3.4 E-38 a 3.4E+38, tanto para valores positivos como para valores negativos.
El valor 3.4 E-38 nos indica la precisión o el valor más pequeño que puede representar, y 3.4E+38
el máximo valor que puede representar.
3.4.4 double
Es un numero real con coma flotante de doble precisión, que puede estar comprendido
entre: 1.7 E-308 a 1.7E+308
Puede tener el modificador long, que pasará de 64 bits a 80 bits pero se deberá poner como
long double tendrá una precisión de 3.4 E-4932 a 3.4E+4932. Se tratan ambos de un número
real con coma flotante con un rango mayor, tanto en la precisión como en el valor máximo.
3.5 VARIABLES
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:
<tipo> <nombre>;
Ejemplo: Declaración de variables.
int p;
float suma, precio;
Ejemplo: Inicializar variables.
p=25;
precio=300;
Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia:
<tipo> <nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<nombre4>;
Ejemplo: unsigned inter a=25,b=100;
Como ampliaremos posteriormente las variables pueden ser globales o locales. Las globales
afectan a todo el programa y se declaran después de main () al iniciar el cuerpo del programa. Las
variables locales se declaran dentro de las funciones.
Ejemplo 2 de programa:
/* Uso de las variables */

/* variable.c */
#include <stdio.h>
main() /* Suma dos valores */
{
int num1=4,num2,num3=6;
printf ("El valor de num1 es %d",num1);
printf ("\n El valor de num3 es %d",num3);
num2=num1+num3;
printf ("\nnum1 + num3 = %d",num2);
}
3.6 OPERADORES
Un operador es un símbolo que indica al compilador que ha de realizar operaciones

matemáticas o lógicas. Se dividen en : aritméticos, relacionales y lógicos.
Operadores aritméticos
Los operadores aritméticos más habituales son los siguientes:
Operador Acción Ejemplos

+ Suma a=a+5
- Resta c=b-a
* Multiplicación res = b * c
/ División a=b/5
++ Incremento (suma1) x++ = x +1
-- Decremento (resta 1) x - - = x -1
% Módulo (resto de una división) 13 % 5 es 3
= Asignación a=7
/******************** Operaciones aritméticas *******************/

/*aritmeti.c*/
#include <stdio.h>
main()
{
int dato1, dato2, resultado;
dato1 = 20;
dato2 = 10;
/*Suma*/
resultado = dato1 + dato2;
printf("%d + %d = %d \n", dato1, dato2, resultado);
/*Resta*/
resultado = dato1 - dato2;
printf("%d - %d = %d \n", dato1, dato2, resultado);
/* Producto*/
resultado = dato1 * dato2;
printf("%d * %d = %d \n", dato1, dato2, resultado);
/* Cociente*/
resultado = dato1 / dato2;
printf("%d / %d = %d \n", dato1, dato2, resultado);
}
Operadores relacionales

< Menor que a<b
<= Menor que o igual que c <= b - a
> Mayor que res > b * c
>= Mayor que o igual que a >= b / 5
== Igual cajas = = 5
!= Distinto cajas != 5
Operadores lógicos

&& And (y) (a < b) && (j<5)
|| Or(o) (c <= b – a) || (d = 5)
! Not (no) ! (res = b * c)
3.6.1 Jerarquía de los operadores
Habrá 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, esta se realiza de
izquierda a derecha:
Ejemplo 4 de programa: printf("%d + %d = %d\n",x,y,z);

r=z-e;
/* Jerarquía de los operadores */
printf("%d = %d",r,a*b+c/d-e);
/* operad1.c*/
}
#include <stdio.h>
main() /* Realiza una operación */
{
int a=6,b=5,c=4,d=2,e=1,x,y,z,r;
x=a*b;
printf("%d * %d = %d\n",a,b,x);
y=c/d;
printf("%d / %d = %d\n",c,d,y);
z=x+y;
a+=5;
printf("a + 5 = %d\ n" ,a);
/* Uso de los operadores de asignación */
c-=1;
/* operad2.c */
printf("c - 1 = %d\ n" ,c);
#include <stdio.h>
b*=3;
main() /* Realiza varias operaciones */
printf("b * 3 = %d" ,b);
{
}
int a=1, b=2, c=3 ;
3.7 UTILIZACIÓN DE printf Y scanf
Las operaciones printf y scanf son de entrada y salida (E/S) por lo tanto no forman parte del
conjunto de sentencias de C sino que pertenecen al conjunto de funciones de la biblioteca
estándar de C. Por esta razón cualquier fichero fuente en el que se incluyan las operaciones E/S,
deberá contener la línea: # include <stdio.h>
3.1 SENTENCIA printf( )
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 esta 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:
Modificadores Salida
%c Un único carácter (int).
%d Un entero con signo, en base decimal.
%i Un entero con signo, en base decimal.
%u Un entero sin signo, en base decimal.
%o Un entero en base octal.
%x Un entero sin signo en base hexadecimal letras en minúsculas. %X (mayúsculas)
%e Un número real en coma flotante, con exponente en minúscula. %E (mayúsculas)
%f Un número real en coma flotante, sin exponente.
%g Un número real en coma flotante, con formato %f o %e. (%G en mayúsculas)
%s Una cadena de caracteres
%p Un puntero o dirección de memoria
%n Un puntero a un entero, en el cual se almacena el tamaño de l buffer.
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, este aparece ajustado a la izquierda.
Precisión: indicamos el número máximo de decimales que tendrá el valor.

Ejemplo: % 10.3 d /* numero entero en 10 espacios con 3 decimales ajustar derecha */
% -10.4d/* numero entero en 10 espacios con 3 decimales ajustar derecha */
h/l/L: utilizamos h cuando se trata de una variable de tipo short, l cuando es de tipo long y h
tipo double.
Debemos tener en cuenta que los modificadores entre corchetes [ ] son opcionales.
3.2 SENTENCIA scanf( )
La rutina scanf permite entrar datos en la memoria del ordenador a través 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.
Ejemplo 6 de programa: printf ("%s c es %e o %f",cad,c,c);

}
/* Uso de la sentencia printf() 1. */
#include <stdio.h>
main() /* Modificadores 1 */
{
char cad[]="El valor de";
int a=-15;
unsigned int b=3;
float c=932.5;
printf ("%s a es %d\n",cad,a);
printf ("%s b es %u\n",cad,b);
long int b=1976524;
float c=9.57645;
/* Uso de la sentencia printf() 2. */
printf ("%s a es %9d\n",cad,a);
#include <stdio.h>
printf ("%s b es %ld\n",cad,b);
main() /* Modificadores 2 */
printf ("%s c es %.3f",cad,c);
{
getch ();
char cad[ ]="El valor de";
}
int a=25986;
Ejemplo 8 de programa
/* La suma de dos numeros*/
/*suma.c*/
#include<stdio.h>
main ()
{
int dato1, dato2,suma;
printf ("Introduce dos numeros: ");
scanf ("%d \n %d",&dato1,&dato2);
/*resultado*/
suma = dato1 + dato2;
printf ("La suma es: %d + %d = %d",dato1,dato2,suma);
}
Ejercicios propuestos:
1. El ejemplo 8 modifícalo para que no solo obtengas la suma, sino también la resta, la división y
la multiplicación, con un formato similar al que tiene la suma.
2. Realizar un programa que calcule los intereses producidos y el capital total acumulado de una
cantidad c, invertida a un interés r durante t días.
c⋅r ⋅t
La fórmula utilizada para el calculo de los intereses es: I =
360 ⋅ 100
Siendo: I = Total intereses a pagar.
c = Capital.
r = Tasa de interés nominal en tanto por ciento.
t = Período de cálculo en días.
4 3
3. Realizar un programa que calcule el volumen de una esfera, cuya fórmula es: v = πr
3
4. Realizar un programa que pregunte el nombre y el año de nacimiento y dé como resultado:
Hola “nombre de la persona”, en el año 2032 tendrás “n” años.
4. SENTENCIAS DE CONTROL
4.1 SENTENCIA IF
La sentencia if permite a un programa tomar una decisión para ejecutar una acción u otra,
basándose en el resultado verdadero o falso de una expresión. La sintaxis es la siguiente:
if (condición) Ejemplo 9 de programa:

/* Uso de la sentencia condicional if. */
{
/* clave.c*/
Sentencias_verdad;
#include <stdio.h>
}
main() /* Simula una clave de acceso */
else
{
{ int usuario,clave=123;
Sentencia_falso; printf("Introduce tu clave: ");
} scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
else
printf("Acceso denegado");
}
Si en alguno de los camino de verdad o falso solo hay una sentencia que ejecutar pueden
omitirse las llaves. Una sentencia if se ejecuta de la siguiente forma:
Se evalúa la condición.
Si el resultado de evaluar la condición es verdadero (distinto de cero) se ejecutará lo

indicado en las sentencias_verdad.
Si el resultado de evaluar la condición es falso (es cero) se ejecutará lo indicado en las

sentencias_falso.
Si el resultado de evaluar la condición es falso (es cero), y se ha omitido el else

entonces las sentencias_verdad se ignoran.
En cualquiera de los casos cuando se termina el else se continua con la siguiente

sentencia ejecutable.
4.1.1 ANIDAMIENTO DE SENTENCIAS IF
Las sentencias if...else pueden estar anidadas. Con la siguiente sintaxis por ejemplo:
if (condición 1) Ejemplo 10 de programa:

/***Menor de tres números a, b y c*****/
{
/* menor.c*/
if (condición 2) #include <stdio.h>
Sentencias_verdad;
main()
else
{
Sentencia_falso; float a, b, c, menor;
} printf("Números a b c : ");
else scanf("%g %g %g", &a, &b, &c);
if (a < b)
Sentencia_falso;
if (a < c)
menor = a;
else
menor = c;
else
if (b < c)
menor = b;
else
menor = c;
printf("Menor = %g\n", menor);
}
Estructura else if
Es una estructura que aparece con bastante frecuencia, es consecuencia de las sentencias
if anidadas. Tiene la siguiente sintaxis.
if (condición 1) Ejemplo 11 de programa:

/*Descuento en función de las unidades compradas*/
sentencia 1;
/* descuento.c */
else if (condición 2) #include <stdio.h>
Sentencias2; main()
{
else if (condición 3)
int ar, cc; /* código y cantidad */
Sentencia3; float pu; /* precio unitario */
else printf("Codigo articulo....... ");
Sentencia_falso; scanf("%d", &ar);
printf("Cantidad comprada..... ");
scanf("%d", &cc);
printf("Precio unitario....... ");
scanf("%f", &pu);
printf("\n\n%10s %10s %10s %10s %10s\n\n",
"Articulo", "Cantidad", "P. U.", "Dto.", "Total");
printf("%10d %10d %10.2f", ar, cc, pu);
if (cc > 100)
printf(" %9d%% %10.2f\n", 40, cc * pu * 0.6);
else if (cc >= 25)
printf(" %9d%% %10.2f\n", 20, cc * pu * 0.8);
else if (cc >= 10)
printf(" %9d%% %10.2f\n", 10, cc * pu * 0.9);
else
printf(" %10s %10.2f\n", "--", cc * pu);
}
4.2 SENTENCIA SWITCH
Permite ejecutar una o varias acciones, en función del valor de una expresión. Es una
sentencia especial para decisiones multiples. La sintaxis a utilizar es la siguiente.
switch (expresión)
{
case valor1: sentencias 1; break;
..............
case valorN: sentencias N; break;
default: sentencias_por_defecto;
}
Primero se evalúa la expresión y se ejecutan las sentencias de la rama cuyo valor coincida
con el de la expresión. La expresión puede debe ser entera, o un char con valor entero o una
constante entera.
La rama default es opcional incluirla y se ejecuta cuando ninguno de los valores

enumerados valor1,......,valorN ha coincidido con el valor de la expresión. La rama default puede
colocarse en cualquier parte del bloque.
Cuando un valor coincide con la expresión, se ejecuta la sentencia o sentencias

especificadas, continuando con el siguiente case, a no ser que se decida abandonar el bloque y
esto es precisamente lo que hace break. Es decir cuando se cumple un case y hay un break no
pasa al siguiente case sino que da por finalizado el switch. Poner break es opcional para el
programador, pero sirve para eliminar posibles errores. El break se puede poner también en el
default.
case 1:
/*Días correspondientes a un mes de un año case 3:
dado*/
case 5:
/*dias.c*/
case 7:
#include <stdio.h>
case 8:
case 10:
main()
case 12:
{
dd = 31;
unsigned int dd = 0, mm = 0, aa = 0;
break;
printf("Introducir mes (##) y año (####): ");
case 4:
scanf("%d %d", &mm, &aa);
case 6:
switch (mm)
case 9:
{
case 11:
dd = 30; printf("\nEl mes no es valido\n");
break; break;
case 2:
if ((aa % 4 == 0) && (aa % 100 != 0) || }
(aa % 400 == 0)) if (mm >= 1 && mm <= 12)
dd = 29; printf("\nEl mes %d del año %d tiene %d
else dias\n", mm, aa, dd);
dd = 28;
break; }
default:
Ejercicio propuesto:
Realizar un programa que pida “Dar el número del día de la semana” y escriba el
equivalente en letras.
4.3 SENTENCIAS REPETITIVAS O BUCLES
Las sentencias repetitivas o 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. Existen tres tipos principales:
while, do y for.
4.3.1 SENTENCIA while
La sentencia while repite una o varias sentencias mientras el valor de una condición sea
verdadero. La sintaxis es la siguiente:
While (condición)
Sentencia_que_se_repite;
Una sentencia while se ejecuta de la siguiente forma:

Se evalúa la condición.
Si el resultado es falso, la sentencia no se ejecuta y sigue con la sentencia que haya

después de la condición de while.
Si el resultado es cierto, se ejecuta la sentencia y el proceso se repite otra vez,

empezando en el punto de evaluar la condición de nuevo.
Ejemplo 13 de programa: {
/* Uso de la sentencia WHILE. */ int numero=1;
/*while.c*/ while(numero<=25)
#include <stdio.h> {
#include <stdlib.h> printf("%d\n",numero);
main() /* Escribe los números del 1 al 25 */ numero++;
} Ejemplo 14 de programa:
system("PAUSE"); /* Uso de la sentencia WHILE. */
} /*divisor.c*/
#include <stdio.h>
#include <stdlib.h>
main()
{
int num,divisor;
printf("Numero:...");
scanf("%d",&num);
divisor=num;
while(divisor>0)
{
if (num % divisor ==0)
printf("El numero %d es divisor de
%d\n",divisor,num);
divisor --;
} system("PAUSE");
}
4.3.2 SENTENCIA do while
La sentencia do while repite una o varias instrucciones hasta que se cumpla una condición.
La condición se evalúa después de ejecutar las sentencias del bucle. La sintaxis es la siguiente:
do {
sentencia_que_se_repite
}
while (condición);
Una sentencia do while se ejecuta de la siguiente forma:
Se evalúa ejecuta la sentencia que se repite en el do.
Se evalúa la expresión correspondiente a la condición del while.
Si el resultado es falso, la sentencia no se ejecuta y sigue con la sentencia que haya

después de la condición de while.
Si el resultado es cierto, se ejecuta la sentencia y el proceso se repite otra vez,

empezando en el punto de evaluar la condición de nuevo.
Ejemplo 15 de programa: Ejemplo 16 de programa:
/* Uso de la sentencia WHILE. */ /* Uso de la sentencia DO...WHILE. */
/* x.c */ /*dowhile.c*/
#include <stdio.h> #include <stdio.h>
main() main() /* Mostrar un menú si no se pulsa 4 */
{ {
char c; char seleccion;
int cont=0; do{
printf("Introduza un texto en una línea:...."); printf("1.- Comenzar \n");
do printf("2.- Abrir \n");
{ printf("3.- Grabar \n");
scanf("%c",&c); printf("4.- Salir\ n");
if (c =='x') printf("Escoge una opción: ");
cont =cont + 1; seleccion=getchar();
} switch(seleccion){
while(c!='\n'); case '1':printf("Opción 1 \n");
printf("Aparece %d veces letra X \n", cont); break;
getch(); case '2':printf("Opción 2 \n");
} break;
case '3':printf("Opción 3 \n");
}
} while(seleccion!='4');
getch();
}
4.3.3 SENTENCIA for
La sentencia for permite repetir una o varias tantas veces como indique una variable. La
condición se evalúa despees de ejecutar las sentencias del bucle. La sintaxis es la siguiente:
for (Inicialización; Condición_fin; Incremento)

sentencia_que_se_repite
Una sentencia for se ejecuta de la siguiente forma:
La Inicialización es una o varias instrucciones separadas por comas, que se ejecuta la

primera vez. Suele ser la asignación de valor inicial a la variable indice del bucle
(Ejemplo: i =1).
La Condición_fin provoca el fin del bucle cuando su valor sea falso (Ejemplo: i <= 5).
El incremento es una o varias instrucciones separadas por comas, que se ejecuta una vez en
cada ejecución del bucle antes de evaluar la Condición_fin. Suele ser la instrucción de
incremento de la variable indice ( Ejemplo: i ++).
Si la Condición_fin es verdadera sentencia_que_se_repite se ejecutará, hasta que la

Condición_fin sea falsa, entonces se sale del bucle.
Por ejemplo para escribir los 10 primeros números enteros en orden creciente:
for (1=1; i <= 10; i++)

printf (“%10” , i);
y para escribirlos en orden decreciente:
for (1=10; i <= 1; i- -)

printf (“%10” , i);
/* Uso de la sentencia FOR. */

/* for.c*/
#include <stdio.h>
main() /* Escribe la tabla de multiplicar */
{
int num,x,result;
printf("Introduce un numero: ");
scanf("%d",&num);
for (x=0;x<=10;x++){
result=num*x;
printf("\n%d por %d = %d\n",num,x,result);
}
getch();
}
4.3.4 BUCLES ANIDADOS
Cuando se incluye una sentencia while dentro de otra sentencia while, en general una
sentencia while, do o for dentro de otra de ellas, estamos en el caso de bucles anidados.
Ejemplo 18 de programa: }
/*bucle.c*/
#include <stdio.h>
void main()
{
int i = 1, j = 1;
while ( i <= 3 ) /* mientras i sea <=3 */
{
printf("Para i = %d: ", i);
while ( j <= 4 ) /* mientras j sea <= que 4 */
{
printf("j = %d, ", j);
j++;
}
printf("\n");
i++; /* aumentar i en una unidad */
j = 1; /* inicializar j de nuevo a 1 */
}
getch();
Ejemplo 19 de programa: z = sqrt(x * x + y * y);
/* Teorema de Pitágoras*/ while (y <= 50 && z <= 50)
/*Imprime los valores z, comprendidos entre 1 {
y 50, que cumplan la expresión z2 = x2 + y2 */ /* Si la raíz cuadrada anterior fue exacta,
/* pitagoras.c*/ escribir z, x e y */
#include <stdio.h> if (z * z == x * x + y * y)
#include <math.h> printf("%10d %10d %10d\n", z, x, y);
void main() y = y + 1;
{ z = sqrt(x * x + y * y);
unsigned int x = 1, y = 1, z = 0; }
printf("%10s %10s %10s\n", "Z", "X", "Y"); x = x + 1; y = x;
printf(" ___________________________\n"); }
while (x <= 50) getch();
{ }
/* Calcular z. Como z es un entero, almacena
la parte entera de la raíz cuadrada */
4.4 SENTENCIA break
La sentencia break finaliza la ejecución de una sentencia switch, while, do o for en la cual
aparece. Tal como hemos visto en switch.
4.5 SENTENCIA continue
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 iteración del bucle.

/* El siguiente programa que imprime todos /* Uso de la sentencia CONTINUE. */
los numeros entre 1 y 100 no seanmultiplo de /* continue2.c*/
5*/ #include <stdio.h>
/*continue1.c*/ main() /* Escribe del 1 al 100 menos el 25 */
void main() int numero=1;
{ while(numero<=100)
int n; {
for (n = 0; n <= 100; n++) if (numero==25)
{ {
if (n % 5 == 0) /* si n es múltiplo de 5, numero++;
siguiente iteración */ continue;
continue; }
printf("%d ", n); printf("%d ",numero);
} numero++;
getch(); }
} getch();
}
Ejercicios propuestos:
1. Realizar un programa que calcule las raíces de la ecuación: ax 2 + bx + c = 0 , teniendo en

cuenta los siguientes casos:
Si a es igual a 0 y b es igual a 0, imprimiremos un mensaje diciendo que la ecuación es

degenerada.
Si a es igual a 0 y b no es igual a 0, existe una raíz única con valor – c / b.
− b ± b 2 − 4ac
En los demás casos, utilizaremos la fórmula siguiente: xi =
2a
La expresión d = b 2 − 4ac se denomina discriminante.
Si d es mayor o igual que 0 entonces hay dos raíces reales.
x + yi
Si d es menor 0 entonces hay dos raíces complejas de la forma:
x − yi
2. Realizar un programa que pida una fecha , de la forma: dd de mm de aaaa, donde dd, mm y
aaaa son enteros. Este programa debe averiguar su número del Tarot, sumando los números
de su fecha de nacimiento y a continuación los reduce a un solo dígito; por ejemplo si su fecha
de nacimiento fuera 17 de Octubre de 1970, los cálculos serían:
17 + 10 + 1970 = 1997 ⇒ 1 + 9 + 9 + 7 = 26 ⇒ 2 + 6 = 8
lo que quiere decir que su número del Tarot es el 8.
5. FUNCIONES
En C como en la mayoría de los lenguajes, existen funciones que son bloques de código
utilizados para dividir un programa en partes más pequeñas (subprogramas), cada una de las
cuáles tendrá una tarea determinada. Su sintaxis es:
tipo_función nombre_función (tipo y nombre de argumentos)

{
declaración de variables locales;
sentencias;
return ( valor o expresión );
}
tipo_función: puede ser de cualquier tipo de los que conocemos. El valor devuelto por la
función será de este tipo. Por defecto, es decir, si no indicamos el tipo, la función devolverá
un valor de tipo entero (int). Si no queremos que retorne ningún valor deberemos indicar el
tipo vacío (void).
nombre_función: es el nombre que le daremos a la función.
tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos
de una función no son más que variables (locales) definidas en la función, que reciben un
valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones
que no reciban argumentos.
declaración de variables locales: son las variables declaradas dentro de la función y por
tanto solo son accesibles dentro de la función.
bloque de sentencias: es el conjunto de sentencias que serán ejecutadas cuando se

realice la llamada a la función.
retorno a un valor: las funciones pueden retornar un valor. Esto se hace mediante la
instrucción return, que finaliza la ejecución de la función, devolviendo o no un valor. En
una misma función podemos tener más de una instrucción return. El valor devuelto por la
función debe asignarse a una variable. De lo contrario, el valor se perderá.
Las funciones pueden ser llamadas desde la función main o desde otras funciones. Nunca
deben llamar a la función main. Por último recalcar que los argumentos de la función y sus
variables locales se destruirán al finalizar la ejecución de la misma. Su sintaxis puede ser también:
tipo_función nombre_función (nombre de argumentos)

declaración de argumentos;
{
declaración de variables locales;
sentencias;
return ( valor o expresión );
}
5.1 TIEMPO DE VIDA DE LOS DATOS
Según el lugar donde son declaradas puede haber dos tipos de variables:
Globales: las variables permanecen activas durante todo el programa. Se crean al

iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser utilizadas en cualquier
función.
Locales: las variables son creadas cuando el programa llega a la función en la que están
definidas. Al finalizar la función desaparecen de la memoria.
Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá sobre
la global dentro de la función en que ha sido declarada. Dos variables locales pueden tener el
mismo nombre siempre que estén declaradas en funciones diferentes

/* Variables globales y locales. */ /* Declaración de funciones. */
/*funcion1.c*/ /*funcion2.c*/
int num1=1; /*variable global*/ void funcion(void); /* prototipo */
main() /* Escribe dos cifras */ int num=5; /* variable global */
{ main() /* Escribe dos números */
int num2=10; /*variable local*/ {
printf("num1 = %d\n",num1); int num=10; /* variable local */
printf("num2 = %d\n",num2); printf("La variable local num = %d\n",num);
getch(); funcion(); /* llamada */
} getch();
}
void funcion(void)
{
printf("La variable global num = %d\n",num);
}
En el ejemplo23 podemos ver la declaración de una función (prototipo). Que al no recibir ni

retornar ningún valor, está declarada como void en ambos lados.
5.2 DECLARACIÓN DE LAS FUNCIONES
Al igual que las variables, las funciones también han de ser declaradas. Esto es lo que se
conoce como prototipo de una función. Para que un programa en C sea compatible entre distintos
compiladores es imprescindible escribir los prototipos de las funciones. Los prototipos de las
funciones pueden escribirse antes de la función main o bién en otro fichero. En este último caso
se lo indicaremos al compilador mediante la directiva #include.
Ejemplo 24 de programa: } Ejemplo 24.1 de programa:

/* Declaración de funciones. */ int suma(int x,int y) /* Declaración de funciones. */
/*sumafun.c*/ { /*sumafun.c*/
#include <stdio.h> return x + y; #include <stdio.h>
int suma(int x,int y); /* prototipo */ } int suma(x,y); /* prototipo */
main() /* Escribe dos números */ main() /* Escribe dos números */
{ {
int a,b; /* variable local */ int a,b; /* variable local */
printf("Valor de a: "); printf("Valor de a: ");
scanf("%d",&a); scanf("%d",&a);
printf("Valor de b: "); printf("Valor de b: ");
scanf("%d",&b); scanf("%d",&b);
printf("La suma de a y b es: printf("La suma de a y b es:
%d\n", suma(a,b)); %d\n", suma(a,b)); getch();
getch(); }
int suma(x,y) Ejemplo 25 de programa:
int x,y; /* Paso de parámetros. */
{ /*funcion3.c*/
return x + y; #include <stdio.h>
} int suma(int,int); /* prototipo */
main() /* Realiza una suma */
{
int a=10,b=25,t;
t=suma(a,b);/*guardamos el
valor */
printf("%d=%d",suma(a,b),t);
suma(a,b); /* el valor se pierde
sino lo asigno a una variable con
un printf */
getch();
}
int suma(int a,int b)
{
return (a+b);
}
5.3 PASO DE PARAMETROS A UNA FUNCIÓN
Como se ha visto las funciones pueden retornar a un valor mediante la sentencia return.
Esta sentencia tiene dos usos importantes:
Uno de ellos se utiliza par provocar la salida inmediata de una función en la que esta,
volviendo al programa que llamo esta función.
Otro es usar return para devolver un valor.
Además una función puede tener varias sentencias return.
Ejemplo 26 de programa: {
/*Un numero elevado a una potencia positiva*/ float i;
/*exponente.c*/ if (exp < 0)
#include <stdio.h> return ; /* no funciona con números negativos*/
potencia(int base,int exp); i=1;
main() for ( ;exp;exp --)
{ i = base * i ;
int a,b; /* variable local */ printf ("La respuesta es: %f",i);
for(;;) }
{ Ejemplo 27 de programa:
printf("\nValor de a: "); /*Un numero elevado a una potencia positiva/
scanf("%d",&a); /*exponente.c*/
printf("Valor de b: "); #include <stdio.h>
scanf("%d",&b); float potencia(int base,int exp);
potencia(a,b); main()
} {
getch(); int a,b; /* variable local */
} for(;;)
potencia(int base,int exp) {
printf("\nValor de a: "); {
scanf("%d",&a); float i;
printf("Valor de b: "); if (exp < 0)
scanf("%d",&b); return ; /* no funciona con números negativos*/
printf("La respuesta es: %f\n",potencia(a,b)); i=1;
} for ( ;exp;exp --)
getch(); i = base * i ;
} return(i);
float potencia(int base,int exp) }
Existen dos formas de enviar parámetros a una función:
Por valor: cualquier cambio que se realice dentro de la función en el argumento enviado, NO
afectará al valor original de las variables utilizadas en la llamada. Es como si trabajáramos con
una copia, no con el original. No es posible enviar por valor arrays, deberemos hacerlo por
referencia.
Por referencia: lo que hacemos es enviar a la función la dirección de memoria donde se

encuentra la variable o dato. Cualquier modificación si afectará a las variables utilizadas en la
llamada. Trabajamos directamente con el original.
Para enviar un valor por referencia se utiliza el símbolo & delante de la variable enviada.
Esto le indica al compilador que la función que se ejecutará tendrá que obtener la dirección de
memoria en que se encuentra la variable.
Las variables con un * son conocidas como punteros (almacena una dirección de memoria),
devuelven el valor de la variable situada en la dirección de memoria de esa variable.
Ejemplo 28 de programa: }
/* Paso por valor. */ Ejemplo 29 de programa:
void intercambio(int,int); void intercambio(int *,int *);
main() /* Intercambio de valores */ main() /* Intercambio de valores */
{ {
int a=1,b=2; int a=1,b=2;
printf("Tenemos que a=%d y b=%d \n",a,b); printf("Tenemos que a=%d y b=%d \n",a,b);
intercambio(a,b); /* llamada */ intercambio(&a,&b); /* llamada */
printf("\nNos queda al final a=%d y b=%d",a,b); printf("\nNos queda al final a=%d y b=%d",a,b);
getch(); getch();
} }
void intercambio (int x,int y) void intercambio (int *x,int *y)
{ {
int aux; int aux;
aux=x; aux=*x;
x=y; *x=*y;
y=aux; *y=aux;
printf("a=%d y b=%d",x,y); printf("a=%d y b=%d",*x,*y);
}
5.4 FUNCION MAIN
Todo programa tiene una función main principal, es el punto de entrada y de salida del
programa. Hay compiladores que no requieren tipo retornado como el Dev-C++, generalmente
debería hacerse ya que hay compiladores que dan un mensaje de aviso. Los tipos retornados son
int o void se hace de la siguiente forma:
int main () void main ()

{ {
.... ....
return 0; }
}
5.4.1 LOS ARGUMENTOS DE LA FUNCIÓN MAIN
Ya hemos visto que las funciones pueden recibir argumentos. Pues bien, la función main no
podía ser menos y también puede recibir argumentos, en este caso desde el exterior. Los
argumentos que puede recibir son:
argc: es un contador. Su valor es igual al número de argumentos escritos en la línea de

comandos, contando el nombre del programa que es el primer argumento.
argv: es un puntero a un array de cadenas de caracteres que contiene los argumentos, uno
por cadena. En este ejemplo vamos a ver un pequeño programa que escribirá un saludo por
pantalla.
Ejemplo 30 de programa: Ejemplo 30.1 de programa:

/* Argumentos de la main. */ /* Argumentos de la main. */
main(int argc,char *argv[]) /* argumentos */ main(argc,argv) /* argumentos */
{ int argc;
printf("\nCurso de Programación en C \n"); char *argv[];
printf("Programa de ejemplo.\n\n"); {
if (argc!=3) printf("\nCurso de Programacion en C\n");
{ printf("Programa de ejemplo.\n\n");
printf("Teclee: funcion6 su_nombre"); if (argc!=3)
exit(1); /* fin */ {
} printf("Teclee: funcion6 su_nombre");
printf("Hola %s",argv[1]); exit(1); /* fin */
} }
printf("Hola %s",argv[1]);
}
6. ARRAYS
Un array es un identificador que referencia un conjunto de datos del mismo tipo, se podrá
utilizar un dato u otro con sólo cambiar el índice que lo referencia. El índice será un valor entero y
positivo. En C los arrays comienzan por la posición 0.
Según su dimensión tenemos arrays unidimensionales y arrays multidimensionales.
6.1 ARRAYS UNIDIMENSIONALES
La declaración de un array de una dimensión , se hace así:
Tipo nombre_array [ tamaño ] ;

Tipo nombre_array [ ] ;
El tipo de datos puede ser cualquier tipo menos void.
Nota: El lenguaje C no hará comprobaciones de contornos en los arrays por lo tanto es

responsabilidad del programador el manejo adecuado de los arrays evitando el desbordamiento
de los mismos escribiendo o leyendo fuera de los limites, porque si se sale de limites puede
sobreescribir sobre otras variables, por tanto el programador debe asignar el suficiente tamaño a
los arrays.
Ejemplos:
int lista [100]; /*lista de 100 elementos*/
char nombre [40] /*una cadena de 40 elementos*/
También podemos inicializar (asignarle valores) un vector en el momento de declararlo. Si lo

hacemos así no es necesario indicar el tamaño. Su sintaxis es:
tipo nombre [ ]={ valor 1, valor 2...}
Ejemplos:
int vector[5]={10, 20, 30,40,50 }; 10 20 30 40 50

vector[0] vector[1] vector[2] vector[3] vector[4]
int vector[ ]={10, 20, 30,40,50 };

char vector[ ]="programador";
char vector[ ]="no se puede abrir un archivo";
char vector[ ]={'p','r','o','g','r','a','m','a','d','o','r'};
Ejemplo 31 de programa: /* Declaración de un array. */
/*arrays1a.c*/ Ejemplo 32 de programa:
main() /* Rellenamos del 0 - 9 */ /*arrays1b.c*/
{ #define N_ELEMENTOS 15 /*número de elementos
int vector[10],i; del array */
for (i=0;i<10;i++) void main()
vector[i]=i; {
for (i=0;i<10;i++) int a[N_ELEMENTOS]; /* array a */
printf(" %d",vector[i]); int i = 0; /* subíndice */
getch(); printf("Introducir los valores del array.\n");
} for (i = 0; i < N_ELEMENTOS; i++)
{
printf("a[%d]= ", i);
scanf("%d", &a[i]);
}
/* Salida de datos */
printf("\n\n");
for (i = 0; i < N_ELEMENTOS; i++)
printf("%d ", a[i]);
printf("\n\nFin del proceso.\n");
getch();
}
6.1.1 CADENAS DE CARACTERES
Una particularidad con los arrays de tipo char (cadena de caracteres), es que deberemos
indicar en que elemento se encuentra el fin de la cadena mediante el caracter nulo (\0). Esto no lo
controla el compilador, y tendremos que ser nosotros los que insertemos este carácter al final de
la cadena.
Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es

decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4], debemos asignar el
carácter nulo a vector[5]. Es muy sencillo: vector[5]='\0'. En resumen: al declarar una cadena
deberemos reservar una posición más que la longitud que queremos que tenga dicha cadena.

/* Vector de tipo char. */ /*arrays6.c*/
/*arrays2.c*/ #include <stdio.h>
#include <stdio.h> #define TM 5
main()
main() /* Rellenamos un vector char */ {
{ char s[TM];
char cadena[20]; puts("Escribe hola");
int i; gets(s);
for (i=0 ; i<19 && cadena[i -1] !=13 ; i++) printf("%s\n", s);
cadena [i] = getche( ) ; getch();
if (i==19) cadena[i]=' \0 ' ; }
else cadena [i -1]=' \0 '; /* La cadena s quedará así en memoria:*/
printf(" \n %s " ,cadena);
}
h o l a /0
6.1.2 FUNCIONES PARA TRABAJAR CON CADENAS DE CARACTERES
Entrada y salida de consola
Para el uso de estas funciones es necesario incluir el archivo "stdio.h".
getchar(): Lee un carácter desde el teclado, espera por el retorno de carro.
getche(): Lee un carácter del teclado con eco, no espera por retorno de carro.
getch(): Leé un carácter del teclado, no hace eco y no espera por retorno de carro.
putchar(): Escribe un carácter en la pantalla.
gets(): Lee una cadena desde el teclado.
puts(): Escribe una cadena en la pantalla.
6.2 ARRAYS BIDIMENSIONALES
La declaración de un array de dos dimensiones , se hace así:
Tipo nombre_array [nº_filas] [nº_col] ;
Tipo nombre_array [ ] [nº_col] ;
Ejemplos:
int c [2] [3] ; o también se puede inicializarla a la vez que se declara de dos formas
distintas:
int c [2] [3] = {10, 20 , 30 , 40, 50, 60 };
int c [ ] [3] = {10, 20 , 30 , 40, 50, 60 };
Columna 0 Columna 1 Columna 2

Fila 0 10 20 30
Fila 1 40 50 60
Para acceder a los datos de los arrays lo haremos con subíndices, el primero indicará la fila
y el siguiente la columna:
Columna 0 Columna 1 Columna 2
Fila 0 c [0] [0] c [0] [1] c [0] [2]
Fila 1 c [1] [0] c [1] [1] c [1] [2]
Haciendo uso de la siguiente fórmula podemos averiguar el número de bytes de memoria
usados por un array:
bytes = filas * columnas * sizeof(tipo_de_datos) Ejemplo : 2 * 3 * 2 = 6 bytes
Ejemplo 35 de programa: while (nalumnos < 1 || nalumnos > ALUM_MAX);

/*********** Nota media del curso ********************/ /* Entrada de datos */
/* notas.c */ for (i = 0; i < nalumnos; i++)
#define ALUM_MAX 100 /* número máximo de printf("Alumno numero %3d, nota final: ", i+1);
alumnos */ scanf("%f", &notas[i]);
main() }
{ /* Sumar las notas */
float notas[ALUM_MAX]; /* array notas */ for (i = 0; i < nalumnos; i++)
int i = 0; /* índice */ suma += notas[i];
int nalumnos = 0; /* número de alumnos */ /* Escribir resultados */
float suma = 0; /* suma de todas las notas */ printf("\n\nNota media del curso: %5.2f\n", suma /
do nalumnos);
{ getch();
printf("Numero de alumnos: "); }
scanf("%d", &nalumnos);
}
Ejemplo 36 de programa: do
/***** Suma de las filas de un array bidimensional *****/ {
/* arraybi.c*/ printf("Número de columnas del array: ");
#include <stdio.h> scanf("%d", &cols);
#define FILAS_MAX 10 /* número máximo de filas */ }
#define COLS_MAX 10 /* número máximo de while (cols < 1 || cols > COLS_MAX);
columnas */ for (fila = 0; fila < filas; fila++)
main() {
{ sumafila = 0;
float c[FILAS_MAX][COLS_MAX]; /* array dos for (col = 0; col < cols; col++)
dimensiones */
{
float sumafila; /* suma de los elementos de una fila */
printf("c[%d][%d] = ", fila, col);
int filas, cols; /* filas y columnas del array*/
scanf("%f", &c[fila][col]);
int fila, col; /* fila y columna del elemento accedido */
sumafila += c[fila][col];
do
}
{
printf("Fila %d, suma = %g\n", fila, sumafila);
printf("Número de filas del array: ");
}
scanf("%d", &filas);
getch();
}
}
while (filas < 1 || filas > FILAS_MAX);
6.2.1 ARRAYS CADENAS DE CARACTERES BIDIMENSIONALES
Un array de cadenas es un array donde cada elemento es a su vez una cadena de

caracteres, es decir un array tipo char de dos dimensiones.
char lista [3] [6]; /* tres cadenas de seis cararacteres cada una */
lista[0] lista[1] lista[2]
lista[0]
lista[1]
lista[2]
Los arrays lista[0], lista[1] y lista[3] son tres cadenas de caracteres de 6 elementos cada
una.
6.3 ARRAYS MULTIDIMENSIONALES
La declaración de un array de dos dimensiones , se hace así:
Tipo nombre_array [expre-cte-1] [expre-cte-2] [expre-cte-3] ......... ;
Tipo nombre_array [ ] [expre-cte-2] [expre-cte-3] ......... ;
La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos 3D.
/*suma2.c*/
int suma(int x,int y)
{
return x + y;
}
8. NÚMEROS ALEATORIOS
Ejemplo 37 de programa: num = rand () % (10);

/* El uso de los números aleatorios*/ printf("\n Dime un numero entre 0 y 10: “);
/* adivina1.c*/ scanf(“%d”,&mio);
#include <stdio.h> if (num == mio)
#include <stdlib.h> printf(“Acertaste\n”);
#include <time.h> else
main(void) printf(“Fallaste\n”);
{ printf(“ Mio = %d, Num = %d”,mio,num);
int num,mio; }
for (;;) }
{ Ejemplo 38 de programa:
randomize(); /* El uso de los números aleatorios*/
/* adivina2.c*/ num = rand() % (10);
#include <stdio.h> printf(“\n Dime un numero entre 0 y 10: “);
#include <stdlib.h> scanf(“%d”,&mio);
#include <time.h> if (num == mio)
main(void) printf(“Acertaste\n”);
{ else
int num,mio; printf(“Fallaste\n”);
for (;;) printf(“ Mio = %d, Num = %d”,mio,num);
{ }
randomize(); }

Introducción Al Lenguaje C

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introducción Al Lenguaje C

Încărcat de

Drepturi de autor:

Formate disponibile

CICLO FORMATIVO DE GRADO SUPERIOR (1º)

Automatización y Robótica Industrial

El C no pasa de moda. Por ejemplo, C es un lenguaje perfecto para desarrollar programas

El lenguaje C es un lenguaje de programación de propósito general y sus principales

Permite programación estructurada, facilitando, facilitando la representación gráfica del

⇒ Secuencial (Sucesión de acciones).

La sentencia GOTO de BASIC va contra los lenguajes estructurados puesto que

Permite programación modular, es decir permite realizar subprogramas que en realidad

Es un lenguaje compilado. Todos los lenguajes necesitan el empleo de programas

Interpretes: La traducción de las ordenes de usuario en C a código máquina

Compiladores: Este programa traduce de todas las sentencias del programa

La estructura general de un programa en C esta compuesto por las siguientes partes:

ENCABEZAMIENTO Declaración de ficheros externos # include <stdio.h>

♦ Los ficheros de constantes, declaraciones, cabeceras de subprogramas y referencias a

A la hora de realizar programas es aconsejable incluir comentarios al inicio del programa

/* Los comentarios también se puede

poner en varias lineas*/

3.2 DIRECTIVAS PARA EL COMPILADOR

La declaración de constantes con la directiva #define.

Por ejemplo: # define MSG_SALUDO “Hola buenas tardes”

Se utiliza para llamar a ficheros. Su formato es: # include nombre_fichero.

Por ejemplo: # include <stdio.h>

auto double int struct

/* Uso de las constantes */

Float 32 3.4 E-38 a 3.4 E+38

Modificadores de los tipos de datos

Ejemplo: char car;

A continuación si las inicializamos:

car = “z”; /* en código ASCII z es 122 , sería lo mismo car = 122 */

b=‘‘; /* en código ASCII espacio en blanco es 32, equivale a poner b=32 */

Un int es la abreviación de signed int, para C es un número sin decimales. El tamaño en

Una variable es un tipo de dato, referenciado mediante un identificador (que es el nombre de

Ejemplo: Declaración de variables.

float suma, precio;

Ejemplo: Inicializar variables.

Ejemplo: unsigned inter a=25,b=100;

/* Uso de las variables */

Un operador es un símbolo que indica al compilador que ha de realizar operaciones

Los operadores aritméticos más habituales son los siguientes:

Operador Acción Ejemplos

/******************** Operaciones aritméticas *******************/

Operador Acción Ejemplos

Operador Acción Ejemplos

3.6.1 Jerarquía de los operadores

Ejemplo 4 de programa: printf("%d + %d = %d\n",x,y,z);

3.7 UTILIZACIÓN DE printf Y scanf

3.1 SENTENCIA printf( )

En la cadena de control indicamos la forma en que se mostrar n los argumentos posteriores.

Los modificadores más utilizados son:

% [signo] [longitud] [.precisión] [l/L] conversión

Signo: indicamos si el valor se ajustar a la izquierda, en cuyo caso utilizaremos el signo

Precisión: indicamos el número máximo de decimales que tendrá el valor.

3.2 SENTENCIA scanf( )

Ejemplo 6 de programa: printf ("%s c es %e o %f",cad,c,c);

4. Realizar un programa que pregunte el nombre y el año de nacimiento y dé como resultado:

Hola “nombre de la persona”, en el año 2032 tendrás “n” años.

if (condición) Ejemplo 9 de programa:

Si el resultado de evaluar la condición es verdadero (distinto de cero) se ejecutará lo

Si el resultado de evaluar la condición es falso (es cero) se ejecutará lo indicado en las

Si el resultado de evaluar la condición es falso (es cero), y se ha omitido el else

En cualquiera de los casos cuando se termina el else se continua con la siguiente

if (condición 1) Ejemplo 10 de programa:

if (condición 1) Ejemplo 11 de programa:

La rama default es opcional incluirla y se ejecuta cuando ninguno de los valores

/** Operaciones aritméticas */