¡o cómo aprender C++ en 1 hora!

  Enrique Alba Torres

Cuando deseemos crear un objeto de una clase definida lo que haremos será lo siguiente:

Nombre de la Clase Nombre del Objeto;

También se puede crear una clase usando la palabra clave struct, la diferencia es que con struct los miembros se hacen públicos por defecto, mientras que con class se hacen privados por defecto.

public, private o protected

El cuerpo de un método, puede o bien incluirse en la definición de una clase, en cuyo caso lo llamaremos método inline, o bien en un archivo fuera de la clase.

Para que C++ sepa cuándo una función es simplemente una función, y cuándo es un método, en éste último caso siempre debemos poner al método como prefijo el nombre de la clase a la que pertenece seguido de :: (operador de ámbito).

En la definición de la clase anterior pueden verse dos variantes, en la primera los métodos se definen dentro de la misma clase, mientras que en la segunda sólo se incluye en la clase un prototipo de los métodos, su implementación está fuera. Los métodos cuya definición se incluye en la clase se denominan Métodos inline.

En el caso de emplear métodos inline, vamos a tener como beneficio que la ejecución va a ser más rápida, pero sin embargo, el código objeto que genera el compilador va a ser mayor.

2.5.1. cin y cout

cin y cout son dos flujos (entrada y salida) de datos pertenecientes a la biblioteca de C++ llamada iostream, y se utilizan para lo siguiente:

cin>>dato : Almacena el carácter introducido por teclado en dato.

cout<<dato : Lee el contenido de dato y lo muestra por pantalla.

Una clase puede tener uno o varios constructores, pero un sólo destructor. El constructor debe tener el mismo nombre que la clase a la que pertenece, mientras que el destructor también debe llamarse de igual forma pero precedido por el carácter ~ .

Al haber creado un constructor que toma un parámetro - la cadena a asignar a la cadena que se está declarando -, ya no es posible crear un objeto de clase Cadena sin ese parámetro. Puesto que es posible tener varios constructores, estamos usando sobrecarga. También se puede tener un constructor que por ejemplo inicialice a nulo todos los datos miembros de la clase.

En el ejemplo anterior, se observa que el operador de concatenación devuelve un objeto de la clase Cadena a fin de que ese valor de retorno se asigne a algún objeto de la forma C3=C1+C2. Sin embargo, no se ha definido el operador = para esta clase, y esto va a funcionar a pesar de ello porque por defecto el operador = hace una copia bit a bit. Por el contrario sí va a haber problemas cuando ocurra que el operando de destino (C2=C1) apunte a alguna dirección de memoria y con esta asignación se pierda. Para evitar este problema, se usa el constructor de copia y asignación, definiendo el método operator=(). Sin embargo, hay a veces un problema con este operador que nos lleva a que tengamos que sobrecargarlo.

Esto sí es correcto, porque estamos asignando a C1 un char *, que sería la cadena "Hola, mundo", que será lo que reciba como parámetro el constructor de la clase Cadena:

Esto no sería correcto hasta que no se cree un constructor que recibiendo un objeto de la clase Fecha cree un objeto de la clase Cadena. En el otro caso, es decir, convertir un dato de nuestra clase en otro tipo, hay que sobrecargar los operadores de moldeado o casts.

Por ejemplo, si queremos mostrar por pantalla la cadena de caracteres que tiene un objeto, así como su longitud, no podríamos hacer cout<<C1, sino que tendríamos que especificar el tipo básico de datos que queremos mostrar, es decir, debemos hacer lo siguiente: cout<<(char *) C1; cout<<(int) C1;

El destructor, como se mencionó antes, se distingue del resto de miembros de una clase porque va precedido por el carácter ~ . Cada vez que un objeto deja de ser útil, se llamará al destructor del objeto, que realizará sobre éste las últimas operaciones que sean necesarias. Si no se provee de un destructor se creará uno por defecto, que destruirá el objeto, sin tener en cuenta posibles liberaciones de memoria.

Se llama Asignación Dinámica de Memoria al proceso mediante el cual, se va reservando memoria a medida que vaya haciendo falta, y se va liberando cuando ya no sea útil. Algunos ejemplos son los vistos antes con new y delete.

Un objeto también se puede crear explícitamente por medio del operador new, que asignará la memoria necesaria para contener al objeto y devolverá un puntero al objeto en cuestión.

El operador new siempre va seguido de un parámetro que indica el tipo de objeto que se quiere crear. De este parámetro, new obtiene el número de bytes necesarios para almacenar el objeto, y a continuación buscará un bloque de memoria apropiado, lo asigna al programa y devuelve su dirección. En este caso, accederemos a los miembros de la clase mediante el operador ->, y por medio de * accedemos al contenido. Lo que ocurre es que un objeto creado con new no se destruirá automáticamente cuando quede fuera de su ámbito, sino que ha de usarse para liberar memoria el comando delete. Al crear un objeto con new detrás del nombre de la clase se le puede hacer una asignación poniéndola entre paréntesis.

