Documentos de Académico
Documentos de Profesional
Documentos de Cultura
C1
C1
ar
MANUAL DE VISUAL C+
Autor : Ricardo Amezua Martinez
1-INTRODUCCIN
C est caracterizado por ser de uso general, de sintaxis sumamente compacta y de alta portabilidad. Es un
lenguaje de nivel medio porque combina elementos de lenguajes de alto nivel, manipulacin de bits, bytes,
direcciones y elementos bsicos como nmeros y caracteres.
La portabiblidad significa que es posible adaptar el software escrito para un tipo de computadora o sistema
operativo en otro. C no lleva a cabo comprobaciones de errores en tiempo de ejecucin, es el programador el
nico responsable de llevar a cabo esas comprobaciones
Se trata de un lenguaje estructurado, que es la capacidad de un lenguaje de seccionar y esconder del
resto del programa toda la informacin y las instrucciones necesarias para llevar a cabo un determinada tarea.
Un lenguaje estructurado permite colocar las sentencias en cualquier parte de una lnea. Todos los lenguaje
modernos tiende a ser estructurados.
El componente estructural principal de C es la funcin, subrutina independiente que permiten definir tareas
de un programa y codificarlas por separado haciendo que los programas sean modulares. Otra forma de
estructuracin es el bloque de cdigo que es un grupo de sentencias conectadas de forma lgica que es
tratado como una unidad.
El compilador de C lee el programa entero y lo convierte a cdigo objeto o cdigo mquina. Una vez
compilado, las lneas de cdigo fuente dejan de tener sentido durante la ejecucin. Este cdigo maquina puede
ser directamente ejecutado por la computadora. El compilador de C incorpora una biblioteca estndar que
proporciona las funciones necesarias para llevar a cabo las tareas ms usuales. En C se puede partir un
programa en muchos archivos y que cada uno sea compilado por separado.
En la compilacin de un programa consiste en tres pasos. Creacin del cdigo fuente, Compilacin del
programa y Enlace del programa con las funciones necesarias de la biblioteca. La forma en que se lleve a cabo
el enlace variar entre distintos compiladores y entornos, pero la forma general es:
1. PRIMER PROGRAMA
La mejor forma de aprender a programar en cualquier lenguaje es editar, compilar, corregir y ejecutar
pequeos programas descriptivos. Todos los programas en C consisten en una o ms funciones, la nica
funcin que debe estar presente es la denominada main(), siendo la primera funcin que se invoca cuando
comienza la ejecucin del programa.
2. VARIABLES Y CONSTANTES
Unidad bsica de almacenamiento, la creacin es la combinacin de un identificador, un tipo y un mbito.
Todas las variables en C tienen que ser declaradas antes de ser usadas. El lugar donde se declaran las
variables puede ser dentro o en la definicin de una funcin, fuera de todas las funciones.
TIPOS
RANGO
TAMAO
DESCRIPCIN
char
-128 a 127
unsigned char
0 a 255
int
-32.768 a 32.767
unsigned int
0 a 65.535
long int
2.147.483.647
0 a 4.294.967.295
float
3.4E-38 decimales(6)
double
1.7E-308 decimales(10)
long double
3.4E-4932 decimales(10)
10
El nombre de las variables conocido como identificadores debe cumplir las siguientes normas. La longitud
puede ir de un carcter a 31. El primero de ellos debe ser siempre una letra. No puede contener espacios en
blanco, ni acentos y caracteres gramaticales. Hay que tener en cuenta que el compilador distingue entre
maysculas y minsculas.
SINTAXIS:
tipo nombre=valor_numerico;
tipo nombre=letra;
tipo nombre[tamao]=cadena de letras,
tipo nombre=valor_entero.valor_decimal;
CONVERSION (casting): Las conversiones automticas pueden ser controladas por el programador.
Bastar con anteponer y encerrar entre parentesis, el tipo al que se desea convertir. Este tipo de conversiones
solo es temporal y la variable a convertir mantiene su valor.
SINTAXIS:
variable_destino=(tipo)variable_a_convertir;
variable_destino=(tipo) (variable1+variable2+variableN);
EJEMPLO: convertimos 2 variables float para guardar la suma en un entero.
#include<stdio.h>
void main(void)
{
float num1=25.75, num2=10.15;
int total=0;
clrscr();
total=(int)num1+(int)num2;
// total=(int)(num1+num2);
printf(Total: %d,total);
getch();
}
AMBITO DE VARIABLE: Segn el lugar donde se declaren las variables tendrn un mbito. Segn el
mbito de las variables pueden ser utilizadas desde cualquier parte del programa o nicamente en la funcin
donde han sido declaradas. Las variables pueden ser:
LOCALES: Cuando se declaran dentro de una funcin. Las variables locales slo pueden ser
referenciadas (utilizadas) por sentencias que estn dentro de la funcin que han sido declaradas. No son
conocidas fuera de su funcin. Pierden su valor cuando se sale y se entra en la funcin. La declaracin es
como siempre.
GLOBALES: Son conocidas a lo largo de todo el programa, y se pueden usar desde cualquier parte del
cdigo. Mantienen sus valores durante toda la ejecucin. Deban ser declaradas fuera de todas las funciones
incluida main(). La sintaxis de creacin no cambia nada con respecto a las variables locales. Inicialmente
toman el valor 0 o nulo, segn el tipo.
DE REGISTRO: Otra posibilidad es, que en vez de ser mantenidas en posiciones de memoria del
ordenador, se las guarde en registros internos del microprocesador. De esta manera el acceso a ellas es ms
directo y rpido. Para indicar al compilador que es una variable de registro hay que aadir a la declaracin la
palabra register delante del tipo. Solo se puede utilizar para variables locales.
ESTTICAS: Las variables locales nacen y mueren con cada llamada y finalizacin de una funcin, sera
til que mantuvieran su valor entre una llamada y otra sin por ello perder su mbito. Para conseguir eso se
aade a una variable local la palabra static delante del tipo.
EXTERNAS: Debido a que en C es normal la compilacin por separado de pequeos mdulos que
componen un programa completo, puede darse el caso que se deba utilizar una variable global que se conozca
en los mdulos que nos interese sin perder su valor. Aadiendo delante del tipo la palabra extern y definindola
en los otros mdulos como global ya tendremos nuestra variable global.
TIPOS DEFINIDOS POR EL USUARIO: C permite explcitamente nuevos nombres para tipos de datos.
Realmente no se crea un nuevo tipo de dato, sino que se define un nuevo nombre para un tipo existente. Esto
ayuda a hacer ms transportables los programas con dependencias con las mquinas, solo habr que cambiar
las sentencias typedef cuando se compile en un nuevo entorno.
SINTAXIS:
tydef tipo nuevo_nombre;
nuevo_nombre nombre_variable[=valor];
EJEMPLO:
#include<stdio.h>
void func1(void);
int numero;
extern int numero1;
void main(void)
{
int numero3=10;
static int numero4=20;
register int numero5=30;
clrscr();
printf(%d %d %d %d %d\n,numero,numero1,
numero2,numero3,numero4,numero5);
func1();
getch();
}
void func1(void)
{
printf(Las globales, que aqu se conocen);
printf(%d %d,numero,numero1);
}
LAS CONSTANTES: Se refieren a los valores fijos que no pueden ser modificados por el programa.
Pueden ser de cualquier tipo de datos bsicos. Las constantes de carcter van encerradas en comillas simples.
Las constantes enteras se especifican con nmeros sin parte decimal y las de coma flotante con su parte
entera separada por un punto de su parte decimal.
SINTAXIS:
const tipo nombre=valor_entero;
const tipo nombre=valor_entero.valor_decimal;
const tipo nombre=carcter;
La directiva #define es un identificador y una secuencia de caracteres que sustituir se sustituir cada vez
que se encuentre ste en el archivo fuente. Tambin pueden ser utilizados para definir valores numricos
constantes.
SINTAXIS:
#define IDENTIFICADOR valor_numerico
#define IDENTIFICADOR cadena
EJEMPLO:
#include<stdio.h>
#define EURO 166.386
#define TEXTO "Esto es una prueba"
const int peseta=1;
void main(void)
{
clrscr();
printf("El valor del Euro es %.3f ptas",EURO);
printf("\nEl valor de la Peseta es %d pta",peseta);
printf("\n%s",TEXTO);
printf(Ejemplo de constantes y defines);
getch();
}
3. OPERADORES
C es un lenguaje muy rico en operadores incorporados, es decir, implementados al realizarse el
compilador. Define cuatro tipos de operadores: aritmticos, relacionales, lgicos y a nivel de bits. Tambin se
definen operadores para realizar determinadas tareas, como las asignaciones.
ASIGNACION (=): En C se puede utilizar el operador de asignacin en cualquier expresin valida. Solo
con utilizar un signo de igualdad se realiza la asignacin. El operador destino (parte izquierda) debe ser
siempre una variable, mientras que en la parte derecha puede ser cualquier expresin valida. Es posible
realizar asignaciones mltiples, igualar variables entre si y a un valor.
SINTAXIS:
variable=valor;
variable=variable1;
variable=variable1=variable2=variableN=valor;
ARITMTICOS: Pueden aplicarse a todo tipo de expresiones. Son utilizados para realizar operaciones
matemticas sencillas, aunque unindolos se puede realizar cualquier tipo de operaciones. En la siguiente
tabla se muestran todos los operadores aritmticos.
OPERADOR
DESCRIPCIN
ORDEN
Resta.
Suma
Multiplica
Divide
signo (monario).
--
Decremento en 1.
++
Incrementa en 1.
LGICOS Y RELACIONALES: Los operadores relacionales hacen referencia a la relacin entre unos
valores y otros Los lgicos se refiere a la forma en que esas relaciones pueden conectarse entre si. Los
veremos a la par por la estrecha relacin en la que trabajan.
OPERADORES RELACIONALES
OPERADOR
DESCRIPCIN
OPERADORES LGICOS
ORDEN
OPERADOR
DESCRIPCIN
ORDEN
<
Menor que.
&&
Y (AND)
10
>
Mayor que.
||
O (OR)
11
<=
Menor o igual.
NO (NOT)
>=
Mayor o igual
==
Igual
! =
Distinto
A NIVEL DE BITS: Estos operadores son la herramienta ms potente, pueden manipular internamente
las variables, es decir bit a bit. Este tipo de operadores solo se pueden aplicar a las variables de tipo char,
short, int y long. Para manejar los bits debemos conocer perfectamente el tamao de las variables.
OPERADOR
DESCRIPCIN
ORDEN
&
O (OR) Inclusiva.
O (OR) Exclusiva.
<<
Desplazamiento a la izquierda.
>>
Desplazamiento a la derecha.
En las siguientes tablas se muestran todos los identificadores de formato y las constantes de carcter las
que se utilizan para realizar operaciones automticamente sin que el usuario tenga que intervenir en esas
operaciones.
IDENTIFICADORES DE FORMATO
IDENTIFICADOR
DESCRIPCION
CONSTANTES DE CARCTER
CONSTANTE
DESCRIPCION
%c
Carcter
\n
Salto de lnea
%d
Entero
\f
Salto de pgina
%e
N. Cientfica
\r
Retorno de carro
%E
N. Cientfica
\t
Tabulacin
%f
Coma flotante
\b
Retroceso
%o
Octal
Comilla simple
%s
Cadena
Comillas
%u
Sin signo
\\
Barra invertida
%x
Hexadecimal
\?
Interrogacin
%X
Hexadecimal
%p
Puntero
%ld
Entero Largo
%h
Short
%%
signo %
Existen especificadores de formato asociados a los identificadores que alteran su significado ligeramente.
Se puede especificar la longitud mnima, el nmero de decimales y la alineacin. Estos modificadores se sitan
entre el signo de porcentaje y el identificador.
% modificador identificador
El especificador de longitud mnima hace que un dato se rellene con espacios en blanco para asegurar
que este alcanza una cierta longitud mnima. Si se quiere rellenar con ceros o espacios hay que aadir un cero
delante antes del especificador de longitud.
printf(%f ,numero); //salida normal.
printf(%10f ,numero); //salida con 10 espacios.
printf(%010f ,numero); //salida con los espacios poniendo 0.
El especificador de precisin sigue al de longitud mnima(si existe). Consiste en un nulo y un valor entero.
Segn el dato al que se aplica su funcin varia. Si se aplica a datos en coma flotante determina el nmero de
posiciones decimales. Si es a una cadena determina la longitud mxima del campo. Si se trata de un valor
entero determina el nmero mnimo de dgitos.
printf(%10.4f ,numero); //salida con 10 espacios con 4 decimales.
printf(%10.15s,cadena); //salida con 10 caracteres dejando 15 espacios.
printf(%4.4d,numero); //salida de 4 dgitos mnimo.
El especificador de ajuste fuerza la salida para que se ajuste a la izquierda, por defecto siempre lo muestra
a la derecha. Se consigue aadiendo despus del porcentaje un signo menos.
printf(%8d,numero); // salida ajustada a la derecha.
printf(%-8d,numero); //salida ajustada a la izquierda.
SCANF: Es la rutina de entrada por consola. Puede leer todos los tipos de datos incorporados y convierte
los nmeros automticamente al formato incorporado. En caso de leer una cadena lee hasta que encuentra un
carcter de espacio en blanco. El formato general:
scanf(identificador,&variable_numerica o char);
scanf(identificador,variable_cadena);
La funcin scanf() tambin utiliza modificadores de formato, uno especifica el nmero mximo de
caracteres de entrada y eliminadores de entrada.. Para especificar el nmero mximo solo hay que poner un
entero despus del signo de porcentaje. Si se desea eliminar entradas hay que aadir %*c en la posicin
donde se desee eliminar la entrada.
scanf(%10s,cadena);
scanf(%d%*c%d,&x,&y);
En muchas ocasiones se combinaran varias funciones para pedir datos y eso puede traer problemas para
el buffer de teclado, es decir que asigne valores que no queramos a nuestras variables. Para evitar esto hay
dos funciones que se utilizan para limpiar el buffer de teclado.
fflush(stdin);
fflushall();
OTRAS FUNCIONES E/S: El archivo de cabecera de todas estas funciones es STDIO.H. Todas estas
funciones van a ser utilizadas para leer caracteres o cadenas de caracteres. Todas ellas tienen asociadas una
funcin de salida por consola.
FUNCIONES
DESCRIPCIN
var_char=getchar();
var_char=getche();
var_char=getch();
gets(var_cadena);
putchar(var_char);
puts(variables);
5. SENTENCIAS DE CONTROL
Es la manera que tiene un lenguaje de programacin de provocar que el flujo de la ejecucin avance y se
ramifique en funcin de los cambios de estado de los datos.
IF-ELSE: La ejecucin atraviese un conjunto de estados bolean que determinan que se ejecuten distintos
fragmentos de cdigo.
if (expresion-booleana)
Sentencia1;
else
Sentencia2;
if (expresion-booleana)
{
Sentencia1;
sentencia2;
}
else
Sentencia3;
La clusula else es opcional, la expresin puede ser de cualquier tipo y ms de una (siempre que se unan
mediante operadores lgicos).Otra opcin posible es la utilizacin de if anidados, es decir unos dentro de otros
compartiendo la clusula else.
Un operador muy relacionado con la sentencia if es ?. Es un operador ternario que puede sustituir al if.
El modo de trabajo es el siguiente, evala la primera expresin y si es cierta toma el valor de la segunda
expresin y se le pasa a la variable. Si es falsa, toma el valor de la tercera y la pasa a la variable
varible=condicion ? expresion2:expresion3;
EJEMPLO:
#include <stdio.h>
void main(void)
{
int peso;
clrscr();
gotoxy(5,3);printf(Introducir edad: );
gotoxy(22,3);scanf(%d,&peso);
if(peso<500)
{
gotoxy(5,5);
printf(No es ni media Tn);
}
else
{
gotoxy(5,5);
pritnf(Es ms de media Tn);
}
getch();
}
Para probar la utilizacin de un if anidado realizar un programa que pida una edad. Si la edad es igual o
menor a 10 poner el mensaje NIO, si la edad es mayor a 65 poner el mensaje JUBILADO, y si la edad es
mayor a 10 y menor o igual 65 poner el mensaje ADULTO.
SWITCH: Realiza distintas operaciones en base al valor de una nica variable o expresin. Es una
sentencia muy similar a if-else, pero esta es mucho ms cmoda y fcil de comprender. Si los valores con los
que se compara son nmeros se pone directamente el pero si es un carcter se debe encerrar entre comillas
simples.
switch (expresin){
case valor1:
sentencia;
break;
case valor2:
sentencia;
break;
case valor3:
sentencia;
break;
case valorN:
sentencia;
break;
default:
}
El valor de la expresin se compara con cada uno de los literales de la sentencia case si coincide alguno
se ejecuta el cdigo que le sigue, si ninguno coincide se realiza la sentencia default (opcional), si no hay
sentencia default no se ejecuta nada.
La sentencia break realiza la salida de un bloque de cdigo. En el caso de sentencia switch realiza el
cdigo y cuando ejecuta break sale de este bloque y sigue con la ejecucin del programa. En el caso que
varias sentencias case realicen la misma ejecucin se pueden agrupar, utilizando una sola sentencia break.
switch (expresin){
case valor1:
case valor2:
case valor5:
sentencia;
break;
case valor3:
case valor4:
sentencia;
break;
default:
}
EJEMPLO:
#include <stdio.h>
void main(void)
{
int opcion;
clrscr();
pritnf(1.ALTAS\n);
pritnf(2.BAJAS\n);
pritnf(3.MODIFICA\n);
pritnf(4.SALIR\n);
pritnf(Elegir opcin: );
scanf(%d,&opcion);
switch(opcion)
{
case 1:
printf(Opcin Uno);
break;
case 2:
printf(Opcin Dos);
break;
case 3:
printf(Opcin Tres);
break;
case 4:
printf(Opcin Salir);
break;
default:
printf(Opcin incorrecta);
}
getch();
}
WHILE: Ejecuta repetidamente el mismo bloque de cdigo hasta que se cumpla una condicin de
terminacin. Hay cuatro partes en cualquier bucle. Inicializacin, cuerpo, iteracin y terminacin.
[inicializacin;]
while(terminacin){
cuerpo;
[iteracin;]
}
DO-WHILE: Es lo mismo que en el caso anterior pero aqu como mnimo siempre se ejecutara el cuerpo
una vez, en el caso anterior es posible que no se ejecute ni una sola vez.
[inicializacin;]
do{
cuerpo;
[iteracin;]
}while(terminacin);
EJEMPLO:Este programa va sumando nmeros y el resultado lo suma a otro, as hasta 100.000.
#include <stdio.h>
void main(void)
{
int n1=0,n2=1,n3;
printf("Numero de Fibonacci: %d %d\n",n1,n2);
do{
n3=n1+n2;
n1=n2+n3;
n2=n1+n3;
printf("%d %d %d\n",n3,n1,n2);
}while(n1<1000000 && n2<1000000 && n3<1000000);
}
FOR: Realiza las mismas operaciones que en los casos anteriores pero la sintaxis es una forma compacta.
Normalmente la condicin para terminar es de tipo numrico. La iteracin puede ser cualquier expresin
matemtica valida. Si de los 3 trminos que necesita no se pone ninguno se convierte en un bucle infinito.
for (inicio;fin;iteracin)
sentencia1;
for (inicio;fin;iteracin)
{
sentencia1;
sentencia2;
}
EJEMPLO: Este programa muestra nmeros del 1 al 100. Utilizando un bucle de tipo FOR.
#include<stdio.h>
void main(void)
{
int n1=0;
for (n1=1;n1<=100;n1++)
printf("%d\n",n1);
getch();
}
La sentencia continue lo que hace es ignorar las sentencias que tiene el bucle y saltar directamente a la
condicin para ver si sigue siendo verdadera, si es as sigue dentro del bucle, en caso contrario saldra
directamente de el.
La sentencia exit() tiene una operatoria ms drstica, que la sentencia break, en vez de saltear una
iteracin, esta abandona directamente el programa dndolo por terminado. Aparte realiza operaciones tiles
como cerrar cualquier archivo que estuviera abierto, vaciado de buffers. Se suele utilizar cuando se desea
abandonar programas cuando se produce algn error fatal e inevitable.
Otra funcin relacionada con los bucles es kbhit(), lo que hace esta funcin es la detectar el momento en
que se pulsa una tecla (cualquiera). Devuelve 0 cuando NO SE HA PULSADO ninguna tecla, cuando SE
PULSA una tecla devuelve cualquier valor DISTINTO DE 0.
EJEMPLO: Muestra nmeros hasta que se pulsa una tecla.
#include <stdio.h>
void main(void)
{
long num=0;
clrscr();
for( ; ; )
{
num++;
printf(%ld\n,num);
if(kbhit())
exit();
}
getch();
}
6. ARRAYS Y CADENAS
Un array es una coleccin de variables del mismo tipo que se referencian por un nombre en comn. A un
elemento especifico de un array se accede mediante un ndice. Todos los array constan de posiciones de
memoria contiguas. La direccin mas baja corresponde al primer elemento. Los arrays pueden tener de una a
varias dimensiones.
UNIDIMENSIONALES
El array ms comn en C es la cadena (array de caracteres terminado por un nulo). Todos los array tienen
el 0 como primer elemento. Hay que tener muy presente el no rebasar el ltimo ndice. La cantidad de memoria
requerida para guardar un array est directamente relacionada con su tipo y su tamao.
SINTAXIS:
tipo nombre_array [n elementos];
tipo nombre_array [n elementos]={valor1,valor2,valorN};
tipo nombre_array[]={valor1,valor2,valorN};
INICIALIZACIN DE UN ELEMENTO:
nombre_array[indice]=valor;
UTILIZACIN DE ELEMENTOS:
nombre_array[indice];
EJEMPLO: Reserva 100 elementos enteros, los inicializa todos y muestra el 5 elemento.
#include <stdio.h>
void main(void)
{
int x[100];
int cont;
clrscr();
for(cont=0;cont<100;cont++)
x[cont]=cont;
printf(%d,x[4]);
getch();
}
El uso ms comn de los arrays unidimensionales es con mucho las cadenas, conjunto de caracteres
terminados por el carcter nulo (\0). Por tanto cuando se quiera declarar una arrays de caracteres se pondr
siempre una posicin ms. No es necesario aadir explcitamente el carcter nulo el compilador lo hace
automticamente.
SINTAXIS:
char nombre[tamao];
char nombre[tamao]=cadena;
char nombre[]=cadena;
BIDIMENSIONALES:
C admite arrays multidimensionales, la forma ms sencilla son los arrays bidimensionales. Un array
bidimensional es esencialmente un array de arrays unidimensionales. Los array bidimensionales se almacenan
en matrices fila-columna, en las que el primer ndice indica la fila y el segundo indica la columna. Esto significa
que el ndice ms a la derecha cambia ms rpido que el de ms a la izquierda cuando accedemos a los
elementos.
SINTAXIS:
tipo nombre_array[fila][columna];
tipo nomb_array[fil][col]={{v1,v2,vN},{v1,v2,vN},{vN}};
tipo nomb_array[][]={{v1,v2,vN},{v1,v2,vN},{vN}};
INICIALIZACIN DE UN ELEMENTO:
nombre_array[indice_fila][indice_columna]=valor;
UTILIZACIN DE UN ELEMENTO:
nombre_array[indice_fila][indice_columna];
Para conocer el tamao que tiene un array bidimensional tenemos que multiplicar las filas por las
columnas por el nmero de bytes que ocupa en memoria el tipo del array. Es exactamente igual que con los
array unidimensionales lo nico que se aade son las columnas.
filas * columnas * bytes_del_tipo
Un uso muy comn de los arrays bidimensionales es crear un array de cadenas. En este tipo de array el
nmero de filas representa el nmero de cadenas y las columnas representa la longitud de cada una de esas
cadenas.
llaman miembros de la estructura y est relacionado lgicamente con los otros. Otra caracterstica es el ahorro
de memoria y evitar declarar variables que tcnicamente realizan las mismas funciones.
SINTAXIS:
struct nombre{
struct nombre{
var1;
var1;
var2;
var2;
varN;
varN;
};
}etiqueta1,etiquetaN;
.
.
.
.
.
.
struct nombre etiqueta1,etiquetaN;
Los miembros individuales de la estructura se referencian utilizando la etiqueta de la estructura el operador
punto(.) y la variable a la que se hace referencia. Los miembros de la estructura deben ser inicializados fuera
de ella, si se hace en el interior da error de compilacin.
etiqueta.variable;
EJEMPLO:
#include <stdio.h>
void main (void)
{
int opcion=0;
struct ficha{
char nombre[40];
char apellido[50];
unsigned edad;
}emplead,usuario;
do
{
clrscr();
gotoxy(2,4);printf("1.empleados");
gotoxy(2,5);printf("2.usuarios");
gotoxy(2,6);printf("0.visualizar");
gotoxy(2,7);printf("Elegir Opcion: ");
scanf("%d",&opcion);
if (opcion==0)
break;
if(opcion==1)
{
gotoxy(2,10);printf("Nombre: ");
gets(emplead.nombre);
gotoxy(2,11);printf("Apellido: ");
gets(emplead.apellido);
gotoxy(2,12);printf("Edad: ");
scanf("%d",&emplead.edad);
}
else
{
gotoxy(2,10);printf("Nombre: ");
gets(usuario.nombre);
gotoxy(2,11);printf("Apellido: ");
gets(usuario.apellido);
gotoxy(2,12);printf("Edad: ");
scanf("%d",&usuario.edad);
}
}while(opcion!=0);
gotoxy(2,18);printf("%s %s\n",emplead.nombre,emplead.apellido);
gotoxy(2,19);printf("%u aos",emplead.edad);
gotoxy(30,18);printf("%s %s\n",usuario.nombre,usuario.apellido);
gotoxy(30,19);printf("%u aos",usuario.edad);
getch();
}
Las operaciones ms comunes es asignar el contenido de una estructura a otra estructura del mismo tipo
mediante una nica sentencia de asignacin como si fuera una variable es decir no es necesario ir elemento
por elemento. Otra operacin muy comn son los arrays de estructuras. Para declarar un array de estructuras,
se debe definir primero la estructura y luego declarar la etiqueta indicando el nmero de elementos.
SINTAXIS:
struct nombre{
var1;
var2;
varN;
}etiqueta[n elementos];
Como ejemplo de array de estructuras deberemos crear una lista de correos utilizando estructuras para
guardar la informacin. Las operaciones que deben hacerse son aadir datos, borrar datos y realizar listados.
El nmero de registros que va a mantener es de 100. Se deber controlar que no supere el lmite mximo.
UNIONES
Una unin es una posicin de memoria que es compartida por dos o ms variables diferentes,
generalmente de distinto tipo, en distintos momentos. La declaracin es similar a la estructura. Cuando se crea
una etiqueta de la unin el compilador reserva memoria para el mayor miembro de la unin. El uso de una
unin puede ayudar a la creacin de cdigo independiente de la mquina y ahorra memoria en la declaracin
de variables. Para referencia a un elemento de la unin se hace igual que si fuera una estructura.
SINTAXIS:
union nombre{
var1;
var2;
varN
};
.
.
.
union nombre etiqueta1,etiquetaN;
union nombre{
var1;
var2;
varN
}etiqueta1,etiquetaN;
ENUMERACIONES
Es un conjunto de constantes enteras con nombre que especifica todos los valores vlidos que una
variable de ese tipo puede tener. La definicin es muy parecida a las estructuras, la palabra clave enum seala
el comienzo de un tipo enumerado. El valor del primer elemento de la enumeracin es 0 aunque se puede
especificar el valor de uno o ms smbolos utilizando una asignacin.
SINTAXIS:
enum nombre{lista_de_enumeraciones}etiqueta1,etiquetaN;
enum nombre{lista_de_enumeraciones};
.
.
.
enum nombre etiqueta1,etiquetaN;
EJEMPLO:
#include<stdio.h>
void main(void)
{
enum moneda{dolar,penique=100,medio=50,cuarto=25};
enum moneda dinero;
clrscr();
printf("Valor de la moneda: ");
scanf("%d",&dinero);
switch(dinero)
{
case dolar:
printf("Con ese valor es un Dolar");
break;
case penique:
printf("Con ese valor es un Penique");
break;
case medio:
printf("Con ese valor es Medio-Dolar");
break;
case cuarto:
printf("Con ese valor es un Cuarto");
break;
default:
printf("Moneda Inexistente");
}
getch();
}
8. PUNTEROS
Un puntero es una variable que contiene una direccin de memoria. Esa direccin es la posicin de n
objeto (normalmente una variable) en memoria. Si una variable va a contener un puntero, entonces tiene que
declararse como tal. Cuando se declara un puntero que no apunte a ninguna posicin valida ha de ser
asignado a un valor nulo (un cero).
SINTAXIS:
tipo *nombre;
OPERADORES: El & devuelve la direccin de memoria de su operando. El * devuelve el valor de la variable
localizada en la direccin que sigue. Pone en m la direccin de memoria de la variable cuenta. La direccin no
tiene nada que ver con el valor de cuenta. En la segunda lnea pone el valor de cuenta en q.
m= &cuenta;
q=*m;
EJEMPLO:
#include <stdio.h>
void main(void)
{
int *p;
int valor;
clrscr();
printf("Intruducir valor: ");
scanf("%d",&valor);
p=&valor;
printf("Direccion de memoria de valor es: %p\n",p);
printf("El valor de la variable es: %d",*p);
getch();
}
ASIGNACIONES: Como en el caso de cualquier variable.
#include <stdio.h>
void main(void)
{
int x;
int *p1, *p2;
p1=&x;
p2=p1;
printf(%p,p2);
}
ARITMTICA: Dos operaciones aritmticas que se pueden usar como punteros, la suma y la resta. Cuando se
incrementa un puntero, apunta a la posicin de memoria del siguiente elemento de su tipo base. Cada vez que
se decrementa, apunta a la posicin del elemento anterior.
p1++;
p1--;
p1+12;
int recupera(void)
{
if(p1==top)
{
printf("pila vacia");
exit(1);
}
p1--;
return *(p1+1);
}
ARRAY DE PUNTEROS: Los punteros pueden estructurarse en arrays como cualquier otro tipo de datos. Hay
que indicar el tipo y el nmero de elementos. Su utilizacin posterior es igual que los arrays que hemos visto
anteriormente, con la diferencia de que se asignan direcciones de memoria.
DECLARACIN:
tipo *nombre[n elementos];
ASIGNACIN:
nombre_array[indice]=&variable;
UTILIZAR ELEMENTOS:
*nombre_array[indice];
EJEMPLO:
#include<stdio.h>
void dias(int n);
void main(void)
{
int num;
clrscr();
printf(Introducir n de Dia: );
scanf(%d,&num);
dias(num);
getch();
}
void dias(int n)
{
char *dia[]={N de dia no Valido,
Lunes,
Martes,
Miercoles,
Jueves,
viernes,
Sabado,
Domingo};
pritnf(%s,dia[n]);
}
PUNTEROS A CADENAS: Existe una estrecha relacin entre punteros y los arrays. Se asigna la direccin del
primer elemento del array y as se conoce el comienzo del array, el final lo sabemos mediante el nulo que
tienen todas las cadenas al final. Con esta relacin se puede declarar una cadena sin tener en cuenta la
longitud de la cadena. Otra caracterstica importe es la posibilidad es poder pasar cadenas a las funciones.
SINTAXIS:
char *nombre;
char *nombre[];
EJEMPLO: En este ejemplo se pueden incluir primer apellido o el primero y el segundo, la longitud de
la cadena no importa. Mostramos el contenido de apellidos y su direccin de memoria.
#include<stdio.h>
void main(void)
{
char *apellidos;
clrscr();
printf(Introducir apellidos: );
gets(apellidos);
printf(Tus apellidos son: %s,apellidos);
printf(La direccin de memoria es: %p,apellidos);
getch();
}
PUNTEROS A ESTRUCTURAS: C permite punteros a estructuras igual que permite punteros a cualquier otro
tipo de variables. El uso principal de este tipo de punteros es pasar estructuras a funciones. Si tenemos que
pasar toda la estructura el tiempo de ejecucin puede hacerse eterno, utilizando punteros slo se pasa la
direccin de la estructura. Los punteros a estructuras se declaran poniendo * delante de la etiqueta de la
estructura..
SINTAXIS:
INDIRECCIN MLTIPLE: Que un puntero apunte a otro puntero que apunte a un valor de destino. En el caso
de un puntero a puntero, el primer puntero contiene la direccin del segundo puntero, que apunta al objeto que
contiene el valor deseado. La siguiente declaracin indica al compilador que es un puntero a puntero de tipo
float.
float **balance;
9.
FUNCIONES
Las funciones son los bloques constructores de C, es el lugar donde se produce toda la actividad del
programa. Es la caracterstica ms importante de C. Subdivide en varias tareas concurrentes el programa, as
slo se las tendr que ver con diminutas piezas de programa, de pocas lneas, cuya escritura y correccin es
una tarea simple. Las funciones pueden o no devolver y recibir valores del programa.
El mecanismo para trabajar con funciones es el siguiente, primero debemos declarar el prototipo de la
funcin, a continuacin debemos hacer la llamada y por ltimo desarrollar la funcin. Los dos ltimos pasos
pueden cambiar, es decir, no es necesario que el desarrollo de la funcin este debajo de la llamada.
Antes de seguir debemos conocer las reglas de mbito de las funciones. El cdigo de una funcin es
privado a esa funcin, el cdigo que comprende el cuerpo de esa funcin est oculto al resto del programa a
menos que se haga a travs de una llamada. Todas las variables que se definen dentro de una funcin son
locales con la excepcin de las variables estticas.
SEGUNDO TIPO: Son funciones que devuelven un valor una vez han terminado de realizar sus operaciones,
solo se puede devolver uno. La devolucin se realiza mediante la sentencia return, que adems de devolver un
valor hace que la ejecucin del programa vuelva al cdigo que llamo a esa funcin. Al compilador hay que
indicarle el tipo de valor que se va a devolver poniendo delante del nombre de la funcin el tipo a devolver. En
este tipo de casos la funcin es como si fuera una variable, pues toda ella equivale al valor que devuelve.
tipo_devuelto nombre_funcion(void);
variable=nombre_funcion();
EJEMPLO:
#include<stdio.h>
int suma(void);
#include<stdio.h>
int suma(void);
void main(void)
{
int total;
clrscr();
void main(void)
{
clrscr();
printf(Suma valores\n);
pritnf(\n %d,suma());
getch();
}
printf(Suma valores\n);
total=suma();
pritnf(\n%d,total);
getch();
}
int suma(void)
{
int a,b;
printf(valores: );
scanf(%d%*c%d,&a,&b);
return a+b;
}
int suma(void)
{
int a,b,total_dev;
printf(valores: );
scanf(%d%*c%d,&a,&b);
total_dev=a+b;
return total_dev;
TERCER
TIPO: En este tipo las funciones pueden o no devolver valores pero lo importante es que las
}
funciones pueden recibir valores. Hay que indicar al compilador cuantos valores recibe y de que tipo es cada
uno de ellos. Se le indica ponindolo en los parentesis que tienen las funciones. Deben ser los mismos que en
el prototipo.
void nombre_funcion(tipo1,tipo2tipoN);
nombre_funcion(var1,var2varN);
EJEMPLO:
#include<stdio.h>
void resta(int x, int y, char *cad);
void main(void)
{
int a,b;
char cadena[20];
clrscr();
printf(Resta de Valores\n);
printf(Introducir valores y cadena: );
scanf(%d%*c%d,&a,&b);
gets(cadena);
resta(a,b,cadena);
getch();
}
Para devolver un puntero, una funcin debe ser declarada como si tuviera un tipo puntero de vuelta, si no
hay coincidencia en el tipo de vuelta la funcin devuelve un puntero nulo. En el prototipo de la funcin antes del
nombre de esta hay que poner un asterisco y en la llamada hay que igualar la funcin a un puntero del mismo
tipo que el valor que devuelve. El valor que se retorna debe ser tambin un puntero.
PROTOTIPO:
valor_devuelto *nombre(lista_parametros);
LLAMADA:
puntero=nombre_funcion(lista_parametros);
DESARROLLO:
valor_devuelto *nombre_funcion(lista_parametros)
{
cuerpo;
return puntero;
}
EJEMPLO: Busca la letra que se le pasa en la cadena y si la encuentra muestra la cadena a partir de
esa letra.
#include<stdio.h>
void *encuentra(char letra, char *cadena);
void main(void)
{
char frase[80], *p, letra_busca;
clrscr();
printf("Introducir cadena: ");
gets(frase);
fflush(stdin);
printf("Letra a buscar: ");
letra_busca=getchar();
p=encuentra(letra_busca,frase);
if(p)
printf("\n %s",p);
getch();
}
void *encuentra(char letra, char *cadena)
{
while(letra!=*cadena && *cadena)
cadena++;
return cadena;
}
LA FUNCIN MAIN: Mtodo para pasar informacin a la funcin main mediante el uso de argumentos, el lugar
desde donde se pasan esos valores es la lnea de ordenes del sistema operativo. Se colocan detrs del
nombre del programa.
Hay dos argumentos especiales ya incorporados, argc y argv que se utilizan para recibir esa informacin.
En argc contiene el nmero de argumentos de la lnea de ordenes y es un entero. Siempre vale como mnimo
1, ya que el nombre del programa cuenta como primer argumento. El caso de argv es un puntero a un array de
punteros de caracteres donde se irn guardando todos los argumentos. Todos ellos son cadenas.
Si la funcin main espera argumentos y no se le pasa ninguno desde la lnea de ordenes, es muy posible
que de un error de ejecucin cuando se intenten utilizar esos argumentos. Por tanto lo mejor es siempre
controlar que el nmero de argumentos es correcto.
Otro aspecto a tener en cuenta es que el nombre de los dos argumentos (argc y argv) son tradicionales
pero arbitrarios, es decir que se les puede dar el nombre que a nosotros nos interese, manteniendo eso si el
tipo y el nmero de argumentos que recibe.
SINTAXIS:
void main(int argc, char *argv[])
{
cuerpo;
}
EJEMPLO: Al ejecutar el programa a continuacin del nombre le indicamos 2 valores.
#include<stdio.h>
void main(int argc, char *argv[])
{
clrscr();
if(argc!=3)
//controlo el n de argumentos
{
printf("Error en n de argumentos");
exit(0);
}
printf("Suma de valores\n");
printf("Total= %d",atoi(argv[1])+atoi(argv[2]));
getch();
}
RECURSIVIDAD: Es el proceso de definir algo en trminos de si mismo, es decir que las funciones pueden
llamarse a si mismas, esto se consigue cuando en el cuerpo de la funcin hay una llamada a la propia funcin,
se dice que es recursiva. Una funcin recursiva no hace una nueva copia de la funcin, solo son nuevos los
argumentos.
La principal ventaja de las funciones recursivas es que se pueden usar para crear versiones de algoritmos
ms claras y sencillas. Cuando se escriben funciones recursivas, se debe tener una sentencia if para forzar a
la funcin a volver sin que se ejecute la llamada recursiva.
EJEMPLO:
int fact(int numero)
{
int resp;
if(numero==1)
return 1;
resp=fact(numero-1)*numero;
return(resp);
}
10. PROYECTOS
Procedimiento con el que se compilan de forma independiente distintas partes de un programa y luego se
enlazan para formar el programa ejecutable final. Se utiliza con aplicaciones muy grandes. Los proyectos
tienen la extensin PRJ. Solo se genera un ejecutable, los ficheros fuente generan ficheros OBJ.
Lo primero es crear el proyecto (que es el que va a contener los ficheros fuente). El proyecto va a tener la
extensin PRJ. El modo de crearlo es:
MENU PROJECT
Asignar un nombre
al proyecto.
Lo siguiente es crear cada uno de los ficheros fuente que van a componer el proyecto. La creacin de los
ficheros es como siempre, no hay nada de particular. Cuando tengamos los ficheros hay que aadirlos al
proyecto. El modo de hacerlo.
Seleccionar la ventana del proyecto (ventana inferior de color gris).
MENU PROJECT
Ir seleccionando cada
uno de los ficheros que
forman el proyecto
El siguiente paso es COMPILAR CADA UNO DE LOS FICHEROS FUENTE. Para hacerlo hay que
seleccionar primero el fichero y luego pulsar ALT+F9. As con todos los ficheros. Posteriormente se tiene que
linkar el proyecto. MENU COMPILE
OPCION LINK. Cuando se termine con el proyecto hay que
cerrarlo. MENU PROJECT
OPCION CLOSE.
EJEMPLO: En este proyecto hay dos ficheros fuente. En el primero se muestra 2 valores y se hace la
llamada a funciones del segundo programa.
Fichero: UNO.C
Fichero:DOS.C
#include <stdio.h>
#include <conio.h>
#include<stdio.h>
#include<conio.h>
void mostrar();
void sumar();
void sumar()
{
int x,y;
printf("%d",x+y);
getch();
}
void main(void)
{
int x,y;
clrscr();
x=10;
y=20;
printf("%d %d",x,y);
getch();
mostrar();
sumar();
void mostrar()
{
int z,p;
z=15;
p=25;
printf("%d %d",z,p);
getch();
}
getch();
}
Devuelve un entero. DISTINTO DE CERO si la variable es una letra del alfabeto, en caso contrario
devuelve cero. Cabecera: <ctype.h>.
int isalpha(variable_char);
ISDIGIT:
ISGRAPH: Devuelve un entero. DISTINTO DE CERO si la variable es cualquier carcter imprimible distinto de
un espacio, si es un espacio CERO. Cabecera <ctype.h>.
int isgraph(variable_char);
ISLOWER: Devuelve un entero. DISTINTO DE CERO si la variable esta en minscula, en caso contrario
devuelve cero. Cabecera <ctype.h>.
int islower(variable_char);
ISPUNCT: Devuelve un entero. DISTINTO DE CERO si la variable es un carcter de puntuacin, en caso
contrario, devuelve cero. Cabecera <ctype.h>
int ispunct(variable_char);
ISUPPER: Devuelve un entero. DISTINTO DE CERO si la variable esta en maysculas, en caso contrario,
devuelve cero. Cabecera <ctype.h>
int isupper(varible_char);
EJEMPLO: Cuenta el numero de letras y nmeros que hay en una cadena. La longitud debe ser
siempre de cinco por no conocer an la funcin que me devuelve la longitud de una cadena.
#include<stdio.h>
#include<ctype.h>
void main(void)
{
int ind,cont_num=0,cont_text=0;
char temp;
char cadena[6];
clrscr();
printf("Introducir 5 caracteres: ");
gets(cadena);
for(ind=0;ind<5;ind++)
{
temp=isalpha(cadena[ind]);
if(temp)
cont_text++;
else
cont_num++;
}
printf("El total de letras es %d\n",cont_text);
printf("El total de numeros es %d",cont_num);
getch();
}
EJEMPLO: Utilizando el resto de funciones nos va a dar informacin completa del valor que
contiene la variable.
#include <stdio.h>
#include <ctype.h>
void main(void)
{
char letra;
clrscr();
printf("Introducir valor: ");
letra=getchar();
if(isdigit(letra))
printf("Es un numero");
else
{
if(islower(letra))
printf("Letra en minuscula");
else
printf("Letra en mayuscula");
if(ispunct(letra))
printf("Caracter de puntuacion");
if(!isgraph(letra))
printf("Es un espacio");
}
getch();
}
MEMSET: Inicializa una regin de memoria (buffer) con un valor determinado. Se utiliza principalmente para
inicializar cadenas con un valor determinado. Cabecera <string.h>.
memset (var_cadena,carcter,tamao);
STRCAT:
Concatena cadenas, es decir, aade la segunda cadena a la primera, la primera cadena no pierde
su valor origina. Lo nico que hay que tener en cuenta es que la longitud de la primera cadena
debe tener la longitud suficiente para guardar la suma de las dos cadenas. Cabecera <string.h>.
strcat(cadena1,cadena2);
STRCHR:
STRCMP:
RESULTADO
VALOR
STRCPY:
DESCRIPCIN
Menor a Cero
Cero
Mayor a Cero
STRLEN:
STRNCAT:
STRNCMP:
strncmp(cadena1,cadena2,n de caracteres);
strncmp(cadena1,texto,n de caracteres);
STRNCPY:
STRRCHR:
strncpy(cadena1,texto,n de caracteres);
Devuelve un puntero a la ltima ocurrencia del carcter buscado en la cadena. Si no lo encuentra
devuelve un puntero nulo. Cabecera <string.h>.
strrchr(cadena,carcter);
strrchr(texto,carcter);
STRPBRK:
Devuelve un puntero al primer carcter de la cadena que coincida con algn carcter de la
cadena a buscar. Si no hay correspondencia devuelve un puntero nulo. Cabecera <string.h>.
strpbrk(texto,cadena_de_busqueda);
strpbrk(cadena,cadena_de_busqueda);
printf("%s",destino);
getch();
}
EJEMPLO: Pide una contrasea de entrada. Luego pide 10 cdigos de 6 dgitos. Por ltimo pide los 3
primeros dgitos de los cdigos que deseas ver.
#include<stdio.h>
#include<string.h>
void main(void)
{
int cont;
char ver_codigo[4];
char contra[6]="abcde";
char tu_contra[6];
char codigos[10][7];
clrscr();
printf("CONTRASEA ");
gets(tu_contra);
clrscr();
if(strcmp(tu_contra,contra))
{
printf("ERROR");
delay(2000);
exit(0);
}
printf("Introducir Codigos\n");
for(cont=0;cont<10;cont++)
{
printf("%2.2d: ",cont+1);
gets(codigos[cont]);
}
clrscr();
printf("cdigo a listar? ");
gets(ver_codigo);
for(cont=0;cont<10;cont++)
{
if(!strncmp(ver_codigo,codigos[cont],3))
printf("%s\n",codigos[cont]);
}
getch();
}
#include<stdio.h>
#include<string.h>
#include<stdio.h>
#include<string.h>
void main(void)
{
char letra;
char *resp;
char cad[30];
clrscr();
void main(void)
{
char letra;
char *resp;
char cad[30];
clrscr();
printf("Cadena: ");
gets(cad);
printf("Buscar Letra: ");
letra=getchar();
printf("Cadena: ");
gets(cad);
printf("Buscar Letra: ");
letra=getchar();
resp=strchr(cad,letra);
resp=strrchr(cad,letra);
if(resp)
printf("%s",resp);
else
printf("No Esta");
if(resp)
printf("%s",resp);
else
printf("No Esta");
getch();
}
getch();
}
}
12. FUNCIONES MATEMTICAS
El estndar C define 22 funciones matemticas que entran en las siguientes categoras, trigonomtricas,
hiperblicas, logartmicas, exponenciales y otras. Todas la funciones requieren el archivo de cabecera
MATH.H. Si un argumento de una funcin matemtica no se encuentra en el rango para el que esta definido,
devolver un valor definido EDOM.
ACOS:
Devuelve un tipo double. Muestra el arcocoseno de la variable. La variable debe ser de tipo double y
debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double acos(variable_double);
ASIN:
Devuelve un tipo double. Muestra el arcoseno de la variable. La variable debe ser de tipo double y
debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double asin(variable_double);
ATAN:
Devuelve un tipo double. Muestra el arcotangente de la variable. La variable debe ser de tipo double
y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double atan(variable_double);
COS:
Devuelve un tipo double. Muestra el coseno de la variable. La variable debe ser de tipo double y
debe estar expresada en radianes. Cabecera <math.h>.
double cos(variable_double_radianes);
SIN:
Devuelve un tipo double. Muestra el seno de la variable. La variable debe ser de tipo double y debe
estar expresada en radianes. Cabecera <math.h>.
double sin(variable_double_radianes);
TAN:
Devuelve un tipo double. Muestra la tangente de la variable. La variable debe ser de tipo double y
debe estar expresada en radianes. Cabecera <math.h>.
double tan(variable_double_radianes);
COSH:
Devuelve un tipo double. Muestra el coseno hiperblico de la variable. La variable debe ser de tipo
double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera
debe ser <math.h>.
double cosh(variable_double);
SINH:
Devuelve un tipo double. Muestra el seno hiperblico de la variable. La variable debe ser de tipo
double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera
debe ser <math.h>.
double sinh(variable_double);
TANH:
Devuelve un tipo double. Muestra la tangente hiperblico de la variable. La variable debe ser de tipo
double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera
debe ser <math.h>.
double tanh(variable_double);
EJEMPLO:
#include<stdio.h>
#include<math.h>
void main(void)
{
double radianes;
clrscr();
printf("Introducir radianes: ");
scanf("%f",&radianes);
printf("Coseno= %f\n",cos(radianes));
printf("Seno= %f\n",sin(radianes));
printf("Tangente= %f",tan(radianes));
getch();
}
CEIL:
Devuelve un double que representa el menor entero sin ser menor de la variable redondeada. Por
ejemplo, dado 1.02 devuelve 2.0. Si asignamos 1.02 devuelve 1. En resumen redondea la
variable a la alta. Cabecera <math.h>.
double ceil(variable_double);
FLOOR:
Devuelve un double que representa el entero mayor que no sea mayor a la variable redondeada.
Por ejemplo dado 1.02 devuelve 1.0. Si asignamos 1.2 devuelve 2. En resumen redondea la
variable a la baja. Cabecera <math.h>.
double floor(variable_double);
FABS:
Devuelve un valor float o double. Devuelve el valor absoluto de una variable float. Se considera una
funcin matemtica, pero su cabecera es <stdlib.h>.
var_float fabs(variable_float);
LABS:
Devuelve un valor long. Devuelve el valor absoluto de una variable long. Se considera una funcin
matemtica, pero su cabecera es <stdlib.h>.
var_long labs(variable_long);
ABS:
MODF:
Devuelve un valor entero. Devuelve el valor absoluto de una variable int. Se considera una funcin
matemtica, pero su cabecera es <stdlib.h>.
var_float abs(variable_float);
Devuelve un double. Descompone la variable en su parte entera y fraccionaria. La parte decimal es
el valor que devuelve la funcin, su parte entera la guarda en el segundo termino de la funcin. La
variables tienen que ser obligatoriamente de tipo double. Cabecera <math.h>.
var_double_deimal= modf(variable,var_parte_entera);
POW:
Devuelve un double. Realiza la potencia de un nmero base elevado a un exponente que nosotros
le indicamos. Se produce un error si la base es cero o el exponente es menor o igual a cero. La
cabecera es <math.h>.
var_double=pow(base_double,exponente_double);
SQRT:
Devuelve un double. Realiza la raz cuadrada de la variable. La variable no puede ser negativa, si lo
es se produce un error de dominio. La cabecera <math.h>.
var_double=sqrt(variable_double);
EJEMPLO:
#include<stdio.h>
#include<math.h>
void main(void)
{
float num;
double num_dec,num_ent;
clrscr();
printf("Introducir Numero: ");
scanf("%f",&num);
gotoxy(9,3);printf("ALTO: %.1f",ceil(num));
gotoxy(1,4);printf("REDONDEO");
gotoxy(9,5);printf("BAJO: %.1f",floor(num));
num_dec=modf(num,&num_ent);
gotoxy(12,8);printf("ENTERA: %.2f",num_ent);
gotoxy(1,9);printf("DESCONPONGO");
gotoxy(12,10);printf("DECIMAL: %.2f",num_dec);
gotoxy(1,13);
printf("VALOR ABSOLUTO: %.2f",fabs(num));
gotoxy(1,16);
printf("R.CUADRADA: %.2f",sqrt(fabs(num)));
getch();
}
LOG:
LOG10:
Devuelve un valor double. Realiza el logaritmo decimal de la variable de tipo double. Se produce un
error de dominio si la variable es negativo y un error de rango si el valor es cero. La cabecera que
utiliza es <math.h>.
double log10(var_double);
RAMDOMIZE():
Inicializa la semilla para generar nmeros aleatorios. Utiliza las funciones de tiempo para
crear esa semilla. Esta funcin esta relacionada con random. Cabecera <stdlib.h>.
void randomize();
RANDOM:
Devuelve un entero. Genera un nmero entre 0 y la variable menos uno. Utiliza el reloj del
ordenador para ir generando esos valores. El programa debe llevar la funcin randomize
para cambiar la semilla en cada ejecucin. Cabecera <stdlib.h>.
int random(variable_int);
EJEMPLO: Genera seis nmeros aleatorios entre 1 y 49. No se repite ninguno de ellos.
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int num=0,num1=0,repe,temp;
int valores[6];
clrscr();
printf("Loteria primitiva: ");
randomize();
for(;;)
{
repe=1;
if(num==6)
break;
temp=random(49)+1;
for(num1=0;num1<=num;num1++)
{
if(valores[num1]==temp)
{
valores[num1]=temp;
num--;
repe=0;
break;
}
}
if (repe==1)
valores[num]=temp;
num++;
}
for(num=0;num<6;num++)
printf("%d ",valores[num]);
getch();
}
Devuelve un entero. Esta funcin convierte la cadena en un valor entero. La cadena debe contener un
nmero entero vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar con
espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La
cabecera es <stdlib.h>.
int atoi(variable_char);
ATOL:
Devuelve un long. Esta funcin convierte la cadena en un valor long. La cadena debe contener un
nmero long vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar con
espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La
cabecera es <stdlib.h>.
long atol(variable_char);
ATOF:
Devuelve un double. Esta funcin convierte la cadena en un valor double. La cadena debe contener
un nmero double vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar
con espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La
cabecera es <stdlib.h>.
double atof(variable_char);
SPRINTF:
Devuelve una cadena. Esta funcin convierte cualquier tipo numrico a cadena. Para convertir
de nmero a cadena hay que indicar el tipo de variable numrica y tener presente que la longitud
de la cadena debe poder guardar la totalidad del nmero. Admite tambin los formatos de salida,
es decir, que se puede coger distintas partes del nmero. La cabecera es <stdlib.h>.
sprintf(var_cadena,identificador,var_numerica);
ITOA:
Devuelve una cadena. La funcin convierte un entero en su cadena equivalente y sita el resultado
en la cadena definida en segundo termino de la funcin. Hay que asegurarse que la cadena se lo
suficientemente grande para guardar el nmero. Cabecera <stdlib.h>.
itoa(var_entero,var_cadena,base);
BASE
LTOA:
DESCRIPCIN
10
16
Devuelve una cadena. La funcin convierte un long en su cadena equivalente y sita el resultado en
la cadena definida en segundo termino de la funcin. Hay que asegurarse que la cadena se lo
suficientemente grande para guardar el nmero. Cabecera <stdlib.h>.
ltoa(var_long,var_cadena,base);
EJEMPLO:
#include<stdio.h>
#include<stdlib.h>
void main(void)
{
char texto[4];
char ntext[10],ntext1[10];
int num;
float total;
clrscr();
printf("Numero de 3 digitos: ");
scanf("%d",&num);
fflush(stdin);
printf("Cadena numerica: ");
gets(ntext);
fflush(stdin);
printf("Cadena numerica: ");
gets(ntext1);
fflush(stdin);
sprintf(texto,"%d",num);
printf("%c %c %c\n",texto[0],texto[1],texto[2]);
total=atof(ntext)+atof(ntext1);
printf("%.3f",total);
getch();
}
Devuelve la hora actual del calendario del sistema. Si se produce un error devuelve 1. Utiliza la
estructura time_t a la cual debemos asignar una etiqueta que nos servir para trabajar con la fecha
y hora. Por si sola no hace nada, necesita otras funciones para mostrar los datos. Cabecera
<time.h>.
CTIME:
time_t nombre_etiqueta;
.
.
nombre_etiqueta=time(NULL);
Devuelve un puntero a una cadena con un formato da semana mes hora:minutos:segundo ao \n\0.
La hora del sistema se obtiene mediante la funcin time. Cabecera <time.h>.
puntero=ctime(&etiqueta_estructura_time_t);
EJEMPLO:
#include<stdio.h>
#include<time.h>
void main(void)
{
time_t fecha_hora;
clrscr();
fecha_hora=time(NULL);
printf(ctime(&fecha_hora));
getch();
}
GETTIME:
Devuelve la hora del sistema. Utiliza la estructura dostime_t para guardar la informacin
referente a la hora. Antes de hacer referencia a la funcin hay que crear una etiqueta de la
estructura. Cabecera <dos.h>.
_dos_gettime(&etiqueta_estructura_dostime_t);
struct dostime_t{
unsigned hour;
unsigned minute;
unsigned second;
unsigned hsecond;
}
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
struct dostime_t ho;
clrscr();
_dos_gettime(&ho);
printf(" %d:%d:%d",ho.hour,ho.minute,ho.second);
getch();
}
GETDATE:
Devuelve la fecha del sistema. Utiliza la estructura dosdate_t para guardar la informacin
referente a la fecha. Antes de hacer referencia a la funcin hay que crear una etiqueta de la
estructura. Cabecera <dos.h>.
_dos_getdate(&etiqueta_estructura_dosdate_t);
struct dosdate_t{
unsigned day;
unsigned month;
unsigned year;
unsigned dayofweek;
}
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
struct dosdate_t fec;
clrscr();
_dos_getdate(&fec);
printf("%d/%d/%d\n",fec.day,fec.month,fec.year);
getch();
}
SETTIME:
Permite cambiar la hora del sistema. Utiliza la estructura dostime_t para guardar la informacin
referente a la hora. Antes de hacer referencia a la funcin hay que crear una etiqueta de la
estructura. Cabecera <dos.h>.
_dos_settime(&etiqueta_estructura_dostime_t);
SETDATE:
Permite cambiar la fecha del sistema. Utiliza la estructura dosdate_t para guardar la informacin
referente a la fecha. Antes de hacer referencia a la funcin hay que crear una etiqueta de la
estructura. Cabecera <dos.h>.
_dos_setdate(&etiqueta_estructura_dosdate_t);
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
struct dosdate_t fec;
struct dostime_t ho;
clrscr();
DIFFTIME:
Devuelve un double. La funcin devuelve la diferencia, en segundos, entre una hora inicial y hora
final. Se restara la hora final menos la hora inicial. Tenemos que obtener la hora al iniciar un
proceso y al terminar el proceso volveremos a tomar la hora. Cabecera <time.h>.
double difftime(hora_final,hora_inicial);
EJEMPLO:
#include<stdio.h>
#include<time.h>
void main(void)
{
time_t inicio, final;
double tiempo,cont;
clrscr();
inicio=time(NULL);
for(cont=0;cont<50000;cont++)
clrscr();
final=time(NULL);
tiempo=difftime(final,inicio);
printf("Tiempo: %.1f",tiempo);
getch();
}
BIT
EQUIPO
--
--
0 0: 16K
2,3
0 1: 32K
1 0: 48K
1 1: 64K
0 0: no utilizado
4,5
0 1: 40x25BN adap.color
1 0: 80x25BN adap.color
1 1: 80x25adap.monocromo
0 0: una
6,7
0 1: dos
1 0: tres
1 1: cuatro
Chip DMA.
0
0 0 0: cero
0 0 1: uno
0 1 0: dos
9,10,11
0 1 1: tres
1 0 0: cuatro
1 0 1: cinco
1 1 0: seis
1 1 1: siete
12
13
Con mdem
1
0 0: cero
14,15
Nmero de impresoras
0 1: uno
1 0: dos
1 1: tres
num_bit=_bios_equiplist();
num_bit>>=6;
printf("N de disqueteras: %d",(num_bit & 3)+1);
getch();
}
GETDISKFREE:
Devuelve la cantidad de espacio libre del disco especificado por la unidad (numeradas a
partir de 1 que corresponde a la unidad A). Esta funcin utiliza la estructura diskfree_t.
El espacio lo devuelve indicando el nmero de cilindros libres, para pasarlo a bytes hay
que multiplicarlo por 512 y por 64. Cabecera <dos.h>.
_dos_getdiskfree(unidad,&etiq_struct_diskfree_t);
struct diskfree_t{
unsigned total_clusters;
unsigned avail_clusters;
unsigned sectors_per_cluster;
unsigned bytes_per_sector;
}
VALOR
UNIDAD
A:
B:
C:
EJEMPLO:
#include <stdio.h>
#include <dos.h>
void main(void)
{
struct diskfree_t disco;
float tam;
clrscr();
_dos_getdiskfree(3,&disco);
tam= (float)(disco.avail_clusters)*
(float)(disco.sectors_per_cluster)*
(float)(disco.bytes_per_sector);
printf("Tamao Bytes: %.0f\n",tam);
printf("Tamao Sectores: %d",disco.avail_clusters);
getch();
}
GETDRIVE:
Devuelve el nmero de la unidad de disco actual del sistema y deja el valor en la variable
int. Ese valor se puede discriminar por medio de un switch o como en el ejemplo utilizar
directamente un printf. La cabecera <dos.h>.
_dos_getdrive(&var_intera);
VALOR
UNIDAD
A:
B:
C:
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
int unidad;
clrscr();
_dos_getdrive(&unidad);
printf("La unidad actual es: %c",unidad+'A'-1);
getch();
}
SETDRIVE:
La funcin cambia la unidad de disco actual a la especificada por la variable de tipo entero.
La funcin devuelve el nmero de unidades del sistema en el entero apuntado por la
segunda variable de la funcin. La cabecera <dos.h>.
_dos_setdrive(var_int_unidad,&var_int_unidades);
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
unsigned unit;
clrscr();
_dos_setdrive(3,&unit);
printf("N unidades: %u",unit);
getch();
}
GETCUDIR:
void main(void)
{
char *director;
clrscr();
getcurdir(3,director);
printf("Directorio: %s",director);
getch();
}
FINDFIRST/FINDNEXT:
La funcin findfirst busca el primer nombre de archivo que coincida con el patrn
de bsqueda. El patrn puede contener la unidad como el camino donde buscar.
Adems el patrn puede incluir los caracteres comodines * y ?. Si se encuentra
alguno, rellena con informacin la estructura find_t.
int _dos_findfirst(patron,atrib,&etique_find_t);
struct find_t{
char reserved[21];
char attrib;
unsigned wr_time;
unsigned wr_date;
long size;
char name[13];
}
ATRIBUTO
DESCRIPCIN
_A_NORMAL
Archivo normal.
_A_RDONLY
_A_HIDDEN
Archivo oculto.
_A_SYSTEM
_A_VOLID
Etiqueta de volumen.
_A_SUBDIR
Subdirectorio.
_A_ARCH
EJEMPLO:
#include<stdio.h>
#include<dos.h>
void main(void)
{
struct find_t fiche;
int fin;
fin=_dos_findfirst("*.c",_A_NORMAL,&fiche);
while(!fin)
{
printf("%s %ld\n",fiche.name,fiche.size);
fin=_dos_findnext(&fiche);
}
getch();
}
REMOVE:
RENAME:
La funcin cambia el nombre del archivo especificado en primer termino por el nombre de la
segunda variable cadena. El nuevo nombre no debe coincidir con ninguno que exista en el
directorio. Devuelve CERO si tiene xito y DISTINTO DE CERO si se produce algn error.
Cabecera <stdio.h>.
int rename(var_nombre_antiguo,var_nombre_nuevo);
EJEMPLO:
#include<stdio.h>
void main(int argc, char *argv[])
{
clrscr();
if (argc!=3)
{
printf("Error en los argumentos");
exit(0);
}
if(remove(argv[1]))
printf("El fichero no esta\n");
if(rename(argv[2],"nuevo.txt"))
printf("No puedo cambiar nombre\n");
}
MKDIR:
Esta funcin permite crear directorios. El directorio depender de aquel donde estemos situados a
la hora de crearlo. Devuelve CERO si todo ha ido correctamente y DISTINTO de cero si hay algn
error. Cabecera <dir.h>.
int mkdir(variable_cadena);
CHDIR:
Esta funcin permite cambiarse de directorio. Hay que indicarle la ruta completa para poder
cambiarse. Devuelve CERO si todo ha ido correctamente y DISTINTO de cero si hay algn error.
Cabecera <dir.h>.
int chdir(variable_cadena);
RMDIR:
Esta funcin permite borrar el directorio que le indiquemos. Las condiciones para borrar el
directorio es que este vaco y estar en el directorio que le precede. Devuelve CERO si todo ha ido
correctamente y DISTINTO de cero si hay algn error. Cabecera <dir.h>.
int rmdir(variable_cadena);
SYSTEM:
La funcin pasa la cadena como una orden para el procesador de rdenes del sistema operativo.
El valor devuelto por system normalmente es CERO si se realiza todo correctamente y DISTINTO
de cero en cualquier otro caso. No es muy utilizada, al llamarla perdemos todo el control del
programa y lo coge el sistema operativo. Para probar esta orden es necesario salir a MS-DOS. La
cabecera utilizada es <stdlib.h>.
int system(variable_cadena);
SOUND/NOSOUND:
La funcin sound hace que el altavoz del ordenador comience a pitar con una
frecuencia determinada por la variable. El altavoz seguir pitando hasta que el
programa lea una lnea con la funcin nosound(). Cabecera <dos.h>.
sound(int_frecuencia);
nosound();
EJEMPLO:
#include <stdio.h>
#include <dir.h>
void main(void)
{
char *directorio;
clrscr();
printf("Nombre del directorio: ");
gets(directorio);
if(!mkdir(directorio))
printf("Directorio creado\n");
else
{
printf("No se pudo crear directorio\n");
delay(1000);
exit(0);
}
getch();
system(dir/p);
getch();
if(!rmdir(directorio))
printf("\nDirectorio borrado\n");
else
{
printf("\nNo se pudo borrar\n");
delay(1000);
exit(0);
}
getch();
}
Graphics Library
TEXTO
VALOR
COLOR
VALOR
COLOR
FONDO GRFICO
VALOR
COLOR
Negro.
Negro.
Negro.
Azul.
Azul.
Azul.
Verde.
Verde.
Verde.
Can.
Can.
Can.
Rojo.
Rojo.
Rojo.
Magenta.
Magenta.
Magenta.
Marrn.
Marrn.
Marrn.
Gris claro.
Gris claro.
Gris oscuro.
Gris oscuro.
Azul Claro.
Azul Claro.
10
Verde claro.
10
Verde claro.
11
Can claro
11
Can claro
12
Rojo claro.
12
Rojo claro.
13
Magenta claro
13
Magenta claro
14
Amarillo.
14
Amarillo.
15
Blanco.
15
Blanco.
n+128
TEXTCOLOR:
Parpadean.
Establece el color del texto. No es una funcin grfica. La variable que tiene como
parmetro especifica el color, se puede poner una variable o directamente el n de color. Se
mantiene ese color hasta el momento en que lee otro valor para textcolor. Cabecera
<conio.h>.
textcolor(int color);
CPRINTF:
Tiene la misma funcin y formato que printf pero mediante esta funcin el texto se muestra
con el color especificado en texcolor. Cabecera <conio.h>.
cprintf(mensaje);
cprintf(identificador_formato,variable);
TEXTBACKGROUND:
SETCURSORTYPE:
_setcursortype(constante_tipo_cursor);
CONSTANTES DE CURSOR
CONSTANTE
DESCRIPCIN
_NOCURSOR
No se ve el cursor.
_SOLIDCURSOR
Cursor grande.
_NORMALCURSOR
Cursor normal.
EJEMPLO:
#include <stdio.h>
#include <conio.h>
void main(void)
{
char cadena[20]="hola que tal";
clrscr();
_setcursortype(_NOCURSOR);
textbackground(4);
textcolor(1);
cprintf("%s",cadena);
getch();
}
INICIO GRAFICO:
Antes de poder utilizar cualquiera de las funciones grficas hay que iniciar el modo
grfico. Al iniciar el modo grfico hay que indicarle cual es el modo de vdeo y el
directorio donde estn las funciones grficas en C. Para indicar la tarjeta y el modo se
utilizan variables de tipo entero asignndoles una constante llamada DETECT. La
cabecera <graphics.h>.
initgraph(&var_tarjeta,&var_modo,dir_lib_graficas);
GRAPHRESULT:
Una vez iniciado el modo grfico debemos comprobar que se ha iniciado correctamente
el modo grfico para poder utilizar las funciones grficas sin ningn problema. La funcin
devuelve un entero que debemos comparar con la constante grOk, si son iguales el
modo grfico se ha iniciado correctamente.
variable_int=graphresult();
CERRAR GRAFICO:
Una vez que se ha terminado de trabajar con las funciones grficas se debe cerrar
siempre el modo grfico. Si un programa termina sin cerrar el modo grfico el sistema
operativo mantendr el modo grfico. Cabecera <graphics.h>.
closegraph();
CLEARDEVICE:
Esta funcin borra la pantalla una vez que se ha inicializado el modo grfico. Si se utiliza
la orden clrscr solo se limpiara una parte de la pantalla. Cabecera <graphics.h>.
cleardevice();
SETBKCOLOR:
Establece el color de fondo en la pantalla. Hay que indicarle mediante variable o valor
numrico. Cuando se borra la pantalla este no desaparece. Cabecera <graphics.h>.
setbkcolor(int_color);
EJEMPLO:
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main(void)
{
int tarjeta= DETECT,modo=DETECT;
int color;
clrscr();
initgraph(&tarjeta, &modo, "c:\\tc\\bgi");
if(graphresult()!=grOk)
{
printf("Error en el modo grafico");
exit(0);
}
cleardevice();
for(color=0;color<=15;color++)
{
setbkcolor(color);
delay(1000);
}
closegraph();
}
SETCOLOR:
Establece el color del borde con el que van a mostrarse los objetos grficos que se van
pintando. Por defecto los objetos aparece con el borde de color blanco. El valor que tiene
la funcin es un entero. Cabecera <graphics.h>.
setcolor(int_color);
SETFILLSTYLE:
Establece el estilo de relleno de los objetos. Hay que indicar el tipo y el color, teniendo
en cuenta que el color debe ser igual al que establecemos en setcolor. Esto simplemente
establece el estilo. Cabecera <graphics.h>.
setfillstyle(int_estilo,int_color);
ESTILO
1
DESCRIPCIN
Slido 100%
FLOODFILL:
10
Puntos separados.
11
Puntos cercanos.
Rellena el objeto que ha sido pintado previamente. Hay que indicarle las mismas
coordenas que tiene el objeto y el color debe ser igual al borde y al estilo de relleno. La
cabecera <graphics.h>.
floodfill(int_x,int_y,in_color);
CIRCULO:
Dibuja un circulo en una posicin indicada mediante las coordenadas x e y, tambin hay
que indicarle un color. Cabecera <graphics.h>.
circle(int_x,int_y,int_color);
RECTANGULO:
EJEMPLO:
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main(void)
{
int tarjeta= DETECT,modo=DETECT;
int color;
initgraph(&tarjeta, &modo, "c:\\tc\\bgi");
if(graphresult()!=grOk)
{
printf("Error en el modo gr fico");
exit(0);
}
cleardevice();
setcolor(3);
circle(200,200,90);
setcolor(14);
circle(500,200,90);
setfillstyle(3,14);
floodfill(500,200,14);
rectangle(300,100,400,300);
getch();
closegraph();
}
ESTILO LINEA:
Sirve para establecer el tipo de lnea con el que se van a pintar los objetos. Los tipos de
lnea establecen cinco valores definidos. Tambin hay que especificar el ancho y la
separacin. Cabecera <graphics.h>.
setlinestyle(int tipo,int_separacion,int_ancho);
VALOR LINEA
LINEAS:
DESCRIPCIN
Continua.
Guiones.
Guiones largos.
Puntos.
Dibuja una lnea desde la posicin donde nos encontramos. Primero debemos
posicionarnos en la coordenada de inicio y despus llamar a la funcin dando la
coordenada final mediante 2 enteros. En la segunda funcin directamente se le da el
comienzo y el final. Cabecera <graphics.h>.
moveto(x,y);
lineto(x,y);
line(x1,y1,x2,y2);
EJEMPLO:
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main(void)
{
int tarjeta= DETECT,modo=DETECT;
int color,coord_y,tipo_linea=0;
clrscr();
initgraph(&tarjeta, &modo, "c:\\tc\\bgi");
if(graphresult()!=grOk)
{
printf("Error en el modo gr fico");
exit(0);
}
cleardevice();
setcolor(14);
moveto(350,150);
lineto(350,250);
for(coord_y=150;coord_y<=250;coord_y+=25)
{
setlinestyle(tipo_linea,1,1);
line(300,coord_y,400,coord_y);
tipo_linea++;
}
getch();
closegraph();
}
ELIPSES:
Dibuja una elipse o arco de elipse. Se le indica la posicin mediante los valores x, y. El
ngulo inicial (que es cero si es una elipse) y el ngulo final (que es 360 si es una
elipse). Hay que indicarle el radio para x y el radio para y. Cabecera <graphics.h>.
ellipse(x,y,ang_inicio,ang_fin,radio_x,radio_y);
ARCOS:
Dibuja un arco. hay que indicarle la posicin, el ngulo inicial y el final y el radio que tiene
dicho arco. Todos sus valores son enteros. Cabecera <graphics.h>.
arc(x,y,ang_inicial,ang_final,radio);
PUNTOS:
Pintan un punto en una coordenada determinada con un color establecido. Hay que
indicarle las coordenadas y el color mediante variables o valores enteros. Se pude pintar
puntos aleatoriamente. Cabecera <graphics.h>.
putpixel(int_x,int_y,int_color);
EJEMPLO: Se pinta un tarrina con pajilla.
#include <stdio.h>
#include <conio.h>
#include <graphics.h>
void main(void)
{
int tarjeta= DETECT,modo=DETECT;
clrscr();
initgraph(&tarjeta, &modo, "c:\\tc\\bgi");
if(graphresult()!=grOk)
{
printf("Error en el modo gr fico");
exit(0);
}
cleardevice();
setcolor(2);
ellipse(400,200,0,360,90,40);
setcolor(15);
arc(310,200,0,45,90);
setcolor(11);
line(490,200,470,350);
line(310,200,330,350);
setcolor(14);
ellipse(400,350,180,360,70,25);
getch();
closegraph();
}
SETTEXTSTYLE:
Establece el estilo de letra que se va a utilizar en modo grfico. Hay que indicarle
mediante valores enteros el tipo, la direccin y el tamao que tiene la letra. El color se
establece con la funcin setcolor. Cabecera <graphics.h>.
settextstyle(int_tipo,const_direccion,int_tamao);
TIPO DE LETRAS
VALOR
DESCRIPCIN
DESCRIPCIN
ABC
HORIZ_DIR
En Horizontal.
ABC
VERT_DIR
En Vertical.
ABC
3
4
ABC
ABC
ABC
ABC
ABC
A B C (tamao grande).
10
(tamao grande)
11
ALINEAR TEXTO:
ABC
HORIZONTAL
VERTICAL
CONST.
DESCRIPCIN
CONST.
DESCRIPCIN
LEFT_TEXT
Alineacin izquierda.
TOP_TEXT
Alineacin superior.
CENTER_TEXT
Alineacin centrada.
CENTER_TEXT
Alineacin centrada.
RIGHT_TEXT
Alineacin derecha.
BOTTOM_TEXT
Alineacin inferior.
VER TEXTO:
COPIAR IMAGEN:
Existen tres funciones grficas relacionadas entre si, que permiten copiar y mover
objetos grficos por la pantalla. Las tres tienen la cabecera <graphics.c>. Deben estar
siempre las tres para funcionar. El modo de trabajo es: copiar una zona de la pantalla a
la memoria (utilizando un puntero), asignar la memoria necesaria y, mostrar la imagen.
GETIMAGE:
Copia el contenido del rectngulo definido por las cuatro coordenadas (tipo int) y lo
guarda en memoria mediante un puntero. Cabecera <graphics.h>.
getimage(x1,y1,x2,y2,puntero);
IMAGESIZE:
PUTIMAGE:
Muestra en pantalla una imagen obtenida por getimage(). El puntero es quien contiene la
imagen y la sita en la posicin dada por x,y. El modo en que se muestra esta definido
por 5 constantes. Cabecera <graphics.h>.
putimage(x,y,puntero,modo);
CONST.
VALOR
DESCRIPCIN
COPY_CUT
Copia la imagen.
XOR_PUT
OR_PUT
AND_PUT
NOT_PUT
}
17. FICHEROS
El sistema de archivos de C est diseado para secuencias que son independientes del dispositivo.
Existen dos tipos se secuencias: de texto que es una ristra de caracteres organizados en lneas terminadas por
el carcter salto de lnea. Secuencia binaria que es una ristra de bytes con una correspondencia uno a uno con
los dispositivos. En esencia C trabaja con dos tipos de archivo secuenciales (texto) y binarios (registros).
Todas las operaciones de ficheros se realizan a travs de llamadas a funciones que estn definidas en en
fichero de cabecera CONIO.H o IO.H. Esto permite una gran flexibilidad y facilidad a la hora de trabajar con
ficheros.
Mediante una operacin de apertura se asocia una secuencia a un archivo especificado, esta operacin de
apertura se realiza mediante un puntero de tipo FILE donde estn definidas las caractersticas del fichero
(nombre, estado, posicin,). Una vez abierto el fichero escribiremos y sacaremos informacin mediante las
funciones implementadas y por ltimo cerraremos los ficheros abiertos.
ABRIR FICHERO:
La funcin fopen abre una secuencia para que pueda ser utilizada y vinculada con un
archivo. Despus devuelve el puntero al archivo asociado, si es NULL es que se ha
producido un error en la apertura. Se utiliza un puntero de tipo FILE para abrir ese
fichero. Sirve para los dos tipos de ficheros. Cabecera <stdio.h>.
FILE *nombre_puntero_fichero;
fopen(char_nombre_archivo,char_modo_apertura);
MODOS DE APERTURA
VALOR
CIERRE FICHERO:
DESCRIPCIN
rb
wb
ab
r+
w+
a+
r+b
w+b
a+b
Una vez terminadas las operaciones de escritura y lectura hay que cerrar la secuencia
(archivo). Se realiza mediante la llamada a la funcin fclose() que cierra un fichero
determinado o fcloseall() que cierra todos los archivos abiertos. Estas funciones
escribe la informacin que todava se encuentre en el buffer y cierra el archivo a nivel
de MS-DOS. Ambas funciones devuelve CERO si no hay problemas. La cabecera que
utilizan es <stdio.h>.
int fclose(puntero_fichero);
int fcloseall();
EJEMPLO:
#include <stdio.h>
void main(void)
{
FILE *punt_fich;
clrscr();
if((punt_fich=fopen("hla.txt","a"))==NULL)
{
printf("Error en la apertura");
exit(0);
}
.
.
.
operaciones lectura/escritura
.
.
.
fclose(punt_fich);
}
Escribe un carcter en el fichero abierto por el puntero que se pone como parmetro. Si
todo se produce correctamente la funcin devuelve el propio carcter, si hay algn error
devuelve EOF. La cabecera que utiliza es <stdio.h>.
int fputc(variable_char,puntero_fichero);
int fputc(carcter,puntero_fichero);
int putc(variable_char,puntero_fichero);
int putc(carcter,puntero_fichero);
FPUTS:
FPRINTF:
Escribe en el fichero cualquier tipo de valor, cadenas, nmeros y caracteres. Esta funcin
tiene el mismo formato que printf. Hay que indicarle el puntero, el identificador de formato y
nombre de la variables o variables a escribir. Cabecera <stdio.h>.
fprintf(puntero_fichero,texto);
fprintf(puntero_ficheroidentificador,var);
fprintf(puntero_fichident(es)_formato,variable(s));
EJEMPLO:
#include <stdio.h>
#include <string.h>
void letra(void);
void frase(void);
FILE *punt_fich;
void main(void)
{
int opt;
clrscr();
if((punt_fich=fopen("hla.txt","w"))==NULL)
{
printf("Error en la apertura");
exit(0);
}
printf("1.INTRODUCIR LETRA A LETRA\n");
printf("2.INTRODUCIR CADENA A CADENA\n\n");
printf("Elegir opcion: ");
scanf("%d",&opt);
fflush(stdin);
clrscr();
(SIGUE)
switch(opt)
{
case 1:
letra();
break;
case 2:
frase();
break;
}
fclose(punt_fich);
}
void letra(void)
{
char t;
for(;t!='$';)
{
printf(":");
t=getchar();
fputc(t,punt_fich);
fflush(stdin);
}
}
void frase(void)
{
char *frase;
do
{
printf(":");
gets(frase);
fprintf(punt_fich,"%s\n",frase);
// fputs(frase,punt_fich);
fflush(stdin);
}while(strcmp(frase,"$"));
}
LECTURA DE CARACTERES Y CADENAS EN SECUENCIALES
FGETC/FGET:
Devuelve el carcter ledo del fichero e incrementa el indicador de posicin del archivo.
Si se llega al final del fichero la funcin devuelve EOF. Todos los valores que lee los
transforma a carcter. Cabecera es <stdio.h>.
var_char=fgetc(puntero_fichero);
var_char=getc(puntero_fichero);
FGETS:
}
printf("1.LEER LETRA A LETRA\n");
printf("2.LEER CADENAS\n\n");
printf("Elegir opcion: ");
scanf("%d",&opt);
fflush(stdin);
clrscr();
switch(opt)
{
case 1:
letra();
break;
case 2:
frase();
break;
}
getch();
fclose(punt_fich);
}
(sigue)
void letra(void)
{
char t=0;
for(;t!=EOF;)
{
t=getc(punt_fich);
printf("%c",t);
}
}
void frase(void)
{
char frase[31];
fgets(frase,30,punt_fich);
printf("%s",frase);
}
POSICION EN FICHEROS SECUENCIALES Y BINARIOS
REWIND:
Lleva el indicador de posicin al principio del archivo. No devuelve ningn valor. La cabecera
que utiliza es <stdio.h>.
rewind(puntero_fichero);
FGETPOS: Guarda el valor actual del indicador de posicin del archivo. El segundo termino es un objeto
del tipo fpos_t que guarda la posicin. El valor almacenado slo es valido para posteriores
llamadas a fsetpos. Devuelve DISTINTO DE CERO si se produce algn error y CERO si todo
va bien. Cabecera <stdio.h>.
int fgetpos(puntero_fichero,&objeto_fpos_t);
FSETPOS: Desplaza el indicador de posicin del archivo al lugar especificado por el segundo termino
que es un objeto fpos_t. Este valor tiene que haber sido obtenido por una llamada a fgetpos.
Devuelve DISTINTO DE CERO si hay errores y CERO si va todo bien. Cabecera <stdio.h>.
int fsetpos(puntero_fichero,&objeto_fpos_t);
TELL:
Devuelve el valor actual del indicador de posicin del archivo. Este valor es el nmero de
bytes que hay entre el comienzo del archivo y el indicador. Devuelve 1 si se produce un
error. Cabecera <io.h>.
var_long =tell(puntero_fichero);
FEOF:
Determina el final de un fichero binario. Se utiliza siempre que se realizan consultas, informes
y listados, va asociado a un bucle que recorre todo el fichero. Cabecera <stdio.h>.
feof(puntero_fichero);
FSEEK:
Sita el indicador del archivo en la posicin indicada por la variable de tipo long (en segundo
termino) desde el lugar que le indiquemos mediante el tercer termino de la funcin (mediante
una constante). Devuelve 1 si hay error, si no hay error devuelve la nueva posicin. La
Cabecera es <io.h>.
var_long=fseek(puntero_fichero,long_despl,int_origen);
CONSTANTE
DESCRIPCIN
SEEK_SET
SEEK_CUR
SEEK_END
EJEMPLO:
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
FILE *punte;
clrscr();
if((punte=fopen("hla.txt","r"))==NULL)
{
printf("Error de lectura");
exit(0);
}
fseek(punte,7,SEEK_SET);
printf("%c",fgetc(punte));
getch();
fclose(punte);
}
Escribe los datos de una estructura a un fichero binario e incrementa la posicin del
archivo en el nmero de caracteres escritos. Hay que tener en cuenta que el modo de
apertura del fichero debe ser binario Cabecera <stdio.h>.
fwrite(&eti_estru,tamao_estru,n_reg,punter_fichero);
FREAD:
Lee registros de un fichero binario, cada uno del tamao especificado en la funcin y los
sita en la estructura indicada en primer termino de la funcin. Adems de leer los
registros incrementa la posicin del fichero. Hay que tener en cuenta el modo de apertura
del fichero. Cabecera <stdio.h>.
fread(&eti_estru,tamao_estru,n_reg,punter_fichero);
EJEMPLO:
#include<stdio.h>
#include<ctype.h>
void altas(void);
void muestra(void);
FILE *fich;
struct ficha{
int cdigo;
char nombre[25];
char direcion[40];
int edad;
}cliente;
void main(void)
{
char opcion;
if((fich=fopen("gestion.dat","a+b"))==NULL)
{
printf("Error al crear fichero");
exit(0);
}
do
{
clrscr();
printf("Altas\n");
printf("Consulta\n");
printf("Salir\n\n");
printf("Elegir opcion: ");
scanf("%c",&opcion);
fflush(stdin);
switch(toupper(opcion))
{
case 'A':
altas();
break;
case 'C':
muestra();
break;
}
}while(toupper(opcion)!='S');
fclose(fich);
}
void altas(void)
{
clrscr();
printf("Cdigo: ");
scanf("%d",&cliente.codigo);
fflush(stdin);
printf("Nombre: ");
gets(cliente.nombre);
fflush(stdin);
printf("Direccion: ");
gets(cliente.direcion);
fflush(stdin);
printf("Edad: ");
scanf("%d",&cliente.edad);
fflush(stdin);
fwrite(&cliente,sizeof(cliente),1,fich);
}
void muestra(void)
{
int cod_temp;
clrscr();
rewind(fich);
printf("Cdigo a mostrar:");
scanf("%d",&cod_temp);
while(!feof(fich))
{
fread(&cliente,sizeof(cliente),1,fich);
if(cod_temp==cliente.codigo)
{
printf("Cdigo: %d\n",cliente.codigo);
printf("Nombre: %s\n",cliente.nombre);
printf("Direc: %s\n",cliente.direcion);
printf("Edad: %d\n",cliente.edad);
getch();
break;
}
}
}
Autor : Ricardo Amezua Martinez (netamezua@mixmail.com)
Para Softdownload Argentina
www.softdownload.com.ar
info@softdownload.com.ar
Ao 2001