LA LIBRERA IOSTREAM.

H
C++ propone una solucin muy interesante al tratar las operaciones de entrada-salida
(E/S) no como una funcin, sino como una clase que implementa una gran capacidad de
formatos para entrada y salida de datos, de sta manera el programador C++ toma slo las
carctersticas que el trabajo requiere. Aunque no hemos definido qu es una clase, tenga en
cuenta que en C++ las operaciones de E/S estn definidas en una clase, ste es un punto
importante. Existen cuatro flujos de E/S (iostreams) predefinidos:
cin, asociado al dispositivo de entrada estndar.
cout, asociado al dispositivo de salida estndar.
cerr, asociado al dispositivo de error estndar.
clog, salida almacenada temporalmente para el dispositivo de error estndar.
Tomando en cuenta lo dicho estamos en condicin de escribir un el programa para
utilizando los flujos de E/S, de sta manera ya no necesitamos el archivos de otras cabeceras
si no el por el archivo iostream.h que nos permite utilizar los flujos de E/S
//******************************************
// entsal.cpp
//******************************************
#include <iostream.h>
int main()
{
float corriente, voltaje, resistencia; // tres variables
cout << "Este programa calcula volaje de acuerdo a la ley de Ohm\n";
cout << "Valor de la corriente, en amperes?\n";
cin >> corriente;
cout << "Valor de la resistencia, en ohms?\n";
cin >> resistencia;
voltaje=corriente*resistencia; // calculo de voltaje
cout << "El valor del voltaje es de " << voltaje << " voltios\n";
return 0;
}

El programa entsal.cpp es importante hacer notar lo siguiente, no se recomienda mezclar la

funcin printf() con el flujo de salida cout en el mismo programa ya que se generaran dos
flujos independientes hacia el mismo dispositivo de salida con resultados impredecibles.
Comparando los dos ltimos programas es fcil asimilar el uso de cin y cout. Utilizamos el
flujo de salida cout en conjuncin con el operador de insercin, << para mostrar un mensaje
en la pantalla del monitor. De manera similar, utilizamos el flujo de entrada cin en conjuncin
con el operador de extraccin, >> para asignar un valor a las variables llamadas corriente y
resistencia. Observe que no es necesario utilizar el operador de direccin y con las variables
de entrada. La lnea 19 demuestra el uso de varios operadores de insercin en una sola lnea
de cdigo, observe que las cadenas y los datos se despliegan en el orden en que se escriben
en la lnea de cdigo, tambien observe el espacio en blanco al final de la primera cadena y al
principio de la segunda cadena de sta lnea de cdigo.
En trminos generales declaramos el archivo de cabecera iostream.h para operaciones de
flujos de E/S, ste suele incluir otros archivos de cabecera adicionales que declaran
funciones, macros, clases y valores necesarios en las operaciones con flujos de entrada
(istream.h), flujos de salida (ostream.h), buffers de flujos (streamb.h) y manipuladores de flujo
(imanip.h) principalmente. Analizaremos stas tres partes por separado.
Utilizando manipuladores
Un manipulador es un valor que podemos extraer insertar de un flujo de E/S para lograr un
efecto especial en estos. Un manipulador parece un objeto que insertamos extraemos de un
flujo pero generalmente solo cambia el estado del mismo. Existen tres manipuladores
comunes, dec, oct y hex los cuales permiten desplegar un valor numrico en base decimal,
octal y hexadecimal respectivamente, y otros ms declarados en el archivo iomanip.h entre los
que figuran setw(), setfill(), setprecision(), setiosflags() y resetiosflags().

Manipuladores bsicos
En el siguiente programa, manipu01.cpp, se demuestra el uso de los manipuladores bsicos
oct, hex, y dec. El programa inicia solicitndole introducir un nmero, mismo que se almacena
en la variable de tipo int llamada numero, en forma predeterminada, el sistema despliega los
valores numricos utilizando la base 10, esto se demuestra en el primer mensaje desplegado
por el programa en la lnea 14. Enseguida se utiliza el operador de insercin (<<) para
introducir el manipulador oct que cambia la base para despliegue numrico a octal por lo que
el valor contenido en la variable llamada numero se despliega en pantalla en su equivalente
de base 8. Observe que el contenido de la variable no ha cambiado, solo se modifica la forma
para desplegar un valor numrico en el dispositivo estndar de salida.
// manipu01.cpp
//*********************************************************
#include <iostream.h>
int main()
{
int numero;
cout <<"Introduzca un numero" << endl;
cin >> numero;
cout <<"El numero introducido en base decimal es: "
<< numero << endl;
cout << oct; // Ahora trabajamos en base octal
cout << "Cambiando a base octal el numero introducido se "
"despliega asi: " << numero << endl;
cout << hex; // Trabajamos en base hexadecimal
cout << "El mismo numero en base hexadecimal es: ";
cout << numero << endl;
cout << "Introduzca otro numero" << endl;
cin >> numero;
cout << "El numero es: " << numero << endl;
cout << dec; // Restituimos la base predeterminada
return 0;
}