El operador new devuelve la dirección de memoria reservada para el objeto que se crea, pero esto lo hará siempre y cuando no haya problemas. Si no hay memoria suficiente devolverá un valor NULL. Por tanto, para controlar tales tipos de problemas lo que podemos hacer es crearnos una función que los trate.

Esto puede automatizarse en C++ usando la función set_new_handler() a la que se le pasará como parámetro el nombre de la función que maneja el error. Es necesario para poder usarlo incluir el fichero cabecera new.h.

El operador new, así como el delete, se pueden sobrecargar y así particularizar su funcionamiento dentro de una clase. new toma como parámetro size_t, indicando el tamaño del objeto a crear, y devuelve un puntero de tipo void. Delete por su parte, recibe un puntero void y no devuelve nada.

Además de new y delete también podemos utilizar malloc() o free().

Por ejemplo, supongamos que a partir de la clase Ventana, que permite gestionar ventanas en modo texto, queremos crear una clase Ventanagrafica que las gestiona en modo gráfico. Para ello empleamos el siguiente código:

.

Todo va a depender del cualificador que se utilice delante del nombre de la clase base: public o private.

Los miembros de la clase base que sean private no serán accesibles en la clase derivada en ningún momento.

Los miembros de la clase base que sean declarados protected serán accesibles en la clase derivada, aunque no fuera de ella, es decir, que si una clase deriva de forma privada miembros protegidos de la base, en la derivada van a ser accesibles, pero en una futura derivada de la actual derivada van a ser privados.

Si por el contrario, se derivan como public, en la clase derivada van a seguir siendo públicos, pero si se deriva de forma privada, serán privados.

Para hacer uso de la clase base es necesario usar el operador :: precedido del nombre de dicha clase.

Un objeto de una clase derivada tendrá más información que uno de la clase base. Así, esto nos va a permitir hacer asignaciones de un objeto de la clase derivada a otro de la clase base, aunque no al revés, es decir, BASE=DERIVADA, pero no al revés.

En este ejemplo, el objeto A está compuesto de un miembro -un entero-, mientras que B está compuesto de dos miembros -el entero heredado y el suyo propio-. Por tanto, B tiene información suficiente para "llenar" el objeto A, pero no así en sentido contrario.

Para construir una clase derivada tomando varias como base, se pondrán los nombres de cada una de las clases base separadas por coma, antecedidos, cada una de la palabra public o private. Siempre que sea posible evite usar herencia múltiple.

Para hacer que una función sea amiga de una clase y tenga acceso a todos sus miembros, habrá que definir un prototipo de esa función dentro de la clase, precediendo a la definición con la palabra friend.

a.- Que la clase almacene todos sus datos como punteros a void

template <class X,class Y,.....>

Con la palabra template estamos indicando al compilador que estamos creando una función general, (una plantilla) a partir de la cual deberá posteriormente ir creando las funciones adecuadas.

Los identificadores X e Y, representan dos clases con las que al usar la función se debe instanciar la plantilla, y pueden usarse para indicar el tipo del valor devuelto, el tipo de los parámetros que recibe la función o para declarar variables dentro de ella.

Lo que diferencia una plantilla de clase de una plantilla de función es que en lugar de tener la definición de una función detrás de template y los argumentos, vamos a tener la definición de una clase.

A la hora de implementar los métodos de la clase es obligatorio encabezar cada método de la misma forma que la clase, con la palabra template y los parámetros adecuados.

Los miembros y métodos de una clase pueden declararse estáticos anteponiendo la palabra static.

En cuanto a los métodos declarados como estáticos, debemos decir que no han de estar relacionados con objeto alguno de dicha clase. Un método estático no puede ser nunca virtual.

Un miembro declarado con const, no puede sufrir modificaciones, tan sólo una inicialización en el momento en que se crea. También un miembro de una clase puede declararse constante, impidiendo que cualquier otro método que no sea el constructor y el destructor lo trate. Ni siquiera el constructor puede asignar un valor al campo directamente, sino que tendrá que llamar al constructor del miembro que se va a inicializar.

Sin embargo, si queremos que algunos métodos puedan hacer uso de estos miembros, lo que hacemos es poner detrás el modificador const.

En algunos compiladores como Borland C++ no existen plantillas o templates, con el consiguiente problema de que hay que crearse una clase para cada tipo. Sin embargo, para solucionar este problema y no tener que hacer algo así, podemos hacer uso de los llamados toren-pasting.

Normalmente, las definiciones de las clases están incluidas en ficheros cabecera, existiendo un archivo de cabecera por cada clase que definamos. En este archivo incluiremos la definición de la clase, cualquier constante, enumeración, etc..., que se pueda usar con un objeto de la clase y los métodos inline, ya que estos necesitan estar definidos antes de usarse.

