C

1.TIPOS DE DATOS, OPERADORES Y EXPRESIONES..................................................... 6 1.1DECLARACIÓN DE VARIABLES..........................................................................................................6 1.2TIPO CARÁCTER. SECUENCIAS DE ESCAPE ANSI C.......................................................................... 6 1.3TIPO ENTERO...............................................................................................................................6 1.4MODIFICADORES DE TIPO............................................................................................................... 7 1.5MODIFICADORES DE ACCESO...........................................................................................................7 1.6OPERADORES ARITMÉTICOS............................................................................................................ 7 1.7OPERADORES RELACIONALES Y LÓGICOS.......................................................................................... 7 1.8OPERADORES A NIVEL DE BITS........................................................................................................ 7 1.9OPERADORES ESPECIALES...............................................................................................................7 1.9.1OPERADOR CONDICIONAL (?).........................................................................................................7 1.9.2OPERADORES DE DIRECCIÓN (&) Y DE CONTENIDO (*)...................................................................... 8 1.9.3OPERADOR SIZEOF....................................................................................................................... 8 1.9.4OPERADOR COMA (,)....................................................................................................................8 1.9.5OPERADORES PUNTO (.) Y FLECHA (->)...........................................................................................8 1.9.6OPERADORES PARENTESIS () Y CORCHETES []................................................................................... 8 1.10SENTENCIAS DE ASIGNACIÓN......................................................................................................... 8 1.11INICIALIZACIÓN DE VARIABLES...................................................................................................... 8 1.12CONVERSIÓN DE TIPOS................................................................................................................. 8 1.13PRECEDENCIA DE OPERADORES (DE MAYOR A MENOR)..................................................................... 9 2.SENTENCIAS DE CONTROL DE FLUJO........................................................................... 9 2.1SENTENCIAS CONDICIONALES.......................................................................................................... 9 2.1.1SENTENCIA IF..............................................................................................................................9 2.1.2SENTENCIA SWITCH.................................................................................................................... 10 2.2SENTENCIAS ITERATIVAS.............................................................................................................. 10 2.2.1SENTENCIA WHILE......................................................................................................................10 2.2.2SENTENCIA FOR.........................................................................................................................10 2.2.3SENTENCIA DO.......................................................................................................................... 11 2.2.4SENTENCIA BREAK..................................................................................................................... 11 2.2.5SENTENCIA CONTINUE.................................................................................................................11 2.2.6SENTENCIA GOTO.......................................................................................................................11 3.FUNCIONES DE CONTROL DEL PROGRAMA............................................................. 11 3.1FUNCIONES EXIT() Y _EXIT()........................................................................................................11 3.2FUNCIÓN ABORT()....................................................................................................................... 11 3.3FUNCIÓN ASSERT()...................................................................................................................... 11 4.FUNCIONES DE E/S.............................................................................................................. 12 4.1FUNCIONES PRINTF() Y SCANF().................................................................................................... 12 4.1.1ORDENES DE FORMATO DE ANSI C............................................................................................ 12 4.1.2ORDENES DE FORMATO DE TURBO C............................................................................................ 12 4.1.3DIFERENCIAS PRINTF/SCANF......................................................................................................... 13 4.2FUNCIONES PUTCHAR() Y GETCHAR()............................................................................................ 14 4.3FUNCIONES PUTS() Y GETS()......................................................................................................... 14

2

5.FUNCIONES DE CONSOLA................................................................................................ 15 5.1FUNCIONES CPRINTF() Y CSCANF()................................................................................................ 15 5.2FUNCIONES CPUTS() Y CGETS()..................................................................................................... 15 5.3FUNCIONES PUTCH(), GETCH(), GETCHE() Y UNGETCH().................................................................. 15 5.4FUNCIÓN KBHIT()........................................................................................................................15 5.5FUNCIONES LOWVIDEO(), HIGHVIDEO() Y NORMVIDEO().................................................................. 16 6.FUNCIONES........................................................................................................................... 16 6.1DECLARACIÓN DE FUNCIONES....................................................................................................... 16 6.2VALORES DEVUELTOS.................................................................................................................. 16 6.3REGLAS DE ÁMBITO DE LAS FUNCIONES..........................................................................................16 6.4ARGUMENTOS DE LAS FUNCIONES.................................................................................................. 16 6.5ARGUMENTOS DE MAIN................................................................................................................ 17 6.6NÚMERO VARIABLE DE ARGUMENTOS.............................................................................................17 6.7RECURSIVIDAD............................................................................................................................17 7.VARIABLES............................................................................................................................ 17 7.1TIPOS DE VARIABLES SEGÚN EL LUGAR DE DECLARACIÓN................................................................. 17 7.1.1VARIABLES LOCALES.................................................................................................................. 17 7.1.2PARAMETROS FORMALES............................................................................................................. 18 7.1.3VARIABLES GLOBALES................................................................................................................ 18 7.2ESPECIFICADORES DE CLASE DE ALMACENAMIENTO......................................................................... 18 7.2.1EXTERN...................................................................................................................................18 7.2.2STATIC.................................................................................................................................... 18 7.2.3REGISTER.................................................................................................................................18 7.2.4AUTO......................................................................................................................................19 8.SEPARACIÓN DE UN PROGRAMA EN VARIOS FICHEROS..................................... 19

9.EL PREPROCESADOR C..................................................................................................... 19 9.1DIRECTIVAS................................................................................................................................19 9.1.1DIRECTIVA #INCLUDE.................................................................................................................19 9.1.2DIRECTIVA #DEFINE................................................................................................................... 19 9.1.3DIRECTIVA #UNDEF................................................................................................................... 20 9.1.4DIRECTIVA #ERROR................................................................................................................... 20 9.1.5DIRECTIVAS #IF, #ELSE, #ELIF, #ENDIF......................................................................................... 20 9.1.6DIRECTIVAS #IFDEF Y #IFNDEF.....................................................................................................20 9.1.7DIRECTIVA #LINE...................................................................................................................... 20 9.2NOMBRES DE MACROS PREDEFINIDAS............................................................................................. 20 10.ARRAYS................................................................................................................................ 21 10.1ARRAYS UNIDIMENSIONALES....................................................................................................... 21 10.1.1INDICES DE ARRAYS UNIDIMENSIONALES....................................................................................... 21 10.1.2PASO DE ARRAYS UNIDIMENSIONALES COMO PARAMETROS............................................................... 21 10.1.3UTILIZACIÓN DE ARRAYS UNIDIMENSIONALES COMO CADENAS.......................................................... 22
3

..................10............3HUGE (MODIFICADOR DE TIPO)........ 30 13..............................................2................28 12..................................................................................................................................................................................................................................................................................25 11........................4PUNTEROS A ESTRUCTURAS.................................... 28 12......................................................................................................8FUNCIÓN QSORT().........................................................................26 11..................................22 10................................................................. 25 11..1ESTRUCTURAS.........2INICIALIZACIÓN DE ESTRUCTURAS..........................................................13MODIFICADORES DE TIPO NEAR........................................................1.............................................................27 11..1.........................................................2................................................. 30 13......... 30 13.............4ENUMERACIONES...................1.....................3REFERENCIA A LOS ELEMENTOS DE LA ESTRUCTURA.PUNTEROS.................................................3UNIONES..31 13...5PUNTEROS Y ARRAYS............1.......................23 11..........................................................................ENTRADA/SALIDA......................... HUGE Y MODELOS DE MEMORIA EN TURBO C............................................. 24 11...... FAR.........................2........25 11.....................10FUNCIONES LFIND() Y LSEARCH().........................................1FLUJOS Y FICHEROS...............................................................................13..................................3ARITMÉTICA DE PUNTEROS....... 23 11................29 12................. 27 11..........2.............4ASIGNACIÓN DINÁMICA DE MEMÓRIA...................................1PASO DE ARRAYS MULTIDIMENSIONALES COMO ARGUMENTOS A FUNCIONES.........................................................................5ESTRUCTURAS Y FUNCIONES.................13...................................................................................................25 11............1OPERADOR &..............................30 13.....................9FUNCIÓN BSEARCH()..................... 28 12..........................................................................................................4OPCIONES DE MODELO.............................2FAR (MODIFICADOR DE TIPO)......................................................................................2CAMPO DE BITS...................TIPOS COMPUESTOS DE DATOS...1DECLARACIÓN DE ESTRUCTURAS............12DISTINTOS TIPOS DE DECLARACIONES......................... 23 11.................................................................................................... 30 13.......................................................2OPERADOR *...................................................................................................................................................................4PASOS PARA OPERAR CON UN FICHERO.....................2TIPOS DE FLUJOS.....................27 12.................................30 13...................7PUNTEROS A FUNCIONES...... 22 10.......................................28 12............................................6INICIALIZACIONES DE PUNTEROS.......1NEAR (MODIFICADOR DE TIPO).....................................................................................13.......6OJO CON LAS MACROS............................ 29 12.........................................28 12................................................................................... 23 11..........29 12... 28 12.11TIPO VOID Y PUNTEROS.............................3INICIALIZACIÓN DE ARRAYS........................................................................................................................................................................................................................................................................................................................................................................................................................................................5SISTEMA DE FICHEROS TIPO UNIX........25 11.....................................1...............CONEXIÓN DE TURBO C CON ENSAMBLADOR............................................................ 31 14........3PROGRAMAS C CON FLUJOS......................13............................................................................................................................................................................2ARRAYS MULTIDIMENSIONALES......... 26 11................................. 31 4 .........................................................................................29 12..............................................31 13.....................................................................................................................................................................................................................................................2FLUJOS BINARIOS.......27 11.......1DECLARACIÓN.................5TIPOS DEFINIDOS POR EL USUARIO: TYPEDEF......................................... 30 13.. 23 11..........26 11............................................... 22 11.................28 12.........................................................................................1FLUJOS DE TEXTO.............................

.................................................... 60 5 .................................................................................1CONIO.........................................................H.............2.................H...........H..............................................................5GRAPHICS..........................6LIMITS.................................................13TIME............3DOS..........................................................................48 15...2............2CONSTANTES................1FUNCIONES Y MACROS....................................... 56 15....57 15....................H................2........................................................................2...................57 15...........2.. 55 15..................................................................LA BIBLIOTECA DEL C....................2..............................................H.......................4FLOAT...............................................2........14VALUES..........2DIR....................................................................................................................H....................................................................................................................................................2...........................H....................................................2........................8MATH...................2..H................................................................................................... 53 15.............................................................H........................2............7LOCALE........................................48 15.........................................58 15...................H.................10SIGNAL....................... 49 15..... 31 15..............................................................................................9PROCESS...... 59 15........................................................................H....................12SYS\STAT...............H.........11STDLIB.....2..2.....H.... TIPOS DE DATOS Y VARIABLES GLOBALES.................... 53 15................................................2................................................. 58 15......15.........H...... 31 15....... 56 15........ 49 15..........................

Tipos de datos.2Tipo carácter. 1.3Tipo Entero Es un número sin parte fraccionaria. 1.k.RESUMEN C 1. Puede escribirse de tres modos: 6 . los caracteres se definen con apóstrofos. 12 dígitos de precisión double coma flotante sin valor 0 sin valor void 1 Caracteres ASCII char 1 0 a 255 unsigned char 1 -128 a 127 signed char 2 -32768 a 32767 int 2 0 a 65535 unsigned int 2 Igual que int signed int 1 -128 a 127 short int 0 a 255 unsigned short int 1 1 Igual que short int signed short int 4 -2147483648 a 2147483649 long int 4 -2147483648 a 2147483649 signed long int 4 0 a 4294967296 unsigned long int 4 Aproximadamente 6 dígitos de precisión float 8 Aproximadamente 12 dígitos de precisión double 16 Aproximadamente 24 dígitos de precisión long double En C.1Declaración de variables Todas las variables en C han de ser declaradas antes de poder ser usadas. operadores y expresiones Descripción Longitud en bytes Rango Tipo carácter 1 0 a 255 char entero 2 -32768 a 32767 int coma flotante 4 aprox. Ejemplos: int i.j. Secuencias de escape ANSI C Código \b \f \n \r \t \” \’ \0 \\ \v \a \ddd \xddd Significado retroceso salto de página nueva línea retorno de carro tabulación horizontal comillas (“) apóstrofo (‘) caracter nulo ASCII 0 barra invertida (\) tabulación vertical alerta (bell. char caracter. 6 dígitos de precisión float 8 aprox. El valor de una constante carácter es el valor numérico del carácter en el conjunto de caracteres del sistema. campanilla) constante octal (ddd son tres dígitos como máximo) constante hexadecimal (ddd son tres dígitos como máximo) 1. La forma general de declaración es la siguiente: tipo lista_variables.

8Operadores a nivel de bits Operador & | ^ ~ >> << Acción AND OR XOR NOT (Complemento a uno) Desplazamiento a la derecha (no rotación) Desplazamiento a la izquierda (no rotación) 1. En octal: empezando el número por 0. char 1. En hexadecimal: empezando el número por 0x.6Operadores aritméticos Operador + * / % -++ Acción Resta Suma Producto Cociente Módulo del cociente Decremento Incremento 1. 1.4Modificadores de tipo Modificador signed unsigned long short Descripción con signo sin signo largo corto Tipos que lo aceptan int. char int.5Modificadores de acceso Modificador const volatile Descripción constante volátil 1. char int. En decimal: escribiendo el número sin empezar por 0. double int. Operadores relacionales Operadores lógicos Acción Acción Operador Operador > Mayor que && And >= Mayor o igual que || Or < Menor que ! Not <= Menor o igual que == Igual != No igual 1. char.9Operadores especiales 1.7Operadores relacionales y lógicos En C. 2. cualquier valor distinto de cero es cierto.1Operador condicional (?) Forma: expresión_1 ? expresión_2 : expresión_3 7 .1.9. 3. y el valor 0 es falso.

10Sentencias de asignación Son las siguientes: *=. es el tipo de mayor tamaño (mayor longitud en bytes). 8 . 1.6Operadores parentesis () y corchetes [] Para aumentar la precedencia y indexar arrays respectivamente.9. <<=. Como operador: la coma encadena varias expresiones. Equivalen. +=.4Operador coma (.9.12Conversión de tipos La conversión de tipos se refiere a la situación en la que se mezclan variables de un tipo con variables de otro tipo. -=. Cuando esto ocurre es un sentencia de asignación. 1. evalúa expresión_2 y toma ese valor para la expresión. &=. El tipo que resulta de aplicar un operador con dos operandos de tipos diferentes. 1. Estas expresiones son evaluadas de izquierda a derecha y el valor de la expresión total es el valor de la expresión más a la derecha. Para representar una lista de elementos. /=. por ejemplo. 1. 1. para inicializar varias variables del mismo tipo.Si expresión_1 es cierta.9.2Operadores de dirección (&) y de contenido (*) Estos dos operadores operan con punteros y se verán más adelante.5Operadores punto (. Se puede forzar un tipo poniendolo entre parentesis antes de la expresión. en este último caso.) Tiene dos usos en C: 1.9.9. Si expresión_1 es falsa. %=. |=. 1. la regla de conversión de tipo es muy fácil: el valor del lado derecho de la expresión se convierte al del lado izquierdo. el tipo ha de estar entre paréntesis. 2.) y flecha (->) Estos dos operadores se utilizan con dos tipos compuestos: estruct y unión y se verán más adelante.3Operador sizeof Toma el valor de la longitud en bytes de una expresión o de un tipo. = expresión es opcional y inicializa la última variable de la lista con el valor de la expresión.11Inicialización de variables tipo nombre_variable [= expresión]. siendo # un operador cualquiera: x #= y equivale a x=x # y. Se pueden utilizar comas en nombre_variable. 1. >>=. ^=. 1. evalúa expresión_3 y toma su valor para la expresión.