De manera similar se utiliza el operador de insercin para introducir ahora el modificador hex
que sirve para cambiar el despliegue numrico a base 16 hexadecimal, entonces el
programa muestra el valor almacenado en numero pero representado en base 16. Cuando
utilizamos los manipuladores oct hex le indicamos al sistema la base numrica que
deseamos para representar nuestros valores numricos, una vez cambiada la representacin
numrica, sta permanece hasta que especifiquemos una nueva base hasta que
apaguemos el sistema, para demostrar sta situacin, en la parte final del programa se le
solicita introducir otro nmero, observar que el despliegue en pantalla parece no coincidir con
el nmero introducido, ste fenmeno sucede porque estamos acostumbrados a pensar en
trminos generales, utilizando la base 10, pero con un anlisis ms cuidadoso encontramos
que no existe error alguno, sencillamente el programa despliega los valores numricos
utilizando el ltimo modificador especificado, que en ste caso es de tipo hexadecimal. El
programa termina utilizando una vez ms el operador de insercin para especificar la base 10
como la deseada para representar los valores numricos en el dispositivo estndar de salida.

EL ARCHIVO IOMANIP.H

El archivo de cabecera llamado iomanip.h define un conjunto de manipuladores adicionales

a los bsicos tratados en el prrafo anterior, generalmente se trata de los siguientes:
setw(), se utiliza con flujos istream y ostream.
setfill(), se utiliza con flujos istream y ostream.
setprecision(), se utiliza con flujos istream y ostream.
setiosflags(), se utiliza con flujos istream.
resetiosflags(), se utiliza con flujos istream y ostream.

Empezamos estudiando el manipulador setw(), ya sea que se utilice con flujos de entrada
(istream) flujos de salida (ostream) establece el ancho de campo al valor especificado dentro
del parntesis del manipulador como se demuestra en el programa manipu02.cpp.
//*********************************************************
// manipu02.cpp
//*********************************************************
#include <iostream.h> // para operaciones de E/S
#include <iomanip.h> // define diferentes manipuladores
int main()
{
int i;
cout << " El ancho de este campo es de 36" << endl;
for(i=1; i<6; i++)
{
cout << setw(i);
cout << "1" << endl;
cout << setw(i);
cout << "12" << endl;
cout << setw(i);
cout << "123" << endl;
cout << endl;
}
cout << setw(36);
cout << "El ancho de este campo es de 36" << endl;
return 0;
}

El manipulador setw(), como ya se dijo, establece el ancho de un campo de salida pero su

efecto solo se aplica a la salida del valor siguiente, la siguiente operacin de insercin
extraccin restablece el valor del ancho del campo a cero que es el valor predeterminado, por
sta razn se utiliza varias veces el manipulador setw() a lo largo del programa manipu02.cpp,
compilndolo podemos apreciar los espacios en blanco a la izquierda del campo de salida que
resultan de especificar diferentes valores de tipo int.

En el siguiente programa de ejemplo, manipula03.cpp, especificamos diferentes valores de

ancho de campo para los datos correspondientes a las calificaciones de un pequeo grupo
ficticio de estudiantes con el objeto de darle al reporte de calificaciones una mejor apariencia,
en ste programa utilizamos el manipulador setfill() para especificar que deseamos rellenar los
espacios en blanco, definidos por el manipulador setw(), con el carcter de punto. Se puede
observar que al utilizar el manipulador setfill() su efecto permanece para todos los flujos de
E/S hasta que se selecciona otro carcter diferente. Al final del programa especificamos
utilizar el carcter de espacio en blanco para rellenar los espacios, que es el carcter
predeterminado.
//*********************************************************
//
manipu03.cpp
//*********************************************************
#include <iostream.h>
#include <iomanip.h>

// para operaciones de E/S

// define diferentes manipuladores

int main()
{
cout << setfill('.');

// rellenar con puntos

cout << "Reporte de calificaciones\n" << endl;

cout << "Roberto Andrade" << setw(20) << "85" << endl;
cout << "Andrea Gutierrez" << setw(19) << "89" << endl;
cout << "Lisseth Sanchez" << setw(20) << "87" << endl;
cout << "Anastasio Castro" << setw(19) << "75" << endl;
cout << "Barbara Clintonsky" << setw(17) << "78" << endl;
cout << "Martin Flores Garcia" << setw(15) << "91" << endl;
cout << setfill('\0'); // se restablece el carcter de llenado
return 0;
}

En el siguiente programa escrito en C++, entsal.cpp, despliega automticamente los dgitos