En cada uno de los archivos que necesiten hacer uso de una clase será necesario incluir los archivos cabecera en los cuales están definidas las clases que van a ser usadas. Sin embargo, normalmente estas bibliotecas son compiladas obteniendo ficheros.OBJ que serán enlazados junto a las aplicaciones.

En el caso de que tengamos varios ficheros se puede, o bien generar un código objeto por cada uno de los archivos fuente, o bien varios archivos. OBJ, o bien unirlos todos en una biblioteca.LIB.

Con el enlace seguro podemos dar la característica de sobrecarga a funciones implementadas en C que queremos usar en C++. Para ello, ponemos en la declaración del prototipo extern "c".

.

Todos los streams van a disponer de estos dos operadores. El operador de inserción, <<, es el operador de desplazamiento de bits a la izquierda, que está definido en la clase ostream perteneciente a iostream.h, y >>, es el operador de desplazamiento a la derecha y está definido en la clase istream, definida en el mismo archivo cabecera.

Estos operadores van a disponer a su izquierda un objeto stream que será origen o destino, dependiendo del operador usado, y a la derecha lo que se va a escribir o donde se va a almacenar lo leído. Ya se han usado streams: cout y cin que tienen por defecto la salida estándar (pantalla) y la entrada estándar (teclado). También existe cerr para la salida estándar de errores del programa.

Para fijar la anchura, tanto se puede usar el método width() como el manipulador setw(). Si se usa width() sin parámetro devolverá la anchura fijada, que por defecto es 0. Esto significa que se tomen los caracteres necesarios para la representación del dato en el stream de salida. Si le pasamos un parámetro se fijará la anchura a ese número de caracteres.

Cuando se ajusta una salida, y quedan espacios libres, estos se rellenan con espacios en blanco. Este carácter de relleno se puede modificar con el método fill() o el manipulador setfill().

Llamando a fill() nos devuelve el carácter de relleno que se está usando en ese momento.

Para números en punto flotante, a la hora de la salida se representa con todos sus dígitos, pero esto es alterable, o bien mediante el método precision(), o bien mediante el manipulador setprecision(), poniendo el número de dígitos a presentar en la salida como parámetro.

Normalmente, la entrada y salida de datos se hace en decimal, lo cual es modificable mediante dec(), hex(), oct(), y setbase(). Los tres primeros no necesitan parámetro alguno, pasando a base decimal, hexadecimal, u octal, mientras que la última necesitará recibir un entero indicando la base en la que se desea trabajar. No es necesario usar paréntesis en los tres primeros.

Para el objeto cout existen además:

ends() è sin parámetros

endl(): Inserta un retorno de carro.

ends(): Inserta un terminador de cadena.

flush(): Fuerza la salida de todos los caracteres del buffer al stream.

Todos ellos se pueden llamar con cout._____ o bien con cout<<_____.

Cin además tiene el manipulador ws, sin parámetros, que permite ignorar los espacios en blanco en las operaciones de entrada o lectura. Está activado por defecto.

Los dos primeros equivalen a los modificadores setioflags() y resetioflags(). Todos toman un entero largo que indica los indicadores a activar o desactivar. Pertenecen a la clase ios, de la cual se derivan las clases a las que pertenecen los objetos que se manejan.

Los métodos flags(), setf(), unsetf() devuelven un entero con el estado de los indicadores antes de alterarlos, siendo interesante almacenarlos para luego restituirlos.

Los operadores de inserción y extracción permiten realizar entradas y salidas con formato. Sin embargo, a veces puede ser necesario leer o escribir información sin formato alguno. Para ello también se dispone de algunos operadores en las clases istream y ostream.

get() es un método para realizar lecturas o entradas de datos desde un objeto. Sus posibles formas son:

get(): Toma el siguiente carácter y lo devuelve. En caso de que haya encontrado final del stream, devuelve EOF.

get(char *, int, char): El primer parámetro es la dirección donde se almacenará la cadena de caracteres, el segundo la longitud y el tercero el carácter delimitador, para que cuando lo encuentre se pare. Se va a detener cuando:

get(char &): Toma un carácter del stream y lo almacena en la variable cuya referencia se toma como parámetro.

El método getline() toma los mismos parámetros que get() y el mismo valor por defecto para el delimitador. Se almacena el delimitador antes de añadir el carácter nulo.

Mediante el método read() se puede leer un número de caracteres y almacenarlo en el espacio de memoria indicado. Sólo se detiene si llega al final del stream y no ha leído la cantidad indicada, pero no lo hace cuando se encuentre un delimitador o el carácter nulo.

Como primer parámetro pasamos el puntero a donde se almacenará la cadena, y como segundo la longitud. Mediante el método gcount() es posible saber el número de bytes leídos (nos lo devuelve).

.

A cada stream se le asocia un buffer, para mejorar los tiempos de acceso. Mediante el método rdbuf() obtenemos un puntero al buffer correspondiente a un stream. Los métodos que nos van a permitir acceder a estos buffers podemos dividirlos en tres grupos: