Manual C++, Apuntes de Algoritmos y Programación
danio-38
danio-38

Manual C++, Apuntes de Algoritmos y Programación

92 páginas
50Número de descargas
123Número de visitas
80%de 30 votosNúmero de votos
10Número de comentarios
Descripción
Asignatura: Programació I, Profesor: Ramon Ferrer, Carrera: Enginyeria Informàtica, Universidad: UPC
100 Puntos
Puntos necesarios para descargar
este documento
Descarga el documento
Vista previa3 páginas / 92
Esta solo es una vista previa
3 páginas mostradas de 92 páginas totales
Descarga el documento
Esta solo es una vista previa
3 páginas mostradas de 92 páginas totales
Descarga el documento
Esta solo es una vista previa
3 páginas mostradas de 92 páginas totales
Descarga el documento
Esta solo es una vista previa
3 páginas mostradas de 92 páginas totales
Descarga el documento
Microsoft Word - ManualCpp_new.doc

A pr

en da

In fo

rm át

ic a

... En

er o

20 06

Aprenda C++ como si estuviera en primero

(edición revisada)

Javier García de Jalón • José Ignacio Rodríguez José María Sarriegui • Alfonso Brazález • Manuel González

http://www.tayuda.com/ayudainf/index.htm

Aprenda C++ como si estuviera en primero

(edición revisada)

Javier García de Jalón José Ignacio Rodríguez

José María Sarriegui Alfonso Brazález Manuel González

Perteneciente a la colección : “Aprenda …, como si estuviera en primero” Editada y mantenida por Javier García de Jalón (jgjalon@etsii.upm.es)

Nuevos títulos y actualizaciones en: http://www.tayuda.com/ayudainf/index.htm

ÍNDICE

1INTRODUCCIÓN........................................................................................................................................ 1

2MODIFICACIONES MENORES .............................................................................................................. 2 2.1 CAMBIO EN LA EXTENSIÓN DEL NOMBRE DE LOS FICHEROS ............................................................... 2 2.2 DEFINICIÓN DE LA FUNCIÓN MAIN() ................................................................................................... 2 2.3 NAMESPACES ..................................................................................................................................... 2 2.4 CAMBIOS EN LAS LIBRERÍAS ESTÁNDAR............................................................................................. 4 2.5 COMENTARIOS INTRODUCIDOS EN EL PROGRAMA .............................................................................. 5 2.6 DECLARACIÓN SIMPLIFICADA DE VARIABLES TIPO ENUMERACIÓN .................................................... 6 2.7 DECLARACIÓN SIMPLIFICADA DE VARIABLES CORRESPONDIENTES A ESTRUCTURAS ......................... 7 2.8 MAYOR FLEXIBILIDAD EN LA DECLARACIÓN DE VARIABLES .............................................................. 7 2.9 SCOPE O VISIBILIDAD DE VARIABLES.................................................................................................. 8 2.10 ESPECIFICADOR CONST PARA VARIABLES ........................................................................................... 9 2.11 ESPECIFICADOR CONST PARA PUNTEROS .......................................................................................... 10 2.12 CONVERSIONES EXPLÍCITAS DE TIPO ................................................................................................ 11 2.13 ESPECIFICADOR INLINE PARA FUNCIONES......................................................................................... 11 2.14 SOBRECARGA DE FUNCIONES ........................................................................................................... 12 2.15 VALORES POR DEFECTO DE PARÁMETROS DE UNA FUNCIÓN ............................................................ 12 2.16 VARIABLES DE TIPO REFERENCIA...................................................................................................... 13 2.17 OPERADORES NEW Y DELETE PARA GESTIÓN DINÁMICA DE MEMORIA .............................................. 15 2.18 PUNTEROS DE TIPO VOID .................................................................................................................. 16 2.19 NUEVA FORMA DE REALIZAR LAS OPERACIONES DE ENTRADA Y SALIDA. ........................................ 17 2.20 FUNCIONES CON NÚMERO DE PARÁMETROS VARIABLE .................................................................... 18

3MODIFICACIONES MAYORES ............................................................................................................ 19 3.1 INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (OOP)............................................ 19 3.2 CLASES, OBJETOS Y MÉTODOS. ....................................................................................................... 20 3.3 EJEMPLO DE CLASE EN C++: NÚMEROS COMPLEJOS ......................................................................... 20 3.4 CLASE SIN SECCIONES PRIVADAS: STRUCT ........................................................................................ 26 3.5 CLASES CON SECCIONES PRIVADAS. ................................................................................................. 29 3.6 EXPANSIÓN INLINE ........................................................................................................................... 30

3.6.1Definición.......................................................................................................................... 303.6.2Implementación de las funciones inline ............................................................................ 30

3.7 ENTRADA Y SALIDA DE DATOS ......................................................................................................... 31 3.7.1Una breve comparación con la entrada y salida de datos de ANSI C .............................. 33