decimales de acuerdo al clculo realizado, sin embargo, en ciertas aplicaciones puede ser
deseable especificar un nmero determinado de dgitos a desplegar por el flujo de E/S. Para
ste fin se utiliza el manipulador setprecision() en donde podemos especificar mediante un
valor de tipo int el nmero de dgitos a la derecha del punto decimal a desplegar en pantalla,
estudie el programa llamado manipu04.cpp

//*********************************************************
//
manipu04.cpp
//*********************************************************
#include <iostream.h>
#include <iomanip.h>

// para operaciones de E/S

// define diferentes manipuladores

int main()
{
int i;
double variable1=22, variable2=7;
for(i=0; i<15; i++)
{
cout << setprecision(i);
cout << variable1/variable2 << endl;
}
return 0;
}
Ya habr notado que los flujos de E/S tienen ciertos valores predefinidos y que stos valores
se pueden modificar utilizando manipuladores como oct y hex, sucede que los flujos de E/S
tienen un campo para especificar los valores correspondientes y stos campos se llaman
banderas (flags). El archivo de cabecera ios.h define diferentes especificaciones de banderas.
Mediante el uso del manipulador setiosflags() nuestros programas pueden manipular muchas
de stas banderas utilizando a su vez el operador de alcance, identificado por un par de
smbolos de dos puntos (::) y que nos sirve para acceder a una variable de alcance global a
los miembros de una clase. Recuerde que en la siguiente leccin daremos la definicin de una
clase y demostraremos detalladamente el uso del operador de alcance, por lo pronto es
importante que conserve en mente los datos previos de sta leccin pues sern aplicados
prcticamente en todo programa que escriba en C++.

En una determinada seccin del archivo de cabecera ios.h podemos encontrar las
definiciones para las diferentes banderas como un tipo de dato enum, generalmente de la
siguiente manera:
enum
{
skipws

= 0x0001, // Salta espacios en blanco durante la entrada

left

= 0x0002, // justifica a la izquierda

right

= 0x0004, // justifica a la derecha

internal = 0x0008, // relleno despus de signo indicador de base

dec

= 0x0010, // base decimal

oct

= 0x0020, // base octal

hex

= 0x0040, // base hexadecimal

showbase = 0x0080, // muestra indicador de base durante la salida

showpoint = 0x0100, // punto decimal obligatorio en float
uppercase = 0x0200, // salida hex en maysculas
showpos

= 0x0400, // signo positivo obligatorio

scientific = 0x0800, // notacin de tipo 3.145363E23

fixed
unitbuf
stdio
};

= 0x1000, // dgitos decimales predeterminados

= 0x2000, // desaloja flujos despus de insercin
= 0x4000 // desaloja stdout, stderr despus de insercin

Puede identificar fcilmente algunos de los manipuladores que ya hemos estudiado y ahora
veremos cmo se utilizan stas banderas mediante el manipulador setiosflags() y cmo
restituimos las condiciones originales mediante el manipulador resetiosflags(), estudie y
compile el siguiente ejemplo, manipu05.cpp, adems experimente con las banderas no
incluidas en el programa, estoy seguro que no presentar problema alguno comprender el uso
de las diferentes banderas.
//***********************************************
//
manipu05.cpp
//***********************************************
#include <iostream.h>
#include <iomanip.h>
int main()
{
int numero;
cout << "Introduzca un numero:\n";
cin >> numero;
cout << "El valor introducido en base 10 es: " << numero
<< endl;
cout << setiosflags(ios::oct);
cout << "en base octal es: " << numero << endl;
cout << setiosflags(ios::hex);
cout << "y en base hexadecimal es: " << numero << endl;
cout << setiosflags(ios::uppercase|ios::showbase);
cout << "utilizando los manipuladores uppercase y showbase"
" el valor es: " << numero << endl;
cout << resetiosflags(ios::hex);
cout << "Ahora el valor se representa en base octal asi: "
<< numero << endl;
cout << resetiosflags(ios::uppercase|ios::showbase|ios::oct);
cout << setiosflags(ios::showpos|ios::showpoint|ios::fixed);
cout << "Ahora el valor es: " << (float)numero << endl;
cout << resetiosflags(ios::showpos|ios::showpoint|
ios::fixed);
cout << "El valor es " << numero << endl;
return 0;
}

El programa manipu05.cpp empieza solicitndole un nmero el cual es desplegado

inmediatamente para demostrar los ajustes predeterminados para los flujos de E/S, despus
se utiliza la bandera oct para representar el valor introducido en base octal, luego de mostrar
el valor en pantalla se vuelve a utilizar la bandera hex sta vez para mostrar el nmero
introducido en base hexadecimal. En sta parte del programa, lnea 19, es conveniente hacer
notar que hemos modificado dos veces la representacin que deseamos darle a los flujos de
E/S, en ste orden, primero indicamos que deseamos la base octal y posteriormente la base
hexadecimal, si despus de la lnea 19 utilizamos el manipulador setiosflags(ios::oct) la
representacin de los flujos de E/S no ser en base octal sino en hexadecimal, entonces, si
deseamos nuevamente la representacin del valor numrico introducido en base octal
necesitamos reestablecer la bandera oct anteriormente establecida en la lnea 15, para esto
utilizamos el manipulador resetiosflags() como est ilustrado en la lnea 23 y posteriormente
en las lneas 26 y 29 del programa. Cuando sea necesario especificar varias banderas
podemos hacer uso del operador OR tanto con el manipulador setiosflags() como con
resetiosflags() tal y como se puede apreciar en las lneas 20, 26, 27 y 30 del programa.
//
manipu05.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{
int numero;
cout << "Introduzca un numero:\n";
cin >> numero;
cout << "El valor introducido en base 10 es: " << numero
<< endl;
cout << setiosflags(ios::oct);
cout << "en base octal es: " << numero << endl;
cout << setiosflags(ios::hex);
cout << "y en base hexadecimal es: " << numero << endl;
cout << setiosflags(ios::uppercase|ios::showbase);
cout << "utilizando los manipuladores uppercase y showbase"
" el valor es: " << numero << endl;
cout << resetiosflags(ios::hex);
cout << "Ahora el valor se representa en base octal asi: "
<< numero << endl;
cout << resetiosflags(ios::uppercase|ios::showbase|ios::oct);
cout << setiosflags(ios::showpos|ios::showpoint|ios::fixed);
cout << "Ahora el valor es: " << (float)numero << endl;
cout << resetiosflags(ios::showpos|ios::showpoint|
ios::fixed);
cout << "El valor es " << numero << endl;
return 0;
}

EL CONTENIDO <DE CTYPE.H>

Librera <El ctype.h> contiene los prototipos para las funciones de las docena clasificaciones
del carcter. Todas estas funciones exceptan isdigit y isxdigit sea locale-especfico; su
comportamiento puede cambiar si el locale cambia.
Contiene los prototipos de las funciones y macros de clasificacin de caracteres.
Funciones:
tolower
toupper

Macros:
isalnum
isdigit
ispunct
toascii
Tabla de referencia rpida:
Funcin
isalnum
isalpha
isascii
iscntrl
isdigit
isgraph
islower
isprint
ispunct
isspace
isupper
isxdigit

isalpha
isgraph

isascii
islower

iscntrl
isprint

isspace

isupper

isxdigit

Valores
(A - Z o a - z) o (0 - 9)
(A - Z o a - z)
0 - 127 (0x00-0x7F)
(0x7F o 0x00-0x1F)
(0 - 9)
Imprimibles menos ' '
(a - z)
Imprimibles incluido ' '
Signos de puntuacin
espacio, tab, retorno de lnea, cambio de lnea, tab vertical, salto de pgina
(0x09 a 0x0D, 0x20).
(A-Z)
(0 to 9, A to F, a to f)

Funcin tolower
int tolower(int ch);
Convierte un carcter, en un parmetro entero ch, a minscula.
Valor de retorno:
ch debe estar en el rango 0 a 255, y si est entre A y Z lo convierte a su equivalente en el
rango a a z, el resto de los valores no son modificados. El valor de retorno es el valor
convertido si ch era una mayscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diresis, en mayscula y la no sufren
modificaciones.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "ESTO ES UNA CADENA DE PRUEBA";
int i;
for(i = 0; cadena[i]; i++)
cadena[i] = tolower(cadena[i]);
printf("%s\n", cadena);
return 0;
}

Funcin toupper
int toupper(int ch);
Convierte un carcter, en un parmetro entero ch, a mayscula.
Valor de retorno:
ch debe estar en el rango 0 a 255, y si est entre a y z lo convierte a su equivalente en el
rango A a Z, el resto de los valores no son modificados. El valor de retorno es el valor
convertido si ch era una minscula, o el valor original en caso contrario.
Nota: los caracteres en acentuados, o con diresis, en minscula y la no sufren
modificaciones.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "esto es una cadena de prueba";
int i;
for(i = 0; cadena[i]; i++)
cadena[i] = toupper(cadena[i]);
printf("%s\n", cadena);
return 0;
}

Macro isalnum

int isalnum(int c);

Comprueba sin un carcter es alfanumrico.
isalnum es una macro que verifica el entero c pertenece al rango de letras (A a Z o a a z) o al
de dgitos (0 a 9), por defecto. La verificacin se hace mediante una tabla, y su
comportamiento depende le la categora LC_CTYPE actual.
Valor de retorno:
El valor de retorno ser no nulo si c es una letra o un nmero, y cero en caso contrario.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isalnum(cadena[i]));
return 0;
}