Sentencias de control de flujo Una sentencia en C puede ser: 1. 2. 10. sent_n} 2. Más alto Operador () [] -> . Una sentencia compuesta: { sent_1 sent_2 . Aditivo 5. Condicinal 14. Desplazamiento 6. Relacional 7. Igualdad 8.1. 9..1Sentencia if Sintaxis: 9 .1Sentencias condicionales 2. Unario 3. ! ~ + ++ -& * sizeof * / % + << >> < <= > >= == != & ^ | && || ?: = *= /= %= += -= &= ^= |= <<= >>= .1. 12. 13. Asignación 15. si no y) Asignación simple Asignar producto Asignar cociente Asignar módulo Asignar suma Asignar diferencia Asignar AND entre bits Asignar XOR entre bits Asignar OR entre bits Asignar desplazamiento hacia la izquierda Asignar desplazamiento hacia la derecha Evaluar 2. 11. Qúe es (o hace) Llamada a función Indexamiento de array Selector de componente indirecta Selector de componente directa Negación lógica (NO) Complemento a 1 Más unario Menos unario Preincremento o postincremento Predecremento o postdecremento Dirección Contenido (indirección) (devuelve tamaño operando. Una sentencia simple 2.. en bytes) Multiplica Divide Módulo (resto) Más binario Menos binario Desplazamiento a la izquierda Desplazamiento a la derecha Menor que Menor o igual que Mayor que Mayor o igual que Igual a Distinto a AND entre bits XOR entre bits OR entre bits AND lógico OR lógico ( a ? x : y significa “si a entonces x.13Precedencia de operadores (de mayor a menor) # Categoría 1. Multiplicativo 4.

Cuanda la encuentra ejecuta las sentencias correspondientes a ese case. case expresión_constante_2: sentencias_2 break. .2. se ejecuta sentencia.2. 2. } 10 .2Sentencias iterativas 2. se ejecuta las sentencias correspondientes al default.2Sentencia for Forma general: for (expresión_1. expresión_2. 2.2Sentencia switch Forma general: switch (expresión) { case expresión_constante_1: sentencias_1 break. y a expresión_3 se le llama incremento.if (expresión) sentencia o if (expresión) sentencia_1 else sentencia_2 Nota: El operador ? se puede utilizar para reemplaar las sentencias if-else. Si no hay ninguna expresión case que coincida con expresión. no se ejecuta ninguna sentencia. a expresión_2 se le llama condición.1Sentencia while Sintaxis: while (expresión) sentencia Descripción: Mientras expresión sea cierta. expresión_3) sentencia En la sentencia for. La forma general es equivalente a: expresión_1 while (expresión_2) { sentencia expresión_3. A continuación evalúa cada una de las expresiones constantes hasta que encuentra una que coincida con expresión. a expresión_1 se le llama inicialización. . 2. default: sentencias_n } Descripción: El switch evalúa expresión. . Si tampoco existe default.1.

2. NO UTILIZAR LAS SENTENCIA GOTO Y CONTINUE. 11 .1Funciones exit() y _exit() La función exit da lugar a la terminación del programa. Salta a una etiqueta.3Función assert() La función assert no devuelve nada y acepta una expresión como argumento.6Sentencia goto Sintaxis: goto etiqueta. Descripción: Fuerza una nueva iteración del bucle y salta cualquier código que exista entre medias. 2. 2. La función _exit provoca la terminación inmediata del programa. y a continuación llama a la función _exit() para terminar el programa. Por convención.2. 3. pero la sentencia se ejecuta antes de evaluar la expresión. 2.4Sentencia break Sintaxis: break. el valor 0 indica terminación normal. pero sólo del ciclo (o switch) más interior.3Sentencia do Sintaxis: do sentencia while (expresión). Igual que el do.2. si la expresión es falsa escribe un mensaje en la salida de error estándar y termina la ejecución del programa. Esta función testea la expresión dada. La función exit cierra todos los ficheros abiertos.Funciones de control del programa 3. no vacía los buffers ni cierra ningún fichero. for y do. En la libreria stdlib de Turbo C hay dos constantes definidas para pasárselas como argumento a la función exit: EXIT_SUCCESS que tiene valor 0 y EXIT_FAILURE que tiene valor 1 3. 3.2.5Sentencia continue Sintaxis: continue. vacía todos los buffers de salida. while. No requiere nada pero necesita un argumento que es recogido por el programa llamador. PROVOCAN PROGRAMAS POCO LEGIBLES Y/O MODIFICABLES. Descripción: Provoca la salida inmediata de las sentencias switch. No acepta ningún argumento. si la expresión es cierta no hace nada.2Función abort() La función abort aborta el programa.2.

4.prec] [F|N|h|l] type 4. el que sea más corto de longitud %g Entero octal sin signo %o Cadena de caracteres %s Entero decimal sin signo %u Entero hexadecimal sin signo %x Signo de tanto por ciento: % %% Puntero %p El argumento asociado debe ser un puntero a entero en el que se pone el número de caracteres %n impresos hasta el momento.1Ordenes de formato de ANSI C Forma # 0# #. rellenos con espacios a la derecha. Código Formato Carácter %c Entero decimal con signo %d Entero decimal con signo %i %e Punto flotante en notación no científica: [-]d. Numero de digitos de la parte real y de la fraccionaria. Justificación izquierda (por defecto es a la derecha) Long Short 4.# l h Descripción Indica la anchura mínima en la que se escribe ese argumento.ddd e [±] ddd %f Punto flotante en notación no científica: [-]dddd.2Ordenes de formato de Turbo C Incluye las de ANSI C. Indica el número mínimo y máximo de anchura para una cadena de carácteres. Igual que # pero los espacios sobrantes se rellenan con 0. en el caso de imprimir un número. 4.1. Sintaxis: printf (“cadena de control”. La función scanf lee datos formateados de la entrada estándar. scanf (“cadena de control”.1. 4.2. Hay una constante definida en el fichero stdio. rellenos con 0 o blancos a la izq.1Especificadores de formato % [banderas] [width] [. lista de argumentos).h que se llama EOF y tiene el valor -1.4.ddd Usa %e o %f. Las ordenes de formato pueden tener modificadores.1. lista de argumentos). Siempre empieza con + o+ Imprime signo para valores negativos solamente blanco Convierte usando forma alternativa # Formas alternativas para la bandera # 12 .Funciones de E/S El final de la entrada y salida de datos se suele marcar con un carácter especial llamado fin-de-fichero y se simboliza EOF.1Funciones printf() y scanf() La función printf escribe datos formateados en la salida estándar. La cadena de control está formada por caracteres imprimibles y códigos de formato.2.1. Estos modificadores van entreel % y la letra identificativa del código. respectivamente.2Especificador de formato “[bandera]” [bandera] Acción (ninguna) Justificado a la derecha. Justificado a la izquierda.

