B I B L I O T E C A D E F U N C I O N E S E S T Á N D A R ANSIISO C++ Y BORLAND C++ 5.0

Texto completo

(1)

F.1. Plantilla referencia de entradas. F.2. Funciones de asignación de memoria. F.3. Funciones de búsqueda y ordenación. F.4. Funciones de cadena.

F.5. Funciones de clasificación de caracteres. F.6. Funciones de calendario (fecha y hora). F.7. Funciones de control de directorios.

F.8. Funciones de control de procesos. F.9. Funciones de conversión de datos. F.10. Funciones de entrada/salida. F.11. Funciones de gestión de archivos. F.12. Funciones matemáticas.

F.13. Funciones de manipulación de bloques de memoria (buffers). F.14. Funciones de presentación de texto.

B I B L I O T E C A D E F U N C I O N E S E S T Á N D A R

A N S I / I S O C + + Y B O R L A N D C + + 5 . 0

Esta parte es una revisión breve de la biblioteca de rutinas (funciones) y archivosinclude, en tiempo de ejecución. La biblioteca de Borland C++ es un conjunto de más de 450 funciones y macros preparadas para utilizar y diseñadas para su uso en programas C++. La biblioteca en tiempo de ejecu-ción hace la programaejecu-ción más fácil, ya que incluye una amplia variedad de tareas tales como E/S de bajo y alto nivel, manipulación de cadenas y archi-vos, asignación de memoria, control de procesos, cálculos matemáticos, etc. Las rutinas de Borland C++ están contenidas en los archivos de bibliote-caCx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ imple-menta la versión estándar última de ANSI C, que entre otras cosas recomien-da el uso de los prototipos de función en las rutinas de sus programas C++. Este apéndice describe alfabeticamente funciones de la biblioteca Bor-land C++ y contiene todas las funciones incluidas en ANSI/ISO C++.

F.1. PLANTILLA REFERENCIA DE ENTRADAS