Macro isdigit
int isdigit(int c);
Comprueba sin un carcter es un dgito decimal.
isdigit es una macro que verifica el entero c pertenece al rango caracteres de digitos
decimales, que depende de la categora local LC_CTYPE, por defecto, el rango es de ('0' a
'9').
Valor de retorno:
El valor de retorno ser no nulo si c es un dgito decimal.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0fR(4h&~?R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isdigit(cadena[i]));
return 0;
}

Macro ispunct
int ispunct(int c);
Comprueba sin un carcter es correspondiente a un signo de puntuacin.
ispunct es una macro que verifica el entero c pertenece al rango de caracteres de los signos
de puntuacin, que por defecto son todos menos los alfanumricos y el blanco ' '. El
comportamiento depende de la categora local de LC_CTYPE.
Valor de retorno:
El valor de retorno ser no nulo si c es un signo e puntuacin.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAb.Bc/Cd(D3:1&,75%$/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], ispunct(cadena[i]));
return 0;

Macro toascii
int toascii(int c);
Convierte caracteres a formato ASCII.
toascii es una macro convierte el entero c a ASCII eliminando todos los bits menos los siete
de menor peso. Eso proporciona un valor dentro del rango entre 0 y 127.
Valor de retorno:
El valor de retorno ser el valor de c convertido.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %c\n", cadena[i], toascii(cadena[i]));
return 0;
}

Macro isalpha
int isalpha(int c);
Comprueba sin un carcter es alfabtico.
isalpha es una macro que verifica el entero c pertenece al rango de letras (A a Z o a a z), por
defecto. La verificacin se hace mediante una tabla, y su comportamiento depende le la
categora LC_CTYPE actual.
Valor de retorno:
El valor de retorno ser no nulo si c es una letra y cero en caso contrario.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isalpha(cadena[i]));
return 0;
}

Macro isgraph
int isgraph(int c);
Comprueba sin un carcter es imprimible.
isgraph es una macro que verifica el entero c pertenece al rango de caracteres con
representacin grfica, que por defecto son todos menos el espacio ' '. El comportamiento
depende de la categora local de LC_CTYPE.
Valor de retorno:
El valor de retorno ser no nulo si c es un carcter grfico.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0 sR(h &~?R 1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isgraph(cadena[i]));
return 0;
}

Macro isspace
int isspace(int c);
Comprueba sin un carcter es de tipo espacio.
isspace es una macro que verifica el entero c pertenece grupo de caracteres de espacio, ' ',
tab, retorno de carro, nueva lnea, tabulador vertical o salto de pgina. El comportamiento
depende de la categora local de LC_CTYPE.
Valor de retorno:
El valor de retorno ser no nulo si c es un carcter de tipo espacio.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0 sR\n(h &~?\177R\t 1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isspace(cadena[i]));
return 0;
}

Macro isascii
int isascii(int c);
Comprueba sin un carcter pertenece al ASCII de 7 bits.
isascii es una macro que verifica el entero c pertenece al rango de (0 a 127). Esta macro est
definida para todos lo valores enteros.
Valor de retorno:
El valor de retorno ser no nulo si c est en el rango entre 0 y 127, en hezadecimal entre 0x00
y 0x7f.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0sR(h&~?R1/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isascii(cadena[i]));
return 0;
}

Macro islower
int islower(int c);
Comprueba sin un carcter es de tipo minscula.
islower es una macro que verifica el entero c pertenece al rango de caracteres de letras
minsculas, que por defecto son los que estn en el rango a a z. El comportamiento depende
de la categora local de LC_CTYPE.
Valor de retorno:
El valor de retorno ser no nulo si c es un carcter en minscula.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAbBcCdD31&75$/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], islower(cadena[i]));
return 0;
}

Macro isupper
int isupper(int c);
Comprueba sin un carcter es de tipo mayscula.
islower es una macro que verifica el entero c pertenece al rango de caracteres de letras
maysculas, que por defecto son los que estn en el rango A a Z. El comportamiento depende
de la categora local de LC_CTYPE.
Valor de retorno:
El valor de retorno ser no nulo si c es un carcter en mayscula.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = "aAbBcCdD31&75$/";
int i;
for(i = 0; cadena[i]; i++)
printf("%c, %d\n", cadena[i], isupper(cadena[i]));
return 0;
}

Macro iscntrl
int iscntrl(int c);
Comprueba sin un carcter es de control.
iscntrl es una macro que verifica el entero c pertenece al rango caracteres de control, que
depende de la categora local LC_CTYPE, por defecto, el rango es de (0x00 a 0x1F y 0x7F).
Valor de retorno:
El valor de retorno ser no nulo si c es un carcter "delete" o un carcter de control.
Ejemplo:
#include <stdio.h>
#include <ctype.h>
int main()
{
char cadena[] = ";0s\003R(h\177&~?\037R1/";
int i;
for(i = 0; cadena[i]; i++)
if(isprint(cadena[i]))
printf("%c, %d\n", cadena[i], iscntrl(cadena[i]));
else
printf("%d, %d\n", cadena[i], iscntrl(cadena[i]));
return 0;
}