3.8 OPERADORES NEW Y DELETE CON CLASES ........................................................................................ 33 3.9 CONSTRUCTORES Y DESTRUCTORES................................................................................................. 34

3.9.1Inicializadores................................................................................................................... 353.9.2Llamadas al constructor ................................................................................................... 363.9.3Constructor por defecto y constructor con parámetros con valor por defecto ................. 363.9.4Constructor de oficio ........................................................................................................ 373.9.5Constructor de copia......................................................................................................... 383.9.6Necesidad de escribir un constructor de copia ................................................................. 383.9.7Los constructores y el operador de asignación (=) .......................................................... 403.9.8Destructores ...................................................................................................................... 40

3.10 CLASES Y FUNCIONES FRIEND .......................................................................................................... 41 3.11 EL PUNTERO THIS ............................................................................................................................. 43 3.12 SOBRECARGA DE OPERADORES ........................................................................................................ 44

3.12.1Clase cadena para manejo de cadenas de caracteres. ..................................................... 453.12.2Definición de funciones y operadores de la clase cadena................................................. 483.12.3Ejemplo de utilización de la clase cadena ........................................................................ 513.12.4Sobrecarga de los operadores (++) y (--) ........................................................................ 53

3.13 OBJETOS MIEMBRO DE OTROS OBJETOS............................................................................................ 54 3.14 VARIABLES MIEMBRO STATIC ........................................................................................................... 56 3.15 FUNCIONES MIEMBRO STATIC ........................................................................................................... 58

ESIISS: Aprenda C++ como si estuviera en Primero página 2

4HERENCIA ................................................................................................................................................ 60 4.1 NECESIDAD DE LA HERENCIA ........................................................................................................... 60 4.2 DEFINICIÓN DE HERENCIA................................................................................................................ 60

4.2.1Variables y funciones miembro protected ......................................................................... 60 4.3 CONSTRUCTORES DE LAS CLASES DERIVADAS: INICIALIZADOR BASE............................................... 63 4.4 HERENCIA SIMPLE Y HERENCIA MÚLTIPLE ....................................................................................... 63 4.5 CLASES BASE VIRTUALES................................................................................................................. 64 4.6 CONVERSIONES ENTRE OBJETOS DE CLASES BASE Y CLASES DERIVADAS ......................................... 65

5POLIMORFISMO ..................................................................................................................................... 66 5.1 IMPLEMENTACION DE LAS FUNCIONES VIRTUALES........................................................................... 68 5.2 FUNCIONES VIRTUALES PURAS......................................................................................................... 69 5.3 CLASES ABSTRACTAS....................................................................................................................... 70 5.4 DESTRUCTORES VIRTUALES ............................................................................................................. 70

6ENTRADA/SALIDA EN C++................................................................................................................... 72 6.1 ENTRADA/SALIDA CON FORMATO .................................................................................................... 72 6.2 ACTIVAR Y DESACTIVAR INDICADORES............................................................................................ 73 6.3 FUNCIONES MIEMBRO WIDTH(), PRECISION() Y FILL() ....................................................................... 74

6.3.1Manipuladores de entrada/salida ..................................................................................... 74 6.4 SOBRECARGA DE LOS OPERADORES DE ENTRADA/SALIDA (<< Y >>) ............................................... 75 6.5 ENTRADA/SALIDA DE FICHEROS ....................................................................................................... 75

6.5.1Funciones miembro de iostream ....................................................................................... 766.5.2Funciones miembro de fstream ......................................................................................... 776.5.3Ejemplo completo de lectura y escritura en un fichero..................................................... 786.5.4Errores de Entrada/Salida ................................................................................................ 79

7OPCIONES AVENZADAS: PLANTILLAS (TEMPLATES) Y MANEJO DE EXCEPCIONES ..... 81 7.1 PLANTILLAS..................................................................................................................................... 81

7.1.1Plantillas de funciones ...................................................................................................... 817.1.2Plantillas de clases............................................................................................................ 827.1.3Plantillas vs. Polimorfismo. .............................................................................................. 84

7.2 MANEJO DE EXCEPCIONES ............................................................................................................... 84 8BIBLIOGRAFÍA........................................................................................................................................ 86

Capítulo 1: Introducción página 1

1 INTRODUCCIÓN

El comité para el estándar ANSI C fue formado en 1983 con el objetivo de crear un lenguaje uni- forme a partir del C original, desarrollado por Kernighan y Ritchie en 1972, en la ATT. Hasta en- tonces el estándar lo marcaba el libro escrito en 1978 por estos dos autores1.

