Guía de Algorítmica y Programación
Estructura Básica de un Programa en C++ [Borland C++ 5.02]
Zona de ficheros de cabecera de las librerías #include <... . h> // h de Head #include <... . h>
Zona de declaración de constantes simbólicas #define PI 3.1415 <... . h>
Zona de prototipos de funciones int Potencia (int x,y)
Zona de variables globales int valor;
float media_total;
void main (void) // Prog. ppal. típico de Turbo C { // llave de inicio del programa // codigo del programa
... ... ...
} // fin del programa
/* Comentarios de un párrafo completo comprendidos entre /*...*/, sirven para aclarar qué el programa o una parte del programa */
La Biblioteca Estándar de C
La biblioteca estándar deC es una recopilación de ficheros cabecera y bibliotecas con rutinas, estandarizadas por un comité de la Organización Internacional para la Estandarización (ISO), que implementan operaciones comunes, tales como las de entrada y salida o el manejo de cadenas. A diferencia de otros lenguajes como COBOL, FORTRAN, o PL/I, C no incluye palabras clave para estas tareas, por lo que prácticamente todo programa implementado en C se basa en la biblioteca estándar para funcionar.
Diseño
El nombre y las características de cada función, el prototipo, así como la definición de algunos tipos de datos y macros, se encuentran en un fichero denominado archivo de cabecera (con extensión ".h"), pero la implementación real de las funciones están separadas en un archivo de la biblioteca. La denominación y el ámbito de las cabeceras se han convertido en comunes, pero la organización de las bibliotecas sigue siendo diversa, ya que éstas suelen distribuirse con cada compilador. Dado que los compiladores de C, a menudo, ofrecen funcionalidades adicionales que no están especificados en el ANSI C, la biblioteca de un compilador no siempre es compatible con el estándar ni con las bibliotecas de otros compiladores.
Calidad del diseño
Está demostrado que la mayor parte de la biblioteca estándar de C ha sido bien diseñada, aunque, se ha comprobado que algunas partes también son fuente de errores; funciones para entrada de cadenas como gets() o scanf(), producen desbordamientos de buffer, y muchas guías de programación recomiendan evitar su uso. La función strtok() presenta otra singularidad, está diseñada para ser utilizada como un analizador léxico rudimentario, pero resulta difícil de utilizar además de ser muy frágil
.
El estándar ANSI
La biblioteca estándar de ANSI C consta de 24 ficheros cabecera que pueden ser incluidos en un proyecto de programación con una simple directiva. Cada cabecera contiene la declaración de una o más funciones, tipos de datos y macros.
básicos (listas, pilas, colas, ...), ni herramientas para crear una interfaz gráfica de usuario (GUI), ni operaciones para trabajar en red, no otras funcionalidades que un lenguaje como Java incorpora de manera estándar. La principal ventaja del reducido tamaño de la biblioteca estándar de C es que construir un entorno de trabajo en ANSI C es muy fácil y, en consecuencia, portar un programa en ANSI C de una plataforma a otra es relativamente sencillo.
Se han desarrollado muchas otras bibliotecas para proporcionar una funcionalidad equivalente a la de otros lenguajes de programación. Por ejemplo, el proyecto de desarrollo del entorno de escritorio de GNOME creó las bibliotecas GTK+ y Glib con funcionalidades para desarrollar y trabajar con interfaces gráficas de usuario. La variedad de bibliotecas disponibles ha hecho que, a lo largo de la historia, haya quedado demostrada la superioridad de algunas de estas herramientas. El gran inconveniente es que a menudo no funcionan especialmente bien en conjunto, normalmente son los propios programadores familiarizados con las diferentes bibliotecas quienes consiguen sacarles el máximo partido, aunque diferentes partes de ellas puedan estar disponibles en cualquier plataforma.
La biblioteca estándar de C en C++
El lenguaje de programación C++ incluye la funcionalidad de la biblioteca estándar ANSI C, pero hace algunas modificaciones como cambiar los nombres de los ficheros de cabecera, de <xxx.h> a <cxxx> (aunque los nombres en estilo C, aun siendo obsoletos, siguen estando disponibles), y ubican todos los identificadores dentro del namespace std.
Archivos de cabeceras de la biblioteca ANSI C
<assert.h> Contiene la macro assert (aserción), utilizada para detectar errores lógicos y otros tipos de fallos en la depuración de un programa.
<complex.h> Conjunto de funciones para manipular números complejos (nuevo en C99).
<errno.h> Para testar los códigos de error devueltos por las funciones de biblioteca.
<fenv.h> Para controlar entornos en coma flotante (nuevo en C99).
<float.h> Contiene la definición de constantes que especifican ciertas propiedades de la biblioteca de coma flotante, como la diferencia mínima entre dos números en coma flotante (_EPSOLON), el número máximo de dígitos de precisión (_DIG), o el rango de valores que se pueden representar (_MIN, _MAX).
<inttypes.h> Para operaciones de conversión con precisión entre tipos enteros (nuevo en C99).
<iso646.h> Para utilizar los conjuntos de caracteres ISO 646 (nuevo en NA1).
<limits.h> Contiene la definición de constantes que especifican ciertas propiedades de los tipos enteros, como rango de valores que se pueden representar (_MIN, _MAX).
<locale.h> Para la función setlocale() y las constantes relacionadas. Se utiliza para seleccionar el entorno local apropiado (configuración regional).
<math.h> Contiene las funciones matemáticas comunes.
<setjmp.h> Declara las macros setjmp y longjmp para proporcionar saltos de flujo de control de programa no locales.
<signal.h> Para controlar algunas situaciones excepcionales como la división por cero.
<stdbool.h> Para el tipo booleano (nuevo en C99).
<stdint.h> Para definir varios tipos enteros (nuevo en C99).
<stddef.h> Para definir varios tipos de macros de utilidad.
<stdio.h> Proporciona el núcleo de las capacidades de entrada/salida del lenguaje C (incluye la venerable función printf).
<stdlib.h> Para realizar ciertas operaciones como conversión de tipos, generación de números pseudo-aleatorios, gestión de memoria dinámica, control de procesos, funciones de entorno, de señalización (??), de ordenación y búsqueda.
<string.h> Para manipulación de cadenas de caracteres.
<tgmath.h> Contiene funcionalidades matemáticas de tipo genérico (type-generic) (nuevo en C99).
<time.h> Para tratamiento y conversión entre formatos de fecha y hora.
<wchar.h> Para manipular flujos de datos anchos y varias clases de cadenas de caracteres anchos (2 o más bytes por carácter), necesario para soportar caracteres de diferentes idiomas (nuevo en NA1).
La librería stdio.h
La biblioteca <stdio.h>, cuyas siglas significan “standard input-output header” (cabecera standar de entrada y salida), es la biblioteca estándar del lenguaje de programación C, el archivo de cabecera que contiene las definiciones de macros, las constantes, las declaraciones de funciones y la definición de tipos usados por varias operaciones estándar de entrada y salida. Por motivos de compatibilidad, el lenguaje de programación C++ (derivado de C) también tiene su propia implementación de estas funciones, que son declaradas con el archivo de cabecera cstdio.
Las funciones declaradas en stdio.h son sumamente populares. Los programadores
tienen que incluir el archivo de cabecera stdio.h dentro del código fuente para poder utilizar las funciones que están declaradas. Aparte de las funciones también encontramos variables y tipos de dato propios de la biblioteca que se pasaran a definir a continuación:
Funciones en la <stdio.h>
Las funciones declaradas en stdio.h pueden clasificarse en dos categorías: funciones de manipulación de ficheros y funciones de manipulación de entradas y salidas.
Las funciones de manipulación de puntero que encontramos en la stdio.h son:
Nombre Descripción
fclose cierra un fichero a través de su puntero
fopen,
freopen,
fdopen
abre un fichero para lectura, para escritura/reescritura o para adición
remove elimina un fichero
rewind La función rewind coloca el indicador de posición de fichero para el stream apuntado por stream al comienzo del fichero.
tmpfile crea y abre un fichero temporal que es borrado cuando cerramos con la función fclose()
Las funciones de manipulación de datos de entrada y salida que encontramos en esta biblioteca son cerca de 44 funciones representadas en la siguiente tabla:
clearerr fclose feof ferror
fflush fgetc fgetpos fgets
fopen formato fprintf fputc
fputs fread freopen fscanf
fseek fsetpos ftell fwrite
getc getchar gets perror
printf putc putchar puts
remove rename rewind scanf
setbuf setvbuf sprintf sscanf
tmpfile tmpnam ungetc vfprintf
vprintf vsprintf
Dentro de estas funciones se destacan las funciones: getchar, putc, putchar, getc, gets, puts, fflush, scanf, printf, debido a que están se usan con mayor frecuencia en los programas en C.
getchar ( ): esta función se utiliza para leer solo un carácter introducido por un dispositivo de entrada.
o Formato: Variable de carácter = getchar ( );
getc( ): devuelve un carácter desde un fichero.
putchar( ): esta función se utiliza para visualizar un carácter al dispositivo de salida. o Formato: putchar(variable de carácter);
putc( ): devuelve un carácter de un fichero.
scanf( ): se utiliza para introducir cualquier combinación de datos procedentes del dispositivo (valores numéricos, cadenas de caracteres o caracteres sueltos).
o Formato: scanf(cadena de control, arg1, arg2, … , arg n )
printf( ): se utiliza para visualizar cualquier combinación de datos (valores numéricos, cadenas de caracteres o caracteres sueltos).
gets( ): facilitan la transferencia de cadenas de caracteres, esta función se utiliza para introducir una cadena de caracteres.
o Formato: gets(cadena de caracteres);
puts( ): facilitan la transferencia de cadenas de caracteres, esta función se utiliza para mostrar una cadena de caracteres.
o Formato: puts(cadena de caracteres);
fflush( ):Sirve para vaciar el buffer de escritura del archivo especificado.
Constantes predeterminadas en la <stdio.h>
Las constantes definidas en el fichero cabecera stdio.h son:
Nombre Descripción
EOF entero negativo (int) usado para indicar "fin de fichero"
BUFSIZ entero que indica el tamaño del buffer utilizado por la función setbuf()
FILENAME_MAX tamaño máximo de la cadena de caracteres que contienen el nombre de un fichero para ser abierto
FOPEN_MAX Número máximo de ficheros que pueden estar abiertos simultáneamente
_IOFBF abreviatura de input/output fully buffered (buffer entrada/salida totalmente lleno); es un entero que se puede pasar como parámetro de la función setvbuf() para requerirbloqueo del buffer en la entrada y salida del stream abierto
_IOLBF abreviatura de input/output line buffered (...??); es un entero que se puede pasar como parametro a la función setvbuf() para requerir line buffered (??) en la entrada y salida del stream abierto
función setvbuf() para requerir que la entrada salida del stream abierto funcione sin buffer
L_tmpnam tamaño de la cadena de caractres con la longitud suficiente para almacenar un nombre de fichero temporal generado por la función tmpnam()
NULL macro que representa la constante puntero nulo; representa un valor de puntero que no apunta a ninguna dirección válida de objeto alguno en memoria
SEEK_CUR entero que se puede pasar como parámetro a la función fseek() para indicar posicionamiento relativo a la posición actual del fichero
SEEK_END entero que se puede pasar como parámetro a la función fseek() para indicar posicionamiento relativo al final del fichero
SEEK_SET entero que se puede pasar como parámetro a la función fseek() para indicar posicionamiento relativo al inicio del fichero
TMP_MAX el número máximo de nombres de ficheros únicos generables por la función tmpnam()
Variables que podemos encontrar en la <stdio.h>
El fichero de cabecera stdio.h define las siguientes variables:
Nombre Descripción
stdout puntero a FILE que referencia la salida estándar, normalmente el monitor
stderr puntero a FILE que referencia la salida de error estándar, normalmente el monitor
Tipos de datos
Los tipos de datos definidos en el fichero de cabecera stdio.h son:
FILE - estructura que contiene información sobre el fichero o stream (flujo) de texto necesario para realizar las operaciones de entrada/salida sobre él. incluye:
posición actual de stream
indicador de fin de fichero (EOF)
indicador de error
puntero al buffer del stream
fpos_t - tipo no-array capaz de identificar unívocamente la posición de cada byte en un archivo
size_t - tipo entero sin signo (positivo); es el tipo devuelto por el operador sizeof
Ejemplos
Ejemplo No.1:
#include <stdio.h>
main() {
inta, b;
printf( "Introduzca el primer número: " ); scanf( "%d", &a );
printf( "Introduzca el segundo numero: " ); scanf( "%d", &b );
Introduzca el primer número: 76 Introduzca el segundo numero: 45 Los valores son: 76, 45
Ejemplo No. 2:
#include <stdio.h> main()
{
chara, b, c;
printf("Introduzca primer caracter: " ); scanf("%c", &a );
printf("Introduzca segundo caracter: " ); fflush( stdin );
scanf("%c", &b );
printf( "Introduzca tercer caracter: " ); fflush( stdin );
scanf("%c", &c );
printf( "Los valores son: %c, %c, %c ", a, b, c ); }
La librería Conio.h
Contiene los prototipos de las funciones, macros, y constantes para preparar y manipular la
consola en modo texto en el entorno de MS-DOS®.
Funciones más importante de la <conio.h> gotoxy (columna, fila)
Sitúa el cursor en la columna y fila especificada. Por ejemplo, esta instrucción:
gotoxy (5, 2);
…sitúa el cursor en la fila 2, columna 5 de la pantalla. La siguiente instrucción de escritura en consola comenzará a escribir a partir de esas coordenadas.
cprintf() y cscanf()
Son las equivalentes a printf() y scanf(). Su sintaxis es la misma, y es recomendable usarlas en lugar de las funciones estándar para evitar funcionamientos extraños.
textcolor(color)
Cambia el color del texto. Los colores predefinidos son: BLACK, BLUE, RED, GREEN, CYAN, MAGENTA, BROWN, DARKGRAY. Además, existen las variedades “claras” de estos colores: LIGHTBLUE, LIGHTRED, LIGHTGREEN, etc.
Así, si ejecutamos:
textcolor (LIGHTRED);
…el texto que se escriba a continuación aparecerá el color rojo intenso.
textbackground (color)
Establece el color del fondo del texto. Los colores predefinidos son los mismos que para textcolor(). Así, este código:
textbackground (BLUE);
…hace que el texto que se escriba a continuación aparezca con el fondo en color azul oscuro.
cgets
encuentre una combinación de retorno de línea y nueva línea (CR/LF), o hasta que el número máximo de caracteres permitidos hayan sido leídos. Si se lee una combinación CR/LF, entonces es sustituido por un carácter nulo '\0' antes de ser guardado la cadena.
Cputs
Muestra la cadena, que finaliza con el carácter nulo, apuntada por el argumento cadena en la ventana de texto actual. Esta función es similar a la función puts, pero con dos excepciones: la función cputs no convertirá los caracteres de nueva línea (\n) en la pareja de caracteres de retorno de línea/nueva línea (\r\n) tampoco añadirá el carácter de nueva línea al final del texto.
Kbhit
Revisa si una tecla pulsada está disponible. Cualesquier pulsadas disponibles pueden ser recogidas con las funciones getch o getche.
getch ()
Lee un carácter desde el teclado, sin mostrar el eco y sin necesidad de pulsar Return. Devuelve el código ASCII del carácter tecleado. Ahí va un ejemplo:
char c;
c = getch();
clrscr ()
La librería Ctype.h
Este archivo de cabecera analiza el tipo de carácter dependiendo de la función mandada a llamar. El carácter puede ser mandado a la función como un número entero o como un carácter (variable o encerrado entre apóstrofos). Si la función determina que no es ese tipo de carácter regresa el valor de 0 (que para c es un valor de falso y otro valor si lo es (para C es un valor de verdadero). Existen también un par de funciones que permiten convertir un carácter de minúscula a mayúscula y viceversa,
Funciones dentro de <Ctype.h>
Isalnum: determina si el character c es una letra del alfabeto (de la a a la z sin distinguir entre mayúsculas y minúsculas) o un digito. Si no es letra o digito regresa un valor cero, de lo contrario regresa un valor distinto de cero.
o Formato: Int isalnum (int c)
Programa Salida
void main (void) { char letra; letra=getche(); if (isalnum(letra))
printf("\n%c es una
letra o número", letra); else
printf("\n%c no es una
letra ni número", letra); }
Si letra='r'
"r es una letra o número"
Si letra='7'
"7 es una letra o número"
Si letra='$'
Isdigit: determina si el carácter c es un número. Si no es un número regresa un valor cero, de lo contrario regresa un valor distinto de cero.
o Fomarto: int isdigit (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche(); if (isdigit(letra))
printf("\n%c es un
número", letra); else
printf("\n%c no es un
número", letra); }
Si letra='4'
"4 es un número"
Si letra='$'
"$ no es un número"
Isascii: determina si el entero c es un carácter de la tabla de código ASCII básico (del 0 al 127). Si no es un carácter ASCII básico regresa un valor cero, de lo contrario regresa un valor distinto de cero.
o Formato: int isascii (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche(); if (isascii(letra))
printf("\n%c es ASCII
básico", letra); else
printf("\n%c no es un
ASCII básico", letra); }
Si letra='+'
"+ es un ASCII básico"
Si letra='ñ'
Isspace: determina si el caracter c es un caracter blanco (tab, espacio, retorno de carro, cambio de línea, tab vertical, salto de página). Si no es caracter blanco regresa un valor cero, de lo contrario regresa un valor distinto de cero.
o Formato: int isspace (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche(); if (isspace(letra))
printf("\n%02x es un
caracter blanco", letra); else
printf("\n%c no es un
caracter blanco", letra); }
Si letra='\t'
"0x09 es un caracter blanco"
Si letra='$'
"$ no es un caracter blanco"
islower : determina si el caracter c es una letra minúscula. Si no es minúscula regresa un valor cero, de lo contrario regresa un valor distinto de cero.
o Formato: int islower (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche(); if (islower(letra))
printf("\n%c es una
letra minúscula", letra); else
printf("\n%c no es una
letra minúscula", letra); }
Si letra='r'
"r es una letra minúscula"
Si letra='R'
"R no es una letra minúscula"
Si letra='&'
"& no es una letra minúscula"
Isupper: Determina si el caracter c es una letra mayúscula. Si no es mayúscula regresa un valor cero, de lo contrario regresa un valor distinto de cero.
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche(); if (isupper(letra))
printf("\n%c es una
letra mayúscula", letra); else
printf("\n%c no es una
letra mayúscula", letra); }
Si letra='R'
"R es una letra mayúscula"
Si letra='r'
"r no es una letra mayúscula"
Si letra='&'
"& no es una letra mayúscula"
Toascii: convierte un entero a un carácter ASCII básico (solo mantiene los 7 bits menos significativos).
o Formato: int toascii (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche();
printf("\n%c sin convertir", letra);
printf("\n%c convertido a ASCII", toascii(letra));
}
Si letra='r'
"r sin convertir" "r convertido a ASCII"
Si letra='ú'
"ú sin convertir" "# convertido a ASCII"
tolower : Convierte una letra mayúscula a minúscula. Si es una letra mayúscula retornara su equivalente en minúscula, de lo contrario retornará el carácter sin modificación alguna.
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche();
printf("\n%c sin convertir", letra);
printf("\n%c en minúscula", tolower(letra));
}
Si letra='A'
"A sin convertir" "a en minúscula"
Si letra='5'
"5 sin convertir" "5 en minúscula"
toupper: Convierte una letra minúscula a mayúscula. Si es una letra minúscula retornara su equivalente en mayúscula, de lo contrario retornará el carácter sin modificación alguna.
o Formato: int toupper (int c)
Ejemplo:
Programa Salida
void main (void) { char letra; letra=getche();
printf("\n%c sin convertir", letra);
printf("\n%c en mayúscula", toupper(letra));
}
Si letra='a'
"a sin convertir" "A en mayúscula"
Si letra='5'
La librería Stdlib.h
stdlib.h , cuyas siglas se definien como: std-lib: standar library o biblioteca estándar, es el archivo de cabecera de la biblioteca estándar de propósito general del lenguaje de programación C. Contiene los prototipos de funciones de C para gestión de memoria dinámica, control de procesos y otras. Es compatible con C++ donde se conoce como cstdlib.
Las funciones que pertenencen a stdlib.h pueden clasificarse en las siguientes categorías:
conversión, memoria, control de procesos, ordenación y búsqueda, matemáticas.
Nombre Descripción
Conversión de tipos
atof (ascii to float) cadena de caracteres a coma flotante
atoi (ascii to integer) cadena de caracteres a entero
atol (C Standard Library) (ascii to long)
cadena de caracteres a entero tamaño largo
strtod (string to double) cadena de caracteres a coma flotante tamaño doble
strtol (string to long) cadena de caracteres a entero largo
strtoul (string to unsigned long) cadena de caracteres a entero largo sin signo (positivo)
Generación de números pseudo-aleatorios
srand Establece la semilla para el generador de números pseudo-aleatorios
Gestión de memoria dinámica
malloc, calloc, realloc Reservan memoria dinámica del heap (montón o montículo)
free Liberan memoria devolviéndola al heap
Control de procesos
abort terminar ejecución anormalmente
atexit registrar una función callback para la salida del
programa
exit terminar ejecución del programa
getenv recuperar una variable de entorno
system ejecutar un comando externo
Ordenación y búsqueda
bsearch búsqueda binaria en un array
qsort ordena un vector (informática) usando Quicksort
abs, labs valor absoluto
div, ldiv división entera o euclidiana
Ahora pasaremos a definir algunas de las funciones que se utilizan más de esta librería que son:
Atoi: Convierte una cadena a un entero
Formato: int atoi ( const char * str );
Analiza la cadena str C interpretación de su contenido como un número entero, que se devuelve como un valor int.
Los descartes primera función como muchos espacios en blanco como sea necesario hasta que el primer carácter no blanco se encuentra. Luego, a partir de este personaje, toma un opcional signo inicial más o menos seguido de tantos caracteres numéricos como sea posible, y las interpreta como un valor numérico.
La cadena puede contener caracteres adicionales después de los que forman el número entero, que se ignoran y no tienen ningún efecto sobre el comportamiento de esta función.
Si la primera secuencia de caracteres no está en blanco str no es un número entero válido, o si no existe tal secuencia, ya sea porque str está vacío o sólo contiene espacios en blanco, sin conversión se realiza.
Atof : convierte una cadena a doble
Formato: double atof ( const char * str );
Analiza la cadena str C interpretación de su contenido como un número de punto flotante y devuelve su valor como un doble.
Los descartes primera función como muchos espacios en blanco como sea necesario hasta que el primer carácter no blanco se encuentra. Luego, a partir de este personaje, toma como muchos personajes de lo posible que son válidos después de una sintaxis parecida a la de los literales de coma flotante, y las interpreta como un valor numérico. El resto de la cadena después de que el último carácter válido es ignorado y no tiene ningún efecto sobre el comportamiento de esta función.
Un signo opcional más o menos
Una secuencia de dígitos, de forma opcional que contiene un carácter de punto decimal Una parte exponente opcional, que a su vez consiste en una 'e ' o 'E' caracteres seguido de un signo opcional y una secuencia de dígitos.
Si la primera secuencia de caracteres no está en blanco str no forman un número válido de punto flotante como acaba de definir, o si no existe tal secuencia, ya sea porque str está vacío o sólo contiene espacios en blanco, sin conversión se realiza.
Rand: Devuelve un número entero pseudo-aleatorio en el rango de 0 a RAND_MAX.
Formato: int rand ( void );
Este número es generado por un algoritmo que devuelve una secuencia de números aparentemente no relacionados cada vez que se llama. Este algoritmo utiliza una semilla para generar la serie, que debería ser inicializado a un valor distintivo con srand.
RAND_MAX es una constante definida en <cstdlib>. Su valor por defecto puede variar entre las implementaciones pero se concede al menos 32.767.
Una forma típica de generar números pseudo-aleatorios en un rango determinado utilizando rand es utilizar el módulo del valor devuelto por el lapso de gama y añade el valor inicial de la gama:
(% valor de 100) se encuentra en el rango de 0 a 99 (valor 100% + 1) se encuentra en el rango de 1 a 100 (valor 30% + 1985) está en el rango 1985 a 2014
Srand: inicializa el generador de números aleatorios
Formato: void srand (unsigned int semilla);
El generador de números pseudo-aleatorios se inicializa con el argumento pasado como semilla.
Para cada valor de inicialización diferentes utilizados en una llamada a srand, el generador de números pseudo-aleatorios se puede esperar para generar una sucesión de diferentes
resultados en las posteriores convocatorias de rand.
Dos inicializaciones diferentes con la misma semilla, la instrucción de generador de pseudo-aleatorios para generar la misma sucesión de los resultados de las posteriores convocatorias de rands en ambos casos.
Con el fin de generar números al azar-como, srand es normalmente inicializado a un valor distintivo, como los relacionados con el tiempo de ejecución. Por ejemplo, el valor devuelto por la función de tiempo (declarada en <ctime> encabezado) es diferente a cada segundo, que es distintivo suficiente para la mayoría de las necesidades del azar.
System: ejecuta un comando del sistema
Formato: int system (const char * command);
Inicia el procesador de comandos para ejecutar un comando. Una vez que la ejecución de comandos ha terminado, el procesador da el control al programa, devolver un valor entero, cuya interpretación depende del sistema.
La función de llamada también se puede utilizar con NULL como argumento para comprobar si existe un procesador de comandos.
La librería String.h
string.h es un archivo de la Biblioteca estándar del lenguaje de programación C que contiene la definición de macros, constantes, funciones y tipos de utilidad para trabajar con cadenas de caracteres y algunas operaciones de manipulación de memoria (el nombre string puede ser algo inapropiado).
Las funciones declaradas en string.h se han hecho muy populares, por lo que están
garantizadas para cualquier plataforma que soporte C. Sin embargo, existen algunos problemas de seguridad con estas funciones, como el desbordamiento de buffer (buffer overflow), que hacen que algunos programadores prefieran opciones más seguras frente a la portabilidad que estas funciones ofrecen. Además, las funciones para cadenas de caracteres sólo trabajan con conjuntos de caracteres ASCII o extensiones ASCII compatibles.
Funciones dentro de <string.h>
Dentro de las funciones que nos ofrece la biblioteca encontramos las siguientes:
Nombres Descripción
memmove copia n bytes entre dos áreas de memoria; al contrario que memcpy las áreas deben solaparse
memchr busca un valor a partir de una dirección de memoria dada y devuelve un
puntero a la primera ocurrencia del valor buscado o NULL si no se encuentra
memcmp compara los n primeros caracteres de dos áreas de memoria
memset sobre escribe un área de memoria con un patrón de bytes dado
strcat añade una cadena al final de otra
strncat añade los n primeros caracteres de una cadena al final de otra
strchr localiza un carácter en una cadena, buscando desde el principio
strrchr localiza un carácter en una cadena, buscando desde el final
strcmp compara dos cadenas numéricamente ('a'!='A')
strncmp compara los n primeros caracteres de dos cadenas numéricamente ('a'!='A')
strcoll compara dos cadenas según la colación actual ('a'=='A')
strcpy copia una cadena en otra
strncpy copia los n primeros caracteres de una cadena en otra
strerror devuelve la cadena con el mensaje de error correspondiente al número de
strlen devuelve la longitud de una cadena
strspn devuelve la posición del primer carácter de una cadena que no coincide con
ninguno de los caracteres de otra cadena dada
strcspn devuelve la posición del primer carácter que coincide con alguno de los
caracteres de otra cadena dada
strpbrk encuentra la primera ocurrencia de alguno de los caracteres de una cadena
dada en otra
strstr busca una cadena dentro de otra
strtok parte una cadena en una secuencia de tokens
strxfrm transforma una cadena en su forma de colación (??)
strrev invierte una cadena
Entre todas estas funciones que nos ofrece la string.h podemos considerar las siguientes como las de uso frecuente, en cuanto a esta biblioteca se refiere:
strcpy( )
# include <string.h>
char * strcpy (char * s1, const char * s2);
El strcpy () copia la cadena apuntada por s2 (incluyendo el byte nulo de terminación) en el array apuntado por s1. Si la copia se realiza entre los objetos que se superponen, el
comportamiento es
indefinido.
El strcpy () devuelve s1, sin valor de retorno se reserva para indicar un error.
strlen( ) # include <string.h>
size_t strlen (const char * s);
La función strlen () calcula el número de bytes de la cadena a la que s puntos, sin incluir el byte nulo de terminación.
La función strlen () devuelve la longitud de s, sin valor de retorno se reserva para indicar un error.
strncmp( ) # include <string.h>
int strncmp (const char * s1, const char * s2, size_t n);
El strncmp () compara no más de n bytes (bytes que siguen un byte nulo no se comparan) del array apuntado por s1 con la cadena apuntada por s2. El signo de un valor de retorno distinto de cero se determina por el signo de la diferencia entre los valores de la primera pareja de bytes (ambos interpretados como el tipo unsigned char) que difieren en las cadenas que se comparan.
Si es correcto, strncmp () devuelve un número entero mayor, igual o inferior a 0, si la matriz posiblemente terminada en nulo apuntado por s1 es mayor, igual o inferior a la matriz posiblemente terminada en nulo apuntada por s2 , respectivamente.
strncpy( )
# include <string.h>
char * strncpy (char * s1, const char * s2, size_t n);
cadena apuntada por s1. Si la copia se realiza entre los objetos que se superponen, el
comportamiento es
indefinido.
Si el array apuntado por s2 es una cadena que es menor que n bytes, bytes nulos se añaden a la copia en el array apuntado por s1, hasta que n bytes en todos se escriben.
El strncpy () devuelve s1, sin valor de retorno se reserva para indicar un error.
La librería Time.h
La biblioteca time.h es un archivo de cabecera de la biblioteca estándar del lenguaje de programación C que contiene funciones para manipular y formatear la fecha y hora del sistema.
Función Uso
partir de una estructura tm
clock() Obtener el tiempo transcurrido desde el comienzo de la ejecución del programa
ctime() Obtener una cadena alfanumérica del tipo señalado para asctime a partir de un timestamp.
difftime() Obtener el tiempo en segundos entre dos timestamp.
gmtime() Obtener una fecha GMT en formato tm a partir de un timestamp con la hora local.
localtime() Obtener una fecha en formato tm a partir de un timestamp.
mktime() Obtener un timestamp numérico a partir de una fecha tm.
strftime() Obtener una representación alfanumérica a partir de una fecha tm (acepta un formateo similar a printf)
time() Obtener un timestamp con la fecha y hora del Sistema.
Además de las funciones anteriores, la STL define tres tipos simples: size_t; clock_t, time_t y una estructura tm. En realidad se trata de typedefs dependientes de la implementación.
typedef long time_t;
size_t El tipo size_t es utilizado en muchas ocasiones. Por ejemplo, es el resultado devuelto por el operador sizeof . Es un entero sin signo cuyo tipo exacto depende de la implementación, aunque suele ser de al menos 32 bits (4 Bytes). Normalmente está definido en diversos ficheros de cabecera, entre otros <ctime>, aunque es frecuente que de una cabecera se redireccione a otra donde realmente está definido. En el caso de MS Visual C++ 6.0 y Borland C++size_t es un tipo unsigned int
clock_t Representa el valor devuelto por la función clock. En Borland C++ es un long int
tm Es una estructura utilizada por diversas funciones de la Librería para almacenar información relativa a fecha y hora. Por ejemplo: asctime y localtime. Responde a la definición siguiente:
struct tm {
int tm_sec; // Segundos pasados del minuto (0-61) int tm_min; // Minutos pasados de la hora (0-59) int tm_hour; // Horas desde medianoche (0-23) int tm_mday; // Dia del mes (1-31)
int tm_mon; // Número del mes (0-11)
int tm_year; // Años transcurridos desde 1900 int tm_wday; // Dia de semana (0-6; Domingo = 0) int tm_yday; // Dia del año (0-365)
int tm_isdst; /* Adelanto de hora para horario de verano 1=Si; 0=No; -1=Indefinido */
};
Definición de las funciones de time.h
Asctime( )
La función se presenta en dos versiones: asctime para caracteres normales y _wasctime para caracteres anchos, que responden a los siguientes prototipos:
#include <time.h>
char* asctime(const struct tm* tmPtr); wchar_t* _wasctime(const struct tm* tmPtr);
Descripción:
Ambas funciones aceptan un puntero a una estructura tipo tm , y devuelven un puntero a una cadena de caracteres con información alfanumérica sobre la fecha contenida en la estructura. La cadena es de ancho fijo (26 caracteres), mantiene siempre el mismo formato, y es reescrita cada vez que se invoca la función:
Mon Nov 21 11:31:54 1993\n\0
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // ================== struct tm myt;
myt.tm_sec = 1; myt.tm_min = 30; myt.tm_hour = 9; myt.tm_mday = 22; myt.tm_mon = 11; myt.tm_year = 56; myt.tm_wday = 4; myt.tm_yday = 0; myt.tm_isdst = 0;
char* cTim = asctime(&myt));
cout << "Fecha resultante: " << cTim; return 0;
}
Salida:
Fecha resultante: Thu Dec 22 09:30:01 1956
Clock( )
Prototipo:
#include <time.h> clock_t clock(void);
Descripción:
El valor devuelto representa el número de "tics" del RTC desde el inicio del programa. Es posible calcular este valor en segundos dividiéndolo por una constante denominadaCLK_TCK en unos sistemas y CLOCKS_PER_SEC en otros. Definida en <ctime>.
En el fichero <time.h> del compilador Borland C++ 5.5 encontramos las definiciones siguientes:
#define CLOCKS_PER_SEC 1000.0 #define CLK_TCK 1000.0
Ejemplo:
cout << "Desde el inicio: " << clock()/CLK_TCK << " segundos\n";
Ctime( )
Esta función se presenta en dos versiones: ctime para caracteres normales y _wctime para caracteres anchos. Prototipos:
#include <ctime>
char* ctime(const time_t* sTptr); wchar_t* _wctime(const time_t* sTptr);
Descripción:
Ambas funciones aceptan un puntero a un valor time_t que supuestamente contiene un timestamp expresado en segundos después del inicio de la época UNIX (1 de Enero de 1970 00:00:00 GMT). Por ejemplo un valor devuelto por la función time. Ambas funciones devuelven un puntero a una cadena de 26 caracteres que contiene la fecha y hora con un formato alfanumérico en el que todos los campos tienen siempre el mismo ancho, y que es reescrita cada vez que se invoca a la función (el reloj utilizado es de 24 horas):
Mon Nov 21 11:31:54 1993\n\0
Si la fecha corresponde a un momento anterior a Enero de 1970 se obtiene una cadena nula.
#include <iostream> using namespace std; #include <ctime>
int main() { // ================= time_t tSec = 31536000;
time_t* tPtr = &tSec; char* sTptr = ctime(tPtr); cout << "Fecha: " << sTptr ; return 0;
}
Salida:
Fecha: Fri Jan 01 01:00:00 1971
Difftime( )
Prototipo:
#include <time.h>
double difftime(time_t time2, time_t time1);
Descripción:
La función acepta dos valores tipo time_t y devuelve un double con el tiempo entre ambos valores expresado en segundos.
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // ================= time_t first, second;
delay(2000); // esperar 2 segundos second = time(NULL);
cout << "Diferencia: " << difftime(second, first)) << " segundos\n"; return 0;
}
Gmtime ( )
Prototipo:
#include <time.h>
struct tm* gmtime(const time_t* tPtr);
Descripción:
La función acepta un puntero a un tipo time_t, que suponemos contiene una fecha local (por ejemplo, obtenida con la función time , y devuelve un puntero a una estructura tipotm que contiene la fecha convertida a la hora GMT correspondiente.
Esta función puede ser útil en un programa que maneje comunicaciones por Internet, donde es costumbre utilizar la hora GMT en vez de la hora local.
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // ================= time_t tSac = time(NULL); // instante actual
struct tm* pt1 = localtime(&tSac);
cout << "hh:mm:ss " << pt1->tm_hour << ":" << pt1->tm_min << ":" << pt1->tm_sec << endl;
tm tm2 = *gmtime(&tSac); // deferencia y asignación
cout << "hh:mm:ss " << tm2.tm_hour << ":" << tm2.tm_min << ":" << tm2.tm_sec << endl;
cout << "dd-mm-aaaa: " << tm2.tm_mday << "-" << tm2.tm_mon+1 << "-" << tm2.tm_year+1900 << endl;
return 0; }
Salida:
hh:mm:ss 22:45:2 dd-mm-aaaa: 23-5-2003 hh:mm:ss 5:45:2
dd-mm-aaaa: 24-5-2003
Comentario:
Suponemos que el ordenador está situado en S. Francisco (USA), donde utilizan el horario PDT. En Mayo ya rige el horario de verano que tiene un retraso de 7 horas respecto a la hora Zulú. Cuando en S. Francisco son las 22:45 del día 23, en Greenwich son las 5:45 de la madrugada del día 24.
Localtime( )
Esta función, junto con time, es posiblemente una de las más útiles de entre las que se refieren a asuntos de fecha y hora.
Prototipo:
#include <time.h>
struct tm* localtime(const time_t* timer);
Descripción:
miembros contienen información sobre la fecha introducida. Sus miembros son sobreescritos con cada invocación a la función.
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // =================
char* dS[7] = {"Domingo","Lunes","Martes","Miercoles", "Jueves","Viernes","Sabado"};
time_t tSac = time(NULL); // instante actual struct tm* tmP = localtime(&tSac);
cout << "hh:mm:ss " << tmP->tm_hour << ":" << tmP->tm_min << ":" << tmP->tm_sec << endl;
cout << "dd-mm-aaaa: " << tmP->tm_mday << "-" << tmP->tm_mon+1 << "-" << tmP->tm_year+1900 << endl;
cout << "Dia de semana: " << dS[tmP->tm_wday] << endl; cout << "Dia del año: " << tmP->tm_yday << endl;
cout << "Horario de verano: " << (tmP->tm_isdst ? "Si" : "No") << endl; return 0;
}
Salida:
hh:mm:ss 11:13:23 dd-mm-aaaa: 22-5-2003 Dia de semana: Jueves Dia del año: 141 Horario de verano: Si
Mktime ( )
#include <time.h>
time_t mktime(struct tm* tmPtr);
Descripción:
La función mktime realiza justamente la operación inversa que la anterir localtime. Acepta un puntero a una estructura tm con información sobre una fecha y devuelve un valor tipo time_t con el tiempo en segundos desde el inicio de la época UNIX.
Strftime( )
Esta función se presenta en dos versiones: strftime para caracteres normales y wcsftime para caracteres anchos.
Prototipo:
#include <time.h>
size_t strftime(char* str, size_t maxsize,
const char* fmt, const struct tm* mPt); size_t wcsftime(wchar_t* str, size_t maxsize, const wchar_t* fmt, const struct tm* mPt);
Descripción:
Como puede verse, la función devuelve un tipo size_t, y acepta cuatro argumentos: un puntero-a-carácter str que señala una cadena de caracteres donde se obtendrá el resultado; un tipo size_t maxize; un puntero a cadena de caracteres constante fmt y un puntero mPt a una estructura tm que suponemos contiene datos de una fecha.
La función produce una cadena alfanumérica terminada en un carácter nulo, y la sitúa en el lugar señalado por str. El valor devuelto es la longitud de esta cadena incluyendo el carácter de terminación. En caso de error, o si la longitud resulta mayor que maxsize, el valor devuelto es cero y el resultado obtenido (cadena situada en str) es indeterminado.
Los códigos permitidos son muy numerosos, de forma que puede controlarse todos los detalles de la representación (consulte el manual de su compilador al respecto).
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // ================= time_t tSac = time(NULL); // instante actual tm tms = *localtime(&tSac);
cout << "hh:mm:ss " << tms.tm_hour << ":" << tms.tm_min << ":" << tms.tm_sec << endl;
cout << "dd-mm-aaaa: " << tms.tm_mday << "-" << tms.tm_mon+1 << "-" << tms.tm_year+1900 << endl;
char sRes[80];
size_t r = strftime(sRes, 80,
"Son %M minutos pasados de las %I horas (%Z) %A, %B %d 20%y", &tms);
if (r) cout << sRes; return 0;
}
Salida:
hh:mm:ss 20:14:13 dd-mm-aaaa: 24-5-2003
Son 14 minutos pasados de las 08 horas (WET) Saturday, May 24 2003
Time( )
Prototipo:
#include <ctime>
time_t time(time_t* tPtr);
Descripción:
La función acepta un puntero a time_t y devuelve un valor time_t que es el tiempo en segundos transcurrido desde el inicio de la época UNIX. En realidad puede realizar dos funciones: si se pasa un valor no nulo, el valor correspondiente se almacena en el sitio señalado por el puntero. Si este valor es nulo entonces el valor no se almacena en ningún sitio. En cualquier caso siempre devuelve un valor con el instante actual en segundos desde las 0 horas del 1 de Enero de 1970.
Ejemplo:
#include <iostream> using namespace std; #include <ctime>
int main() { // ================= time_t t1 = 0;
time_t* pt1 = &t1; time(pt1);
cout << "Desde la epoca UNIX " << *pt1 << " segundos\n";
time_t t2 = time(NULL);
cout << "Desde la epoca UNIX " << t2 << " segundos\n"; return 0;
}
Salida:
La librería Math.h
Math.h es un archivo de cabecera de la biblioteca estándar del lenguaje de programación C diseñado para operaciones matemáticas básicas. Muchas de sus funciones incluyen el uso de números en coma flotante. C++ también implementa estas funciones por razones de compatibilidad y las declara en la cabecera cmath.
Funciones dentro de <math.h>
Nombre Descripción
Acos Calcula el valor principal del arco coseno de x. Puede producirse un error de dominio para los argumentos que no estén en el intervalo [-1, +1]
Asin Calcula el valor principal del arco seno de x. Puede producirse un error de dominio para los argumentos que no estén en el intervalo [-1, +1].
Atan Calcula el valor principal del arco tangente de x.
Atan2
Calcula el valor principal del arco tangente de y/x, usando los signos de ambos argumentos para determinar el cuadrante del valor de retorno. Puede producirse un error de dominio si ambos argumentos son cero.
Ceil Calcula el valor integral más pequeño que no sea menor de x.
Cos Calcula el coseno de x (medido en radianes).
Exp Calcula la función exponencial de x.
Fabs Calcula el valor absoluto del número de coma flotante, x.
Floor Calcula el valor integral más grande que no sea mayor de x.
Fmod Calcula el resto de coma flotante de la división de x/y.
Log Calcula el logaritmo natural (o neperiano). Puede producirse un error de dominio si el argumento es negativo. Puede producirse un error de recorrido si el argumento es cero.
Pow Calcula x elevado a la potencia de y. Puede producirse un error de dominio si x es negativo e y no es un valor entero. También se produce un error de dominio si el resultado no se puede representar cuando x es cero e y es menor o igual que cero. Un error de recorrido puede
producirse.
Sqrt Calcula la raíz cuadrada del valor no negativo de x. Puede producirse un error de dominio si x es negativo.
Tan Calcula la tangente de x (medido en radianes).