LIBRERA # INCLUDE <STDLIB.H>

Para usar todas las funciones de sta biblioteca se debe tener la siguiente directiva
#include <stdlib.h>
Las funciones de la biblioteca pueden ser agrupadas en tres categoras bsicas:
Aritmticas;
Nmeros aleatorios; y
Conversin de cadenas.
El uso de todas las funciones es sencillo. Se consideran dentro del captulo en forma breve.
Funciones aritmticas
Hay cuatro funciones enteras bsicas:
int abs(int j);
long int labs(long int j);
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
Fundamentalmente hay dos funciones para enteros y para compatibilidad con enteros largos.

abs() La funcin regresa el valor absoluto del argumento entero j.

div() Calcula el valor numer entre denom y devuelve el cociente y el resto en una
estructura llamada div_t que contiene dos miembros llamados quot y rem.

La estructura div_t esta definida en stdlib.h como sigue:

typedef struct {
int quot; /* cociente */
int rem; /* residuo */
}

La estructura ldiv_t es definida de una forma similar.

Se muestra un ejemplo donde se hace uso de la funcin div_t:
#include <stdlib.h>
main()
{
int num=8, den=3;
div_t res;
res = div(num,den);
printf("Respuesta:\n\t Cociente = %d\n\t Residuo = %d\n",
res.quot, res.rem);
}
Que genera la siguiente salida:
Respuesta:
Cociente = 2
Residuo = 2
14.2 Nmeros aleatorios
Los nmeros aleatorios son tiles en programas que necesitan simular eventos aleatorios,
tales como juegos, simulaciones y experimentos. En la prctica ninguna funcin produce
datos aleatorios verdaderos -- las funciones producen nmeros pseudo-aleatorios. Los
nmeros aleatorios son calculados a partir de una frmula dada (los distintos generadores
usan diferentes frmulas) y las secuencias de nmeros que son producidas se repiten. Una
semilla (seed) es usualmente inicializada para que la secuencia sea generada. Por lo tanto, si
la semilla es siempre inicializada con el mismo valor todo el tiempo, el mismo conjunto ser
siempre calculado.
Una tcnica comn para introducir ms aleatoriedad en el generador de nmeros aleatorios es
usando el tiempo y la fecha para inicializar la semilla, ya que ste siempre estar cambiando.
Hay muchas funciones de nmeros (pseudo) aleatorios en la biblioteca estndar. Todas ellas
operan con la misma idea bsica pero generan secuencias diferentes de nmeros (basadas
en funciones generadoras diferentes) sobre rangos diferentes de nmeros.

El conjunto ms simple de funciones es:

int rand(void);
void srand(unsigned int semilla);

rand() La funcin devuelve un entero pseudo-aleatorio entre 0 y

(RAND_MAX).
srand() Establece su argumento como la semilla de una nueva serie de enteros
pseudo-aleatorios.
Un ejemplo sencillo del uso del tiempo de la fecha es inicializando la semilla a travs de una
llamada:
srand( (unsigned int) time( NULL ) );
Existen unas cuantas funciones para convertir cadenas a enteros, enteros largos y
valores flotantes. Estas son:
double atof(const char *cadena) Convierte una cadena a un valor flotante.
int atoi(const char *cadena) Convierte una cadena a un valor entero.
int atol(const char *cadena) Convierte una cadena a un valor entero largo.
double strtod(const char *cadena, char **finap) Convierte una cadena a un valor de
punto flotante.
double strtol(const char *cadena, char *finap, int base) Convierte una cadena a un
entero largo de acuerdo a una base dada, la cual deber estar entre 2 y 36 inclusive.
unsigned long strtoul(const char *cadena, char *finap, int base) Convierte una
cadena a un entero largo sin signo.
La biblioteca stdlib.h tiene dos funciones tiles para hacer bsqueda y ordenamiento de
datos de cualquier tipo. La funcin qsort() ya fue vista previamente en la seccin 10.3.
Para completar la lista se anota el prototipo, pero para ver un ejemplo pasar al captulo
indicado.
La funcin qsort de la biblioteca estndar es muy til, ya que esta diseada para
ordenar un arreglo por un valor llave de cualquier tipo en orden ascendente, con tal de
que los elementos del arreglo sean de un tipo fijo.
El prototipo de la funcin de acuerdo a stdlib.h es:
void qsort(void *base, size_t nmiemb, size_t tam,
o int (*compar)(const void *, const void *));

LIBRERA TIME.H
time.h es un archivo de cabecera de la biblioteca estndar del lenguaje de programacin C
que Contenido
Funciones
Constantes
Tipos de datos
Fecha (da/hora) de calendario
Funciones

Nombre

Descripcin