x) Precisión por defecto (e.1.6Especificador de formato “tipo” Tipo d i o u x X f e g E G c s % p n Acción signed decimal int signed decimal int unsigned octal int unsigned decimal int En printf = unsigned hexadecimal int En scanf = hexadecimal int En printf = unsigned hexadecimal int En scanf = hexadecimal long Punto flotante [-]dddd.ddd Punto flotante [-].u.4Especificador de formato “[.o. el puntero apunta a el primer elemento del vector.2.prec]” [.x.u.1. En el caso de los arrays.i.X e. devuelve EOF.o.3Diferencias printf/scanf En printf los argumentos son expresiones.c.1.u. La función printf devuelve un valor entero que contiene el número de caracteres escritos.prec] (ninguna) . far = XXXX:YYYY Almacena número de caracteres escritos en la dirección apuntada por el argumento de la entrada 4. rellenos con blanco Anchura mínima. E.X d.1.E.G el argumento es puntero far el argumento es punterno near el argumento es short int el argumento es long int el argumento es double (sólo scanf) el argumento es long double 4.o.3Especificador de formato “[anchura]” [anchura] n 0n * Acción Anchura mínima.i. 13 . f goG (no tiene efecto) Los argumentos distintos de 0 empiezan con 0 Los argumentos empiezan con 0x o 0X Siempre usa punto decimal Igual que e.0 .g.f) Sin punto decimal Al menos n caracteres El próximo argumento de la lista es la precisión 4. pero en scanf los argumentos han de ser direcciones de memoria (punteros).1.2. Para obtener la dirección de una variable se ha de utilizar el operador &: &variable.G e.E.x.i.f.f. En caso de error.E. o f pero con ceros al final 4.n * Acción Precisión por defecto (d. rellenos con 0 a la izquierda El próximo argumento de la lista es la anchura 4.2.i. E.d.2.5Especificador de formato [F|N|h|l]” Modificador F N h l l L Cómo es interpretado el argumento d.ddd e [±]ddd Formato e o f basado en la precisión Igual que e excepto E para exponente Igual que g excepto E para exponente Carácter simple Imprime caracters terminados en ‘\0’ o [.s.prec] El carácter % Puntero: near = YYYY.u o xoX e.d.g.

En otro caso.h que tiene valor 0. Ambas funciones devuelven. Siempre que se manejen caracteres con las funciones de E/S es preferible declararlos como enteros. La función puts acepta como argumento una cadena (sin formato). aunque este carácter no es añadido a la cadena. donde los caracteres introducidos a partir del nº100 son ignorados y no se escriben en la variable cadena. Un espacio en blanco en la cadena de control da lugar a que scanf() salte uno o más espacios en blanco en el flujo de entrada. por ejemplo. el nombre de la variable cadena de caracteres. es decir. La función getchar no recibe ningún argumento. Con la función gets no se puede hacer esto. entonces lea y descarte la coma. Un carácter que no sea espacio en blanco lleva a scanf() a leer y eliminar el carácter asociado. el carácter procesado. Si ocurre un error o se detecta el fin de fichero. y devuelve dicho puntero si tiene éxito o la constante NULL si falla. Un carácter blanco es un espacio.%d” da lugar a que scanf() lea primero un entero. Especificadores de formato. Este problema se puede solucionar con la función scanf y el modificador de formato %100s. devuelve EOF. y finalmente lea otro entero. “%d. Si tiene éxito devuelve el último carácter escrito (siempre es ‘\n’).2Funciones putchar() y getchar() La función putchar escribe un carácter en la salida estándar. 2. Caracteres sin espacios en blanco. En la cadena de control de scanf se pueden distinguir tres elementos: 1. en caso de éxito. por ejemplo. EOF. 4. 3. un tabulador o un carácter de nueva línea.La función scanf devuelve el número de campos que han sido asignados. los caracteres a partir del 100 se están escribiendo en memoria en posiciones no reservadas. en la declaración de cadena se ha reservado memoria para 100 caracteres y la función gets o scanf leen más de 100 carácteres. La función getchar lee un carácter de la entrada estándar. La función gets lee una cadena de caracteres de la entrada estándar hasta que se encuentra el carácter ‘\n’. y en caso de error o fin de fichero. scanf() termina. La función gets acepta como argumento un puntero al principio de la cadena. se devuelve EOF. porque EOF tiene asignado el valor -1. Con las funciones de lectura de cadenas es necesario tener una precaución muy importante: si. Esta constante se suele utilizar para denotar que un puntero no apunta a ningún sitio. 14 . La función putchar necesita un argumento que és el carácter a escribir. Caracteres con espacios en blanco. Por ejemplo. 4. NULL es una constante definida en el fichero stdio. Si el carácter especificado no se encuentra.3Funciones puts() y gets() La función puts escribe una cadena de caracters y un carácter de nueva línea al final de la cadena en la salida estándar.

Funciones de consola Todas las funciones. 15 .2Funciones cputs() y cgets() La función cgets lee una cadena de caracteres de la consola. están representadas por una secuéncia de dos carácteres: un carácter cero seguido del código de exploración de la tecla presionada. 5.Para pasar a la línea siguiente.Se lee de la salida estandar . Funciones de E/S estándar Funciones de E/S de consola . Las teclas especiales. la función cputs no pasa a la línes siguiente a no ser que se encuentre en la cadena los caracteres de nueva línea y retorno de carro.h de Turbo C 2. La función ungetch devuelve un carácter al teclado. devuelve el último carácter escrito.3Funciones putch(). es necesario escribir dos caracteres: ‘\n’ existe una variable de tipo entera que se llama directvideo. con eco a pantalla (getche) o sin eco (getch). No se puede devolver más de un carácter consecutivo. El primer elemento de la cadena debe contener la longitud máxima de la cadena a ser leída.h> (consola input/output).5. Un valor de 1 hace la escritura más rápida pero menos portable. La función cscanf lee de teclado.Se lee de teclado . Es similar a putchar. de consola. La función cputs. tales como las teclas de función. para pasar a la línea siguiente. es necesario ejecutar dos veces la función getch (o getche). Si hace ungetch. La función puts escribía una cadena y además un caracter de nueva línea. Son similares a getchar. están recogidas en la libreria <conio. El valor por defecto es directvideo=1. al igual que la función puts. Así. getche() y ungetch() La función putch escribe un carácter en consola. La función cgets devuelve en el segundo elemento de la cadena el número de carácteres leídos. 5.4Función kbhit() La función kbhit devuelve un valor cierto (distinto de cero) si hay una tecla disponible y falso (0) si no la hay. y en general toda la información. que es donde empieza la cadena leída. 5. si tiene el valor 0. Devuelve la dirección del tercer elemento del array. En la función cprintf. Acepta como parámetro el carácter a devolver y devuelve el propio carácter si hace la operación con éxito o EOF si ha ocurrido un error. Esta variable controla la salida: si y ‘\r’ directvideo tiene valor 1. La cadena empieza en el tercer elemento del array. la salida se escribe vía llamadas a la ROM BIOS.Se escribe en pantalla . La función cprintf escribe en pantalla en la posición actual del cursor y con el atributo de pantalla actual.Se escribe en la salida estandar . la salida va directamante a RAM de video.Se escribe y lee a traves de buffers . la próxima llamada de getch o cualquier otra función de entrada de teclado. Las funciones getch y getche leen un caracter de consola. Sólo se diferencia en dos cosas: 1.Para pasar a la línea siguiente hay que escribir los escribir el carácter de nueva línea: ‘\n’ caracteres de nueva línea y el de retorno de carro: ‘\n’ y ‘\r’ 5. es suficiente . La función cputs escribe una cadena de caracteres en pantalla. leerá el carácter que devolvió la función ungetch. para leer un caracter especial.1Funciones cprintf() y cscanf() Estas dos funciones son exactamente iguales que sus correspondientes printf y scanf. getch().No utiliza buffers . DIRECTVIDEO: En la libreria conio.

En las funciones de tipo void se puede hacer return. 4.5Funciones lowvideo().4Argumentos de las funciones Los argumentos se pueden pasar a las funciones de dos formas: 1. Es conveniente declarar todas las funciones a utilizar. Llamada por valor: este método copia el valor del argumento en el parámetro formal. sino una palabra clave.2Valores devueltos Todas las funciones excepto aquéllas del tipo void. Es lícito suprimir el nombre de los parametros así que también se podría declarar: tipo nombre (tipo.1Declaración de funciones La forma general de una función en el estándar ANSI actual es: especificador_de_tipo nombre_de_la_función (lista_de_declaraciones_de_parametros) { cuerpo de la función } Especificador_de_tipo: es el tipo del valor que devuelve la función. La forma general de return es: return expresión. Se puede utilizar para devolver un valor. Llamada por referéncia: este método copia la dirección del argumento (que ha de ser una variable) en el parámetro formal.3Reglas de ámbito de las funciones Se utilizan las mismas reglas que con las declaraciones y definiciones de las variables globales. y por tanto no necesita paréntesis.). Lista_de_declaraciones_de_parametros: es una lista de declaraciones separadas por comas donde cada declaración consta de tipo y nombre de parámetro. 6.. 6. devuelven un valor. 3. Fuerza a una salida inmediata de la función. el valor es 0. 16 . 2. antes de su definición para evitar problemas. 6. tipo. excepto main.Funciones 6. . & dirección). highvideo() y normvideo() Estas funciones hacen que los carácteres que se escriban a partir de la llamada se escriban en la intensidad correspondiente (baja. (Por punteros: * contenido. para provocar la salida inmediata de la función. alta y normal). 6. Observaciones: 1. A las declaraciones de las funciones tambien se les llama prototipos. Si no se pone se supone que la función devuelve un entero. 2.5.. Declaración función: tipo nombre (declaración_parametros). Este valor se especifíca explícitamente en la sentencia return y si no existe ésta. No es una función.

6.5Argumentos de main
Argc y argv se utilizan para recibir los argumentos de la línea de ordenes. En este caso, la función main se declara para recibir estos dos parametros especiales. El parametro argc contiene el número de argumentos de la línea de ordenes y es un entero. Siempre vale 1, por lo menos, ya que el nombre del programa cuenta como el primer argumento. El parametro argv es un array donde cada elemento es una cadena de caracters, la cual contiene información suministrada al programa a través de la línea de órdenes del sistema operativo. En Turbo C, también podemos utilizar un tercer parámetro en la función main, arge, con la misma estructura que el parametro argv, y que contiene las cadenas del entorno.

6.6Número variable de argumentos
En la libreria <stdarg.h> nos encontramos toda la información necesaria para declarar funciones en las que el número y el tipo de parámetros es variable. Al final de una declaración de parametros puede aparecer un parametro puntos suspensivos (…) que simbolizan que el número y tipo de argumentos es variable. va_list puntero_a_los_argumentos; Esta variable (puntero_a_los_argumentos) es de tipo va_list y es un puntero a uno de los argumentos. El tipo va_list es un tipo definido en la libreria <stdarg.h>. va_start (puntero_a_los_argumentos, segundo_parametro); Esta función esta declarada en la libreria <stdarg.h> y acepta dos parámetros. El primero es de tipo va_list, es decir, es el puntero a los argumentos, y el segundo parámetro ha de ser el parámetro conocido situado más a la derecha en la función en que estamos. La misión de la función va_start() es inicializar el puntero a los argumentos. va_end (puntero_a_los_argumentos); Esta función está declarada en la libreria <stdarg.h> y acepta un parametro que es de tipo va_list y debe ser el puntero de los argumentos. La misión de la función va_end () es finalizar el acceso del puntero a los argumentos. Es importante llamar a esta función cuando ya no es necesario utilizar el puntero a los argumentos. va_arg (puntero_a_los_argumentos, segundo_parametro) Tiene la misma estructura que va_start, y devuelve el argumento al cual el puntero a los argumentos apunta actualmente.

6.7Recursividad
Si una expresión en el cuerpo de una función se llama a sí misma, la función es recursiva. La versión iterativa tiene dos ventajas sobre la versión recursiva: 1. Es más rápida. 2. Consume menos memoria. La versión recursiva es preferible en aquellos casos en los que la lógica es mucho más clara y sencilla que en la versión iterativa.

7.Variables
7.1Tipos de variables según el lugar de declaración
7.1.1Variables locales
Son aquellas que se declaran dentro de una función. 17

Estas variables se declaran al principio de un bloque de código, se destruyen al llegar al final del bloque y sólo pueden ser utilizadas (ya que sólo tienen existéncia) dentro de ese bloque. Recordar que un bloque de código empieza con una llave abierta y termina con una llave cerrada.

7.1.2Parametros formales
Si una función va a usar argumentos, entonces debe declarar las variables que van a aceptar los valores de esos argumentos. Estas variables son los parametros formales de la función. Se comportan como cualquier otra variables local de la función.

7.1.3Variables globales
Las variables globales se conocen a lo largo de todo el programa y se pueden usar en cualquier parte de código. Además, mantienen su valor durante toda la ejecución del programa. Las variables globales se crean al declararlas en cualquier parte fuera de una función.

7.2Especificadores de clase de almacenamiento
Se usan para indicar al compilador cómo se debe almacenar la variable que le sigue. El especificador de almacenamiento precede al resto de la declaración de variable. Su forma general es: especificador_de_almacenamiento tipo nombre_de_variable;

7.2.1Extern
Sirve para declarar (no definir1), una función. El principal uso se da cuando un programa está compuesto de varios ficheros y tenemos una variable global a varios de ellos. En un fichero estará definida la función, mientras en los restantes ficheros que la utilicen, estará declarada.

7.2.2Static
Tienen dos significados diferentes dependiendo si son locales o globales.

7.2.2.1Variables estaticas locales
La diferencia con las variables locales normales es que su contenido no se pierde al salirse de la función, de tal manera que al volver a entrar en la función, la variable estática tiene el mismo valor que el que tenía cuando terminó la función en la llamada anterior. La variable estática sólo es inicializada en la primera llamada a la función.

7.2.2.2Variables estaticas globales
Cuando se aplica el modificador static a una variable global, se indica al compilador que cree una variable global conocida únicamente en el fichero en el que se declara la variable global static. Esto significa que, aunque la variable es global, las rutinas de otros ficheros no la reconocerán ni alterarán su contenido directamente; así, no estará sujeta a efectos secundarios.

7.2.3Register
El especificador register pide al compilador de C que mantenga el valor de las variables definidas con ese modificador en un registro de la CPU en lugar de en memoria, que es donde se almacenan normalmento las variables. Observaciones: 1. El acceso es mucho más rápido. 2. Si no se pueden almacenar en registro, se almacenan en memoria. 3. Sólo pueden ser de tipo int y char, y además han de ser locales no estáticas o parámetros de función.

1

En la definición de una variable se reserva espacio de memoria para una variable. La declaración le indica al compilador que esa variables está o será definida en otra parte, pero no reserva memoria para ella. Así pues, una variable sólo se puede definir una vez pero se puede declarar todas las veces que se desee. 18

4. En la mayoria de los sistemas sólo se permiten una o dos variables register al mismo tiempo. En la práctica, se declaran variables register aquéllas que se utilizan como índices en los bucles.

7.2.4Auto
Las variables auto son todas aquellas variables locales que no son estáticas. En la practica, este especificador de clase de almacenamiento no se utiliza nunca, ya que todas las variables locales que no llevan el especificador static son consideradas auto.

8.Separación de un programa en varios ficheros
Tiene dos grandes ventajas: 1. Mayor modularidad. 2. Tiempos de compilación más cortos. En Turbo C, la compilación separada se consigue creando un fichero proyecto (con extensión .PRJ) en el cual se listan todos los ficheros fuentes que componen el proyecto.

9.El preprocesador C
El preprocesador le da ciertas órdenes al compilador. Conceptualmente, el preprocesador procesa el código fuente antes que el compilador. A las instrucciones del preprocesador se les llama directivas de preprocesamiento. Todas empiezan con el símbolo #. Las directivas no son sentencias C, y por eso no llevan puntos y coma al final.

9.1Directivas
9.1.1Directiva #include
Busca el fichero que atiende por el nombre que está situado detrás y lo incluye en el fichero actual.

9.1.2Directiva #define
Tiene dos formas:

9.1.2.1Primera forma
#define identificador cadena A este identificador se le llama nombre de macro o simplemento macro. Esta directiva hace que a partir de la definición de la macro, cada vez que el preprocesador encuentre identificador en el código fuente, lo sustituya por cadena. Si el identificador aparece dentro de una cadena, no se realiza la sustitución. Cuando la cadena es más larga que una línea, se puede continuar en la siguiente poniendo una barra invertida al final de la línea.

9.1.2.2Segunda forma
#define id1(id2,…) cadena El paréntesis ha de ir inmediatamente después de id1 ya que si no pertenecería a la cadena. Todas las instancias de id2 en cadena serán reemplazadas con el texto actual definido por id2 cuando id1 es referenciado en el código fuente. Ejemplo: #define SUMA(a,b) a + b

19

#endif Estas directivas permiten compilar selectivamente parte del código fuente de un programa./*…*/ x = SUMA (5. 20 . #line <constante> [<identificador>] 9. Este proceso se llama compilación condicional. sea la dada por <constante>. #elif. Esto se expande a: x= 5 + 8. y el fichero de entrada corriente sea el dado por <identificador>. #undef identificador 9. 9.5Directivas #if. Contiene 1 si implementación estandar. Forma general bloque #if: #if expresión_constante secuencia de sentencias #endif Forma general bloque #if-#else: #if expresión_constante secuencia de sentencias #else secuencia de sentencias #endif La directiva #elif quiere decir else if 9. #error mensaje 9.1.6Directivas #ifdef y #ifndef #ifdef identificador secuencia de sentencias #endif #ifdef significa “si definido”. Si se ha definido previamente identificador en una sentencia #define.1.7Directiva #line Hace que el compilador crea que el número de línea de la próxima línea a la que está esta directiva.4Directiva #error Fuerza al compilador a parar la compilación y escribir un mensaje de error. 8). #ifndef significa “si no definido”. se compila el bloque de código que sigue a la sentencia. Nombre del fichero fuente actual.2Nombres de macros predefinidas Macro _DATE_ _FILE_ _LINE_ _STDC_ Tipo Literal string Literal string Constante decimal Constante Contenido Cadena de la forma mes/día/año con la fecha de compilación.1. Número de línea actual del fichero fuente actual.1. 9. y otro número si no. #else.1.3Directiva #undef Elimina una definición anterior de la macro que le sigue.

funcion_ejemplo_2 (array). for (y=0. funcion_ejemplo_1 (array). Es responsabilidad del programador el indexamiento correcto de un array. y<10 .2Paso de arrays unidimensionales como parametros Existen tres formas de declarar un parámetro que va a recibir un puntero a un array.1.Arrays Un array es una colección de variables del mismo tipo que se referencia por un nombre común.i++) printf(“%d”.1Arrays unidimensionales Forma general de declaración: especificador_de_tipo nombre_variable [tamaño]. for (i=0. } void funcion_ejemplo_2 (int a[]).i<10. a[i]). funcion_ejemplo_3 (array). void funcion_ejemplo_2 (int a[]). void main (void) { int array [10] register int y. Forma general de acceder a un elemento del array es: nombre_variable [indice] 10._TIME_ Cadena de la forma horas:minutos:segundos con la hora de compilación. Veamos con un ejemplo las tres formas.1Indices de arrays unidimensionales Todos los arrays tienen el cero como índice de su primer elemento. #include <stdio. Literal string 10. } void funcion_ejemplo_1 (int a[10]) { register int i.1. { register int y.y++) array[i]=i. for (i=0. Tiene dos usos principales: saber si estamos compilando en Turbo C y con que versión en el caso de que así sea. 10. En Turbo C existe _TURBOC_. C no comprueba los límites de los arrays. 10. } 21 .i++) printf (“%d”.i<10. a[i]). void funcion_ejemplo_3 (int *a).h> void funcion_ejemplo_1 (int a[10]).

Así. Forma general de acceso: nombre_array [ind_1] [ind_2]…[ind_n] 10. este método de declaración define a como un puntero a entero.3Utilización de arrays unidimensionales como cadenas En C una cadena se define como un array de caracteres que termina en un carácter nulo (\0). el tamaño real del array es irrelevante al parámetro (pero no al programa. La lista_de_valores es una lista de constantes. Esta es la forma más común en los programas escritos profesionalmente en C. para declarar arrays de caracters es necesario que sean de un carácter más que la cadena más larga que pueda contener. 10.void funcion_ejemplo_3 (int *a) { register int i. de esta manera sólo se pasa un puntero a un array. cuyo tipo es compatible con especificador_de_tipo. Por supuesto si se quiere se puede incluir la primera dimensión. el parámetro a se declara como un puntero a entero. Además. int m [3][4] { {1.2Arrays multidimensionales Forma general de declaración: especificador_de_tipo nombre_array [tam_1] [tam_2]…[tam_n]. debe haber en las funciones un parámetro de tipo puntero para recibirlo. el compilador de C automáticamente lo convierte a un puntero a entero. tam_2. a[i]). 22 .3.2. En la función funcion_ejemplo_2.4}.2. y<10. Ya que el C no comprueba los límites de los arrays. } En la función funcion_ejemplo_1.3.1Paso de arrays multidimensionales como argumentos a funciones Cuando se pasan arrays multidimensionales a funciones. separadas por comas.2. En la función funcion_ejemplo_3. …. Esto se permite porque cualquier puntero se puede indexar usando [] como si fuese un array. Por esta razón. Esto es necesario porque ningún parámetro puede recibir un array de enteros. el parámetro a se declara como un array de enteros de diez elementos. y++) printf (“%d”.1.4. todo lo que esté encerrado entre comillas es una constante de cadena. se tiene que declarar todo excepto la primera dimensión. for (y=0. 10. tam_n han de ser expresiones constantes.3Inicialización de arrays especificador_de_tipo nombre_array [tamaño_1]…[tamaño_N] = { lista_de_valores}. En C. por supuesto). 10. Los tres metodos de declarar un parámetro de tipo array llevan al mismo resultado: un puntero. el parámetro a se declara como un array de enteros de tamaño desconocido. NOTA: tam_1. Hay dos formas de inicializar arrays multidimensionales: int m [3][4] { 1.

En nuestro caso el molde es: (int *) /* puntero a entero */ El argumento que le pasamos a malloc ha de ser el número de bytes de memoria a reservar.8}.7. un puntero que apunta a una dirección de memoria sin tener tipo base.12 }. Al valor devuelto por la función malloc (puntero a void o puntero a char) siempre se le realiza un moldeado (recordad que esto se hacia con: (tipo)) para adecuarlo al tipo base de nuestro puntero que va a apuntar a esa zona de memoria reservada.11. los bytes de memoria solicitados los reserva en un espacio de memoria contiguo. {9. Es un operador monario que devuelve el valor de la variable localizada en la dirección que sigue. los subcorchetes delimitan las lineas a rellenar. v= (int *) malloc (n * sizeof(int)). 11.6.6.11.Punteros Un puntero contiene una dirección de memoria 11.7. La función malloc reserva memoria.10.10. el compilador va rellenando el vector posicion a posición con los valor que encuentra. En esta declaración estamos declarando v como un puntero a entero. se aprecia que si hacemos p++. Si no hay suficiente memoria. Toda la aritmética de punteros está en relación con el tipo base del puntero por lo que el puntero está siempre apuntando al elemento apropiado del tipo base. es decir. La diferencia es que en el primer caso. Y en el segundo caso. int *v. 11.1Operador & & es un operador monario que devuelve la dirección de memoria de su operando. 11. 11. el tamaño del objeto al que apunta. devuelve NULL. no aumenta el valor de p en 1 sino que aumenta en 2. }. acepta como argumento los bytes de memoria a reservar y devuelve un puntero al primer byte de la zona de memoria reservada. Esto siempre se hace siguiendo la fórmula: numero_de_elementos * sizeof (tipo_de_cada_elemento) Otra forma de hacer lo mismo es: 23 .4Asignación dinámica de memória Cuando la asignación de memoria se determina en tiempo de ejecución se dice que es asignación dinámica. {5. Ejemplo: queremos crear un vector de enteros (v) de tamaño n (introducido por el usuario).8.12}. o dicho de otro modo.5.3Aritmética de punteros Si tenemos un puntero p de tipo int. esto quiere decir que devuelve un puntero que apunta a cualquier tipo base. void *malloc (unsigned int bytes). El prototipo de esta función se encuentra en el fichero malloc. saltando a la siguiente linea cuando a completado una. 9.h.2Operador * El operador * es el complemento de &. Vemos que devuelve un puntero a void. que es el tamaño en bytes de un int.

h>. unsigned numero_de_elementos_a_reservar. Una estructura común en C es la de array de punteros. Un puntero a void como parámetro indica que acepta cualquier puntero. Cuando se trabaja con cadenas de caracteres sí se debe utilizar la notación puntero. que es la función calloc cuyo prototipo es el siguiente: void *calloc ( tamanyo_en_bytes_de_cada_elemento). Pensad que con notación array. se puede caer el sistema.5Punteros y arrays Existe una estrecha relación entre los punteros y los arrays. Esta función es igual que malloc con la única diferencia de sus parámetros. si no es así. se escribe: x[2] = &var. independientemente del tipo base al que apunta. se escribe: *x[2] 24 . equivalente a malloc. No obstante. en la librería <alloc. Esta memoria asignada no se desasigna al salir del bloque de código en que fue asignada como ocurre con las variables locales sino con la función free (liberar) o al terminar el programa.h y es el siguiente: void free (void *p). Para encontrar el valor de var.n * sizeof (*v) Las dos formas son equivalentes. aunque para los no acostumbrados a esta notación se ve un poco extraño al principio. cuando el código queda más claro en la notación array que con la notación puntero es preferible la primera notación. no ya sólo por eficiencia sino también por convención. para acceder a un determinado elemento. El puntero que se le pasa a free como argumento ha de ser un puntero que apunta al principio de una zona reservada anteriormente por malloc. El prototipo de la función free se encuentra en el fichero malloc. Los programadores profesionales de C suelen utilizar la notación puntero en vez de la notación array porque es bastante más rápido y más cómodo. mientras que en la notación puntero basta con una simple suma. La declaración para un array de 10 punteros a int es: int *x[10]. La memoria asignada por malloc se desasigna con la función free(). cualquier puntero lo podemos indexar con los []: Arrays unidimensionales: p[i] == *(p+i) Arrays bidimensionales: p[i][j] == *(p+(i*longitud_fila)+k) == *(*(p+i)+j) Arrays multidimensionales: se sigue cualquiera de los dos procedimientos ejemplarizados en los arrays bidimensionales. Para asignar la dirección de una variable entera llamada var al tercer elemento del array de punteros. El nombre de un array es un puntero al primer elemento del array. el compilador tiene que hacer un serie de cálculos para averiguar en qué posición está. unsigned 11. Hay otra función. A cualquier elemento de un array podemos acceder mediante la aritmética de punteros y viceversa.

devuelve un valor menor que 0. Una utilidad de los punteros a funciones la tenemos en las funciones qsort() y bsearch() cuyos prototipos están en el fichero stdlib. (const void *clave.7Punteros a funciones Una caracteristica algo confusa pero muy útil de C es el puntero a función. const void *base. (const void *) no es lo mismo que (void *). size_t num. En (const void *) el objeto apuntado es constante. no se puede modificar. un puntero a función puede utilizarse para llamar la función. (void *base. Si arg1 es mayor que arg2. La dirección de una función es el punto de entrada de la función.R. size_t *num. const void *)). El número de elementos en el array se especifica mendiante num. devuelve un valor mayor que 0. y el tamaño en bytes de cada elemento está descrito por tam. int (*compara) (const void *arg1.6Inicializaciones de punteros Un puntero que tiene el valor NULL es un puntero que no apunta a ningún sitio. const void *arg2) (const void *clave. es decir.h y son los siguientes: void *lfind (const void *clave. Size_t es un tipo definido en el fichero stdlib. Debe devolver los siguientes valores: Si arg1 es menor que arg2.h y suele ser unsigned int. void *lsearch anchura.8Función qsort() Prototipo: void qsort void *.h 11. La función qsort() ordena el array apuntado por base utilizando el método de ordenación de C. void *base. int (*func_de_comp) (const void *elem1. Ambas funciones realizan una búsqueda lineal.9Función bsearch() Prototipo: void *bsearch *num. en (void *) el objeto apuntado por el puntero sí se puede modificar. int (*compara) (const 11. La comparación debe ser: int nombre_func (void *arg. size_t 25 .10Funciones lfind() y lsearch() Estas dos funciones no pertenecen al ANSI C actual per sí estan incluidas en las versiones de Turbo C. const void *elem2)).A. El array ordenado en orden ascendente con la dirección más pequeña conteniendo el menor elemento. Sus prototipos están en el fichero stdlib. size_t *num. size_t tam. por lo tanto. Hoare (este método se ha explicado en el ejemplo 3 de la lección 5).11. Si arg1 es igual a arg2 devuelve 0. unsigned int 11. const void *base. unsigned int tam. La función compara se utiliza para comparar un elemento del array con la clave. void *arg2). 11. size_t anchura.

Los modificadores de tipo near. Pero los punteros a void no pueden ser referenciados (utilizando *) sin utilizar moldes. que sólo se pueden aplicar a punteros y funciones. Cuando se hace una declaración. Para indicar que una función no acepta ningún argumento. huge y modelos de memoria en Turbo C En MS-DOS se suele direccionar memoria en la forma segmento:offset donde cada segmento son 64K y offset es el desplazamiento dentro de cada segmento. y el segundo es un array de 10 punteros a carácter const void * const x (const void ***) función que acepta un puntero a puntero a puntero a constante y devuelve un puntero constante a constante función que no devuelve nada y acepta como argumento un void x (void (*) (void (*) (void))) puntero a función que no devuelve nada y acepta como argumento un puntero a función que no devuelve nada y no acepta ningún argumento función que acepta un int como argumento y devuelve un int (* (x (int))) (int) puntero a una función que acepta un int como argumento y devuelve un int 11. 11. están relacionados con el direccionamiento de memoria. el nombre (o “identificador”) que usamos se puede modificar añadiéndole uno o varios modificadores: Modificador Significado indica un puntero * indica una función () indica un array [] Ejemplos: array de arrays de ints int x[8][8] puntero a puntero a int int **x array de 10 punteros a int int *x[10] puntero a array de 10 int int (*x)[10] array de 3 punteros a array de 4 int int *x[3][4] puntero a array de 3x4 int int (*x)[3][4] funcion que devuelve un puntero a int int *x(void) puntero a función que devuelve un tipo int int (*x)(void) funcion que acepta un puntero a char como argumento y que char (*(*x(char*)))(void) devuelve un puntero a puntero a una función que devuelve un carácter puntero a función que devuelve un puntero a puntero a carácter y char ** (*x) (char ***. char *[10] acepta dos argumentos: el primero es un puntero a puntero a puntero a carácter.12Distintos tipos de declaraciones El C permite la creación de formas de datos muy elaboradas. El modificador near (cerca) fuerza que el valor de un puntero o una función estén en un sólo segmento mientras que far (lejos) y huge (enorme) hacen que un puntero pueda apuntar a cualquier dirección de la memoria y una función puede estar en cualquier lugar de la memória disponible.int (*func_de_comp) (const void *elem1. Para indicar que una función no devuelve nada. far y huge. 11. const void *elem2)). 2. far. Aplicados a punteros tiene otro uso: los punteros a void son punteros genéricos que pueden apuntar a cualquier objeto.13Modificadores de tipo near.11Tipo void y punteros Hasta esta lección hemos visto que el tipo void tiene dos usos: 1. 26 . puesto que el compilador no puede determinar el tamaño del objeto al que apunta el puntero.

27 . 11. cualquier segmento). 11.13.13.2Small Usa el modelo small para aplicaciones de tamaño medio 11.COM.11. un mismo segmento).4. El modelo de memoria elegido determina el método de direccionamiento de memoria por defecto.1Tiny Usa el modelo tiny cuando la cantidad de memoria a consumir sea muy importante y ha de ser la menor posible. genera código de funciones parar llamadas far y devuelve un valor far.4.4Opciones de modelo Las opciones de modelo especifican qué modelo de memoria se quiere usar.4.4. Su segmento es normalizado durante la aritmética de punteros así que las comparaciones de punteros son más precisas.3Huge (modificador de tipo) El modificador huge es similar al modificador far pero tiene dos caracteristicas adicionales: 1.3Medium El modelo medium es mejor para grandes programas que no guardan muchos datos en memoria 11. genera código de funciones para llamadas near y devuelve un valor near.13. El modelo por defecto es small.13. <tipo> near <definición-puntero> <tipo> near <definición-función> 11.5Large y Huge Usa los modelos large y huge para aplicaciones muy grandes solamente.2Far (modificador de tipo) Fuerza a los punteros a ser far (estar lejos. Los programas de modelo tiny pueden ser convertidos a formato .13.13.13. 11. Segmentos Punteros Modelo Código Datos Pila Código Datos 64K near near Tiny 64K 64K near near Small 1 MB 64K far near Medium 64K 1 MB near far Compact 1 MB 1 MB far far Large 1 MB 64K cada 64K pila far far Huge uno 11. 2.13.4.1Near (modificador de tipo) Fuerza a los punteros a ser near (estar cerca.4Compact Usa el modelo compact si tu código es pequeño pero necesitas direccionar una gran cantidad de datos. Los punteros huge pueden ser incrementados sin el temor de que sobrepase un segmento. 11.13.

Para declarar una variable de un tipo structura sin nombre se hace: struct { int dia. mes.1.4Punteros a estructuras 12. 28 . 12. } fecha_creación. int mes. anyo. De la misma forma se pueden declarar varias variables separadas por comas.1Estructuras 12. ( realmente se esta pasando el valor de ese elemento de la función) (no se utiliza en la práctica. struct fecha fecha_creación. -Una estructura completa. }.12. mes. por ser poco eficiente) Ejemplo: Paso de dirección de variable estructura. -La dirección de una estructura.1. 12.5Estructuras y funciones Con respecto a las estructuras.1Declaración de estructuras struct { int dia. 7. a una función le podemos pasar como argumento: -Un elemento de una estructura.Tipos compuestos de datos 12. 12. anyo}.1. struct fecha fecha_creación = { 22.1.). int anyo.2Inicialización de estructuras Una estructura se inicializa añadiendo a su definición la lista de inicializaciones de las componentes.2Utilización pfecha -> dia = 20. El operador -> se utiliza para acceder a un elemento de una estructura a través de un puntero 12. 90 }. pfecha = &fecha_creación 12.1. *pfecha.4. Si la estructura tiene nombre se puede hacer de la siguiente forma: struct fecha {int dia.1.1Declaración struct fecha fecha_creación.1.3Referencia a los elementos de la estructura Los elementos individuales de la estructura se referencia utilizando el operador punto (.4. Despues de la palabra clave struct va opcionalmente el nombre de la structura y se puede emplear en declaraciones posteriores como una abreviatura de la entrada.

Su declaración y utilización es exactamente igual que el de las estructuras con la excepción que utiliza la palabra clave union en vez de struct. param -> a).h> struct st { int a.b. void f ().3Uniones Las uniones son similares a las estructuras.#include <stdio.2Campo de bits 12. }. } /* los paréntesis vacíos indican que no decimos nada acerca de sus 12. f (&arg). arg. La diferencia que hay entre una variable estructura y una variable union es que esta última todos sus elementos ocupan la misma posición de memoria. Los nombres de los campos son opcionales. unsigned o signed. los campos se disponen de izquierda a derecha y en otras de derecha a izquierda. tipo2 nombre2 : longitud2.a = 10. 12. /* imprime 10 */ } void f (param) struct st *param. 12. A los campos de bits se accede de la misma forma que a los campos de cualquier estructura: Los campos de bits tienen algunas restricciones: no se puede tomar la dirección de una variable de campos de bits. Un campo de bits tiene que declararse como int.1Declaración La forma general de definición de un campo de bits es: struct nombre_estructura { tipo1 nombre1 : longitud1. }. 29 . parametros */ void main (void) { struct st arg.4Enumeraciones Una enumeración es un conjunto de constantes enteras con nombre que especifica todos los valores válidos que una variable de ese tipo puede tomar. Se puede mezclar elementos normales de estructura com elementos de campos de bits. Los campos de bits de longitud 1 deben declararse como unsigned debido a que un bit individual no puede tener signo. esto implica código menos portable. en algunas máquinas. { printf (“%d”.2. El tamaño del tipo union es el tamaño del elemento que necesita más memoria.

2. A cada fichero se le asigna un flujo al realizar la operación de apertura sobre él.1Flujos y ficheros Los flujos son sucesiones de caracteres a través de los cuales realizamos las operaciones de E/S. 13. 13. excepto el primero que toma el valor 0 si no es inicializado. sólo se da otro nombre.Entrada/Salida 13.1Flujos de texto Son una sucesión de caracteres originado en líneas que finalizan con un carácter de nueva-linea. tomando el primero el valor 0. enum colores color. rojo. Para el programador un fichero es un dispositivo externo capaz de una E/S. Dada esta declaración y definición la variable color sólo puede tomar tres valor posibles: azul. Para el C un fichero es un concepto lógico que puede ser aplicado a cualquier cosa desde ficheros de disco a terminales. amarillo }. los símbolos no inicializados toman el valor numérico siguiente al del símbolo anterior. 12. Como se ve. En estos flujos puede no haber una relación de uno a uno entre los caracteres que son escritos y los del dispositivo externo. Para el programador todos los flujos son iguales.3Programas C con flujos Al principio de la ejecución de un programa Turbo C se abren cinco flujos de tipo texto predefinidos: 30 . Todos los ficheros no son iguales pero todos los flujos sí. El uso de typedef hace más fácil leer el código y más facil de transportar a una nueva máquina. al igual que con las estructuras. Pero recuerda: NO se crea ningún tipo de datos nuevo. Ejemplo: enum colores { azul.2. Aquí. rojo o amarillo. el segundo el valor 1 y así sucesivamente. 13.La forma general de declaración es: enum nombre_tipo_enum { lista_de_enumeración } lista_variables.2Tipos de flujos 13. donde tipo es cualquier tipo de datos permitido y nombre es el nuevo nombre para ese tipo. Cada uno de los símbolos del conjunto de enumeración es un valor entero. 13.2Flujos binarios Son flujos de bytes que tienen una correspondencia uno a uno con los que están almacenados en el dispositivo externo. tanto el nombre de la enumeración nombre_tipo_enum como lista_variables son opcionales.5Tipos definidos por el usuario: typedef La forma general de la sentencia typedef es: typedef tipo_nombre.

2.6Ojo con las macros. Cerrar el fichero. 13. 4.h errno. Errores del sistema.La Biblioteca del C 15.h Propósito Asignación dinámica. Abrir el fichero. E/S de bajo nivel o E/S tipo UNIX. x = (( getch()) >= ‘0’ && (getch()) <= ‘9’). y = isdigit (*p++). se creó un segundo sistema de ficheros.h>. Crear un nombre interno de fichero. Define la macro assert() Funciones relacionadas con la ROM BIOS. Porque pueden suceder cosas como: #define isdigit (c) ((c) >= ‘0’ && (c) <= ‘9’).h dir. A este sistema se le llama E/S sin buffer. Directorio. Sistema operativo DOS.Conexión de Turbo C con ensamblador Antes de escribir instrucciones en ensamblador debemos incluir la siguiente directiva: #pragma inline La palabra clave asm tiene la siguiente sintaxis: asm codigo_de_operación nueva_línea Se pueden utilizar bloques ( { } ). Realizar las operaciones pertinentes. Esta estructura está definida en el fichero stdio.h dos. con alguna de las funciones que hay al efecto.h. Esto se hace en C declarando un puntero de fichero (o puntero a fichero). 13. Con las macros debe evitarse hacer operaciones como las siguientes: x = isdigit (getch() ).4Pasos para operar con un fichero 1.5Sistema de ficheros tipo UNIX Debido a que el lenguaje C se desarrolló incialmente bajo el sistema operativo UNIX. operandos punto_y_coma o 15. Un puntero de fichero es una variable puntero que apunta a una estructura llamada FILE. X X X 31 . Este sistema está obsoleto. Uno de caracteres.h ctype.1Funciones y macros Fichero de cabecera alloc. 3.h assert.h conio.stdin: stdout: stderr: stdaux: stdprn: dispositivo de entrada estándar dispositivo de salida estándar dispositivo de salida de error estándar dispositivo auxiliar estándar impresora estándar 13. E/S por consola. 14. TC? X X X Notas Cada una de las funciones representa un estas funciones se pueden implementar c fichero de cabecera <dos.h bios.

Esta cabecera define tres m uno de los argumentos de las funciones dominos para el cual está definido la var de dominio). Recordar qu realizar un salto dentre de una función.h implementación. Soporta las funciones de tiempo del sistema.h stddef.h setjmp. limits.h Define los límites dependientes de la implementación.h E/S estándar a bajo nivel. Gráficos. Define algunas constantes de uso común. Constantes simbólicas para compatibilidad con UNIX.h stdarg.h values. io.Fichero de cabecera Propósito Constantes simbólicas utilizadas por open(). Define los valores de señal. La macro size_t es el tipo tiempo de compilación sizeof.h Define valores en coma flotante dependiente de la float. Constantes simbólicas utilizadas por sopen().h share. Soporta funciones de cadena. mem. Funciones de proceso. X X Declaración de funciones que terminan e sistema operativo y que ejecutan otro pr Contiene la información necesaria para p saltos de una función a otra.h signal. Definición de tipos. X Contiene las declaraciones de dos funcio enviar y recibir señales (interrupciones) Contiene unos cuantos tipos estándares Uno de los tipos es ptrdiff_t que es un ti dos punteros. Hora actual. Lo mismo ocurre cuando s rutina devuelve HUGE_VAL y errno se produce un error de desbordamiento por ERANGE. Contiene una serie de macros que define Las funciones matemáticas toman argum tipo double. math.h Funciones de memoria. graphics.h stdlib. Las dos m corresponde con el valor modificable uti error generados por las funciones de bib stdio. Soporta listas de argumentos de longitud variable.h process. Información de ficheros.h Definiciones utilizadas por la biblioteca matemática. Otras declaraciones.h TC? X X X Notas Requiere coprocesador matemático o em Obsoleto. locale. X X X X 32 .h Soporta la E/S de ficheros.h string. Soporta saltos no locales.h sys\stat sys\timeb sys\types time. fcntl.h Soporta la funcion setlocale().

la cual puede se Si el bloque no puede ser reasignad Suma incr bytes al valor umbral..in_use es un flag que se p El parámetro tam está en bytes. tamaño. Devuelve el estado actual del Devuelve 0 si tiene éxito. int puerto). o NULL si no hay suficie Devuelve la cantidad total de espac de la memoria. void *buffer). El valor devuelto es menor de cero Si un nodo ha sido liberado y farhe farheapchecknode() puede devolve porque los bloques libres adyacente El valor devuelto es menor de cero La función farheapwalk() asume qu montón antes de usar farheapwalk( _HEAPEND será devuelto en la pr Estructura farheapinfo: farmalloc farrealloc free heapcheck heapcheckfree heapchecknode heapfillfree heapwalk void far *farmalloc (unsigned long nbytes). po hi. int heapfillfree (unsigned int valorrelleno). Chequea los bloques libres en el montón para un valor constante. Asigna espacio para nunids elemen asignado. Asigna memoria principal. La función heapwalk() recibe un pu la primera llamada a heapwalk(). int biosequip (void). y otros atributos El valor devuelto es menor de cero Como farheapchecknode. en otro c puede tomar cmd y el significado d BIOS. unsigned long tamunid). void *sbrk (int incr). int farheapfillfree (unsigned int valorrelleno). Como farheapwalk. br y da el valor a errno. Devuelve los indicadores de equipo 33 . Devuelve la cantidad de memoria no usada. tamaño. E/S de comunicaciones RS-232 biosdisk biosequip int biosdisk (int cmd. Devuelve la cantidad de memoria no usada en el montón far. size_t tam).H Cambia la asignación de espacio del segmento de datos Asigna memoria principal. Camina a través del montón far nodo a nodo. Servicios de disco de la BIOS. int heapchecknode (void *nodo). void farfree (void far *bloque). void free (void *bloque). Chequea los bloques libres en el montón far para un valor constante. Los valores para cmd son los siguie 0.H int bioscom (int cmd. Chequea y verifica el montón. Asigna memoria del montón far. Cambia la asignación de espacio del segmento de datos. Chequea y verifica un nodo simple en el montón far. Asigna espacio para nelems elemen Devuelve el puntero al nuevo bloqu farcalloc farcoreleft farfree farheapcheck farheapcheckfree farheapchecknode farheapfillfree farheapwalk unsigned long coreleft (void). Chequea y verifica un nodo simple en el montón. void far *farrealloc (void far *viejobloque. Devuelve un puntero al nuevo bloq nuevo bloque. Modelos tiny. La función farheapcheck() camina a punteros. int pista. large. Asigna memoria del montón far. Reasigna memoria principal. int heapcheck (void). Camina a través del montón nodo a nodo. Chequea y verifica el montón far. Si la operación tiene éxito. La función heapcheck() camina a tr punteros. Envía el carácter que está en b 2. void *calloc (size_t nelems. int cabeza. Rellena el bloque libre en el montón far con un valor constante. unsigned long farcoreleft (void).ptr la dirección del primer bloqu campo hi. int nsect. int heapwalk (struct heapinfo *hi). y otros atributos y mayor de cero si tiene éxito. int farheapwalk (struct farheapinfo *hi). Ajusta bloque asignado al montón far. void *realloc (void *bloque. El valor devuelto es menor de cero malloc realloc sbrk bioscom void *malloc (size_t tam). void far *farcalloc (unsigned long nunids. int farheapcheck (void)..Nombre brk calloc coreleft Sintaxis int brk (void *addr). Rellena el bloque libre en el montón con un valor constante. size_t tam). Pone los parametros de comun 1. Libera un bloque del montón far. Si Si falla. int farheapchecknode (void *nodo). Recibe un carácter de la línea devuelto). 3. Chequea equipo. y huge: Descripción Notas ALLOC. int farheapcheckfree (unsigned int valorrelleno). devuelve -1 y le da valor a BIOS. y medium: unsigned coreleft (void). Devuelve la dirección del bloque re diferente a la dirección original. y además. int sector. int heapcheckfree (unsigned int valorrelleno). small. int unidad. Modelos compact. De existe suficiente espacio para el nue Intenta achicar o expandir el bloque bloque reasignado. char byte. unsigned long nbytes). Pone el tope del segmente de datos addr. Libera bloques asignados con malloc() o calloc().

Inicializa el puerto de impreso 2.Nombre bioskey Sintaxis int bioskey (int cmd). int puerto). Devuelve el código de explora pulsación de la tecla si el buff 1. long nuevahora). a El valor devuelto es el tamaño de la Rutina del servicio de reloj de la BIOS. lee la hora de la BIOS reloj desde la medianoche. Cmd 0. Cmd: 0. 2. long biostime (int cmd. control. Notas biosmemory biosprint biostime int biosmemory (void). int biosprint (int cmd. Devuelve los indicadores de e izquierda y derecha. 1. Un segu 34 . int bytes. Devuelve el código de explora Devuelve 0 si el buffer está va bioskey() devuelve -1. Lee el estado actual de la imp Si cmd es 0. Devuelve el tamaño de la memoria. E/S de impresora usando directamente BIOS. Descripción Interface de teclado. Imprime el byte.

void *destino). Si una tecla está disponible. . int izqdest. void *fuente). void normvideo (void). es decir. int ar.]). Devuelve un carácter al teclado. Obtiene información de vídeo en modo texto. Devuelve ch. kbhit() Como highvideo(). el valor devuelto es EOF. Cambia modo de pantalla (en modo texto). Borra línea en ventana de texto. int puttext (int izq. Chequea para ver si se ha pulsado alguna tecla. int putch (int ch). El resultado es devuelto en r. Como getch(). para ver si hay alguna tecla disponible en el buffer de teclas. 35 . isxdigit(c) _toupper(c) Z]. Escribe un carácter en la ventana de texto sobre en la pantalla. void textbackground (int nuevocolor). int ungetch (int ch). void window (int izq. int der. int getch (void). int movetext (int izq. Selecciona nuevo color de fondo de los caracteres en modo texto. void highvideo (void). Selecciona nuevo color de texto de los caracteres en modo texto. el carácter visualizad Como movetext(). int kbhit (void). char *getpass (const char *prompt).H cgets clreol clrscr cprintf cputs cscanf delline getch getche getpass gettext gettextinfo gotoxy highvideo insline kbhit lowvideo movetext normvideo putch puttext _setcursortype textattr textbackground textcolor textmode ungetch wherex wherey window is* char *cgets (char *cad). int ab). Lee una cadena de la consola. void gettextinfo (struct text_info *r). Los car líneas completas). Borra ventana de texto. void clreol (void).. El tipo de cursor t_cur puede ser: void textattr (int newattr). Devuelve posición horizontal del cursor dentro de la ventana de texto corriente. Las coordenadas son relativas a la valor distinto de cero si la operació Como highvideo(). - Pone los atributos de texto para las funciones de ventana de texto. Lee un password. Macro isalnum(c) isalpha(c) isdigit(c) idcntrl(c) ordinario. int der. cad [0] debe contener la longitud m número de caracteres leídos realme [2]. int ar. Afecta a subsecuentes llamadas a f Las líneas por debajo de la posición se piertde. void _setcursortype (int t_cur). La de cero si tiene éxito. . void lowvideo (void).. Copia text de pantalla en modo texto a memoria. Selecciona caracteres de texto en intensidad normal. Escribe una cadena en la ventana de texto de la pantalla. Lee entrada formateada de consola. _tolower(c) z]. argumento. Copia texto en pantalla de un rectángula a otro (en modo texto). El valor devuelto es un puntero a u Las coordenadas son absolutas. isascii(c) isprint(c) isgraph(c) islower(c) isupper(c) ispunct(c) isspace(c) vertical. toascii(c) poniendo los bits menos significat. Devuelve el número de bytes escrit Devuelve el último carácter escrito Devuelve el número de campos pro fichero. int cprintf (const char *formato [.H Macros variadas.]).. int der. Devuelve posición vertical del cursor dentro de la ventana de texto corriente. int y). int ardest). void clrscr (void). int der. void insline (void). int cscanf (char *formato [. int wherey (void). void textmode (int nuevomodo). Escribe salida formateada en la ventana de texto de la pantalla. int ab. int ab. Lee carácter de consola si eco en pantalla. Define ventana activa en modo texto.CONIO. int ab. Selecciona caracteres de texto en alta intensidad. Borra hasta el final de la línea en ventana de texto. void delline (void). o alimentación de línea. int getche (void). Inserta línea en blanco en ventana de texto en la posición actual del cursor.. int cputs (const char *cad). Selecciona la apariencia del cursor. int ar. Devuelve el carácter leído. dirección. int gettext (int izq. Posiciona el cursor en ventana de texto. int wherex (void). int ar. Copia texto de memoria a la pantalla. No sirve para cambiar de modo grá La próxima llamada a getch() o cua Devuelve el carácter ch si tiene éxi Devuelve un entero en el rango de Devuelve un entero en el rango de La esquina superior izquierda de la CTYPE. void gotoxy (int x. Lee carácter de consola con eco en pantalla. void textcolor (int nuevocolor). Selecciona caracteres de texto en baja intensidad.

Devuelve el núm DOS. El path de especificación del ficher si tiene éxito. void enable (void). Obtiene información sobre la tabla de asignación de fichero para la unidad dada. y -1 e Obtiene la fecha y hora de un fichero. void delay (unsigned ms).H Busca directorio de disco. unsigned *pseg). int freemem (unsinged segx).. void *argument. char *nombre. int nsects. Convierte fecha y hora a formato de hora de UNIX. Macro que genera una interrupción software. void getfatd (struct fatinfo *dtable). Continúa búsqueda de findfirst().H Lee sectores absolutos de disco. int rmdir (const char *path). struct time *t). int getdisk (void). const char *dir.toupper tolower findfirst findnext fnmerge fnsplit getcurdir getcwd getdisk mkdir mktemp rmdir searchpath setdisk absread abswrite allocmem bdos bdosptr country ctrlbrk delay disable dosexterr dostounix __emit__ enable macro FP_OFF macro FP_SEG macro MK_FP freemem geninterrupt getcbrk getdate getdfree getdta getfat getfatd getftime getpsp gettime int toupper (int ch). void getdfree (unsigned char drive. int bdos (int dosfun. Obtiene el segmento de una dirección far. -1 en cas Reemplaza nomfich por un nombre debería ser una cadena terminada e Igual que mkdir(). const char *unidad. Construye un path de sus partes componentes. int getcurdir (int unidad. Tam es el número de párrafos a asi área asginada es almacenada en *p devuelve el tamaño del bloque disp error. int findnext (struct ffblk *ffblk).. Esta ca llamada. char *searchpath (const char *fichero). La unid Devuelve 0 si tiene éxito. Drive es 0=A. Asigna memoria. Quita un directorio. Descompone un nombre de path en sus partes componentes. void __emit__ (argument. -1 en cas El estado de todos los registros des Cuidado: las interrupciones pueden Devuelve si el chequeo de control-b En caso de error. . Hace un puntero far. void fnmerge (char *path. int longitud_buffer). Devuelve un puntero a una cadena otro caso. struct dfree *dtable). char *mktemp (char *nomfich). int atributo). void getfat (unsigned char drive. Devuelve ch en minúsculas. int tolower (int ch). Obtiene el estado de control-break. long dostounix (struct date *d. Hace un nombre de fichero único. DIR. char far *getdta (void). Obtiene el prefijo de segmento de programa. const char *ext). Busca el path del DOS para un determinado fichero. Pone manejador de control-break. Invoca una función del DOS. Devuelve un puntero a buffer. int getftime (int descriptor. Obtiene del espacio libre de disco. int mkdir (const char *path). Obtiene unidad actual. Devuelve 0 si tiene éxito. Inserta valores literales directamente dentro del código. int getcbrk (void). unsigned getpsp (void). struct ftime *pftime). char *getcwd (char *buffer. Devuelve información dependiente del pais. char *directorio). Obtiene la hora del sistema. Obtiene directorio de trabajo actual. Devuelve 0 en caso de éxito. en ca de error. forma corta. devuelve -1 si ocurre Igual que findfirst(). struct COUNTRY *pc). Crea un directorio. Inhabilita todas las interrupciones h Rellena los campos de *eblkp basa de_exterror de la extructura. Suspende la ejecución durante el intervalo (en ms). int fnsplit (const char *path. void geninterrupt (int num_interrupt). const char *nombre. void far *MK_FP (unsigned seg. Inhabilita interrupciones. a df_sclus en la e Devuelve un puntero a la dirección Obtiene la dirección de transferencia de disco. Escribe sectores absolutos de disco. Devuelve un entero compuesto de c Obtiene directorio actual para la unidad especificada. int bdosptr (int dosfun. devuelve NULL. int nsects. La unidad A es 0. int allocmem (unsigned tam. char *dir. void *buffer). Obtiene información de error extendido del DOS. Pone la unidad de disco actual. La función manejador devuelve 0 p continuará la ejecución. unsigned dosdx.). struct ffblk *ffblk. void gettime (struct time *phora). Devuelve el puntero pc. Devuelve ch en mayúsculas. long lsect. int abswrite (int drive. void getdate (struct date *pfecha). Devuelve la unidad actual. devuelve -1 y pone en errn Igual que absread(). int findfirst (const char *nombrepath. Devuelve la versión UNIX de la ho (GMT). Libera un bloque de memoria del DOS asignado previamente con allocmem(). int setdisk (int unidad). struct COUNTRY *country (int xcode. char *unidad. Obtiene el offset de una dirección far. int absread (int drive. Nsects es el número comienzo (0 es el primero). unsigned dosal). Llamada al sistema MS-DOS. void disable (void). int dosexterr (struct DOSERROR *eblkp). Habilita las interrupciones hardware. long lsect. unsigned ofs). void ctrlbrk (int (*manejador) void)). Buffer memoria más grande por llamada q de error. void *buffer). char *ext). Obtiene información sobre la tabla de asignación de fichero. unsigned dosal). Sólo puede ser llamada usando DO 36 . struct fatinfo *dtable). unsigned FP_SEG (void far *p). Obtiene fecha del sistema (DOS). El valor devuelto es el valor que po El valor devuelto es el valor de AX _doserrno con el código de error. Unidad es 0 para la unidad por defe hay algún error. unsigned FP_OFF (void far *p).

union REGS *inregs. int setblock (unsigned segx. void intr (int intno. Usa los bloques asignados con allo el tamaño del bloque posible más g Si valorcbrk es 1. int valor). Si el fichero nombre tiene el atribut llamar primero a chmod() para cam caso de error. Función de manejador de error hardware. unsigned int _status87 (void). int value). unsigned desplazamiento). Interfase de interrupción software 8086. Manenjador de error hardware. unsigned desplazamiento. Suspende la ejecución durante un intervalo (en segundos). unsigned int mascara). Si devuelve 0 todos los registros ha algún problema. void interrupt (*isr) ()). unsinged char inportb (int portid). void outport (int portid. impres Isr apunta a una función que será ll isr es una función C. char peekb (unsigned segmento. Activa el altavoz del PC a una frecuencia especificada. Analiza un nombre de fichero y construye un bloque de control de fichero (FCB). struct date *d. void setdta (char far *dta). Lee un byte de un puerto hardware. void harderr (int (*manejador) ()). Establece un manejador de error hardware. Almacena un valor entero en la posición de memoria especificada por segmento:desplazamiento. unsigned desplazamiento. int peek (unsigned segmento. struct time *t). el corr bit en la palabra de control. devuelve 0.getvect getverify harderr hardresume hardretn inp inportb int86 int86x intdosx intr keep nosound outp outport outportb parsfnm peek peekb poke pokeb randbrd randbwr segread setblock setcbrk setdate setdta settime setvect setverify sleep sound unixtodos unlink void interrupt (*getvect (int num_interrupcion)) (). y almacena los va Esta función vuelve al DOS con va porción de programa residente ocup liberada. Almacena un byte en la posición de memoria especificada por segmento:desplazamiento. struct SREGS *segregs). void setvect (int interruptno. Reinicializa el paquete matemático de coma flotante. Escribe una palabra en un puerto hardware.H _clear87 _fpreset _control87 _status87 unsigned int _clear87 (void). Lee bloque aleatorio. void poke (unsigned segmento. Interfase de interrupción DOS. void settime (struct time *phora). Obtiene el estado de coma flotante. char *parsfnm (cons char *cmline. void hardretn (int retn). chequea el ctrl-b llamadas de E/S de consola. int randbrd (struct fcb *fcb. Si masc Los bits del valor devuelto contiene GRAPHICS. Esta función carga los registros de interrupción intn. debería ser de Si valor=1. char valor). y almacena los v Esta función carga los registros de ejecuta la interrupción intno. int byte_value). Devuelve el valor de 4 bytes almac num_interrupción. struct REGPACK *preg). Escribe bloque aleatorio usando el bloque de control de fichero (FCB). int intdosx (union REGS *inregs. int rcnt). void setdate (struct date *pfecha). void hardresume (int axret). Después de analizar con éxito el no siguiente después del final del nom nombre del fichero. int rcnt). Pone la dirección de transferencia de disco. int outp (int portid. cada operación de escri asegurrar resultados correctos. Borra un fichero. El valor normal devuelto de la función Esta función carga los registros de interrupción intno. Pone el estado de verificación. unsigned char value). Devuelve el byte que hay en la localización de memoria especificada por segmento:desplazamiento. void unixtodos (long time. struct fcb *fcb. Pone el estado de control-break. 1=reintentar. Obtiene el estado de verificación. (0 s Frecuencia está en herzios. Esta función carga los registros de ejecuta la interrupción DOS (int 0x CPU en outregs y segregs. Interrupción de software 8086. int int86x (int intno. Devuelve 0 si el estado de verificac La función apuntada por manejador 0x24). El manejador de error establecido p aplicación llamada a hardretn(). int setcbrk (int valorcbrk). int opt). int int86 (int intno. void _fpreset (void). void sleep (unsigned segundos). int unlink (const char *nombre). Pone la hora del sistema.H 37 . Lee registros del segmento. union REGS *outregs. void setverify (int valor). Los bits del valor devuelto indican acerca de los estados. int randbwr (struct fcb *fcb. unsigned tamanyo). unsigned nuevotam). Pone la entrada de un vector de interrupción. int getverify (void). Cambia palabra de control de coma flotante. Interfase de interrupción software 8086. int inp (int portid). void nosound (void). y alma outregs y segregs. ver las const Esta función se suele usar junto con hijo podría alterar el estado de com Si un bit en la máscara es 1. unsigned desplazamiento). Macro que lee un byte de un puerto hardware. struct SREGS *segregs). Desactiva el altavoz del PC. Modifica el tamaño de un bloque asignado previamente. Macro que escribe un byte en un puerto hardware. Obtiene un vector de interrupción. Termina y queda residente. union REGS *inregs. union REGS *outregs). Si devuelve 0 todos los registros ha algún problema. void outportb (int portid. Escribe un byte en un puerto hardware. Convierte fecha y hora de formato UNIX a formato DOS. Devuelve la palabra que hay en la localización de memoria especificada por segmento:desplazamiento. union REGS *outregs. unsigned int _control87 (unsigned int nuevo. void pokeb (unsigned segmento. void keep (unsigned char estado. FLOAT. El manejador de error establecido p rutina del COS que provocó el erro Valores: 0=ingnorar. void sound (unsigned frequencia). Pone la fecha del DOS. Borra el estado de coma flotante. void segread (struct SREGS *segp).

int far getx (void). void far drawpoly (int número de puntos. Cierra el sistema gráfico. int radiox. patrón y grosor actual de la línea. void far cleardevice (void). Devuelve el modo gráfico actual.y) como el punto central y r Como drawpoly(). int radiox. void far circle (int x. Dibuja un polígono. Borra la pantalla gráfica. Rellena una región definida. Dibuja un círculo en (x. 38 . struct palettetype *far getdefaultpalette (void). Devuelve la coordenada y de la posición actual. Obtiene información acerca del viewport actual. int ang_comienzo. Manejador de usuario para asignar memoria gráfica. int far graphresult (void). Manejador de usuario para desasignar memoria gráfica. int ang_final. int der. Devuelve el código de error para la nivel de error a grOK. int far getcolor (void). Devuelve el código de error para la última operación gráfica que no tuvo éxito. Obtiene el color de un pixel especificado.y) con el radio dado. Obtiene información acerca del patrón y color de relleno actual. void far floodfill (int x. void far getviewsettings (struct viewporttype far *viewport). Devuelve el número de modo gràfico máximo para el controlador actual. int y). char *far grapherrormsg (int codigo_de_error). void far getarccoords (struct arccoordstype far *coords_arc). int ang_comienzo. los angulo Si flag_de_encima es 0 no se dibuj *puntos_por_poligono apunta a un de x e y par un punto del polígono. Obtiene la cuadratura para el modo gráfico actual. int ar. void far closegraph (void). Obtiene información acerca de la paleta actual. int ab. (x. int far *puntos_por_poligono). int ar. void far gettextsettings (struct textsettingstype far *texttypeinfo). Dibuja una barra. Devuelve un puntero a una cadena Esta función es llamada por las ruti Podemos controlar esta asignación _graphgetmem() y _graphfreemem( Igual que arriba. Dibuja un barra en 3-D. El valor es relativo al viewport. void far getfillsettings (struct fillsettingstype far *fillinfo). void far _graphfreemem (void far *ptr. int far *polypoints[]). void far graphdefaults (void). int far *cuady). unsigned tamanyo). Usa cuad para pixels altos. Obtiene el rango de los modos para un controlador gráfico dado. int far getbkcolor (void). Borra el viewport actual.arc bar bar3d circle cleardevice clearviewport closegraph detectgraph drawpoly ellipse fillellipse fillpoly floodfill getarccoords getaspectratio getbkcolor getcolor getdefaultpalette getdrivername getfillpatern getfillsettings getgraphmode getimage getlinesettings getmaxcolor getmaxmode getmaxx getmaxy getmodename getmoderange getpalette getpalettesize getpixel gettextsettings getviewsettings getx gety graphdefaults grapherrormsg _graphfreemem _graphgetmem graphresult void far arc (int x. Devuelve la coordenada y máxima de pantalla. int radio). Copia un patrón de relleno definido por el usuario en memoria. (x. int profundidad. int y. Devuelve la estructura de definición de paleta. void far fillpoly (int numpoints. void far getmoderange (int controlador_gráfico. El puntero devuelto apunta al nomb El valor es relativo al viewport. Dibuja un arco elíptico. int far getgraphmode (void). int far *mode_bajo. Como arc(). void far bar (int izq. Dibuja y rellena una ellipse Dibuja y rellena un polígono. unsigned far getpixel (int x.y) es un punto que reside dentro Cuadx debería ser 10000. int ab. Obtiene información acerca de las características del texto gráfico actual. Devuelve el valor del color máximo. Devuelve la coordenada x máxima de pantalla. int far getmaxx (void). Devuelve un puntero a la estructura mediante una llamada a initgraph(). void far getpalette (struct palettetype far *paleta). int far gety (void). int far getmaxcolor (void). El puntero far devuelto apunta a un Antes de llamar a getgraphmode() s El modo mínimo es 0. int ab). int der. int radioy). void far ellipse (int x. void far *bitmap). Devuelve el número de entradas de la paleta.y) es el punto central. int far *mode_alto). int far getmaxy (void). Obtiene las coordenadas de la última llamada a arc. void far * far _graphgetmem (unsigned tamanyo). Determina el controlador y el modo gráfico a usar chequeando el hardware. Devuelve el color de dibujar actual. Dibuja un arco. Devuelve un puntero a una cadena que contiene el nombre del modo gráfico especificado. int y. Devuelve un puntero a una cadena con el mensaje de error. int y. int y. char * far getmodename (int numero_de_modo). int radioy). int y. void far getimage (int izq. int radio). int ang_final. void far clearviewport (void). Devuelve un puntero al nombre del controlador gráfico actual. void far getlinesettings (struct linesettingstype far *infolinea). Obtiene el estilo. Devuelve la coordenada x de la posición actual. int der. int far getpalettesize (void). Salva una imagen de la región especificada en memoria. int far getmaxmode (void). char *far getdrivername (void). int far *graphmode). void far fillellipse (int x. int ar. void far getfillpatern (char far *pattern). void far detectgraph (int far *graphdriver. Usa (x. int flag_de_encima). Devuelve el color de fondo actual. int color_borde). Pone todos los valores gráficos a sus valores por defecto. void far getaspectratio (int far *cuadx. void far bar3d (int izq.

char far *cadena_de_text). int color). int der. int azul). void far setcolor (int color). 39 . Pone el estilo de línea. Cambia un color de la paleta. int clip). Las salidas gráficas siguientes a la especifiada. void far setpalette (int num_de_color. void far putimage (int izq. int vert). Dibuja y rellena un sector de círculo Escribe una imagen en la pantalla. Visualiza una cadena en el viewport (modo gráfico). Restaura modo de pantalla previa a entrar al modo gráfico. void far moveto (int x. Cambia el tamaño del buffer gráfico interno. int ab). int y). Pone las caracteristicas actuales del texto. int multy. El parámetro patrón identifica un p el usuario. int ar. void far outtextxy (int x. int radiox. int color). Dibuja una línea desde la posición actual hasta (x. int far installuserdriver (char far *nombre. int ang_final. int radioy). void far *bitmap. int ar. Pone el color actual para dibujar. void far setbkcolor (int color). Pone la página activa para la salida gráfica. int tamaño de caracter). Los valores para hor horiz 0 1 2 settextstyle setusercharsize setviewport void far settextstyle (int estilo. El parámetro path_para_controlado -bgi\drivers es el nombre de directo -el parámetro está encerrado entre c -el path para los ficheros de control Instala un nuevo controlador de dispositivo a la trabla de controladores de dispositivo BGI. Al mismo Dibuja una línea desde (x1. Usa cuad para pixels altos. int op).y). int ar. char far *path_para_controlador). unsigned patron_usuario. void far setgraphmode (int modo). void far setviewport (int izq. Visualiza una cadena en el lugar especificado (modo gráfico). n especifica como se combina la ima Usa el estilo. int ab. x e y definen el punto central. int y. void far setfillstyle (int patrón. int ab). estilo de línea y groso Bitmap apunta a un mapa de bits. int color). El parámetro patron_usuario apunta 8. int huge (*detect) (void)). Informa al sistema gráfico que el es enlazado. unsigned far setgraphbufsize (unsigned tambuf). Pone el viewport actual para salida gráfica. int verde. int rojo. void far pieslice (int x. Pone justificación de texto para modo gráfico. int y1. int der. int y. void far setactivepage (int pagina). int x2. Escribe un pixel en el punto especificado. Pone el color de fondo actual usando la paleta. int far installuserfont (char far *nombre). void far setallpalette (struct palettetype far *paleta). Registra controlador gráfico en el enlazado. int ar. void far setusercharsize (int multx. Cambia la posición actual a una distancia relativa. int cuady). llamar a la función setfil Esta función debe ser llamada antes del buffer interno. El parámetro nombre es el nombre es un puntero a una función de auto controlador. Pone el sistema en modo gráfico y borra la pantalla. int divx. int registerbgifont (void (*font) (void)). Pone el estilo y grosor para el dibu El parámetro numcolor es la entrad parametros rojo. Esta página puede no s Cuadx debería ser 10000. Devuelve el número de bytes requeridos para almacenar una imagen. int ang_comienzo. void far line (int x1. Selecciona un patrón de relleno definido por el usuairo. int registerbgidriver (void (*driver) (void)). int far *modo_gráfico. void far lineto (int x. anchura y patrón actual. void far sector (int x. int ang_final. Dibuja un rectangulo (modo gráfico). color y grosor de líne Informa al sistema gráfico que el co tiempo de enlazado. Factor de amplificación de los caracteres definidos por el usuario para los estilos de caracteres. Esta función de autode El parámetro nombre es el nombre carácter en modo gráfico. Define colores para la tarjeta gráfica IBM-8514. y1) has Usa el color. void far rectangle (int izq. void far outtext (char far *cadena_de_texto). int y. Si el tamaño requerido para la imag devuelve 0xFFFF. int der. void far setfillpatern (char far *patron_usuario. verde y azul defin de estos valores es usado. void far restorecrtmode (void).imagesize initgraph installuserdriver installuserfont line linerel lineto moverel moveto outtext outtextxy pieslice putimage putpixel rectangle registerbgidriver registerbgifont restorecrtmode sector setactivepage setallpalette setaspectratio setbkcolor setcolor setfillpattern setfillstyle setgraphbufsize setgraphmode setlinestyle setpalette setrgbpalette settextjustify unsigned far imagesize (int izq. int divy). void far settextjustify (int horiz. Cambia los colores de todas las paletas. void far linerel (int dx. Carga un fichero de estilo de caracteres (. void far moverel (int dx. Pone la cuadratura gráfica. int dy). void far initgraph (int far *controlador_gráfico. Registra estilo de texto en el enlazado. Inicializa el sistema gráfico.CHR) que no está dentro del sistema BGI. int grosor(. void far setrgbpalette (int numcolor. int ang_comienzo. Pone el patrón y color de relleno. Dibuja una línea a una distancia relativa de la posición actual. int dirección. Dibuja un línea entre dos puntos especificados. int dy). void far setlinestyle (int estilo_de_linea. void far putpixel (int x. int y2). int color). y sólo su Afecta a la salida de texto con outte verticalmente. Cambia la posición actual a (x. void far setaspectratio (int cuadx. int radio). int y). int y. Dibuja y rellena un sector elíptico.y). El se y patrón de relleno actual.

int memcmp (const void *s1. void *memchr (const void *s. Función logaritmo neperiano. Arcocoseno. double y). Función seno hiperbólico. La función modf() descompone x e fraccionaria y sitúa la parte entera e Devuelve el valor de un polinomio Devuelve base elevado a exponente menor o igual que 0. int grado. Devuelve el arcocoseno de x (valor cualquier otro caso se produce erro Devuelve el arcocoseno de x (valor rango de -1 a 1. Selecciona el lugar. Calcula e elevando a la x-éxima potencia. double tan (double x). x en radianes. size_t n). el sistema llama autom propia función matherr para contro matherr debe devolver un valor dis caso devuelve 0. double fmod (double x. 10 elevado a p. MATH. double y). int c. const void *s2.H Devuelve un puntero a la estructura de lugar actual. Redondea por abajo. Descompone en parte entera y parte fraccionaria. Tangente hiperbólica. int c. Devuelve la anchura de una cadena en pixels. Calcula x módulo y. Si dominio. double pow (double base. También pued desbordamiento produce un error d Devuelve 10 elevado a p. double cos (double x). Define un manejador de errores matemáticos. en cualquier otro c Devuelve el arcotangente de x (un v Devuelve el arcotangente de y/x (u para obtener el cuadrante del valor Devuelve el valor contenido en s co Devuelve el menor entero mayor o X en radianes. Compara dos string. Función logaritmo en base 10. double ceil (double x). Devuelve uno de los valores siguie Devuelve destino. double atan2 (double y. Esta función no puede ser llamada matemático. Coseno hiperbólico. double acos (double x). Algunos adaptadores gráficos tiene que está actualmente visualizada en activa. char *lugar). double coefs[]). long int labs (long int x). las líneas sobreesc operación XOR es ejecutada entre pantalla. size_t n). Pone el modo de escritura para el dibujo de líneas en modo gráfico. Función potencia. Calcula el valor absoluto de un long. double sqrt (double x). double sinh (double x). Busca el carácter c en los primeros n bytes del array s. Calcula la raíz cuadrada. Función seno. Útil para ser usada con funciones g Útil para ser usada con funciones g LOCALE. double cosh (double x). Arcotangente.H Macro que devuelve el valor absoluto de un entero. Copia un bloque de n bytes de fuente a destino. double log (double x). Pone el número de página gráfica visual. Convierte cadena a punto flotante. double exponente). int matherr (struct exception *e). x elevado a y). double fabs (double x).setvisualpage setwritemode textheigh textwidth localeconv setlocale abs acos asin atan atan2 atof cabs ceil cos cosh exp fabs floor fmod frexp hypot labs ldexp log log10 matherr void far setvisualpage (int pagina). const void *fuente. Devuelve el valor absoluto de z com Devuelve el mayor entero que no e La función frexp() descompone el n exponente entero tal que x = mantis se guarda en la variable apuntada p Devuelve la hipotenusa de un triáng modf poly pow pow10 sin sinh sqrt tan tanh Nota memccpy memchr memcmp memcpy double modf (double x. struct lconv *localeconv (void). int *exp). int far textheigh (char far *cadena_con_texto). Todas las funciones. MEM. int abs (int x). 40 . int exp). Redondea por arriba. Calcula la hipotenusa de un triángulo rectángulo. void far setwritemode (int modo). Arcotangente de y/x. x en radianes. excepto memm equivalente far que empieza por _f Esta función se para después de co en destino inmediatamente siguient Devuelve un puntero a la primera o s. double sin (double x). Localeconv pone la moneda especí C++ actualmente sólo soporta el lu La función setlocale() permite al us lugar donde se utiliza el programa. definida por setactivepage() Si el modo es 0. X en radianes. double poly (double x. Función potencia. para una longitud de n bytes exactamente. double floor (double x). const void *fuente. Copia un bloque de n bytes de fuente a destino. Descompone un double en mantisa y exponente. Valor absoluto de valor en punto flotante. Calcula el producto entre x y 2 elevado a exp. Valor absoluto de un número complejo. int far textwidth() (char far *cadena_con_texto). double ldexp (double x. double asin (double x). Tangente. double atan (double x). double exp (double x). double log10 (double x). void *memcpy (void *destino. Arcoseno. Coseno. char *setlocale (int categoria. double pow10 (int p). double tanh (double x). x en radianes. size_t n). double atof (const char *s). Devuelve la altura de una cadena en pixels. double cabs (struct complex z). s1 y s2. Genera un polinomia de los argumentos de esta función. double frexp (double x. Devuelve la raíz cuadrada de x. double *parte_entera). size_t n). double hypot (double x. double x).H void *memccpy (void *destino.

int execle (. b t Una vez alcanzado el final del fiche que se cambie la posición del punte función feof() es particularmente út fin de fichero es también un entero 41 ..B Devuelve 0 en caso de éxito.H clearerr fclose fcloseall fdopen void clearerr (FILE *flujo). void movmem (void *fuente. Macro que devuelve un valor distinto de cero si se ha detectado el fin de fichero en un flujo. Termina el programa. el resultado queda programa aborta). int fcloseall (void). La instrucción longjmp() da lugar a llamó por última vez a setjmp(). void _exit (int estado). Si el proceso no puede ser ejectuad system Comando puede ejecutar un coman COM o . SIGNAL. Las funciones exec. Ejecuta goto (salto) no local. char *argv[]). ignorando el caso.. Copia n veces el byte c en s. .. int valdev). Borra indicación de error.. char **env). Copy n bytes..H longjmp void longjmp (jmp_buf jmpb. FILE *fdopen (int descriptor.. Como memcmp(). o un fichero batch .. -puntero a entorno cambia: char *envp[] int system (const char *comando). Devuelve destino. Borra los indicadores de error y fin Devuelve 0 si tiene éxito. char *tipo). char **env). Siguen el mismo patrón que las exec con algunas diferencias: -cambia exec por spawn (logicamente) -param nuevo: al principio un int mode. Como las funciones exec.. char *argv[]. Copia un bloque de n bytes de fuente a destino.. Si no.. Compara los primeros n bytes de s1 y s2. unsigned des1. int execv (. size_t n). char *arg0. El valor de valdev se transforma en determinar de dónde viene longjmp devuelve este valor cuando se le lla Es importante comprender que long () vuelva.. setjmp int setjmp (jmp_buf jmpb). void abort (void). size_t n). Copy n bytes de seg1:des1 a seg2:d PROCESS. int fclose (FILE *flujo). permiten a nuestros programas ejecutar procesos hijos (otros programas) y devolver el control a nuestro programa cuando el proceso hijo finaliza. unsigned desp2. + lectura/escritura. int execvpe (. . char *arg0. Cierra un flujo.. y es este valor (que siem llamada de longjmp().. char valor). const void *s2. int exevp (. void (*func) (int sig [. void setmem (void *destino. char **env). Un programa puede enviar señales instalado por signal() para ese tipo y un valor distinto de 0 en caso con La función a la cual apunta func ser señales son enviadas cuando ocurre raise(). que se ha omitido antes por razones de espacio. STDIO. int c. char *arg0.). int execlp (. char **env). void *memset (void *s. las funciones exec no -1 y se asigna a errno el código de Antes de terminar. void *destino. int execve (. E2 SETJMP. char *arg0. int execlpe (. Envía una señal software.H raise signal int raise (int sig). Cierra todos los flujos abiertos.. permiten a nuestro programa ejecutar otros programas (procesos hijos).H Termina un proceso anormalmente. Asocia un flujo con un descritor de fichero. ENOMEM. void (* signal (int sig. Termina el programa. Devuelve un puntero al nuevo flujo argumento tipo son los mismos que combinación de los siguientes carac Tipo r w existente. NULL. Devuelve 0 despues de la llamada.. Devuelve s. Especifica las acciones a realizar asociadas a una señal. int long. void *memmove (void *destino... -1 en valores: ENOENT. . void movedata (unsigned seg1.. unsigned longitud). el valor terminación normal).EXE.. Mueve un bloque de longitud bytes de fuente a destino. size_t n). NULL). Almacena información de contexto para poder realizar saltos no locales. NOTA: Todas las versiones tienen como primer argumento char *path.. NULL. unsigned seg2. const void *fuente. Ejecuta comando DOS. void ext (int estado). char *argv[]). El prototipo de esta función tambié exit _exit funciones spawn. .int subcode]))) (int).memicmp memmove memset movedata movmem setmem abort exec. a o crea fichero para escritura. int memicmp (const void *s1. int execl (. Asigna un valor a un rango de memoria. devuelve ejemplo cuando se intenta cerrar un Devuelve el número total de flujos feof int feof (FILE *flujo). Si la ejecución tiene éxito. Las funciones spawn. Cuando se hace una llamada a exec haber suficiente memoria disponibl Las letras al final de cada función e Ltr p l v e alterar el entorno que tendrá el proc Si tiene éxito.. la salida buffere son llamadas. se ejecuta. char *argv[]. size_t n).

La función fputc() escribe un carác fichero y entonces incrementa el in declare de tipo in. Devuelve Devuelve el próximo entero en el fl fichero.ferror fflush fgetc in ferror (FILE *flujo). . FILE *flujo). Ya que se devuel alcanza el final del fichero. Vuelca un flujo. Esta función es idéntica a la funció estandar (flujo stdout) y la función primer argumento). Si se han leído menos carac error o es que se ha alcanzado el fi ha tenido lugar. actual = SEEK_CUR. Lee caracteres de stdin hasta que u es colocado en el string. En caso de éxito. dirección. int fileno (FILE *flujo). int origen). fsetpos ftell fwrite gets getw perror printf int fsetpos (FILE *flujo. fgetchar fgets int fgetchar (void). int n. Posiciona el puntero de fichero de un flujo.. Escribe un carácter en un flujo.. El estandar ANSI SEEK_SET. argumento. Mensajes de error del sistema. Si el flujo se abre p salto de línea se transforma automá El flujo es cerrado. FILE *flujo). int tam. int fprintf (FILE *flujo. int tam. se ha ejecutado correctamente. Obtiene la posición actual del puntero de fichero. Obtiene un carácter de un flujo.. Despues de leíd inmediatamente después del último parte de s. La función fputs() escribe el conten especificado. fgetpos fileno flushall fopen fprintf fputc int fgetpos (FILE *flujo. Obtiene una cadena de caracteres de stdin. int fputc (int c. utiliza f La posición almacenada en *pos pu puntero de fichero. Si fgets() tiene éxito dev produce un error. desplazamiento es el núm seleccionada. Si se alcanza el final del fic entero. Lee datos de un flujo. Abre un flujo. La nueva posición apuntada por po fgetpos(). int flushall (void). . const char *modo. En caso de fin de fichero o e La función fgets() lee hasta n-1 car caracteres se leen hasta que se reci límite específicado. Escribe una cadena de caracteres en un flujo. FILE *flujo). El carácter nulo de te éxito. Devuelve la posición actual del puntero de fichero. El origen es 0. Lee n elementos de tam bytes cada leídos. void perror (const char *s). int getw (FILE *flujo). argumento. long desplazamiento. Obtiene una cadena de caracters de un flujo. Obtiene un carácter de stdin. FILE *flujo). Devuelve EOF si se detect La función fgetc() devuelve el sigui indicador de posición del fichero. int fscanf (FILE *flujo.]). . freopen fscanf fseek FILE *freopen (const char *nombre_fichero. int fputs (const char *s.. Obtiene un entero de un flujo. char *gets (char *string). fpos_t *pos).. y un valor no nulo bajo cond ciertas transformaciones de caracte correspondencia uno a uno de la ca no se producen transformaciones d la cadena y el fichero. Devuelve un puntero al flujo abiert fputchar fputs int fputchar (int c).]). 42 . Un implementaciones y en el estándar ficheros de más de 64K bytes. Escribe con formateo a stdout. char *fgets (char *s. const fpos_t *pos). int fgetc (FILE *flujo). long ftell (FILE *flujo). Escribe un carácter en stdout. const char *modo_apertura). El fichero nomb tiene éxito o NULL si falló. devuelv Devuelve el valor actual del indicad éxito o -1L en caso de error. const char *formato[. int n. Macro que devuelve el descriptor de fichero asociado con un flujo. Los indicadores de error asociados llama a rewind() o a perror(). Siempre que ocurre u int printf (const char *formato [. a continuación variable errno. FILE *flujo). E entero. 1 o 2 final del fichero). Si el flujo está asociado a un ficher contenido del buffer de salida se es entonces el contenido del buffer de abierto. La función fseek() sitúa el indicado valores de desplazamiento y origen aleatorias.]). Por tanto cuando trabajes co final del fichero. Asocia un nuevo fichero con un flujo abierto. int fflush (FILE *flujo). getchar() devuelve el signo. Vuelca todos los flujos abiertos. Si fgetc() encuentr trabajas con ficheros binarios debes Si tiene éxito. Posiciona el puntero de fichero de un flujo. Escribe n elementos de tam bytes c realmente. Envía salida formateada a un flujo. FILE *fopen (const char *nombre_fichero. Una llamada a fputchar() es funcion fread int fread (void *buf. Usa las funciones feof() o f Imprime un mensaje de error en std escriben dos puntos. es convertido po tipo carácter son pasados a enteros tipo carácter como argumentos. FILE *flujo). Si significativo. Macro que devuelve un valor distinto de cero si ha ocurrido algún error en el flujo.. int fseek (FILE *flujo. const char *formato[. Devuelve 0 en c un tipo declarado con typedef en el Vacía los buffers para los flujos de salida. Esta función es idéntica a la funció estandar (flujo stdin) y la función fs primer parametro). int n. int fwrite (const void *buff. Escribe en un flujo. y por último se escr tipo de error. Ejecuta entrada formateada de un flujo.

Ejecuta entrada formateada de string. explorados. Asigna un buffer a un flujo. El nuevo_nombre n entrada. va_list lista_arg).puts putw remove rename rewind scanf setbuf setvbuf int puts (const char *s). FILE *flujo). int atoi (const char *s). como función de terminación. const char *formato.. sprintf() Esta función es igual que la función () se coge del flujo stdin y la entrad número de bytes escritos. int putw (int d. en cu fijar varias funciones de terminació En otras palabras. const char *formato. El array de cara operaciones de E/S. vf () y sprintf() respectivamente. Ejecuta entrada formateada de un flujo usando una lista de argumentos. char *buf). Si no es este el caso 43 .. fscanf() y ss lista de argumentos se sustituye por definido en stdarg. Devuelve el valor absoluto de un entero. en caso de fallo devu Esta función es igual que la función va al flujo stdou y la salida de la fu escritos. int vsscanf (const char *buffer.. Escribe un string en stdout (y añade un carácter de nueva línea). lo que escribe un carácter de salto de línea los caracteres hasta un carácter de fichero cuando se llena. int vfscanf (FILE *flujo. Están produce una operación de buffer co _IONBF. va_list lista_de_arg). va_lista lista_de_arg). La función atexit() fija la función ap alcanzada la terminación normal de se llama a la función especificada. int tam). La función rewind() mueve el indic También inicializa los indicadores d valor. Ejecuta entrada formateada de stdin. tmpfile FILE *tmpfile (void). entonces debe ser BU setbuf() no devuleve valor. _IONBF y _IOLBF. Función que borra un fichero. Asigna un buffer a un flujo. const char *formato. Si la escritura tiene éxito. la naturaleza del declarado del siguiente modo: type La función atof() convierte la caden contener un número válido con com La función atoi() convierte la caden número válido. int sscanf (const char *buffer. Convierte una cadena a un punto flotante. ..H abort abs atexit void abort (void). atof atoi double atof (const char *s). Envía salida formateada a un string.. Borra el fichero especificado por no borrado y -1 si se ha producido un La función rename() cambia el nom nuevo_nombre. convert del final de buffer. va_list lista_de_arg). dirección. Crea un nombre de fichero único. El f automáticamente cuando el fichero La función tmpnam() genera un úni nombre. Ejecuta entrada formateada de stdin usando una lista de argumentos Envía salida formateada a un string usando una lista de argumentos. no tiene lugar ninguna _IOFBF. Ejecuta entrada formateada de un string usando una lista de argumentos. La función devu devuelve un puntero a un flujo. entonces el valo La función tmpfile() abre un fichero La función utiliza automáticamente ficheros existentes. sprintf sscanf int sprintf (char *buffer. . int tipo. En caso de er Reposiciona el puntero a fichero al comienzo del flujo. STDLIB. int rename (const char *viejo_nombre. Envía salida formateada a un flujo usando una lista de argumentos. tmpnam char *tmpnam (char *nombre_fichero). Escribe un entero en un flujo. La función rename() devue error. void rewind (FILE *flujo). char *buf. int atexit (atexit_t func). Devuelve un carácter al flujo de entrada. int scanf (const char *formato [. Convierte una cadena en un entero. Termina anormalmente un programa.para desac programador. En caso de éxito se devu caso se devuelve un puntero nulo. puts() de Devuelve el entero d.. const char *formato [. En caso d campos leídos.h. int remove (const char *nombre_fichero). const char *formato. int vsprintf (char *buffer. int vscanf (const char *formato. int vprintf (const char *formato. int vfprintf(FILE *pf. void setbuf (FILE *flujo.]). Las f equivalentes a scanf(). El valor de caso de éxito. int setvbuf (FILE *flujo. Renombra un fichero. const char *nuevo_nombre). . El tamaño del buf es nulo. va_list lista_de_arg). que está defini temporal. En caso de error. La función setbuf() se utiliza para d se llama con buf a nulo. el flujo no utiliza buffer i flujo utiliza buffer por líneas. FILE *flujo). Abre un fichero temporal en modo binario. ungetc vfprintf vfscanf vprintf vscanf vsprinf vsscanf int ungetc (int c. int abs (int x).]). La próxima llamada a getc (u otras función ungetc() devuelve el caráct Devuelve el número de bytes escrit Devuelve el número de campos leíd Devuelve el número de bytes escrit Devuelve el número de campos leíd Devuelve EOF en caso de que se d Devuelve el número de bytes escrit Devuelve el número de campos leíd Devuelve EOF en caso de que se d NOTA: Las funciones vprintf(). La función setvbuf() permite al pro flujo especificado. Registra una función de terminación. argumento. va_list lista_de_arg).]). const char *formato [. Envía salida formateada a stdout usando una lista de argumentos. El objetivo de tmpnam() e cualquier otro que exista en el direc igual a TMP_MAX.

void exit (int estado). void *lsearch (const void *clave. void free (void *bloque). size_t tam). void *base. (_lrotr). void _exit (int estado). (unsigned long val. char *ltoa (long valor. El parámetro tam está en bytes. int radix). En caso de éxito. Generador de números aleatorios. int (*func_de_com) (const void *elem1. Convierte número en coma flotante a cadena. size_t anchura. puede hacer con sprintf(). u puntero al argumento cadena.cvt (double valor. la cual puede ser difere reasignado o tam==0. void *calloc (size_t nelems.. Obtiene un string del entorno. size_t *num. Macro que devuelve un entero. int (*compara) (void *arg1. int ndec. Antes de terminar. const void *arg2)). max (a. La base d normalmente en el rango de 2 a 16. Macros que generan código en línea para encontrar el valor máximo y mínimo de dos enteros. Devuelve la dirección de la primera clave buscada no se encuentra. Para ecvt(). unsigned int tam. Las dos funciones devuelve el valo Para una representación decimal. devuelve el conciente y el resto. Inicializa el generador de número a time(). en un array de elementos sec El array tiene num elementos. Calcula el valor absoluto de un long. int (*func_de_comp) (const void *elem1. La función itoa() convierte el entero cadena apuntada por cad. size_t tam). void *malloc (size_t tam). Rota un valor long a la izquierda (_lrotl) o a la derecha int cont). Debe dev si arg1>arg2. void *arg2)).. Macro que inicializa el generador de números aleatorios. long int denom). int denom). Divide dos longs. Búsqueda binaria. Asigna memoria principal. putenv() devuelve rand random randomize realloc _rotl _rotr int rand (void). int ndig. La función atol() convierte la caden un número entero de tipo long válid La función bsearch() realiza una bú devuelve un puntero al primer elem número de elementos en el array es elemento está descrito por tam. La función ldiv() divide dos longs y lfind lsearch _lrotl _lrotr ltoa malloc max min putenv qsort void *lfind (const void *clave. int *sign). int (*compara) (const void *arg1. const Ejecuta busqueda lineal. char *buf). unsigned _rot. char *cad. El número de elementos en cada elemento está descrito por tam array con la clave. unsigned int *num. realloc() dev Estas dos funciones devuelven el v 44 . ldiv_t ldiv (long int numer. void *base. Libera bloques asignados con malloc() o calloc(). int radix). (unsigned val. char *getenv (const char *nombre). Divide dos enteros. La elemento del array con la clave. const void *)). void randomize (void). int cont). Convierte un número en coma flotante a string. lsea La rutina *func_de_comp debe dev caso contrario. De existe suficiente espacio para el nue int putenv (const char *nombre). const void *elem2)). así que debemos incluir time El prototipo de esta función tambié achicar o expandir el bloque asigna reasignado. long int labs (long int x). size_t tam.. >0. La función qsort() ordena el array a Hoare. la salida buffere son llamadas. La función getenv() devuelve un pu apuntada por nombre en la tabla de cadena devuelta no debe ser cambi incluir cosas como nombres de cam exacta de estos datos viene definid un argumento que no se correspond nulo. La (void *arg1. Añade una cadena al entorno actual. Rota un valor unsigned int a la izquierda (_rotl) o a la derecha (_rotr).b) min (a. void *bsearch (const void *clave. int (*compara) (const void *. div_t div (int numer. Termina el programa. size_t *num. void *arg2). Convierte un entero a una cadena. ndig es el número de d a almacenar después del punto deci sobreescrita en la próxima llamada. unsigned int tam. Asigna espacio para nelems elemen Devuelve un puntero al nuevo bloq Devuelve el cociente y el resto com ecvt y fcvt exit _exit free gvct getenv char *. char *gcvt (double valor. size_t anchura. El array debe esta conteniendo el elemento más peque nulo. Devuelve la dirección del string apu itoa labs ldiv char *itoa (int valor. const void *base. Convierte un string a un long. Reasigna memoria principal. Termina programa. const void *elem2)). calloc div Asigna memoria principal.atol bsearch long atol (const char *s). int random (int num). Estas funciones utilizan una rutina d clave. int *dec. unsigned long _lort. cada memoria apuntada por base. La comparación devolver los siguientes valores: si a ordenado en orden ascendente con Devuelve números aleatorios entre Devuelve un entero entre 0 y (num- void *realloc (void *bloque.b) Convierte un long a una cadena. char *cadena. Ordena usando el algoritmo quicksort. size_t num. void qsort (void *base.

char *destino. size_t n). strtol long strtol (const char *inic. N STRING. size_t longmax). Devuelve la longitud del substring i caracteres que no están contenidos primer carácter en el string apuntad Devuelve un puntero a la copia dup para la asignación de la copia. y menos. Copia como máximo longmax caracter de fuente a destino. const char *s2). Ejecuta comparac Devuelve el número de caracteres q Devuelve un puntero a s. const char *s2). La función srand() utiliza semilla p que La función strtod() convierte la rep apuntada por inic a un valor double siguiente forma. Ejecuta comparaci 45 . =0 si s1=s2 Esta rutina está implementada com igual que stricmp(). excepto que s Devuelve un puntero a la primera o devuelve NULL. char *s2). Si son copiados longmax caracteres destino no es un string terminado e Devuelve s1-s2. Devuelve un puntero al stri Devuelve: s1-s2. La función strcoll() compara el strin valores puestos por setlocale(). Devuelve: s1-s2. Devuelve destino. int stricmp (const char *s1. size_t longmax). const char *s2. char *cadena. Devuelve destino. strtol() devuelv LONG_MIN en caso de desbordam Como strtol(). Añade fuente a destino. Devuelve: <0 si s1<s2. (_fstrcmp: todos los punteros far) int strcmpi (const char *s1. Es igual que strcpy(). Cualquier carácter que n proceso. ignorando el caso. Ejecuta comparac La función strncmpi() ejecuta una c de n bytes. char *strcpy (char *destino. Compara como mucho longmax caracteres de un string con otro. Compara dos strings. empezando con el prim siguientes hasta encontrar caracters caracteres. Intercambia bytes. Añade como máximo longmax caracteres de fuente a destino. (_fstrcat: todos los punteros far) char *strchr (const char *s. const char *s2). size_t strcspn (const char *s1. int c). Construye un mensaje de error hecho a medida. (_fstrlwr: todos los punteros far) char *strncat (char *destino. Obtiene una copia dublicada de s. const char *s2). (_fstrnicmp: todos los punteros far) Convierte una cadena a un unsigned long con la base fijada. const char *fuente.H Copia un string en otro. Convierte s a caracteres en minúsculas. Inicializa el generador de números aleatorios. char **final. Devuelve un puntero al string que contiene el mensaje de error. const char *fuente). (_fstrlen: todos los punteros far) char *strlwr (char *s). char *ultoa (unsigned long valor.srand strtod void srand (unsigned semilla). size_t longmax). char *strcat (char *destino. const char *s2. Copia nbytes bytes de fuente a dest transferencia. Copia el string fuente al string destino. size_t longmax). Compara un string con otro. char *stpcpy (char *destino. int radix). int nbytes). (_fstrchr: todos los punteros far) int strcpy (const char *s1. const char *fuente). El p strdup() cuando ya no sea necesario El mensaje de error está constituido reciente generado por el sistema. Explora un string. Compara un trozo de un string con un trozo de otro. Devuelve un puntero a la cadena. se elimin A continuación cada carácter que n que el proceso se detenga. y caracteres que no sean E o cadena original. se deja apunta error de conversión. (_fstricmp: todos los punteros far) size_t strlen (const char *s). o copia s a una nueva localización. strtoul swab system ultoa stpcpy strcat _fstrcat strchr _fstrchr strcmp _fstrcmp strcmpi strcoll strcpy strcspn _fstrcspn strdup _fstrdup _strderr strerror strcimp _fstricmp strlen _fstrlen strlwr _fstrlwr strncat _fstrncat strncmp _fstrncmp strncmpi strncpy _fstrncpy strnicmp _fstrnicmp unsigned long strtoul (const char *inic. char **fin). Finalmente. Esto inc punto. La función strtol() trabaja de la de la cadena apuntada por inic.h. Convierte cadena a long usando la base fijada. char *strdup (const char *s). sin sensibilidad al caso. Calcula la longitud de un string. (_fstrncat: todos los punteros far) int strncmp (const char *s1. int system (const char *comando). Encuentra c en s. const char *s2. (_fstrncmp: todos los punteros far) int strncmpi (const char *s1. Compara como máximo n caracteres de un string con otro. Convierte un unsigned long a una cadena. char **final. char *strerror (int numerr). A c el número. Compara un string con otro ignorando el caso. Nbytes deberia ser un Ver dos. Devuelve destino. int radix). (_fstrncpy: todos los punteros far) int strnicmp (const char *s1. int strcoll (char *s1. Primero. Ejecuta un comando DOS. char *strncpy (char *destino. double strtod (const char *inic. char *_strderr (const char *s). int radix). void swab (char *fuente. Convierte cadena a double. Si se produce un e overflow o HUGN_VAL para unde La función strtol() convierte la repr en la cadena apuntada por inic) en número está determinada por radix gobiernan la especificación de cons 36. const char *fuente). const char *fuente. Macro que compara strings.

Encuentra la última ocurrencia de c en s. se devuelve un pu Devuelve un puntero a la última oc Devuelve un puntero al string inver Termina cuando se encuentra el pri Devuelve la longitud del substring i aquellos caracteres contenidos en e devuelve el índice del primer carác ningún caracter del string apuntado Devuelve un puntero a la primera o por s2 (excepto el carácter nulo de encuentra. struct stat *statbuf). const char *s2). 46 . (_fstrnset: todos los punteros far) Copia el carácter ch en las primeras n posiciónes de s. Explora s1 para encontrar el primer token no contenido en s2. int stat (char *path. size_t n). o -1 en c Devuelve 0 si tiene éxito. (_fstrspn: todos los punteros far) char *strstr (const char *s1. s separados por los caracteres separa strtok() devuelve NULL. Si se encu token. *s2). Encuentra la primera ocurrencia de un substring en un string.H Convierte fecha y hora a ASCII. Transforma un trozo de un string. Copia el carácter ch a todas las posiciones de s. Se para cuando los n caracteres son char *strpbrk (const char *s1. Obtiene información del fichero abierto. Calcula la diferencia entre dos horas. La estructura utilizada por forma estática y se reescribe cada v de la estructura. (_fstrstr: todos los punteros far) char *strtok (cahr *s1. char *s2. Convierte fecha y hora a hora de Greenwich. Para transformar devuelve el valor -1 si el tiempo no Esta función es equivalente a: ascti Devuelve la diferencia. const char *s2). Devuelve el número de pulsos de reloj desde el comienzo del programa. Es equivalente a strncpy(). SYS\TIMEB. Información acerca de la hora actual rellenada por la función ftime(). strupr _fstrupr strxfrm ftime timeb char *strupr (char *s). Obtiene información acerca del fichero abierto. void ftime (struct timeb *buf). const char Explora un string. Convierte fecha y hora a una cadena. Devuelve un puntero al primer cará carácter en el string apuntado por s correspondencia. double difftime (time-t hora2. (_fstrrev: todos los punteros far) char *strset (char *s. struct stat *statbuf). int c). char *asctime (const struct tm *punt). La estructura utili estática y se sobreescribe cada vez La función localtime() devuelve un hora se trepresenta en la hora local a time(). Explora un string para encontrar un segmento que es un subconjunto de un conjunto de caracteres. int ch. size_t n). es necesario copia La función mktime() devuelve la ho encuentra en la estructura apuntada el sistema. (_fstrset: todos los punteros far) size_t strspn (const char *s1. La función gmtime() devuelve un p representada en hora de Greenwich llamada a time(). y strtok() devuelve un punte como primer argumento. (_fstrupr: todos los punteros far) size_t strxfrm (char *s1. Devuelve 0 si tiene éxito. S2 define caracteres separadores. en segundo struct tm *localtime (const time *hora). La función asctime() devuelve un p en la estructura apuntada por punt d dia_del_mes horas:minutos:segund obtiene normalmente de localtime() cadena de salida con formato se sit cada vez que se llama a la función. Estructura Convierte todos los caracteres de s a mayúsculas. Devuelve el tiempo de procesador en pulsos de reloj. clock ctime difftime gmtime localtime clock_t clock (void). mktime time_t mktime (struct tm *t). time_t hora1). o -1 en c TIME. por Devuelve un puntero a s. copiarlo en otro lugar. (_fstrpbrk: todos los punteros far) char *strrchr (const char *s. Los elementos tm_wday necesitan ser definidos en el mome información como una hora de cale Devuelve 0. char *ctime (const time_t *time).H fstat stat asctime int fstat (int descriptor. int ch). (_fstrrchr: todos los punteros far) char *strrev (char *s). struct tm *gmtime (const time_t *hora). (_fstrtok: todos los punteros far) Invierte todos los caracteres de s(excepto el carácter terminador nulo). struct timeb { 1-70 hora Greenwich */ hora Greenwich */ }. Convierte hora a formato de calendario. const char *s2).strnset _fstrnset strpbrk _fstrpbrk strrchr _fstrrchr strrev _fstrrev strset _fstrset strspn _fstrspn strstr _fstrstr strtok _fstrtok char *strnset (int *s. SYS\STAT.H Almacena la hora actual en la estructura timeb. Pone fecha y hora del sistema. usa el stri Notese que la cadena inicial es. Convierte fecha y hora a una estructura. stime int stime (time_t *pt).

Para compatibilidad con hora de UNIX. time tzset time_t time (time_t *hora). Si se utiliza calendario. La función time() pued variable de tipo time_t. tzset() espera encontrar una cadena TZ=.strftime size_t strftime (char *cad. Formatea hora para salida. La información se sitúa de cadena apuntada por fmt y en la for caracteres en cad. 47 .. const char *fmt.. La función strftim reconoce un conjunto de órdenes d sitúa su salida con formato en una c forma exacta en que se representan otro carácter que se encuentre en la fecha presentadas están en hora loc Observa que muchas órdenes distin La función time() devuelve la hora devuelve -1. Obtiene la hora actual. void tzset (void). const struct tm *tm). size_t maxtam. La función strftime() sitúa la hora y por cad. timezone y tzname. da valores a las variables globales daylight.

2Constantes. unsigned char currmode. unsigned char curx. tipos de datos y variables globales 15. LASTMODE BW40 C40 MONO BW80 C80 C4350 _wscroll Variable global. } text_modes Tipo enumerado. unsigned char winright. unsigned char screenheight. winbottom.2.15. cury. Constante Esta constante se le suma a color de fondo para visualizar caracteres parpadeantes en modo texto. struct text_info { unsigned char winleft.H COLORS Tipo enumerado Colores/atributos del video CGA estándar BLACK DARKGRAY BLUE LIGHTBLUE GREEN LIGHTGREEN CYAN LIGHTCYAN RED LIGHTRED MAGENTA LIGHTMAGENTA BROWN YELLOW LIGHTGRAY WHITE BLINK la ROM BIOS (directvideo = 0). directvideo Variable global Controla la salida de vídeo. extern int _wscroll. Modos de vídeo estándar. Es un flag de E/S de consola. unsigned char screenwidth. int directvideo. unsigned char attribute. TEXT_INFO Estructura Información de ventana de texto corriente. Valor por defect: 1 (scroll permitido). Podemos usarla para dibujar entre los ojos de una ventana sin provacar un scroll de la pantalla. Habilita o deshabilita el scroll en funciones de E/S de consola. Valor por defecto: 1. wintop. normattr. La variable global directvideo controla si la salida en consola de nuestro programa va directamenta a la RAM de vídeo (directvideo = 1) o va vía llamadas a .1CONIO.

_argv Variable global Array de punteros a los argumentos de la línea de comandos. FNSPLIT #define Definiciones de bits devueltos por fnsplit para identificar qué partes de un nombre de fichero fueron encontrados durante la descomposición. 15.2. unsigned ff_ftime. dl. }.DRIVE 15. WILDCARDS caracteres comodín. FILENAME incluye un nombre de fichero. struct WORDREGS . DIRECTORY un subdirectorio.H FFBLK Estructura Estructura de bloque de control de fichero del DOS.3DOS. long ff_fsize.2DIR.H int _8087 Variable global Valor matemático 0 detectado) 1 2 3 Coprocesador (no 8087 80287 80387 _argc Variable global Contiene el número de argumentos de la línea de comandos. extern char *_argv[] BYTEREGS WORDREGS Estructuras struct BYTEREGS { unsigned char al. EXTENSIÓN extensión. struct ffblk { char ff_reserved[21]. ah. ch. bh. char ff_attrib. bl. unsigned ff_fdate. char ff_name[13]. }. extern int _argc. El path contiene El path incluye El path El path incluye El path incluye una unidad.2. dh. unsigned char cl.

DEVHDR Estructura Estructura de cabecera para los controladores de dispositivos de MS-DOS. COUNTRY Estructura La estructura COUNTRY especifica como se van a formatear ciertos datos dependientes del país. }. unsigned int si. /* clusters totales */ unsigned df_bsec. unsigned short dh_inter. /* formato de fecha */ char co_curr [5]. char co_dasep[2]. getdate() y unixtodos(). bx. setdate(). /* bytes por sector */ unsigned df_sclus. /* dígitos significativos en moneda */ char co_time. /* separador de fecha */ char co_tmsep[2]. cx. char dh_name[8]. /* separador de millar */ char co_desep[2]. /* clusters disponibles */ unsigned df_total. /* sectores por cluster */ }. /* separador decimal */ char co_dtsep[2]. }. struct COUNTRY { int co_date. /* estilo de moneda */ char co_digits. DFREE Estructura Estructura de la información devuelta por la función getdfree(). }. struct devhdr { long dh_next. struct DATE { int da_year. char co_fill DATE Estructura Estructura de la fecha usada por las funciones dostounix(). cflag. . dx. long co_case.{ unsigned int ax. struct DFREE { unsigned df_avail. /* símbolo de moneda */ char co_thsep[2]. unsigned short dh_strat. }. short dh_attr. flags. char da_day. /* separador de datos */ [10]. di. /* separador de tiempo */ char co_currstyle. char da_mon.

/* bytes por sector */ }. . char fcb_currec. long short fcb_date. Los mnemotécnicos para los códigos de error de DOS actual que pueden ser asignados a _doserrno son: Mnemotécnico Código de error del DOS Entorno malo E2BIG Acceso denegado EACCES Acceso malo EACCES Es directorio corriento EACCES Manejador malo EBADF Reservado EFAULT Datos malos EINVAL Función mala EINVAL Demasiados ficheros abiertos EMFILE No es un fichero ni directorio ENOENT Formato malo ENOEXEC MCB destruido ENOMEM Fuera de memoria ENOMEM Bloque malo ENOMEM Unidad mala EXDEV No es el mismo dispositivo EXDEV dosSearchInfo Tipo typedef struct { char drive. extern char **environ FATINFO Estructura La estructura de información rellenada por las funciones getfat() y getfatd(). environ Variable global Array de cadenas usado para acceder y alterar el entorno del proceso. unsigned _heaplen El valor al principio de la ejecución del programa determina el tamaño del montón near que será asignado. fcb_filsize. short fcb_recsize. date. long } dosSearchInfo._doserrno Variable global Variable que contiene el código de error de DOS actual. size. a _doserrno se le asigna el código de error DOS actual. time. fcb_curblk. FCB Estructura La estructura de los bloques de control de ficheros de MS-DOS. El valor de 0. FA_xxxx #defines Atributos de fichero de MS-DOS FA_RDONLY FA_HIDDEN FA_SYSTEM FA_LABEL FA_DIREC FA_ARCH _heaplen Variable global Tamaño inicial del montón en bytes. int _doserrno. char fcb_ext[3]. attrib. }. hace un montón de tamaño máximo. fcb_resv[10]. namez struct fcb { char fcb_drive. /* sectores por cluster */ char fi_fatid. char reserved [7]. struct fatinfo { char fi_sclus. char short short long char [13]. fcb_name[8]. fcb_random. por defecto. Cuando en una llamada al sistema MS-DOS ocurre un error. char pattern [13]. /* número de clusters */ int fi_bysec. /* el byte identificador de la FAT */ int fi_nclus.

unsigned char _osmajor /* número de versión mayor */ unsigned char _osminor /* número de versión menor */ unsigned int _version /* número de versión completa */ _psp Variable global Dirección del segmento del PSP (prefijo de segmento de programa) del programa. _stklen es usado antes de que se llame a la función main(). unsigned int ss. NFDS #define Número máximo de decriptores de fichero. _osmajor _osminor _version Variables globales La versión de MS-DOS bajo la cual está corriendo el programa actualmente. union REGS { struct WORDREGS x. extern unsigned int _psp. r_di. unsigned int cs. struct BYTEREGS h. int86x() y segread(). r_cx. r_es. debes declarar _stklen en tu fichero fuento como una variable global. }. r_si. unsigned r_ds. struct { unsigned r_ax. SREGS Estructura La estructura de los registros de segmentos pasadas y rellenadas en las funciones intdosx(). extern unsigned _stklen. intdosx(). REGS Unión Es usada para pasar y recibir información de las funciones intdos(). Especifica el tamaño de la pila. . unsigned r_bp. _stklen Variable global Variable con longitud de la pila. Para poner un tamaño de pila diferente. int86() y int86x(). REGPACK Estructura La estructura de los valores pasados y devuetos en la función intr()._heaplen no es usado en los modelos de datos grandes. }. r_flags. }. struct SREGS { unsigned int es. r_dx. unsigned int ds. r_bx. El tamaño de la pila por defecto es 4K.

char xfcb_resv[5]. cflag. /* posición final 15. unsigned char ti_hund.5GRAPHICS. LINE_FILL Relleno con --LTSLASH_FILL Relleno con /// SLASH_FILL Relleno con líneas gruesas ///. unsigned char ti_sec. struct xfcb { char xfcb_flag. dx. ah. gettime().4FLOAT. struct { int x.y. EMPTY_FILL Usa color de fondo. /* punto central */ int xstart.TIME Estructura Estructura de la hora usada por las funciones dostounix(). struct WORDREGS { unsigned char ax. }. */ }. }. ystart. dh. 15. dl. yend. EGA_BLACK EGA_DARKGRAY EGA_BLUE EGA_LIGHTBLUE EGA_GREEN EGA_LIGHTGREEN EGA_CYAN EGA_LIGHTCYAN EGA_RED EGA_LIGHTRED EGA_MAGENTA EGA_LIGHTMAGENTA EGA_BROWN EGA_YELLOW EGA_LIGHTGRAY EGA_WHITE fill_patterns Tipo enumerado Patrones de relleno para las funciones getfillsettings () y setfillsettings(). di. bx. unsigned char ti_hour. struct BYTEREGS { unsigned char al. }.2. struct fcb xfcb_fcb. flags. cx. /* posición inicial */ EGA_XXXX #defines Colores para las funciones setpalette() y setallpalette(). }. settime() y unixtodos(). BYTEREGS WORDREGS Estructuras Estructuras para el almacenamiento de registros de bytes y palabras. ch. XFCB Estructura La estructura de bloque de control de fichero extendido de MS-DOS.H CW_DEFAULT #define Palabra de control por defecto para el coprocesador matemático 8087/80287. char xfcb_attr. bl. int xend.H ARCCOORDSTYPE Estrucura Usado por la función getarccoords() para obtener las coordenadas de la última llamada a arc(). . unsigned char cl.2. SOLID_FILL Usa color de relleno sólido. unsigned char si. bh. struct time { unsigned char ti_min.

BKSLASH_FILL gruesas \\\. }. LTBKSLASH_FILL HATCH_FILL claro. SOLID_LINE DOTTED_LINE CENTER_LINE DASHED_LINE USERBIT_LINE (User-defined) line_widths Tipo enumerado MCGA . Sombreado Sombreado Lineas entrelazadas. int color. 320 x 200 paleta 0 CGAC0 320 x 200 paleta 1 CGAC1 320 x 200 paleta 2 CGAC2 320 x 200 paleta 3 CGAC3 640 x 200 2 colores CGAHI NCGAC0 MCGAC1 MCGAC2 MCGAC3 MCGAMED MCGAHI 320 x 200 320 x 200 320 x 200 320 x 200 640 x 200 640 x 480 paleta 0 paleta 1 paleta 2 paleta 3 2 colores 2 colores line_styles Tipo enumerado Estilos de línea para las funciones getlinesettings() y setlinestyle(). XHATCH_FILL espeso. struct { int pattern. CLOSE_DOT_FILL espaciados. font_names Tipo enumerado Nombres de tipos de carácters gráficos. Puntos bastante Puntos pocos Definido por el EGA EGAMONO HERCMONO VGA DETECT autodetección) EGA64 IBM8514 ATT400 PC3270 (Requiere EGALO EGAHI EGA64LO EGA64HI EGAMONOHI HERCMONOHI ATT400C0 ATT400C1 ATT400C2 ATT400C3 ATT400MED ATT400HI VGALO VGAMED VGAHI PC3270HI IBM8514LO IBM8514HI 640 x 200 640 x 350 640 x 200 640 x 350 640 x 350 720 x 348 320 x 200 320 x 200 320 x 200 320 x 200 640 x 200 640 x 400 640 x 200 640 x 350 640 x 480 720 x 350 640 x 480 1024 x 768 16 colores 16 colores 16 colores 4 colores 2 colores 2 colores paleta 0 paleta 1 paleta 2 paleta 3 2 colores 2 colores 16 colores 16 colores 16 colores 2 colores 256 colores 256 colores FILLSETTINGSTYPE Estructura Usado para obtener los valores de relleno actuales por la función getfillsettings(). grOk grNoInitGraph grNotDetected grFileNotFound grInvalidDriver grNoLoadMem grNoScanMem grNoFloodMem grFontNotFound grNoFontMem grInvalidMode grError grIOError grInvalidFont grInvalidFontNum grInvalidDeviceNum grInvalidVersion graphics_modes Tipo enumerado Modos gráficos para cada controlador BGI. DEFAULT_FONT TRIPLEX_FONT SMALL_FONT SANS_SERIF_FONT GOTHIC_FONT graphics_drivers Tipo enumerado CGA graphics_errors Tipo enumerado Códigos de error devuelto por graphresult(). USER_FILL usuario. INTERLEAVE_FILL WIDE_DOT_FILL espaciados. Relleno con líneas Relleno con \\\.

int direction int charsize. }. CHAR_MAX . COPY_PUT XOR_PUT OR_PUT AND_PUT NOT_PUT fuente. signed char colors[MAXCOLORS+1]. text_just Tipo enumerado Justificación horizontal y vertical para la función settextjustify(). int y. · 10 visualiza caracteres en caja de 80x80 VIEWPORTTYPE Estructura Estructura usada para obtener información sobre el viewport actual por la función getviewsetting(). struct textsettingstype { int font. es signed. int vert. Si tienen una U delante.6LIMITS. int right. putimage_ops Tipo enumerado Operadores para putimage(). int top. int horiz. USER_CHAR_SIZE #define Tamaño de los caracteres definidos por el usuario (tamaño de caracteres = amplificación de caracteres en salida gráfica). HORIZ_DIR derecha.H Especial máximos y mínimos: Notas: Si tienen una S delante. es unsigned. int clip. setpalette() y setallpalette(). Valores que puede tomar esta constante simbólica: ·1 visualiza caracteres en caja de 8x8 ·2 visualiza caracteres en caja de 16x16 . struct palettetype { unsigned char size. LEFT_TEXT CENTER_TEXT RIGHT_TEXT BOTTOM_TEXT TOP_TEXT *_DIR (Dirección) #defines Direccion de salida gráfica...Anchuras de línea para las funciones getlinesettings () y setlinesettings(). }.2. 15. int bottom. NORM_WIDTH THICK_WIDTH MAXCOLORS #define Define el número máximo de entradas de colores para el campo array de colores en la estructura palettetype PALETTETYPE Estructura Contiene información de la paleta para el controlador gráfico actual. Copia Exclusive OR Inclusive OR AND Copia inversa de }. struct viewporttype { int left. }. Esta estructura es usada por las funciones getpalette(). VERT_DIR arriba. POINTTYPE Estructura Coordenadas de un punto struct pointtype { int x. De izquierda a De abajo hacia TEXTSETTINGSTYPE Estructura Usado para obtener los valores de texto actual por la función gettextsettings().

char p_cs_precedes. char *currency_symbol. número de bits en un dato tipo char char *mon_thousand_sep. Este valor es asignado a errno cuando se produce un error de rango. char p_sep_by_space. struct lconv { char }. Esta estructura es usada solamente en la función cabs(). char *negative_sign. char n_cs_precedes.7LOCALE. EDOM *decimal_point. char n_sign_posn.8MATH.y. #define Código de error para errores de dominio matemática. char *mon_decimal_point. . char p_sign_posn. struct complex { double x. cuando el argumento de la función matemática está fuera del dominio. char int_frac_digits.CHAR_MIN INT_MAX INT_MIN LONG_MAX LONG_MIN SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN UCHAR_MAX UINT_MAX ULONG_MAX USHRT_MAX CHAR_BIT #define Tipo char.2. char *positive_sign. char n_sep_by_space.H LCONV Estructura 15. char *int_curr_symbol. }. char *mon_grouping. char *thousands_sep. es decir.H COMPLEX Estructura Representación de número complejo. char *grouping. 15.2.

ignorar señal. _psp Variable global Dirección del segmento del PSP (Prefijo de Segmento de Programa) del programa. SING Singularidad en argumento. P_NOWAIT Los procesos hijo y padre se ejecutan concurrentemente (no implementado). M_SQRT2 √2 M_SQRT_2 (√2)/2 _mexcep Tipo enumerado Estas constantes representan posibles errores matemáticos. #defines Modos usados por las funciones spawn.2.9PROCESS. HUGE_VAL #define Valor de overflow para las funciones matemáticas. PLOSS Pérdida total de significancia. double arg1. SIG_IGN Ninguna acción. SIGXXXX #defines Las funcioens predefinidas para manejar las señales generados por la función raise() o por sucesos externos son: 15. P_WAIT El proceso hijo se ejecuta separadamente. 15.H P_XXXX . EXCEPTION Estructura El formato de información de error para las rutinas matemáticas. retval. extern unsigned int _psp. DOMAIN Error de dominio en argumento. M_XXXX #defines Los valores constantes para funciones logarítmicas. Este valor es asignado a errno cuando se produce un error de rango.ERANGE #define Código de error para resultados fuera de rango. char *name. UNDERFLOW Error de rango de underflow.10SIGNAL. PI #defines M_PI M_PI_2 M_PI_4 M_1_PI M_2_PI M_1_SQRTPI M_2_SQRTPI π π/2 π/4 1/π 2/π √π (√π)/2 M_SQRTXX #defines Valores constantes para raíces cuadradas de 2. arg2. M_LN10 El valor de ln (10). struct exception { int type. P_OVERLAY El proceso hijo reemplaza al proceso padre de tal forma que el padre ya no existe. M_LOG2E El valor de log (e). M_LOG10E El valor de log10(e). M_LN2 El valor de ln(2). TLOSS Pérdida parcial de significancia. M_E El valor de e. OVERFLOW Error de rango de overflow. SIG_ERR Devuelve código de error.H SIG_XXX #defines Las funciones predefinidas para manejar las señales generadas por la función raise() o por sucesos externos son: SIG_DFL Terminar el programa. }.2.

Demasiados ficheros abiertos. Dirección de bloque de memoria no válido. short st_mode. Trampa ECURDIR EDOM EEXIST EFAULT EINVACC EINVAL EINVDAT EINVDRV EINVENV EINVFMT EINVFNC EINVMEM EMFILE ENMFILE ENODEV ENOENT ENOEXEC ENOFILE ENOMEM ENOPATH ENOTSAM ERANGE EXDEV EZERO Violación de Terminar. EBADF Bloques de memoria destruidos. struct stat { short st_dev. st_atime. No más ficheros. No como fichero o directorio. No es el mismo dispositivo. sys_errlist Variable global Array de cadenas de mensajes.SIGABRT SIGFPE de punto flotante. EAACCES Número malo de fichero. S_IFMT Máscara de tipo de fichero. Formato no válido. S_IFREG Fichero regular. st_gid. Cross-device link. S_IFCHR Carácter especial. short st_rdev. Error 0. Al comienzo tiene el valor de O_TEXT por defecto. S_IEXEC Poseedor puee ejecutar. Error de formato de exec. S_IFDIR Directorio. st_ctime. Unidad especificada no válida. S_IFIFO FIFO especial. No como dispositivo. . Datos no válidos. RAND_MAX #define Valor máximo devuelto por la función rand(). Esta variable contiene el número de cadenas de mensajes de error en sys_errlist. STAT Estructura Describe una estructura que contiene información acerca de un fichero o directorio.11STDLIB. S_IWRITE Poseedor puede escribir. El fichero ya existe. Los mnemotécnicos y sus significados para los valores son: Mnemotécnico Significado Lista de argumentos demasiado E2BIG larga. No como fichero o directorio. ECONTR Intento de quitar el directorio actual. No hay suficiente memoria. Error desconocido. SIGSEGV acceso a mem. long st_size. int st_uid. sys_nerr Variable global Número de cadenas de mensajes de error. SIGINT Interrupción. Número de función no válido. Error de dominio.2. Argumeno no válido. 15. SIGTERM Abortar. S_IREAD Poseedor puede leer. 15.H _fmode Variable global Modo por defecto de translación de ficheros. Resultado fuera de rango. Path no encontrado. long st_mtime. SIGILL Instrucción ilegal.H S_Ixxxx #defines Definiciones usadas por las funciones de directorio y estado de fichero.12SYS\STAT. st_ino. st_nlink. int _fmode. S_IFBLK Bloque especial. int sys_nerr. Entorno no válido. Permiso denegado. char *sys_errlist[] Esta variable es un array de cadenas de mensajes que corresponden a errno y es usada por la función perror().2. Código de acceso no válido.

timezone Variable global Diferencia en segundos entre hora local y hora del meridiano de Greenwich. 059 */ int tm_min. time_t Tipo Este tipo de variable define el valor usado por las funciones de tiempo. no en éste (time. daylight Variable global Indica si se harán ajustes de horario de verano. 0-23 */ int tm_mday.13TIME. extern long timezone. El fichero sys\types. %d Hora. 0-365.h. Ordenes de formato para strftime Orden Substituida por Día de la semana en abreviatura. %A Abreviatura del mes. La constante CLK_TCK define el número de pulsos de reloj por segundo. %H Hora. Domingo =0 */ int tm_yday. rango (0-23). /* día de la semana. %B Cadena de hora y fecha estándar. 1-31 */ int tm_mon. /* día del mes. Las funciones de hoar y fecha usan dylight. también está declarado en sys\types. 15. extern char * tzname [2] NOTA: Esta variable está declarada en el fichero io. rango (1-12). %M Equivalencia de lugar de AM y PM. %j Mes en número (1-12). /* minutos. int daylight. /* año. /* mes.h únicamente contiene la declaración de este tipo. %a Dia de la semana completo. %I Día del año en número (1-366). /* horas. %b Nombre del mes completo. 1 de Enero=0 */ int tm_isdst. 0-6. TM Estructura Describe una estructura que contiene una fecha y hora separada en sus componentes.}. /* indicador de horario de verano */ tzname Variable global Array de punteros a cadenas. %c Día del mes en número (1-31). struct tm { int tm_sec.2. %p . año actual-1900 */ int tm_wday.h). Un array de punteros a cadenas conteniendo las abreviaciones para los nombres de zonas horarias. En TC. Enero=0 */ int tm_year. Usada por las funciones de hora y fecha. 0-11. /* segundos.h. /* día del año. %m Minuto en número (0-59). 0-59 */ int tm_hour.H clock_t Tipo Este tipo de datos devuelto por la función clock() almacena un tiempo trasncurrido medido en pulsos de reloj.

DMAXEXP Máximo exponente permitido. Límites float y double #defines UNIX Sytem V compatible _LENBASE aplicar exponente. Semana del año. DMAXPOWTWO Potencia de dos más grande.2. Cadena de fecha estándar. DMAXEXP Máximo exponente permitido. Límites para valores float _DEXPLEN Número de bits en exponente. MINDOUBLE más pequeño. MINDOUBLE Valor double más pequeño. Base a la que Límites para valores float y double _DEXPLEN Número de bits en exponente. domingo primer día (0-52). DMINEXP Mínimo exponente permitido. Día de la semana (0-6. domingo 0). MAXDOUBLE Valor double más grande. Cadena de hora estándar. DSIGNIF Número de bits significativos. DMINEXP Mínimo exponente permitido.H BITSPERBYTE #define Número de bits en un byte. Valor double 15. Nombre de zona temporal. Signo de %. Semana del año. DMAXPOWTWO Potencia de dos más grande. lunes primer día (0-52). Año en número sin centenas (00-99).14VALUES. MAXDOUBLE Valor double más grande.%S %U %w %W %x %X %y %Z %% Segundos en número (0-59). . DSIGNIF Número de bits significativos.

Sign up to vote on this title
UsefulNot useful