Las entradas de las diferentes funciones y macros han sido normalizadas para facilidad de manejo del lector. Las rutinas han sido clasificadas por categorías (en general, se ha procurado respetar la clasificación dada por Borland y ANSI, pero con una adaptación más próxima al uso diario del programador /.

Al comienzo de cada categoría se hace una breve descripción de su cometido principal y se presenta una tabla con las funciones que contiene cada categoría por orden alfabético, así como una breve síntesis de su des-cripción o propósito. A continuación, por orden alfabético, se describen las rutinas de acuerdo al siguiente modelo para cada entrada.

F.2. FUNCIONES DE ASIGNACIÓN DE MEMORIA

Borland C++ almacena información en la memoria principal de la compu-tadora por dos métodos. El primero utiliza variables globalesy locales (incluyendo arrays, cadenas y estructura); en este caso, el almacenamiento o longitudes fija. Para cambiar el tamaño de arrays y cadenas de caracteres se debe editar el archivo fuente y recompilar su programa. Esta información se almacena en la pila(stack). El segundo método de almacenar informa-ción es asignar memoria a medida que el programa lo requiera y liberar esta memoria cuando ya no se necesita; esta acción permite utilizar la misma CONTENIDO

nombre función archivo de cabecera

• strrev #include <string.h>

char *strrev(char *cad) sintaxis Descripción

Propósito y breve descripción de cómo y dónde se utiliza la función.

Ejemplo

Una o más instrucciones o programas sencillos, donde se muestra la explicación real de la función.

(2)

memoria para colas diferentes en un tiempo distinto. Este proceso de asig-nar memoria se denomina asignación dinámica de memoria.

Por omisión, cada vez que se ejecuta un programa, DOS establece un segmento de 64 Kb denominado segmento de código, que contiene su códi-go programa. DOS establece también un segmento de 64 Kb denominado segmento de datos. Su programa puede tener múltiples segmentos de datos y códigos.

El segmento de datos se divide en tres regiones:datos del programa (variables estáticas y globales), pilastack— (variables locales y argu-mentos) y montónomontículoheap.

Segmento de datos

Después de asignar partes del segmento de datos a variables estáticas y globales y a la pila, el compilador dedica el resto del segmento de datos al montículooheap.

Borland C++ contiene un gran número de funciones para asignación dinámica de memoria, que realizan una gran variedad de tareas: asignar y liberar memoria del montículo y de la pila, obtener información de bloques de memoria, etc.

allocmen #include <dos.h>

int allocmen(unsigned t, unsigned * seg);

La función allocmen()establecesegpara apuntar a un segmento asig-nado de memoria de tpárrafos (1 párrafo = 16 bytes) de largo. Si hay éxito se devuelve –1, si hay error (falta memoria), allocmen()devuelve el tamaño en párrafos del mayor bloque disponible.

if(allocmen(size, &segadd)!= -1)

printf (“Error asignación memoria \n”);

Funciones relacionadas: falloc frremem, malloc, setblock.

brk #include <alloc.h>

int brk( void* a)

La función brkpermite modificar el «valor break» de un programa. El valorbreakes la dirección de la primera posición más allá del segmento de

Montículo Pila Datos del programa

(heap) (stack)

datos de un programa. Si hay éxito se devuelve 0; en caso contrario, –1, y la variable global errnoctoma el valor ENOMEN(insuficiente memoria).

it(brk(nuevo_break) == -1) perror(“brk ha fallado”);

Funciones relacionadas:free, farmalloc, malloc, sbrk.

calloc #include <stdlib.h>

#include <alloc.h>

int *calloc(size_t n, size_t s);

Asigna memoria principal (un bloque de tamaño n.s). El bloque se borra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debe utilizarfarcalloc. Devuelve un puntero al bloque recién asignado. Si no existe bastante espacio para el nuevo bloque o bien n o s es 0, calloc devuelve nulo.

long *buffer

buffer=(long *) calloc(40, sizeof(long));

Funciones relacionadas free, malloc.

coreleft #include <alloc.h>

unsigned coreleft(void) // modelos small, tiny, medium unsigned long coreleft(void); // en otros modelos de memoria

Determina la cantidad de memoria no utilizada. El valor devuelto depende del modelo de memoria.

Mem_avail = coreleft();

Funciones relacionadas: calloc, farcoreleft, malloc.

farcalloc #include <alloc.h>

void far *farcalloc(unsigned long n, unsigned long s);

(3)

if(array_grande=farcalloc(20000L, sizeof (int)) “” NULL) printf (“Fallo en asignación de memoria\n”);

Funciones relacionadas: calloc, farfree, farmalloc, malloc.

farcoreleft #include <alloc.h>

unsigned long farcoreleft(void);

Determina el número total de bytes disponibles en el sistema.

memoria_total_disponible = farcoreleft();

Funciones relacionadas:coreleft, farcalloc, farmalloc.

farfree #include <alloc.h>

void farfree(void far *b);

Libera la memoria apuntada por b.

farfree(arraygrande);

Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.

farheapcheck #include <alloc.h>

int farheapcheck(void);

Verifica la consistencia del montículo (heap)far.

estadoheap = farheapcheck();

Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk, heapcheck.

farheapcheckfree #include <alloc.h>

int farheapcheckfree(unsigned int f);

Verifica la consistencia de los bloques libres en el montículo (heap)far.

estadoheap = farheapcheckfree(´F´);

Funciones relacionadas: farheapfillfree, farheapwalk, heapfill-free, heapcheckheapfill-free, heapwalk.

farheapchecknode #include <alloc.h>

int farheapchecknode(void *bloque);

Verifica la consistencia de un solo bloque en el montículo (heap)far.

estadoheap = farheapchecknode(arraygrande);

farheapfillfree #include <alloc.h>

int farheapfillfree(unsigned int f);

Rellena todos los bloques libres del montículo farcon un valor constante.

estadoheap = farheapfillfree(´X´);

Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk.

farheapwalk #include <alloc.h>

int farheapwalk(struct farheapinfo *m);

Obtiene información sobre las entradas en el montículo (heap)far.

struct farheapinfo heap_entry;

estadopila = farheapwalk(&heap_entry);

farmalloc #include <alloc.h>

void far *farmalloc(unsigned long n);

Asignan bytes de memoria far. La cantidad completa de memoria encima de la pila está disponible para asignación por farmalloc. El tamaño del bloque puede exceder de 64 Kb.

if(bloquegrande = farmalloc(80000L) == NULL printf(“Asignación fallada\n”);

(4)

farrealloc #include <alloc.h>

void far *farrealloc(void far *b, unsigned long n)

Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b, al cual se ha asignado una longitud de nbytes).

if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL printf(“Fallo reasignación memoria\n”);

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

free #include<alloc.h>

#include <stdlib.h>

vid free(void *dir_memoria);

La función free() libera un bloque de memoria. El argumento dir_memoriaapunta a un bloque de memoria previamente asignado a través de una llamada a calloc, mallocorealloc. Después de la llama-da el bloque libre está disponible para asignación.

char *cad;

// asignar memoria para cadena cad = (char *) malloc(50);

...

free(cad); // liberar memoria

Funciones relacionadas: calloc, malloc, realloc

heapcheck #include <alloc.h>

int heapcheck(void);

Verifica la consistencia del montículo (heap). En Visual C++ 6.0 la fun-ción equivalente es _heapcheck();

estadoheap = heapcheck();

Funciones relacionadas:heapcheckfree, heapchecknode, heapfill-free, heapwalk, farheapcheck.

heapcheckfree #include <alloc.h>

int heapcheckfree(unsigned int f);

Verifica la consistencia de los bloques libres en el montículo (heap).

estadoheap = heapcheckfree(´N´);

Funciones relacionadas:farheapcheckfree, heapfillfree, heapwalk.

heapchecknode #include <alloc.h>

int heapchecknode(void *n);

Verifica la consistencia de un solo nodo (bloque de memoria). Verifica el bloque de memoria identificado por el puntero n.

estadopila = heapchecknode(array);

Funciones relacionadas: farheapchecknode, heapcheck, heapcheck-free, heapfillheapcheck-free, heapwalk.

heapfillfree #include <alloc.h>

int heapfillfree(unsigned int f);

Rellena cada byte de todos los bloques de memoria no utilizados en el montículo con un valor de carácter especificado. En Visual C++ la función equivalente es –heapset.

estadopila = heapfillfree(´Z´);

Funciones relacionadas: farheapfillfree, heapcheck, heapcheck-free, heapwalk.

heapwalk #include <alloc.h>

int heapwalk(struct heapinfo *i);

(5)

struct heapinfo i;

estadoheap = heapwalk(&i);

Funciones relacionadas: farheapwalk, heapcheck.

malloc #include <stdlib.h>

#include <alloc.h>

void *malloc (size_t n);

Asigna memoria a bloques en el montículo. Devuelve un puntero, que es la dirección inicial de la memoria asignada.

cadena = malloc(MAX_CHR)

Funciones relacionadas: calloc, free, realloc.

realloc #include <alloc.h>

#include <stdlib.h>

void *realloc(void *b, size_t n);

Ajusta el tamaño de un bloque de memoria basignado por malloco calloc a un tamaño de nbytes. Devuelve un puntero voidal bloque de memoria reasignado.

Nuevo_buffer = realloc(viejo_buffer, long+100);

Funciones relacionadas: calloc, free, malloc.

sbrk #include <alloc.h>

void *sbrk(int n);

Se utiliza sbrk para indicar el valor breakde un proceso. El valor breakes la dirección del primer byte disponible en el segmento de datos por omisión, más allá del segmento de datos que está siendo utilizado por los datos en el proceso.

sbr(500);

Funciones relacionadas: brk, coreleft

setblock #include <alloc.h>

int setblock(unsigned seg, unsigned n);

Ajusta el tamaño de un bloque de memoria asignado anteriormente por allocmen. Esta función llama a la función 4Ah de DOS para ampliar el tamaño de un bloque de memoria previamente asignado por allocmen. En las versiones Visual C++ la función equivalente es _dos_setblock.

F.3. FUNCIONES DE BÚSQUEDA Y ORDENACIÓN

La mayoría de los programas requieren casi siempre alguna operación de clasificación y búsqueda de elementos en arrays. Borland C++ incluye dife-rentes funciones que realizan estas tareas.

bsearch() #include <stdlib.h>

void bsearch(const void*k, const void *b, size_t n, size_t a, int(*comparar)(const void*, const void*));

La función bsearchrealiza una búsqueda binaria en un array ordena-dob, de nelementos, cada uno de abytes de tamaño. El argumento k apun-ta al valor que se está buscando. bearchdevuelve un puntero (la dirección) a la primera aparición del valor ken el array. Si no se encuentra el valor, bsearchdevuelve o.

El argumento comparar proporciona la dirección de una rutina que aceptará dos argumentos elem1yelem2, cada uno un puntero a un elemen-to del array. La función compararcompara cada uno de los elementos apun-tados y devuelve un valor de acuerdo con la tabla siguiente:

Valor devuelto Condición

Negativo Primer elemento menor que el segundo (elem1) (elem2).

Cero Los dos elementos son idénticos.

Positivo Primer elemento mayor que el segundo.

La búsqueda binaria requiere que el array esté ordenado, por lo cual, caso de que no esté ordenado el array, se puede utilizar la función qsort para ordenar el array antes de llamar a bsearch.

(6)

lfind #include <stdlib.h>

void * lfind(const void k, const void *b, size_t *num, size_t anchura, int(*comparar)(const void*, const void*));

La función lfind()realiza una búsqueda lineal de valor de k(clave) en un array de un número específico de elementos, cada uno de un número fijo de bytes de longitud. Al contrario que bsearch(), el array no necesita estar ordenado. lfind()devuelve un puntero al primer elemento del array que coincide con la clave; si la clave no existe en el array, se devuelve un 0.

int comp(const void*, const void *); resultado = (char **) lfind(palabrabuscada, envp, &cuenta, sizeof(char*), comp);

Funciones relacionadas: bsearch, lsearch, qsort.

lsearch #include <stdlib.h>

void * lsearch(const void *k, const void *a, size_t *n, size_t W, int(*comparar) (const void*, const void *));

La función lsearchrealiza una búsqueda lineal de la clave k. El arrayacontienenelementos de anchura W. La función compararse uti-liza para comparar la clave con el elemento actual del array. Al contrario quebsearch(), en la función lsearch() el array no tiene que estar ordenado.lsearch()devuelve un puntero al primer elemento del array que se corresponde con la clave. Si no existe la clave en el array, se devuelve 0 y un registro se añade al array con un valor de k.

La diferencia entre lsearch()ylfind()es que lsearch()añadirá un registro al final del array con un valor de la clave si ese registro no se ha encontrado en el array.

Funciones relacionadas: bsearch, lfind, qsort.

qsort #include <stdlib.h>

void qsort(void a, size_t n, size_t w, int(*comparar) (const void*, const void*));

La función qsortordena un array con un número dado de elementos utilizando el método de ordenación rápida quicksort (creado por C.A.R. Hoare). El número de elementos de array es ny el tamaño (en bytes) de cada elemento es w. La función compararse utiliza para comparar un elemento del array con la clave; devuelve los siguientes valores:

Valor devuelto Condición

Negativo Primer elemento (elem1)menor que el segundo (elem2).

Cero Los dos elementos son idénticos.

Positivo Primer elemento mayor que el segundo.

Ordenar la lista de enteros y visualizar el resultado.

#include <stdlib.h> #include <stdio.h>

int comparar(const void*, const void *);

int numeros[10] = {4,5,7,3,12,8,6,1,0,2};

main(void) {

int i;

printf(“lista original:”); for(i =0; i < 10; i++)

printf(“%d”, numeros[i]);

qsort(numeros,10,sizeof(int), comparar); printf(“lista ordenada:”);

for(i = 0; i < 10; i++) printf(“%10, numeros[i]); return 0;

}

// comparar enteros

comparar(const void *i, const void *j) {

return ((int *)i) – ((int *) j) }

Funciones relacionadas: bsearch, lfind, lsearch.

F.4. FUNCIONES DE CADENA

C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación el final de una cadena en C se representa por un byte que contiene un carácter nulo(´\0´). Las cadenas pueden ser declaradas como arrays de caracteres.

(7)

Acceso a las cadenas

A las cadenas se accede directamente a través de su índice, como en el ejemplo anterior, o bien a través de un puntero.

char cad5[] = “Hola Mortimer”; char *p_cad5;

p_cad5 = cad5;

Se puede también declarar e inicializar una cadena a la vez:

char *p_cad5 = “Hola Mortimer”;

El archivo de cabecera <string.h> contiene numerosas funciones que manipulan cadenas.

stpcpy #include <string.h>

char *stpcpy(char *cad1, const char *cad2);

La función stpcpy()copia una cadena en otra. Devuelve un puntero al final de la cadena copiada. Se devuelve el valor de cad1+strlen(cad2)

stpcpy(orden_dos, “DIR”); stpcpy(caad1, cad2);

Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.

strcat #include <string.h>

char *strcat(char *cad1, const char cad2);

strcat()concatena (añade) cad1al final de cad2, terminando la cade-na resultante con un carácter nulo (\0).

char nombre[80] = “Bob”; char blanco[2] = “”;

char ultimo[80] = “Marley”; ...

strcat(nombre,blanco); // blanco se concatena a nombre strcat(nombre,ultimo); // ultimo se concatena a nombre // la cadena nombre será “Bob Marley”

Funciones relacionadas: strcpy, strdup, strncat, strncpy.

strchr #include <string.h>

char *strchr(const char *cad, int c);

strchr()encuentra la primera aparición de cencad y devuelve un puntero a la primera aparición de cencad. Si cno se encuentra, devuelve un cero (NULL).

printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));

