Versión 3.0

800x600 mínimo
En esta lección:

Comentarios en C++
-----
El archivo iostream.h
-----
Manipuladores
-----
El archivo iomanip.h
-----
Funciones de salida
-----
Funciones de entrada
-----
Descargas
-----


Otras secciones:

Conceptos básicos
-----
Programando en C
-----
Programando en C++
-----
Programando Windows 9x.
-----
Teoría electrónica
-----
Circuitos electrónicos
-----
Actividades adicionales
-----
Hipervínculos
-----


Contácteme:

Dudas y comentarios
-----


 Hola mundo

     De acuerdo a su definición, C++ es una extensión del lenguaje C, un supercunjunto, esto implica para quién decide iniciar sus estudios en C++ que para empezar dispone de un lenguaje completo como soporte a los nuevos conceptos introducidos por C++, esto significa que todo lo que podemos programar en ANSI-C funciona en C++ y esto a su vez es una buena razón para afirmar la importancia que tiene en el aprendizaje de C++ el conocimiento previo del lenguaje C, por lo tanto se supone que el lector está familiarizado con todo lo expuesto en el curso en línea de la sección programando en C.

Hola mundo

Comentarios en C++ 

     Es natural tratar en primer lugar la manera de hacer comentarios en el código fuente de un programa escrito en C++, y para probar la afirmación hecha en el párrafo anterior, el siguiente código escrito en C debe compilar perfectamente. Le llamaremos al código comenta1.cpp, habrá notado que la extensión *.cpp se refiere a C-plus-plus. Un compilador de C++ sabe que el código está escrito en C++ precisamente por la extensión del archivo que contiene el código fuente.


/******************************************/
/* comenta1.cpp                           */
/******************************************/

#include <stdio.h>

int main()
{
    float corriente, voltaje, resistencia; /* tres variables */

    printf("Este programa calcula volaje de acuerdo a la ley de Ohm\n");
    printf("Valor de la corriente, en amperes?\n");
    scanf("%f", &corriente);
    printf("Valor de la resistencia, en ohms?\n");
    scanf("%f", &resistencia);

    voltaje=corriente*resistencia; /* calculo de voltaje */

    printf("El valor del voltaje es de %f voltios\n", voltaje);

    return 0;
}

     Aunque se trata de un programa escrito en C, por la sencilla razón de que el archivo de código fuente lleva la extensión *.cpp, el compilador lo trata como un código C++ válido, esto demuestra la total compatibilidad de que disponemos al programar en C++ con respecto al lenguaje C. Empero C++ introduce una manera más práctica de hacer comentarios al utilizar doblemente el símbolo de barra inclinada para indicarle al compilador que el resto de la línea de código que sigue a la doble barra inclinada es un comentario y por lo tanto debe ignorarse en el proceso de compilación. Al contrario del mecanismo para hacer comentarios en C que puede abarcar varias líneas de código, el estilo utilizado en C++ sólo es válido hasta el final del renglón en donde es utilizada la doble barra inclinada. Ahora nuestro programa lo modificamos para utilizar comentarios en C++:


//******************************************
// comenta2.cpp
//******************************************

#include <stdio.h>

int main()
{
    float corriente, voltaje, resistencia; // tres variables

    printf("Este programa calcula volaje de acuerdo a la ley de Ohm\n");
    printf("Valor de la corriente, en amperes?\n");
    scanf("%f", &corriente);
    printf("Valor de la resistencia, en ohms?\n");
    scanf("%f", &resistencia);

    voltaje=corriente*resistencia; // calculo de voltaje


    printf("El valor del voltaje es de %f voltios\n", voltaje);

    return 0;
}

     Se aprecia de inmediato la comodidad del nuevo estilo de introducir comentarios en el código fuente de C++ además del doble beneficio que representa el poder seguir utilizando los comentarios en C. Se debe tener ciertas precauciones al manejar los comentarios pues aunque C++ reconoce ambos métodos, el estándar ANSI-C en sí no reconoce la mecánica de C++ para los comentarios, dicho en otras palabras, no escriba código en ANSI-C pensando en términos de C++, lo contrario, como ya lo probamos, es perfectamente válido.