char * asctime(struct Recibe una variable de tipo puntero a estructura tm (struct tm*) y
tm *)
devuelve una cadena de caracteres cuyo formato es:
"Www Mmm dd hh:mm:ss yyyy\n" (ej: Tue May 15 19:07:04
2008\n)

clock_t clock (void)

Devuelve el nmero de pulsos de reloj desde que se inici el

proceso

char * ctime(time t *)

Recibe una variable de tipo puntero a time t (time t*) y devuelve

una cadena con el mismo formato que asctime()

double difftime(time t, Recibe dos variables de tipo time t, calcula su diferencia y devuelve
time t)
el resultado (double) expresado en segundos.

Nombre

Descripcin

struct tm *gmtime(time
t *)

Recibe un puntero a una variable de tiempo (time t*) y devuelve su

conversion como fecha/hora UTC a struct tm a travs de un
puntero.

struct
*localtime(time t *)

tm Similar funcionalidad a gmtime(), pero devuelve la conversin como

fecha/hora LOCAL.

time t mktime(struct tm Inversamente a gmtime() y localtime(),l recibe un puntero a struct

*)
tm (struct tm*) y devuelve su conversin al tipo time t.

time t time(time t *)

Devuelve la fecha/hora (time t) actual o -1 en caso de no ser

posible. Si el argumento que se le pasa no es NULL, tambin
asigna la fecha/hora actual a dicho argumento.

size_t
strftime(char Formatea la informacin pasada mediante la estructura (struct tm*)
*,size_t,char *,struct tm mediante el formato indicado en una cadena (char*) e imprime el
*)
resultado sobre otra cadena (char*) hasta un lmite de caracteres
(size_t).

 Constantes

Nombre

Descripcin

CLK_PER_SEC

Constante que define el nmero de pulsos de reloj por segundo; usado

por la funcin clock()

CLOCKS_PER_SEC nombre alternativo para CLK_PER_SEC usado en su lugar en algunas

bibliotecas

CLK_TCK

usualmente una macro para CLK_PER_SEC

Tipos de datos

Nombre

Descripcin

clock_t

tipo de dato devuelto por clock(), generalmente un long int

time t

tipo de dato devuelto por time(), generalmente un long int

struct
tm

representacin del tiempo en formato de calendario (fecha/hora)

 Fecha (da/hora) de calendario

La fecha de calendario se representa como la estructura struct tm, que consta de los
siguientes atributos:

Atributo
Descripcin
int tm_hour

hora (0 - 23)

int tm_isdst

Horario de verano enabled/disabled

int tm_mday

da del mes (1 - 31)

int tm_min

minutos (0 - 59)

int tm_mon

mes (0 - 11, 0 = Enero)

int tm_sec

segundos (0 - 60)

int tm_wday

da de la semana (0 - 6, 0 = domingo)

int tm_yday

da del ao (0 - 365)

int tm_year

ao desde 1900

LIBRERA STRING.H
string.h es el jefe en Biblioteca del estndar de C para Lenguaje de programacin de C cul
contiene macro definiciones, constantes, y declaraciones de las funciones y de los tipos
usados no slo para secuencia direccin pero tambin varia memoria que manejan funciones;
el nombre es as algo de un misnomer.
Las funciones declararon adentro string.h sea extremadamente popular, desde como parte de
Biblioteca del estndar de C, estn garantizados para trabajar en cualquier plataforma cules
apoyan la C. Sin embargo, algunas ediciones de seguridad existen con estas funciones, por
ejemplo desbordamientos del almacenador intermediario, programadores principales para
preferir variantes ms seguras, posiblemente menos portables. Tambin, las funciones de la
secuencia trabajan solamente con ASCII o juegos de caracteres tal como los cuales ample el
ASCII de una manera compatible ISO-8859-1; juegos de caracteres ASCII-compatibles del
multibyte por ejemplo UTF-8 trabajar con la advertencia que la secuencia longitud es ser
interpretado como la cuenta de octetos en la secuencia ms bien que la cuenta de Unicode
caracteres. La direccin compatible de la secuencia No-ASCII se alcanza generalmente a
travs wchar.h.
Contenido
Constantes y tipos
Funciones
Extensiones a ISO C
Acoplamientos externos
Constantes y tipos

Nombre

Notas

FALTA
DE Macro que se ampla a puntero nulo constante; es decir, una constante
INFORMACIN
que representa un valor del puntero que est garantizado no para ser
una direccin vlida de un objeto en memoria.
size_t

Un sin firmar nmero entero tipo que es el tipo del resultado del size of
operador.

Funciones

Nombre

Notas

vaco *memcpy(*src ms *dest, del Copia octetos de n entre dos reas de memoria, que
const vaco, size_t vacos n);
no deben traslaparse

*memmove vaco (*src ms *dest, Copia octetos de n entre dos reas de memoria;
del const vaco, size_t vacos n);
desemejante de con memcpy las reas pueden
traslaparse

