Printf y scanf, que siguen estando vigentes, se pueden utilizar los operadores cin



Descargar 0.61 Mb.
Página1/6
Fecha de conversión09.03.2017
Tamaño0.61 Mb.
  1   2   3   4   5   6
El lenguaje C++ (a partir del lenguaje C)
Capítulo 1: Modificaciones menores
1.1.1 Nueva forma de realizar las operaciones de entrada y salida.

En C++ además de las funciones printf() y scanf(), que siguen estando vigentes, se pueden utilizar los operadores cin y cout. Para utilizar estos nuevos operadores es necesario incluir la biblioteca iostream con la instrucción include . Así en un programa en C habría que hacer algo de este estilo:


char nombre;

int num=2;


printf ("Introduzca el nombre del archivo %d: ", num);

scanf (" %s", nombre);


En C++ podría escribirse así:
char nombre;

int num=2;


std :: cout << "Introduzca el nombre del archivo " << num << ": ";

std :: cin >> nombre;


Es importante darse cuenta de que ahora ya no hace falta especificar el tipo de dato que va a ser impreso o leído, asociándolo con un formato determinado. Es el propio programa el que decide el tipo de dato en tiempo de ejecución. Estos operadores están sobrecargados de tal manera que admiten tanto los tipos predefinidos como aquellos tipos de datos definidos por el usuario. C++ permite sobrecargar los operadores de modo similar a lo que se hace con las funciones: un mismo operador (+, -, *, /, =, ==, !=, <<, >>, etc.) tiene distinto significado según la naturaleza de los operandos a los que se aplica.
Para poder escribir o leer desde archivos es necesario incluir la biblioteca . A continuación se presenta un sencillo ejemplo en el que primero se escriben unas frases en un archivo y después se imprimen en la pantalla leídas desde ese archivo:
// Programa de lectura y escritura de archivos

#include

#include

#include


using namespace std;
int main()

{

ofstream out("archivo.h"); // se define un flujo de salida a archivo



out << "Estamos aprendiendo ";

out << "cómo se escribe en un archivo ";

out << "y cómo se lee desde él.";

out.close();


// Ahora comienza la lectura

ifstream in("archivo.h"); // se define un flujo de entrada de archivo

const int SIZE=81;
char line[SIZE];

in.getline(line, SIZE);


cout << line << endl;

in.getline(line, SIZE);


cout << line << endl;

in.getline(line, SIZE);


cout << line << endl;

}

El ejemplo anterior necesita algunas explicaciones extras, aunque más adelante se incluye un capítulo dedicado a las entradas y salidas de datos en C++.




  • Se declara un objeto del tipo ofstream llamado out. Este será un objeto que almacenará la información necesaria para llevar los datos de salida hasta un archivo llamado archivo.h. Esto es el equivalente a utilizar la función fopen() de ANSI C para abrir un archivo de escritura de datos.




  • Hay que darse cuenta de que la primera vez que se abre el archivo se abre en modo de escritura. Por eso hay que cerrarlo para después poder abrirlo en modo de lectura. Para realizar esta última operación es necesario declarar un objeto, al que se llama in, del tipo ifstream. El endl del final de las líneas de impresión en pantalla hace que se imprima un caracter de salto de línea y que se vacíe el buffer de salida de modo inmediato.




  • La función getline se utiliza para leer los datos que se introduzcan desde el teclado de forma similar a la que lo haría la función scanf() leyendo una línea completa hasta el '\n'.


1.1.2 Una breve comparación con la entrada y salida de datos de ANSI C

En C++ también se pueden utilizar las funciones printf() y scanf(), si se incluye la biblioteca . En la práctica esta opción no se utiliza mucho, porque los operadores (<<) y (>>) tienen algunas ventajas que se van a citar a continuación.


Con los operadores propios de C++ se evita el chequeo de compatibilidad entre el especificador de formato (lo que sigue al carácter %, como por ejemplo %s, %d, %lf, etc.) y el argumento actual de la función printf() o scanf(). Esto hace que se elimine una importante fuente de errores, que provenía, además, de una innecesaria duplicidad de información de los tipos de variable a imprimir o leer. En C++ el compilador determina en tiempo de compilación el tipo de variable que el usuario desea imprimir y aplica un formato por defecto adecuado, evitando cualquier