Volver al principio

Hola mundo

La librería iostream.h 

     Aunque comenta2.cpp es un programa C++ válido sabemos que es en realidad un programa escrito en C y nosotros estamos interesados en aprender los aspectos nuevos introducidos en C++, pues bien, un cambio muy importante es en la manera en que se maneja la entrada y salida de datos en el programa. Al igual que en C, C++ no incluye operaciones de entrada y salida como parte del lenguaje en sí, en cambio define la librería iostream que agrega funciones de entrada y salida muy elegantes. Al programar en C nos familiarizamos con el archivo stdio.h en donde está definida entre otras, la función printf() que como sabemos sirve para escribir datos en el dispositivo estándar de salida, que en la gran mayoría de los casos es el monitor de la computadora. Como la función printf() se desarrolló casi desde los origenes de C, la función ha sufrido una serie de transformaciones que la ha hecho crecer en tamaño, como resultado de esto, cuando incluimos la función printf() en nuestro programa C tambien incluimos todas las opciones agregadas con el tiempo aunque no las utilicemos. Un caso similar sucede con la función scanf().

     C++ propone una solución muy interesante al tratar las operaciones de entrada-salida (E/S) no como una función, sino como una clase que implementa una gran capacidad de formatos para entrada y salida de datos, de ésta manera el programador C++ toma sólo las carácterísticas que el trabajo requiere. Aunque no hemos definido qué es una clase, tenga en cuenta que en C++ las operaciones de E/S están definidas en una clase, éste es un punto importante. Existen cuatro flujos de E/S (iostreams) predefinidos:

  • cin, asociado al dispositivo de entrada estándar.
  • cout, asociado al dispositivo de salida estándar.
  • cerr, asociado al dispositivo de error estándar.
  • clog, salida almacenada temporalmente para el dispositivo de error estándar.

     Tomando en cuenta lo dicho estamos en condición de modificar el programa anterior para utilizar los flujos de E/S, de ésta manera ya no necesitamos el archivo de cabecera stdio.h el cual lo hemos sustituido 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 idéntico a comenta2.cpp, sin embargo es importante hacer notar lo siguiente, no se recomienda mezclar la función printf() con el flujo de salida cout en el mismo programa ya que se generarían dos flujos independientes hacia el mismo dispositivo de salida con resultados impredecibles. Comparando los dos últimos programas es fácil asimilar el uso de cin y cout. Utilizamos el flujo de salida cout en conjunción con el operador de inserción, << para mostrar un mensaje en la pantalla del monitor. De manera similar, utilizamos el flujo de entrada cin en conjunción con el operador de extracción, >> para asignar un valor a las variables llamadas corriente y resistencia. Observe que no es necesario utilizar el operador de dirección & con las variables de entrada. La línea 19 demuestra el uso de varios operadores de inserción en una sola línea de código, observe que las cadenas y los datos se despliegan en el orden en que se escriben en la línea de código, tambien observe el espacio en blanco al final de la primera cadena y al principio de la segunda cadena de ésta línea de código.

     En términos 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.

Volver al principio

Hola mundo

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 numérico en base decimal, octal y hexadecimal respectivamente, y otros más declarados en el archivo iomanip.h entre los que figuran setw(), setfill(), setprecision(), setiosflags() y resetiosflags().

Manipuladores básicos

     En el siguiente programa, manipu01.cpp, se demuestra el uso de los manipuladores básicos oct, hex, y dec. El programa inicia solicitándole introducir un número, mismo que se almacena en la variable de tipo int llamada numero, en forma predeterminada, el sistema despliega los valores numéricos utilizando la base 10, esto se demuestra en el primer mensaje desplegado por el programa en la línea 14. Enseguida se utiliza el operador de inserción (<<) para introducir el manipulador oct que cambia la base para despliegue numérico 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 numérico en el dispositivo estándar 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 inserción para introducir ahora el modificador hex que sirve para cambiar el despliegue numérico 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 numérica que deseamos para representar nuestros valores numéricos, una vez cambiada la representación numérica, ésta permanece hasta que especifiquemos una nueva base ó hasta que apaguemos el sistema, para demostrar ésta situación, en la parte final del programa se le solicita introducir otro número, observará que el despliegue en pantalla parece no coincidir con el número introducido, éste fenómeno sucede porque estamos acostumbrados a pensar en términos generales, utilizando la base 10, pero con un análisis más cuidadoso encontramos que no existe error alguno, sencillamente el programa despliega los valores numéricos utilizando el último modificador especificado, que en éste caso es de tipo hexadecimal. El programa termina utilizando una vez más el operador de inserción para especificar la base 10 como la deseada para representar los valores numéricos en el dispositivo estándar de salida.

     Para más información en relación con los sistemas numéricos consulte Sistemas numéricos y representación de datos de la sección Conceptos básicos.

El archivo iomanip.h 

     El archivo de cabecera llamado iomanip.h define un conjunto de manipuladores adicionales a los básicos tratados en el párrafo 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 paréntesis 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 operación de inserción ó extracción restablece el valor del ancho del campo a cero que es el valor predeterminado, por ésta razón se utiliza varias veces el manipulador setw() a lo largo del programa manipu02.cpp, compilándolo 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 pequeño 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 carácter 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 carácter diferente. Al final del programa especificamos utilizar el carácter de espacio en blanco para rellenar los espacios, que es el carácter predeterminado.


//*********************************************************
//	manipu03.cpp
//*********************************************************

#include <iostream.h>	// para operaciones de E/S
#include <iomanip.h>	// 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 carácter de llenado

	return 0;
}

     En el programa comenta1.cpp, escrito en C, se realizó un sencillo cálculo utilizando valores de tipo float, al ejecutarlo observamos que la salida mostrada en la pantalla invariablemente desplegaba seis dígitos decimales, incluso introduciendo valores que dieran por resultado un valor exacto. En comparación, el mismo programa escrito en C++, entsal.cpp, despliega automáticamente los dígitos decimales de acuerdo al cálculo realizado, sin embargo, en ciertas aplicaciones puede ser deseable especificar un número determinado de dígitos 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 número de dígitos a la derecha del punto decimal a desplegar en pantalla, estudie el programa llamado manipu04.cpp


//*********************************************************
//	manipu04.cpp
//*********************************************************

#include <iostream.h>	// para operaciones de E/S
#include <iomanip.h>	// 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 símbolos 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 lección daremos la definición 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 lección pues serán aplicados prácticamente en todo programa que escriba en C++.

     En una determinada sección 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 después 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 mayúsculas
    showpos    = 0x0400,  // signo positivo obligatorio
    scientific = 0x0800,  // notación de tipo 3.145363E23
    fixed      = 0x1000,  // dígitos decimales predeterminados
    unitbuf    = 0x2000,  // desaloja flujos después de inserción
    stdio      = 0x4000   // desaloja stdout, stderr después de inserción
};

     Puede identificar fácilmente algunos de los manipuladores que ya hemos estudiado y ahora veremos cómo se utilizan éstas banderas mediante el manipulador setiosflags() y cómo restituimos las condiciones originales mediante el manipulaodr resetiosflags(), estudie y compile el siguiente ejemplo, manipu05.cpp, además 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 solicitándole un número el cual es desplegado inmediatamente para demostrar los ajustes predeterminados para los flujos de E/S, después 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 número introducido en base hexadecimal. En ésta parte del programa, línea 19, es conveniente hacer notar que hemos modificado dos veces la representación 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 después de la línea 19 utilizamos el manipulador setiosflags(ios::oct) la representación de los flujos de E/S no será en base octal sino en hexadecimal, entonces, si deseamos nuevamente la representación del valor numérico introducido en base octal necesitamos reestablecer la bandera oct anteriormente establecida en la línea 15, para esto utilizamos el manipulador resetiosflags() como está ilustrado en la línea 23 y posteriormente en las líneas 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 líneas 20, 26, 27 y 30 del programa.