*memchr vaco (*s vacos del Vuelve un indicador a la primera ocurrencia de c en los
const, c interna, size_t n);
primeros octetos de n de s, o de FALTA DE
INFORMACIN si no encontrada

memcmp interno (const *s1 vaco, Compara los primeros caracteres de n de dos reas de
const *s2 vaco, size_t n);
memoria

*memset vaco (vaco *, interno, Sobreescribe un rea de memoria con un patrn del
size_t);
octeto

carbn *strcat(carbn ms *dest, Aade el src de la secuencia al dest

*src del carbn del const);

Nombre

Notas
Aade a lo ms los caracteres de n del src de la
secuencia al dest

*strncat del carbn (carbn *,

carbn del const *, size_t);
*strchr del carbn (carbn del Localiza un carcter en una secuencia, buscando del
const *, interno);
principio

*strrchr del carbn (carbn del Localiza un carcter en una secuencia, buscando del
const *, interno);
extremo
interno strcmp(carbn del const *, Compara dos secuencias numricamente
carbn del const *);

strncmp interno (carbn del const Compara hasta los primeros octetos de n de dos
*, carbn del const *, size_t);
secuencias numricamente
strcoll interno (carbn del const *, Compara dos secuencias usando la corriente locales
carbn del const *);
orden de compaginacin
carbn *strcpy(*toHere del carbn, Copia una secuencia a partir de una localizacin a otra
*fromHere del carbn del const);

carbn *strncpy(*toHere del

carbn, *fromHere del carbn del
const, size_t);

Copias hasta octetos de n de una secuencia a partir de

una localizacin a otra

Nombre

Notas
Vuelve la representacin de la secuencia de un
nmero del error e.g. errno (roscar-no seguro)

carbn *strerror(interno);
size_t strlen(carbn del const *);

Encuentra la longitud de a Secuencia de C

strspn del size_t (*s del carbn del Determina la longitud de la subsecuencia inicial
const, *accept del carbn del mxima de s que consiste enteramente en caracteres
const);
adentro aceptan
strcspn del size_t (*s del carbn Determina la longitud de la subsecuencia inicial
del const, *reject del carbn del mxima de s que consiste enteramente en caracteres
const);
no en rechazo
*strpbrk del carbn (*s del carbn Encuentra la primera ocurrencia de cualquier carcter
del const, *accept del carbn del adentro para aceptar en s
const);
*strstr del carbn (*haystack del Encuentra la primera ocurrencia de la secuencia
carbn del const, *needle del aguja en la secuencia ms larga haystack.
carbn del const);
*strtok del carbn
carbn del const *);

(carbn

*, analiza una secuencia en una secuencia del smbolo;

no-rosque la caja fuerte en espec., no-reentrante

strxfrm del size_t (carbn ms Transforma el src en una forma de compaginacin, tal
*dest, *src del carbn del const, que la pedido numrica de la clase de la secuencia
size_t n);
transformada es equivalente a la pedido de
compaginacin del src.

Extensiones a ISO C

Nombre

Notas

Especificacin

carbn *strdup(carbn del asigna y duplica una secuencia en POSIX; originalmente

const *);
memoria
una extensin del DEB
errno_t
strcpy_s(*restrict variante
s1 del carbn, rsize_t strcpy
s1max, *restrict s2 del
carbn del const);

limitar-comprobada

de ISO/IEC WDTR 24731

*mempcpy vaco (*src ms variante de memcpy volver un GNU

*dest, del const vaco, indicador al octeto despus del
size_t vacos n);
octeto escrito pasado
copias hasta octetos de n entre dos UNIX 98?
*memccpy vaco (la ms reas de memoria, que no deben
*dest vaco, *src vaco del traslaparse, parando cuando se
const, c interna, size_t n
encuentra el octeto c
);
*strerror_r interno (interno, vuelve la representacin de la
carbn *, size_t);
secuencia de un nmero del error
e.g. errno (roscar-seguro; algunas
diferencias en la semntica en
medio GNU y XSI/POSIX)
size_t strlcpy(carbn ms variante limitar-comprobada de
*dest, *src del carbn del strcpy
const, size_t n);
*strtok_r
del
carbn versin roscar-segura del strtok
(carbn *, carbn del const
*, ** del carbn);
*strsignal del carbn (sig
interno);

GNU, POSIX

originalmente
OpenBSD,
ahora
tambin
FreeBSD,
Solaris, OS X del Mac
POSIX

FUENTES DE INFORMACIN

Como programar en C/C++. H.M. Deitel / P.J. Deitel. Prentice may, 2da ed. 1995.
Programacin orientada a objetos con C++. Fco. Javier Ceballos. Ed. ra-ma 1993.
Programacin en C++. Enrique Hernndez / Jos Hernndez. Ed. Paraninfo 1993.
EN INTERNET
www.lawebdelprogramador.com
http://www.publispain.com/supertutoriales/programacion