Lenguaje C PDF

INFORMÁTICA
INDUSTRIAL
LENGUAJE C
VISUAL C
Visual C – Lenguaje C ARI Página 1

TEMA 01
NOCIONES BÁSICAS
1.1.- Introducción.
1.2.- Mi primer programa en C.
1.3.- Elementos básicos de un programa de C.
1.4.- Ejercicios.
El lenguaje C fue inventado por Dennis Ritchie en 1972 en el proceso de diseño del
sistema operativo UNIX. Deriva del lenguaje B de Ken Thompson quien cooperó
también en el diseño de la primera versión (UNIX v.5). Más tarde surgieron gran
cantidad de nuevas implementaciones y se hizo necesario un estándar, el ANSI C. La
implementación que usaremos es la de Visual C ++ 2010 Express.
Algunas características del C son:
 Es un lenguaje de propósito general porque no está enfocado a hacer un tipo

determinado de programas, con él se puede crear desde sistemas operativos hasta
los más avanzados sistemas expertos.
 Es de medio nivel porque en él se puede trabajar a alto nivel (nivel lógico, más
fácil) y a bajo nivel (nivel físico del ordenador, más rápido).
 Su código es fácilmente portable a otros sistemas.
 Es un lenguaje potente y eficiente: Usando C, un programador puede casi
alcanzar la eficiencia del código ensamblador junto con la estructura del Algol o
Pascal.
Para crear un programa en C se deben seguir los siguientes pasos:
1. Escribirlo en uno o más ficheros de texto de una forma reconocible por el

compilador (se escriben con extensión .C o .CPP). Son los ficheros de
código fuente.
2. Compilarlo. Los ficheros fuente se compilan creando ficheros de código

objeto o código máquina con significado para el microprocesador (se
escriben con extensión .OBJ).

Este código objeto no está completo, le falta una serie de rutinas que
están en las librerías (.LIB) y a las que por ahora solo hace referencia.
3. Enlazarlo. Se unen todos los programas (.OBJ y .LIB) mediante el

enlazador (linker) que produce un fichero ejecutable (.EXE, .COM) por
el sistema operativo (por ejemplo tecleando nosotros su nombre en la
línea de comandos).
4. Depurarlo. Se comprueba si hay errores.
5. Ejecutarlo. Si funciona correctamente, como nosotros queremos, el

programa está acabado. En caso contrario habrá que corregirlo y volver a
repetir todos los pasos anteriores.
El entorno de desarrollo integrado de Visual C++ proporciona facilidades para

administrar cada estado del programa, desde la creación del código fuente a la
construcción (compilado y enlazado) del código, hasta probar, depurar y optimizar el
programa.
1.2.- Mi primer programa en C.
Todos los programas deben incluir las librerías, la función principal, abrir llave y cerrar
llave.
En programación, la experiencia es la gran maestra. Por ello, es conveniente hacer

programas en C cuanto antes. Por ejemplo mi primer programa en C puede ser el
siguiente:
Programa 001
1ª línea /* Programa 001 */
2ª línea // Programa que escribe una frase
3ª línea # include <stdio.h>
4ª línea void main (void)
5ª línea {
6ª línea printf( “Mi primer programa en C.” );
7ª línea }

Este proyecto se llamará Programa 001 y su misión es sacar por pantalla la frase: Mi
primer programa en C. Para crear un nuevo proyecto y agregar un archivo de código
fuente seguiremos los siguientes pasos.
1. Si hemos creado un icono de acceso directo en el escritorio hacemos doble clic

en el botón izquierdo del ratón.
2. Si no hemos creado el icono de acceso directo pulsamos en Inicio, Todos los
programas, Microsoft Visual C++ 2010 Express, Microsoft Visual C++
2010 Express, haciendo un clic en el botón izquierdo del ratón aparece la
siguiente imagen la primera vez y en sucesivas veces saldra una lista con los
proyectos recientes.
3. En el menú Archivo, seleccionamos Nuevo y, a continuación, hacemos clic en

Proyecto.
O directamente hacemos doble click con el botón izquierdo del ratón en Nuevo
Proyecto.

4. En la pantalla que nos aparece, hacemos clic en Win32 y, a continuación, en
plantillas instaladas de Visual Studio hacemos clic en Aplicación de consola
Win32.
5. En Nombre escribimos el nombre del proyecto. En nuestro caso Programa001.
De forma predeterminada, la solución que contiene el proyecto tiene el mismo

nombre que el nuevo proyecto, pero podemos escribir un nombre diferente.
Podemos, también, escribir una ubicación diferente para el proyecto.
Hacemos clic en Aceptar para crear el nuevo proyecto y aparece la siguiente

pantalla.

6. Hacemos clic en Siguiente o en Configuracion de la aplicación viendo la
siguiente pantalla.
7. En el Asistente para aplicaciones Win32 en el apartado Tipo de aplicación

debemos marcar: Aplicación de consola y en Opciones adicionales: Proyecto
vacío. Atención: debemos desmarcar Encabezado precompilado. A
continuación hacemos clic en Finalizar.
8. En la siguiente pantalla, si el Explorador de soluciones no está visible, hacemos

clic en Explorador de soluciones en el menú Ver.
9. Para agregar un nuevo archivo de código fuente, en el Explorador de

soluciones, seleccionamos Programa001, Archivo de código fuente, botón
derecho del ratón, Agregar, Nuevo Elemento.

10. En la siguiente pantalla, en categorías marcamos Visual C++ Código.
En Plantillas, Plantillas instaladas de Visual Studio, hacemos clic en Archivo

C++ (.cpp), escribiendo un nombre de archivo (lo llamamos igual que el
proyecto, Programa001, aunque podemos variarlo) y a continuación, hacemos
clic en Agregar.
Antes de escribir el código debemos agregar un Archivo de Encabezado. Para

ello y teniendo seleccionado Programa001 en el Explorador de soluciones
hacemos clik en botón derecho del ratón y en el menú que se despliega
seleccionamoes Agregar, Nuevo elemento.
Aparece la siguiente pantalla y en Plantillas, Plantillas instaladas en Visual

Studio, seleccionamos Archivo de encabezado (.h). En nombre ponemos
Programa001.

El archivo Programa001.h incluimos las bibliotecas, en este caso stdio.h.
Es momento de escribir el código del programa. El archivo Programa001.cpp

que hemos creado se muesta en la carpeta Archivos de código fuente en el
Explorador de soluciones, apareciendo en la derecha una ventana donde
escribiremos dicho código.

Como nuestros programas son tan sencillos podemos incluir en
Programa001.cpp la libreria stdio.h. Asi no hace falta crear Programa001.h en
Archivos de encabezado. Esta será la forma habitual de hacer nuestro programas.
11. En el menú Depurar, hacemos clic en Generar solución . También desde el

teclado con F7.

Vemos en Resultados (ventana de abajo) muestra información sobre el progreso
de la compilación y si hay algún fallo de escritura nos lo indicará (errores y
advertencias). Si está correcto en Generar nos dirá 1 correcto 0 incorrectos.
12. En el menu Depurar, hacemos clic en Iniciar depuración o F5.
Nos da un “pantallazo” y no vemos nada. Para que esto no ocurra debemos

incluir una nueva línea con la función getchar( ) que está incluida en la librería
stdio.h (Librería de C).

Analizamos el programa, teniendo en cuenta, qué el programa está escrito en
minúsculas.
1ª línea Mediante /* …… */ podemos insertar comentarios en el programa (Los

comentarios acaban cuando escribo */).
2ª línea Hace lo mismo que la primera línea (pero solo puedo escribir una línea).
3ª línea Contiene una referencia a un archivo especial (stdio.h) que contiene

informaciónque se debe incluir en el programa cuando se compila. Está
información la maneja automáticamente el compilador.
4ª línea Los programas en C están compuestos de unidades de programa llamadas

funciones, las cuales son los módulos básicos del programa. En este caso,
el programa está compuesto por una sola función llamada main.
Todos los programas en C deben tener la función main (significa en

español principal) pues la primer función que se ejecuta cuando hacemos
funcionar el programa.
Los paréntesis que siguen a main la identifican como nombre de función.
Un método de comunicación de datos entre las funciones es el uso de los

argumentos. Los argumentos son los datos que se les pasa a las
funciones. Estos se encierran entre paréntesis. En Visual C++ es
necesario que devuelva argumentos (nos vale void delante de main).
5ª línea Apertura de llave. Comienza el programa.
6ª línea Realiza una llamada a una función denominada printf, con el argumento
“Mi primer programa en C”; printf es una función de biblioteca que
realiza una escritura en la salida estándar (normalmente la salida estándar
es el monitor). La función printf escribe una cadena de caracteres
(string). Cada instrucción en C acaba con punto y coma ( ; ).
7ª Cierre de llave. Finaliza el programa.

Donde hemos guardado el programa Programa001, Visual C 2010 ha generado varios
archivos y carpetas.
Dentro de la carpeta Programa001 nos interesa el programa llamado Programa001.cpp.

En este archivo se encuentra escrito el código de nuestro programa. En Programa001.h
todas nuestras librerias.
Dentro de la carpeta Debug se encuentra el programa Programa001.exe (Tipo

Aplicación) desde donde se puede ejecutar el programa.

Vamos a por un nuevo proyecto que llamaremos Programa002. Este programa me
escribe dos frases, una debajo de la otra y haremos que la información de finalización
del programa no aparezca inmediatamente.
Programa 002
1ª línea /* Programa 002 */
2ª línea // Programa que escribe dos frases
3ª línea # include <stdio.h>
4ª línea void main (void)
5ª línea {
6ª línea printf( “Mi primer programa en C.\n” );
7ª línea printf(“Me llamo Javier”);
8ª línea getchar( );
9ª línea }
Hay dos novedades respecto al primer ejemplo:
Primera: Aparece en la línea 6ª el código \n dentro de la cadena del primer printf.

Hay un cierto número de caracteres no imprimibles. Para usarlos
debemos representarlos mediante una combinación de secuencias de
escape, estas son:
Código Significado
\b Retroceso, lo mismo que la tecla borrar
\f Salto de página
\n Nueva línea
\r Retorno de carro, el curso al principio de la línea actual
\t Tabulación horizontal
%% Tanto por ciento %
\” Comillas “
\´ Apóstrofe ‘
\0 Carácter nulo, suele delimitar las cadenas de caracteres
\\ Barra invertida \
\v Tabulación vertical
\a Alerta (bell, campanilla)
\ddd Constante octal (ddd son tres dígitos como máximo)
\xddd Constante hexadecimal (ddd son tres dígitos como
máximo)

Segunda: Aparece una nueva función llamada getchar.
Es una función que espera que se pulse la tecla RETURN por parte del
usuario. Esta función no necesita argumentos pero los paréntesis son
necesarios ya que se trata de una función. Se encuentra en la librería
stdio.h.
En algunas versiones de C, cuando ejecutamos un nuevo programa, vemos “los restos”

del anterior programa ejecutado. Por ello es conveniente limpiar la pantalla. Existe, en
C++, una función que realiza esta limpieza. Se trata de la función clrscr( ) que se
encuentra en la librería conio.h (Si ejecutamos el programa sin incluir la librería conio.h
cuando compilamos nos da un error diciendonos que “que la función clrscr debería tener
un prototipo”, osea que le falta la librería para ir a buscar dicha función). En Visual C
2010 nos dice que “no se encontro el identificador” ya que no reconoce dicha función
(Para poder limpiar la pantalla llamaremos al sistema y ejecutando la orden cls,
escribiendo system(“cls”) e incluyedo la librería windows.h lo conseguiremos).
1.3.- Elementos básicos de un programa de C.
Los programas funcionan con datos que contienen información. Estos datos se pueden
dividir en constantes (valores fijos no alterables) y variables (valores que pueden
cambiar).
Antes de utilizar un datos debemos declararlo dándole un nombre que utilizaremos

después para referenciarlo. En la declaración avisamos al compilador de la existencia de
una variable, del nombre de la misma y si queremos de su valor.
La longitud del nombre, identificador, depende del compilador, pero la mayoría

considera los treinta y dos caracteres primeros. El nombre nunca debe comenzaar por un
número o por ningún carácter que no sea una letra del alfabeto o el carácter subrayado.
Solo son permitidas las letras, los números y el carácter subrayado. Un identificador
siempre debe contener al menos una letra.
Ejemplos:
Numero Válido
2Numero No válido, comienza por dígito
Numero2 Válido
_Numero Válido
_Numero! No válido. Contiene un carácter no válido
#Numero No válido. Comieza # y contiene un carácter no válido

Existen unas palabras reservadas que no pueden usarse como identificadores, poque el
compilador de C las interpreta única y exclusivamente de una manera determinada.
Estas palabras son:
auto double int struct break else

long switch case enum register type
def char extern return union const
float short unsigned continue for signed
void default goto sizeof volatile do
if static while
Vamos a continuar escribiendo, ejecutando y observando el siguiente programa:
/* Programa 003 */
#include <stdio.h>
void main()
int horas,minutos;
horas=3;
minutos=60*horas;
printf("Hay %d minutos en %d horas.\n",minutos,horas);
}
1.4.- Ejercicios
Ejercicio 01.- Escribe un programa que imprima tu nombre y apellidos.
Ejercicio 02.- Escribe un programa que convierta tu edad de años a días (No tenemos en
cuenta las fracciones y los bisiestos)
NOTA.-
En el apéndice A tenemos las bibliotecas de C brevemente comentadas.
Debemos ver las bibliotecas que se usan en ANSI C a través de internet.
www.conclase.net/c/librerias/index.php
Debemos ver las bibliotecas que se usan en C++
www.zator.com/Cpp/E5.htm
En el mismo programa de Visual podemos ver las bibliotecas que se usan.

TEMA 02
TIPOS, OPERADORES Y
EXPRESIONES
2.2.- Datos.
2.3.- Entrada y salida básica.
2.4.- Modificadores.
2.5.- Cadenas de caracteres.
2.6.- Operadores.
2.7.- Precedencia de operadores.
2.8.- Ejercicios.
A modo de introducción tendremos en cuenta las siguientes consideraciones:
Las variables y constantes son objetos básicos que se manipulan en un programa.
Las declaraciones indican las variables que se van a utilizar y establecen su tipo
y, a veces, su valor inicial.
Los operadores especifican lo que se va a hacer con ella.
Las expresiones combinan variables y constantes para producir nuevos valores.
2.2.- Datos
Los programas funcionan con datos que contienen la información que manipularán.
Estos datos se pueden dividir en constantes (valores fijos no alterables) y variables
(valores que pueden cambiar).
Para utilizar un dato este debe ser antes declarado dándole un nombre que utilizaremos
después para referenciarlo. En la declaración avisamos al compilador de la existencia de
una variable y del nombre de la misma.
Ejemplo de declaración: int t ; /* t es una variable de tipo entero */
Ejemplo de declaración e inicialización: int t = 3 ; /* t comienza valiendo 3 */
Las variables se pueden conjugar con operadores mediante expresiones para dar lugar a
nuevos valores.
Ejemplo: b=a+3;

Existen cinco tipos de datos básicos en C:
Tipo Descripción Código Longitud Rango

en printf en bytes
char Carácter %c 1 0 a 255
int Entero %d 2 -32768 a 32767
float punto flotante %f 4 aprox. 6 dígitos de precisión
double punto flotante %lf 8 aprox. 12 dígitos de
precisión.
void sin valor 0 sin valor
A la función printf se le indica el lugar y el tipo en que se escribirá una variable

mediante los siguientes códigos:
char %c int %d float %f double %lf
Hay veces que interesa convertir un char en un int. Se puede hacer de varias formas.
Una de ellas es escribiendo ‘0’ (cero) a continuación del elemento char.
Ejemplo 1: 6 -‘0’
Ejemplo 2: char frase[a]=3;
frase[a] -‘0’ frase[a] es un entero que vale 3
Nota.- La función atoi de stdlib.h convierte una cadena en un número entero.
Programa 004
#include<stdio.h>
void main (void)

{
int i=1;
char c ='c';
float f = 1.0;
double d = 1e-1;
printf(" i=%d\n c=%c\n f=%f\n d=%lf\n",i,c,f,d);

Los datos, según la tabla anterior, pueden ser:
2.2.1- Char.
Los CARACTERES se definen con apóstrofes.
Ejemplo válido: ‘r’ , ‘3' , ‘U’.

Ejemplo inválidos: ‘Rrr’ porque son varios caracteres.
e porque no está delimitado por apóstrofes y es
tomado como variable.
3 porque no está delimitado por apóstrofes y es
tomado como un entero.
2.2.2.- Int.
Los ENTEROS indican un número con signo sin parte decimal. Se pueden
escribir:
En decimal, escribiendo el número sin empezar por 0 (a excepción del 0).

En hexadecimal, empezando el número por 0x. Ejemplo: 0xE, 0x1d, 0x8.
En octal, empezando el número por 0. Ejemplo: 02, 010.
2.2.3.- Float y Double.
Los tipos FLOAT y DOUBLE tienen parte real y parte decimal. El tipo double
tiene el doble de precisión que el tipo float. Por lo demás son iguales. El número
no puede empezar por e o E ya que el compilador lo interpretaría como un
identificador y no como un número. Ejemplos:
1.0e9 1*(10**9) 1 000 000 000

-3E-8 -3*(10**-8) -0.000 000 03
-10.1 -10.1
-3.082e-2 -0.03082
2.2.4.- Void.
El tipo VOID significa sin valor, sin tipo. Tiene varios usos:
- Uno es al declarar un argumento de función de este tipo. Lo que

estamos haciendo es indicar que este parámetro no se utilizará. Ej:main
(void) indica que no utilizaremos ningún parámetro.
- Otro es al declarar una función como de este tipo. La función no

devolverá valor alguno. Ej: void main (int argc) no devolverá nada al
sistema.
- Otro es declarar un puntero void que podrá apuntar a cualquier tipo de

dato.

2.3.- Entrada y salida básica.
Analizaremos ahora las funciones de entrada y salida básica que nos proporciona el
lenguaje C para poseer, al menos, unos elementos con los que podamos dar nuestros
primeros pasos. Para ello observamos el siguiente programa:
Programa 005
#include<stdio.h>
void main (void)
int num1;
printf("Introduzca un numero:");
scanf("%d",&num1);
printf("El número %d en decimal\n",num1);
printf("es %x en hexadecimal",num1);
La segunda sentencia declara una variable de tipo int llamada num1.
La cuarta sentencia, scanf, es una llamada a una función de entrada. Esta función recoge
información del dispositivo de entrada estándar, en este caso el teclado. La función
recibe dos parámetros: el primero es una cadena de formato (va entre comillas) y el
segundo es un puntero a una variable donde se va almacenar ese dato. El primero indica
el tipo de dato que se va almacenar en el segundo.
%d especifica un número entero

%u especifica un número entero, sin signo
%f especifica un número de coma flotante
%e especifica un número de coma flotante en formato exponencial
%g selecciona %f o %e según el tamaño del número
%c especifica un carácter
%s especifica una cadena (string)
%o especifica un número OCTAL, sin signo
%x especifica un número HEXADECIMAL, sin signo.
En Visual 2010 scanf , al depurar, nos da un warnig, y nos aconseja que usemos scanf-s.

También podemos escribir estas dos sentencias
scanf("%d",&a);
printf("El numero es:%d");
por
printf("El numero es:%d",&a);
2.4.- Modificadores.
A excepción del tipo void, los tipos de datos básicos pueden tener varios modificadores
precediéndoles. Pueden ser modificadores de tipo o modificadores de acceso.
2.4.1.- Modificadores de tipo.
Un modificador de tipo se usa para alterar el significado del tipo base para que
se ajuste más precisamente a las necesidades de cada momento
Modificador Descripción Tipos a los que se les

puede aplicar
signed con signo int, char
unsigned sin signo int, char
long Largo int, char, doublé
short Corto int, char
2.4.2.- Modificadores de acceso.
Indican el tipo de acceso al tipo de datos que modifican.
Los de tipo constante (const) se inicializan al declarar la variable y no se pueden

modificar en el programa. El siguiente ejemplo daría error:
const int i = 8 ;
int i = 7 ;
Los del tipo volatil (volatile) indica al compilador que esa variable puede ser
modificada por algo externo al programa (por el sistema operativo, por un driver
de dispositivo).
2.5.- Cadenas de caracteres.
Las cadenas de caracteres (string) es un tipo derivado. Esto significa que se forman a
partir de los tipos básicos. Se forman delimitando los caracteres entre comillas. Las
comillas no forman parte de la secuencia.

Ejemplos:
“ Esto es una cadena “
”a “ // Tiene solo un carácter pero sigue siendo una cadena.
“\n Esto es otra cadena \a con alarma “
Una cadena es sinónimo de un array unidimensional, un vector. Es una secuencia de

datos que se encuentran almacenados en memoria de una forma consecutiva limitados
por un carácter nulo (null). Este carácter se utiliza para señalar el final de la cadena. Por
ello hemos de tener en cuenta que al definir una cadena el tamaño de la variable es 1
carácter mayor que la cadena escrita. Por ejemplo:
“abc” se almacena en memoria
a b C \0
Vemos que tiene 4 caracteres. ¡Atención! El carácter nulo ‘\0' no es la cifra 0 (cuyo
código ASCII es 48), sino un carácter no imprimible, cuyo código ASCII es 0.
Para dividir una cadena de caracteres en varias líneas usamos el código %s que indica a
la función printf que escriba una cadena en su lugar. Ejemplo:
La sentencia printf (“Hola pepito %s”, “grillo”);
saldría Hola pepito grillo
Nota: caracter 'a ' y frase "hola".
2.6.- Operadores.
Un operador es un signo que realiza una determinada acción sobre unos operandos. El
operando es el valor manipulado por el operador, puede ser un dato o el valor devuelto
por la función. Se dice que el operador es binario si opera con dos operandos y es
monario cuando opera con uno solo.
Hay varios tipos de operadores: aritméticos, relacionales y lógicos, a nivel de bits y

