Turbo c++
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
  • Hola gracias Kevin, por compartir conocimiento
    Are you sure you want to
    Your message goes here
    Be the first to like this
No Downloads

Views

Total Views
8,966
On Slideshare
8,966
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
166
Comments
1
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. © Rodolfo Gallardo-Rosales Programación en Lenguaje C Universidad de Colima Colima, Col.Copyright© 2001 por Rodolfo Gallardo-Rosales rodolfo@gallardo.cc http://www.gallardo.cc Tutorial Turbo C
  • 2. © Rodolfo Gallardo-RosalesProgramación en Lenguaje C avanzadoEstado del presente documentoEste documento es un manual rápido para aprender a programar en Lenguaje C,dedicado en especial a los estudiantes de programación en Lenguaje C, que es editadocon el propósito de complementar la información que pueda ser encontrada en el mercado,uniendo el análisis de varios textos en un solo documento.IntroducciónEl lenguaje C fué implementado e inventado por Dennis Ritchie en un DEC PDP-11 bajoUNIX; basado en dos lenguajes anteriores: BCPL de Martín Richards y B de KenThompson.C es un lenguaje de nivel medio, porque combina elementos de lenguajes de alto nivel conla funcionalidad del ensamblador; es portable, porque si se escribe para un tipo decomputadora, se puede adaptar a otra.Aunque es un lenguaje estructurado, no permite la creación de funciones dentro defunciones.El componente estructural principal de C es la función.Tabla de contenidos 1. El entorno de Turbo C 1.1. Sumario de las órdenes del menú principal 1.2. Abreviaturas del teclado de Turbo C 1.3. Uso del editor de Turbo C 2. Lenguaje C 2.1. Introducción 2.2. Variables, constantes, operadores y expresiones 2.3. Sentencias de control de programa 2.4. Funciones 2.5. Arrays Tutorial Turbo C
  • 3. © Rodolfo Gallardo-Rosales 2.6. Punteros 2.7. Estructuras, uniones y variables definidas por el usuario 2.8. Entrada, salida y archivos de disco 2.9. El preprocesador de Turbo C 2.10. Funciones gráficas y de pantalla3. La biblioteca de Turbo C 3.1. Funciones de E/S 3.2. Funciones de cadenas, memoria y caracteres 3.3. Funciones matemáticas 3.4. Funciones de hora, fecha y otras del sistema 3.5. Funciones de aignación dinámica de memoria 3.6. Funciones de directorio 3.7. Funciones de control de procesos 3.8. Funciones de gráficos y de la pantalla de texto 3.9. Funciones variadas4. Librería de programas5. Bibliografía Tutorial Turbo C
  • 4. © Rodolfo Gallardo-Rosales1. El entorno de Turbo C1.1. Sumario de las órdenes del menú principal Elemento Opciones File Carga y graba archivos, maneja directorios, invoca a DOS y termina Edit Invoca al editor de Turbo C Run Compila, enlaza y ejecuta el programa cargado Compile Compila el programa cargado Project Gestiona proyectos de varios archivos Options Diversas opciones de compilación y enlazado Debug Diversas opciones de depuración Break/Watch Inspecciona expresiones y puntos de ruptura Menú File Sub-elemento Acción Load Cargar programa Pick Escoger programa New Nuevo programa Save Guardar programa Write to Escribir en... Directory Directorio Change dir Cambiar directorio OS shell Sale temporalmente a MS_DOS Quit Terminar Menú Edit Se activa el editor de Turbo C Menú Run Sub-elemento Acción Run Ejecutar programa Program reset Reinicialización de programa Goto cursor Ejecutar programa hasta donde está el cursor Trace into Trazar dentro Step over Saltarse User screen Pantalla del usuario Tutorial Turbo C
  • 5. © Rodolfo Gallardo-RosalesMenú CompileSub-elemento AcciónCompile to OBJ Compilar a archivo .OBJMake EXE file Crear archivo .EXELink EXE file Enlazar archivo .EXEBuild all Construír todoPrimary C file Archivo primario de CGet info Obtener informaciónMenú ProjectSub-elemento AcciónProject name Nombre del proyectoBreak make on Detener la creación por...Auto dependencies Auto dependenciasClear project Termina con proyectoRemove messages Eliminar mensajesMenú OptionsSub-elemento AcciónCompiler CompiladorLinker EnlazadorEnvironment EntornoDirectories DirectoriosArguments ArgumentosSave options Guardar opcionesRetrieve options Recuperar opcionesMenú DebugSub-elemento AcciónEvaluate EvaluarCall stack Pila de llamadaFind function Encontrar funciónRefresh display Refrescar pantallaDisplay swapping Cambio de pantallaSource debugging Depuración de fuente Tutorial Turbo C
  • 6. © Rodolfo Gallardo-Rosales Menú Break/Watch Sub-elemento Acción Add watch Añadir inspector Delete watch Borrar inspector Edit Watch Editar inspector Remove all Elimina todos los inspectores watches Toggle breakpoint Poner o quitar puntos de ruptura Clear all Quitar todos los puntos de ruptura breakpoints View next Ver siguiente punto de ruptura breakpoint1.2. Abreviaturas del teclado de Turbo C Abreviatura Acción F1 Ayuda F2 Grabar archivo F3 Carga archivo F4 Ejecuta hasta cursor F5 Amplía ventana F6 Cambio entre ventanas F7 Traza dentro de llamadas a función F8 Traza sin entrar a función F9 Compila y enlaza F10 Cambia entre editor y menú Alt-F1 Ultima pantalla de ayuda Alt-F3 Escoge archivo a cargar Alt-F5 Cambia entre pantalla de usuario y editor Alt-F6 Cambia entre ventanas de inspección y mensajes Alt-F7 Error anterior Alt-F8 Error siguiente Alt-F9 Compila a .OBJ Alt-C Menú Compile (Compila) Alt-D Menú Debug (Depurador) Alt-E Menú Edit (Editar) Alt-F Menú File (Archivo) Alt-O Menú Options (Opciones) Alt-P Menú Project (Proyecto) Alt-R Menú Run (Ejecutar) Alt-X Sale de Turbo C Tutorial Turbo C
  • 7. © Rodolfo Gallardo-Rosales Ctrl-F1 Ayuda donde está el cursor Ctrl-F2 Devuelve programa a estado inicial Ctrl-F3 Muestra Call stack Ctrl-F4 Evalúa expresiones Ctrl-F7 Inspecciona expresión Ctrl-F8 Activa/Desactiva breakpoint Ctrl-F9 Ejecuta programa actual1.3. Uso del editor de Turbo C Ordenes de cursor Acción Ctrl-R Mover una pantalla hacia arriba (RePág) Ctrl-C Mover una pantalla hacia abajo (AvPág) Inicio Va a inicio de línea Fin Va a fin de línea Ctrl-RePág Principio de archivo Ctrl-AvPág Fin de archivo Ctrl-Inicio Principio de pantalla Ctrl-Fin Fin de pantalla Ordenes de borrado Acción Ctrl-Y Borra línea completa Ctrl-QY Borra hasta fin de línea Ctrl-T Borra palabra a la derecha del cursor Ordenes de bloque Acción Ctrl-KB Marca comienzo de bloque Ctrl-KK Marca fin de bloque Ctrl-KT Marca palabra Ctrl-KC Copia bloque marcado Ctrl-KY Borra bloque marcado Ctrl-KH Oculta o muestra bloque Ctrl-KV Mueve bloque marcado Ctrl-KW Escribe bloque marcado a disco Ctrl-KR Lee bloque marcado de disco Ctrl-KP Imprime bloque marcado Ordenes de búsqueda Acción Ctrl-QF Buscar Ctrl-QA Buscar y reemplazar Ctrl-L Repite búsqueda Tutorial Turbo C
  • 8. © Rodolfo Gallardo-Rosales2. Lenguaje C2.1. IntroducciónUna forma típica de estructuración en C es mediante el uso de bloques de código, que es ungrupo de sentencias conectadas en forma lógica que es tratado como una unidad. En C secolocan entre llaves. Ejemplo: if (x<10){ printf("demasiado pequeño, pruebe de nuevo..."); reini_contador(-1); } El bloque se ejecuta sólo si x es menor que 10. C tiene sólo 43 palabras clave: 32 definidas por el estándar ANSI auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while 11 añadidas por Turbo C asm _cs _ds _es _ss cdecl far huge interrupt near pascalTodos los programas en C consisten de una o más funciones. La única que debe estarabsolutamente presente es la demçnominada main() Tutorial Turbo C
  • 9. © Rodolfo Gallardo-RosalesLa forma general de un programa en C es: declaraciones globales main() { variables locales secuencia de sentencias } f1() { variables locales secuencia de sentencias } f2() { variables locales secuencia de sentencias } . . . fn() { variables locales secuencia de sentencias } Términos más frecuentes usados en la programación en Turbo C: Código fuente: Texto de un programa, es la entrada al compilador, su extensión es .C Código objeto: Traducción del código fuente a código máquina, es la entrada al enlazador, su extensión es .OBJ Enlazador: Programa que enlaza funciones para prodiçucir un solo programa, su salida es el código ejecutable, cuya extensión es .EXE Biblioteca: Archivos que contienen las funciones estándar de C Tutorial Turbo C
  • 10. © Rodolfo Gallardo-Rosales Tiempo de compilación: Lo que sucede mientras un programa es compilado Tiempo de ejecución: Lo que sucede mientras un programa es ejecutado2.2. Variables, constantes, operadores y expresionesExisten 5 tipos de datos atómicos: carácter, entero, punto flotante, punto flotante de dobleprecisión, y sin valor. Tamaño y rango: Tipo Tamaño en bits Rango char 8 0..255 int 16 -32768..32767 float 32 3-4E-38..3-4E+38 double 64 1.7E-308..1.7E+308 void 0 sin valor char: valores definidos en caracteres ASCII int: variables enteras float y double: variables reales void: sirve para a. declarar una función que no devuelva un valor b. declarar una función sin parámetros c. crear punteros genéricos Modificadores: signed, unsigned, short, long: para variables int y char long: para variables double const: variables que no pueden ser cambiadas durante la ejecución del programa ejemplo: const int a; /*no está inicializada*/ const int cuenta=100; /*ya inicializada*/ volatile: indica que puede cambiar por medios no especificados explícitamente. Tutorial Turbo C
  • 11. © Rodolfo Gallardo-Rosales Declaración de variables La forma general es: tipo lista_de_variables; ejemplos: int i, j, l; short int si; unsigned int u; double balance, beneficio, perdida; Variables locales: son las que se declaran dentro de una función, son conocidas sólodentro del bloque de código. ejemplo: void func1(void) { int x; x=10; } otro ejemplo: void f(void) { int t; scanf ("%d",&t); if (t==1){ char s[80]; /*se crea al entrar al bloque*/ printf("introduzca el nombre"); gets(s); procesar(s); } /*aquí no se conoce s*/ }Parámetros formalesSi una función va a usar argumentos, debe declarar las variables que van a aceptar losvalores de los argumentos. Se deben dar tras el nombre de la función y entre paréntesis. Tutorial Turbo C
  • 12. © Rodolfo Gallardo-Rosales ejemplo: /*devuelve 1 si c es parte de la cadena, si no devielve un 0*/ esta_en(char s, char c) { while (*s) if (*s==c) return 1; else s++; return 0; }Variables globalesSon las que se conocen a lo largo de todo el programa y se pueden usar en cualquier partedel código, además mantiene su valor durante toda la ejecución del programa; se crean aldeclararse fuera de todas las funciones.Actividad:>> Desarrollar en TC los programas ejemplo Nos. 1 y 2Especificadores de clase de almacenamiento Son cuatro especificadores: extern static register auto su forma general es:especificador_de_almacenamiento tipo nombre_de_variable;-> externSe usa para compilar programas por separado; en uno de ellos se declaran las variablesglobales, y en los otros, como extern. Tutorial Turbo C
  • 13. © Rodolfo Gallardo-Rosales Archivo 1 Archivo 2 Archivo 3 int x,y; extern int x,y; extern int x,y; char ch; extern char ch; extern char ch; main(void) void func1(void) void func2(void) { { { --------- --------- --------- --------- --------- --------- --------- --------- --------- } } } -> Variables estáticas (locales) Son variables permanentes que mantienen su valor entre llamadas, si no se permitiera usarstatic, habría que usar variables globales. Un ejemplo se ilustra con la función cuenta().Actividad:>> Desarrollar en TC los programas ejemplo Nos. 3 y 4 -> Variables estáticas (globales)Indican al compilador que cree una variable global sólo en éste archivo, por lo que lasrutinas de otros archivos no la reconocerán ni alterarán. ejemplo: /*debiera estar en un sólo archivo*/ static int num; int series(void); void comienza_series(int semilla); series(void) { num=num+23; return (num); } /*inicialización de num*/ void comienza_series(int semilla) { num=semilla; } Tutorial Turbo C
  • 14. © Rodolfo Gallardo-Rosales -> Variables registroLas operaciones sobre variables registro son mucho más rápidas que sobre variablesguardadas en memoria. Cuando una variable está realmente guardada en la CPU norequiere acceso a memoria para determinar o modificar su valor.Son ideales para el control de bucles. ejemplo: pot_ent(int m, register int e) { register int temp; temp=1; for (;e;e--) temp *=m; return temp; } Sentencias de asignación Su forma general es: nombre_de_variable=expresión;donde expresión puede ser una constante o una combinación de variabñes, operadores yconstantes.Conversión de tipo en las asignacionesCuando se mezclan variables de un tipo con variables de otro, se da la conversión de tipo;el valor del lado derecho se convierte al tipo del lado izquierdo. ejemplo: int x; char ch; float f; void func(void) { ch=x; /*x ahora es caracter*/ x=f; /*f ahora es entero*/ Tutorial Turbo C
  • 15. © Rodolfo Gallardo-Rosales f=ch; /*ch ahora es flotante*/ f=x; /*x ahora es flotante*/ } Inicialización de variablesSe hace colocando el signo igual y una constante después del nombre de una variable. Forma general: tipo nombre_de_variable=constante; ejemplos: char ch=a; int primero=0; float balance=123.45;ConstantesSon valores fijos que no pueden ser alterados por el programa. Una constante de cadena,será entre " ", como "es una prueba". La de un solo carácter, con comillas simples, como ena. ejemplos: char a, n, 9 int 1, 123, 21000, -234 long int 35000, -34 short int 10, -12, 90 unsigned int 10000, 987, 40000 float 123.45, 4.34e-3 double 12345.67, 112356476, -0.9876756Constantes de carácter con barra invertidaAlgunos caracteres no se pueden traducir desde el teclado, como el <cr>, por ejemplo: c=t; printf("esto es una prueban");Asigna tabulación a c y escribe la cadena y <cr> Tutorial Turbo C
  • 16. © Rodolfo Gallardo-RosalesCódigos de barra invertida Código Significado b Espacio atrás f Salto de página n Salto de línea r Retorno de carro t Tabulación horizontal " Comillas dobles Comilla simple 0 Nulo Barra invertida v Tabulación vertical a Alerta o Constante octal x Constante hexadecimalOperadoresSímbolos que indican al compilador que efectúe ciertas manipulaciones matemáticas ológicas. -> Operadores aritméticos - Resta y menos monario + Suma * Multiplicación / División % División en módulo -- Decremento ++ Incremento ejemplo: int x, y; x=10; y=3; printf ("%d", x/y); /*muestra 3*/ printf ("%d", x%y); /*muestra 1*/ Tutorial Turbo C
  • 17. © Rodolfo Gallardo-Rosales Respecto a incremento y decremento: x=x+1; equivale a ++x; x=x-1; equivale a --x;Operadores relacionales y lógicosRelacional: se refiere a la relación entre unos valores y otros.Lógico: se refiere a las formas en que las relaciones se pueden conectar entre sí siguiendolas reglas de la lógica formal. -> Operadores relacionales: > Mayor que >= Mayor que o igual a < Menor que <= Menor que o igual a == Igual a != No igual a -> Operadores lógicos && And (Y) || Or (O) ! Not (NO) Tabla de verdad de los operadores lógicos p q p&&q p||q !p 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 1 1 1 1 0 Operadores a nivel de bits Se refieren a la comprobación, asignación o desplazamiento de los bits reales que componen un byte o una palabra. Tutorial Turbo C
  • 18. © Rodolfo Gallardo-Rosales-> Operadores a nivel de bits& Y| O^ = exclusiva (XOR)~ Complemento a uno>> Desplazamiento a la derecha<< Desplazamiento a la izquierdaTabla de verdad de XORp q p^q0 0 00 1 11 0 11 1 0Un ejemplo de uso:char obtener_car_del_modem(void){ char c; c=leer_modem(); return (c&127);}El & pone el bit de paridad a cero. Suponiendo que se ha recibido una letraA, entonces:11000001 A con paridad 101111111 127-------- &01000001 A sin paridadEl | pone el bit de paridad a uno, por ejemplo:01000001 A sin paridad10000000 128-------- |11000001 A con paridad 1La ^ pone a uno sólo los bits que al compararse sean distintos, por ejemplo: Tutorial Turbo C
  • 19. © Rodolfo Gallardo-Rosales01111111 12701111000-------- ^00000111Los operadores >> y << mueven todos los bits a la derecha o izquierda, porejemplo:x=7 00000111 7x=x<<1; 00001110 14x=x<<3; 01110000 112x=x<<2; 11000000 192x=x>>1; 01100000 96x=x>>2; 00011000 24El operador de complemento a uno (~) cambia el estado de cada bit en lavariable especificada, por ejemplo:byte original 001011001er. complemento 110100112do. complemento 00101100-> El operador ?Operador ternario que puede usarse para sustituir ciertas sentencias de laforma if-then-else.Su forma general es:expresión1? expresión2: expresión3;Ejemplo:Forma ? Forma if-then-elsex=10; x=10;y=x>9? 100: 200; if (x>9) y=100; else y=200;-> Los operadores de puntero & y *Un puntero es la dirección de memoria de una variableejemplo: Tutorial Turbo C
  • 20. © Rodolfo Gallardo-Rosalesm=&cont;coloca en m la dirección de memoria de la variable cont, supongamos que seala posición de memoria 2000, m tendrá el valor de 2000.si anotamos: q=*m;entonces, devuelve a q el valor ubicado en la dirección de memoria que seespecifica, devolverá cont.Las variables que vayan a mantener direcciones de memoria, se declararáncolocando un * delante del nombre.ejemplo:char *c;int x, *y, cont;código ejemplo:main(void){ int destino, fuente; int *m; fuente=10; m=&fuente; destino=*m; return 0;}-> El operador de tiempo de compilación sizeofEs un operador monario que devuelve la longitud en bytes, de la variableentre paréntesis.Es muy útil para desarrollar código a ejecutarse en diferentes entornos, porejemplo:poner_reg(FILE *fp, int reg[6]){ int long num; Tutorial Turbo C
  • 21. © Rodolfo Gallardo-Rosales longit=sizeof(reg); num=fwrite(reg,longit,l,fp); if (num<>1) printf ("error de escritura...");}-> La coma como operadorLa coma encadena varias expresiones. La parte izquierda se evalúa como void,y el valor de la derecha tomará el valor total de la expresión.ejemplo:x=(y=3, y+1); /*x vale 4*/y=10;x=(y=y-5, 25/y); /*x vale 5*/-> Los operadores . y ->hacen referencia a elementos individuales de las estructuras y las uniones,tipos de datos compuestos denominados bajo un solo nombre.El punto se usa cuando se trabaja realmente con la estructura o la unión. Eloperador flecha, cuando se usa un puntero a una estructura.ejemplo:struct empleado{ char nombre[80]; int edad; float sueldo;}emp;Para asignar el valor 123.45 al elemento sueldo de la estructura emp, serealizaría así:emp.sueldo=123.45;y usando un puntero a la estructura emp, sería de esta manera:emp->sueldo=123.45; Tutorial Turbo C
  • 22. © Rodolfo Gallardo-Rosales -> Los operadores [] y () En C los paréntesis son operadores que aumentan la precedencia de las operaciones. Los corchetes llevan a cabo el indexamiento de arrays. Dado un array, la expresión entre corchetes proporciona un índice para el array. Actividad >> Desarrollar en TC los programas ejemplo Nos. 5 y 62.3. Sentencias de control de programa Sentencias condicionales C soporta dos tipos de sentencias condicionales: if y switch. if La forma general es: if (expresión) sentencia; else (sentencia); donde sentencia puede ser simple o un bloque de sentencias. Else es opcional. Con bloques de sentencias, la forma general será: if (expresión){ secuencia_de_sentencias } else{ secuencia_de_sentencias } Actividad: >> Desarrollar en TC los programas ejemplo Nos. 7 y 8 ifs anidados Se deben usar llaves para saltarse la asociación normal, por ejemplo: if (x){ if (y) printf("1"); Tutorial Turbo C
  • 23. © Rodolfo Gallardo-Rosales}else printf ("2");Para ver el programa "mágico" mejorado se sugiere la siguienteActividad:>> Desarrolar en TC los programas ejemplo Nos. 9 y 10La escala if-else-ifSu forma general es:if (expresión) sentencia;else if (expresión) sentencia;else if (expresión) sentencia;else sentencia;Utilizando lo anterior, se puede mejorar el programa mágico, para lo que sesugiere la siguienteActvidad:>> Desarrollar en TC los programas ejemplo Nos. 11 y 12La alternativa ?Su forma general es:expresión1? expresión2: expresión3;Para ver el programa mágico con esta alternativa, se sugiere la siguienteActividad:>> Desarrollar en TC los programas ejemplo Nos. 13 y 14 Tutorial Turbo C
  • 24. © Rodolfo Gallardo-RosalesswitchSentencia de decisión de ramificación múltiple.Forma general:switch (variable){ case constante1: secuencia_de_sentencias break; case constante2: secuencia_de_sentencias break; case constante3: secuencia_de_sentencias break; . . . default: secuencia_de_sentencias}default se ejecuta sólo si no se encuentra ninguna correspondencia.ejemplo:void menu(void){ char c; printf("1. Comprobar ortografían"); printf("2. Corregir errores ortográficosn"); printf("3. Mostrar errores ortográficos"); printf("Pulse cualquier otra tecla para terminar..."); printf("Introduzca su opción..."); c=getche(); switch (c){ case 1: comprobar_ortografia(); break; case 2: corregir_errores(); Tutorial Turbo C
  • 25. © Rodolfo Gallardo-Rosales break; case 3: mostrar_errores(); break; default: printf("Ninguna opción seleccionada..."); }}Sentencias switch anidadasCuando un switch forma parte de la secuencia de otro switch, por ejemplo:switch(x){ case 1: switch (y){ case 0: printf ("división por cero"); break; case 1: procesar (x, y); } break; case 2:}Bucles for, while y doforSu forma general es:for (inicialización;condición;incremento) sentencia;inicialización normalmente es una sentencia de asignación, también llamadavariable de controlcondición es una expresión relacional que determina cuándo finaliza el bucleincremento define cómo cambia la variable de controlActividad:>> Desarrollar en TC los programas ejemplo Nos. 15 y 16Con múltiples sentencias, se maneja como un bloque. Tutorial Turbo C
  • 26. © Rodolfo Gallardo-Rosalesejemplo:for (x=100;x!=65;x-=5) { z=sqrt(x); printf ("La raíz cuadrada de %d, es %f", x, z);}Otro ejemplo sería:void conexión(void){ char cad[20]; int x; for(x=0;x<3&&strcmp(cad,"clave");++x){ printf("Password:"); gets(cad); } if(x==3) cerrar();}El bucle infinitoSe realiza dejando la expresión condicional vacía, por ejemplo:for(;;) printf ("Este bucle estará siempre ejecutándosen");La sentencia break, se usará para dar fin al bucle, por ejemplo:c=0;for(;;){ c=getchar(); /*obtener un caracter*/ if (c==A) break; /*salir del bucle*/}printf("Ha pulsado una A...")este bucle se ejecutará hasta que se pulse una "A"Los bucles for sin cuerpoPueden aplicarse para aumentar la eficiencia de algunos algoritmos o paraoriginar retardos. Tutorial Turbo C
  • 27. © Rodolfo Gallardo-Rosalesejemplo:for(t=0;t<ALGUN_VALOR;t++);El bucle whileForma general:while (condicion) sentencia;sentencia puede ser vacía, simple o bloque; condición, puede ser cualquierexpresión, diferente de 0ejemplo:void esperar_caracter(void){ char c; c=0; /*inicializa c*/ while (c!=A) c=getchar();}do/whileAnaliza la condición al final del bucle. El bucle se ejecuta al menos unavez. Su forma general es:do{ secuencia_de_sentencias}while (condición);ejemplo:do{ scanf("%d",&num);}while(num>100);Lee los números del teclado hasta que encuentra uno menor o igual que 100.Quizás el uso más común es en rutinas de seleción por menú.Ejemplo:void menu(void) Tutorial Turbo C
  • 28. © Rodolfo Gallardo-Rosales{ char c; printf("1. Comprobar ortografían"); printf("2. Corregir erroresn"); printf("3. Mostrar erroresn"); printf("Introduzca su opción..."); do{ c=getche(); switch(c){ case 1: comprobar_ortografia(); break; case 2: corregir_errores(); break; case 3: mostrar errores(); break; } }while (c!=1&&c!=2&&c!=3);}breakTiene dos usos: para finalizar un case en switch o forzar la terminación deun bucle.ejemplo:Cuando encuentra break dentro del bucle, éste finaliza de inmediato.Actividad:>> Desarrollar en TC los programas ejemplo Nos. 17 y 18ejemplo:El siguiente código, puede detener la ejecución del bucle al presionar unatecla. "kbhit()" devuelve 0 si no se presiona una tecla.localiza (char *nombre){ char tnombre[40]; Tutorial Turbo C
  • 29. © Rodolfo Gallardo-Rosales int pos; pos=-1; do { pos=leer_sig_nombre(tnombre); if (kbhit()) break; }while (!strcmp(tnombre, nombre)); return pos;}exit()Esta función permite salir anticipadamente de un programa, y forzar la vueltaal sistema operativo.forma general:void exit(int estado);Generalmente estado devuelve un cero (0 se usa como argumento paraterminación normal)ejemplo:mein(void){ if (!tarjeta_color()) exit(1); jugar(); return 0;}Como otro ejemplo, podemos considerar el uso de exit() en una versión de lafunción menu() para abandonar el programa y volveer al sistema operativo.void menu(void){ char c; printf("1. Comprobar ortografían"); printf("2. Corregir erroresn"); printf("3. Mostrar erroresn"); printf("4. Salirn"); printf("Introduzca su opción..."); do{ Tutorial Turbo C
  • 30. © Rodolfo Gallardo-Rosales c=getchar(); switch(c){ case 1: comprobar(); break; case 2: corregir(); break; case 3: mostrar(); break; case 4: exit(0); } }while (c!=1&&c!=2&&c!=3); } continue Funciona de manera similar a break, pero en vez de forzar la terminación, forza una nueva iteración del bucle. Por ejemplo: do{ scanf("%d", &num); if(x<0) continue; printf("%d",x); }while(x!=100); esta fracción de código, muestra sólo números positivos.2.4. Funciones Las funciones son los bloques constructores de C y el lugar donde se da toda la actividad del programa. Su forma general es: especificador_de_tipo nombre_de_función(lista_de_parámetros) { cuerpo_de_la_función } especificador_de_tipo: es el tipo de valor que devuelve la sentencia return de la función. Si no se especifica ninguno, asume que es un entero. Tutorial Turbo C
  • 31. © Rodolfo Gallardo-Rosaleslista_de_parámetros: son los parámetros separados por comas, que son losargumentos cuando se llama a la función. Si no tiene parámetros, contiene lapalabra "void".returnTiene dos usos importantes: primero, una salida inmediata de la función, oque vuelva al código que la llamó; segundo, para devolver un valor.Todas las funciones, excepto las de tipo void, devuelven un valor, y puedenser usadas como operando en una expresión.main() devuelve un código de terminación; 0 significa que el programa haterminado normalmente.Argumentos de las funcionesSi una función va a usar argumentos, debe declarar variables que acepten losvalores de los argumentos, éstas se llaman parámetros formales.ejemplo:esta_en(char *cad, char c){ while (*cad) if (*cad==c) return 1; else cad++; return 0;}Prototipos de funcionesSe aplica en C la declaración anticipada tradicional de funciones.Cualquier función de la biblioteca estándar que se use en un programa debeestar prototipada. Se debe incluir el archivo de cabecera apropiado. Tutorial Turbo C
  • 32. © Rodolfo Gallardo-Rosales Archivos de cabecera de Turbo C Archivo Funciones alloc.h Asignación dinámica de memoria assert.h Define la función assert() bios.h Interface con el BIOS conio.h Entrada/salida por consola ctype.h Relacionadas con caracteres dir.h Relacionadas con directorios dos.h Interface con el DOS errno.h Define varios códigos de error fcntl.h Constantes de tipo UNIX float.h Límites reales de punto flotante graphics.h Relacionadas con gráficos io.h Entrada/salida de bajo nivel limits.h Límites de enteros locale.h Específicas de países math.h Matemáticas mem.h Manipulación de memoria process.h Control de procesos setjmp.h requerido por setjmp() y logjmp() share.h Compartición de archivos signal.h Soporte para signal() y raise() stdargs.h Argumentos de longitud variable stddef.h Tipos y macros estándar stdio.h Entrada/salida estándar stdlib.h Variadas string.h Relacionadas con cadenas sysstat.h Constantes relacionadas con archivos systimeb.h Soporta la función ftime() systypes.h Define time_t para hora time.h Hora y fecha values.h Constantes varias2.5. Arrays Un array es una colección de variables del mismo tipo que se denominan por un nombre común y diferenciado por un índice. Arrays unidimensionales La forma general es: Tutorial Turbo C
  • 33. © Rodolfo Gallardo-Rosalestipo nombre_de_variable[tamaño];Todos los arrays tienen 0 como índice de su primer elemento, así:char p[10];tiene diez elementos, desde p[0] hasta p[9].Actividad:>> Desarrollar en TC los programas ejemplo Nos. 19 y 20CadenasEl uso más común de array unidimensional es como un string. Termina siemprecon un caracter nulo (0), por lo que la declaración debe ser un caractermás.strcpy(), strcat(), strlen() y strcmp()Sus formas generales son:strcpy(cadena1, cadena2);Copya la cadena 1 en la cadena 2.strcat(cadena1, cadena2);Concatena las cadenas 1 y 2.strlen(cadena);Devuelve el número de caracteres de una cadena.strcmp(cadena1, cadena2);Compara las cadenas 1 y 2.Actividad:>> Desarrolar en TC los programas ejemplo Nos. 21 y 22Arrays bidimensionales Tutorial Turbo C
  • 34. © Rodolfo Gallardo-Rosales Son esencialmente un array de arrays unidimensionales. Su forma general es: tipo nombre[tamaño 2a. dimesión] [tamaño 1a. dimensión]; ejemplo: int d[10][20]; Actividad: >> Desarrollar en TC los programas ejemplo Nos. 23, 24, 25 y 262.6. Punteros La importancia de los punteros se basa en: 1. Proporcionan los medios por los cuales las funciones modifican sus argumentos de llamada. 2. Soportan rutinas de asignación dinámica de TC 3. Mejora la eficiencia de ciertas rutinas. 4. Se usan como soportes de ciertas estructuras de datos como las listas enlazadas y árboles binarios. Un puntero es una variable que contiene una dirección de memoria, que es la posición de otra variable. Si eso ocurre, se dice que la variable apunta a la segunda. Si una variable en 1004 está apuntada por otra situada en la posición 1000, esta última contiene el valor 1004 -> Variable puntero Consiste en un tipo base, un asterisco (*) y el nombre de la variable. Su forma general es: tipo *nombre; -> Los operadores de punteros Existen dos operadores especiales de punteros: & y *. El ampersand (&) es un operador monario que devuelve la dirección de memoria de su operando; por ejemplo: Tutorial Turbo C
  • 35. © Rodolfo Gallardo-Rosales m=&cuenta; pone en m la dirección de memoria de la variable "cuenta". El asterisco (*) es el complemento de &. Es un operador monario que devuelve el valor de la variable localizada en la dirección que sigue; por ejemplo: q=*m; pone el valor de la variable cuenta en q. Actividad: >> Desarrollar en TC los programas ejemplo Nos. 27, 28 y 292.7. Estructuras, uniones y variables definidas por el usuario El lenguaje C proporciona cinco formas diferentes de creación de tipos de datos propios: 1. La estructura es una agrupación de variables bajo un nombre. 2. El campo de bits es una variación de la estructura. 3. La unión permite que la misma parte de memoria sea definido como dos o más tipos diferentes de memoria. 4. La enumeración es una lista de símbolos. 5. typedef crea un nuevo nombre para un tipo ya existente. -> estructuras Es una colección de variables bajo un mismo nombre para mantener junta la información relacionada. struct indica al compilador que se está declarando una estructura. La forma general es: struct etiqueta{ tipo nombre_de_variable; tipo nombre_de_variable; tipo nombre_de_variable; }variables_de_estructura; Por ejemplo: Tutorial Turbo C
  • 36. © Rodolfo Gallardo-Rosalesstruct dir{ char nombre[30]; char calle[40]; char ciudad[20]; char estado[3]; long int codigo;}info_dir, binfo, cinfo;Para referir los elementos individuales de la estructura, se usará eloperador . (punto); por ejemplo:info_dir.codigo=12345;printf("%d", info_dir.codigo);gets(info_dir.nombre);El uso más común, será el de array de estructuras; primero se declara laestructura y luego el array.Por ejemplo:#define MAX 100struct inv{ char item[30]; float coste; int dispo;}info_inv[MAX];Actividad:>> Desarrollar en TC los programas ejemplo Nos. 30, 31 y 32-> Campos de bitsMétodo incorporado por C para acceder a un bit individual dentro de un byte.Será útil cuando:1. El almacenamiento es limitado, se pueden almacenar varias variables lógicas en un byte.2. Ciertos dispositivos transmiten la información codificada en los bits dentro de bytes.3. Ciertas rutinas de cifrado necesitan acceder a los bits dentro de los Tutorial Turbo C
  • 37. © Rodolfo Gallardo-Rosales bytes.La forma general es:struct etiqueta{ tipo nombre1: longitud; tipo nombre2: longitud; . . . . . . tipo nombren: longitud;}Los tipos deben ser int, unsigned o signed.Por ejemplo:struct dispositivo{ unsigned activo: 1; unsigned preparado: 1; unsigned error: 1;}codigo_disp;-> UnionesUna unión es una posición de memoria que es compartida por varias variablesde diferentes tipos, su declaración es similar a una estructura, por ejemplo:union tipo_n{ int i; char ch;};-> EnumeracionesConjunto de constantes enteras con nombre que especifica todos los valoresválidos que una variable de ese tipo pueda tener.La forma general es:enum etiqueta{lista_de_enumeraciones} variables;Por ejemplo: Tutorial Turbo C
  • 38. © Rodolfo Gallardo-Rosales enum moneda{penique, níquel, diez_centavos, cuarto, medio_dolar, dolar}; -> typedef Permite definir un nuevo nombre de tipo. Su forma general es: typedef tipo nombre; Por ejemplo: typedef float balance; y se puede usar para declarar otras variables, por ejemplo: balance negativo;2.8. Entrada salida y archivos de disco Los conjuntos completos de funciones de E/S definidos en Turbo C son: 1. El sistema de E/S definido por el estándar ANSI, también denominado sistema de archivos con buffer. 2. El sistema de E/S tipo UNIX, a veces referido como sistema de archivos sin buffer. 3. Algunas funciones de E/S de bajo nivel que operan directamente sobre el hardware de la computadora. -> Flujos y archivos Flujos: dispositivos, como terminales y controladores de disco y conta son transformados en dispositivos lógicos llamados flujos. Los hay de texto y binarios. Flujos de texto: es una secuencia de caracteres. Flujos binarios: es una secuencia de bytes con una correspondencia de 1 a 1 con los del dispositivo externo. Archivos: es un concepto lógico aplicable a cualquier cosa, desde un archivo de disco hasta una terminal. Se asocia un flujo con un archivo realizando una operación de apertura. Tutorial Turbo C
  • 39. © Rodolfo Gallardo-RosalesSe puede desasociar un flujo con un archivo por la operación de cerrar.Todos los archivos se cierran automáticamente cuando termina main(), devuelveel control al Sistema Operativo llamando a exit(). Cerrar el archivo, se hecemediante fclose().Los archivos no se cierran cuando un programa interrumpe su ejecución por unallamada a abort().Al iniciar la ejecución de un programa, se abren cinco flujos de textopredefinidos:stdin, stdout, stderr, stdaux, stdprindefinidos con los dispositivos estándar del sistema así:flujo dispositivostdin tecladostdout pantallastderr pantallastdaux primer puerto seriestdprn impresora-> E/S por consola-> getche() y putchar()getche() lee un caracter del teclado y putchar() lo pone en la pantalla.Actividad:>> Desarrollar en TC los programas ejemplo Nos. 33, 34 y 35-> getch()Trabaja igual que getche(), pero no muestra eco en la pantalla.-> gets() y puts()Permiten leer y escribir cadenas de caracteres.Las funciones más simples que realizan las operaciones de E/S por consola Tutorial Turbo C
  • 40. © Rodolfo Gallardo-Rosalesson:función Operacióngetchar() Lee caracter del teclado, espera por entergetche() Lee caracter con eco, no espera entergetch() Lee sin eco, no espera enterputchar() Escribe caracter en pantallagets() Lee cadena del tecladoputs() Escribe cadena en la pantalla-> E/S por consola y con formato-> printf()Especificadores de formato para printf()especificador aplicación%c caracter%d decimal%i decimal%e notación científica%f real%g %e o %f, el más corto%o octal%s cadena%u decimal sin signo%x hexadecimal%% signo %%p puntero%n puntero a enteroPor ejemplo:%05d rellena con ceros para que sea de cinco espacios%5.7s imprime cadena de al menos 5 y no más de 7 caracteres%-10.2f ajusta a la izquierda, 10 espacios y dos decimales Tutorial Turbo C
  • 41. © Rodolfo Gallardo-Rosales-> scanf()Especificadores de formato para scanf()especificador aplicación%c caracter%d decimal%i decimal%e real%f real%h corto%o octal%s cadena%x hexadecimal%p puntero%n entero con número de caracteres leídosPor ejemplo:scanf("%20s", cad); lee sólo 20 caracteresFunciones más comunes de un sistema de archivosFunción Actividadfopen() Abre un flujofclose() Cierra un flujoputc() Escribe caracter a un flujogetc() Lee un caracter de un flujofseek() Busca un byte específico en el flujofprintf() Hace lo mismo que printf() en un flujofscanf() Hace lo mismo que scanf() en un flujofeof() Cierto si es fin de archivoferror() Cierto si hay errorrewind() Resetea al principio del archivoremove() Elimina archivo-> fopen()Abre un flujo y lo asocia con un archivo, su forma general es:FILE *fopen(*nombre_archivo, *modo); Tutorial Turbo C
  • 42. © Rodolfo Gallardo-Rosalesmodo puede tener los valores siguientes:Modo Significado"r" Abre archivo de texto, sólo lectura"w" Abre archivo de texto, sólo escritura"a" Abre archivo de texto sólo para agregar"rb" Abre archivo binario para lectura"wb" Crea archivo binario para escritura"ab" Crea archivo binario para agregar"r+" Abre archivo de texto, lectura/escritura"w+" Crea archivo de texto lectura/escritura"a+" Abre o crea archivo de texto lectura/escritura"r+b" Abre binario lectura/escritura"w+b" Crea archivo binario lectura/escritura"a+b" Abre o crea archivo binario lectura/escritura"rt" Abre archivo de texto para lectura"wt" Crea archivo de texto para escritura"at" Abre archivo de texto para agregar"r+t" Abre archivo de texto para lectura/escritura"w+t" Crea archivo de texto lectura/escritura"a+t" Abre o crea archivo de texto lectura/escrituraPor ejemplo:if((fp=fopen("prueba","w"))==NULL){ puts("no se puede abrir el archivon"); exit(1);}-> putc()Escribe caracteres en un flujo abierto con fopen(). Si tiene éxito, devuelveel caracter escrito, si no, eof().-> getc()Lee caracteres de un flujo abierto con fopen().-> fclose()Cierra un flujo abierto con fopen().-> ferror() y rewind() Tutorial Turbo C
  • 43. © Rodolfo Gallardo-Rosales ferror() determina si ha habido error en una operación, si es así, devuelve positivo. rewind() inicializa el indicador al principio del archivo. Actividad: >> Desarrollar en TC los programas ejemplo Nos. 36, 37 y 38. -> getw() y putw() Se usan para leer y escribir enteros de y en un archivo de disco. -> fputs() y fgets() Leen y escriben cadenas de caracteres sobre archivos de disco. -> fread() y fwrite() Sirven para leer y escribir bloques de datos -> fseek() y E/S de acceso directo. Son operaciones de lectura y escritura directa. -> fprintf() y fscanf() Se comportan como el printf() y el scanf(), pero redirigidos a un archivo. Actividad: >> Desarrollar en TC los programas ejemplo Nos. 39, 40 y 41.2.9. El preprocesador de Turbo C El preprocesador contiene las siguientes directivas: #define #error #include #if #else #elif #endif #ifdef Tutorial Turbo C
  • 44. © Rodolfo Gallardo-Rosales#ifndef#undef#line#pragma-> #defineSe usa para definir un identificador y una cadena que será sustituída por elidentificador.Su forma general es:#define nombre_de_macro cadenaPor ejemplo:#define MS_E "Error estándar en la entradan"...printf(MS_E)-> #errorForza a Turbo C a parar la compilación, su forma general es:#error mensaje_de_errormanda el mensaje de error cuando éste existe.-> #includeHace que el compilador incluya otro archivo fuente, debe estar entre comillas(" ") o entre ángulos (< >), por ejemplo:#include "stdio.h"#include <stdio.h>-> #if, #else, #elif y #endifSi la expresión constante que sigue a #if es cierta, se compila el código quehay entre ella y #endifSu forma general es: Tutorial Turbo C
  • 45. © Rodolfo Gallardo-Rosales#if expresión_constante secuencia_dfe_sentencias#endifPor ejemplo:#include <stdio.h>#define MAX 100main (void){ #if MAX>99 printf("Compilado para arrays mayores de 99n"); #endif return 0;}El #else proporciona una alternativa:#include <stdio.h>#define MAX 100main(void){ #if MAX>99 printf("Compilado para arrays mayores de 99n"); #else printf("Compilado para arrays pequeñosn"); #endif return 0;}#elif establece una escala if-else-if para opciones de compilación múltiples.Su forma general es:#if expresión sentencias#elif expresión1 sentencias#elif expresión2 sentencias . . .#elif expreiónN Tutorial Turbo C
  • 46. © Rodolfo Gallardo-Rosales sentencias#endifPor ejemplo:#define USA 0#define GB 1#define ESP 2#define PAIS_ACTIVO ESP#if PAIS_ACTIVO==USA char moneda[]="dólar";#elif PAIS_ACTIVO==GB char moneda[]="libra";#else char moneda[]="peseta";#endif-> #ifdef y #ifndefSignifican "si definido" y "si no definido". Su forma general es:#ifdef nombre_de_macro sentencias#endifPor ejemplo:#include <stdio.h>#define TED 10main(void){ #ifdef TED printf("HOla, Ted!n"); #else printf("Hola, quienquiera que seas!n"); #endif return 0;}-> #lineEs el número de línea que se está compilando. Su forma general es: Tutorial Turbo C
  • 47. © Rodolfo Gallardo-Rosales #line numero <<nombre_archivo>> -> #pragma Permite que se den varias instrucciones conforme al compilador; su forma general es: #pragma nombre donde nombre puede ser: inline argused saveregs exit warn startup option argused, precede a una función y se usa para prevenir mensajes de advertencia cuando no se usa la función. exit, especifica una o más funciones que se llamarán al terminar el programa. startup, especifica una o más funciones que se llamarán nada más al comenzar la ejecución del programa. Su forma general es: #pragma exit función prioridad #pragma startup función prioridad prioridad es un valor entre 64 y 255, si no se especifica, es 100. Actividad: >> Desarrollar en TC los programas ejemplo Nos. 42, 43 y 44.2.10. Funciones gráficas y de pantalla. Las funciones de E/S básicas de texto para ventanas son: cprintf() escribe salida con formato cputs() escribe cadena cputch() escribe un caracter getche() lee un caracter Tutorial Turbo C
  • 48. © Rodolfo Gallardo-Rosalescgets() lee una cadenaFunciones de Turbo C para manipulación de la pantalla de texto:clrscr() limpia ventanaclreol() borra hasta fin de líneadelline() borra la líneagettext() copia parte del texto al buffer de memoriagotoxy() coloca cursos en la posición indicadainsline() inserta línea vacíamovetext() copia texto de una parte a otraputtext() copia texto de buffer a pantallatextmode() establece modo texto en la pantallawindow() define y activa una ventanaSus formas generales son:-> clrscr();-> clreol();-> delline();-> insline();-> gotoxy(x,y); x=1..80 y=1..25-> gettext(izquierda, arriba, derecha, abajo, *buffer);-> puttext(izquierda, arriba, derecha, abajo, *buffer); buffer=filas x columnas x 2-> movetext(arriba, izquierda, derecha, abajo, nuevoarriba, nuevoizquierda);-> window(izquierda, arriba, derecha, abajo);Actividad:>> Desarrollar en TC el programa ejemplo No. 45. Tutorial Turbo C
  • 49. © Rodolfo Gallardo-RosalesLas funciones de los atributos de texto son:highvideo() alta intensidadlowvideo() baja intensidadnormvideo() intensidad originaltextattr() texto y fondo en colortextbackground() color de fondotextmode() modo de video-> highvideo()-> lowvideo()-> normvideo()-> textcolor(color) color: BLACK 0 BROWN 6 LIGHTRED 12 BLUE 1 LIGHTGRAY 7 LIGHTMAGENTA 13 GREEN 2 DARKGRAY 8 YELLOW 14 CYAN 3 LIGHTBLUE 9 WHITE 15 RED 4 LIGHTGREEN 10 BLINK 128 MAGENTA 5 LIGHTCYAN 11-> textattr(atributo)atributo: FONDO*16 | TEXTO-> textmode(modo)modo:BW40 0 Blanco y negro, 40 columnasC40 1 Color, 40 columnasBW80 2 Blanco y negro, 80 columnasC80 3 Color, 80 columnasMONO 7 Monocromo, 80 columnasLASTMODE -1 Modo anteriorC4350 64 EGA 80X43, VGA 80X25 Tutorial Turbo C
  • 50. © Rodolfo Gallardo-RosalesLas funciones de estado de la pantalla de texto son:gettextinfo() Información sobre ventanawherex() Coordenada de xwherey() Coordenada de yActividad:>> Desarrollar en TC el programa ejemplo No. 46.Funciones de gráficos:initgraph(), para poner el adaptador en modo gráfico, su forma es:initgraph(*controlador, *modo, *camino);Controladores y modos:Controlador Modo Equivalente ResoluciónCGA CGAC0 0 320X200 CGAC1 1 320X200 CGAC2 2 320X200 CGAC3 3 320X200 CGAHI 4 640X200MCGA MCGAC0 0 320X200 MCGAC1 1 320X200 MCGAC2 2 320X200 MCGAC3 3 320X200 MCGAMED 4 640X200 MCGAHI 5 640X480EGA EGALO 0 640X200 EGAHI 1 640X350EGA64 EGA64LO 0 640X200 EGA64HI 1 640X350EGAMONO EGAMONOHI 3 640X350HERC HERCMONOHI 0 720X348ATT400 ATT400C0 0 320X200 ATT400C1 1 320X200 ATT400C2 2 320X200 ATT400C3 3 320X200 ATT400CMED 4 640X200 ATT400CHI 5 640X400 Tutorial Turbo C
  • 51. © Rodolfo Gallardo-RosalesControlador Modo Equivalente ResoluciónVGA VGALO 0 640X200 VGAMED 1 640X350 VGAHI 2 640X480PC3270 PC3270HI 0 720X350IBM8514 IBM8514HI 0 1024X768 IBM8514LO 0 640X480-> Gráficos básicos-> putpixel()Pone un punto en la pantalla. Forma general:putpixel(x,y,color);-> line()Dibuja una línea. Forma general:line(x1,y1,x2,y2);-> circle()Dibuja un círculo. Forma general:circle(x,y,radio):-> setcolor()Color del dibujo. Forma general:setcolor(color);-> floodfill()Rellenar figura cerrada. Forma general:floodfill(x,y,colorborde);-> setfillstyle()Cambia la manera de rellenar objetos. Forma general: Tutorial Turbo C
  • 52. © Rodolfo Gallardo-Rosalessetfillstyle(patron,color);patron:EMPTY_FILL 0 Rellena color del fondoSOLID_FILL 1 Rellena color lisoLINE_FILL 2 Rellena con líneasLTSLASH_FILL 3 Rellena con barras finasSLASH_FILL 4 Rellena con barrasBKSLASH_FILL 5 Rellena con barras invertidasLTBKSLASH_FILL 6 Rellena con barras invertidas finasHATCH_FILL 7 Rellena con trama finaXHATCH_FILL 8 Rellena con tramaINTERLEAVE_FILL 9 Rellena con puntos espaciadosWIDE_DOT_FILL 10 Rellena con puntos muy espaciadosCLOSE_DOT_FILL 11 Rellena con puntos poco espaciadosUSER_FILL 12 Rellena con patrón de usuarioEjemplo:circle(320,175,100);setfillstyle(SOLID_FILL, GREEN);floodfill(500,250,1);Otro ejemplo:void borde(void){ line(0,0,639,0); line(0,0,0,349); line(0,349,639,349); line(639,0,639,349);}-> Texto en modo gráfico-> outtext()Pone texto en la pantalla en modo gráfico. Forma general:outtext(cadena);-> settextstyle() Tutorial Turbo C
  • 53. © Rodolfo Gallardo-RosalesDefine estilo, tamaño y dirección del texto. Forma general:settextstyle(fuente,dirección,tamaño);fuente:DEFAULT_FONT 0TRIPLEX_FONT 1SMALL_FONT 2SANS_SERIF_FONT 3GOTHIC_FONT 4dirección:HORIZ_DIR 0VERT_DIR 1tamaño:0 a 10Actividad:>> Desarrollar en TC el programa ejemplo No. 47.-> outtextxy()Escribe texto en una posición determinada. Su forma general es:outtextxy(x,y,*cad);Funciones de control de la pantalla gráfica:clearviewport() Limpia ventana gráficagetimage() Copia parte de un gráfico al buffer de memoriaimagesize() Devuelve el número de bytes de una imagenputimage() Copia buffer a pantallasetactivepage() Qué página de afectará por los gráficossetviewpart() Crea ventana gráficasetvisualpage() Determina la página que se muestraActividad:>> Desarrollar en TC el programa ejemplo No. 48. Tutorial Turbo C
  • 54. © Rodolfo Gallardo-Rosales3. La biblioteca de Turbo C3.1. Funciones de E/S -> access(*archivo,modo); lib=io.h Comprueba archivos, modo: 0 sí existe 1 es ejecutable 2 se le puede escribir 4 se puede leer 6 acceso de lectura/escritura Por ejemplo: access("PRUEBA.PRU", 0); -> _chmod(*archivo,fijar,atributo); lib=io.h Establece el byte de atributo para un archivo. atributo: FA_RDONLY sólo lectura FA_HIDDEN oculto FA_SYSTEM de sistema Por ejemplo: _chmod("PRUEBA.PRU",1,FA_RDONLY); -> chmod(*nombre,modo); lib=io.h Cambia el modo a un archivo modo: Tutorial Turbo C
  • 55. © Rodolfo Gallardo-RosalesS_IWRITE EscribirseS_IREAD LeersePor ejemplo:chmod("PRUEBA.PRU",S_IREAD|S_IWRITE);-> chsize(manejador,tamaño);lib=io.hAumenta o reduce el tamaño de un archivo, por ejemplo:chsize(manejador,256);-> clearerr(FILE *flujo);lib=stdio.hinicializa a cero el indicador de error. Por ejemplo:clearerr(fp);-> close(dat);-> _close(dat);lib=io.hCierra un archivo. Por ejemplo:close(arch);_close(arch);-> creat(*archivo,modo);-> _creat(*archivo,atrib);-> creatnew(*archivo,atrib);-> creattemp(*archivo,atrib);lib=io.hcreat(), crea un nuevo archivo, modo es S_IWRITE, S_IREAD._creat(), crea un archivo nuevo, pero atrib tiene los valores de FA_RDONLY, Tutorial Turbo C
  • 56. © Rodolfo Gallardo-RosalesFA_HIDDEN, FA_SYSTEM.creatnew(), si ya existe, devuelve error.creattemp(), crea un archivo temporal.-> dup(manejador);-> dup2(manejador,manejador_nuevo);lib=io.hDevuelven el descriptor de archivo, es decir, lo duplica. Por ejemplo:FILE *pa, *pa2; . . .pa2=dup(pa);-> eof(arch);lib=io.hDevuelve 1 si es fin de archivo, Por ejemplo:eof(arch);-> fclose(FILE *flujo);-> fcloseall(void);lib=stdio.hCierra archivos.-> fdopen(manejador, modo);lib=stdio.hAbre un archivo.-> feof(FILE *flujo);lib=stdio.h Tutorial Turbo C
  • 57. © Rodolfo Gallardo-RosalesIndica fin de archivo para flujo.-> ferror(FILE *flujo);lib=stdio.hSi es cero, no hay errores.-> fflush(FILE *flujo);lib=stdio.hEl contenido del buffer de salida se escribe a archivo.-> fgetc(FILE *flujo);lib=stdio.hObtiene el siguiente caracter del flujo e incrementa posición.-> fgetchar();lib=stdio.hIgual que el anterior.-> fgetpos(FILE *flujo, *pos);lib=stdio.hGuarda el valor de posición del archivo.-> fgets(*cad, num, FILE *flujo);lib=stdio.hlee caracteres del flujo, como cadena.-> filelenght(manejador);lib=io.hlongitud en bytes de un archivo. Tutorial Turbo C
  • 58. © Rodolfo Gallardo-Rosales-> fileno(FILE *flujo);lib=stdio.hDevuelve descriptor de archivo.-> flushall();lib=stdio.hGraba físicamente todos los buffers de salida.-> fopen(*nombre, *modo);lib=stdio.hAbre archivo.-> fprintf(FILE *flujo, *formato, argumentos);lib=stdio.hEscribe en el flujo los argumentos.-> fputc(c, FILE *flujo);lib=stdio.hEscribe un caracter c en el flujo.-> fputchar(c);lib=stdio.hEscribe el caracter c en stdout().-> fputs(*cad, FILE *flujo);lib=stdio.hEscribe la cadena en el flujo.-> fread(*buf, tam, cuenta, FILE *flujo); Tutorial Turbo C
  • 59. © Rodolfo Gallardo-Rosaleslib=stdio.hLee el número de caracteres que se indican.-> freopen(*nombre, *modo, FILE *flujo);lib=stdio.hReabre un archivo.-> fscanf(FILE *flujo, *formato, argumentos);lib=stdio.hLee una cadena del flujo.-> fseek(FILE *flujo, desp, origen);lib=stdio.hrealiza búsqueda en archivo.-> fsetpos(FILE *flujo, pos, *pos);lib=stdio.hApunta a un lugar especificado.-> fstat(manejador, stat, *bufstat);lib=sysstat.hLlena el buffer con información.-> ftell(FILE *flujo);lib=stdio.hDevuelve indicador de posición del archivo.-> fwrite(*buf, tam, cuenta, FILE *flujo);lib=stdio.h Tutorial Turbo C
  • 60. © Rodolfo Gallardo-RosalesEscribe en un flujo.-> getc(FILE *flujo);lib=stdio.hDevuelve un caracter desde el flujo.-> getch();lib=conio.hLee un caracter de la consola.-> getche();lib=conio.hLee un caracter del teclado, haciendo eco.-> getchar();lib=stdio.hLee un caracter de tipo string desde la consola.-> gets(*cad);lib=stdio.hLee una cadena desde la consola.-> getw(FILE *flujo);lib=stdio.hLee el siguiente entero de un flujo.-> isatty(manejador);lib=io.hDevuelve <>0 si manejador está asociado con terminal, consola, impresora oCOM1. Tutorial Turbo C
  • 61. © Rodolfo Gallardo-Rosales-> lock(manejador, desp, longitud);lib=io.hProtege una parte del programa para no ser usado hasta que se desbloquee.-> lseek(manejador, desp, origen);lib=io.hHace búsquedas de tipo UNIX.-> open(*nombre, acceso, modo);-> _open(*nombre, acceso);lib=io.hAbren un archivo con un modo de acceso.-> perror(*cad);lib=stdio.hConvierte el valor a cadena.-> printf(*formato, argumentos);lib=stdio.hEscribe en la pantalla una cadena con formato.-> putc(c, FILE *flujo);lib=stdio.hEscribe el caracter c a un flujo.-> putchar(c);lib=stdio.hEscribe el caracter c a la pantalla. Tutorial Turbo C
  • 62. © Rodolfo Gallardo-Rosales-> puts(*cad);lib=stdio.hEscribe una cadena en la pantalla.-> putw(i, FILE *flujo);lib=stdio.hEscribe un entero en un flujo.-> read(da, *buf, cuenta);-> _read(da, *buf, cuenta);lib=io.hLeen un byte del archivo y lo colocan en el buffer de memoria.-> remove(*nombre);lib=stdio.hBorra el archivo especificado.-> rename(*anterior, *nuevo);lib=stdio.hRenombra un archivo.-> rewind(FILE *flujo);lib=stdio.hMueve el indicador al principio del flujo.-> scanf(*formato, argumentos);lib=stdio.hLee datos desde el teclado, con formato.-> setbuf(FILE *flujo, *buf); Tutorial Turbo C
  • 63. © Rodolfo Gallardo-Rosaleslib=stdio.hDetermina el buffer del flujo.-> setmode(manejador, modo);lib=io.hInicializa un archivo.-> setvbuf(FILE *flujo, *buf, modo, tam);lib=stdio.hEspecifica buffer, tamaño y modo.-> sopen(*nombre, acceso, compart, modo);lib=io.hAbre cadenas para acceso.->sprintf(*buf, *formato, argumentos);lib=stdio.hGenera salida hacia el array apuntado por *buf.-> sscanf(*buf, *formato, argumentos);lib=stdio.hLee cadena por buffer del teclado.-> stat(*nombre, *bufstat);lib=sysstat.hLlena el buffer con la información del archivo.-> tell(da);lib=io.h Tutorial Turbo C
  • 64. © Rodolfo Gallardo-RosalesDevuelve el indicador de posición del archivo.-> *tmpfile();lib=stdio.hAbre un archivo temporal.-> *tmpnam(*nombre);lib=stdio.hAbre un archivo temporal con nombre.-> ungetc(c, FILE *flujo);lib=stdio.hDevuelve un caracter del byte menos significativo.-> unlink(*nombre);lib=dos.hElimina el archivo especificado.-> unlock(manejador, desp, longitud);lib=io.hDesbloquea un archivo bloqueado.-> vprintf(*formato, argumentos);-> vfprintf(FILE *flujo, *formato, argumentos);-> vsprintf(*buf, *formato, argumentos);lib=stdio.h y stdarg.hImprimen datos con formato.-> vscanf(*formato, argumentos);-> vfscanf(FILE *flujo, *formato, argumentos);-> vsscanf(*buf, *formato, argumentos); Tutorial Turbo C
  • 65. © Rodolfo Gallardo-Rosales lib=stdio.h y stdarg.h Leen datos desde el teclado. -> write(manejador, *buf, cuenta); -> _write(manejador, *buf, cuenta); lib=io.h Escriben cuenta bytes al archivo.3.2. Funciones de cadenas, de memoria y de caracteres. -> isalnum(ch); lib=ctype.h Devuelve <>0 si es alfanumérico. -> isalpha(ch); lib=ctype.h Devuelve <>0 si es alfabético. -> isascii(ch); lib=ctype.h Devuelve <>0 si es ascii. -> iscntrl(ch); lib=ctype.h Devuelve <>0 si es caracter de control. -> isdigit(ch); lib=ctype.h Devuelve <>0 si está entre 0 y 9. Tutorial Turbo C
  • 66. © Rodolfo Gallardo-Rosales-> isgraph(ch);lib=ctype.hDevuelve <>0 si es caracter gráfico.-> islower(ch);lib=ctype.hDevuelve <>0 si es minúscula.-> isprint(ch);lib=ctype.hDevuelve <>0 si es caracter imprimible.-> ispunct(ch);lib=ctype.hDevuelve <>0 si es signo de puntuación.-> isspace(ch);lib=ctype.hDevuelve <>0 si es espacio.-> isupper(ch);lib=ctype.hDevuelve <>0 si es letra mayúscula.-> isxdigit(ch);lib=ctype.hDevuelve <>0 si es hexadecimal.-> *memccpy(*dest, *orig, ch, cuenta); Tutorial Turbo C
  • 67. © Rodolfo Gallardo-Rosaleslib=string.h y mem.hCopia el contenido de memoria de origen a destino.-> *memchr(*buffer, ch, cuenta);lib=string.h y mem.hBusca ch en los primeros cuenta caracteres.-> memcmp(*buf1, *buf2, cuenta);-> memicmp(*buf1, *buf2, cuenta);lib=string.h y mem.hCompara los cuenta caracteres entre los dos arrays.-> *memcpy(*hacia, *desde, cuenta);lib=string.h y mem.hCopia cuenta caracteres desde y hacia.-> *memmove(*hacia, *desde, cuenta);lib=string.h y mem.hMueve los cuenta caracteres desde y hacia.-> *memset(*buf, ch, cuenta);lib=string.h y mem.hCopia el LSB de ch en los cuenta primeros caracteres del array en buf.-> movedata(origseg, origdesp, destseg, destdesp, cuenta);lib=string.h y mem.hCopia cuenta caracteres desde la posición orig hasta destino.-> movemem(*orig, *dest, cuenta);lib=mem.h Tutorial Turbo C
  • 68. © Rodolfo Gallardo-RosalesCopia cuenta caracteres de origen a destino.-> setmem(*buf, cuenta, ch);lib=mem.hCopia ch en los cuenta caracteres del array.-> *stpcpy(*cad1, *cad2);lib=string.hCopia cadena 1 en cadena 2.-> *strcat(*cad1, *cad2);lib=string.hConcatena las cadenas 1 y 2.-> *strchr(*cad, ch);lib=string.hEs un puntero al LSB de ch.-> strcmp(*cad1, *cad2);lib=string.hcompara cadena 1 con cadena 2.-> strcoll(*cad1, *cad2);lib=string.hCompara la cadena 1 con la cadena 2.-> *strcpy(*cad1, *cad2);lib=string.hCopia cadena 1 en cadena 2. Tutorial Turbo C
  • 69. © Rodolfo Gallardo-Rosales-> strcspn(*cad1, *cad2);lib=string.hDevuelve la longitud de la subcadena constituida por los caracteres que noestán en la cadena 2.-> *strdup(*cad);lib=string.hDuplica la cadena.-> *_strerror(*cad);lib=stdio.h y string.hMuestra la cadena, dos puntos y el mensaje de error producido por elprograma.-> *strerror(num);lib=stdio.h y string.hDevuelve un puntero a un mensaje de error.-> stricmp(*cad1, *cad2);-> strcmpi(*cad1, *cad2);lib=string.hComparan dos cadenas.-> strlen(*cad);lib=string.hDevuelve el número de caracteres de la cadena.-> *strlwr(*cad);lib=string.h Tutorial Turbo C
  • 70. © Rodolfo Gallardo-RosalesConvierte la cadena a minúsculas.-> *strncat(*cad1, *cad2, cuenta);lib=string.hConcatena cuenta caracteres de cad2 a cad1.-> strncmp(*cad1, *cad2, cuenta);-> strnicmp(*cad1, *cad2, cuenta);-> strncmpi(*cad1, *cad2, cuenta);lib=string.hComparan lexicográficamente cad1 y cad2.-> *strncpy(*dest, *orig, cuenta);lib=string.hCopia cuenta caracteres de origen a destino.-> *strnset(*cad, ch, cuenta);lib=string.hPone ch en cuanta caracteres de cad.-> *strpbrk(*cad1, *cad2);lib=string.hApunta al primer caracter de cad1 que coincida con cad2.-> *strrchr(*cad, ch);lib=string.hApunta al LSB de ch en cad.-> *strrev(*cad);lib=string.h Tutorial Turbo C
  • 71. © Rodolfo Gallardo-RosalesInvierte el orden de la cadena.-> *strset(*cad, ch);lib=string.hPone ch en toda la cadena.-> strspn(*cad1, *cad2);lib=string.hDevuelve la intersección de las cadenas.-> *strstr(*cad1, *cad2);lib=string.hApunta la primera ocurrencia de cad2 en cad1.-> *strtok(*cad1, *cad2);lib=string.hApunta la siguiente palabra de cad1.-> *strupr(*cad);lib=string.hConvierte la cadena a mayúsculas.-> strxfrm(*dest, *orig, cuenta);lib=string.hCopia cuenta caracteres de origen a destino.-> tolower(ch);-> _tolower(ch);lib=ctype.hDevuelve ch en minúscula. Tutorial Turbo C
  • 72. © Rodolfo Gallardo-Rosales -> toupper(ch); -> _toupper(ch); lib=ctype.h Devuelve ch en mayúscula.3.3. Funciones matemáticas. -> acos(arg); lib=math.h Arco coseno de arg. -> asin(arg); lib=math.h Arco seno de arg. -> atan(arg); lib=math.h Arco tangente de arg. -> atan2(x,y); lib=math.h Arco tangente de y/x. -> cabs(znum); lib=math.h Valor absoluto de un número complejo. -> ceil(num); lib=math.h Tutorial Turbo C
  • 73. © Rodolfo Gallardo-RosalesMenor entero mayor o igual que num.-> cos(arg);lib=math.hCoseno de arg.-> cosh(arg);lib=math.hCoseno hiperbólico de arg.-> exp(arg);lib=math.he a la arg potencia.-> fabs(num);lib=math.hValor absoluto de num.-> floor(num);lib=math.hMayor entero no mayor de num.-> fmod(x,y);lib=math.hResto de x/y.-> frexp(num, *exp);lib=math.hmun será igual a la mantisa por 2 a la exp. Tutorial Turbo C
  • 74. © Rodolfo Gallardo-Rosales-> hypot(x.y);lib=math.hHipotenusa de x e y.-> ldexp(num, exp);lib=math.hDevuelve num por 2 a la exp.-> log(num);lib=math.hLogaritmo de num.-> log10(num);lib=math.hLogaritmo base 10 de num.-> matherr(*err);lib=math.hEstructura de errores matemáticos.-> modf(num, *i);lib=math.hDescompone en entero y fracción.-> poly(x, n, c[]);lib=math.hEvalúa polinomio x grado n desde c[0] hasta c[n].-> pow(base, exp); Tutorial Turbo C
  • 75. © Rodolfo Gallardo-Rosales lib=math.h Base elevado a la exp. -> pow10(n); lib=math.h Devuelve 10 a la n. -> sin(arg); lib=math.h Seno de arg. -> sinh(arg); lib=math.h Seno hiperbólico de arg. -> sqrt(num); lib=math.h Raíz cuadrada de num. -> tan(arg); lib=math.h Tangente de arg. -> tanh(arg); lib=math.h Tangente hiperbólica de arg.3.4. Funciones de hora, fecha y otras del sistema. -> absread(unidad, numsects, sectnum, *buf); Tutorial Turbo C
  • 76. © Rodolfo Gallardo-Rosales-> abswrite(unidad, numsects, sectnum, *buf);lib=dos.hLectura y escritura desde y a disco.-> *asctime(*punt);lib=time.hDevuelve cadena con los datos de fecha.-> bdos(dx, al);-> bdosptr(fnum, *dsdx, al)lib=dos.hPone dx en el registro dx y al en el registro al.-> bioscom(orden, byte, puerto);lib=bios.hManipula el puerto RS232-C.-> biosdisk(orden, unidad, cabeza, pista, sector, nsects, *buf);lib=bios.hOpera en disco a nivel del bios.-> biosequip();lib=bios.hDevuelve el valor del equipo existente.-> bioskey(orden);lib=bios.hOperaciones directas de teclado.-> biosmemory(); Tutorial Turbo C
  • 77. © Rodolfo Gallardo-Rosaleslib=bios.hDevuelve la cantidad de memoria instaladas en el sistema.-> biosprint(orden, byte, puerto);lib=bios.hControla el puerto de la impresora.-> biostime(orden, nuevahora);lib=bios.hAjusta el reloj del sistema.-> clock();lib=time.hTiempo de ejecución hasta la llamada.-> *country(codigo_pais, *puntpais);lib=dos.hAjusta elementos del país.-> ctime(*tiempo);lib=time.hCadena de tiempo.-> ctrlbrk((*fptr)());lib=dos.hRealiza la función de Ctrl-Break.-> delay(tiempo);lib=dos.h Tutorial Turbo C
  • 78. © Rodolfo Gallardo-RosalesDetiene el tiempo de ejecución tiempo milisegundos.-> difftime(hora2, hora1);lib=time.hDiferencia en segundos entre hora1 y hora2.-> disable();lib=dos.hInhibe las interrupciones.-> dosexterr(DOSERROR *err);lib=dos.hInformación extensa de error.-> dostounix(*d, *t);lib=dos.hHora en formato UNIX.-> enable();lib=dos.hHabilita las interrupciones.-> FP_OFF(*punt);-> FP_SEG(*punt);lib=dos.hDesplazamiento del puntero.-> ftime(*hora);lib=systimeb.h Tutorial Turbo C
  • 79. © Rodolfo Gallardo-RosalesInformación completa sobre la hora del sistema.-> geninterrupt(intr);lib=dos.hGenera interrupción por software.-> getcbrk();lib=dos.hDevuelve 0 si está desactivada ctrl-brk.-> getdate(*d);-> gettime(*t);lib=Rellena date o time con fecha y hora del sistema.-> getdfree(unidad, *dfpunt);lib=dos.hObtiene el espacio libre en el disco.-> *getdta();lib=dos.hDirección de transferencia de disco.-> getfat(unidad, *fpunt);-> getfatd(*fpunt);lib=dos.hDevuelve información sobre la FAT del disco.-> getftime(manejador, *fpunt);lib=io.hObtiene fecha y hora del sistema. Tutorial Turbo C
  • 80. © Rodolfo Gallardo-Rosales-> getpsp();lib=dos.hObtiene el PSP.-> interrupt(*vect(intr))();lib=dos.hDevuelve la dirección de la rutina de interrupción.-> getverify();lib=dos.hEstado de verificable del DOS.-> *gmtime(*hora);lib=time.hApunta a la forma de hora en la estructura tm.-> harderr((*int)());-> hardresume(cod);-> hardretn(cod);lib=dos.hReemplaza el manipulador de errorres del DOS.El manejador sale a DOS y vuelve código.El hardretn() retorna el código al programa.-> inport(port);-> inportb(port);lib=dos.hDevuelve el valor de la palabra leída en el puerto.Devuelve un byte leído del puerto.-> int86(int, *reg_e, *reg_s);-> int86x(int, *reg_e, *reg_s, *segregs); Tutorial Turbo C
  • 81. © Rodolfo Gallardo-Rosaleslib=dos.hEjecuta interrupción de software.Copia los valores de segregs -> ds en DS y ->es en ES.-> intdos(*reg_e, *reg_s);-> intdosx(*reg_e, *reg_s, *segregs);lib=dos.hAccede a la interrupción de DOS 21H.El valor de segregs lo pone en DS y ES.-> intr(intr, *reg);lib=dos.hEjecuta la interrupción especificada.-> keep(estado, tam);lib=dos.hEl programa en tam bytes queda residente y devuelve el estado a DOS.-> *localtime(*hora);lib=time.hApunta a la hora ->tm.-> mktime(*p);lib=time.hConvierte la hora en calendario equivalnte.-> *MK_FP(seg, desp);lib=dos.hDevuelve puntero a far en segmento seg y desp desplazamiento. Tutorial Turbo C
  • 82. © Rodolfo Gallardo-Rosales-> outport(puerto, palabra);-> outportb(puerto, byte);lib=dos.hPone palabra o byte en puerto.-> *parsfnm(*nombre, *fcbpunt, opción);lib=dos.hConvierte nombre de archivo en cadena.-> peek(seg, desp);-> peekb(seg, desp);-> poke(seg, desp, palabra);-> pokeb(seg, desp, byte);lib=dos.hValor en 16 bits de la posición seg:desp.Valor en 8 bits de la posición seg:desp.Almacena valor de 16 bits de la posición seg:desp.Almacena valor de 8 bits de la posición seg:desp.-> randbrd(*fcbpunt, cuenta);-> randbwr(*fcbpunt, cuenta);lib=dos.hLee cuenta número de registros.Escribe cuenta número de registros.-> segread(*sregs);lib=dos.hCopia valores actuales del segmento.-> setcbrk(cb);lib=dos.hActiva o desactiva la comprobación. Tutorial Turbo C
  • 83. © Rodolfo Gallardo-Rosales-> setdate(*d);-> settime(*t);lib=dos.hPone fecha del DOS.Pone hora del DOS.-> setdta(*dta);lib=dos.hAjusta la dirección de transferencia de disco a 4000:000.-> setftime(manejador, *t);lib=io.hAjusta hora y fecha a manejador.-> setvect(intr, (*rsi)());lib=dos.hColoca la interrupción rsi en la tabla.-> setverify(valor);lib=dos.hAjusta el indicador de verify de DOS.-> sleep(tiempo);lib=dos.hSuspende la ejecución tiempo segundos.-> stime(*t);lib=time.hPone hora de DOS en el valor t. Tutorial Turbo C
  • 84. © Rodolfo Gallardo-Rosales -> time(*hora); lib=time.h Devuelve la hora del DOS. -> tzset(); lib=time.h Ajusta las variables de tiempo. -> unixtodos(uhora, *d, *t); lib=dos.h Convierte la hora de formato UNIX a formato DOS.3.5. Funciones de asignación dinámica de memoria. -> allocmem(tam, *seg); lib=dos.h Coloca tam párrafos en seg para uso de la memoria. -> brk(*fsd); lib=alloc.h cambia la cantidad de memoria a usarse. -> *calloc(num, tam); lib=stdlib.h Asigna memoria de tam en bytes a num objetos. -> coreleft(); lib=alloc.h Número de bytes libres de memoria. Tutorial Turbo C
  • 85. © Rodolfo Gallardo-Rosales-> *farcalloc(num, tam);lib=alloc.hIdéntica a calloc().-> farcoreleft();lib=alloc.hIdéntica a coreleft().-> farfree(*ptr);lib=alloc.hLibera memoria asignada lejana.-> *farmalloc(tam);lib=alloc.hApunta al primer byte de memoria lejana.-> *farrealloc(*ptr, nuevotam);lib=alloc.hCambia un bloque de tamaño.-> free(*ptr);lib=stdlib.hLibera la memoria apuntada.-> freemem(seg);lib=dos.hLibrea el bloque de memoria.-> heapcheck();-> farheapcheck(); Tutorial Turbo C
  • 86. © Rodolfo Gallardo-Rosaleslib=alloc.hExaminan la pila en busca de errores.-> heapcheckfree(relleno);->farheapcheckfree(relleno);lib=alloc.hVerifica que estén llenas con relleno.-> heapchecknode(*ptr);-> farheapchecknode(*ptr);lib=alloc.hComprueban el estado del nodo.-> heapfillfree(relleno);-> farheapfillfree(relleno);lib=alloc.hRellenan bloques libres con relleno.-> heapwalk(*inform);-> farheapwalk(*inform);lib=alloc.hRellena los campos de esa estructura.-> *malloc(tam);lib=stdlib.hApunta a una región de tam bytes.-> *realloc(*ptr, nuevotam);lib=stdlib.hCambia el tamaño de memoria. Tutorial Turbo C
  • 87. © Rodolfo Gallardo-Rosales -> *sbrk(cantidad); lib=alloc.h Incrementa en cantidad bytes la memoria. -> setblock(seg, tam); lib=dos.h Cambia el tamaño del bloque seg a tam.3.6. Funciones de directorio. -> chdir(*camino); lib=dir.h Convierte a camino en directorio actual. -> findfirst(*nombrear, *ptr, atrib); -> findnext(*ptr); lib=dir.h Busca el archivo que coincida con nombrear. -> fnmerge(*camino, *unidad, *dir, *nombrear, *ext); -> fnsplit(*camino, *unidad, *dir, *nombrear, *ext); lib=dir.h Construye el nombre de un archivo en base a sus componentes. Descompone el nombre de archivo. -> getcurdir(unidad, *dir); lib=dir.h Copia el directorio actual de trabajo en cadena dir. -> *getcwd(*dir, long); Tutorial Turbo C
  • 88. © Rodolfo Gallardo-Rosales lib=dir.h Copia el camino completo, hasta long caracteres. -> getdisk(); lib=dir.h Devuelve el número de unidad actual (1,A; 2,B; 3C; etc.) -> mkdir(*camino); lib=dir.h Crea un directorio usando el camino. -> *mktemp(*nombrear); lib=dir.h Crea un nombre de archivo único y lo copia a nombrear. -> rmdir(*camino); lib=dir.h Borra un directorio. -> searchpath(*nombrear); lib=dir.h Devuelve el camino donde está el archivo. -> setdisk(unidad); lib=dir.h Devuelve el número de unidades del sistema.3.7. Funciones de control de procesos. -> abort(); Tutorial Turbo C
  • 89. © Rodolfo Gallardo-Rosaleslib=process.h y stdlib.hTerminación inmediata del programa.-> atexit((*func)());lib=stdlib.hSi termina normalmente, llama a la función.-> execl(*nombrear, *arg0,...,*argn, NULL);-> execle(*nombrear, *arg0,...,*argn, NULL, *pent[]);-> execlp(nombrear, *arg0,...,*argn, NULL);-> execlpe(*nombrear, *arg0,...,*argn, NULL, *pent[]);-> execv(*nombrear, *arg[]);-> execve(*nombrear, *arg[], *pent[]);-> execvp(*nombrear, *arg[]);-> execvpe(*nombrear, *arg[], *pent[]);lib=process.hEjecutan un programa externo.-> exit(estado);-> _exit(estado);lib=process.h y stdlib.hTerminación normal inmediata del programa.-> spawnl(modo, *nombrear, *arg0,...,*argn, NULL);-> spawnle(modo, *nombrear, *arg0,...,*argn, NULL, *pent[]);-> spawnlp(modo, *nombrear, *arg0,...,*argn, NULL);-> spawnlpe(modo, *nombrear, *arg0,...,*argn, NULL, *pent[]);-> spawnv(modo, *nombrear, *arg[]);-> spawnve(modo, *nombrear, *arg[], *pent[]);-> spawnvp(modo, *nombrear, *arg[]);-> spawnvpe(modo, *nombrear, *arg[], *pent[]);lib=process.hEjecuta archivos externos. Tutorial Turbo C
  • 90. © Rodolfo Gallardo-Rosales3.8. Funciones de gráficos y de la pantalla de texto. -> arc(x,y,inicio,fin,radio); lib=graphics.h Dibuja un arco desde inicio hasta fin grados con centro en x,y y de radio radio. -> bar(izq,arr,der,aba); -> bar3d(izq,arr,der,aba,prof,indtapa); lib=graphics.h Realiza una barra en dos y tres dimensiones. -> circle(x,y,radio); lib=graphics.h Círculo con centro en x,y y radio radio. -> cleardevice(); -> clearviewport(); lib=graphics.h Limpia pantalla y restablece a 0,0. No existen más ventanas gráficas. -> closegraph(); lib=graphics.h Desactiva el entorno gráfico. -> clreol(); -> clrscr(); lib=conio.h Limpia hasta fin de línea. Limpia ventana de texto. Tutorial Turbo C
  • 91. © Rodolfo Gallardo-Rosales-> cprintf(*fmt);lib=conio.hEscribe en ventana de texto.-> cputs(*cad);lib=conio.hEscribe cadena a pantalla.-> cscanf(*fmt);lib=conio.hLee cadena del teclado.-> delline();lib=conio.hBorra línea actual.-> detectgraph(*controlador, *modo);lib=graphics.hDetecta el tipo de controlador gráfico.-> drawpoly(numpuntos, *puntos);lib=graphics.hDibuja un polígono.-> ellipse(x,y,inicio,fin,radiox,radioy);lib=graphics.hDibuja una elipse con centro en x,y, la parte mostrada entre iniciio y fin engrados (0..360) y longitudes radiox y radioy.-> fillellipse(x,y,rx,ry); Tutorial Turbo C
  • 92. © Rodolfo Gallardo-Rosaleslib=graphics.hDibuja y rellena una elipse, con centro en x,y y radios rx y ry.-> fillpoly(numpuntos, *puntos);lib=graphics.hRellena un polígono.-> floodfill(x,y,borde);lib=graphics.hRellena un objeto cerrado.-> getarcoords(*coords);lib=graphics.hDa valores a los campos de la estructura de coords.-> getaspectratio(*xasp, *yasp);lib=graphics.hRazones de aspecto de un objeto.-> getbkcolor();lib=graphics.hDevuelve el color de fondo actual.-> getcolor();lib=graphics.hDevuelve el color actual del dibujo.-> getdefaultpalette();lib=graphics.h Tutorial Turbo C
  • 93. © Rodolfo Gallardo-RosalesDevuelve la paleta por defecto.-> getdrivername();lib=graphics.hDevuelve el nombre del controlador de gráficos.-> getfillpattern(*patron);lib=graphics.h-> getfillsettings(*info);lib=graphics.hDa valor a la estructura de info.-> getgraphmode();lib=graphics.hDevuelve el modo de registro actual.-> getimage(izq,arr,der,aba,*buf);lib=graphics.hCopia una porción de pantalla a buffer.-> getlinesettings(*info);lib=graphics.hDa valores a las estructuras de info.-> getmaxcolor();lib=graphics.hMayor valor válido para el color actual.-> getmaxmode(); Tutorial Turbo C
  • 94. © Rodolfo Gallardo-Rosaleslib=graphics.hModo máximo disponible.-> getmaxx();-> getmaxy();lib=graphics.hMayor valor de x o y.-> getmodename(modo);lib=graphics.hNombre del modo especificado.-> getmoderange(controlador, *modobajo, *modoalto);lib=graphics.hModos que soporta el controlador.-> getpalette(*pal);lib=graphics.hCarga la estructura con paleta actual.-> getpalettesize();lib=graphics.hNo. de colores de la paleta actual.-> getpixel(x,y);lib=graphics.hColor del pixel en esas coordenadas.-> gettext(izq,arr,der,aba,*buf); Tutorial Turbo C
  • 95. © Rodolfo Gallardo-Rosaleslib=conio.hCopia el texto de esas coordenadas a buffer.-> gettextsettings(*info);lib=graphics.hcarga la estructura con valores de info.-> getviewsettings(*info);lib=graphics.hInformación sobre ventana gráfica actual.-> getx();-> gety();lib=graphics.hDevuelven x e y de posición actual.-> gotoxy(x,y);lib=conio.hSitúa al cursos de la pantalla de texto.-> graphdefaults();lib=graphics.hRestaura el sistema gráfico por default.-> grapherrormsg(coderror);lib=graphics.hApunta al mensaje de error.-> _graphfreemem(*ptr, tam);-> _graphgetmem(tam); Tutorial Turbo C
  • 96. © Rodolfo Gallardo-Rosaleslib=graphics.hDevuelve el valor de última operación gráfica.-> highvideo();lib=conio.hAlta intensidad de video.-> imagesize(izq,arr,der,aba);lib=graphics.hBytes necesarios para almacenar imagen.-> initgraph(*controlador, *modo, *camino);lib=graphics.hInicializa sistema de gráficos.-> insline();lib=conio.hInserta línea en blanco.-> installuserdriver(*controlador, (*func)());lib=graphics.hInstala controladores BGI creados por otros.-> installuserfont(*nomfuente);lib=graphics.hInstala fuentes trazadas por otros.-> line(xini,yini,xfin,yfin);-> lineto(x,y);-> linerel(deltax,deltay); Tutorial Turbo C
  • 97. © Rodolfo Gallardo-Rosaleslib=graphics.hTraza una línea desde ini hasta fin.Traza una línea desde CP hasta x,y.Traza una línea desde cp hasta dx y dy.-> lowvideo();lib=conio.hVideo de baja intensidad.-> moverel(deltax,deltay);lib=graphics.hSe desplaza desde CP hasta dx y dy.-> movetext(izq,arr,der,aba,nuevaizq,nuevaarr);lib=conio.hMueve área a nueva izq y arr.-> moveto(x,y);lib=graphics.hMueve el cursor desde CP hasta x,y.-> normvideo();lib=conio.hIntensidad normal.-> outtext(*cad);-> outtextxy(x,y,*cad);lib=graphics.hMuestra texto en modo gráfico.-> pieslice(x,y,inicio,fin,ratio); Tutorial Turbo C
  • 98. © Rodolfo Gallardo-Rosaleslib=graphics.hPastel con centro en x,y, y de inicio a fin con radio en r.-> putimage(x,y,*buf,op);lib=graphics.hColoca imagen salvada con getimage().-> putpixel(x,y,color);lib=graphics.hPone el pixel especificado de color.-> puttext(izq,arr,der,aba,*buf);lib=conio.hCopia el texto salvado con gettext().-> rectangle(izq,arr,der,aba);lib=graphics.hDibuja un rectángulo.-> registerbgidriver((controlador)());-> registerbgifont((fuente)());lib=graphics.hIndica al sistema presencia de controlador o fuente.-> restorecrtmode();lib=graphics.hRestaura pantalla a donde estaba antes de initgraph().-> sector(x,y,inicio,fin,xr,yr); Tutorial Turbo C
  • 99. © Rodolfo Gallardo-Rosaleslib=graphics.hDibuja un sector de elipse relleno de inicio a fin con centro en x,y y ejesxr y yr.-> setactivepage(página);lib=graphics.hDetermina la página de video que recibirá las funciones gráficas.-> setallpalette(*pal);lib=graphics.hCambia todos los colores de la paleta.-> setaspectratio(xaspect,yaspect);lib=graphics.hObtiene las razones de aspecto.-> setbkcolor(color);lib=graphics.hCambia el color del fondo.-> setcolor(color);lib=graphics.hEstablece color del dibujo.-> setfillpattern(*patron, color);lib=graphics.hEstablece patrón de relleno.-> setfillstyle(patron, color);lib=graphics.h Tutorial Turbo C
  • 100. © Rodolfo Gallardo-RosalesEstablece el patrón de relleno.-> setgraphbufsize(size);lib=graphics.hEstablece el tamaño del buffer.-> setgraphmode(modo);lib=graphics.hEstablece el modo gráfico actual.-> setlinestyle(estilo,patrón,ancho);lib=graphics.hDetermina el aspecto de la línea.-> setpalette(indice,color);lib=graphics.hCambia los colores del sistema de video.-> setrgbpalette(color,r,v,a);lib=graphics.hCambia los colores del sistema de video.-> settextjustify(horiz,vert);lib=graphics.hEstablece la manera de alineación del texto.-> settextstyle(fuente,dirección,tamaño);lib=graphics.hEstablece la fuente y estilo activos. Tutorial Turbo C
  • 101. © Rodolfo Gallardo-Rosales-> setusercharsize(mulx,divx,muly,divy);lib=graphics.hEscala el tamaño de las fuentes.-> setviewport(izq,arr,der,aba,corta);lib=graphics.hCrea una nueva ventana gráfica.-> setvisualpage(página);lib=graphics.hMuestra la página de video.-> setwritemode(modo);lib=graphics.hDetermina la salida de line(), linerel(), lineto(), rectangle() y drawpoly().-> textattr(atr);lib=conio.hEstablece color de fondo y primer plano para el texto.-> textbackground(color);lib=conio.hEstablece el color de fondo.-> textcolor(color);lib=conio.hEstablece el color de los caracteres.-> textheight(*cad); Tutorial Turbo C
  • 102. © Rodolfo Gallardo-Rosales lib=graphics.h Establece la altura de la cadena. -> textmode(modo); lib=conio.h Modo de video para pantalla de texto. -> textwidth(*cad); lib=graphics.h Anchura de la cadena, en pixels. -> wherex(); -> wherey(); lib=conio.h Devuelve las coordenadas de x o y. -> window(izq,arr,der,aba); lib=conio.h Crea una ventana rectangular de texto.3.9. Funciones variadas. -> abs(num); lib=stdlib.h y math.h Valor absoluto de num. -> assert(exp); lib=assert.h Escribe información de error y aborta el programa. Tutorial Turbo C
  • 103. © Rodolfo Gallardo-Rosales-> atof(*cad);lib=stdlib.h y math.hConvierte la cadena en double.-> atoi(*cad);lib=stdlib.hConvierte cadena a int.-> atol(*cad);lib=stdlib.hConvierte cadena en longint.-> *bsearch(*clave,*base,num,tam,(*comparar)(*,*));lib=stdlib.hRealiza búsqueda binaria en el array ordenado por base y apunta al primeroque coincida con clave, elementos=num, bytes/elemento=tam.-> _clear87();lib=float.hInicializa palabra de estado del coprocesador de punto flotante.-> _control187(palabracf,mascaracf);lib=float.hValor de la palabra del coprocesador.-> div(numer,denom);lib=stdlib.hObtiene cociente y resto de numer/denom.-> *ecvt(valor,ndigit,*dec,*signo); Tutorial Turbo C
  • 104. © Rodolfo Gallardo-Rosaleslib=stdlib.hConvierte valor en una cadena de longitud ndigit, dec indica la posición del. signo= + o -.-> __emit__(arg...);lib=stdlib.hInserta valores directamente en el código del programa.-> *fcvt(valor,ndigit,*dec,*signo);lib=stdlib.hIgual que ecvt.-> _fpreset();lib=float.hReinicializa el coprocesador.-> *gcvt(valor,ndigit,*buf);lib=stdlib.hConvierte valor en cadena -> a buffer.-> *getenv(*nombre);lib=stdlib.hInformación de entorno.-> *getpass(*cad);lib=conio.hApunta a una cadena de 8 caracteres, como password.-> getpid(); Tutorial Turbo C
  • 105. © Rodolfo Gallardo-Rosaleslib=process.hDevuelve el número de identificador de proceso.-> *itoa(num,*cad,base);lib=stdlib.hConvierte el entero num a cadena.-> labs(num);lib=stdlib.h y math.hDevuelve el absoluto de valor num = long int.-> ldiv(numer,denom);lib=stdlib.hDevuelve el cociente y resto de la operación numer/denom.-> *lfind(*clave,*base,*num,tam,(*comparar)(*,*));-> *lsearch(*clave,*base,*num,tam,(*comparar)(*,*));lib=stdlib.hRealizan búsqueda lineal.-> longjmp(bufent,val);lib=setjmp.hLa ejecución regresa al punto donde se llamó a setjmp().-> *ltoa(num,*cad,base);-> *ultoa(num,*cad,base);lib=stdlib.hConvierte num a cadena equivalente.-> _lrotl(l,i);-> _lrotr(l,i); Tutorial Turbo C
  • 106. © Rodolfo Gallardo-Rosaleslib=stdlib.hRotan los bits i posiciones a la izquierda o derecha.-> max(x,y);-> min(x,y);lib=stdlib.hEl mayor de dos valores, ó el menor.-> nosound();lib=dos.hApaga el altavoz de la micro.-> putenv(*vare);lib=stdlib.hMete al DOS variables de entorno.-> qsort(*base,num,tamaño,(*comparar)(*,*));lib=stdlib.hOrdena el array con quicksort.-> raise(señal);lib=signal.hManda al programa la señal señal.-> rand();lib=stdlib.hGenera secuencia pseudo-aleatoria.-> random(num);-> randomize(); Tutorial Turbo C
  • 107. © Rodolfo Gallardo-Rosaleslib=stdlib.hDevuelve un número aleatorio entre 0 y num -1.Inicializa el generador aleatorio.-> _rotl(val,num);-> _rotr(val,num);lib=stdlib.hRotan los bits de val num a la izquierda, o derecha.-> _setcursortype(tipo);lib=conio.hCambia la forma del cursor.-> setjmp(bufent);lib=setjmp.hSalva el contenido de pila en buffer.-> (signal(señal,(*sigfunc)(func)))();lib=signal.hInforma ejecutar la función cuando se recibe la señal.-> sound(frec);lib=dos.hPita en frecuencia frec hertz.-> srand(semilla);lib=stdlib.hPone semilla aleatoria.-> strtod(*inicio,**fin); Tutorial Turbo C
  • 108. © Rodolfo Gallardo-Rosales lib=stdlib.h Convierte en double la cadena de inicio. -> strtol(*inicio,*fin,base); -> strtoul(*inicio,**fin,base); lib=stdlib.h Convierte el long int el número de cadena. -> swab(*fuente,*destino,num); lib=stdlib.h Copia num bytes de la cadena fuente a destino. -> system(*cad); lib=stdlib.h Pasa cad como orden al DOS. -> va_start(ptrarg,ult_parm); -> va_end(ptrarg); -> va_arg(ptrarg,tipo); lib=stdarg.h Pasa a una función un número variable de argumentos.4. Librería de programas /*****PROG01.C*****/ #include <stdio.h> void func1(void), func2(void); int cuenta; /*cuenta es global*/ main (void) { cuenta=100; func1(); return 0; Tutorial Turbo C
  • 109. © Rodolfo Gallardo-Rosales}void func1(void){ int temp; temp=cuenta; func2(); printf("cuenta es %d", cuenta); /*imprime 100*/}void func2(void){ int cuenta; for (cuenta=1;cuenta<10;cuenta++) putchar(.);}/*****PROG02.C*****/#include <stdio.h>{ printf("Este es mi primer programa en Turbo Cn"); getch(); /*congela la pantalla/}/*****PROG03.C*****/#include <stdio.h>#include <conio.h>int cuenta(int i);main(void){ do{ cuenta(0); }while(!kbhit()); printf("se llamó %d veces", cuenta(1)); return 0;}cuenta (int i){ static int c=0; if(i) return c; else c++; return 0;} Tutorial Turbo C
  • 110. © Rodolfo Gallardo-Rosales/*****PROG04.C*****/#include <stdio.h>main(){ int edad; edad=35; printf("mi edad es de %d añosn", edad);}/*****PROG05.C*****/#include <stdio.h>char s[80];main(void){ s[3]=x; printf("%c",s[3]); return 0;}/*****PROG06.C*****/#include <stdio.h>main(){ char ch1, ch2, ch3; clrscr(); printf("Introduce un caracter y lo escribe tecleando ENTERn"); ch1=getchar(); putchar(ch1); putchar(n); printf("introduce un caracter y produce eco sin utlizar ENTERn"); ch2=getche(); putchar(ch2); putchar(n); printf("espera el tecleo de un caracter y lo escribe sin usar ENTERn"); ch3=getch(); putchar(ch3); printf("n Compás de espera ... Teclee ENTERn"); getch();}/*****PROG07.C*****/#include <stdio.h> Tutorial Turbo C
  • 111. © Rodolfo Gallardo-Rosalesmain(void){ int magico=123; int intento; printf("adivine el número mágico: "); scanf("%d",&intento); if (intento==magico) printf("*** Correcto ***"); else printf("... Incorrecto ..."); return 0;}/*****PROG08.C*****/#include <stdio.h>main(){ char aster=*, efe=F, jota=J; char silba=007, retro=b, blanco= , tab=t; int num1=-32767; unsigned int num2=65535; long int num3=999876; clrscr(); printf("resultados obtenidosn"); printf("%c--%c--%c--%c--n", aster, efe, jota, silba); printf("%c--%c--%c--%c--%c--%c--n", aster, blanco, retro, aaster, tab, aster); printf("%d--%u--%ld--%c--n", num1, num2, num3, silba); getch();}/*****PROG09.C*****/#include <stdio.h>main(void){ int magico=123; int intento; printf("Adivine el número mágico:"); scanf("%d", &intento); if (intento==magico){ printf("*** Correcto ***"); printf("%d es el número mágico...", magico); } Tutorial Turbo C
  • 112. © Rodolfo Gallardo-Rosales else{ printf("...Incorrecto..."); if (intento>magico) printf("demasiado alto..."); else printf("demasiado bajo..."); } return 0;}/*****PROG10.C*****#include <stdio.h>main(){ float num1=2345678.45; double num2=2345678.33; clrscr(); printf("resultado de punto flotante y notación científican"); printf("número flotante=--%f--%e--n", num1, num1); printf("doble flotante=--%f--%e--n", num2, num2); getch();}/*****PROG11.C*****/#include <stdio.h>main(void){ int magico=123; int intento; printf("Adivine el número mágico:"); scanf("%d",&intento); if (intento==magico){ printf("*** Correcto ***"); printf("%d es el número mágico", magico); } else if (intento>magico) printf("Incorrecto... demasiado alto"); else printf ("Incorrecto... demasiado bajo"); return 0;}/*****PROG12.C*****/#include <stdio.h>main() Tutorial Turbo C
  • 113. © Rodolfo Gallardo-Rosales{ int nomb=17; float nomb1=20.7658; char nomb2=K; clrscr(); printf("resultado: valor y dirección n"); printf("%d--%un", nomb, &nomb); printf("%c--%un", nomb2, &nomb2); printf("%f--%un", nomb1, &nomb1); getch();}/*****PROG13.C*****/#include <stdio.h>main(void){ int magico=123; int intento; printf("Adivine el número mágico:"); scanf("%d",&intento); if (intento==magico){ printf("*** Correcto ***"); printf("%d es el número mágico", magico); } else intento>magico? printf("Muy Alto"): printf("Muy Bajo"); return 0;}/*****PROG14.C*****/#include <stdio.h>#define NUM 1994main(){ int nume=222; float fnum=22.35; char letra=Z; char nom[50]="Gustavo Adolfo"; clrscr(); printf("resultados :n"); printf("definido el año %dn", NUM); Tutorial Turbo C
  • 114. © Rodolfo Gallardo-Rosales printf("el número entero es %dn", nume); printf("el número en punto flotante es %fn", fnum); printf("el rey %s y la letra %c", num, letra); getch();}/*****PROG15.C*****/#include <stdio.h>main(void){ int x; for (x=1;x<=100;x++) printf("%d",x); return 0;}/*****PROG16.C*****/#include <stdio.h>main(){ clrscr(); printf("resultado: secuencias de escapen"); printf("línea1 n línea2 t tabulado 6****** b retroceso de espacion"); printf("línea3========= b retorno de 1 espacio --> sigue a campanan"); getch();}/*****PROG17.C*****/#include <stdio.h>main(void){ int t; for(t=0;t<100;t++){ printf("%d",t); if (t==10) break; } return 0;}/*****PROG18.C*****/#include <stdio.h>main() Tutorial Turbo C
  • 115. © Rodolfo Gallardo-Rosales{ int ch; int cont=0; clrscr(); printf("resultado. códigos ASCII n"); for (ch=1;ch<127;ch++){ if (cont%12==0){ putchar(n); cont++; } if (ch>32) printf("%c=%d", ch, ch); cont++; } getch();}/*****PROG19.C*****/#include <stdio.h>main(void){ int x[10]; int t; for(t=0;t<10;++t) x[t]=t; for(t=0;t<10;++t) printf("%d",x[t]); return 0;}/*****PROG20.C*****/#include <stdio.h>main(){ float num1=456.8357; clrscr(); printf("formato de números ajustadosn"); printf("|%f|n", num1); /*entre barras*/ printf("%-18f|n", num1); /*18 espacios al margen izquierdo*/ printf("|%++18f|n", num1); /*18 esp. der. y con signo + */ printf("|%-+18f|n", num1); /*18 esp. izq. y con signo + */ printf("|%-28f|n", num1); /*28 esp. izq. sin signo */ getch();} Tutorial Turbo C
  • 116. © Rodolfo Gallardo-Rosales/*****PROG21.C*****/#include <stdio.h>#include <string.h>main(void){ char c1[80], c2[80]; gets(c1); gets(c2); printf("Longitudes: %d %dn", strlen(c1), strlen(c2)); if (!strcmp(c1, c2)) printf("las cadenas son igualesn"); strcat(c1, c2); printf("%sn", c1); return 0;}/*****PROG22.C*****/#include <stdio.h>main(){ int num1; int ning; float num2; char car1; clrscr(); printf("Introduzca en una sola línea y separados por un espacion"); printf("una letra un número decimal y un enteron"); ning=scanf("%c %f %d", &car1, &num2, &num1); printf("resultado: tipo y número de entradasn"); printf("caract=%c nfloat=%f entero=%d no. ingresos=%dn", car1, num2, num1, ning); getch();}/*****PROG23.C*****/#include <stdio.h>main(void){ int t, i, num[3][4]; for(t=0;t>3;++t) Tutorial Turbo C
  • 117. © Rodolfo Gallardo-Rosales for(i=0;i<4;++i) num[t][i]=(t*4)+i+1; /*mostrarlos*/ for(t=0;t<3;++t){ for(i=0;i<4;++1) printf("%d", num[t][i]); printf("n"); } return 0;}/*****PROG24.C*****/#include <stdio.h>main(){ int num1; long int num3; unsigned num4; float num2; char car1; static char nombre[80]; clrscr(); printf("escriba su nombren"); scanf("%s", nombre); printf("escribe: número--número largo--sin signo--float--caráctern"); scanf("%d %ld %u %f %c", &num1, &num3, &num4, &num2, &car1); printf("resultado: datos introducidosn"); printf("caract=%c nfloat=%f entero=%d largo=%ldn", car1, num2, num1, num3); printf("sin signo=%nn", num4); printf("La cadena es: %sn", nombre); getch();}/*****PROG25.C*****/#include <stdio.h>#include <ctype.h>#include <conio.h>#include <stdlib.h>#define CLASES 3#define NOTAS 30int nota [CLASES][NOTAS];void mostrar_notas(int n[][NOTAS]), intro_notas(void); Tutorial Turbo C
  • 118. © Rodolfo Gallardo-Rosalesint obt_nota(int num);main(void){ char c; for (;;){ do{ printf("(I)ntroducir notasn"); printf("(M)ostrar notasn"); printf("(T)erminarn"); c=toupper(getche()); }while(c!=I&&c!=M&&c!=T); switch(c){ case I: intro_notas(); break; case M: mostrar_notas(nota); break; case T: return 0; } }}/* introducir las notas de los alumnos */void intro_notas(void){ int t, i; for(t=0;t<CLASES;t++){ printf("clase # %d:n", t+1); for(i=0;i<NOTAS;++i) nota[t][i]=obt_nota(i); }}/* leer una nota realmente */obt_nota(int num){ char c[80]; printf("Introduzca la nota del estudiante # %d:n", num+1); gets(c); return(atoi(c)); Tutorial Turbo C
  • 119. © Rodolfo Gallardo-Rosales}/* mostrar notas */void mostrar_notas(int n[][NOTAS]){ int t, i; for(t=0;t<CLASES;++t){ printf("Clase #%d:n", t+1); for(1=0;i<NOTAS;++1) printf("el estudiante # %d tiene %dn", i+1, n[t][i]); }}/*****PROG26.C*****/#include <stdio.h>#define MAX 100#define LONG 80char texto [MAX][LONG];/* sencillo editor de texto */main(void){ register int t, i, j; for(t=0;t<MAX;T++){ printf("%d", t); gets(texto[t]); if(!*texto[t]) break; } /* muestra el texto caracter a caracter */ for(i=0;i<ti++){ for(j=0;*texto[i][j];j++) printf("%c", texto[i][j]); printf("%c", n); } return 0;}/*****PROG27.C*****/main(void){ int cuenta, q; int *m; cuenta=100; /* se asigna 100 a cuenta */ Tutorial Turbo C
  • 120. © Rodolfo Gallardo-Rosales m=&cuenta; /* m recibe la dirección de cuenta */ q=*m; /* q recibe el valor de la dirección de m */ printf("%d",q); /* imprime 100 */ return 0;}/*****PROG28.C*****/#include <stdio.h>main(){ int chi; while((chi=getchar())!=EOF) putchar(chi); getch();}/*****PROG29.C*****/#include <stdio.h>main(){ int LIMITE=4; int indice=0; int n=5; char caracter; clrscr(); while(++indice<=LIMITE){ printf("Resultados 1 n"); printf("índice=%dn", indice); } /* decreciente */ while(--n){ printf("Resultados 2 n"); printf("índice=%dn", n); } /* otro ejemplo */ printf("Ingrese una letran"); while((caracter=getch())!=s){ /* s para salir */ printf("La letra es una %cn", caracter); printf("Ingrese una s para salirn"); }} Tutorial Turbo C
  • 121. © Rodolfo Gallardo-Rosales/*****PROG30.C*****/#include <stdio.h>#include <stdlib.h>#define MAX 100struct inv{ char item[30]; float coste; int dispo;}info_inv[MAX];void inic_lista(void), listar(void), borrar();void intro(void);int menu(void), busca_libre(void);main(void){ char opcion; inic_lista(); for(;;){ opcion=menu(); switch(opcion){ case 1: intro(); break; case 2: borrar(); break; case 3: listar(); break; case 4: return 0; } }}void inic_lista(void){ register int t; for (t=0;t<MAX;++t) info_inv[t].item[0]=0;}menu (void){ char s[80]; Tutorial Turbo C
  • 122. © Rodolfo Gallardo-Rosales int c; printf("n"); printf("1. Introducir un artículon"); printf("2. Borrar un artículon"); printf("3. Listar el inventarion"); printf("4. Salirn"); do{ printf("nIntroduzca su opción: n"); gets(s); c=atoi(s); }while(c<0||c>4); return c;}void intro(void){ int sitio; sitio=busca_libre(); if (sitio==-1){ printf("nLista llena"); return; } printf("Introduzca artículo: "); gets(info_inv[sitio].item); printf("Introduzca coste: "); scanf("%f", &info_inv[sitio].coste); printf("Introduzca número de disponibles: "); scanf("%d%*c", &info_inv[sitio].dispo);}busca_libre(void){ register int t; for(t=0;info_inv[t].item[0]&&t<MAX;++t); if(t==MAX) return -1; return t;}void borrar(void){ register int sitio; Tutorial Turbo C
  • 123. © Rodolfo Gallardo-Rosales char s[80]; printf("Introduzca número de registro: # "); gets(s); sitio=atoi(s); if (sitio>=0&&sitio<MAX) info_inv[sitio].item[0]=0;}void listar(void){ register int t; for(t=0;t<MAX;++t){ if (info_inv[t].item[0]){ printf("artículo: %sn", info_inv[t].item); printf("coste: %fn", info_inv[t].coste); printf("disponibles: %dnn", info_inv[t].dispo); } } printf("nn");}/*****PROG31.C*****/#include <stdio.h>main(){ int n,y; char ch; printf("--- bucle típico ---n"); for(n=1;n<=5;++n) printf("n=%dn",n); printf("--- bucle de números pares ---n"); for(n=2;n<=6;n=n+2) printf("n=%dn",n); printf("--- descripción de caracteres ASCII ---n"); for(ch=A;ch<=C;ch++) printf("el caracter: %c equivale en ASCII a %dn", ch, ch); printf("--- bucle infinito con salida ---n"); n=0; for(;;){ printf("n=%d", n); n++; if(n==7) break; Tutorial Turbo C
  • 124. © Rodolfo Gallardo-Rosales } printf("--- bucle quebrado en n=%dn", n); printf("--- bucle descendiente condicionadon"); for(n=100;n>1;n=n/5) printf("n=%d", n); printf("--- bucle que condiciona al índice ---n"); y=0; for(n=1;y<23;y=++n*5+2) printf("n=%d y=%d n", n, y);}/*****PROG32.C*****/#include <stdio.h>main(){ int x; int y=25; clrscr(); printf("Ingrese un número: n"); scanf("%d", &x); printf("resultados de la sentencia if()n"); if(y>x*2+3) if(x>8) printf("x es mayor que 8 n"); else printf("x es igual a %dn", x); else printf("y toma el valor igual a: %dn", x*2+3); getch();}/*****PROG33.C*****/#include <stdio.h>#include <conio.h>#include <ctype.h>main(void){ char car; do{ car=getche(); if (islower(car)) putchar(toupper(car)); else putchar(tolower(car)); Tutorial Turbo C
  • 125. © Rodolfo Gallardo-Rosales }while (car!=.); return 0;}/*****PROG34.C*****/#include <stdio.h>#include <stdlib.h>main(){ int premio; int loteria=1; clrscr(); randomize(); premio=random(100); printf("%dn", premio); while (loteria){ printf("meta un número de uno a cien... cero para salir: n"); scanf("%d", &loteria); if (loteria==premio){ printf("EUREKA!!! numero=%dn", loteria); break; } else if (loteria>premio) printf("Apunte más bajo!!n"); else printf("Apunte más alto!!n"); } getch();}/*****PROG35.C*****/#include <stdio.h>main(){ int x=10; int y=20; int *p; clrscr(); printf("&x=%u &y=%u x=%d y=%dn", &x, &y, x, y); printf("asignación de punteros: p=&x; y=*p; n"); p=&x; y=*p; Tutorial Turbo C
  • 126. © Rodolfo Gallardo-Rosales printf(resultados: p=65496 y=*p=10n); printf("&p=%u p=%u &x=%u x=%d &y=%u y=%dn", &p, p, &x, x, &y, y); getch();}/*****PROG36.C*****/#include <stdio.h>#include <string.h>main(void){ char cad[80]; gets(cad); printf("La longitud es %d", strlen(cad)); return 0;}/*****PROG37.C*****/#include <stdio.h>main(argc, char argv[]){ FILE *fp; char car; if (argc!=2){ printf("Olvidó el nombre del archivo...n"); return 1; } if ((fp=fopen(argv[1],"w"))==NULL){ printf("No se puede abrir el archivo...n"); return 1; } do { car=getchar(); putc(car, fp); }while (car!=$); fclose(fp); return 0;}/*****PROG38.C*****/#include <stdio.h> Tutorial Turbo C
  • 127. © Rodolfo Gallardo-Rosalesmain(argc, char *argv[]){ FILE *fp; char car; if (argc!=2){ printf("Olvidó el nombre del archivo...n"); return 1; } car=getc(fp); while(car!=EOF){ putchar(car); car=getc(fp); } fclose(fp); return 0;}/*****PROG39.C*****/#include <stdio.h>main(int argc, char *argv[]){ FILE *entrada, *salida; char car; if(argc!=3){ PRINTF("Olvidó introducir nombre de archivo...n"); return 1; } if ((entrada=fopen(argv[1], "rb"))==NULL){ printf("No se puede abrir el archivo fuente...n"); return 1; } if ((salida=fopen(argv[2], "wb"))==NULL){ printf("No se puede abrir el archivo destino...n"); return 1; } while(!feof(entrada)){ car=getc(entrada); if(!eof(entrada)) putc(car, salida); } fclose(entrada); fclose(salida); Tutorial Turbo C
  • 128. © Rodolfo Gallardo-Rosales return 0;}/*****PROG40.C*****/#include <stdio.h>main(void){ FILE *fp; float f=12.23; if((fp=fopen("prueba", "wb"))==NULL){ printf("No se puede abrir el archivo...n"); return 1; } fwrite(&f, sizeof(float), 1, fp); fclose(fp); return 0;}/*****PROG41.C*****/#include <stdio.h>main(void){ register int i; FILE *fp; float balance[100]; if ((fp=fopen("balance", "wb"))==NULL){ printf("No se puede abrir el archivo...n"); return 1; } for(i=0;i<100;i++) balance[i]=(float)i; fwrite(balance, sizeof balance, 1, fp); fclose(fp); for(i=0;i<100;i++) balance[i]=0.0; if((fp=fopen("balance", "rb"))==NULL){ printf("No se puede abrir el archivo...n"); return 1; } fread(balance, sizeof balance, 1, fp); for(i=0;i<100;i++) printf("%f", balance[i]); fclose(fp); return 0;} Tutorial Turbo C
  • 129. © Rodolfo Gallardo-Rosales/*****PROG42.C*****/#include <conio.h>#include <stdlib.h>#include <stdio.h>#include <ctype.h>#include <string.h>void otro_num(void), busca(void);int menu(void);main(void){ char opcion; do{ opcion=menu(); switch(opcion){ case a: otro_num(); break; case b: buscar(); break; } }while (opcion!=t) return 0;}menu(void){ char c; do{ printf("(A)ñadir, (B)uscar o (T)erminar:"); c=tolower(getche()); printf("n"); }while(c!=t&&c!=a&&c!=b); return 0;}void otro_num(void){ FILE *fp; char nombre[80]; int prefijo, num; Tutorial Turbo C
  • 130. © Rodolfo Gallardo-Rosales if((fp=fopen("telef", "a"))==NULL){ printf("No se puede abrir archivo de directorio...n"); exit(1); } printf("Introduzca un nombre y un número: "); fscanf(stdin, "%s%d%d%d", nombre, &prefijo, &num); fscanf(stdin, "%*c"); fprintf(fp, "%s%d%d%dn", nombre, prefijo, num); fclose(fp);}void buscar(void){ FILE *fp; char nombre[80], nombre2[80]; int prefijo, num; if((fp=fopen("telef", "r"))==NULL){ printf("No se puede abrir el archivo de directorio...n"); exit(1); } printf("Nombre?"); gets(nombre); while(!feof(fp)){ fscanf(fp, "%s%d%d%d", nombre2, &prefijo, &num); if (!strcmp(nombre, nombre2)){ printf("%s: (%d) %d - %dn", nombre, prefijo, num); break; } } fclose(fp);}/*****PROG43.C*****/#include <stdio.h>main(){ float x=10.32; float y=20.43; clrscr(); printf("&x=%v &y=%u x=%f y=%fn", &x, &y, x, y); Tutorial Turbo C
  • 131. © Rodolfo Gallardo-Rosales printf("asignación de punteros: p=&x; y=*p; n"); p=&x; y=*p; printf("resultados: n"); printf("&p=%u p=%u &x=%u &y=%u x=%f y=%f n", &p, p, &x, &y, x, y); getch();}/*****PROG44.C*****/#include <stdio.h>#define text1 "texto 1 #define"char text2[20]="texto2 global";main(){ char text3[20]; char text5[80]; char text4[]="texto sin dimensión"; static char texto[80]="esto es una cadena"; *text5=0; clrscr(); printf("resultados: texto1=%sn", text1); puts(texto); puts(text2); puts(text4); printf("%s -- %s -- %sn", texto, text2, text4); printf("ingrese cadena tecleando...n"); gets(text3); puts(text3); strcat(text5, "texto rellenado"); puts(text5); getch();}/*****PROG45.C*****/#include <conio.h>void borde (int xinicial, int yinicial, int xfinal, int yfinal);main(void){ clrscr(); borde(1,1,79,25); window(3,2,40,9); Tutorial Turbo C
  • 132. © Rodolfo Gallardo-Rosales borde(3,2,40,9); gotoxy(3,2); cprintf("primera ventana"); window(30,10,60,18); borde(30,10,60,28); gotoxy(3,2); cprintf("segunda ventana"); gotoxy(5,4); cprintf("hola"); getche(); return 0;}void borde(int xinicial, int yinicial, int xfinal, int yfinal){ register int i; gotoxy(1,1); for(i=0;i<=xfinal-xinicial;i++) putch(-); gotoxy(1, yfinal-yninicial); for(i=0;i<=xfinal-xinicial;i++); putch(-); for(i=2;i<=yfinal-yinicial;i++){ gotoxy(1,i); putch(|); gotoxy(xfinal-xinicial+1, i); putch(|); }}/*****PROG46.C*****/#include <conio.h>main(void){ register int i, j; textmode(c80); clrscr(); for(i=1,j=1;j<24;i++,j++){ gotoxy(i,j); cprintf("X"); } for(;j>0;i++,j--){ gotoxy(i,j); cprintf("X"); Tutorial Turbo C
  • 133. © Rodolfo Gallardo-Rosales } textbackground(LIGHTBLUE); textcolor(RED); gotoxy(40,12); cprintf("Est es rojo con fondo azul claro"); gotoxy(45,15); textcolor(GREEN|BLINK); textbackground(BLACK); cprintf("Verde parpadeante sobre negro"); getch(); textmode(LASTMODE); return 0;}/*****PROG47.C*****/#include <graphics.h>#include <conio.h>main(void){ int controlador, modo; controlador=VGA; modo=VGAMED; initgraph(&controlador, &modo, " "); outtext("Normal"); settextstyle(GOTHIC_FONT, HORIZ_DIR, 2); outtext("Gótica"); settextstyle(TRIPLEX_FONT, HORIZ_DIR, 2); outtext("Triplex"); settextstyle(SANS_SERIF_FONT, HORIZ_DIR, 7); outtext("Sans_Serif"); getch(); restorecrtmode(); return 0;}/*****PROG48.C*****/#include <conio.h>#include <graphics.h>#include <stdlib.h>void cuadro(int xinicial, int yinicial, int xfinal, int yfinal, int color);main(){ Tutorial Turbo C
  • 134. © Rodolfo Gallardo-Rosales int controlador, modo; unsigned tamanio; void *buf; controlador=VGA; modo=VGAMED; initgraph(&controlador, &modo, " "); cuadro(20,20,200,200,15); setcolor(RED); line(20,20,200,200); setcolor(GREEN); line(20,200,200,20); geetch(); tamanio=imagesize(20,20,200,200); if(tamanio!=-1){ buf=malloc(tamanio); if(buf){ getimage(20,20,200,200,buf); putimage(100,100,buf,COPY_PUT); putimage(300,50,buf,COPY_PUT); } } outtext("Pulse una tecla..."); getch(); restorecrtmode(); return 0; } void cuadro(int xinicial, int yinicial, int xfinal, int yfinal, int color) { setcolor(color); line(xinicial,yinicial,xinicial,yfinal); line(xinicial,yinicial,xfinal,yfinal); line(xfinal,yinicial,xfinal,yfinal); line(xfinal,yfinal,xinicial,yfinal); }5. Bibliografía.BORLAND International. Turbo C users guide. U.S.A. 1988.BORLAND International. Turbo C reference guide. U.S.A. 1988. Tutorial Turbo C
  • 135. © Rodolfo Gallardo-RosalesGARCIA-BADELL, J.Javier. Turbo C: Programación y manejo de archivos. Macrobit Corporation. México, 1991.SCHILDT, Herbert. Programación en lenguaje C. [C made easy]. McGraw-Hill Inc. España, 1990.SCHILDT, Herbert. Turbo C/C++. Manual de referencia. [The complete reference]. Osborne/McGraw-Hill Inc. México, 1993.SCHILDT, Herbert. Turbo C. Programación avanzada. [Advanced Turbo C]. 2a. ed. Borland-Osborne/McGraw-hill. España, 1990.Para mayor información Se sugiere la lectura de alguno de los libros mencionados arriba, y el estudio más completo será la única manera de dominar completamente el Lenguaje de programación Turbo C. Tutorial Turbo C