visualizará$85725

char *s[81] = “Esta es una cadena de prueba”; char *ptr;

ptr = strchr(s, ´a´);

el valor almacenado en ptres un puntero a la primera aparición de ´a´.

strcmp #include <string.h>

int strcmp(const char *a, const char *b);

Compara una cadena con otra. Los resultados serían:

> 0 si a > b = 0 si a == b < 0 si a < b

i = strcmp(“MNP”, “mnp”); // resultado < 0 i = strcmp(“abc”, “abc”); // resultado = 0 i = strcmp(“xy”, “abc”); // resultado > 0

char s1[80] “ “Mayo”; char s2[80] = “Octubre”; int j;

j = strcmp(s1, s2);

Funciones relacionadas:strcmpi, stricmp, strnicmp, strncmp.

strcmpi #include <string.h>

int strcmpi(const char *cad1, const char * call2);

(8)

< 0 si cad1 < cad2 = 0 si cad1 = cad2 > 0 si cad1 > cad2

v = strcmpi(c1, c2);

Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.

strcoll #include <string.h>

int strcoll(const char *cad1, const char cad2);

Comparacad1concad2. Devuelve un valor.

< 0 si cad1 < cad2 = 0 si cad1 = cad2 > 0 si cad1 > cad2

if(strcoll(nombre1, nombre2)! = 0) exit(EXIT_FAILURE);

Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp, strxfrm.

strcpy() #include <string.h>

char *strcpy(char *cad1, const char *cad2);

strcpy()copiacad2encad1. Si la longitud de la cadena resultante excede el tamaño asignado a cad1, puede producir fallos en el programa.

char *a = “Pepe Luis”; char b[12];

strcpy(b, a); cout << b << ´\n´;

Funciones relacionadas: strcat, strcup, strncat, strncpy.

strcspn #include <string.h>

size_strcspn(const char *cad1, const char *cad2);

Localiza la posición de la primera aparición en una cadena de cualquier carácter de otra cadena. Si tiene éxito, la función strcspndevuelve el

índi-ce del primer carácter de cad1, que pertenece al conjunto de caracteres de cad2.

primero = strcspn(“circunloquio”, “q”); // primero = 8

Funciones relacionadas: strpbrk, strspn.

strdup #include <string.h>

char * strdup(const char *cad);

Asigna memoria y copia una cadena dada en ese espacio. En realidad, strdup()llama a mallocpara asignar suficiente memoria para contener a cad. Si falla la asignación de memoria, strdup()devuelve un carácter nulo (NULL).

Leer una cadena y hacer un duplicado.

#include <stdio.h> #include <string.h> main()

{

char cad1[80], * cad1_copia; printf(“Introduzca una cadena:”); gets(cad1);

cad1_copia = strdup(cad1);

printf(“La cadena duplicada es:%s\n”, cad1_copia); return 0;

}

strerror #include <string.h>

char *strerror(int errnum);

Obtiene el mensaje de error del sistema correspondiente al número dado en el argumento errnum. La función strerror()obtiene el mensaje de error del sistema utilizando el valor en la variable global errno, como el índice una tabla de errores denominadas sys_errlist,que está declarado en el archivo de cabecera stdlib.h.

errno = 0;