incompatibilidad.


Como se verá en el apartado de sobrecarga de operadores, C++ permite el mismo tratamiento a los tipos de variable definidos por el usuario que a los tipos de datos predefinidos del lenguaje. Esto quiere decir que el programador puede definir un operador (<<) especial para imprimir por ejemplo números Complejos (que incluya la letra i para indicar la parte imaginaria). Esta capacidad no está soportada por las funciones del ANSI C conocidas, a las que no se pueden añadir nuevos especificadores de formato que permitan leer o escribir directamente los datos definidos por el usuario.



    1. Mayor flexibilidad en la declaración de variables

La declaración de variables en C++ es similar a la de C, pero con una importante diferencia. En ANSI C las variables tenían que ser declaradas (salvo que fueran extern) al comienzo de un bloque, antes de la primera sentencia ejecutable de dicho bloque. En C++ las variables pueden ser declaradas en cualquier lugar de un bloque. Esto permite acercar la declaración de las variables al lugar en que se utilizan por primera vez. Las variables auto

declaradas de esta forma existen desde el momento en que se declaran, hasta que se llega al fin del

bloque correspondiente.

Un caso importante son los bucles for. En C++ la variable que sirve de contador al bucle puede declararse e inicializarse en la propia sentencia for. Por ejemplo, considérese el siguiente bucle para sumar los elementos de un vector:

for (double suma = 0.0, int i = 0; i

suma += a[i];


donde las variables suma e i son declaradas y creadas como double e int en el momento de iniciarse

la ejecución del bucle for.




    1. Scope o visibilidad de variables

La visibilidad de una variable es la parte del programa en la que esa variable está definida y puede ser utilizada. La duración hace referencia al tiempo que transcurre entre la creación de una variable y el instante en que es destruida. En general la visibilidad de una variable auto abarca desde el punto en el que se define hasta que finaliza el bloque en el que está definida. Si la declaración de una variable no se encuentra dentro de ningún bloque (variable global o extern), la visibilidad se extiende desde el punto de declaración hasta el final del archivo (otros archivos pueden ver dicha variable sólo si la declaran como extern).

Las reglas de duración y visibilidad de C++ son similares a las de C. En C++ la visibilidad de una variable puede ser local, a nivel de archivo o a nivel de clase.


Las variables locales se crean dentro de un bloque y sólo son visibles dentro del bloque en el que han sido definidas y en sus bloques anidados, salvo que sean ocultadas por una nueva variable del mismo nombre declarada en uno de esos bloques anidados.

Las variables que tienen visibilidad a nivel de archivo –variables globales– se definen fuera de cualquier bloque, función o clase.


Una variable local declarada dentro de un bloque oculta una variable global del mismo nombre u otra variable local también del mismo nombre declarada en un bloque más exterior. Por ejemplo, puede suceder que en un bloque, hasta la declaración de una variable x se pueda estar utilizando otra variable con el mismo nombre x de otro bloque que contenga al primero. A partir de su declaración y hasta el final de su bloque, la nueva variable x será la local del bloque más interior.

Véase el ejemplo siguiente:

...

{

double x = 2.0;



printf("%.lf", x); // se imprime 2.0

{

printf("%.lf", x); // se imprime 2.0



double x = 3.0;

printf("%.lf", x); // se imprime 3.0

}

printf("%.lf", x); // se imprime 2.0



}

...
En C++ las variables definidas dentro de una clase variables miembro– pueden ser declaradas como privadas, públicas o protegidas. Las variables miembro que han sido declaradas como privadas no son visibles fuera de la clase; si se declaran como públicas se puede acceder a ellas mediante los operadores punto (.) y flecha (->), con las mismas reglas que para las variables miembro de las estructuras de C. Las variables miembro de una clase tienen visibilidad directa desde todas las funciones miembro de esa clase, sin necesidad de que les sean pasadas como argumento.


La duración (lifetime) de una variable es el período de tiempo en que esta variable existe durante la ejecución del programa. La duración de una variable puede ser automatic (opción por defecto) o static. En el primer caso –el caso de las variables declaradas dentro de un bloque – la variable se crea y se destruye cada vez que se pasa por el bloque. Las variables static existen hasta que termina la ejecución del programa. Su valor se conserva entre las distintas pasadas por un bloque. Para que una variable local sea static hay que declararla como tal dentro del bloque. Debe recordarse que aunque una variable exista durante toda la ejecución de un programa, sólo puede utilizarse en la zona del programa en que esa variable es visible. C++ dispone del operador (::), llamado operador de resolución de visibilidad (scope resolution operator). Este operador, antepuesto al nombre de una variable global que está oculta por una variable local del mismo nombre, permite acceder al valor de la variable global.
Considérese el siguiente ejemplo:
int a = 2; // declaración de una variable global a

int main()

{

...


printf("a = %d", a); // se escribe a = 2

int a = 10; // declaración de una variable local a

printf("a = %d", a); // se escribe a = 10

printf("a = %d", ::a); // se escribe a = 2

}
El operador (::) no permite acceder a una variable local definida en un bloque más exterior oculta por otra variable local del mismo nombre. Este operador sólo permite acceder a una variable global oculta por una variable local del mismo nombre.


    1. Especificador const para variables

En C++ el especificador const se puede utilizar con variables y con punteros. Las variables definidas como const no son lo mismo que las constantes simbólicas, aunque evidentemente hay una cierta similitud en las áreas de aplicación. Si una variable se define como const se tiene la garantía de que su valor no va a cambiar durante toda la ejecución del programa. Si en alguna sentencia del programa se intenta variar el valor de una variable definida como const, el compilador produce un mensaje de error. Esta precaución permite detectar errores durante la compilación del programa, lo cual siempre es más sencillo que detectarlos en tiempo de ejecución.

Las variables de este tipo pueden ser inicializadas pero no pueden estar a la izquierda de una sentencia de asignación.

Las variables declaradas como const tienen importantes diferencias con las constantes simbólicas definidas con la directiva #define del preprocesador. Aunque ambas representan valores que no se puede modificar, las variables const están sometidas a las mismas reglas de visibilidad y duración que las demás variables del lenguaje.

Las variables const de C++ pueden ser utilizadas para definir el tamaño de un vector en la declaración de éste, cosa que no está permitida en C. Así las siguientes sentencias, que serían ilegales en C, son ahora aceptadas en C++:


int main()

{

const int SIZE = 5;



char cs[SIZE] ;

}
De todas formas, nunca puede declararse ninguna variable array cuyo tamaño sea desconocido en tiempo de compilación. Si el tamaño de una variable va a ser conocido sólo en tiempo de ejecución, hay que utilizar reserva dinámica de memoria tanto en C como en C++.


Es muy frecuente que las funciones a las que por motivos de eficiencia (para no tener que sacar copias de los mismos) se les pasan los argumentos por referencia, éstos serán declarados como const en la definición y en el prototipo de la función, con objeto de hacer imposible una modificación accidental de dichos datos. Esto sucede por ejemplo con las funciones de manejo de cadenas de caracteres. El prototipo de la función strcpy() puede ser como sigue:
char *strcpy(char *s1, const char *s2);
donde s1 es la cadena copia y s2 es la cadena original. Como no tiene sentido tratar de modificar la cadena original dentro de la función, ésta se declara como const. En este caso el valor de retorno es un puntero a la cadena copia s1.


    1. Declaración simplificada de variables tipo enumeración

En C las variables de tipo enum se hacían corresponder con enteros, y por tanto no hacían nada que no se pudiera hacer también con enteros.

En C++ las variables enum son verdaderos tipos de variables, que necesitan un cast para que un valor entero les pueda ser asignado (ellas son promovidas a enteros cuando hace falta de modo automático). Esto quiere decir que si una función espera recibir como argumento un tipo enum sólo se le puede pasar un entero con un cast. Por el contrario, si espera recibir un entero se le puede pasar un valor enum directamente.


Por ejemplo, si se desean representar los colores rojo, verde, azul y amarillo se podría definir un tipo de variable enum llamada color cuyos cuatro valores estarían representados por las constantes ROJO, VERDE, AZUL Y AMARILLO, respectivamente. Esto se puede hacer de la siguiente forma:
enum color {ROJO, VERDE, AZUL, AMARILLO};
Utilizar mayúsculas para los identificadores que representan constantes es una convención estilística ampliamente adoptada. En el ejemplo anterior se ha definido el tipo color, pero no se ha creado todavía ninguna variable con ese tipo. Por defecto los valores enteros asociados empiezan en 0 y van aumentando de uno en uno.

Así, por defecto, los valores asociados serán:


ROJO = 0 VERDE = 1 AZUL = 2 AMARILLO = 3
Sin embargo, el programador puede asignar el valor que desee a cada uno de esos identificadores, asignando incluso el mismo entero a varios identificadores diferentes. por ejemplo, siguiendo con el tipo color:
enum color {ROJO = 3, VERDE = 5, AZUL = 7, AMARILLO};
Lógicamente en este caso los valores enteros asociados serán:
ROJO = 3 VERDE = 5 AZUL = 7 AMARILLO = 8
Cuando no se establece un entero determinado para un identificador dado, se toma el entero siguiente al anteriormente asignado.
Una vez que se ha definido un tipo enum, se pueden definir cuantas variables de ese tipo se desee. Esta definición es distinta en C y en C++. Por ejemplo, para definir las variables pintura y fondo, de tipo color, en C hay que utilizar la sentencia:
enum color pintura, fondo; /* esto es C */
mientras que en C++ bastaría hacer:
color pintura, fondo; // esto es C++
Se puede utilizar, por ejemplo, la siguiente sentencia de asignación:
pintura = ROJO;
Hay que recordar que al imprimir una variable enum se imprime su valor entero y no su valor

asociado.




    1. Declaración simplificada de variables correspondientes a estructuras

De modo análogo a lo que pasa con la palabra clave enum, en C++ no es necesario colocar la palabra clave struct para declarar una variable del tipo de una estructura definida por el usuario. Por ejemplo, si se define la estructura alumno del modo siguiente:
struct alumno {

long nmat;

char nombre[41];

};
en C++ se puede declarar después una variable delegado del tipo alumno simplemente con:


alumno delegado; // esto es C++
mientras que en C es necesario utilizar también la palabra struct en la forma:
struct alumno delegado; /* esto es C */

    1. Especificador const para punteros

En el caso de los punteros hay que distinguir entre dos formas de aplicar el cualificador const:

1. un puntero variable apuntando a una variable constante y

2. un puntero constante apuntando a una variable cualquiera.

Un puntero a una variable const no puede modificar el valor de esa variable (si se intentase el compilador lo detectaría e imprimiría un mensaje de error), pero ese puntero no tiene por qué apuntar siempre a la misma variable.

En el caso de un puntero const, éste apunta siempre a la misma dirección de memoria pero el valor de la variable almacenada en esa dirección puede cambiar sin ninguna dificultad.
Un puntero a variable const se declara anteponiendo la palabra const:
const char *nombre1 = "Ramón"; // no se puede modificar el valor de la variable
Por otra parte, un puntero const a variable cualquiera se declara interponiendo la palabra const entre el tipo y el nombre de la variable:
char* const nombre2 = "Ramón"; // no se puede modificar la dirección a la que

// apunta el puntero, pero sí el valor.


En ANSI C una variable declarada como const puede ser modificada a través de un puntero a dicha variable. Por ejemplo, el siguiente programa compila y produce una salida i=3 con el compilador de C, pero da un mensaje de error con el compilador de C++:

#include

int main()

{

const int i = 2;



int *p;

p = &i;


*p = 3;

printf("i = %d", i);

}


    1. Conversiones explícitas de tipo

Además de las conversiones implícitas de tipo que tienen lugar al realizar operaciones aritméticas entre variables de distinto tipo –promociones– y en las sentencias de asignación, el lenguaje C dispone de una conversión explícita de tipo de variables, directamente controlada por el programador, llamada cast. El cast se realiza anteponiendo al nombre de la variable o expresión el tipo al que se desea hacer la conversión encerrado entre paréntesis. Por ejemplo, pera devolver como int un cociente entre las variables double x e y:
return (int) (x/y);
El lenguaje C++ dispone de otra conversión explícita de tipo con una notación similar a la de las funciones y más sencilla que la del cast. Se utiliza para ello el nombre del tipo al que se desea convertir seguido del valor a convertir entre paréntesis. Así, las siguientes expresiones son válidas en C++:
y = double(25);

return int(x/y);





    1. Sobrecarga de funciones

La sobrecarga (overload) de funciones consiste en declarar y definir varias funciones distintas que tienen un mismo nombre. Dichas funciones se definen de forma diferente. En el momento de la ejecución se llama a una u otra función dependiendo del número y/o tipo de los argumentos actuales de la llamada a la función. Por ejemplo, se pueden definir varias funciones para calcular el valor absoluto de una variable, todas con el mismo nombre abs(), pero cada una aceptando un tipo de argumento diferente y con un valor de retorno diferente.

La sobrecarga de funciones no admite funciones que difieran sólo en el tipo del valor de retorno, pero con el mismo número y tipo de argumentos. De hecho, el valor de retorno no influye en la determinación de la función que es llamada; sólo influyen el número y tipo de los argumentos.

Tampoco se admite que la diferencia sea el que en una función un argumento se pasa por valor y en otra función ese argumento se pasa por referencia.

1.10 Valores por defecto de parámetros de una función

En ANSI C se espera encontrar una correspondencia biunívoca entre la lista de argumentos actuales (llamada) y la lista de argumentos formales (declaración y definición) de una función. Por ejemplo, supóngase la siguiente declaración de una función para calcular el módulo de un vector x con n elementos:


double modulo(double x[], int n);

En C esta función tiene que ser necesariamente llamada con dos argumentos actuales que se corresponden con los dos argumentos formales de la declaración.

En C++ la situación es diferente pues se pueden definir valores por defecto para todos o algunos de los argumentos formales. Después, en la llamada, en el caso de que algún argumento esté ausente de la lista de argumentos actuales, se toma el valor asignado por defecto a ese argumento. Por ejemplo, la función modulo() podía haberse declarado del siguiente modo:
double modulo(double x[], int n=3);
La función modulo() puede ser llamada en C++ de las formas siguientes:
v = modulo(x, n);

v = modulo(x);


En el segundo caso se utiliza el valor por defecto n=3 incluido en la declaración.

En C++ se exige que todos los argumentos con valores por defecto estén al final de la lista de argumentos. En la llamada a la función pueden omitirse alguno o algunos de los últimos argumentos de la lista. Si se omite un argumento deben de omitirse todos aquellos que se encuentren detrás suyo.


1.11 Variables de tipo referencia

A continuación se va a recordar brevemente cómo se pasaban argumentos por referencia en ANSI C. Para ello se va a utilizar la función permutar():


#include

#include


int main()

{

int i = 1, j = 2;



void permutar(int *a, int *b);

printf("\ni = %d, j = %d", i, j);

permutar(&i, &j);

printf("\ni = %d, j = %d", i, j);

}
void permutar(int *a, int *b)

{

int temp;



temp = *a;

*a = *b;


*b = temp;

}
La clave para pasar argumentos o parámetros por referencia en C está en el uso de punteros. Al pasar la dirección de la variable, ésta es accesible desde dentro de la función y su valor puede ser modificado. De modo análogo, si dentro de una función hay que modificar un puntero habrá que pasar su dirección como argumento, esto es, habrá que pasar un puntero a puntero.


C++ ofrece una nueva forma de pasar argumentos por referencia a una función, que no obliga a utilizar –dentro de la función– el operador indirección (*) para acceder al valor de la variable que se quiere modificar. Esto se hace por medio de un nuevo tipo de dato –que no existe en C– llamado tipo referencia (reference).
Las variables referencia se declaran por medio del carácter (&). Por lo demás, son variables normales que contienen un valor numérico o alfanumérico. Antes de pasar a explicarlas con más detenimiento, se presenta de nuevo el ejemplo de la función permutar() utilizando variables referencia en lugar de punteros.
// Este programa requiere compilador de C++

#include

#include
int main()

{

int i = 1, j = 2;



void permutar(int &a, int &b); // los argumentos son referencias

printf("\ni = %d, j = %d", i, j);

permutar(i, j); // los argumentos no llevan (*) ni (&)

printf("\ni = %d, j = %d", i, j);

}
void permutar(int &a, int &b) // los argumentos son referencias

{

int temp;



temp = a; // no hace falta utilizar

a = b; // el operador indirección (*)

b = temp;

}
Los dos programas dan idéntico resultado, sin embargo, el segundo tiene la ventaja de que no hay que utilizar el operador indirección dentro de la función permutar(). C++ permite pasar argumentos por referencia sin más que anteponer el carácter (&) a los argumentos correspondientes, tanto en el prototipo como en el encabezamiento de la definición. En la llamada a la función los argumentos se ponen directamente, sin anteponerles ningún carácter u operador.


En C++ existe realmente un tipo llamado referencia que va más allá del paso de argumentos a funciones tal y como se acaba de explicar. Las variables de tipo referencia se declaran con el operador (&) y deben ser inicializadas a otra variable o a un valor numérico. Por ejemplo:
int i=2;

int& iref = i; // declaración de referencia válida

int& jref; // declaración de referencia no válida
La variable i es una variable normal tipo int. La variable iref es una variable referencia que se asocia con i, en el sentido de que ambas variables comparten la misma posición de memoria: si se modifica i se modifica iref, y viceversa. En este sentido, iref es un alias de i. La diferencia con un puntero que apuntase a la dirección de i está en que, una vez que una variable referencia ha sido declarada como alias de i no puede ser declarada como alias de otra variable. Siempre se referirá a la misma posición de memoria. Es como un puntero a una posición de memoria fija. En la función permutar() los argumentos formales, que son referencias, se inicializan y se convierten en alias de los argumentos actuales, que son variables ordinarias.

El principal uso de las variables referencia es como valor de retorno o argumentos de funciones. Los vectores y matrices (arrays) no pueden ser declarados como variables referencia, porque ya tienen una forma propia y natural de ser pasados como argumentos a una función.


No se debe confundir el uso de (&) en la declaración de una referencia con el operador dirección (&), de la misma

forma que no se debe confundir el carácter (*) en la declaración de un puntero, con el operador indirección (*).


El que una función tenga como valor de retorno una variable tipo referencia permite

utilizarla de una manera un poco singular. Considérese el siguiente ejemplo:


int& maxref(int& a, int& b)

{

if (a >= b)



return a;

else


return b;

}
La función maxref() tiene referencias como valor de retorno y como argumentos. Esto

permite utilizarla, por ejemplo, del siguiente modo:
maxref(i, j) = 0;
Esta es una forma un poco extraña de utilizar una función: la llamada está a la izquierda del operador de asignación, en vez de aparecer a la derecha en una expresión aritmética o de otro tipo. El resultado de esta llamada también es un poco extraño: el valor de retorno es una referencia, esto es un alias del argumento de valor máximo. Cuando la llamada a la función se sustituye por su valor de retorno, el resultado de la sentencia anterior es que la variable pasada como argumento que tiene mayor valor se hace igual a cero. Este mismo efecto puede conseguirse mediante punteros, pero con referencias resulta mucho más sencillo.
En C++ las referencias son muy utilizadas para pasar argumentos a funciones (y como valores de retorno), no sólo para poderlos modificar dentro de la función, sino también por motivos de eficiencia, pues es mucho más rápido pasar un puntero o un alias de una variable que una copia del valor de esa variable. Si además la variable es una estructura, las ventajas de eficiencia son todavía mucho más palpables.

  1   2   3   4   5   6


La base de datos está protegida por derechos de autor ©bazica.org 2016
enviar mensaje

    Página principal