El lenguaje C++ se comenzó a desarrollar en 1980. Su autor fue B. Stroustrup, también de la ATT. Al comienzo era una extensión del lenguaje C que fue denominada C with classes. Este nuevo lenguaje comenzó a ser utilizado fuera de la ATT en 1983. El nombre C++ es también de ese año, y hace referencia al carácter del operador incremento de C (++). Ante la gran difusión y éxito que iba obteniendo en el mundo de los programadores, la ATT comenzó a estandarizarlo internamente en 1987. En 1989 se formó un comité ANSI (seguido algún tiempo después por un comité ISO) para estandarizarlo a nivel americano e internacional. Este trabajo finalizó en Septiembre de 1998 con la publicación del estándar “Information Technology – Programming Languages – C++” (documento ISO/IEC 14882-1998).

En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los progra- madores profesionales le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas cosas de C++ y añadiendo otras, que se utiliza para realizar aplicaciones en Internet.

Hay que señalar que el C++ ha influido en algunos puntos muy importantes del ANSI C, co- mo por ejemplo en la forma de declarar las funciones, en los punteros a void, etc. En efecto, aunque el C++ es posterior al C, sus primeras versiones son anteriores al ANSI C, y algunas de las mejoras de éste fueron tomadas del C++.

En estas Notas se van a presentar los fundamentos del lenguaje C++ tradicional a partir del lenguaje C. Su descripción se va a realizar en dos partes: una inicial en la que se contemplan las modificaciones y una posterior con los añadidos. El C++ es a la vez un lenguaje procedural (orien- tado a algoritmos) y orientado a objetos. Como lenguaje procedural se asemeja al C y es compatible con él, aunque ya se ha dicho que presenta ciertas ventajas (las modificaciones menores, que se verán a continuación). Como lenguaje orientado a objetos se basa en una filosofía completamente diferente, que exige del programador un completo cambio de mentalidad. Las características propias de la Programación Orientada a Objetos (Object Oriented Programming, u OOP) de C++ son modificaciones mayores que sí que cambian radicalmente su naturaleza.

1 B. Kernighan and D. Ritchie, The C Programming Language, Prenctice-Hall, 1978.

ESIISS: Aprenda C++ como si estuviera en Primero página 2

2 MODIFICACIONES MENORES

Como ya se ha dicho, el C++ contiene varias modificaciones menores sobre el C original. Normal- mente se trata de aumentar la capacidad del lenguaje y la facilidad de programación en un conjunto de detalles concretos basados en la experiencia de muchos años. Como el ANSI C es posterior a los primeros compiladores de C++, algunas de estas modificaciones están ya introducidas en el ANSI C. En cualquier caso, se trata de modificaciones que facilitan el uso del lenguaje, pero que no cam- bian su naturaleza.

Hay que indicar que el C++ mantiene compatibilidad casi completa con C, de forma que el viejo estilo de hacer las cosas en C es también permitido en C++, aunque éste disponga de una me- jor forma de realizar esas tareas.

2.1 Cambio en la extensión del nombre de los ficheros

El primer cambio que tiene que conocer cualquier programador es que los ficheros fuente de C++ tienen la extensión *.cpp (de C plus plus, que es la forma oral de llamar al lenguaje en inglés), en lugar de *.c. Esta distinción es muy importante, pues determina ni más ni menos el que se utilice el compilador de C o el de C++. La utilización de nombres incorrectos en los ficheros puede dar lugar a errores durante el proceso de compilación.

2.2 Definición de la función main()

Según el estándar C++, las dos únicas definiciones portables de la función main() son:

int main(void) { ... }

e int main(int argc, char* argv[]) { ... }

El valor int devuelto por la función indica al sistema operativo si el programa se ejecutó con éxito (valor 0) o si hubo algún fallo (cualquier valor distinto de 0). C++ define una instrucción im- plícita return 0; al final de main(), de modo que la ejecución de todo programa que no devuelva un valor de forma explícita es interpretada como exitosa por el sistema operativo.

2.3 Namespaces

Cuando se desarrolla un programa C++ complejo suele ser necesario combinar un número elevado de librerías creadas por diferentes autores: las del propio lenguaje, las escritas por el programador, otras librerías comerciales o de libre distribución, etc). Puede ocurrir que dos o más de estas librerí- as utilicen un mismo identificador (nombre de función, variable global, …) con significados dife- rentes. Si es así, aunque estas librerías funcionen perfectamente por separado, cuando se combinan en un mismo programa se puede producir un conflicto de nombres que origina un error de compila- ción o un funcionamiento incorrecto del programa por utilizar una función no adecuada.

Capítulo 2: Modificaciones menores página 3

El siguiente ejemplo ilustra el problema:

// fichero libreria1.h double f1(double x); // fichero libreria2.h double f1(double x); // fichero main.cpp #include <libreria1.h> #include <libreria2.h> int main() { f1(3.1416); // conflicto de nombres! }

En las versiones anteriores de C/C++ sólo había un espacio de nombres o namespace global. Todas las variables y funciones declaradas pertenecían a ese namespace global. En la versión ac- tual, todas las declaraciones globales pertenecen por defecto al nemespace std o estándar. Para utili- zar dichas variables o funciones hay dos posibilidades:

1. Introducir la sentencia using namespace std; que hace que std se incluya en el namespace global.

2. Cualificar con std:: las funciones incluidas en los nuevos headers. Así, habría que utilizar std::in y std::out para leer y escribir con las funciones declaradas con #include <iostream>.

Los namespaces intentan resolver con generalidad este problema definiendo distintas zonas de scope, es decir ámbito o visibilidad en un programa. Un namespace agrupa distintos identifica- dores bajo un scope común. De este modo, esos identificadores ya no están definidos en el scope global, sino en el scope del namespace. Si cada librería define todos sus identificadores bajo un namespace propio y único, desaparecen los conflictos de nombres. Un namespace de nombre ONE se define en la forma:

namespace ONE { // declaraciones ... // definición de funciones y variales ... }

Dentro del namespace las variables y funciones declaradas en él se utilizan directamente, sin cualificar. Una forma de especificar fuera del namespace cuál de los identificadores se utiliza en cada momento es anteponer al nombre del mismo el nombre del namespace separado por el opera- dor de resolución de visibilidad (::), como por ejemplo:

// fichero libreria1.h namespace lib1 { double f1(double x); } // fichero libreria2.h namespace lib2 { double f1(double x); } // fichero main.cpp #include <libreria1.h> #include <libreria2.h> int main() { lib1::f1(3.1416); // se refiere a f1() de libreria1.h lib2::f1(3.1416); // se refiere a f1() de libreria2.h }

ESIISS: Aprenda C++ como si estuviera en Primero página 4

El contenido de los namespaces es abierto, es decir, diferentes ficheros pueden añadir identi- ficadores a un mismo namespace (es decir, un mismo namespace se puede cerrar y abrir varias veces, para añadir identificadores). De esta forma el namespace representa un módulo cuya funcio- nalidad es proporcionada mediante un conjunto de ficheros. No es necesario especificar el names- pace de los argumentos de una función si éste coincide con el namespace en el que se define la fun- ción, cosa bastante habitual.

Los namespaces pueden anidarse (definir uno dentro de otro), cuyo caso puede ser necesario utilizar más de un cualificador (::), como en el ejemplo siguiente:

namespace ONE { double a=1.0; ... namespace TWO { double b=2.0; ... } } int main () { double c = ONE::a + ONE::TWO::b; ... }

A veces resulta tedioso especificar el namespace de todos los identificadores de una librería cada vez que se utilizan. Una forma de evitarlo es mediante una declaración using:

using lib1::f1;

que convierte el identificador f1 en un identificador global (sinónimo de lib1::f1) en el ámbito en el que se emplea la declaración. Otra forma es mediante una directiva using:

using namespace lib1;

que convierte todos los identificadores del namespace lib1 en identificadores globales en el ámbito en el que se emplea.

Es importante resaltar que las declaraciones y directivas using nunca se deben emplear en ficheros cabecera o header, ya que pueden ocasionar comportamientos imprevistos a los usuarios de esos ficheros.

Existen también namespaces anónimos, es decir sin nombre. Los namespaces anónimos per- miten crear identificadores únicos en un determinado fichero. En dicho fichero dichos identificado- res se pueden utilizar directamente, y fuera de ese fichero no se pueden utilizar de ninguna forma. Es una forma de sustituir las variables y/o funciones definidas como static extern.

2.4 Cambios en las librerías estándar

El lenguaje C++ incluye la librería estándar de C, sin embargo el nombre de sus ficheros cabecera cambia: incorporan el prefijo “c” (para indicar que la librería proviene de C) y no tienen extensión (esta es la norma para todos los ficheros de cabecera estándar en C++). Por ejemplo, si se desea utilizar la librería matemática estándar de C en un programa de C++ habrá que añadir la directiva #include <cmath> en lugar de #include <math.h>.

Pero además de la librería estándar de C, el lenguaje C++ incorpora su propia librería están- dar, con unas prestaciones mucho más avanzadas que la primera. Esta librería está compuesta por tres componentes principales, además de otros componentes menores:

Capítulo 2: Modificaciones menores página 5

• La clase String, para trabajar con cadenas de texto.

• La entrada/salida de datos, incluyendo el soporte para la internacionalización.

• La STL (Stantard Template Library), que proporciona diferentes estructuras de datos (arrays dinámicos, listas, árboles binarios ...) y algoritmos (búsquedas, ordenar datos ...).

Para evitar conflictos de nombres con otras librerías, todos los identificadores de la librería es- tándar de C++ están definidos bajo el namespace std. Para usarlos es necesario añadir el prefijo std:: a su nombre o usar una declaración o una directiva using.

La librería estándar de C++ es muy potente y simplifica en gran medida el desarrollo de apli- caciones. Sin embargo es también bastante extensa y compleja, por lo que su explicación en detalle queda fuera del alcance de este texto.

2.5 Comentarios introducidos en el programa

En C los comentarios empiezan por los caracteres /* y terminan con los caracteres */. Pueden com- prender varias líneas y estar distribuidos de cualquier forma, pero todo aquello que está entre el /* (inicio del comentario) y el */ (fin del comentario) es simplemente ignorado por el compilador. Al- gunos ejemplos de formato de comentarios son los siguientes:

/* Esto es un comentario simple. */

/* Esto es un comentario más largo, distribuido en varias líneas. El texto se suele alinear por la izquierda. */

/************************************** * Esto es un comentario de varias * * líneas, encerrado en una caja para * * llamar la atención. * **************************************/

En C++ se admite el mismo tipo de comentarios que en C, pero además se considera que son comentarios todo aquel texto que está desde dos barras consecutivas (//) hasta el fin de la línea2. Las dos barras marcan el comienzo del comentario y el fin de la línea, el final. Si se desea poner comen- tarios de varias líneas, hay que colocar la doble barra al comienzo de cada línea. Los ejemplos ante- riores se podrían escribir del siguiente modo:

// Esto es un comentario simple.

// Esto es un comentario más largo, // distribuido en varias líneas. El // texto se suele indentar por la izquierda.

//************************************* // Esto es un comentario de varias * // líneas, encerrado en una caja para * // llamar la atención. * //*************************************

La ventaja de este nuevo método es que no se pueden comentar inadvertidamente varias líneas de un programa abriendo un indicador de comentario que no se cierre en el lugar adecuado.

2 El ANSI C permite el mismo tipo de comentarios que el C++, utilizando la doble barra //.

ESIISS: Aprenda C++ como si estuviera en Primero página 6

2.6 Declaración simplificada de variables tipo enumeración

Las enumeraciones (variables enum) permiten definir variables de tipo entero con un número pe- queño de valores que están representados por identificadores alfanuméricos. Estos identificadores permiten que el programa se entienda más fácilmente, dando un significado a cada valor de la va- riable entera. Las variables tipo enum son adecuadas para representar de distintas formas valores binarios (SI o NO; VERDADERO o FALSO; EXITO o FRACASO, etc.), los días de la semana (LUNES, MARTES, MIERCOLES, ...), los meses del año (ENERO, FEBRERO, MARZO, ...), y cualquier conjunto análogo de posibles valores. En C las variables de tipo enum se hacían corres- ponder 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áti- co). 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.

La principal razón de ser de las variables enum es mejorar la claridad y facilidad de compren- sión de los programas fuente.

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 constan- tes 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 es- tilí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 identifica- dores, 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. Por ejemplo, en el caso anterior al AMARILLO se le asigna un 8, que es el número siguiente al asignado al AZUL.

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:

Capítulo 2: Modificaciones menores página 7

color pintura, fondo; // esto es C++

Así pues en C++ no es necesario volver a utilizar la palabra enum. Los valores que pueden tomar las variables pintura y fondo son los que puede tomar una variable del tipo color, es decir: ROJO, VERDE, AZUL Y AMARILLO. 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 asociado3.

2.7 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 pala- bra 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 */

2.8 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 bloque4. 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 pue- de 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<n; 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.

3 En C++ se podría conseguir que escribiera correctamente el tipo enum, sobrecargando el operador << de modo

adecuado, según se verá en secciones posteriores. La opción por defecto es que el tipo enum se promueve a entero y se imprime su valor.

4 Un bloque es una unidad básica de agrupamiento de declaraciones e instrucciones encerrada entre llaves ({}).

ESIISS: Aprenda C++ como si estuviera en Primero página 8

2.9 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 pun- to 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 extien- de desde el punto de declaración hasta el final del fichero (otros ficheros 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 fichero o a nivel de clase. Este último concepto, la clase, es la base de la Programación Orientada a Objetos y se estudiará detenidamente a partir del Capítulo 3.

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 fichero –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 nom- bre u otra variable local también del mismo nombre declarada en un bloque más exterior. Por ejem- plo, puede suceder que en un bloque, hasta la declaración de una variable x se pueda estar utilizan- do otra variable con el mismo nombre x de otro bloque que contenga al primero. A partir de su de- claració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 clasevariables miembro– pueden ser declara- das como privadas o como públicas5. Las variables miembro que han sido declaradas como priva- das 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 funciones miembro de una clase tienen visibilidad directa sobre todas las va- riables 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 du- rante la ejecución del programa. La duración de una variable puede ser automatic(opción por de- fecto) o static. En el primer caso –el caso de las variables declaradas dentro de un bloque – la varia- ble se crea y se destruye cada vez que se pasa por el bloque. Las variables static existen hasta que

5 Más adelante se verá que existe una tercera forma de declarar las variables miembro: protected.

Capítulo 2: Modificaciones menores página 9

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 resolu- tion 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 global6. Considérese el siguiente ejemplo:

int a = 2; // declaración de una variable global a int main(void) { ... 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.

2.10 Especificador const para variables

En C++ el especificador const se puede utilizar con variables y con punteros7. Las variables defini- das como const no son lo mismo que las constantes simbólicas, aunque evidentemente hay una cier- ta 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 du- ració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 de- claració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++:

6 El operador (::) no puede utilizarse para ver una variable local oculta por otra variable local del mismo nombre. 7 En ANSI C el especificador const también se puede utilizar con variables y con punteros, pero con estos últimos

sólo de una de las dos formas posibles en C++.

ESIISS: Aprenda C++ como si estuviera en Primero página 10

int main(void) { const int SIZE = 5; char cs[SIZE] ; }

De todas formas, nunca puede declararse ninguna variable array cuyo tamaño sea desconoci- do en tiempo de compilación. Si el tamaño de una variable va a ser conocido sólo en tiempo de eje- cució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 sa- car 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 modifica- ció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.

2.11 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é apun- tar 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 compi- lador de C, pero da un mensaje de error con el compilador de C++8:

8 En ambos casos se ha utilizado el compilador de Visual C/C++ de Microsoft. La única diferencia es que el fichero

fuente termina en *.c para el compilador de C y en *.cpp para el compilador de C++.

Capítulo 2: Modificaciones menores página 11

#include <stdio.h> // <cstdio> si uso el compilador de C++ int main(void) { const int i = 2; int *p; p = &i; *p = 3; printf("i = %d", i); }

2.12 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 dis- pone 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 co- ciente entre las variables doublex 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);

2.13 Especificador inline para funciones

C++ permite sustituir, en tiempo de compilación, la llamada a una función por el código correspon- diente en el punto en que se realiza la llamada. De esta manera la ejecución es más rápida, pues no se pierde tiempo transfiriendo el control y realizando conversiones de parámetros. Como contrapar- tida, el programa resultante ocupa más memoria, pues es posible que el código de una misma fun- ción se introduzca muchas veces, con las repeticiones consiguientes. Las funciones inline resultan interesantes en el caso de funciones muy breves, que aparecen en pocas líneas de código pero que se ejecutan muchas veces (en un bucle for, por ejemplo). Existen 2 formas de definirlas:

1. Una primera forma de utilizar funciones inline es anteponer dicha palabra en la declara- ción de la función, como por ejemplo: inline void permutar(int &a, int &b);

2. Otra forma de utilizar funciones inline sin necesidad de utilizar esta palabra es introducir el código de la función en la declaración (convirtiéndose de esta manera en definición), poniéndolo entre llaves { } a continuación de ésta. Este segundo procedimiento suele uti- lizarse por medio de ficheros header (*.h), que se incluyen en todos los ficheros fuente que tienen que tener acceso al código de las funciones inline. Considérese el siguiente ejemplo, consistente en una declaración seguida de la definición: void permutar (int *i, int *j) { int temp; temp = *i; *i = *j; *j = temp; }

En cualquier caso, la directiva inline es sólo una recomendaciónal compilador, y éste puede desestimarla por diversas razones, como coste de memoria excesivo, etc.

ESIISS: Aprenda C++ como si estuviera en Primero página 12

2.14 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 eje- cució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 abso- luto de una variable, todas con el mismo nombre abs(), pero cada una aceptando un tipo de argu- mento 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 re- torno, 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.

A continuación se presenta un ejemplo con dos funciones sobrecargadas, llamadas ambas string_copy(), para copiar cadenas de caracteres. Una de ellas tiene dos argumentos y la otra tres. Cada una de ellas llama a una de las funciones estándar del C: strcpy() que requiere dos argumen- tos, y strncpy() que requiere tres (el tercer argumento es el nº de caracteres copiados). El número de argumentos en la llamada determinará la función concreta que vaya a ser ejecutada:

// Ejemplo de función sobrecargada #include <iostream> #include <cstring> inline void string_copy(char *copia, const char *original) { strcpy(copia, original); } inline void string_copy(char *copia, const char *original, const int longitud) { strncpy(copia, original, longitud); } static char string_a[20], string_b[20]; int main(void) { string_copy(string_a, "Aquello"); string_copy(string_b, "Esto es una cadena", 4); std::cout << string_b << " y " << string_a; // La última sentencia es equivalente a un printf() de C // y se explica en un próximo apartado de este manual }

2.15 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.

Capítulo 2: Modificaciones menores página 13

En C++ la situación es diferente pues se pueden definir valores por defecto para todos o algu- nos 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 argumen- tos de la lista. Si se omite un argumento deben de omitirse todos aquellos que se encuentren detrás suyo.

2.16 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 <cstdio> #include <cstdlib> int main(void) { 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 variable9, é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 obli- ga 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– lla- mado tipo referencia (reference).

9 En realidad se pasa una copia de la dirección de la variable

ESIISS: Aprenda C++ como si estuviera en Primero página 14

Las variables referencia se declaran por medio del carácter (&)10. 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 refe- rencia en lugar de punteros.

// Este programa requiere compilador de C++ #include <cstdio> #include <cstdlib> int main(void) { 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 argu- mentos 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 ope- rador (&) 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 funcio- nes. 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.

10 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 (*).

Capítulo 2: Modificaciones menores página 15

El que una función tenga como valor de retorno una variable tipo referencia permite utilizar- la 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 per- mite utilizarla, por ejemplo, del siguiente modo:

maxref(i, j) = 0;

Ésta 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 va- lor 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 valo- res 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.

2.17 Operadores new y delete para gestión dinámica de memoria

Hasta ahora sólo se han visto dos posibles tipos de duración de las variables: static, las cuales exis- ten durante toda la ejecución del programa, y automatic, que existen desde que son declaradas hasta que finaliza el bloque donde han sido declaradas.

Con los operadores new y delete el programador tiene entera libertad para decidir crear o des- truir sus variables cuando las necesite. Una variable creada con el operador new dentro de cualquier bloque, perdura hasta que es explícitamente borrada con el operador delete. Puede traspasar la fron- tera de su bloque y ser manipulada por instrucciones de otros bloques.

Un aspecto diferente con la función malloc(), que es el método más utilizado para reservar di- námicamente memoria en ANSI C, es que ésta devuelve un puntero a void (*void) que es después convertido al tipo de variable que se desea. Esa conversión se evita con new, eliminando así una posible fuente de problemas.

Se puede utilizar el operador new para crear variables de cualquier tipo. Newdevuelve, en to- dos los casos, un puntero a la variable creada. También se pueden crear variables de tipos definidos por el usuario.

struct usuario { .......... }; usuario* Un_Usuario; Un_Usuario = new usuario;

Cuando una variable ya no es necesaria se destruye con el operador delete para poder utilizar la memoria que estaba ocupando, mediante una instrucción del tipo:

ESIISS: Aprenda C++ como si estuviera en Primero página 16

delete p;

A continuación se presenta a modo de ejemplo un programa que reserva memoria de modo dinámico para un vector de caracteres:

#include <iostream> #include <cstring>

int main() { char Nombre[50]; std::cout << "Introduzca su Nombre:"; std::cin >> Nombre; char *CopiaNombre = new char[strlen(Nombre)+1]; // Se copia el Nombre en la variable CopiaNombre strcpy(CopiaNombre, Nombre); std::cout << CopiaNombre; delete [] CopiaNombre; }

El siguiente ejemplo reserva memoria dinámicamente para una matriz de doubles: #include <iostream> int main() { int nfil=4, ncol=3, i, j; double **mat; // se reserva memoria para el vector de punteros mat = new double*[nfil]; // se reserva memoria para cada fila for (i=0; i<nfil; i++) mat[i] = new double[ncol]; // se inicializa toda la matriz for(i=0; i<nfil; i++) for(j=0; j<ncol; j++) mat[i][j]=i+j; // se imprime la matriz for(i=0; i<nfil; i++){ for(j=0; j<ncol; j++) std::cout << mat[i][j] << "\t"; std::cout << "\n"; } // se libera memoria for(i=0; i<nfil; i++) // se borran las filas de la matriz delete [] mat[i]; // se borra el vector de punteros delete [] mat; }

2.18 Punteros de tipo void

Esta posibilidad ya está presente en el ANSI C pero conviene citarla aquí también. Un puntero a void es un puntero que no conoce en el momento de su definición a qué tipo de dato va a apuntar. Un buen ejemplo de esto es el valor de retorno de la función malloc(). Esta función reserva memo- ria dinámicamente para cualquier tipo de dato, incluso para aquellos tipos de datos que haya defini- do el usuario.

Capítulo 2: Modificaciones menores página 17

2.19 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 librería ios- tream con la instrucción #include <iostream>. Así en un programa en C habría que hacer algo de este estilo:

char nombre; int num=2; printf ("Introduzca el nombre del fichero %d: ", num); scanf (" %s", nombre)

En C++ podría escribirse así: char nombre; int num=2; std::cout << "Introduzca el nombre del fichero " << 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 sobrecargados11 de tal manera que admiten tanto los tipos predefinidos como aquellos tipos de datos definidos por el usuario.

Para poder escribir o leer desde ficheros es necesario incluir la librería <fstream>. A conti- nuación se presenta un sencillo ejemplo en el que primero se escriben unas frases en un fichero y después se imprimen en la pantalla leídas desde ese fichero:

// Programa de lectura y escritura de ficheros #include <fstream> #include <iostream> int main(void) { std::ofstream out("fichero.h"); // se define un flujo de salida a fichero out << "Estamos aprendiendo "; out << "como se escribe en un fichero "; out << "y como se lee desde el."; out.close(); // Ahora comienza la lectura std::ifstream in("fichero.h"); // se define un flujo de entrada de fichero const int SIZE=81; char line[SIZE]; in.getline(line, SIZE); std::cout << line << std::endl; in.getline(line, SIZE); std::cout << line << std::endl; in.getline(line, SIZE); std::cout << line << std::endl; }

11 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.

ESIISS: Aprenda C++ como si estuviera en Primero página 18

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 objeto12 del tipo std::ofstream llamado out. Este será un objeto que almace- nará la información necesaria para llevar los datos de salida hasta un fichero llamado fi- chero.h. Esto es el equivalente a utilizar la función fopen() de ANSI C para abrir un fiche- ro de escritura de datos.

• Hay que darse cuenta de que la primera vez que se abre el fichero se abre en modo de es- critura. Por eso hay que cerrarlo para después poder abrirlo en modo de lectura. Para reali- zar esta última operación es necesario declarar un objeto, al que se llama in, del tipo std::ifstream. El std::endl del final de las líneas de impresión en pantalla hace que se im- prima 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 for- ma similar a la que lo haría la función scanf() leyendo una línea completa hasta el '\n'.

2.20 Funciones con número de parámetros variable

Se pueden definir, tanto en ANSI C como en C++, funciones con un número variable y desconocido a priori de argumentos. Un ejemplo de función de este tipo es la propia función main() con argu- mentos, y otros ejemplos, de sobra conocidos, son las funciones printf() y scanf().

Para definir estas funciones se utilizan los puntos suspensivos (...), que representan los argu- mentos desconocidos que puede haber. Un ejemplo de función de este tipo es el siguiente:

void mi_funcion(int i, double a, ...);

donde los argumentos i y a tendrían que estar siempre presentes. Para conocer con más detalle có- mo se crean estas funciones se recomienda acudir a alguno de los textos de C++ recomendados en la Bibliografía.

12 El concepto de objeto, básico en C++, se explica con todo detalle en el Capítulo 3.

Capítulo 3: Modificaciones mayores página 19

3 MODIFICACIONES MAYORES

3.1 Introducción a la Programación Orientada a Objetos (OOP)

La Programación Orientada a Objetos (POO) permite realizar grandes programas mediante la unión de elementos más simples, que pueden ser diseñados y comprobados de manera independien- te del programa que va a usarlos. Muchos de estos elementos podrán ser reutilizados en otros pro- gramas.

A estas “piezas”, “módulos” o "componentes", que interactúan entre sí cuando se ejecuta un programa, se les denomina objetos. Estos objetos contienen tanto datos como las funciones que actúan sobre esos datos.

De ordinario, cada uno de estos objetos corresponde a algún elemento que debe utilizar el programa. Algunos de estos elementos representan entidades del mundo real (matrices, personas, cuentas de banco, elementos mecánicos o eléctricos, ...) y otros pueden ser componentes del orde- nador (tanto de software como de hardware: otro programa, un fichero de disco, una impresora co- nectada en una puerta serie, una ventana abierta en la pantalla, ...). También pueden ser estructuras de datos: colas, pilas, ...

Durante la ejecución del programa, los objetos interactúan pasándose mensajes y respuestas. Es fundamental darse cuenta de que un objeto no necesita conocer el funcionamiento interno de los demás objetos para poder interactuar con ellos (igual que el hombre no necesita conocer cómo fun- ciona por dentro un televisor o un ordenador para poder utilizarlos), sino que le es suficiente con saber la forma en que debe enviarle sus mensajes y cómo va a recibir la respuesta (al hombre le puede ser suficiente con saber cómo funcionan el interruptor, el dial del volumen y los botones de cambio de canal para utilizar un televisor).

Sucede a menudo que hay que utilizar varios ejemplares análogos de un determinado elemen- to u objeto (por ejemplo varias ventanas en la pantalla del PC, varios usuarios, varios clientes, va- rias cuentas corrientes de un banco, etc.). La definición genérica de estos objetos análogos se reali- zar mediante la clase. Así, una clase contiene una completa y detallada descripción de la informa- ción y las funciones que contendrá cada objeto de esa clase. Por ejemplo, en el siguiente código,

struct Alumno { long nmat; char nombre[41]; }; Alumno alu1={76986, "Luis Perez"}, alu2 = { 67549, "Mikel Lasa"};

se definen las variables miembro que va a tener la estructura Alumno y luego se crean dos variables alu1 y alu2 de esa estructura. En C++ los objetos son las variables concretas que se crean de una determinada clase. A veces se llaman también instances o data objects.

Las clases de C++ son como una generalización de las estructuras de C.

En C++ las clases son verdaderos tipos de datos definidos por el usuario y pueden ser utiliza- dos de igual manera que los tipos de datos propios del C++, tales como int o float. Los objetos son a las clases como las variables a los tipos de variables. Un objeto tiene su propio conjunto de datos o variables miembro, aunque no de funciones, que aunque se aplican a un objeto concreto son pro- pias de la clase a la que pertenece el objeto.

Deja tu opinión sobre estos apuntes
Yeah ya era hora!! XD
1-5 de 10
Esta solo es una vista previa
3 páginas mostradas de 92 páginas totales
Descarga el documento