Volver al principio

Hola mundo

Funciones de salida 

     Sabemos que un programa C++ utiliza el operador de inserción (<<) para mostrar datos de salida, tambien que el flujo de salida cout está definido como una clase y por lo tanto contiene ciertas funciones, llamadas miembro. En los programas que hemos visto hasta éste momento utilizamos el flujo de salida cout en conjunto con el operador de inserción << para mostrar datos de salida, sin embargo podemos hacer uso de las funciones miembro de salida definidas para el flujo cout en caso de necesitar un control más preciso, las funciones principales para el flujo de salida están definidas en el archivo ostream.h. Analizando éste archivo de cabecera podemos ver las funciones mencionadas, pero además podemos apreciar que la clase ostream está derivada de la clase ios y por lo tanto tambien podemos utilizar con los flujos de salida las funciones propias de la clase ios. Recuerde que en la siguiente lección trataremos el tema de las clases, por lo pronto es bueno que empiece a familiarizarse con la terminología de la programación en C++. Veamos un ejemplo de las funciones miembro de cout llamadas put y write.


//***********************************************
//	salida01.cpp
//***********************************************

#include <iostream.h>

int main()
{
	int letra;
	char letras[]="Programacion en C++ por Virgilio"
		"Gomez Negrete";

	for(letra='A'; letra <= 'Z'; letra++)
	{
		cout << letra << " ";
	}
	cout << "\n\n";

	for(letra='A'; letra <= 'Z'; letra++)
	{
		cout.put((char)letra);
		cout << " ";
	}
	cout << "\n\n";

	cout.write(letras, 21);
	cout << endl;

	return 0;
}

     El programa contiene dos bucles que demuestran la diferencia entre utilizar la función miembro put versus el mecanismo tradicional cout <<. Observe que hemos declarado una variable de tipo int llamada letra, por ésta razón el primer bucle despliega las letras del alfabeto, sólo que en sus respectivos equivalentes decimales del código ASCII. El segundo bucle es prácticamente igual al primero excepto por el uso de la función miembro de la clase ostream llamada put que de acuerdo a su definición, su argumento debe ser de tipo char, por lo tanto debemos moldear nuestra variable de tipo int para que sea ahora de tipo char y así poder utilizarla en la función miembro put. Habrá notado que para tener acceso a una función miembro de una clase utilizamos el operador punto (.). Ya en la parte final del programa encontramos un ejemplo del uso de la función miembro llamada write, ésta despliega el número indicado de carácteres, en éste caso 21, empezando por el principio del arreglo de tipo char llamado letras. Estudiando el archivo de cabecera ostream.h podemos determinar las funciones miembro de la clase ostream y sus respectivos argumentos, comparando ésta información con los ejemplos aquí presentados nos ayudará a entender la manera en que se relacionan las definiciones de las diferentes funciones con sus aplicaciones reales, práctica que recomiendo ampliamente.

     En el programa manipu05.cpp analizamos diferentes especificaciones de banderas que establecimos mediante el uso del manipulador setiosflags(), pues bien, podemos utilizar la función miembro setf() para realizar la misma función que con el manipulador setiosflags() y en forma similar, podemos utilizar la función unsetf() para los mismos propósitos que el manipulador resetiosflags(), incluso es posible combinar diferentes especificaciones de bandera mediante el uso del operador OR, más interesante aún es que podemos utilizar la función miembro flags() para determinar el estado original de las banderas de flujo de E/S, guardar el dato en una variable y posteriormente utilizarlo para restituir la condición original de operación de las banderas de flujo, como lo demuestra el siguiente programa, llamado salida02.cpp


//***********************************************
//	salida02.cpp
//***********************************************

#include <iostream.h>
#include <iomanip.h>