especiales.

2.6.1.- Operador aritmético.
Operador Signo Tipo

Suma + Binario o unario
Resta - Binario o unario
Multiplicación * Binario
División / Binario
Resto % Binario
Incremento ++ Unario
Decremento -- Unario
Los operadores de suma y resta unarios devuelven los valores positivo y

negativo del operando. El operador resto hace la misma acción que la división
pero devuelve el resto de la operación en vez del cociente (Ejemplo a = 11 % 3;
a = 2; ). Los operadores incremento ( ++ ) y decremento ( - - ) modifican en 1 el
valor del operando (Ejemplo a ++; a = a + 1; y ejemplo a - - ; a = a -1; ).
¡ Atención ! Hay dos modalidades para cada operador incremento y decremento.

Son el prefijo (antes) y el sufijo (después). Los operadores prefijo incrementan o
decrementan el valor del dato antes de devolver el valor del dato que modifican.
Los operadores sufijo modifican el dato después de devolver el dato.
Ejemplo
int x,y; int x,y;

x = 2; x = 2;
y = ++ x; y = x ++;
printf(“x= %d y= %d”,x,y); printf(“x= %d y= %d”,x,y);
Salida x = 3 y = 3 Salida x = 3 y = 2
Modifica y devuelve Devuelve y modifica

2.6.2.- Operadores relacionales y lógicos.
Se usan para generar resultados del tipo Verdadero / Falso.
Símbol Nombre Ejemplos

o
> Mayor 3>1 Verdadero 1
4>4 Falso 0
5 > 12 Falso 0
>= Mayor o 16 >= 10 Verdadero 1
igual 2 >= 2 Verdadero 1
11 >= 12 Falso 0
< Menor 5<4 Falso 0
3<3 Falso 0
2<3 Verdadero 1
<= Menor o 2 <= 3 Verdadero 1
igual 4 <= 4 Verdadero 1
5 < 11 Falso 0
== Igual 60 = = 60 Verdadero 1
12 = = 32 Falso 0
!= No igual 6!=7 Verdadero 1
12 ! = 12 Falso 0
Los operadores relacionales realizan una comparación entre los dos operandos
situados a sus lados. Esta comparación da lugar a un valor verdadero o falso. En
C cualquier valor distinto de 0 es verdadero, cualquier valor igual a 0 es falso (
Cuando no se puede definir un valor determinado, para indicar verdadero se
utiliza el 1 ).
Los operadores lógicos conectan dos expresiones entre si. Son:

Símbolo Nombre Ejemplos
&& And Verdadero si los dos operandos verdadero

5&&6 Verdadero 1
19 & & 0 Falso 0
|| Or Verdad, si es uno de ellos.
3||0 Verdadero 1
2||6 Verdadero 1
0||0 Falso 0
! Not Si el operando verdadero da falso y al
revés
!5 Falso 0
! -15 Falso 0
!0 Verdadero 1
Tabla de la verdad para los operadores lógicos
p q p&&q p||q !p !q
0 0 0 0 1 1
0 1 0 1 1 0
1 0 0 1 0 1
1 1 1 1 0 0
2.6.3.- Operadores de bits.
Estos operadores modifican o comparan a nivel de bits.
* operador OR |
Si x=1 0 0 0 0 0 0 0 1
z=3 0 0 0 0 0 0 1 1
entonces x | z 0 0 0 0 0 0 1 1
* operador XOR ^
Si y = 15 0 0 0 0 1 1 1 1
z=3 0 0 0 0 0 0 1 1
entonces y ^ z = 12 0 0 0 0 1 1 0 0

* operador AND &
Si y = 15 0 0 0 0 1 1 1 1
z=3 0 0 0 0 0 0 1 1
entonces y & z = 3 0 0 0 0 0 0 1 1
* operador desplazamiento hacia la derecha >>
Si x=1
0 0 0 0 0 0 0 1
x >> 1
0 0 0 0 0 0 0 0
x=0
Si y = 15
0 0 0 0 1 1 1 1
y >> 2 (dos veces)
0 0 0 0 0 0 1 1
y=3
Si z=3 z >> 1 z=1

en general indica dividir por la n-esima potencia de dos.
* operador desplazamiento hacia la izquierda <<
Si x=1
0 0 0 0 0 0 0 1
x << 1
0 0 0 0 0 0 1 0
x=2
Si y = 15
0 0 0 0 1 1 1 1
y << 2
0 0 1 1 0 0 0 0
y = 60
Si z=3 z << 1 z=6
en general indica multiplicar por la n-esima potencia de dos.

* operador complemento “
Invierte los ceros por unos y los unos por ceros
Si y = 15 0 0 0 0 1 1 1 1
Entonces “ y = 240 1 1 1 1 0 0 0 0
2.6.4.- Operadores especiales
2.6.4.1.- Operador condicional ?
Su expresión es: variable = expresión1 ? expresión 2 : expresión 3 ;

Si la expresión 1 es verdad la variable toma el valor de la expresión 2
Si la expresión 1 es falsa la variable toma el valor de la expresión 3
Ejemplo mayor = ( a > b ) ? 1 : 2 ;

Si a > b mayor = 1
Si a <= b mayor = 2
2.6.4.2.- Operadores de dirección & y contenido *.
Operan con punteros. Un puntero es una variable que contiene dirección

de memoria. Son monarios.
2.6.4.3.- Operador sizeof
Es monario y devuelve el tamaño en bytes del operando
2.6.4.4.- Operador coma,
Tiene dos usos, uno para representar una lista de elementos y otro para
encadenar varias expresiones (en este último uso se evalúa de izquierda a
derecha y el valor final es el de la expresión más a la derecha).
2.6.4.5.- Operadores punto . y flecha →
Se utilizan en los tipos compuestos de datos.
2.6.4.6.- Operadores paréntesis y corchetes
Los paréntesis aumentan la precedencia de la expresión que encierran,

osea fuerzan la evaluación de la expresión antes que del resto de la
sentencia. Los corchetes se usan para indexar arrays.

2.6.4.7.- Operadores de asignación.
Se utiliza para asignar un valor a las variables. Una sentencia de

asignación es una expresión. El valor de esta expresión es el valor que se
le asigna a la variable. Se evalúa de derecha a izquierda.
= x=5
*= x * = 10 x = x * 10
/= x / = 10 x = x / 10
%= x%=2 x=x%2
+= x+=5 x=x+5
-= x-=5 x=x-5
<< = x << = 4 x = x << 4
>> = x >> = 12 x = x >> 12
&= x&=1 x=x&1
|= x|=4 x=x|4
^= x^=6 x=x^6
2.7.- Precedencia de operadores.
Al evaluar una expresión se sigue un orden de izquierda a derecha evaluándose

antes los operadores de mayor preferencia. Esta preferencia es:
Categoría Operador
Más alta () [] → .
Unarios ! “ + - ++ - - & * sizeof
Multiplicadore * / %
s
Aditivos + - (binarios)
Desplazamient << >>
o
Relacionales < <= > >=
Igualdad == !=
AND de bits &
XOR de bits ^
OR de bits |
AND lógico &&
OR lógico ||
Condicional ?
Asignamiénto = *= /= += -= &= ^= |= << = >>
=
Coma ,

2.8.- Ejercicios.
Ejercicio 03.- Dada la función diseñar un programa que para el valor de abcisa 4.4 de el
correspondiente a la ordenada.
Ejercicio 04.- La Tierra no es una esfera, está ligeramente aplanada y por lo tanto es más
bien un esferoide plano. La fórmula del volumen es . Calcúlese el volumen de la Tierra
para los siguientes datos , a = 1245.5 km y b = 12711.1 km.
Ejercicio 05.- La relación entre temperaturas Celsius y Farenhai está dada por Diseñar
un programa que convierta los grados Farenhai en Celsius.

TEMA 03
SENTENCIAS DE CONTROL DE
PROGRAMA
3.2.- Sentencia condicional if.
3.3.- Sentencia condicional switch.
3.4.- Sentencia iterativa while.
3.5.- Sentencia iterativa do-while.
3.6.- Sentencia iterativa for.
3.7.- Sentencia de salto break.
3.8.- Sentencia de salto continue.
3.9.- Sentencia de salto goto.
3.10.- Sentencia de salida return.
3.11. Algunas utilidades de Visual C 2010
3.12.- Ejercicios.
Las sentencias de control son aquellas que controlan y dirigen la ejecución de un

programa. Hasta ahora hemos visto la ejecución de bloques de sentencias desde el
principio hasta el final del programa, con un orden. Pero puede que queramos que un
bloque de sentencias se ejecute sólo bajo determinadas circunstancias, o que un bloque
de sentencias se ejecute varias veces.
Las sentencias pueden ser simples, separadas por el punto y la coma, y compuestas,
varias sentencias simples agrupadas entre llaves.
Tendremos en cuenta que para escribir un código fuente mucha más legible iremos
colocando las sentencias en niveles de forma que podamos diferenciar con facilidad
cada grupo de sentencias.
Las sentencias pueden ser condicionales ( if, switch ), iterativas ( while, for, do ),
incondicionales (break, continue, goto,return ).
La mayoría de las sentencias de control de cualquier lenguaje están basadas en

condiciones. Una condición es una expresión cuya resolución da como resultado cierto (
true ) o falso ( false ). Muchos lenguajes de programación incorporan los valores true y
false; en C cualquier valor distinto de cero es true, y el valor cero es false.

3.2.- Sentencia condicional if.
Permite la ejecución de una sentencia o un bloque de sentencias, en el caso de que se

cumpla la expresión lógica que lleva asociada. La sintaxis de la sentencia if es:
if ( expresion1 ) sentencia1
Si la expresion1 es verdadera se ejecutará la sentencia1. Si expresion1 es falsa no se

ejecuta sentencia1 y se prosigue el programa.
La sentencia if suele venir acompañada de else. La sintaxis de la sentencia if-else es:
if (expresion1) sentencia1
else if (expresion2) sentencia2
................................
else sentenciaN.
Si la expresion1 es verdadera se ejecutará la sentencia1. Si expresion1 es falsa se evalúa

la expresion2 y si es verdadera se ejecuta la sentencia2. Si la expresion2 es falsa se pasa
al siguiente bloque, y así con todos los bloques hasta llegar a la sentenciaN.
Ejemplos:
* Para el caso if ( 3 < 4 ) x = 2 El valor de x es 2
* Para el caso if ( 3 > 4 ) x = 2

else x = 5 El valor de x es 5
* Para el caso if ( 3 > 4 ) x = 2

else if ( 2 < 5 ) x = 8 El valor de x es 8
* Para el caso if ( 3 > 4 ) x = 2

else if ( 2 > 5 ) x = 8
else x = 14 El valor de x es 14
Programa 006 Ejemplo del uso de if
#include<stdio.h>
void main (void)

{
int n;
printf("Introduzca un numero de una cifra, por favor: \n");
scanf("%d",&n);
printf("El numero es %d\n",n);
if ((n>2)&&(n<6)) /* Con && damos la condición y */
printf("El numero es 3, 4 o 5");
else
printf("El numero es 0, 1, 2, 6, 7, 8 o 9");
}

Atención con las sentencias if-else anidadas. Puede que el compilador no de errores y el
programa no funcionar correctamente. El compilador asocia cada else con el último if
sin else encontrado en el mismo bloque.
El operador condicional ? es una posible alternativa para if en algunas situaciones
Su expresión es: variable = expresión1 ? expresión 2 : expresión 3 ;
Si la expresión 1 es verdad la variable toma el valor de la expresión 2

Si la expresión 1 es falsa la variable toma el valor de la expresión 3
Ejemplo mayor = ( a > b ) ? 1 : 2 ;

Si a > b mayor = 1
Si a <= b mayor = 2
3.3.- Sentencia condicional switch.
Transfiere el control a un bloque de sentencias o a otro, dependiendo del valor de una

expresión. Switch evalúa una expresión. A continuación evalúa cada una de las
expresiones constantes hasta que encuentra una que coincida con la primera expresión.
Cuando la encuentra ejecuta las sentencias correspondientes a ese case. Si no hay
ninguna expresión case que coincida con la primera expresión, se ejecuta las sentencias
correspondientes a default que es opcional.
Las expresiones a evaluar solo pueden ser de tipo entero o de tipo carácter. La sintaxis
es:
switch (expresion)
case expresion1:
sentencia1
break;
case expresion2:
sentencia2
break;
....................................
default:
sentenciadefault

Programa 007 Ejemplo del uso de switch
#include<stdio.h>
void main (void)