printf (“Error”, strerror(errno);

(9)

strerror #include <string.h> #include stdio.h

char *strerror(const char *cad);

Esta función sirve para generar un mensaje de error definido por el usuario.

printf(“%S”, _strerror(“error apertura archivo”));

Funciones relacionadas: perror, strerror.

stricmp #include <string.h>

it stricmp(const char *cad1, const char *cad2);

Esta función se utiliza para comparar una cadena a otra sin tener en cuenta el tamaño de las letras. Convierte todos los caracteres alfabéticos de cad1ycad2en minúsculas; a continuación, se comparan las dos cadenas y devuelve un valor entero que indica el orden lexicográfico de cad1con res-pecto a cad2.

Si cad1 = cad2 el valor de la función es cero.

Si cad1 < cad2 el valor de la función es menor que cero. Si cad1 > cad2 el valor de la función es mayor que cero.

Resultado = stricmp(cad1, cad2),

Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.

strlen #include <strign.h>

size_t strlen(const char *cad);

Proporciona la longitud de una cadena cad. El carácter nulo no se inclu-ye en la longitud; en consecuencia, cuando reserve espacio, recuerde añadir 1 al valor devuelto por strlen.

longitud = strlen(nombre); char s[81] = “Cadena demo”;

printf(“La longitud de s es:%d\n” strlen(s));

Funciones relacionadas: _fstrlen.

strlwr #include <string.h>

char *strlwr(char *cad);

Convierte una cadena en letras minúsculas. La función devuelve un puntero a la cadena convertida.

char *orden =”SALIR”;

strlwr(orden); // ahora orden = “salir”;

Funciones relacionadas: strupr, toloweer.

strncat #include <string.h>

char *strncat(char *cad1, const char *cad2, size_t n);

La función strncat()añade los primeros ncaracteres de cad2acad1, y termina la cadena resultante un carácter nulo. Si cad2 es mayor que n caracteres de longitud, strncat()truncará la cadena a la longitud de n. En otro caso, concatenará la cadena completa.

char *a = “Sierra Madre”;

char *b = “de la ciudad de Monterrey”;

cout << strncat(a, b, 4) << ´\n´; cout << strncat(a, b) << ´\n´;

Funciones relacionadas: strcat, strdup, strcpy, strncpy.

strncmp #include <string.h>

int strncmp(const char *cad1, const char *cad2, size_t n);

Compara un número especificado en caracteres de dos cadenas y devuelve un entero con un valor.

< 0 si cad1 < cad2 = 0 si cad1 < cad2 > 0 si cad1 < cad2

char *a = “Mortimer el andaluz”; char *b = “Mortimer el mexicano”;

(10)

cout << “Ambas cadenas comienzan con \Mortimer\”; else

cout << “Estas cadenas no comienzan con \Mortimer\”;

Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, str-nicmp.

strnset #include <string.h>

char *strnset(char *cad, int c, size_t n);

Inicializa los caracteres de una cadena a un valor dado (blanco u otro carácter). Devuelve un puntero a la cadena cad. El carácter cse utiliza para rellenar la cadena con ese carácter; nes el número de posiciones de carac-teres que se han de inicializar.

printf(“Introduzca una cadena:”); gets(cadena);

printf(“Introducir un carácter:”); c = getche();

long = strlen(cadena)/2; strnset(cadena, c, lon);

Funciones relacionadas: memset, setmem, strset.

strpbrk #include <string.h>

char *strpbrk(const char *cad1, const char *cad2);

Encuentra la primera aparición en cad1de cualquiera de los caracteres decad2. El carácter nulo no se incluye en la búsqueda. Si el carácter no existe, se devuelve un carácter nulo (NULL).

char *s = “Mortimer L.J. Mackoy”; char *p = strpbrk(s, “L4”);

cout << p << ´\n´; // la salida es L.J.Mackoy

Funciones relacionadas: strchr, strcspn.

strrchr #include <string.h>

char *strrchr(const char *cad, int c);

Encuentra la última aparición del carácter cencad. Devuelve un pun-teo a la última aparición de co un carácter nulo si cno está en cad.

char *nombrearch = “c: /usr/tst/libro/cap1.txt”; cout << (strrchr(nombrearch, ´/´)+1 << ´\n´;

Funciones relacionadas: strchr.

strrev #include <string.h>

char *strrev(char *cad);

Invierte los caracteres de la cadena cad. El carácter de terminación nulo permanece en el mismo lugar. strrev()devuelve un puntero a la cadena inversa.

Aplicación: Invertir una cadena leída del teclado e imprimir el resultado.

#include <stdio.h> #include <string.h> main()

{

char demo[80]

printf(“Introduzca una cadena:”); gets(demo);

strrev(demo);

printf(“La cadena inversa es:\n %s |\n”, demo); return 0;

}

Funciones relacionadas: strcpy, strncpy.

strset #include <string.h>

char *strset(char *cad, int c);

Establece todos los caracteres de la cadena cadal valor de c. Termina cuando se encuentra el primer carácter nulo. Devuelve un puntero a la cade-na modificada.

char *cad = “---”;

strset (cad, ´x´); // cad es ahora xxxxx

(11)

strspn #include <string.h>

sze_t strspn(const char *cad1, constchar *cad2);

Localiza la posición del primer carácter de una cadena (cad1) que no pertenece al conjunto de caracteres de otra (cad2).

loc = strspn (cad1, blanco);

Funciones relacionadas: strcmp, strcspn.

strstr #include <string.h>

char *strstr(const char *cad1, const char *cad2);

Localiza la primera aparición de una cadena en otra. Si tiene éxito, la funciónstrstrdevuelve un puntero a la primera aparición de cad2como una subcadena de cad1. Si la búsqueda falla, se devuelve NULL.

char *s = “Mi autor favorito es Octavio Paz” char *a = “Octavio Paz”;

cout << “La subcadena” << a << “se encuentra:” << strstr(s, a) << ´\n´;

Funciones relacionadas: strchr, strcspn, strpbrk

strtok #include <string.h>

char *strtok(char *cad1, const char *cad2);

Rompe una cadena en subcadenas (token) utilizando una lista de sepa-radores. Devuelve un puntero a la subcadena actual y un NULLcuando se alcanza el final de la cadena.

char *s = “¿Prefiere a Verdi, o a Pucini?”; char *t = “.,!* ”;

cout << strtok(s, t) << ´\n´; cout << strtok(NULL, “!”);

Funciones relacionadas: strpbrk, strcspn.

strupr #include <string.h>

char *strupr(char *cad);

Convierte cualquier letra minúscula de la cadena en mayúscula y devuelve un puntero a la cadena convertida (sólo alfabeto inglés).

La función strupry su homónima strlwrno forman parte de la biblio-teca ANSI C. En estos casos, utilice las funciones toupperytolower.

strupr(“sierra madre”); // “SIERRA MADRE”

Funciones relacionadas: strlwr, toupper.

strxfrm #include <string.h>

size_t strxfrm(char *cad1, char *cad2, size_t n);

Conviertecad2encad1basado en información específica local y con un número máximo de caracteres a situar en cad1 den. En el siguiente ejemplo,strxfrm transforma los tres primeros caracteres de cad1en los tres primeros caracteres de cad2.

char *cad1 = “abcdefg”; char *cad2 = “1234567”;

clrscr();

strxfrm(cad1, cad2, 3);

printf(“Transformada: %s\n”, cad1);

F.5. FUNCIONES DE CLASIFICACIÓN

DE CARACTERES

C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita deter-minar la categoría de un carácter o convertir un carácter de mayúsculas en minúsculas, o viceversa. La biblioteca C contiene funciones que pueden ser definidas como macros para estos propósitos. Las macros están definidas en el archivo de cabecera ctype.h.

(12)

Asimismo, existen otras funciones en el archivo ctype.h que sirven para convertir caracteres en mayúsculas en minúsculas, y viceversa; y valo-res enteros en códigos ASCII.

isalnum #include <ctype.h>

int isalnum(int c);

La función isalnum()devuelve un cero si c es un carácter no alfa-numérico y un valor distinto de cero si el carácter es alfaalfa-numérico.

carac = getch(); if(isalnum(carac))

printf(“%c letra|digito \n”, carac); else

printf(“%c no letra|digito \n”, carac);

Funciones relacionadas: isascii.

isalpha #include <ctype.h>

int isalpha(int c);

La función isalpha()verifica si un carácter es alfabético. Devuelve un valor distinto de cero si ces un carácter alfabético, o 0 si cno es alfabético.

int c = getah()

if(isalpha©) printf(“%c es letra\n”, c);

Funciones relacionadas: iascii.

isascii #include ctype.h>

int isascii(int c);

Comprueba si un carácter ces un carácter ASCII; cestá en el rango 0-127. Los caracteres 128 a 255 de ASCII son tratados por iascii()como no ASCII.

carac = getch(); if(isascii(carac))

printf(“%c es ASCII \n”, carac); else

printf(“%c no es ASCII \n”, carac);

Funciones relacionadas: toascii, isalnum, isdigit,

iscntrl, isdigit #include <ctype.h> isgraph, islower

isprint, ispunct, isspace isupper,isxdigit

int iscntrl(int c); int isdigit(int c); int isgraph(int c); int islower(int c); int isprint(int c); int ispunct(int c); int isspace(int c); int isupper(int c); int isxdigit(int c);

Estas macros sirven para determinar propiedades específicas de un carácter ASCII.

Macro Verifica Rango válido de valores

iscntrl Carácter de control. 0..1Fh, 7Fh isdigit Dígito decimal. ´0´..´9´ isgraph Carácter imprimible (sin espacio). 21h a 7Eh islower Carácter minúscula. ´a´..´z´´ isprint Carácter imprimible 20h..7Eh

ispunct Carácter puntuación 21h..2Fh, 3Ah..40h, 5Bh..60h, 7Bh..7Eh isspace Carácter blanco. 9h..Dh 0 20h (blanco) isupper Carácter mayúscula. ´A´..´Z´

isxdigit Dígito hexadecimal. ´0´..´9´ ´A´..´F´ ´a´.. f´

Cada macro (función) devuelve un valor distinto de cero si csatisface el criterio de esa macro; en caso contrario, devuelve un cero.

if(isprint(c)) printf(“\n %c imprimible\n”, c);

if(iscntrl(c)) printf(“%c es un carácter de control\”, c); if(isdigit(c)) printf(“%c es un dígito\n”, c);

if(islower(c)) printf(“%c es letra minúscula\n”, c)

(13)

toascii #include <ctype.h>

int toascii(int c);

Esta función convierte un valor entero en un carácter ASCII válido.

C = toascii(entero);

Funciones relacionadas: iascii.

_tolower

tolower #include <ctype.h>

int _tolower(int c); int tolower(int c);

Convierte un carácter mayúscula en minúscula. Utilice _tolower sólo cuando esté seguro de que el carácter que quiere convertir es una letra mayúscula.

La función _tolower()sólo está disponible en sistemas UNIX. Por consiguiente, para asegurar la compatibilidad utilice sólo la función tolo-wer().

c = tolower(´S´); // c se convierte en ´S´

Funciones relacionadas: iascii, _toupper, toupper.

_toupper

touper #include <ctype.h>

int _toupper(int c); int _toupper(int c);

int c; // carácter a convertir

Estas funciones convierten un carácter minúscula en mayúscula. Utili-ce_touppersólo cuando esté seguro de que el carácter que quiere conver-tir es una letra minúscula (rango a-z).

La macro _toupperno está disponible en ANSI C. Para asegurar la compatibilidad, utilice siempre toupper().

c = toupper(´S´); // c se convierte en ´S´

Funciones relacionadas: iascii, _tolower, tolower.

F.6. FUNCIONES DE CALENDARIO (FECHA Y HORA)

Las funciones de calendario (fecha y hora) permiten obtener la hora actual y, a continuación, convertirla y almacenarla de acuerdo a sus necesidades particulares. La hora actual se toma siempre de la hora del sistema. Las fun-ciones de calendario están incluidas en el archivo de cabecera time.h.

asctime #include <time.h>

char *asctime(const struct tm *hora);

Convierte la fecha y la hora almacenada en una estructura de tipo tmen una cadena de caracteres. La estructura tmse define en time.hasí:

struct tm {

int tm_sec; // [0,59], segundos

int tm_min; // [0,59], minutos

int tm_hour; // [0,23], horas

int tm_mday; // [1,31], dias del mes int tm_mon; // [0,11], mes del año int tm_year; // [desde 1900], año

int tm_wday; // [0,6], dias desde domingo int tm_yday; // [0,265], numero dia año int tm_isdst; // indicador hora de verano };

printf(“Fecha/hora es %s\n”, asctime(&reloj));

Funciones relacionadas: ctime, gmtime, clocaltime, strftime, time.

clock #include <time.h>

cock_t clock(void);

Calcula el tiempo empleado por el proceso llamador, es decir, el tiem-po utilizado de procesador. Devuelve un valor en ticksque ha de dividirse por la constante CLK_TCK para obtener el tiempo transcurrido en segundos.

clock_t inicio, fin;

printf(“Inicio:%f\n, clock()/CLK_TCK;

(14)

ctime #include <time.h>

char *ctime(const time_t *hora);

Convierte la fecha y hora almacenada como valor de tipo time_ten una cadena de caracteres (mes día hora año\0).

time_t hora; hora = time(NULL);

printf(“Hora actual=%s\n”, ctime(&hora));

Funciones relacionadas: asctime, ftime, strtime, time.

difftime #include <time.h>

double difftime(time_t hora2, time_t hora1);

Obtiene la diferencia entre dos tiempos en segundos.

time_t inicio, fin clrscrl();

inicio = time(NULL); delay (5000);

fin = time(NULL);

printf(“Diferencia en segundos: %f\n”, difftime(inicio, fin));

Funciones relacionadas: asctime, ctime, gmtime, localtime, tzset.

dostounix #include <dos.h>

long dostounix(struct date *f, struct time *h);

Convierte la fecha y hora DOS (devuelta por getdateygettime) en formato UNIX.

time_t t;

struct time dos_hora; struct date dos_fecha; gatdate(&Dos_hora); gettime(&dos_fecha);

t = dostounix(&dos_fecha, &dos_hora);

Funciones relacionadas: ctime, gatdate, gettime.

ftime #include <sys/timeb.h>

void ftime(struct timeb *ptrhora);

Obtiene la hora actual y la almacena en la estructura timebapuntada porptrhora.

struct timeb {

long time; // segundos desde 00:00:00 hora GMT short millitm; // milisegundos

short timezone; // diferencia en minutos // hora Greenwich y hora local short dstflag; // hora de verano, ahorro de luz };

ftime(&hora);

Funciones relacionadas: time tzset.

getdate #include <dos.h>

void getdate(struct date *f);

Obtiene la fecha del sistema. Los componentes se almacenan en la estructuradatedefinida en dos.h.

struct date {

int da_year; // año actual (1980-2099) char da_day; // dia mes (1-31)

char da_mon; // mes (1-12)

};

struct date fecha; getdate(&fecha);

Funciones relacionadas: dostounix, gettime, setdate, settime.

gettime #include <dos.h>

void gettime(struct time *t);

Obtiene la hora actual del sistema. Los componentes de la hora se alma-cenan en la estructura timedefinida en dos.h.

struct time {

(15)

unsigned char ti_hour // horas (0-23)

unsigned char ti_hund // centésimas de segundo (0-99) unsigned char ti_sec // segundos (0-59)

};

struct time hora; gettime(&hora);

Funciones relacionadas: dostounix, getdate, setdate, settime.

gmtime #include <time.h>

struct tm *gmtime (const time_t *hora);

Convierte la fecha y hora en el tiempo medio de Greenwich (GMT) (año, mes, día, hora, minutos, segundos y otros campos). Véasestruct tm enasctime.

ahora = gmtime(&hoy);

Funciones relacionadas: asctime, ctime, ftime, localtime, time.

localtime #include <time.h>

struct tm *localtime(const time_t *hora);

Convierte una fecha y hora en varios campos de una estructura de tipo tm.Véasestruct tmenasctime.

tiempoactual = localtime(&ahora);

Funciones relacionadas:asctime, gmtime, time.

mktime #include <time.h>

time_t mktime(struct tm *h);

Convierte la hora local a un valor de calendario. Véasestruct tmen asctime.

Funciones relacionadas: asctime, gmtime, localtime, time.

setdate #include <dos.h>

void setdate(struct date *f);

Cambia la fecha actual del sistema. Los componentes de la fecha (día, mes. Año) se especifican en los campos de la estructura date.

struct date {

int da_year; // año actual char da_day; // día mes

char da_mon; // mes, 1 para enero, 2... };

En Visual C++ la función equivalente es _dos_setdate.

setdate(&fecha);

Funciones relacionadas: getdate, gettime, settime, dostounix.

settime #include <dos.h>

void settime(struct time *h);

Cambia la hora actual del sistema. Los componentes de la hora —hora, minutos y segundos— se deben cargar en los campos apropiados de la estructuratimedefinida en dos.h.Véasegettime.

settime(&hora);

Funciones relacionadas: dostounix, gatdate, gettime, setdate.

stime #include <time.h>

int stime(time_t *t);

Establece la fecha y hora del sistema al valor contenido en la posición cuya dirección está en el argumento t.

time_t horasis; horasis = time(NULL); stime(&horasis);

printf(“segundos desde 1/1/70 %ld”, horasis);

(16)

strftime #include <time.h>

size_t strftime(char *cad, size_t maxlon,

const char *formato, const struct tm *t);

Convierte un puntero en una estructura tmen una cadena cad(con una longitud máxima de n), utilizando fpara dar formato a la cadena. El forma-to es similar a printf().

horaseg = time(NULL);

horaactual = localtime(&horaseg);

strftime(buffer, 80, “%A %B %d 19%y:I:%M, horaactual);

Funciones relacionadas: asctime, ctime, gmtime, localtime, time.

time #include <time.h>

time_t time(time_t *h);

Proporciona el tiempo del sistema en segundos desde las 00:00:00 de 1/1/1970 tiempo GMT.

time(&hora);

tzset #include <time.h>

void tzset(void);

Establece las variables de entorno horarios TZ; asigna valores a las variables globales timezone, daylight y tzname.

tzset();

printf(“Luz de verano = %d\n”, daylight); printf(“zona horario = %ld\n”, timezone);

Funciones relacionadas: asctime, ftime, gmtime, localtime, time.

unixtodos #include <time.h>

void unixtodos(long time, struct date *f, struct time *h);

Convierte a formato DOS un valor de hora en el formato UNIX.

tnixtodos(t_unix, &d_dos, ft_dos);

Funciones relacionadas: getdate, gettime, time, setdate, settime.

F.7. FUNCIONES DE CONTROL DE DIRECTORIOS

MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerárquico que permite al usuario organizar sus archivos en directorios y subdirectorios. Las funciones de control de directorios en Borland C++ proporcionan las herramientas necesarias para crear, modificar, mover y eliminar directorios desde sus programas C. Las funciones de manipulación de directorios resi-den en el archivo de cabecera dir.h.

chdir #include <dir.h>

int chdir(const char *camino);

Cambia el directorio de trabajo actual al directorio especificado en el argumento camino. La función devuelve un 0 si tiene éxito; en caso contra-rio, devuelve un valor de –1 para asignar el error. Cuando se produce un error, la variable global errnotoma el valor ENOENT(camino o archivo no encontrado).

if(chdir(\\)) { perror(“chdir()”); exit(1);

}

Funciones relacionadas: mkdir, rmdir, setdisk, system.

findfirst #include <dir.h>

int findfirst(const char *camino, struct ffblk *ffblk, int atrib);

Busca en un directorio de disco hasta encontrar el primer archivo cuyo nombre y atributos se corresponden con los valores especificados. El for-mato de la estructura ffblkes:

struct ffblk {

(17)

char ff_atrib; // encontrado atributo int ff_ftime; // hora archivo

int ff_date; // fecha archivo

long ff_fsize; // tamaño archivo

char ff_name[13]; // encontrado nombre de archivo };

La variable attribviene definida en el archivo de cabecera <dos.h>y puede ser igual a uno de estos valores:

FA_RDONLY Archivo de sólo lectura.

FA_HIDDEN Archivo oculto.

FA_SYSTEM Archivo del sistema.

FA_LABEL Etiqueta de volumen.

FA_DIREC Directorio.

FA_ARCH Bit de archivo activado.

struct ffblk ffblk; int t;

t = findfirst(“*.*”, &ffblk,0);

Funciones relacionadas: findnext.

findnext #include <dir.h>

int findnext(struct ffblk *ffblk);

findnextcontinúa la búsqueda de findfirst(). findnext llama a la función 4Fhde DOS para encontrar el siguiente archivo cuyo nombre y atributos son idénticos a los dados en la llamada a la función findfirst().

findnext(&filefinfo);

Funciones relacionadas: findfirst.

fnmerge #include <dir.h>

void fnmerge(char *camino, const char *u, const char *dir, const *nombrearch, const char *ext);

Crea un nombre de camino completo compuesto de una letra de la uni-dad (u), camino del directorio (dir), nombre de archivo (nombrearch) y extensión del archivo (ext).

fnmerge(camino, “c:”, \\aux\\”,”demo”,”.dat”);

Funciones relacionadas: fnsplit.

fnsplit #include <dir.h>

void fnsplit(const char *camino, char *u, char *dir, char *nombrearch, char *ext);

Separa un nombre de camino completo en sus componentes: letra de la unidad (u), camino del directorio, nombre del archivo y extensión del archi-vo (ext).

h = fnsplit(camino, unidad, dir, nomarch, ext);

Funciones relacionadas: fnmerge.

getcurdir #include <dir.h>

int getcurdir(int u, char *dir);

Obtiene el directorio de trabajo actual en una unidad específica. El número de la unidad (u) 0 indica la unidad actual por omisión, 1 significa unidad A, 2 unidad B, etc. La función devuelve un cero si tiene éxito, en caso de error devuelve –1.

getcurdir(3, cuentas);

Funciones relacionadas: getcwd, getdisk.

getcwd #include <dir.h>

char *getcwd(char *camino, int numcar);

getcwdobtiene el nombre de camino completo del directorio de traba-jo actual, incluyendo el nombre de la unidad. El argumento numcarindica agetcwdel máximo número de caracteres que el buffercaminopuede con-tener. La función getcwdes útil para obtener el nombre del directorio actual y guardarlo. Si su programa cambia los directorios de trabajo durante su eje-cución, puede utilizar el nombre guardado para restaurar el directorio de tra-bajo actual antes de terminar.

getcwd(cuentas, 80)

(18)

getdisk #include <dir.h>

int getdisk(void);

La función getdisk obtiene el valor entero que representa la unidad actual (0, unidad A; 1, unidad B...)

int unidad; clscr();

unidad = getdisk();

Funciones relacionadas:setdisk.

mdir #include <dir.h>

int rmdir(const char *camino);

Elimina el directorio escrito por la variable camino, siempre que el directorio esté vacío, no sea el directorio raíz y no sea el directorio de tra-bajormdir(); devuelve 0 si la operación de borrado tiene éxito; si se pro-duce un error, el valor devuelto es –1 y la variable global errnose fija a uno de los siguientes valores:

EACCES Permiso denegado.

ENOENT Camino archivo no encontrado.

Esta función es similar a RMDIRoRDde MS-DOS.

rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS

Funciones relacionadas: chdir, mkdir.

mkdir #include <dir.h>

int mkdir(const char *camino);

Crea un directorio con un nombre de camino especificado. Funciona igual que la orden MKDIRo MDde DOS. Devuelve 0 si el directorio se ha creado con éxito o –1 si se produce un error; en este caso, la variable global errnotoma el valor EACCES (permiso denegado) o ENOENT (nombre de camino no válido).

EACCES Permiso denegado. ENOENT Camino no encontrado. resultado = mkdir(“PRUEBAS”); // crea el directorio PRUEBAS

Funciones relacionadas: chdir, rmdir.

mktemp #include <dir.h>

char *mktemp(char *plantilla);

Crea un nombre de archivo a partir de una plantilla. Devuelve un pun-tero al nombre del archivo si tiene éxito y nulo en caso de error.

mktemp(nombre);

searchpath #include <dir.h>

char searchpath(const char *nombre);

Busca un archivo específico en una lista de directorios, incluyendo el directorio de trabajo actual y los definidos en la variable de entorno PATH. Si el archivo se encuentra, se devuelve un puntero al nombre del camino del archivo; en caso contrario, se devuelve NULL.

buffer = searchpath(“BC.EXE”);

Localizar el archivo AUTOEXEC.BATen los directorios definidos en la variable de entorno PATH.

buffer = searchpath(“autoexec.bat”);

Funciones relacionadas: getenv, putenv.

setdisk #include <dir.h>

int setdisk(int unidad);

Cambia a una nueva unidad por omisión. El valor de la unidad (unidad) es un entero.

Unidad A B: C: D: ...

nuevaunidad = setdisk(3); / nueva unidad actual es C:

(19)

F.8. FUNCIONES DE CONTROL DE PROCESOS

Un proceso es un programa ejecutable en memoria y su entornoasociado. Cada vez que se ejecuta un programa se crea un proceso.

En resumen, un proceso es un programa que se está ejecutando por el sistema operativo. Consta del código del programa y de datos, además de información relativa al proceso, tales como número de archivos abiertos. Siempre que se ejecuta un programa al nivel del sistema operativo se arran-ca un proceso.

Las funciones de control de proceso permiten arrancar, detener y ges-tionar procesos desde dentro de un programa. La mayoría de las funciones de control se declaran en el archivo de cabecera process.h; otros archivos de cabecera que contienen funciones de control de proceso y del entorno son locale.h, signal.h, setjmp.hystdlib.h.

abort #include <process.h>

#include <stdlib.h>

void abort(void);

Termina la ejecución del programa actual y devuelve un código de error (3).

if (argc 1) {

printf(“Faltan argumentos!\n”) abort()

}

Funciones relacionadas : exit, _exit, raise, signal, spaw.

assert #include <assert.h>

void assert(int expresión);

Imprime un mensaje de error e interrumpe el programa siexpresiónes falsa (0).

assert(string != NULL; assert(*string != ´\0´); assert(strlen(string) < 2);

Funciones relacionadas: abort, raise, signal.

atexit #include <stdlib.h>

int atexit(void(*func)(void));

Procesa la función especificada al salir.

atexit(segundo);

Funciones relacionadas: abort, exit, _exit.

exec(familia) #include <process.h> int excel(char *camino, char *arg0,...,NULL);

int execle(char *camino, char *arg0,..., *argn, NULL, char **env);

int execlp(char *camino, char *arg0, arg1,...,NULL);

int execlpe(char *camino, char *arg0,...argn, NULL, char **env);

int execv(char *camino, char argv[]);

int execve(char *camino, char argv[], char **env);

int execvp(char *camino, char *argv[]);

int execvpe(char *camino, char *argv[], char **env);

Cargan y ejecutan un proceso hijo en la memoria actualmente ocupada por su código del programa. Las funciones execcrean un proceso hijo que carga y ejecuta el programa especificado por el argumento camino.

execlo(“hijo.exe”, hijo.exe”, “Uno, “Dos”, NULL); execv(“hijo.exe”, argv);

Funciones relacionadas: abort, atexit, exit, _exit, fpreset, spawn.

exit #include <stdlib.h>

void exit(int estado);

Termina un programa. Antes de terminar, se cierran todos los archivos, se escribe la salida a través del buffery se llama a cualquier función exit registrada.estado representa el estado de salida del programa; 0, salida normal; distinto de cero, indica un error.

(20)

Funciones relacionadas: abort, atexit, ´exit, exit, ´fpreset, spawn, system.

_exit #include <stdlib.h>

void _exit(int estado);

Termina inmediatamente el proceso actual sin hacer otras operaciones auxiliares (como cierre de archivos).

_exit(0)

Funciones relacionadas: exit.

getenv #include <stdlib.h>

char *getenv(const char *nomvar);

Obtiene la definición de una variable de la tabla de entorno del proce-so. Utiliza la variable global environpara localizar la lista de las variables de entorno y, a continuación, busca una entrada en la lista correspondiente anomvar.

varlib = getenv(“LIB”);

Funciones relacionadas: putenv.

getpid #include <process.h>

unsigned getpid(void)

Obtiene el ID de proceso de un programa. Está disponible en sistemas UNIX.

printf(“PID:%X\n”,getpid());

Funciones relacionadas: getpsp.

localeconv #include <locale.h>

struct lconv *localeconv(void);

Obtiene información detallada sobre formatos monetarios y numéricos de diferentes países.

p_lconv = localeconv();

Funciones relacionadas: setlocale.

longjmp #include <setjmp.h>

void longjmp(jmp_buf env, int valor);

Restaura el estado de la pila y la ejecución local anteriormente grabada enenvporsetjmp.

longjmp(plaza, 3);

Funciones relacionadas: setjmp.

perror #include <stdio.h>

void perror(const char *cadena);

Imprime un mensaje de error del sistema en el flujo stderr. El argu-mentocadenase imprime primero, seguido por dos puntos; a continuación, el mensaje de error correspondiente al valor actual de la variable global errnoy, finalmente, un carácter de nueva línea. Si cadenaes un puntero nulo o un puntero a una cadena nula, perrorimprime sólo el mensaje de error del sistema.

perror(“Error de cierre de archivos”);

Funciones relacionadas: _strerror, strerror.

putenv #include <stdlib.h>

int putenv(const char *cadena);

Crea nuevas variables de entorno o modifica los valores de las variables de entorno existentes.

if(putenv(argv[1] == -1)

(21)

raise #include <signal.h>

int raise(int señal);

Envía una señal al programa en ejecución. Crea una condición de excepción correspondiente al número señal. Existen diferentes constantes, por ejemplo, SIGABRT(terminación anormal).

printf(“prueba de raise\n”); raise(SIGABRT);

Funciones relacionadas:abort, signal.

setjmp #include <setjmp.h>

int setjmp(jmp_buf env);

Guarda el estado actual del programa (el entorno de la pila) antes de lla-mar a otra función. Este entorno puede ser restaurado por una llamada a longjmp, realizando el efecto de un gotono local.

if(setjmp(env) != 0) printf(“valor de longjmp\n”);

Funciones relacionadas: longjmp.

signal #include <signal.h>

void (*signal(int sig, void (*func) (int))) (int);

Establece tratamiento de señales de interrupción. La función signal per-mite a un proceso elegir uno de los diferentes modos de manipular una señal de interrupción del sistema operativo.

signal(SIGINT, SIG_IGN);

Funciones relacionadas: abort, _control87, exit, longjmp, raise, setjmp.

spawn (funciones) #include <stdio.h> #include <process.h>

int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);

int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL, char **envp[]);

int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL); int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL,

char **envp[]);

int spawnv(int modo, char *camino, char *argv[]);

int spawnve(int modo, char *camino, char /argv[], char *envp[]); int spawnvp(int modo, char *camino, char *argv[]);

int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);

La familia de funciones spawn crea y ejecuta un nuevo proceso hijo. Debe haber memoria suficiente para cargar y ejecutar el proceso hijo.

spawnlpe(P_WAIT, “hijo.exe”, “hijo.exe”, “spawnlpe”, buf, NULL, env);

Funciones relacionadas: exec.

F.9. FUNCIONES DE CONVERSIÓN DE DATOS

Las funciones de conversión de tipos de datos sirven para crear un puente de unión entre los dos estilos de representación de números: la cadena de texto legible por los humanos y el formato binario legible por las máquinas. Las funciones de conversión son ideales para convertir argumentos de líneas de órdenes de su representación de cadena al formato interno.

atof() #include <math.h>

#include <stdlib.h>

double atof(const char *cadena);

La función atof()convierte el argumento cadena en un valor de doble precisión. La cadena debe tener el siguiente formato:

[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]

opcional e/E

blancos o dígitos decimales tabulaciones

(22)

double x;

char *cad_dbl = “200-85”; ...

x = atof(cad_dbl); // convierte la cadena “200.85” a real

Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf, strtod.

atoi #include <stdlib.h>

int atoi (const char *cadena)

La función atoi()convierte el argumento cadena en un valor entero. La cadena debe tener el siguiente formato:

[espacio en blanco][signo][ddd]

opcional

espacio o tabulación dígitos decimales

La conversión termina cuando se encuentra un carácter no reconocible (carácter nulo, ‘\0’, punto decimal o una letra). Si no puede convertir la cadena devuelve nulo.

int i;

char *cad_ent =123; ...

i = atoi(cad_ent);// convierte la cadena “123” al entero 123

Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.

atol #include <stdlib.h>

long atol(const char *cadena);

Convierte el argumento cadena en un valor entero largo. La cadena debe tener el formato:

[espacio en blanco][signo][ddd]

opcional

blancos y tabulaciones dígitos decimales

La conversión de caracteres de la cadena hasta que se encuentre el pri-mer carácter no reconocible o el carácter nulo (‘\0’).

long int i;

char cad_ent = “9876543”; ...

i = atol(cad_ent); // convierte cadena “9876543” a entero // largo.

Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod, strtol, strtoul, ultoa.

ecvt #include <stdlib.h>

char *ecvt(double valor, int n, int *dec, int *signo);

La función ecvt()convierte un argumento de valor doble precisión en una cadena con ndígitos. Si valortiene más de ndígitos, los dígitos infe-riores se truncan. deces un puntero a un entero en donde se devuelve la posición del punto decimal; signoes un puntero a un entero donde se devuelve el signo (cero, positivo; en los restantes casos, negativo).

p_buffer = ecvt(valor, exactitud, &dec, &signo);

Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa, ltoa, ultoa.

fcvt #include <stdlib.h>

char *fcvt(double valor, int n, int *dec, int *signo);

Al igual que la función ecvt,fcvtconvierte el argumento valor de doble precisión en una cadena de ndígitos. Si el número de dígitos de valor excede a n, el exceso de dígitos se trunca. Si hay menos dígitos que n la cadena se rellena con ceros. fcvtse diferencia de ecvten el modo de tra-tar los dígitos significativos. ecvt() busca un número total de dígitos, mientras que fcvt()busca el número de dígitos a la derecha del puntero decimal.

cadena = fcvt(valor, exactitud, %oposición_d, &signo);

(23)

gcvt #include <stdlib.h>

char *gcvt(double valor, int ndig, char, *buf);

La función gcvt()convierte el argumento valorde doble precisión en una cadena de caracteres que se almacena en el buffercuya dirección se da en el argumento buf. Se debe asignar bastante espacio en el bufferpara con-tener todos los dígitos de la cadena convertida y el carácter nulo de termi-nación(‘\0’).

gcvt(valor, digitos, cadena);

Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf, sprintf, ultoa.

itoa #include stdlib.h>

char *itoa(int valor, char *cad, int base);

La función itoa()convierte el argumento entero valoren una cadena de caracteres utilizando el argumento base, como base de un sistema de numeración (2 a 36). Debe existir bastante espacio en cadpara contener 17 caracteres,itoa()devuelve un puntero a la cadena cad.

itoa(32, buffer, 16); // buffer contendrá “20”, ya que 32 entero // equivale a 20 en hexadecimal

Funciones relacionadas: atoi, atol, itoa, ultoa.

ltoa #include <stdlib.h>

char *ltoa(long valor, char * cad, int base);

La función ltoa()convierte el argumento entero largo valoren una cadena de caracteres que utiliza el argumento basecomo base de un siste-ma de numeración. Como un entero largo ocupa 32 bits en base 2, la cade-na puede ocupar 33 bytes con el carácter nulo de termicade-nación. Debe haber bastante espacio para contener 33 bytes. ltoa()devuelve un puntero a cad.

long valor = 99288377L ltoa(valor, cadena, 30);

Funciones relacionadas: atoi, atol, itoa, ultoa.

strtod #include stdlib.h>

double strtod(const char *cad, char **p);

La función strtod()convierte la cadena caden un valor de doble precisión. La cadena debe tener el formato

[blanco][signo][ddd][.][exponente][signo][ddd]

+, - d, D, e, E

blanco/ dígitos decimales tabulación

strtod()devuelve el valor de doble precisión y cero si no se produce la conversión. La conversión se termina con el primer carácter no reconocible. Aplicación: Convertir la cadena “843899.567” a un valor de coma flo-tantedouble.

#include <stdio.h> #include <stdlib.h>

main() {

double x;

char *num_flt = “843899.567”: char *p;

x = strtod(num_flt, &p); printf(“x = %f\n”,x); }

Funciones relacionadas: atof, printf, scanf, strtol, strtoul.

strtol #include <stdlib.h>

long strtol(const char *cad, char **p, int b);

La función strtol()convierte una cadena caden un valor entero largo. La cadena (puede contener hasta 33 caracteres) debe tener el formato:

[espacio en blanco][signo][0][x|X][ddd]

+,- dígitos decimales hexadecimal

(24)

La conversión se termina con el primer carácter no reconocible. Si se produce un error de desbordamiento (positivo o negativo) la variable errno se establece al valor de la macro ERANGE.

Aplicación.Convertir la cadena “9876” en valor entero.

#include <stdio.h> #include <stdlib.h>

main() {

int base = 10; long int i;

char *cad_ent = “9876”; char *ptrcad;

i = strtol(cad_ent, &ptrcad, base); printf(“i = %ld\n”, i);

}

Funciones relacionadas: atoi, atof, atol, ltoa, strtoul.

strtoul #include <stdlib.h>

unsigned long strtoul(const char *cad, char **p, int base);

Convierte una cadena de caracteres a un entero largo sin signo en la base dada. La cadena debe tener el formato:

[espacio en blanco][0][x|X][ddd]

dígitos decimales octal

blanco o tabulaciones hexadecimal

Si la base bes cero, strtoulutiliza el primer carácter de la cadena para determinar la base del valor.

La cadena cadpuede contener hasta 33 caracteres, excluyendo el carác-ter de carác-terminación nulo (´\0,). Si se produce un error de desbordamiento, la variable errnose pone al valor de ERANTE.

i = strtoul(cad_ent, &ptrfin, base);

Funciones relacionadas: atol, ultoa, strtol.

ultoa #include <stdlib.h>

char *ultoa(unsigned long valor, char *cad, int base);

La función ultoa()toma valor en base b(entre 2 y 36) y lo convierte en una cadena. Devuelve el puntero al principio de cad. No devuelve códi-go de error. cadpuede contener hasta 33 caracteres, excluyendo el carácter de terminación nulo (´\0´).

ultoa(valor, buffer, base);

Funciones relacionadas: itoa, ltoa.

F.10. FUNCIONES DE ENTRADA/SALIDA

Las funciones de E/S(Entrada/Salida,I/O,Input/Output) permiten leer y escribir datos entre archivos y dispositivos. En C no hay estructuras de archivos predefinidas, todos los datos se tratan como secuencias de bytes. La lista de funciones de E/S se han agrupado de acuerdo a las tareas especí-ficas que realizan:

1. Secuencias o flujos (stream). 2. Bajo nivel.

3. Consola y puertos.

Funciones de flujos (stream)

Las funciones de E/S tratan los datos como una secuencia o flujo de carac-teres individuales. La elección adecuada de las funciones disponibles per-mite procesar datos en tamaños y formatos diferentes, desde caracteres inde-pendientes a estructuras de datos complejos. La E/S por secuencia, o flujo, también proporciona acciones de taponamiento (buffering) que mejoran sig-nificativamente el rendimiento. Para utilizar los flujos, generalmente se debe incluir el archivo stdio.h.

clearerr #include <stdio.h>

void clearerr(FILE *f);

Reinicializa el indicador de error de un flujo f.

clearerr(fichen);

(25)

fclose, fcloseall #include <stdio.h>

int fclose(FILE *f); int fcloseall(void);

Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall) exceptostdin,stdoutystderr. Se devuelve el número de flujos cerrados yEOFsi se produce un error.

fcloseall();

Funciones relacionadas: close, fdopen, fopen.

fdopen #include <stdio.h>

FILE *fdopen(int handle, char *modo);

Abre un flujo utilizando un handle(entero devuelto por las rutinas de E/S de bajo nivel, tales como open, creat, dupy dup2); asocia una estructura de datos FILE con el archivo especificado por handle.

p_datos = fdopen(handle, “rb”);

Funciones relacionadas: fclose, fopen, fropen, open.

feof #include <stdio.h>

int feof(FILE *flujo);

Comprueba el final de archivo de un flujo.

feof(fichen);

Funciones relacionadas: clearerr, fclose, rewind.

ferror #include <stdio.h>

int ferror(FILE *f);

Verifica si se ha producido un error en un flujo f.

ferror(fichen);

Funciones relacionadas: clarerr, eof, feof, fopen, perror.

fflush #include <stdio.h>

int fflush(FILE *f);

Limpia (vacía) un flujo. Los buffersse limpian automáticamente cuan-do están llenos, cuancuan-do se cierra el flujo, o cuancuan-do un programa termina nor-malmente sin cerrar el flujo.

fflush(fp);

Funciones relacionadas: fclose, flshall, fopen.

fgetc #include <stdio.h>

int fgetc(FILE * f);

Lee un carácter de la posición actual del archivo y, a continuación, incrementa esta posición.

c = fgetc(fp)

Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc, putchar.

fgetchar #include <stdio.h>

#int fgetchar(void);

Lee un carácter del archivo stdin, normalmente el teclado.

c = fgetchar();

Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.

fgetpos #include <stdio.h>

int fgetpos(FILE *flujo, fpos_t *p);

Obtiene y graba la posición actual del archivo. fos_tes un tipo defini-do en stdio.h.

(26)

fgets #include <stdio.h>

char *fgets(char *cad, int n, FILE *f);

Lee una cadena de un flujo (hasta que se encuentra \n, o el número máximo de caracteres especificados).

fgets(caddemo,80, fp);

Funciones relacionadas: fputs, gets, puts.

fileno #include <stdio.h>

int fileno(FILE *f);

Obtiene el mando o manejador (handle) del archivo asociado con un flujo.

fileno(stdin);

Funciones relacionadas: fdopen, fopen.

fopen #include <stdio.h>

FILE *fopen(const char *f, const char *modo);

Abre un archivo f. La cadena de caracteres modo especifica el tipo de acceso.

Modo Acción

“r” Abre para lectura.

“w” Abre un archivo vacío para escritura.

“a” Abre para escritura al final del archivo (añadir). “r+” Abre para lectura/escritura.

“w+” Abre un archivo vacío para lectura/escritura. “a+” Abre para lectura y añadir.

“rb” Abre un archivo binario para lectura. “wb” Crea un archivo binario para escritura. “ab” Abre un archivo binario para añadir.

“rb” Abre un archivo binario para lectura/escritura. “wb” Crea un archivo binario para la lectura/escritura. “ab” Abre o crea un archivo binario para lectura/escritura.

if ((corriente2 = fopen(“datos”, “W+”)) == NULL printf(“el archivo..no se ha abierto \n”);

Funciones relacionadas: fclose, fcloseall, fdopen, ferror, fileno, freopen, open, setmode.

flushall #include stdio.h>

int flushall(void);

Vacía (limpia) todos los buffersasociados con los archivos abiertos.

numvaciados = flushall();

Funciones relacionadas: fclose, fflush.

fprintf #include <stdio.h>

int fprintf(FILE *f, const char *formato[arg,...]);

Imprime datos con formato en un flujo.

fprintf(f1,”El resultado es %f\n”,result);

Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.

fputc #include <stdio.h>

int fputc(int c, FILE *f);

Escribe un carácter cen el flujo abierto para salida con buffer.

fputc(*(p++), stdout);

Funciones relacionadas: fgetc, fgetchar, fputchar, getc, get-char, putc.

fputchar #include <stdio.h>

(27)

Escribe el carácter censtdout.

fputchar(´q´);

Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.

fputs #include <stdio.h>

int fputs(const char *cad, FILE *f);

Escribe una letra caden un flujo f. Devuelve el último carácter impre-so, si hay error devuelve EOF.

fputs(“esto es una prueba”, f1);

Funciones relacionadas fgets, gets, puts.

fread #include <stdio.h>

size_t fread(void *p, size_t t, size_t n, FILE *f);

Leenregistros de tbytes en la memoria apuntada por pdesde el flujo f.

fread(buf, strlen(msg)+1, 1, flujo);

Funciones relacionadas: fwrite, read.

freopen #include <stdio.h>

FILE *freopen(const char *f, const char *m, FILE *flujo);

Cierra el archivo asociado con flujo y reasigna flujoal archivo espe-cificado por f. Los modos (m) utilizados son los mismos de fopen.

freopen(“salida.txt”, “w”, stdout);

Funciones relacionadas: fclose, fopen.

fscanf #include <stdio.h>

int fscanf(FILE *f, const char *formato [, dirección,...]);

Lee datos con formato de un flujo.

fscanf(flujo, “%s%f”, cad, &f);

Funciones relacionadas: csanf, fprintf, scanf, sscanf.

fseek #include <stdio.h>

int fseek(FILE *f, long desp, int org);

Mueve el puntero del archivo asociado con fa una nueva posición que está desplazada despbytes de org.

Origen Significado

SEEK_SET Principio de archivo.

SEEK_CUR Posición actual puntero archivo. SEK_END Final de archivo.

fseek(f1,OL,SEEK_SET); // ir al principio

Funciones relacionadas: ftell, rewind, fopen.

fsetpos #include <stdio.h>

int fsetpos(FILE *f, const fpos_t *p);

Establece la posición del puntero del archivo al lugar especificado por el objeto apuntado por p.

fsetpos(fp, &posarch);

Funciones relacionadas: getpos.

ftell #include <stdio.h>

long int ftell(FILE *f);

Obtiene la posición actual (puntero) del archivo asociado con el flujo f.

ftell(fichen);

Figure

Actualización...

Referencias

Actualización...