int main()
{
	long banderas_originales;
	int numero=64;

	banderas_originales=cout.flags();
	cout << "banderas originales es: " << cout.flags() << endl;
	cout.setf(ios::showbase|ios::uppercase|ios::hex);
	cout << "banderas modificadas es: " << cout.flags() << endl;
	cout << "la variable numero en base 16 es: "
		<< numero << endl;
	cout.flags(banderas_originales);
	cout << "restituidas las banderas originales, \nahora "
		"la variable numero en base 10 es: " << numero << endl;
	cout << "banderas originales es: " << cout.flags() << endl;

	return 0;
}

     Se aprecia cómo el uso adecuado de las funciones miembro puede simplificar un código fuente y hacer el programa más eficiente, ésta es una buena razón para tomarse un tiempo y examinar los diferentes archivos de cabecera incluidos con nuestro compilador, de pasada respondemos a la pregunta ¿Qué archivos de cabecera debo utilizar en mi programa? Muy importante es familiarizarse con la documentación incluida en el compilador que utilicemos, además es una buena práctica como programador.

Volver al principio

Hola mundo

Funciones de entrada 

     Para Usted no debe ser ya cosa extraña que en C++ utilizamos el operador de extracción (>>) en conjunto con el flujo cin para realizar operaciones de entrada. El flujo de entrada cin tambien está definido como una clase y su declaración la encontramos en el archivo de cabecera istream.h junto con sus respectivas funciones miembro, algunas de las cuales analizaremos en el siguiente programa, llamado entrada.cpp, sin duda alguna no tendrá problema en comprender lo expuesto en el siguiente código:


//***********************************************
//	entrada.cpp
//***********************************************

#include <iostream.h>
#include <ctype.h>

int contador;	// automáticamente inicializada en cero

int main()
{
	char texto[64], letra;

	cout << "Teclee una linea de texto y presione enter\n\n";
	cin.getline(texto, sizeof(texto));
	cout << "\n\nEl texto introducido es:\n\n" << texto
		<< "\n" << "el cual contiene " << cin.gcount()-1
		<< " carácteres" << endl;
	cout << "\n\nTeclee otra linea de texto que incluya una x\n";

	do
	{
		letra=cin.get();
		cout << (char)toupper(letra);
		contador++;
	}
	while(letra!='x');
	cout << "\n\nUsted escribio " << contador-1 << " carácteres "
		"antes de la x" << endl;

	return 0;
}

     No está de más recordar que una variable de tipo global es automáticamente inicializada a cero. El programa entrada.cpp demuestra el uso de algunas funciones miembro de la clase istream, empezando por la función llamada getline() que lee una línea de texto hasta encontrar un carácter de retorno de carro ("\n"), similarmente se hace uso de la función miembro gcount() para determinar el número de carácteres leídos, ésta función incluye el carácter de retorno de carro, por lo tanto restamos uno al valor retornado por la función para que el resultado desplegado sea el correcto (línea 17). En la segunda parte del programa se utiliza la función miembro llamada get(), ésta lee un solo carácter borrándolo de la memoria de almacenamiento temporal, se convierte a mayúscula utilizando la función toupper() moldeando la salida de ésta a tipo char y se despliega el resultado en pantalla. Éste proceso se repite merced de un bucle do-while hasta encontrar un carácter 'x'. Compare el resultado obtenido de la cuenta efectuada en el bucle do-while por la variable llamada contador con el resultado obtenido al utilizar la función miembro gcount().

     Es importante experimentar con lo expuesto en éste capítulo, con frecuencia aprendemos detalles que por alguna causa nos pasan inadvertidos con la simple lectura del texto, además cada compilador tiene sus detalles particulares que conviene conocer para conseguir el máximo provecho del mismo.

Volver al principio

Hola mundo

Descargas 

Descargue el código fuente de éste capítulo. Archivo comprimido cap01.zip, 4.6 Kb.

Volver al principio

Hola mundo
© 1999 Virgilio Gómez Negrete, Derechos Reservados