{
int num1, num2;
char op;
printf("Introduce el primer numero: ");
scanf("%d",&num1);
printf("Introduce el segundo numero: ");
scanf("%d",&num2);
printf("̈ Que operacion queremos hacer con ellos ? ");
scanf("%c",&op);
* Con este recogemos el INTRO del numero anterior */
scanf("%c",&op);
switch(op)
{
case '+':
printf("El resultado de sumar %d y %d es
%d",num1,num2,num1+num2);
break;
case '-':
printf("El resultado de restar %d y %d es
%d",num1,num2,num1-num2);
break;
default:
printf("Operacion no valida");
}
}
Nota.- En el ejemplo anterior si op es entero (int) se debe poner case 1, case 2 (sin '').
3.4.- Sentencia iterativa while.
Permite la ejecución de un bloque de sentencias sí se evalúa verdadera una expresión

lógica. La expresión lógica aparece al principio del bloque de sentencias. La sintaxis es:
while ( expresión lógica )

{
................
}
El bloque delimitado por las llaves puede reducirse a una sentencia, y en este caso se
pueden suprimir las llaves.
Cuando el programa llega a una sentencia while, sigue los siguientes pasos:
 Evalúa la expresión lógica.

 Si es falsa, continua la ejecución tras el bloque de sentencias.
 Si es verdadera entra en el bloque de sentencias asociado al while. Ejecuta dicho
bloque de sentencias, y cuando finaliza vuelve al primer paso, evaluando de
nuevo la expresión y actuando en consecuencia.
Si la primera evaluación resulta falsa, el bloque de sentencias no se ejecuta nunca.

Programa 008 Ejemplo del uso de while
#include<stdio.h>
void main (void)
{
int num1,num2,num3,suma, resta,multi,resto;
printf("Introduzca la primera cifra entre 0 y 9: ");
scanf("%d",&num1);
printf("Introduzca la segunda cifra entre 0 y 9: ");
scanf("%d",&num2);
printf("Introduzca la tercera cifra entre 0 y 9: ");
scanf("%d",&num3);
while(num1>5)
{
suma=num1+num2;
multi=num1*num2;
printf("La suma de %d y %d es %d ",num1,num2,suma);
printf("\nLa multiplicacion de %d y %d es
%d",num1,num2,multi);
num1=2; /* para romper el while */
}
resta=num3-num2;
resto=num3%num2;
printf("\n\nLa resta de %d y %d es %d ",num3,num2,resta);
printf("\nEl resto de dividir %d y %d es %d ",num3,num2,resto);
}
3.5.- Sentencia iterativa do-while.

Ejecuta un bloque de sentencias mientras se cumpla una expresión lógica. La expresión
lógica aparece al final del bloque de sentencias. Igual que en la sentencia while, el
bloque delimitado por las llaves puede reducirse a una sentencia, y en este caso se
pueden suprimir las llaves. El programa ejecuta el bloque de sentencias entre llaves y
cuando llega al final del bloque, evalúa la expresión lógica.
 Si es falsa, continua la ejecución del programa tras el bloque do .... while.

1. Si es verdadera, retorna a la sentencia do. Vuelve a ejecutar el bloque y a
evaluar la expresión lógica al final de este, actuando en consecuencia.
Vemos, que al contrario de la sentencia while, el bloque de sentencias asociado a una

sentencia do-while se ejecuta al menos una vez.
Programa 009 Ejemplo de la sentencia do-while.
#include<stdio.h>
void main (void)
{
int i;
i=1;
do
{
printf("\n%d",i++);
}while(i<=10);
}

3.6.- Sentencia iterativa for.
Permite la ejecución de un bloque de sentencias sí se evalúa verdadera la expresión

lógica, al igual que la sentencia while. La característica que diferencia a la sentencia for
de la sentencia while, es que realiza tres operaciones diferentes dentro de una sola
sentencia:
 Sentencias ejecutadas antes de entrar en el bloque delimitado por la sentencia

for.
 Expresión lógica que indica si se repetirá o no la ejecución del bloque de
sentencias.
 Sentencias ejecutadas al finalizar cada ejecución del bloque de sentencias.
La sintaxis de la sentencia for es:
for ( sentencia1; expresión lógica; sentencia2)

{
.....................
}
El programa al llegar a la sentencia for, ejecuta la sentencia1. Después evalúa la

expresión lógica, y si es verdadera, ejecuta el bloque de sentencias entre llaves. en este
caso, al llegar la final del bloque, ejecuta la sentencia2, y vuelve al principio del for.
Evalúa la expresión lógica y actúa en consecuencia.
¡Atención! for solo funciona con números enteros.
Programa 010 Ejemplo de la sentencia for.
#include<stdio.h>
void main (void)

{
int x;
for(x=1;x<=10;x++)
{
printf("\n%d",x);
}
}
Nota.-
for( ; ; ) el for se ejecuta infinitas veces.
for(x=1;x<=10;x++); solo hace con el último.
for( ;x<=10;x++) empieza en el último valor de x.

3.7.- Sentencia de salto break.
El uso de esta sentencia no es recomendable.
Esta sentencia provoca la salida inmediata de las sentencias swich, while, for o do-
while. Por lo tanto su uso solo es correcto dentro de un bloque de una de estas
sentencias.
Programa 011 Ejemplo de la sentencia break
#include<stdio.h>
void main (void)
{
int num1,num2,suma, resta,multi,resto;
printf("Introduzca la primera cifra entre 0 y 9: ");
scanf("%d",&num1);
printf("Introduzca la segunda cifra entre 0 y 9: ");
scanf("%d",&num2);
while(num1>5)
{
suma=num1+num2;
multi=num1*num2;
printf("La suma de %d y %d es %d ",num1,num2,suma);
printf("\nLa multiplicacion de %d y %d es
%d",num1,num2,multi);
break;
}
resta=num1-num2;
resto=num1%num2;
printf("\n\nLa resta de %d y %d es %d ",num1,num2,resta);
printf("\nEl resto de dividir %d y %d es %d
",num1,num2,resto);
}
3.8.- Sentencia de salto continue.
Funciona algo similar a break. Solo puede ser empleada en el interior de una sentencia
de repetición. Es un salto incondicional al final del bucle. No es un salto al exterior del
bucle, sino al final de su bloque de sentencias. En vez de forzar la terminación, continue
fuerza una nueva iteración del bucle y salta cualquier código que exista entre medias.

Programa 012 Ejemplo de la sentencia continue.
#include<stdio.h>
void main (void)

{
int i;
printf("Los numeros pares menores 25 son: ");
for(i=0;i<25;i++)
{
if((i%2)!=0)
continue;
else
printf("\n%d",i);
}
}
3.9.- Sentencia de salto goto.
La sentencia goto provoca un salto incondicional a una etiqueta que se encuentra en la

misma función. Las etiquetas son identificadores seguidos de dos puntos (:) y poseen su
propio espacio nominal ( dentro del mismo bloque no pueden aparecer dos etiquetas
iguales ).
El compilador no se encarga de realizar comprobaciones respecto al lugar hacia donde

se salta. Por ejemplo, si el salto se produce al interior de un bucle, pueden originarse
problemas debido a que salta la inicialización de dicho bucle.
3.10.- Sentencia de salida return.
Es un salto incondicional al final del cuerpo de una función, a la llave de fin de bloque.
Es de uso obligado en las funciones que devuelven un valor. Hablaremos de esta
sentencia cuando veamos el tema de las funciones.
3.11. Algunas utilidades de Visual C 2010
3.11.1- Paso a paso
En Depurar podemos seleccionar Paso a paso por instrucciones o Paso a paso

por procedimientos.

Se ejecuta el programa paso a paso presionando continuadamente la tecla
Entrar (Intro). Ambos comandos indican al depurador que ejecute la siguiente
línea de código.
Si la línea contiene una llamada a una función, Paso a paso por instrucciones o
F11 solo ejecuta la llamada en sí, y a continuación, se detiene en la primera línea
de código incluida la función. Paso a paso por procedimientos o F10 ejecuta toda
la función y después se detiene en la primer línea que está fuera de la misma.
3.11.2.- Punto de interrupción.
Situado el cursor en el lugar que nos interesa, pulsamos el botón derecho del
ratón apareciendo el siguiente menú.

Insertamos un punto de interrupción y depurando el programa F5 se ejecuta
hasta la línea seleccionada. Con insertar punto de seguimiento hacemos lo
mismo pero pudiendo insertar un mensaje.
3.11.3.- Ejecutar hasta el cursor.
Ejecuta el programa hasta donde tengo situado el cursor.

3.12.- Ejercicios.
Ejercicio 06.- Hacer un programa que genere la lista de los 100 primeros números pares
con la sentencia iterativa for.
con la sentencia iterativa while
con la sentencia iterativa do.
Ejercicio 09.- Haz un programa que escriba todos los números menores que 50 y que
además no sean divisibles por 3.
*
Ejercicio 10.- Realizar un programa que me pida un **
número por pantalla y saque su tabla de multiplicar. ***
****
Ejercicio 11.- Realizar un programa que calcule el factorial *****
de un número menor que 100. ******
*******
Ejercicio 12.- Diseña un programa que escriba el siguiente ********
gráfico, utilizando la sentencia iterativa for. *********
**********
Ejercicio 13.- Realizar un programa que me pida que *********
introduzca tres números y los saca clasificados en orden de ********
mayor a menor. *******
******
Ejercicio 14.- Hacer un programa que pida al usuario que *****
introduzca un número y a continuación presenta en pantalla ****
el número de cifras que componen dicho número. ***
**
Ejercicio 15.- Encontrar todos los números primos *
comprendidos entre un número entero, dado por el teclado,
y el 1. Sacarlo por pantalla (si el número introducido es primo: indicarlo).
Ejercicio 16.- Calcular la media de una serie de números que finaliza al introducir 999
(el número 999 no debe ser tenido en cuenta para la media).

TEMA 4
ALGUNAS FUNCIONES DEL
LENGUAJE C
4.2.- Función de salida exit.
4.3.- Función de salida _exit.
4.4.- Función de salida abort.
4.5.- Función de salida assert.
4.6.- Funciones de entrada/salida.
4.7.- Función de entrada salida estándar printf, scanf.
4.8.- Función de entrada salida putchar, getchar.
4.9.- Función de entrada salida puts, gets.
4.10.- Funciones de consola.
4.11.- Funciones rand, randomize y srand.
4.12.- Función clrscr.
4.13.- Ejercicios.
El objetivo de este tema es describir algunas funciones del lenguaje C. Una función es
una porción de código aislado que efectúa una acción determinada según una serie de
parámetros separados por comas (puede no tenerlos) y que devuelve un valor
dependiente de estas acciones (puede también no devolver valor alguno). Estos
parámetros son valores que damos a la función para que trabaje con ellos.
Cuando ejecutamos una función decimos que la llamamos. La sintaxis de una llamada
de función en C es:
nombre_de_funcion ( lista_de_parametros )
Para facilitar el almacenaje y el rápido uso de funciones y variables se utilizan librerías

(.LIB) donde se almacenan en un formato ya compilado. Para no tener que incluir todas
las funciones de una librería en nuestro programa, las funciones se separan por módulos.
Para utilizar una función tan solo tenemos que declararla antes. Para este propósito, con
las librerías suelen venir los archivos de cabecera (.h, header ) en donde se declara un
determinado conjunto de funciones relacionadas.

4.2.- Función de salida exit.
La función exit se encuentra declarada en la biblioteca estándar (stdlib.h) y da lugar a la

terminación automática de un programa. Antes de hacerlo cierra todos los archivos
abiertos y los buffers de archivo (En los programas que manejan ficheros, estos han de
abrirse, manipularse y cerrarse. Los datos de estos ficheros no se manipulan
directamente sino a través de unos almacenamientos temporales llamados buffers) y a
continuación llama a la función _exit para cerrar el programa.
La función exit no devuelve nada pero necesita un argumento que es recogido por el
programa llamador (normalmente el sistema operativo). Por convención el valor 0
indica terminación normal; valores distintos de 0 indican situaciones anormales.
En la librería stdlib.h existen dos constantes definidas para pasarlas como argumento a
la función exit:
exit_success terminación normal tiene valor 0

exit_failure terminación anormal tiene valor 1
de este modo si nos olvidamos si el argumento 0 de exit significa terminación normal o

anormal, utilizamos estas constantes que pueden ser más difícil de olvidarse. Su sintaxis
es:
exit ( exit_success ); exit ( exit_failure )
4.3.- Función de salida _exit.
La función exit se encuentra declarada en la biblioteca estándar (stdlib.h). La función

_exit provoca la terminación inmediata del programa sin realizar el vaciado de los
buffers ni cerrar los ficheros. El argumento es el mismo que el de exit.
4.4.- Función de salida abort.
La función abort se encuentra declarada en la biblioteca estándar (stdlib.h). Es similar a

la función exit diferenciandose en:
 No acepta ningún argumento. Su sintaxis es abort ( );

 No vacía los buffers ni cierra ningún fichero.
4.5.- Función de salida assert.
La función assert se encuentra declarada en la biblioteca estándar (assert.h). No

devuelve nada y acepta una expresión como argumento. Esta función testea la expresión
dada; si la expresión es cierta no hace nada y si la expresión es falsa escribe un mensaje
en la salida de error estándar y termina la ejecución del programa. El mensaje
presentado depende del compilador.

4.6.- Funciones de entrada/salida.
Se llaman funciones de entrada/salida a aquéllas que transportan datos entre el programa

y la entrada salida estándar. La entrada estándar, normalmente, es el teclado y la salida,
normalmente, es el monitor.
En las operaciones de entrada/salida, los datos utilizados suelen pasar por buffers. Un
buffer es una cantidad de memoria utilizada para meter y sacar datos.
El final de entrada/salida se suele marcar con un carácter especial llamado

FinDeFichero EOF (tiene un valor -1). Algunas funciones de C, como scanf, devuelven
el valor EOF cuando leen el carácter de fin de fichero.
El C trata varios dispositivos como si fuesen archivos. Haya unos cuantos predefinidos
que se abren al iniciar el programa dandole unos descriptores:
Descriptor Dispositivo por defecto

stdin entrada, el teclado
stdout salida, la pantalla
stderr error, la pantalla
stdaux auxiliar, el puerto serie
stdprn impresora, LPT1
ENTRADA SALIDA TIPO

scanf printf datos
getchar putchar caracteres
gets puts frases
4.7.- Función de entrada salida estándar printf, scanf.
Están declaradas en la biblioteca estándar stdio.h. La función printf escribe un mensaje

formateado en stdout (salida estándar: pantalla ). La función scanf lee datos formateados
de stdin ( entrada estándar: teclado ). La forma general:

printf ( “cadena de caracteres “, lista de argumentos);
scanf ( “cadena de caracteres “, &lista de argumentos );
La “cadena de caracteres” está formada por caracteres imprimibles y códigos de

formato. Debe haber tantos códigos de formato como argumentos.
%c Simple carácter %s Cadena de caracteres

%d Entero decimal con signo %u Entero decimal sin signo
%i Entero decimal con signo %x Entero hexadecimal sin signo
%e Punto flotante con notación %% Signo %
científica
%f Punto flotante con notación no %p Puntero
científica
%g Usa el más corto de longitud de %n Almacena el número de caracteres
% e o %f escrito en la dirección apuntada
por el argumento de entrada
%o Entero octal sin signo
Las órdenes de formato pueden tener modificadores. Estos modificadores van entre % y
la letra identificadora del código.
Si el modificador es un número específica la anchura mínima en la que se escribe ese

argumento (si empieza por 0 los espacios sobrantes se rellenan con 0).
Si el modificador es un número con parte real y parte decimal indica el número de

dígitos de la parte real y de la parte decimal a imprimir (si es una cadena de caracteres
lo que se va a imprimir indica el número mínimo y máximo de caracteres).
Por defecto la salida se justifica a la derecha (si es negativo el modificador se justifica a

la izquierda).
Se puede introducir con scanf una frase escribiendo el siguiente código:
# include <stdio.h>
void main (void)

{
char linea [80];
printf("Introduce una frase");
scanf("%[^\n]",linea);
printf("%s",linea);
getchar();
getchar();
}

Programa 013 Ejemplos de modificadores
#include<stdio.h>
void main (void)

{
printf(":%f:",123.456);
printf("\n:%e:",123.456);
printf("\n:%g:",123.456);
printf("\n:%-2.5f:",123.456);
printf("\n:%-5.2f:",123.456);
printf("\n:%5.5f:",123.456);
printf("\n:%10s:","hola");
printf("\n:%-10s:","hola");
printf("\n:%2.3s:","hola");
printf("\n:%x:",15);
printf("\n:%o:",15);
printf("\n:%05d:",15);
printf("\n:%x:",2);
}
4.8.- Función de entrada salida putchar, getchar.
Están declaradas en la biblioteca estándar stdio.h. Ambas funciones devuelven, en caso

de éxito, el carácter procesado (escrito o leído) y en caso de error o fin de fichero, EOF.
La función putchar escribe un carácter en la salida estándar (monitor). Necesita un

argumento que es el carácter a escribir.
La función getchar lee un carácter en la entrada estándar (teclado). No recibe ningún

argumento.
Las instrucciones siguientes son equivalentes:
char ch; char ch;

ch = getchar ( ); scanf (“%c”,&ch);
putchar (ch); printf(“%c”,ch);
4.9.- Función de entrada salida puts, gets.
Están declaradas en la biblioteca estándar stdio.h.
La función puts escribe una cadena de caracteres y un carácter de nueva línea al final de
la cadena de la salida estándar (monitor). Acepta como argumento una cadena (sin
formato). Si tiene éxito devuelve el último carácter escrito (siempre es ‘\n’). En otro
caso, devuelve EOF. Esta función es lo mismo que:
puts(“Esto es un ejemplo.”); printf(“Esto es un ejemplo.\n”);

La función gets lee una cadena de caracteres de la entrada estándar hasta que encuentra
el carácter ‘\n’. Acepta como argumento un puntero al principio de la cadena. Devuelve
dicho puntero si tiene éxito o la constante NULL si falla (NULL es una constante
definida en stdio.h que tiene el valor 0. Esta constante se suele utilizar para indicar que
un puntero no apunta a ningún sitio).
¡Atención! Con las funciones de lectura y escritura hay que tener la precaución de
reservar memoria para que entren todos los caracteres que introducimos (si reservamos
para 100 no podemos introducir más de 99 caracteres).
4.10.- Funciones de consola.
Están declaradas en la biblioteca estándar conio.h. Las siguientes funciones son

parecidas a las anteriores pero trabajan directamente con la pantalla y el teclado (son
más rápidas pero no son redireccionables). Además, no introducen un retorno de carro
después de cada carácter de nueva línea.
cprintf printf
cscanf scanf
cputs puts
cgets gets
putch putchar
getch getchar
getche
Las diferencias más notables son:
Estándar Consola
Se escribe en la salida estándar Se escribe en pantalla
Se lee en la salida estándar Se lee en el teclado
Se escribe y lee a través buffers No utiliza buffers
Para pasar a la línea siguiente es Para pasar a la línea siguiente hay
suficiente escribir el carácter de línea que escribir los caracteres de nueva
nueva ‘\n’ línea ‘\n’ y el de retorno de carro ‘\r’
Visual c no reconoce la función cgets.
Diferencia entre cgets y gets.
Vamos a introducir una frase , por ejemplo: “hola, que tal estas”, para ello
reservamos 80 espacios mediante char frase[80].
Con cgets reserva los dos primeros elementos de memoria para: en frase[0]
escribe el número de caracteres reservados, en este caso 80, en frase[1] escribe el
número de caracteres realmente introducidos, en esta caso 19. A continuación
escribe la frase: en el lugar de memoria frase[2] escribe “h”, en el lugar de
memoria frase[3] escribe ”o” ….
Con gets no reserva nada y toma “retorno de carro” en el último elemento.

Para introducir y sacar un número escribimos el siguiente código
# include <stdio.h>
void main (void)

{
int a;
printf("Introduce y saca un numero");
scanf("%d",&a);
printf("%d",a);
getchar();
getchar();
}
Par introducir y sacar un caracter introducimos el siguiente código.
# include <stdio.h>
void main (void)

{
char a;
printf("Introduce y saca un caracter");
scanf("%c",&a);
printf("%c",a);
getchar();
getchar();
}
# include <stdio.h>
void main (void)

{
char a;
printf("Introduce y saca un caracter");
a=getchar();
putchar(a);
getchar();
getchar();
}

Para introducir y sacar una frase introducimos el siguiente código.
# include <stdio.h>
void main (void)

{
char frase[80];
printf("Introduce y saca una frase");
gets(frase);
puts(frase);
getchar();
getchar();
}
# include <stdio.h>
void main (void)

{
char linea [80];
printf("Introduce una frase");
scanf("%[^\n]",linea);
printf("%s",linea);
getchar();
getchar();
}
4.11.- Funciónes rand, randomize y srand.
Están declaradas en la librería stdlib.h. La función rand devuelve un valor

pseudoaleatorio, genera siempre los mismos números, entre 0 y RAND_MAX (suele
ser el valor del mayor número entero (int) con signo.
Programa 014 Ejemplo de la función rand
#include<stdio.h>
#include<stdlib.h>
void main (void)

{
int i;
for(i=0;i<10;i++)
printf("\t%d",rand());
}
Para que realmente los números sean aleatorios, C y en C++, tenemos que usar la
función randomize(), además, si queremos que los números estén en un intervalo por
ejemplo, del 1 al 99, hemos de operar a rand () con % 100.

Programa 015 Ejemplo de la función randomize
#include<stdio.h>
#include<stdlib.h>
void main (void)

{
int i;
randomize();
for(i=0;i<10;i++)
printf("\t%d",rand()%100);
}
Visual C no reconoce la función randomize (). Para hacer algo similar a dicha función
usaremos la función srand(time(NULL)) que se encuentra en la librería time.h y debe
estar en la función principal (main). Esta función genera una “semilla” que tiene como
base el reloj del ordenador.
Programa 015A Ejemplo de la función srand
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void main (void)

{
int i;
srand(time(NULL));
for(i=0;i<10;i++)
printf("\t%d",rand()%100);
}
Programa 16 Generación de un vector y ordenamos por el

método de la Burbuja
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void main (void)

{
int vector [100];
int i;
srand(time(NULL));
for(i=0;i<=99;i++)
vector[i]=rand()%1000;
}

Como no sale por pantalla nada no podemos ver lo que pasa
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void main (void)
{
int vector [100];
int i;
srand(time(NULL));
for(i=0;i<=99;i++)
printf("El vector desordenado es: \n");
for(i=0;i<100;i++)
printf("%d\t",vector[i]);
}
Vemos el vector desordenado (es conveniente ver lo que pasa si en los for ponemos
i<99)
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void main (void)

{
int vector [100];
int i,j,aux;
srand(time(NULL));
for(i=0;i<=99;i++)
printf("El vector desordenado es: \n\n");
for(i=0;i<100;i++)
for(i=98;i>=0;i--)
for(j=0;j<=i;j++)
if(vector[j]>vector[j+1])
{
aux=vector[j];
vector[j]=vector[j+1];
vector[j+1]=aux;
}
printf("\n\nEl vector ordenado es: \n\n");
for(i=0;i<100;i++)
}

4.12.- Función clrscr.
En algunos compiladores al ejecutarse el programa no limpia la pantalla del programa

anterior. A veces nos interesa limpiar la pantalla, borrar lo que hay en ella y así solo ver
lo que nos interesa. En C++ esto se consigue con la función clrscr ( ) que se encuentra
en la librería conio.h.
En Visual C no existe dicha función. Para limpiar la pantalla llamamos al sistema

mediante system y pedimos que lo limpie mediante el argumento “cls”. Para ejecutar la
función system debemos incluir la librería de cabecera stdlib.h. Osea:
1º Incluimos stdlib.h
2º Dentro de main ejecutamos system(“cls”);

4.13.- Ejercicios.
Ejercicio 17.- Resolución de un sistema de ecuaciones con dos incógnitas. Para un

sistema del tipo:
las soluciones son
Ejercicio 18.- Diseñar un programa que lee un valor de x y calcula el valor de y de la

forma
y = x2 + 5 cuando x<0
y=3x+1 cuando 0<=x<2
y = x2 - 4 x + 5 cuando x>2
Ejercicio 19.- Escribir un programa que pregunte un dato N y calcule la suma S de

1 x 1 + 2 x 2 + 3 x 3 + ...........
hasta que dicha suma sea mayor o igual que N. Entonces escribirá N, S y el último
número que ha elevado al cuadrado.
Ejercicio 20.- Programa que obtenga el producto de dos números enteros positivos
mediante sumas sucesivas.
Ejemplo: 3 x 4 = 3 + 3 + 3 + 3 = 12 5 x 2 = 5 + 5 = 10
Ejercicio 21.- Programa que lee una frase en una línea y cuente su número de vocales.
Ejercicio 22.- Cálculo del producto de dos números mediante el alogaritmo ruso.
El alogaritmo ruso consiste en duplicar el primer factor y dividir (cociente entero) por 2
el segundo, obteniendo un producto equivalente, salvo si el segundo factor es impar, en
cuyo caso es necesario acumular previamente el primero en donde se va a obtener el
resultado. el proceso se termina cuando el segundo factor es 0. Ejemplo: 25 x 6 = 150.
Primer factor Segundo factor Acumular Total acumulado

25 6 0 0
50 3 50 50
100 1 100 150
200 0 0 150
Ejercicio 23.- Programa que lee 20 datos, compuesto cada uno de ellos por un nombre
de persona y su sueldo neto mensual, y obtenga e imprima el nombre del sueldo de la
persona que más cobra y de la que menos. Si hay varias se imprime la primera que
aparezca en la secuencia de entrada.

TEMA 5
FUNCIONES Y VARIABLES
5.1.- Funciones.
5.2.- Variables.
5.3.- Especificadores de clase de almacenamiento.
5.4.- El preprocesador. Directivas.
5.5.- Ejercicios.
5.1.- Funciones.
Los programas en C, al menos que sean muy simples, en cuyo caso estarían compuestos
sólo por la función main ( ), están formados por varias funciones. Una función se
declara mediante tres apartados:
Donde
1.- Nos indica el tipo de valor que devuelve la función.
Ejemplo: void = no devuelve ningún tipo
2.- Es el nombre de la función

Ejemplo main = principal
3.- Son las declaraciones. Están separadas por comas. Consta de tipo y
nombre de parámetro.
Ejemplo: si está vacío no hace nada
Antes de usar una función debemos declararlas (decir que las vamos a usar). Se
declaran, normalmente, después de las librerías. Todas las funciones devuelven un valor
(en las de tipo void se ignora). Para especificar este valor se utiliza la sentencia return.

Programa 17 Ejemplo del uso de las funciones
#include<stdio.h>
int maximo(int,int);
long potencia(int,int);
void main (void)

{
int a,b;
printf("Introduce la base: ");
scanf("%d",&a);
printf("\nIntroduce el exponente: ");
scanf("%d",&b);
printf("\n\n %d elevado a %d es %d ",a,b,potencia(a,b));
printf("\n\n el maximo de %d y %d es %d ",a,b,maximo(a,b));
}
long potencia (int pa,int pb)
{
int i;
long pot=1;
for(i=1;i<=pb;i++)
pot *=pa;
return pot;
}
int maximo (int ma,int mb)

{
return ma>mb?ma:mb;
}
Programa 17A Ejemplo del uso de las funciones
#include<stdio.h>
long potencia (int pa,int pb)

{
int i;
long pot=1;
for(i=1;i<=pb;i++)
pot *=pa;
return pot;
}
int maximo (int ma,int mb)

{
return ma>mb?ma:mb;
}
void main (void)

{
int a,b;
printf("Introduce la base: ");
scanf("%d",&a);
printf("\nIntroduce el exponente: ");
scanf("%d",&b);
printf("\n\n %d elevado a %d es %d ",a,b,potencia(a,b));
printf("\n\n el maximo de %d y %d es %d ",a,b,maximo(a,b));
}

5.2.- Variables.
Existen tres lugares básicos donde se pueden declarara las variables: dentro de las
funciones (variables locales), en la definición de parámetros de funciones (parámetros
formales) y fuera de las funciones (variables globales).
 Variables locales: Son aquellas que se declaran dentro del cuerpo de una función
y solo se conocen (están definidas) dentro de esa función. Cualquier intento de
utilizarla fuera de la función donde fue declarada provoca un error de
compilación. Son creadas al entrar en la función y destruidas al salir de ella.
 Parámetros formales: Son las variables que se le pasa a una función. Tienen
ámbito de variables locales.
 Variables globales: Son declaradas fuera de cualquier función, se conocen en

cualquier parte del programa a partir de donde se han declarado.
5.3.- Especificadores de clase de almacenamiento.
Existe cuatro especificadores de clase de almacenamiento soportados en C. Se usan

para indicar al compilador como debe almacenar la variable que le sigue. El
especificador de almacenamiento precede al resto de la declaración de la variable.
 extern con este especificador le decimos al compilador que la variable ya exite

en otro módulo y tan solo la nombramos para poder utilizarla (es externa a este
módulo). Con este modificador no se reserva memoria para la variable.
 static son las variables estáticas. El contenido no se pierde al salirse de la
función. Al volver a entra tiene el mismo valor que el que tenía cuando termino
la función en la llamada anterior. Hay dos tipos:
o Estática local que tiene el mismo ámbito que las variables locales pero
existen durante todo el programa, no son destruidas al salir de una
función y solo son inicializadas la primera vez que llamamos a la
función. conservan el valor entre llamadas a la función.
o Estática global tiene el mismo ámbito que una variable global pero solo
conocida en el fichero donde se declara. Para poder compartir una
variable de este tipo en diferentes módulos debemos declararla en ambos
módulos.
 register con este modificador le pedimos al compilador que almacene la variable

en un registro de la CPU para un más rápido uso de la variable. Se utiliza, sobre
todo, para variables del tipo contador que son usadas con mucha frecuencia.
 auto define una variable local que tiene un tiempo de vida local. Es raramente
utilizada.

5.4.- El preprocesador. Directivas.
El preprocesador le da ciertas ordenes al compilador (procesa el código fuente antes que

el compilador). A las instrucciones del preprocesador se les llama directivas.
 # include < > # include “ ”
Cuando el preprocesador encuentra este comando busca el fichero que

está encerrado entre comillas (lo busca en el directorio que está
trabajando) o ángulos (lo busca en los directorios del sistema) y lo
incluye en el fichero actual.
 # define
Sustituye en el código fuente un determinado identificador por la cadena

especificada.
 # undef
elimina una definición anterior
 # error
fuerza al compilador a parar la compilación y escribir un mensaje de

error.
 # if # else # elif # endif
# if ha de ser una expresión constante. Si es cierta se compila la

secuencia de sentencias que le siguen. Si no es cierta se compilan las
sentencias siguientes a #else o # endif.
# elif establece una escala del tipo if-ese-if.

5.5.- Ejercicios
Ejercicio 24.- Probabilidades binomiales. (Mediante funciones)

Un estudiante coge todos los días un determinado tren para ir a trabajar, pero sabe que
existe cierta probabilidad de que ese tren sea anulado. Teniendo en cuenta esa
probabilidad se calcula mediante la fórmula:
donde: p es la probabilidad de que se cancele un tren (valor entre 0 y 1)

r es el número de cancelaciones en una semana ( valor 0,1,2,3,4,5)
n es el número de jornadas laborales de la semana (3,4,5,6)
c es la probabilidad de que se produzcan cancelaciones
Escribir un programa que acepte la introducción de la probabilidad p, verifique si está

comprendida en el intervalo 0-1, calcule el valor de c para los valores de:
r comprendidos entre 0 y 5, verificando que r está comprendido entre 0 y 5.
n comprendidos entre 3 y 6, verificando que n está comprendido entre 3 y 6.
Ejercicio 25.- Escribir una función recursiva que calcule la raíz cuadrada de un número.
Se deben leer tres números N, A y E donde N es el número del cual quiere hallarse la
raíz cuadrada, A es un valor aproximado de la raíz cuadrada y E es el error de tolerancia
del resultado. Utilizamos la función definida por:
A si | A * A - N | < E
Raíz(N,A,E)
Raíz(N,A,E) con A =((A*A + N)/(2 * A)
Ejercicio 26.- Resolución de la ecuación de segundo grado del tipo a x2 + b x + c = 0
Ejercicio 27.- Dar 20 números y ordenarlos de mayor a menor (Pueden generarse

aleatoriamente).
Ejercicio 28.- Crear una calculadora que me realice las siguientes funciones: suma,
resta, multiplicación, división, factorial, raíz cuadrada y potencia. (Mediante funciones)
Ejercicio 29.- Leer una fecha en formato (dd-mm-aaaa), averiguar si es correcta e

indicar el día siguiente.

TEMA 6
ARRAYS
6.1.- Concepto.
6.2.- Array unidimensional (vector).
6.3.- Array bidimensional.
6.4.- Array multidimensional.
6.5.- Array de cadenas.
6.6.- Ejercicios.
6.1.- Concepto.
En C un array es un conjunto de variables del mismo tipo, correlativas, que se

referencian por un mismo nombre. Para referirnos a un elemento particular de un array
debemos utilizar un indice. El indice mas bajo corresponde al primer elemento y el
indice más alto al último elemento. Los arrays pueden tener varias dimensiones.
6.2.- Array unidimensional (vector).
Consta de una sucesión de variables correlativas. La sintaxis es:
tipo nombre [tamaño]
tipo: tipo de dato (entero, carácter, etc.)

nombre: nombre del array.
tamaño: cantidad de variables
Para referirnos a un elemento concreto de un array
nombre [índice]
Devuelve el elemento en la posición indicada por índice. Hay que tener en cuenta que
empezamos por 0 (El C no comprueba los límites de los índices, así que si nos pasamos
en un array podemos corromper zonas de memoria y producir resultados inesperados).
Recordamos que en el Tema 2 dijimos que hay veces que interesa convertir un char en
un int. Se puede hacer de varias formas. Una de ellas es escribiendo -‘0’ a continuación
del elemento char. Ejemplo
Ejemplo 1: 6 -‘0’
Ejemplo 2: char frase[a]=3;
frase[a] -‘0’ frase[a] es un entero que vale 3
Tenemos tres formas de pasar un array unidimensional como parámetro a una función

Programa 18 Ejemplo
#include <stdio.h>
void forma1(int a[10]);

void forma2(int a[ ]);
void forma3(int *a);
void main (void)

{
int array [10];
register int i;
for(i=0;i<10;i++)
array[i]=i;
forma1(array);
forma2(array);
forma3(array);
}
void forma1(int a[10])

{
register int i;
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
void forma2(int a[ ])
{
printf("\n");
register int i;
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
void forma3(int *a)

{
printf("\n");
register int i;
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
Un uso muy común de los arrays unidimensionales son las cadenas de caracteres que
son vectores de caracteres terminados por un carácter nulo, en este caso el límite del
índice debe tener una unidad más para incluir el carácter nulo (por ejemplo si queremos
declarar un array de caracteres que puede contener una cadena de 9 caracteres, como
máximo, debemos declarar 10).
La longitud en bytes de un array se calcula mediante la fórmula:
totalbytes = sizeof(tipo) * numerodeelementos
Hay varias funciones que trabajan con las cadenas de caracteres. Están incluidas en la
librería string.h y algunas de ellas son:

strcpy (c1,c2) Copia c2 en c1
strcat(c1,c2) Concatena c2 con c1
strlen(c1) Devuelve la longitud de c1
strcmp(c1,c2) Devuelve 0 si c1=c2

menor que 0 si c1<c2
si c1 precede alfabéticamente a c2
mayor que 0 si c1>c2
si c2 precede alfabéticamente a c1
strcmpi(c1,c2) Como strcmp. No distingue mayúsculas y minúsculas
strchr(c1,car) Devuelve un puntero a la primera ocurrencia de car en c1
strstr(c1,c2) Devuelve un puntero a la primera ocurrencia de c2 en c1
Nota.- La función atoi (stdlib.h) convierte una cadena de caracteres en un número

entero.
Para ver lo que hacen tenemos el siguiente programa
Programa 19 Ejemplo
#include <stdio.h>
#include <string.h>
void main(void)
{
char c1[82],c2[82];
printf("\nEscribe la cadena c1: ");
gets(c1);
printf("\nEscribe la cadena c2: ");
gets(c2);
printf("\nLas longitudes de las cadenas son %d
y %d",strlen(c1),strlen(c2));
if(!strcmp(c1,c2))
printf("\nLas cadenas son iguales");
strcat(c1,c2);
printf("\n%s\n",c1);
strcpy(c1,"esta es una prueba");
printf(c1);
if(strchr("hola",'o'))
printf("\no esta en hola");
if(strstr("hola que tal","hola"))
printf("\nhola encontrado");
}

Programa ejemplo de uso de la función strcmp para introducir una clave. Si la clave es
correcta continua el programa
# include <stdio.h>
# include <string.h>
# include <stdlib.h>
int contrasena ( )
{
char s[80];
printf("Introduce la clave para pasar");
gets(s);
if(strcmp(s,"pasar"))
{
return 0;
}
return 1;
}
void main (void)

{
int a;
if(contrasena()==0)
exit(0);
printf("Introduce un numero");
scanf("%d",&a);
printf("\nEl numero introducido es el %d",a);
getchar();
getchar();
}
6.3.- Array bidimensional.

Un array bidimensional es un array de arrays. Es un array en donde cada uno de los
elementos es a su vez un array. Se les llama también matrices. La forma general es:
tipo nombre [tamaño1] [tamaño2]
Programa 20 Ejemplo
#include <stdio.h>
void main(void)
{
int i,j,matriz[4][7];
for(i=0;i<4;i++)
for(j=0;j<7;j++)
matriz[i][j]=i+j;
for(i=0;i<4;i++)
{
for(j=0;j<7;j++)
printf("%2d",matriz[i][j]);
putchar('\n');
}
}

Otra forma
#include <stdio.h>
#define numfilas 4
#define numcolumnas 7
void main(void)
{
int i,j,matriz[numfilas][numcolumnas];
for(i=0;i<numfilas;i++)
for(j=0;j<numcolumnas;j++)
matriz[i][j]=i+j;
for(i=0;i<numfilas;i++)
{
for(j=0;j<numcolumnas;j++)
printf("%2d",matriz[i][j]);
putchar('\n');
}
}
Si quiero variar el número de filas y columnas .... en Tema 7 (Asignación dinámica de

memoria).
Programa 21 Ejemplo: Lo mismo pero con funciones
#include <stdio.h>
#define filas 4
#define columnas 7
void rellenar (int m[filas][columnas]);

void imprimir (int m[filas][columnas]);
void main(void)
{
int matriz[filas][columnas];
rellenar(matriz);
imprimir(matriz);
}
void rellenar (int m[filas][columnas])

{
int i,j;
for(i=0;i<filas;i++)
for(j=0;j<columnas;j++)
m[i][j]=i+j;
}
void imprimir (int m[filas][columnas])
{
int i,j;
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
printf("%2d",m[i][j]);
putchar('\n');
}
}

Para saber el tamaño en bytes de una matriz multiplicamos el número de columnas por
el de filas y por el tamaño del tipo de variables con el que trabajamos.
totalbytes = sizeof(tipo) * numerodefilas * numerodecolumnas
6.4.- Array multidimensional.
Se pueden crear arrays de tantas dimensiones como se quiera dependiendo del límite
impuesto por cada compilador. La forma general es:
tipo nombre [tamaño1] [tamaño2] ..... [tamañoN]
6.5.- Array de cadenas.
En C es necesario a veces la inicialización de un array de cadenas. Un ejemplo de esto

es el siguiente programa:
Programa 22 Ejemplo
#include <stdio.h>
#define numerocadenas 3
#define longitudcadena 81
void main(void)
{
register int i;
char cadenas[numerocadenas][longitudcadena];
puts("\nIntroduccion de cadenas:\n");
for(i=0;i<numerocadenas;i++)
{
printf("Cadena %d: ",i);
gets(cadenas[i]);
}
puts("\n\n\nListado de las cadenas introducidas: \n");
for(i=0;i<numerocadenas;i++)
printf("\nCadena %d: %s",i,cadenas[i]);
}

6.6.- Ejercicios.
Ejercicio 30.- Programa que lee 20 números enteros sobre un vector, calculando e
imprimiendo la suma de los componentes de indice par, por un lado, y la suma de los
componentes de indice impar, por otro.
Ejercicio 31.- Generar una matriz cuadrada (de orden n x n).

Ejercicio 32.- Programa que genera una matriz de 5 filas y 10 columnas con números
entereos, imprimiendo los valores máximo y mínimo, y sus posiciones dentro de la
matriz.
Ejercicio 33.- Programa que genera e imprime una matriz unitaria de orden n.
Ejercicio 34.- Programa que lee una frase y averigua si es palíndroma.
Ejercicio 35.- Programa que lee dos matrices de orden n x n y las suma, las resta y las
multiplica.

TEMA 7
PUNTEROS
7.1.- Concepto.
7.2.- Aritmética de punteros.
7.3.- Asignación dinámica de memoria.
7.4.- Punteros y arrays.
7.5.- Punteros especiales.
7.6.- Ejercicios.
7.1.- Concepto.
Un puntero contiene una dirección de memoria donde se encuentra otro dato de un tipo
determinado. Un puntero es por tanto una dirección de memoria.
La forma general para declarar una variable puntero es:
tipo * nombre
tipo * nombre
donde tipo es el tipo de dato a que apunta el puntero

nombre es el nombre de la variable
Existen dos operadores especiales de punteros: &, *. Estos dos operadores son
monarios y no tienen nada que ver con los operadores binarios de multiplicación (*) y
and a nivel de bits (&).
& es un operado monario que devuelve la dirección de memoria de su operando.
Ejemplo: si m = &cont;
si la variable cont utiliza la posición de memoria 2000
para guardar su valor, y este (su valor) es 100 ......... m =
2000
Programa 23 Ejemplo
#include<stdio.h>
void main (void)

{
int x=10;
printf("x=%d\n&x=%p\n",x,&x);
}
Vemos que la salida es: x = 10

&x =0017FCD0 (varia cada vez que ejecutamos)

* es el operador complementario de &. Es un operador monario que devuelve el
valor de la variable localizada en la dirección que sigue (el contenido)
Ejemplo: si m = &cont;
q = *m;
entonces q = 100 ya que 100 es lo guardado en la
dirección 2000, que es la dirección de memoria que
indica m.
Programa 24 Ejemplo
#include<stdio.h>
void main (void)
{
int x=10;
printf("x=%d\n",x);
printf("*&x=%d",*&x);
}
Vemos que la salida es: x = 10

*&x = 10
Programa 25 Ejemplo mezcla de & y *
#include<stdio.h>
void main (void)

{
int num=1;
int *ppunt=&num;
printf("El puntero vale %p.\n",ppunt);
printf("La direccion de memoria de num es %p.\n",&num);
printf("El numero vale %d.\n",num);
printf("El contenido del puntero vale %d.\n",*ppunt);
*ppunt=5;
printf("El numero vale %d.\n",num);
printf("El contenido del puntero vale %d.\n",*ppunt);
}
Vemos que la salida es: El puntero vale 0017FEC0 (puede variar)

La dirección de memoria de num es 0017FEC0
El número vale 1
El contenido del puntero vale 1
El número vale 5
El contenido del puntero vale 5.

Programa 26 Ejemplo mezcla de & y *
#include<stdio.h>
void main (void)
{
int u =3;
int v;
int *pu; /* puntero a un entero */
int *pv; /* puntero a un entero */
pu = &u; /* asigna direccion de u a pu */
v = *pu; /* asigna valor de u a v */
pv = &v; /* asigna direccion de v a pv */
printf("\nu=%d &u=%x pu=%x *pu=%d",u, &u, pu,*pu);
printf("\n\nv=%d &v=%x pv=%x *pv=%d",v, &v, pv, *pv);
}
La salida es: u=3 &u=38f868 pu=38f868 *pu=3

v=3 &v=38f85c pv=38f85c *pv=3
Ya que vemos que en la primera línea u=3, según lo especificado en la instrucción de la

declaración. La dirección de u está directamente determinada por el compilador como
38f868 (hexadecimal). Al puntero pu se le asigna este valor; por tanto pu también
representa la dirección 38f868 (hexadecimal). Finalmente el valor al que apunta pu (el
valor almacenado en la celda de memoria cuya dirección es 38f868) es 3, como era de
esperar.
7.2.- Aritmética de punteros.
Existen 4 operadores que realizan operaciones aritméticas que pueden realizarse con
punteros. Estos son + , - , + + , - - .
¡Atención! Los punteros se incrementan o decrementan en relación al tamaño del tipo

de dato al que apuntan. Si el dato al que apunta el puntero ocupa 4 bytes, el puntero se
incrementa o decrementa en 4 bytes (no con 1 byte).
Cada vez que se incrementa un puntero, apunta a la posición de memoria del siguiente
elemento de su tipo base. Cada vez que se decrementa, apunta a la posición del
elemento anterior. Cuando se aplica a punteros a caracteres, esto hace que parezca una
aritmética “normal”, ya que los caracteres siempre ocupan un byte.. Sin embargo, el
resto de los punteros aumentan o decrecen en la longitud del tipo de datos a los que
apunta.

//Programa 27 Operaciones con punteros con int
#include<stdio.h>
void main (void)
{
int u =3;
int *pu; /* puntero a un entero */
printf("El numero es u = %d \n",u);
printf("La direccion del numero es &u = %x \n",&u);
u++;
printf("El numero incrementado es u + 1 = u++ = %d \n",u);
printf("La direccion de u++ es &u = %x \n",&u);
pu++;
printf("La direccion de u++ incrementada es pu = %x \n",pu);
getchar();
}
La salida de este programa es
El numero es u = 3
La direccion del numero es &u = 2ffd28
El numero incrementado es u +1 = u++ = 4
La direccion de u++ es &u = 2ffd28
La direccion de u++ incrementada en pu +1 = pu++ = 2ffd2c
Vemos que la dirección se incrementa en 4. Si hacemos lo mismo con un char la

dirección se incrementa en 1.
//Programa 27 B Operaciones con punteros con char
#include<stdio.h>
void main (void)
{
char u = 'c';
char *pu; /* puntero a un caracter */
printf("El caracter es u = %c \n",u);
printf("La direccion del caracter es &u = %x \n",&u);
printf("La direccion de u++ es &u = %x \n",&u);
pu++;
printf("La direccion de u++ incrementada es pu = %x \n",pu);
getchar();
}

7.3.- Asignación dinámica de memoria.
Supongamos que queremos hacer un programa que lea n valores enteros (máximo 100)
introducidos por teclado por el usuario, los almacene en un vector y los imprima en
orden inverso. Sería un programa como:
Programa 28 Asignación estática de memoria
#include<stdio.h>
void main (void)
{
#define NMAX 100
int v[NMAX];
int n=0;
int varaux;
register int i;
do
{
printf("\nIntroduce el numero de valores a leer (1 - %d):
",NMAX);
scanf("%d",&n);
}while(n<1||n>NMAX);
for(i=0;i<=n-1;i++)
{
printf("\nIntroduce el valor %d: ",i);
scanf("%d",&varaux);
v[i]=varaux;
}
printf("\nLos valores en orden inverso : \n");
for(i=n-1;i>=0;i--)
printf("%d ",v[i]);
}
Si el usuario introduce como valor de n, el valor 10, estaremos desperdiciando (si un int
ocupa 4 bytes) 90*4 bytes de memoria. Además, no podemos introducir más de NMAX
valores. Estas restricciones vienen impuestas porque el tamaño de un array en la
declaración ha de ser una expresión constante. La asignación de memoria en este caso
se dice que es estática porque se determina en el momento de la compilación.
Cuando la asignación de memoria se determina en tiempo de ejecución se dice que es

asignación dinámica. El programa 28 con asignación dinámica, en C, sería:

Programa 29 Asignación dinámica de memoria
#include<stdio.h>
#include<malloc.h>
void main (void)

{
int *v;
int n=0;
int varaux;
register int i;
printf("\nIntroduce el numero de valores a leer: ");
scanf("%d",&n);
v=(int*)malloc(n*sizeof(int));
{
for(i=0;i<=n-1;i++)
{
printf("\nIntroduce el valor %d: ",i);
scanf("%d",&varaux);
v[i]=varaux;
}
printf("\nLos valores en orden inverso : \n");
for(i=n-1;i>=0;i--)
printf("%d ",v[i]);
free(v);
}
}
La función malloc ( ) reserva memoria; acepta como argumento los bytes de memoria a
reservar y devuelve un puntero al primer byte de la zona de memoria reservada, los
bytes de memoria solicitados los reserva en un espacio de memoria contiguo. Si no hay
suficiente memoria, devuelve NULL. Un puntero que tiene el valor NULL es un
puntero que no apunta a ningún sitio. La función malloc ( ) se encuentra en la librería
malloc.h.
La memoria asignada a malloc que no se usa se libera con la función free ( ) que
también se encuentra en la librería malloc.h (free = liberar).
7.4.- Punteros y arrays.
Existe una estrecha relación entre los punteros y los arrays. Ya hemos dicho en varias
ocasiones que el nombre de un array es un puntero al primer elemento del array. A
cualquier elemento de un array podemos acceder mediante la aritmética de punteros y
viceversa, cualquier puntero lo podemos indexar con los arrays.
Array unidimensional p [i] = = * ( p+ i )
Array bidimensional p[i][j] = = * (p + (i * longitud_fila) + k) = = * ( * (p + i ) * j )

Una estructura común en c es el array de punteros. Por ejemplo la declaración para un
array de 10 punteros a int es
int * x [ 10 ]
Para asignar la dirección de una variable entera llamada var al tercer elemento del array
de punteros, se escribe
x [ 2 ] = & var
para encontrar el valor de var, se escribe
*x[2]
7.5.- Punteros especiales.
Punteros a punteros
Como se pueden definir punteros a cualquier tipo de dato, se pueden definir

lógicamente, punteros a punteros.
Punteros a estructuras
Igual que a cualquier tipo de datos, se pueden crear punteros a estructuras, pero
el operador de acceso a miembros es diferente.
Punteros a funciones:
Una función tiene una posición física en memoria que puede asignarse a un
puntero aunque la función no es una variable. La dirección de la función es el
punto de entrada de la función, por tanto, un puntero a función puede utilizarse
para llamar a la función.
7.6.- Ejercicios.
Ejercicio 36.- Programa que acepte como entrada una cadena de texto y sustituya todos
los conjuntos de dos o más espacios seguidos por espacios únicos.

TEMA 8
ESTRUCTURAS, FICHEROS Y
GRÁFICOS
8.1.- Estructura.
8.2.- Ficheros.
8.1.- Estructura.
Es una colección de variables que se referencia bajo un único nombre, proporcionando

un medio eficaz de mantener junta una información relacionada. Las variables que
componen la estructura se llaman miembros de la estructura, elementos o campos.
Al definir una estructura, a diferencia de las matrices, hemos de identificar uno a uno
todos sus miembros e identificar la propia estructura. Las estructuras están definidas
con la palabra clave struct.
El siguiente ejemplo definimos una estructura llamada registro en la que vamos a

incluir datos personales (nombre, dirección, teléfono). La forma de introducir datos por
teclado la hacemos mediante la función gets cuando son de tipo carácter (está función
tiene la ventaja de imprimir un retorno de carro al finalizar la introducción de la cadena
de caracteres).
Programa 30 Agenda: Introducción de registro
#include<stdio.h>
void main (void)

{
struct{
char nombre[20];
char direccion[50];
char telefono[10];
}registro;
printf("Nombre: ");
gets(registro.nombre);
printf("Direccion: ");
gets(registro.direccion);
printf("Telefono: ");
gets(registro.telefono);
}

En el ejemplo siguiente vamos a ampliar el programa para que salga en pantalla un
listado de los datos introducidos. Recurriremos a dos funciones, la primera llamada
entrada() la utilizamos para introducir los datos en la estructura registro, que ahora tiene
una capacidad máxima de 10 registros, por lo que los datos los introduciremos a través
de un bucle for. La salida de datos se realiza mediante la función salida(), aplicando la
función printf( ).
Programa 31 Agenda: Introducción de registros y salida por pantalla
#include<stdio.h>
struct{
char nombre[20];
char direccion[50];
char telefono[10];
}registro[10];
void entrada(void);
void salida(void);
void main (void)

{
entrada();
salida();
getchar();
}
void entrada(void)
{
int i;
for(i=0;i<4;++i)
{
printf("Nombre: ");
gets(registro[i].nombre);
printf("Direccion: ");
gets(registro[i].direccion);
printf("Telefono: ");
gets(registro[i].telefono);
}
}
void salida(void)
{
int i;
printf("Nº Nombre Direccion Telefono\n");
printf("================================================\n");
for(i=0;i<4;++i)
{
printf("%d",i+1);
printf("%5s",registro[i].nombre);
printf("%10s",registro[i].direccion);
printf("%20s",registro[i].telefono);
printf("\n");
}
}

8.2.- Ficheros.
Con lo visto hasta ahora podemos trabajar con gran cantidad de datos de formatos
distintos y podemos, de una manera sencilla, almacenarlos en una variable tipo matriz o
estructura, pero al terminar la ejecución del programa perdemos todos los valores
almacenados.
Vamos a estudiar los ficheros FILE o archivos, en los que vamos a poder almacenar,
leer, modificar, añadir o eliminar datos. Para ello vamos a declarar ficheros, abrirlos,
cerrarlos, vamos a grabar datos, modificarlos, borrarlos, consultar registros.
 Para declarar un fichero hemos de definir una variable de tipo puntero a fichero,
que utilizaremos para poder identificarlo. El formato de esta declaración es:
FILE * nombre_identificador
donde nombre_identificador será el nombre que utilizaremos en todas las

operaciones posteriores que afecten al fichero. Siempre que definimos un
archivo hemos de incluir la librería stdio.h
 Antes de comenzar a trabajar con un fichero, necesitamos abrirlo, para ello se

utiliza la función fopen(). El formato de esta declaración es:
fichero=fopen(nombre_fichero,modo_acceso);
donde nombre_fichero será el nombre con el que identificamos el fichero(debe

ser un nombre valido para DOS) y modo_acceso es el modo de apertura del
fichero.
MODO DESCRIPCIÓN
“w” Crea un fichero y lo deja abierto para escritura. Si el fichero
existe lo borra y crea uno nuevo
“a” Añade datos al final de un fichero ya existente. Si no existe
el fichero creará uno nuevo
“r” Abre un fichero para lectura
“rb” Abre un archivo binario para lectura
“wb” Crea un archivo binario para escritura
“ab” Abre una archivo binario para añadir información
“w+” Crea un fichero nuevo para escritura y permite la lectura de
datos. Si el fichero existe lo borra y crea uno nuevo
“r+” Abre un fichero ya existente para lectura y escritura
“a+” Añade datos al final de un fichero ya existente y permite la
lectura de datos.

“r+b” Abre un archivo binario para lectura/escritura
“w+b” Crea un archivo binario para lectura/escritura
“a+b” Abre o crea un archivo binario en modo lectura/escritura
para añadir información
El argumento de fichero es de tipo cadena y devolverá el valor NULL en caso de error.

En caso contrario contendrá los datos del fichero.
Para situar el cursor en un determinado punto, en algunos compiladores de C y de C++,

se usa la función gotoxy. Vemos en el siguiente ejemplo como se usa.
Programa 32A Tratamiento de ficheros en C
#include<stdio.h>
struct{
char nombre[20];
char direccion[25];
char telefono[15];
char poblacion[20];
}datos;
void main(void)
{
for(;;)
{
gotoxy(38,5);printf("MENU");
gotoxy(29,8);printf("1.- Introducir registros");
gotoxy(29,10);printf("2.- Modificar registros");
gotoxy(29,12);printf("3.- Borrar registros");
gotoxy(29,14);printf("4.- Consultar registros");
gotoxy(29,16);printf("5.- Finalizar");
gotoxy(19,19);printf("Introduce el numero de la opcion
deseada");
}
}
Pero en Visual C esta función no existe. Hemos de incluir una función que realice esta
tarea. La llamaremos, también gotoxy. Dicha función necesita la librería windows.h y la
añadimos al programa 32A

Programa 32AVisualC Tratamiento de ficheros en Visual C
#include<stdio.h>
#include<windows.h>
/* Funcion "gotoxy" situa el cursor en un punto determinado */

void gotoxy(int x,int y)
{
COORD point;
point.X=x;
point.Y=y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),point);
}
struct{
char nombre[20];
char direccion[25];
char telefono[15];
char poblacion[20];
}datos;
void main(void)
{
for(;;)
{
deseada");
}
}
Programa 32B Tratamiento de ficheros
#include<conio.h>
#include<stdio.h>
#include<process.h> /* para exit() En Visual C no hace falta incluir*/
#include<windows.h>
//Funcion "gotoxy" situa el cursor en un punto determinado

{
COORD point;
point.X=x;
point.Y=y;
}
struct{
char nombre[20];
char direccion[25];
char telefono[15];
char poblacion[20];
}datos;

char opc;
void main(void)
{
for(;;)
{
deseada");
opc=getch();
switch(opc)
{
case'5':exit(0);
default:break;
}
}
}
Declaramos un fichero mediante FILE *fichero y hacemos un switch con el caso 1 para
grabar datos mediante la función intro
Programa 32C Tratamiento de ficheros. Función Intro
//Programa 32C Tratamiento de ficheros. Función Intro
#include<stdio.h>
#include<conio.h>
#include<string.h> /* strlen */
#include<ctype.h> /* toupper (mayúsculas - minúsculas */
#include<process.h> /* para exit() En Visual C no hace falta incluir*/
#include<windows.h>
void gotoxy(int x,int y);

void intro (void);
struct{
char nombre[30];
char direccion[25];
char telefono[12];
char poblacion[20];
}datos;
FILE *fichero; /* puntero a fichero */

char opc;

void main(void)
{
for(;;) /* bucle infinito */
{
system("cls"); /* limpia la pantalla */
gotoxy(38,5);printf("Menu");
gotoxy(29,8);printf("1.-Introducir registros");
gotoxy(29,10);printf("2.-Modificar registros");
gotoxy(29,12);printf("3.-Borrar registros");
gotoxy(29,14);printf("4.-Consultar registros");
gotoxy(29,16);printf("5.-Finalizar");
deseada");
opc=getch();
switch(opc)
{
case'1':intro(); break;
case'5':exit(0);
default:break;
}
}
}

{
COORD point;
point.X=x;
point.Y=y;
}
void intro (void)

{
system("cls");
if((fichero=fopen("agenda.txt","a")))
/* En Visual por defecto lo guarda en el proyecto, si
queremos otro sitio debemos indicar la direccion */
for(;;) /* bucle infinito */
{
system("cls");
gotoxy(20,6);printf("Para finalizar pulse INTRO");
gotoxy(20,9);printf("Nombre:");
gotoxy(20,11);printf("Direccion:");
gotoxy(20,13);printf("Telefono:");
gotoxy(20,15);printf("Poblacion:");
gotoxy(34,9);gets(datos.nombre);
if(strlen(datos.nombre)==0)break; /*hasta introducir cadena
vacía*//*strlen nos da la longitud de la cadena */
gotoxy(34,11);gets(datos.direccion);
gotoxy(34,13);gets(datos.telefono);
gotoxy(34,15);gets(datos.poblacion);
gotoxy(20,28);printf("Datos correctos ? (S/N): ");
opc=toupper(getch()); /* Da igual mayúsculas que minúsculas
*/
if(opc=='S')
fwrite(&datos,sizeof(datos),1,fichero); /* para
grabar el registro */
}
fclose(fichero);
}

La forma general de fwrite es la siguiente:
fwrite (&identificador_estructura, tamaño_estructura, nºregistros,fichero)
donde:
1. identificador_estructura es el nombre con que hemos identificado la
estructura.
En nuestro caso: datos.
 tamaño_estructura es el tamaño en bytes de la estructura, aquí se
puede utilizar la función sizeof() que automáticamente nos dará ese
resultado.
 nº registros es la cantidad de registros que queremos grabar
En nuestro caso: 1.
 fichero es la variable de tipo FILE con que hemos definido el fichero.
Es conveniente añadir la función error() para el caso de que al abrir el fichero o en

otras funciones que la usemos se produjera un error dandome un mensaje diciendolo.
Programa 32D Tratamiento de ficheros. Función Error

void error (void)
{
printf(“Error!. No puedo abrir el fichero”);
getch();
exit(0);
}
Para modificar un registro tenemos que escoger un campo de la estructura, que será el
que compararemos con los registros leídos secuencialmente. Antes de comenzar la
lectura del fichero utilizaremos una variable temporal donde se almacenará el dato que
compararemos posteriormente con uno de los miembros de la estructura. Aquí hemos
escogido el campo datos.nombre y la variable nom. Las dos variables elegidas han de
ser del mismo tipo.
Mediante la función strcmp() comparamos las dos cadenas. Su valor será 0 cuando las
cadenas son iguales.
El bucle de búsqueda comienza con una función while() y utiliza la condición feof(),
que comprueba el final del fichero. La lectura de los registros del fichero se realiza con
la función fread() que es similar a la función fwrite().
Cada vez que seleccionemos un campo el cursor se irá al primer carácter de ese campo.
Borrará todo lo que hay desde la posición que se encuentra hasta el final de la línea con
la función clreol() y nos pedirá que introduzcamos un nuevo valor para ese campo. Una
vez finalizadas las modificaciones, los cambios realizados han de quedar reflejados en
le fichero de disco, ya que hasta ahora sólo se ha modificado la estructura de memoria.

Para ello es necesario realizar varias operaciones. Cuando tenemos un registro en
memoria C ya está situado en el fichero de disco para trabajar con el siguiente registro,
por lo que antes de grabar los cambios realizados tendremos que retroceder un registro
y posteriormente grabar con la función fwrite(). Para retroceder un registro utilizamos
la función fseek() que tiene el siguiente formato
fseek ( fichero, +/- desplazamiento, posición inicial );

donde:
1. fichero es el identificador del fichero
2. desplazamiento es el número de bytes que ha de desplazarse
3. posición inicial nos indica desde donde tienen que desplazarse los bytes.
En este caso usamos la variable aux que la hemos definido dándole el
tamaño de la estructura con la función sizeof()
La posición inicial del desplazamiento puede ser una de estas tres:
DESPLAZAMIENTO DESCRIPCIÓN
SEEK-SET Principio de fichero
SEEK-CUR Posición actual
SEEK-END Fin de fichero
Programa 32E Tratamiento de ficheros. Función, Intro, Error, Modificar
void modif(void);
void clreol(); /* Borra lo que hay en la linea a partir del cursor */
char opc,nom[30];
int aux;
void main(void)
{
switch(opc)
{
case'1':intro(); break;
case'2':modif(); break;
case'5':exit(0);
default:break;
}
void modif(void)
{
system("cls");
aux=sizeof(datos);
if((fichero=fopen("agenda.txt","r+b"))==NULL) error();
gotoxy(15,12);printf("Introduce Nombre a modificar: ");
gets(nom);
system("cls");

while(!feof(fichero))
{
fread(&datos,sizeof(datos),1,fichero);
if(strcmp(datos.nombre,nom)==0)
{
gotoxy(22,9);printf("1 Nombre : %s",datos.nombre);
gotoxy(22,11);printf("2 Direccion: %s",datos.direccion);
gotoxy(22,13);printf("3 Telefono: %s",datos.telefono);
gotoxy(22,15);printf("4 Poblacion: %s",datos.poblacion);
gotoxy(22,21);printf("5 Fin de las modificaciones");
while(opc!='5')
{
gotoxy(18,19);printf("Campo a modificar: ");
opc=getch();
gotoxy(18,19);clreol();
switch(opc)
{
case'1':gotoxy(37,9);clreol();
gets(datos.nombre);break;
gets(datos.direccion);break;
gets(datos.telefono);break;
gets(datos.poblacion);break;
case'5':fseek(fichero,-aux,SEEK_CUR);
fwrite(&datos,sizeof(datos),1,fichero);break;
default:break;
}
}
break;
}
}
fclose(fichero);
}
void clreol()
{
COORD coord;
DWORD written;
CONSOLE_SCREEN_BUFFER_INFO info;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE),&info);
coord.X=info.dwCursorPosition.X;
coord.Y=info.dwCursorPosition.Y;
FillConsoleOutputCharacter (GetStdHandle
(STD_OUTPUT_HANDLE),'',info.dwSize.X-
info.dwCursorPosition.X,coord,&written);
gotoxy(coord.X+1,coord.Y+1);
}
Para borrar un registro usamos la función borra() aunque realmente no elimina los
registros. En C no existe ninguna función que realice esto, lo que se hace es marcar el
registro con el signo *, así no tendrá ninguna validez cuando queramos hacer una
consulta.

Programa 32F Tratamiento de ficheros. Función, Intro, Modificar,Borrar
void borra(void);
void main(void)
{
case'3':borra();break;
}
void borra(void)
{
system(“clr”);
aux=sizeof(datos);
if((fichero=fopen("a:agenda.txt","r+b"))==NULL) error();
gotoxy(15,12);printf("Introduce Nombre a borrar: ");
gets(nom);
system(“clr”);
{
{
gotoxy(22,9);printf("Nombre : %s",datos.nombre);
gotoxy(22,11);printf("Direccion: %s",datos.direccion);
gotoxy(22,13);printf("Telefono: %s",datos.telefono);
gotoxy(22,15);printf("Poblacion: %s",datos.poblacion);
gotoxy(22,21);printf("Estas seguro de borrar el archivo
(S/N)");
opc=toupper(getch());
system(“clr”);
if(opc='S')
{
strcpy(datos.nombre,"*");
fseek(fichero,-aux,SEEK_CUR);
fwrite(&datos,sizeof(datos),1,fichero);
break;
}
}
}
fclose(fichero);
}
Para eliminar definitivamente un registro marcado deberíamos definir una función que
abriera otro fichero, por ejemplo, copia.txt, fuéramos leyendo todos los registros de
agenda.txt y escribiendo en copia.txt los que no estuvieran marcados, al finalizar
borraríamos el fichero agenda.txt y renombraríamos el fichero copia.txt como
agenda.txt
Para consultar un registro realizamos una función similar a las anteriores pero una vez
localizado el registro lo imprime en pantalla.

Programa 32G Tratamiento de ficheros. Función, Intro, Modificar,
Borrar y Consultar
void consultar(void);
void main(void)
{
case'4':consultar();break;
}
void consultar(void)
{
system(“cls”);
if((fichero=fopen("a:agenda.txt","r+b"))==NULL) error();
gotoxy(15,12);printf("Introduce Nombre a consultar: ");
gets(nom);
system(“cls”);
{
{
gotoxy(22,9);printf("Nombre : %s",datos.nombre);
gotoxy(22,11);printf("Direccion: %s",datos.direccion);
gotoxy(22,13);printf("Telefono: %s",datos.telefono);
gotoxy(22,15);printf("Poblacion: %s",datos.poblacion);
getch();
break;
}
}
fclose(fichero);
}

APENDICE A
Funciones de “C” estándar
clasificadas por ficheros de cabecera

<ctype.h>
Incluye algunas funciones útiles para la clasificación y el mapeado de códigos. Cada

función acepta un argumento de tipo "int" cuyo valor puede ser el valor de la macro
"EOF" o cualquier valor representable por el tipo "unsigned char". Esto es, el argumento
puede ser el valor devuelto por "fgetc", "fputc", "getc", "getchar", "putc", "putchar",
"tolower", "toupper" o "ungetc" (declaradas en "<stdio.h>").
isalnum
int isalnum (int c);
Devuelve un valor distinto de cero si "c" es una letra minúscula "a-z" o mayúscula "A-
Z", uno de los dígitos decimales "0-9" o cualquier otro carácter alfabético local.
isalpha
int isalpha (int c);
Devuelve un valor distinto de cero si "c" es una letra minúscula "a-z" o mayúscula "A-
Z", o cualquier otro carácter alfabético local.
iscntrl
int iscntrl (int c);
Devuelve un valor distinto de cero si "c" es cualquier carácter de control (como FF, HT,
NL).
isdigit
int isdigit (int c);
Devuelve un valor distinto de cero si "c" es cualquiera de los dígitos decimales (0-9).
isgraph
int isgraph (int c);
Devuelve un valor distinto de cero si "c" es cualquier carácter de impresión excepto
"espacio".
islower
int islower (int c);
Devuelve un valor distinto de cero si "c" es cualquiera de las letras minúsculas "a-z" u
otra minúscula local.
isprint
int isprint (int c);
Devuelve un valor distinto de cero si "c" es cualquier carácter imprimible, incluyendo el
"espacio".
ispunct
int ispunct (int c);
Devuelve un valor distinto de cero si "c" es cualquier carácter imprimible excepto
"espacio", o si "isalnum(c)" es distinto de cero.

isspace
int isspace (int c);
Devuelve un valor distinto de cero si "c" es "CR", "FF", "HT", "NL", "VT", "espacio" o
cualquier otro carácter de separación local.
isupper
int isupper (int c);
Devuelve un valor distinto de cero si "c" es una de las letras mayúsculas "A-Z" u otra
mayúscula local.
isxdigit
isxdigit (int c);
Devuelve un valor distinto de cero si "c" es cualquier dígito hexadecimal "0-9", "A-F",
"a-f".
tolower
tolower (int c);
Devuelve la correspondiente letra minúscula si existe y si "isupper(c)" es distinto de
cero; en caso contrario, devuelve "c".
toupper
int toupper (int c);
Devuelve la correspondiente letra mayúscula si existe y si "islower(c)" es distinto de
cero; en caso contrario, devuelve "c".
<errno.h>
Permite comprobar el valor almacenado en "errno" por algunas funciones de librería.
Al arrancar el programa, el valor almacenado en "errno" es cero. Las funciones de
librería almacenan sólo valores mayores que 0 en "errno". Para comprobar si una
función almacena un valor en "errno", el programa debería almacenar un 0 en "errno"
antes de llamar a la función.
EDOM
#define EDOM <expresion #if>
Almacena un valor en "errno" según exista o no un error de dominio.
ERANGE
#define ERANGE <expresion #if>
Almacena un valor en "errno" según exista o no un error de rango.
errno
#define errno <valor modificable int>
Designa un objeto de datos al que se asigna un valor mayor que cero dependiendo de
ciertos errores.

<float.h>
Establece algunas propiedades de las representaciones de tipo real.
DBL_DIG
#define DBL_DIG <valor_entero 10>
Número de dígitos de precisión para el tipo "double".
DBL_EPSILON
#define DBL_EPSILON <valor_double 10-9>
Produce el menor valor "x" de tipo "double", tal que 1.0 + x ? 1.0.
DBL_MANT_DIG
#define DBL_MANT_DIG <valor_int>
Produce el número de dígitos de mantisa, base "FLT_RADIX", para el tipo "double".
DBL_MAX
#define DBL_MAX <valor_double 1037>
Valor representable finito más grande de tipo "double".
DBL_MAX_10_EXP
#define DBL_MAX_10_EXP <valor_int 37>
Máximo entero "x" tal que 10 elevado a "x" sea un valor representable finito de tipo
"double".
DBL_MAX_EXP
#define DBL_MAX_EXP <valor_int>
Máximo entero "x" tal que "FLT_RADIX" elevado a "x-1" es un valor finito
representable de tipo "double".
DBL_MIN
#define DBL_MIN <valor_double 10-37>
Valor finito más pequeño representable normalizado de tipo "double".
DBL_MIN_10_EXP
#define DBL_MIN_10_EXP <valor_int -37>
Mínimo entero "x" tal que 10 elevado a "x" es un valor finito representable y
normalizado de tipo "double".
DBL_MIN_EXP
#define DBL_MIN_EXP <valor_int>
Mínimo entero "x" tal que "FLT_RADIX" elevado a "x-1" es un valor finito
representable y normalizado de tipo "double".
FLT_DIG
#define FLT_DIG <valor_int 6>
Número de dígitos decimales de precisión para el tipo "float".

FLT_EPSILON
#define FLT_EPSILON <valor_float 10-5>
Valor más pequeño "x" de tipo "float", tal que 1.0 + x ? 1.0.
FLT_MANT_DIG
#define FLT_MANT_DIG <valor_int>
Número de dígitos de mantisa, en base "FLT_RADIX", para el tipo "float".
FLT_MAX
#define FLT_MAX <valor_float 1037>
Valor finito representable más grande de tipo "float".
FLT_MAX_10_EXP
#define FLT_MAX_10_EXP <valor_int 37>
Máximo entero "x" tal que 10 elevado a "x" es un valor finito representable de tipo
"float".
FLT_MAX_EXP
#define FLT_MAX_EXP <valor_int>
representable de tipo "float".
FLT_MIN
#define FLT_MIN <valor_float 10-37>
Menor valor finito representable y normalizado de tipo "float".
FLT_MIN_10_EXP
#define FLT_MIN_10_EXP <valor_int -37>
Mínimo entero "x" tal que 10 elevado a "x" es un valor finito representable y
normalizado de tipo "float".
FLT_MIN_EXP
#define FLT_MIN_EXP <valor_int>
Mínimo ntero "x" tal que "FLT_RADIX" elevado a "x-1" es un valor finito
representable y normalizado de tipo "float".
FLT_RADIX
#define FLT_RADIX <expresion #if 2>
Produce la base de numeración de todas las representaciones reales.
FLT_ROUNDS
#define FLT_ROUNDS <valor_int>
Describe el modo de redondeo para las operaciones con reales. El valor es "-1" si el
modo está indeterminado, es "0" si el redondeo es hacia "0", es "1" si el redondeo es
hacia el valor representable más cercano, es "2" si el redondeo es hacia +8 y es "3" si el
redondeo es hacia -8.
LDBL_DIG
#define LDBL_DIG <valor_int 10>
Número de dígitos decimales de precisión para el tipo "long double".

LDBL_EPSILON
#define LDBL_EPSILON <valor_long_double 10-9>
Menor valor de "x" de tipo "long double" tal que 1.0 + x ? 1.0.
LDBL_MANT_DIG
#define LDBL_MANT_DIG <valor_int>
Número de dígitos de mantisa, en base "FLT_RADIX", para el tipo "long double".
LDBL_MAX
#define LDBL_MAX <valor_long_double 1037>
Valor finito representable más grande de tipo "long double".
LDBL_MAX_10_EXP
#define LDBL_MAX_10_EXP <valor_int 37>
Máximo entero "x" tal que 10 elevado a "x" es un valor finito representable de tipo
"long double".
LDBL_MAX_EXP
#define LDBL_MAX_EXP <valor_int>
representable de tipo "long double".
LDBL_MIN
#define LDBL_MIN <valor_long_double 10-37>
Menor valor finito representable y normalizado de tipo "long double".
LDBL_MIN_10_EXP
#define LDBL_MIN_10_EXP <valor_int -37>
Mínimo entero "x" tal que 10 elevado a "x" es unvalor finito representable y
normalizado de tipo "long double".
LDBL_MIN_EXP
#define LDBL_MIN_EXP <valor_int>
Mínimo entero "x" tal que "FLT_RADIX" elevado a "x-1" es un valor finito
representable y normalizado de tipo "long double".
<limits.h>
Contiene macros que determinan varias propiedades de las representaciones de tipos
enteros.
CHAR_BIT
#define CHAR_BIT <expresion #if 8>
Número de bits usados en la representación de un objeto de datos de tipo "char".
CHAR_MAX
#define CHAR_MAX <expresion #if 127>
Máximo valor para el tipo "char", que es el mismo que "SCHAR_MAX" si "char"
representa valores negativos; en caso contrario, el valor es el mismo que
"UCHAR_MAX".

CHAR_MIN
#define CHAR_MIN <expresion #if 0>
Mínimo valor para el tipo "char", el mismo que "SCHAR_MIN" si "char" representa
valores negativos; en caso contrario, el valor es 0.
INT_MAX
#define INT_MAX <expresion #if 32767>
Máximo valor para el tipo "int".
INT_MIN
#define INT_MIN <expresion #if -32767>
Mínimo valor para el tipo "int".
LONG_MAX
#define LONG_MAX <expresion #if 2147483647>
Máximo valor para el tipo "long".
LONG_MIN
#define LONG_MIN <expresion #if -2147483647>
Mínimo valor para el tipo "long".
MB_LEN_MAX
#define MB_LEN_MAX <expresion #if 1>
Máximo número de caracteres que constituyen un carácter multibyte en un conjunto de
caracteres local.
SCHAR_MAX
#define SCHAR_MAX <expresion #if 127>
Máximo valor para el tipo "signed char".
SCHAR_MIN
#define SCHAR_MIN <expresion #if -127>
Mínimo valor para el tipo "signed char".
SHRT_MAX
#define SHRT_MAX <expresion #if 32767>
Máximo valor para el tipo "short".
SHRT_MIN
#define SHRT_MIN <expresion #if -32767>
Mínimo valor para el tipo "short".
UCHAR_MAX
#define UCHAR_MAX <expresion #if 255>
Máximo valor para el tipo "unsigned char".
UINT_MAX
#define UINT_MAX <expresion #if 65535>
Máximo valor para el tipo "unsigned int".

ULONG_MAX
#define ULONG_MAX <expresion #if 4294967295>
Máximo valor para el tipo "unsigned long".
USHRT_MAX
#define USHRT_MAX <expresion #if 65535>
Máximo valor para el tipo "unsigned short".

<math.h>
Contiene la declaración de algunas funciones para realizar operaciones matemáticas
comunes sobre valores de tipo "double". Una excepción por error de dominio ocurre
cuando la función no está definida para el valor o valores de sus argumentos. La función
informa almacenando el valor "EDOM" en "errno" y devolviendo un valor peculiar
propio de cada implementación.
Una excepción por error de rango ocurre cuando el valor de la función está definido
pero no puede ser representado por un valor de tipo "double". La función informa
almacenando el valor "ERANGE" en "errno" y devolviendo uno de los siguientes
valores: "HUGE_VAL" si el valor es positivo y demasiado grande, "0" si el valor es
demasiado pequeño para ser representado, "-HUGE_VAL" si el valor es negativo y con
valor absoluto demasiado grande.
HUGE_VAL
#define HUGE_VAL <valor_double>
Valor devuelto por algunas funciones debido a un error de rango, que puede ser una
representación de infinitud.
acos
double acos (double x);
Angulo cuyo coseno es "x", en el rango [0,p] radianes.
asin
double asin (double x);
Angulo cuyo seno es "x", en el rango [-p/2, +p/2] radianes.
atan
double atan (double x);
Angulo cuya tangente es "x", en el rango [-p/2, +p/2] radianes.
atan2
double atan2 (double y, double x);
Angulo cuya tangente es "y/x", en el rango [-p, +p] radianes.
ceil
double ceil (double x);
Valor entero más pequeño no menor que "x".
cos
double cos (double x);
Coseno de "x" (en radianes).
cosh
double cosh (double x);
Coseno hiperbólico de "x".

exp
double exp (double x);
Exponencial de "x", ex.
fabs
double fabs (double x);
Valor absoluto de "x", "|x|".
floor
double floor (double x);
Mayor valor entero menor que "x".
fmod
double fmod (double x, double y);
Resto de "x/y", el cual es "x-i*y" para algún entero "i", tal que "i*y<x<(i+1)*y". Si "y"
es cero, la función o informa de un error de dominio o simplemente devuelve el valor 0.
frexp
double frexp (double x, int *pexp);
Determina una fracción "f" y un entero "i" en base 2 que representa el valor de "x".
Devuelve el valor "f" y almacena el entero "i" en "*pexp" tal que "f" está en el intervalo
[1/2, 1) o tiene el valor 0, y "x" se iguala a "f*(2i)". Si "x" es 0, "*pexp" es también 0.
ldexp
double ldexp (double x, int exponente);
Devuelve "x*2exponente".
log
double log (double x);
Devuelve el logaritmo natural de "x".
log10
double log10 (double x);
Devuelve el logaritmo en base 10 de "x".
modf
double modf (double x, double *pint);
Determina un entero "i" más una fracción "f" que representan el valor de "x". Devuelve
el valor "f" y almacena el entero "i" en "*pint", tal que "f+i" se iguala a "x", "|f|" está en
el intervalo [0,1), y tanto "f" como "i" tienen el mismo signo que "x".
pow
double pow (double x, double y);
Devuelve "x" elevado a la potencia "y".
sin
double sin (double x);
Devuelve el seno de "x" (en radianes).

sinh
double sinh (double x);
Devuelve el seno hiperbólico de "x".
sqrt
double sqrt (double x);
Devuelve la raíz cuadrada de "x".
tan
double tan (double x);
Devuelve la tangente de "x" (en radianes).
tanh
double tanh (double x);
Devuelve la tangente hiperbólica de "x".
<stdarg.h>
Contiene declaraciones que permiten acceder a los argumentos adicionales sin nombre
en una función que acepta un número variable de argumentos. Para acceder a los
argumentos adicionales, el programa debe ejecutar primero el macro "va_start" dentro
del cuerpo de la función para inicializar un objeto de datos con información de contexto.
Ejecutando sucesivamente el macro "va_arg", indicando esa información de contexto, se
pueden ir obteniendo los valores de los argumentos adicionales en orden, empezando
por el primer argumento sin nombre. Se puede ejecutar "va_arg" desde cualquier
función que pueda acceder a la información de contexto grabada por "va_start". Si se ha
ejecutado "va_start" en una función, se debe ejecutar el macro "va_end" en la misma
función, indicando la misma información de contexto, antes del retorno de la función.
Para almacenar la información de contexto, se declara un objeto de datos "va_list", que
puede ser un tipo "array" que afecta a cómo comparte información el programa con las
funciones.
va_arg
#define va_arg (va_list ap, T) <valor_de_tipo_T>
Produce el valor del siguiente argumento en orden, según la información de contexto
indicada por "ap". El argumento adicional debe ser de tipo "T" depués de aplicar las
reglas para la promoción de argumentos en la ausencia de prototipo de función.
va_end
#define va_end (va_list ap) <expresion_void>
Realiza la limpieza necesaria para que la función pueda retornar.
va_list
typedef do-tipo va_list;
Es el tipo de datos "do_tipo" que se declara para contener la información de contexto
inicializada
por "va_start" y utilizada por "va_arg".
va_start
#define va_start (va_list ap, ultimo_arg) <expresion_void>
Almacena la información de contexto inicial en "ap". "ultimo_arg" es el nombre del
último argumento declarado.

<stdio.h>
Incluye macros y funciones para realizar operaciones de entrada y salida sobre ficheros
y flujos de datos.
_IOFBF
#define _IOFBF <expresion constante entera>
Valor del argumento "modo" para "setvbuf" para indicar "buffer" completo.
_IOLBF
#define _IOLBF <expresion constante entera>
Valor del argumento "modo" para "setvbuf" para indicar el "buffer" de línea.
_IONBF
#define _IONBF <expresion constante entera>
Valor del argumento "modo" para "setvbuf" para indicar que no se usa "buffer".
BUFSIZ
#define BUFSIZ <expresion constante entera 256>
Tamaño del "buffer" de flujo de datos utilizado por "setbuf".
EOF
#define EOF <expresion constante entera 0>
Valor de retorno utilizado para señalar el fin de fichero.
FILE
typedef d-tipo FILE;
Es el tipo de datos que almacena toda la información de control para un flujo de datos.
FILENAME_MAX
#define FILENAME_MAX <expresion constante entera>
Máximo tamaño de un "array" de caracteres para almacenar el nombre de un fichero.
FOPEN_MAX
#define FOPEN_MAX <expresion constante entera 8>
Máximo número de ficheros que el entorno operativo permite que estén abiertos
simultáneamente (incluyendo "stderr", "stdin", "stdout").
L_tmpnam
#define L_tmpnam <expresion constante entera>
Número de caracteres que requiere el entorno operativo para representar nombres de
ficheros temporales creados por "tmpnam".
NULL
#define NULL <0, 0L, o (void *)0>
Constante de puntero nulo que es utilizable como una expresión de direccionamiento
constante.

SEEK_CUR
#define SEEK_CUR <expresion constante entera>
Valor del argumento "modo" para "fseek" para indicar la búsqueda relativa a la posición
actual del fichero.
SEEK_END
#define SEEK_END <expresion constante entera>
Valor del argumento "modo" para "fseek" para indicar la búsqueda relativa al final del
fichero.
SEEK_SET
#define SEEK_SET <expresion constante entera>
Valor del argumento "modo" para "fseek" para indicar la búsqueda relativa al comienzo
del fichero.
TMP_MAX
#define TMP_MAX <expresion constante entera 25>
Número máximo de nombres de ficheros diferentes creados por la función "tmpnam".
clearerr
void clearerr (FILE *flujo);
Limpia los indicadores de error y de fin de fichero para el flujo de datos "flujo".
fclose
int fclose (FILE *flujo);
Cierra el fichero asociado con "flujo". Previamente, escribe lo que queda en el "buffer",
descarta cualquier entrada por "buffer" incompleta y libera cualquier "buffer". Devuelve
0 en caso de éxito y EOF en caso contrario.
feof
int feof (FILE *flujo);
Devuelve un valor distinto de 0 si el indicador de final de fichero está a 1.
ferror
int ferror (FILE *flujo);
Devuelve un valor distinto de 0 si el indicador de error está puesto a 1.
fflush
int fflush (FILE *flujo);
Se escibe cualquier salida por "buffer" que esté pendiente. Devuelve 0 si tiene éxito; en
caso contrario, devuelve EOF;
fgetc
int fgetc (FILE *flujo);
Lee el siguiente carácter por "flujo", avanza el indicador de posición y devuelve "(int)
(unsigned char)". Devuelve EOF si pone a 1 el indicador de fin de fichero o el de error.

fgetpos
int fgetpos (FILE *flujo, fpos_t *pos);
Almacena el indicador de posición de fichero en "pos" y devuelve 0 si tiene éxito; en
caso contrario, almacena un valor positivo en "errno" y devuelve un valor distinto de
cero.
fgets
char *fgets (char *s, int n, FILE *flujo);
Lee caracteres por "flujo" y los almacena en elementos sucesivos del "array" que
comienza en "s", continuando hasta que almacene "n-1" caracteres, almacene un
carácter "NL" o ponga a 1 los indicadores de error o fin de fichero. Si almacena un
carácter, concluye almacenando un carácter nulo en el siguiente elemento del "array".
Devuelve "s" si almacena algún carácter y no ha puesto a 1 el indicador de error; en
caso contrario, devuelve un puntero nulo.
fopen
FILE *fopen(const char *nombre_fichero, const char *modo);

Abre el fichero de nombre "nombre_fichero", lo asocia con un flujo de datos y devuelve
un puntero al mismo. Si falla, devuelve un puntero nulo. Los caracteres iniciales de
"modo" deben ser alguno de los siguientes:
"r", para abrir fichero de texto existente para lectura.
"w", para crear fichero de texto o abrir y truncar uno existente, para escritura.
"a", para crear fichero de texto o abrir uno existente, para escritura. El indicador de
posición se coloca al final del fichero antes de cada escritura.
"rb", para abrir fichero binario existente para lectura.
"r+", para abrir fichero de texto existente para lectura y escritura.
"rb+", para abrir fichero binario existente para lectura y escritura.
fpos_t
typedef do-tipo fpos_t;
Tipo de datos para contener el valor del indicador de posición del fichero almacenado
por "fsetpos" y accedido por "fgetpos".
fprintf
int fprintf (FILE *flujo, const char *formato, ...);
Genera texto formateado, bajo el control del formato "formato" y escribe los caracteres
generados por "flujo". Devuelve el número de caracteres generados o un valor negativo
en caso de error.
fputc
int fputc (int c, FILE *flujo);
Escribe el carácter "(unsigned char) c" por "flujo", avanza el indicador de posición del
fichero y devuelve "(int)(unsigned char) c". En caso de error, devuelve "EOF".
fputs
int fputs (const char *s, FILE *flujo);
Escribe los caracteres de la cadena "s" por "flujo". No escribe el carácter nulo de
terminación. En caso de éxito, devuelve un valor no negativo; en caso de error,
devuelve "EOF".

fread
size_t fread (void *p, size_t longitud, size_t nelem, FILE *flujo);
Lee caracteres por "flujo" y los almacena en el "array" que comienza en "p" hasta que se
almacenen "longitud*nelem" caracteres o se active la condicion de error o la de fin de
fichero. Devuelve "n/longitud", siendo "n" el número de caracteres leidos. Si "n" no es
múltiplo de "longitud", el valor almacenado en el último elemento queda indeterminado.
freopen
FILE *freopen (const char *nombre_fichero, const char *modo, FILE *flujo);
Cierra el fichero asociado con "flujo" y abre el fichero "nombre_fichero" y lo asocia a
"flujo". Devuelve "flujo" si la apertura tiene éxito; en caso contrario, devuelve un
puntero nulo.
fscanf
int fscanf (FILE *flujo, const char *formato, ...);
Lee texto y convierte a la representación interna según el formato especificado en
"formato". Devuelve el número de entradas emparejadas y asignadas, o "EOF" si no se
almacenan valores antes de que se active el indicador de error o de fin de fichero.
fseek
int fseek (FILE *flujo, long desp, int origen);
Activa el indicador de posición de "flujo" según los valores de "desp" y "origen", limpia
el indicador de fin de fichero y devuelve 0 si hay éxito.
Valores de "origen": "SEEK_SET" indica el principio de fichero, "SEEK_CUR" indica
la posición actual, "SEEK_END" indica el final de fichero.
Para un fichero binario, "desp" es un desplazamiento con signo expresado en número de
"bytes", que se añade al indicador de posición indicado por "origen".
Para un fichero de texto, el valor de "desp" puede ser 0 o el valor devuelto por "ftell".
fsetpos
int fsetpos (FILE *flujo, const fpos_t *pos);
Asigna el valor de "pos" al indicador de posición de "flujo", limpia el indicador de fin
de fichero y devuelve 0 si ha tenido éxito.
ftell
long ftell (FILE *flujo);
Devuelve una forma codificada del indicador de posición. Para un fichero binario,
devuelve elnúmero de "bytes" desde el principio de fichero. Para un fichero de texto, le
efecto depende del entorno operativo. En caso de error, devuelve -1.
fwrite
size_t fwrite(const void *p, size_t longitud, size_t nelem, FILE *flujo);
Escribe caracteres por "flujo", tomandolos a partir de la dirección "p", hasta que se
hayan escrito "longitud*nelem" caracteres o se produzca error. Devuelve "n/longitud",
siendo "n" el número de caracteres escritos.
getc
int getc (FILE *flujo);
Tiene el mismo efecto que "fgetc".

getchar
int getchar (void);
Tiene el mismo efecto que "fgetc(stdin)".
gets
char *gets (char *s);
Lee caracteres por el flujo estándar de entrada ("stdin") y los almacena en el "array" que
comienza en "s" hasta que se almacena un carácter "NL" o se active el indicador de
error o el de fin de fichero. Si almacena algún elemento, termina almacenando un
carácter nulo. Devuelve "s" si almacena algún carácter. Sustituye el carácter NL por
‘\0’.
perror
void perror (const char *s);
Escribe una línea de texto por "stderr". Escribe la cadena "s", seguida por dos puntos
(":") y un espacio. Después escribe la misma cadena que devuelve "strerror(errno)"
seguida por "NL".
printf
int printf (const char *formato, ...);
Escribe texto formateado por el flujo "stdout", según las especificaciones de "formato" y
la lista de expresiones. Devuelve el número de caracteres escritos o un valor negativo en
caso de error.
putc
int putc (int c; FILE *flujo);
Tiene el mismo efecto que "fputc".
putchar
int puchar (int c);
Tiene el mismo efecto que "fputc(c, stdout)".
puts
int puts (const char *s);
Escribe los caracteres de la cadena "s" por el flujo "stdout". Escribe un carácter "NL" en
lugar del nulo de terminación. Devuelve un valor no negativo. En caso de error,
devuelve EOF.
remove
int remove <9const char *nombre_fichero);
Elimina el fichero "nombre_fichero".
rename
int rename (const char *viejo, const char *nuevo);
Renombra al fichero de nombre "viejo", poniendole el nombre "nuevo".
rewind
void rewind (FILE *flujo)
La función llama a "fseek(flujo, 0L, SEEK_SET)" y limpia el indicador de error para
"flujo".

scanf
int scanf (const char *formato, ...);
Lee texto por el flujo "stdin" y lo almacena según las especificaciones de "formato".
Devuelve el número de valores asignados o "EOF" si se produce error o se alcanza fin
de fichero sin producirse lectura.
setbuf
void setbuf (FILE *flujo, char *buf);
Si "buf" es un puntero nulo, se desactiva el uso de "buffer", en caso contrario llama a
"setvbuf(flujo, buf_IOFBF, BUFSIZ)".
setvbuf
int setvbuf (FILE *flujo, char *buf, int modo, size_t longitud);
Establece el uso de "buffer" para "flujo". Debe invocarse después de abrir el fichero y
antes de realizar cualquier operación sobre él.
EL "modo" "_IOFBF" es para uso completo de "buffer".
El "modo" "_IOLBF" es para usar "buffer" de linea con ficheros de texto.
EL "modo" "_IONBF" es para no usar "buffer".
Si "buf" no es un puntero nulo , se tomará como la dirección base de un "array" que se
usará como "buffer". Si "buf" es nulo, se asigna otro "buffer" que será liberado al cerrar
el fichero.
size_t
typedef ui-tipo size_t;
Tipo entero sin signo que se declara para contener el resultado de "sizeof".
sprintf
int sprintf (char *s, const char *format, ...);
Genera texto formateado y lo almacena en un "array" que comienza en "s", poniendo un
carácter nulo al final.
sscanf
int sscanf (const char *s, const char *format, ...);
Lee texto formateado tomandolo del "array" que comienza en "s".
stderr
#define stderr <puntero a FILE>
Produce un puntero al flujo de salida estándar para mensajes de error.
stdin
#define stdin <puntero a FILE>
Produce un puntero al flujo de entrada estándar.
stdout
#define stdout <puntero a FILE>
Produce un puntero al flujo de salida estándar.

tmpfile
FILE *tmpfile (void);
Crea un fichero binario temporal que se elimina cuando se cierra o cuando termina la
ejecución del programa. Tiene el mismo efecto que abrir con "fopen" y "modo" "wb+".
tmpnam
char *tmpnam (char s[L_tmpnam]);
"tmpnam(NULL)" crea una cadena que sirve como nombre de fichero único y devuelve
un puntero a un "array" interno estático. Invocando "tmpnam(s)", la cadena se almacena
en "s" y se devuelve su dirección como valor de la función. Se genera un nombre
distinto cada vez que se invoca. Se garantiza un número "TMP_MAX" de nombres
distintos durante la ejecución del programa.
ungetc
int ungetc (int c, FILE *flujo);
Devuelve "c" (convertido en "unsigned char") al flujo de datos, donde podrá recuperarse
en la siguiente lectura.
vfprintf, vprintf, vsprintf

int vfprintf (FILE *flujo, const char *formato, va_list ap);
int vprintf (const char *formato, va_list ap);
int vsprintf (char *s, const char *formato, va_list ap);
Son equivalentes a las correspondientes formas de "printf", con la diferencia de que
usan la infomación de contexto designada por "ap" para acceder a los argumentos
adicionales. Con "va_start" se inicializa "ap", con "va_arg" se asigna otro valor que es
el tipo y valor del siguiente argumento. Hay que llamar a "va_end" después de haber
procesado todos los argumentos, pero antes de que termine la función.
<stdlib.h>
Contiene las declaraciones de una colección de funciones útiles y la definición de tipos
y macros
para usarlas.
EXIT_FAILURE
#define EXIT_FAILURE <expresion entera>
Produce el valor del argumento "estado" para "exit" que informa de una terminación sin
éxito.
EXIT_SUCCES
#define EXIT_SUCCES <expresion entera>
Produce el valor del argumento "estado" para "exit" que informa de una terminación con
éxito.
MB_CUR_MAX
#define MB_CUR_MAX <expresion entera 1>
Produce el máximo número de caracteres que comprende un carácter multibyte local. Su
valor es menor o igual que MB_LEN_MAX.

NULL
#define NULL <0, 0L, o (void *) 0>
Produce una constante de puntero nulo que es utilizable como una expresión de
direccionamiento constante.
RAND_MAX
#define RAND_MAX <expresion constante entera 32767>
Produce el máximo valor devuelto por "rand".
abort
void abort (void);
LLama a "raise(SIGABRT)" que produce la señal de abortar, lo que causa la
terminación anormal del programa informando al entorno operativo.
abs
int abs (int i);
Devuelve el valor absoluto de "i".
atexit
int atexit (void (*func) (void) );
Registra la función cuya dirección es "func" para ser llamada por "exit". Se pueden
registrar al menos 32 funciones. La función "exit" llama a las funciones en orden
inverso de registro.
atof
double atof (const char *s);
Convierte los caracteres de la cadena "s" a la representación interna de tipo "double" y
devuelve ese valor. Es semejante a "strtod(s,NULL)", pero no almacena necesariamente
código de error en "errno" si ocurre error de conversión.
atoi
int atoi (const char *s);
Convierte los caracteres de la cadena "s" a la representación interna de tipo "int" y
devuelve ese valor. Es semejante a "(int)strtol(s,NULL,10)", pero no se almacena
código de error en "errno".
atol
long atol (const char *s);
Convierte los caracteres de la cadena "s" a la representación interna de tipo "long" y
devuelve ese valor. Es semejante a "strtol(s,NULL,10)", pero no almacena código de
error en "errno".

bsearch
void *bsearch (const void *clave, const void *base, size_t nelem, size_t longitud,
int(*cmp) (const void *ckey, const void *celem));
Busca en eun "array" de valores ordenados en sentido creciente y devuelve la dirección
de un elemento del "array" que es igual a la clave de búsqueda "clave". Si no existe
ninguno, devuelve un puntero nulo. El "array" consiste en "nelem" elementos, de
tamaño "longitud", expresado en "bytes", empezando en la dirección "base". LLama a la
función de dirección "cmp" para comparar la clave de búsqueda con los elementos del
"array". La función debe devolver un valor negativo si la clave "ckey" es menor que el
elemento "celem", cero si son iguales y un valor positivo si la clave es mayor.
calloc
void *calloc (size_t nelem, size_t longitud);
Asigna una localización en memoria a un objeto de datos "array" que contiene "nelem"
elementos de tamaño "longitud", asigna ceros a todos los "bytes" del "array" y devuelve
la dirección del primer elemento en caso de éxito; en caso contrario, devuelve un
puntero nulo.
div
div_t div (int numer, int denom);
Divide "numer" entre "denom" y devuelve el cociente y el resto en una estructura de
tipo "div_t". El miembro "coc" es el cociente truncado hacia cero, el miembro "res" es
el resto.
div_t
typedef struct {
int coc; /* cociente */
int res; /* resto */
} div_t;
Es un tipo que se declara para contener el valor devuelto por la función "div". La
estructura contiene miembros que representan el cociente y el resto de una división
entera con signo entre operandos de tipo "int".
exit
void exit (int status);
LLama a todas las funciones registradas por "atexit", cierra todos los ficheros y
devuelve el control al entorno operativo.
free
void free (void *p);
Si "p" no es un puntero nulo, la función libera la memoria asignada al objeto de datos
cuya dirección es "p"; en caso contrario, no hace nada. Se puede liberar la memoria
asignada con "calloc", "malloc", "realloc".
getenv
char *getenv (const char *nombre);
Devuelve el valor de la variable de entorno identificada por "nombre".

labs
long labs (long i);
Devuelve el valor absoluto de "i".
ldiv
ldiv_t ldiv (long numer, long denom);
Es semejante a "div", pero aplicada a valores de tipo "long".
ldiv_t
typedef struct {
long coc; /* cociente */
long res; /* resto */
} ldiv_t;
Es un tipo estructura declarado para contener el valor que devuelve "ldiv".
malloc
void *malloc (size_t longitud);
Asigna una dirección de memoria para un objeto de datos de tamaño "longitud" y
devuelve esa dirección.
mblen
int mblen (const char *s, size_t n);
Si "s" no es un puntero nulo, devuelve el número de caracteres en la cadena multibyte
"s" que constituyen el siguiente carácter multibyte, o devuelve -1 si los siguientes n (o
los restantes caracteres) no comprenden un carácter multibyte válido.
mbstowcs
size_t mbstowcs (wchar_t *wcs, const char *s, size_t n);
Almacena una cadena de caractes amplios en elementos del "array" que empieza en
"wcs", convirtiendo, en orden, cada uno de los caracteres multibyte de la cadena
multibyte "s".
mbtowc
int mbtowc (wchar_t *pwc, const char *s, size_t n);
Si "s" no es un puntero nulo, la función determina el número de caracteres en la cadena
multibyte "s" que constituyen el siguiente carácter multibyte. Si "pwc" no es un puntero
nulo, la función convierte el siguiente carácter multibyte en su valor correspondiente de
carácter amplio y almacena este valor en "*pwc".
qsort
void qsort (void *base, size_t nelem, size_t longitud, int (*cmp) (const void *e1, const
void *e2));
Ordena un "array" que comienza en "base", compuesto por "nelem" elementos, cada
uno de los cuales tiene un tamaño de "longitud" expresado en "bytes". LLama a la
función de comparación cuya dirección es "cmp", que debe devolver un valor negativo
si "e1" es menor que "e2", 0 si son iguales y positivo si "e1" es mayor que "e2".

rand
int rand(void);
Calcula un número pseudoaleatorio "x" basado en un valor inicial (semilla) almacenado
en un objeto de datos interno de duración estática, altera el valor almacenado y devuelve
"x". El valor devuelto está comprendido en el intervalo [0,RAND_MAX].
realloc
void *realloc (void *p, size_t longitud);
Cambia el tamaño de la memoria apuntada por "p" al que se indica con "longitud".
Asigna una dirección de memoria para un objeto de datos de tamaño "longitud",
copiando los valores almacenados en "p". Devuelve la nueva dirección de memoria
asignada.
size_t
Es el tipo entero sin signo que se declara para contener el resultado del operador
"sizeof".
srand
void srand (unsigned semilla);
Utiliza "semilla", en un objeto de datos de duración estática, para generar una secuencia
de números pseudoaleatorios con "rand".
strtod
double strtod (const char *s, char **finptr);
Convierte los caracteres iniciales de una cadena "s" en la correspondiente
representación interna de tipo "double" y devuelve ese valor. Si "finptr" no es un
puntero nulo, la función almacena en él un puntero al resto de la cadena que no se ha
convertido.
strtol
long strtol (const char *s, char **finptr, int base);
Convierte los caracteres iniciales de una caena "s" en la correspondiente representación
interna de tipo "long" y devuelve ese valor. SI "finptr" no es un puntero nulo, la función
almacena en él un puntero al resto de la cadena que no se ha convertido.
strtoul
unsigned strtoul (const char *s, char **finptr, int base);
Es semejante a "strtol", pero aplicada al tipo "unsigned long".
system
int system (const char *s);
Si "s" no es un puntero nulo, se pasa la cadena "s" para que sea ejecutada por el
intérprete de comandos del entorno operativo, y devuelve la información de estado
proporcionada por el intérprete. Si "s" es un puntero nulo, la función devuelve un valor
distinto de cero si existe intérprete de comandos en el entorno operativo.
wchar_t
typedef i-tipo wchar_t;
Es el tipo entero de la constante de caracteres amplios L'X'. Se declara un objeto de
datos de tipo "wchar_t" para almacenar un carácter amplio.

wcstombs
size_t wcstombs (char *s, const wchar_t *wcs, size_t n);
Almacena una cadena multibyte en sucesivos elementos del "array" que comienza en
"s",convirtiendo, en orden, cada uno de los caracteres amplios en la cadena "wcs".
wctomb
int wctomb (char *s, wchar_t wchar);
Si "s" no es un puntero nulo, la función determina y devuelve el número de caracteres
que se necesitan para representar el carácter multibyte correspondiente al carácter
amplio "wchar". La función convierte "wchar" en su correspondiente carácter multibyte
almacenándolo en el "array s".

<string.h>
Contiene la declaración de una colección de funciones útiles para manejar cadenas y
otros arrays de caracteres.
NULL
Produce una constante de puntero nulo que es utilizable como una expresión de
direccionamiento constante.
memchr
void *memchr (const void *s, int c, size_t n);
Busca el primer elemento de un "array de unsigned char" que es igual a "(unsigned
char) c". El "array" comienza en "s" y tiene "n" elementos. En caso de éxito, devuelve la
dirección de elemento buscado; en caso contrario, devuelve un puntero nulo.
memcmp
int memcmp (const void *s1, const void *s2, size_t n);
Compara los elementos de dos "arrays de unsined char", con direcciones base "s1" y
"s2", y "n" elementos, hasta que encuentra elementos diferentes. Si todos los elementos
son iguales, devuelve 0. Si el elemento diferente de "s1" es mayor que el de "s2",
devuelve un valor positivo; en caso contrario, devuelve un valor negativo.
memcpy
void *memcpy (void *s1, const void *s2, size_t n);
Copia el "array de char" que empieza en "s2" en el "array de char" que empieza en "s1".
Devuelve "s1".
memmove
void *memmove (void *s1, const void *s2, size_t n);
Tiene el mismo efecto que "memcpy", pero actúa incluso si los "arrays" se solapan. En
este caso, se accede a cada valor de "s2" antes de almacenar un nuevo valor en ese
elemento.
memset
void *memset (void *s, int c, size_t n);
Almacena "(unsigned char) c" en cada uno de los elementos del "array de unsigned
char" que empieza en "s" y tiene "n" elementos. Devuelve "s".
size_t
Es el tipo entero sin signo de un objeto de datos declarado para contener el resultado del
operador "sizeof".
strcat
char *strcat (char *s1, const char *s2);
Copia la cadena "s2", incluyendo el nulo de terminación, en elementos sucesivos del
"array de char" que almacena la cadena "s1", empezando en el elemento que almacena
el nulo de terminación de "s1". Devuelve "s1".

strchr
char *strchr (const char *s, int c);
Busca el primer elemento de la cadena "s" que sea igual a "(char)c". Considera el nulo
de terminación como parte de la cadena. En caso de éxito, devuelve la dirección del
elemento emparejado; en caso contrario, devuelve un puntero nulo.
strcmp
int strcmp (const char *s1, const char *s2);
Compara los elementos de dos cadenas "s1" y "s2" hasta que encuentra elementos
diferentes. Si todos son iguales, devuelve 0. Si el elemento diferente de "s1" es mayor
que el de "s2", devuelve un valor mayor que cero; en caso contrario, devuelve un valor
menor que cero.
strcoll
int strcoll (const char *s1, const char *s2);
Compara dos cadenas "s1" y "s2" utilizando una secuencia de ordenación especial
diferente de la ASCII.
strcpy
char *strcpy (char *s1, const char *s2);
Copia la cadena "s2", incluyendo el nulo, en el "array de char" que comienza en "s1".
Devuelve "s1".
strcspn
size_t strcspn (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" de la cadena "s1" que sea igual a cualquiera de los
elementos de la cadena "s2" y devuelve "i".
strerror
char *strerror (int codigo_error);
Devuelve un puntero a un objeto de datos interno de duración estática que contiene el
mensaje correspondiente al código de error "codigo_error".
strlen
size_t strlen (const char *s);
Devuelve el número de caracteres de la cadena "s", sin incluir el nulo de terminación.
strncat
char *strncat (char *s1, const char *s2, size_t n);
Copia "n" elementos de la cadena "s2" en la cadena "s1" a partir de su nulo de
terminación. Al final pone el nulo de terminación y devuelve "s1".
strncmp
int strncmp (const char *s1, const char *s2, size_t n);
Compara los elementos de las cadenas "s1" y "s2" hasta que encuentra alguno diferente
o hasta que se han comparado "n" elementos. Si todos los elementos son iguales,
devuelve 0. Si el elemento diferente de "s1" es mayor que el de "s2" (tomados como
"unsigned char"), devuelve un número positivo. En caso contrario, devuelve un número
negativo.

strncpy
char *strncpy (char *s1, const char *s2, size_t n);
Copia la cadena "s2", sin incluir el nulo, en la cadena "s1". Copia no más de "n"
caracteres de "s2". Entonces almacena, cero o más caracteres nulos si son necesarios
para completar un total de "n" caracteres. Devuelve "s1".
strpbrk
char *strpbrk (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" en la cadena "s1" que sea igual a cualquiera de los
elementos de "s2". Si "s1[i]" no es el nulo de terminación, devuelve "&s1[i]"; en caso
contrario, devuelve un puntero nulo.
strrchr
char *strrchr (const char *s, int c);
Busca el último elemento de la cadena "s" que es igual a "(char)c". En caso de éxito,
devuelve la dirección de tal elemento; en caso contrario, devuelve un puntero nulo.
strspn
size_t strspn (const char *s1, const char *s2);
Busca el primer elemento "s1[i]" en la cadena "s1" que no sea igual a ninguno de los
elementos de "s2" y devuelve "i".
strstr
char *strstr (const char *s1, const char *s2);
Busca la primera secuencia de elementos en la cadena "s1" que se empareje con los
elementos de la cadena "s2", sin incluir su nulo. En caso de éxito, devuelve la dirección
del primer elemento emparejado; en caso contrario, devuelve un puntero nulo.
strtok
char *strtok (char *s1, const char *s2);
Permite separar una cadena "s1" en partes usando como delimitadores los caractes de
otra "s2". Cada vez que se invoca, devuelve un puntero a la siguiente palabra de la
cadena "s1".
Devuelve un puntero nulo cuando no existe ninguna palabra que devolver.
La primera vez que se llama a "strtok", se utiliza realmente "s1" en la llamada. Las
llamadas posteriores utilizan un puntero nulo como primer argumento. Se puede usar un
conjunto diferente de delimitadores en cada llamada.
Esta función modifica la cadena "s1". Cada vez que se encuentra una palabra, se pone
un carácter nulo donde estaba el delimitador.
strxfrm
size_t strxfrm (char *s1, const char *s2, size_t n);
Se usa en entornos de lenguajes extranjeros que no utilicen el secuenciamiento ASCII.
Transforma los "n" primeros elementos de la cadena "s2" para que pueda usarse con la
función "strcmp". La función "strxfrm" coloca entonces el resultado en la cadena "s1".
Después de la transformación, el resultado de "strcmp" con "s1" y de "strcoll" con la
cadena original "s2" será el mismo. La función devuelve la longitud de la cadena
transformada.

<time.h>
Contiene la declaración de algunas funciones para manejar fechas. Las funciones
comparten dos objetos de datos de duración estática, una cadena de tiempo de tipo
"array de char" y una estructura de tiempo de tipo "struct tm".
CLOCKS_PER_SECOND
#define CLOCKS_PER_SECOND <valor_aritmetico>
Produce el número de pulsos de reloj, devuelto por "clock" en un segundo.
NULL
Produce una constante de puntero nulo que se puede utilizar como una expresión
constante de direccionamiento.
asctime
char *asctime (const struct tm *tp);
Convierte la información almacenada en la estructura apuntada por "tp" en una cadena
de caracteres que expresa la fecha y hora en lengua inglesa con la forma: Mon Apr 12
09:12:05 1993\n\0. Devuelve la dirección de la cadena.
El puntero que se pasa, "tp", puede obtenerse con "localtime" o con "gmtime".
clock
clock_t clock (void);
Devuelve el número de pulsaciones de reloj de un lapso de tiempo del procesador,
contando desde el momento de arranque del programa. Devuelve "-1" si el entorno
operativo no puede hacer esa medida.
clock_t
typedef a-tipo clock_t;
Es el tipo aritmético "a-tipo" de un objeto de datos que se declara para contener el valor
que devuelve "clock". El valor representa el lapso de tiempo del procesdor.
ctime
char *ctime (const time_t *cal);
Convierte el tiempo de calendario que está en "*cal" a una representación de texto de la
hora local. Es equivalente a "asctime(localtime(cal))". La hora de calendario se obtiene
normalmente con una llamada a "time".
difftime
double difftime (time_t t1, time_t t0);
Devuelve la diferencia, en segundos, entre los tiempos de calendario "t0" y "t1".
gmtime
struct tm *gmtime (const time_t *tod);
Almacena en la estructura de tiempo una codificación del tiempo de calendario
apuntado palmacenado en "*tod", expresado en Tiempo Universal Coordinado (UTC,
antes GMT). Devuelve la dirección a la estructura de tiempo.
El valor de "*tod" se obtiene normalmente llamando a "time".

localtime
struct tm *gmtime (const time_t *tod);
Almacena en la estructura de tiempo una codificación del tiempo de calendario
almacenado en "*tod", expresado como hora local. Devuelve la dirección de la
estructura. El valor de "*tod" se obtiene normalmente llmando a "time".
mktime
time_t mktime (struct tm *tp);
Devuelve la hora de calendario,con la representación propia de "time", correspondiente
a la hora local almacenada en la estructura apuntada por "tp". Devuelve "-1" si la
información no corresponde a una hora de calendario válida.
size_t
Es el tipo entero sin signo de un objeto de datos que se declara para contener el
resultado del operador "sizeof".
strftime
size_t strftime (char *s, size_t n, const char *formato, const struct tm *tp);
Toma los valores de la estructura de tiempo apuntada por "tp" y genera texto
formateado, según las especificaciones de "formato", almacenandolo en la cadena "s" de
tamaño "n". Hay 22 especificaciones de formato.
time
time_t time (time_t *tod);
Devuelve la hora actual de calendario del sistema. Si el entorno operativo no puede
determinarla, devuelve "-1". Si "tod" no es un puntero nulo, la hora también queda
asignada a "*tod".
time_t
typedef a-tipo time_t;
Es el tipo aritmético de un objeto de datos que se declara para almacenar el valor
devuelto por "time". El valor representa la hora de calendario.
tm
struct tm {
int tm_sec; /* segundos después del minuto, 0-59 */
int tm_min; /* minutos después de la hora, 0-59 */
int tm_hour; /* hora del día, 0-23 */
int tm_mday; /* día del mes, 1-31 */
int tm_mon; /* mes del año, 0-11 */
int tm_year; /* años desde 1900 */
int tm_wday; /* días desde el domingo, 0-6 */
int tm_yday; /* día del año, 0-365 */
int tm_isdst; /* indicador de ajuste horario */
};
Se utiliza para mantener la fecha y hora separadas en sus compoentes.
El miembro "tm_isdst" tiene un valor positivo si el ejuste horario es efectivo, tiene el
valor "0" si no es efectivo o un valor negativo si el entorno operativo no puede
determinar su estado.

Lenguaje C PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lenguaje C PDF

Uploaded by

Copyright:

Available Formats

INFORMÁTICA

Visual C – Lenguaje C ARI Página 1

1.2.- Mi primer programa en C.

1.3.- Elementos básicos de un programa de C.

Algunas características del C son:

 Es un lenguaje de propósito general porque no está enfocado a hacer un tipo

Para crear un programa en C se deben seguir los siguientes pasos:

1. Escribirlo en uno o más ficheros de texto de una forma reconocible por el

2. Compilarlo. Los ficheros fuente se compilan creando ficheros de código

Visual C – Lenguaje C ARI Página 2

3. Enlazarlo. Se unen todos los programas (.OBJ y .LIB) mediante el

4. Depurarlo. Se comprueba si hay errores.

5. Ejecutarlo. Si funciona correctamente, como nosotros queremos, el

El entorno de desarrollo integrado de Visual C++ proporciona facilidades para

1.2.- Mi primer programa en C.

En programación, la experiencia es la gran maestra. Por ello, es conveniente hacer

1ª línea /* Programa 001 */

2ª línea // Programa que escribe una frase

3ª línea # include <stdio.h>

4ª línea void main (void)

6ª línea printf( “Mi primer programa en C.” );

Visual C – Lenguaje C ARI Página 3

1. Si hemos creado un icono de acceso directo en el escritorio hacemos doble clic

3. En el menú Archivo, seleccionamos Nuevo y, a continuación, hacemos clic en

Visual C – Lenguaje C ARI Página 4

5. En Nombre escribimos el nombre del proyecto. En nuestro caso Programa001.

De forma predeterminada, la solución que contiene el proyecto tiene el mismo

Hacemos clic en Aceptar para crear el nuevo proyecto y aparece la siguiente

Visual C – Lenguaje C ARI Página 5

7. En el Asistente para aplicaciones Win32 en el apartado Tipo de aplicación

8. En la siguiente pantalla, si el Explorador de soluciones no está visible, hacemos

9. Para agregar un nuevo archivo de código fuente, en el Explorador de

Visual C – Lenguaje C ARI Página 6

En Plantillas, Plantillas instaladas de Visual Studio, hacemos clic en Archivo

Antes de escribir el código debemos agregar un Archivo de Encabezado. Para

Aparece la siguiente pantalla y en Plantillas, Plantillas instaladas en Visual

Visual C – Lenguaje C ARI Página 7

Es momento de escribir el código del programa. El archivo Programa001.cpp

Visual C – Lenguaje C ARI Página 8

11. En el menú Depurar, hacemos clic en Generar solución . También desde el

Visual C – Lenguaje C ARI Página 9

12. En el menu Depurar, hacemos clic en Iniciar depuración o F5.

Nos da un “pantallazo” y no vemos nada. Para que esto no ocurra debemos

Visual C – Lenguaje C ARI Página 10

1ª línea Mediante /* …… */ podemos insertar comentarios en el programa (Los

3ª línea Contiene una referencia a un archivo especial (stdio.h) que contiene

4ª línea Los programas en C están compuestos de unidades de programa llamadas

Todos los programas en C deben tener la función main (significa en

Los paréntesis que siguen a main la identifican como nombre de función.

Un método de comunicación de datos entre las funciones es el uso de los

5ª línea Apertura de llave. Comienza el programa.

7ª Cierre de llave. Finaliza el programa.

Visual C – Lenguaje C ARI Página 11

Dentro de la carpeta Programa001 nos interesa el programa llamado Programa001.cpp.

Dentro de la carpeta Debug se encuentra el programa Programa001.exe (Tipo

Visual C – Lenguaje C ARI Página 12

1ª línea /* Programa 002 */

2ª línea // Programa que escribe dos frases

3ª línea # include <stdio.h>

4ª línea void main (void)

6ª línea printf( “Mi primer programa en C.\n” );

7ª línea printf(“Me llamo Javier”);

Hay dos novedades respecto al primer ejemplo: