0
Ficheros de cabecera
En los siguientes ejemplos usaremos varios ficheros fuente. Más concretamente, crearemos algunos ficheros para definir plantillas que usaremos en programas de ejemplo.
Dado que algunas de esas plantillas se podrán usar en varios programas diferentes, es buena idea definir cada una en un fichero separado, que se pueda incluir desde otros ficheros fuente para hacer uso de esas plantillas.
Generalmente, un fichero de cabecera suele contener sólo declaraciones, de clases, tipos y/o funciones. En el caso de plantillas, también se incluye el código, pero esto es sólo en apariencia.
Es un error ver la implementación de las plantillas como código, ya que el compilador usa las plantillas para generar código que posteriormente compila, pero el código de una plantilla no es compilable. En realidad es sólo un molde para crear clases, y esas son las clases que se pueden compilar.
De modo que el código de una plantilla se suele escribir en el mismo fichero de cabecera que el resto de la declaración de plantilla.
Esta filosofía, la de crear ficheros de cabecera, es la que se debe seguir para reutilizar el código. Si hemos diseñado una clase o la plantilla de una clase que nos puede ser útil en otros proyectos, es buena idea convertirla en un fichero de cabecera, y llegado el caso, en una biblioteca externa.
Hay una precaución que se debe tomar siempre cuando se escriben ficheros de cabecera.
Debido a que el mismo fichero de cabecera puede ser incluido desde varios ficheros fuente de un mismo proyecto, es imprescindible diseñar un mecanismo que evite que se declaren las mismas clases, tipos o funciones varias veces. Esto provocaría errores de compilación, y harían imposible compilar el proyecto completo.
Esto es secillo, nos basamos en si una macro está o no definida, y haremos una compilación condicional del código en función de que la macro esté o no definida. Es importante elegir un nombre único para la macro. Lo normal es crear un identificador en función del nombre del fichero de cabecera.
Por ejemplo, si tenemos un fichero llamado "ccadena.h", el identificador de la macro podría ser CCADENA_H, o _CCADENA_H, o CCADENA, etc.
El fichero tendría esta estructura:
|
// Zona de comentarios, fechas, versiones, autor y propósito del fichero
#ifndef CCADENA
#define CCADENA
// Zona de código
#endif
{/ejemplo}
<p>De este modo, la primera vez que se incluye este fichero la macro CCADENA no está definida. Lo
primero que hacemos es definirla, y después incluimos el código del fichero de cabecera.</p>
<p>En posteriores inclusiones la macro sí está definida, de modo que no se incluye nada de código, y
no necesitamos definir la macro, ya que ya lo estaba.</p>
<a name="042_ejemplo"></a><h3>Ejemplo de uso de plantilla Tabla</h3>
<p>Vamos a ver un ejemplo completo de cómo aplicar la plantilla anterior a
diferentes tipos.</p>
<p>Fichero de cabecera que declara y define la plantilla Tabla:</p>
{ejemplo}
// Tabla.h: definición de la plantilla tabla:
// C con Clase: Marzo de 2002
#ifndef T_TABLA
#define T_TABLA
template <class T>
class Tabla {
public:
Tabla(int nElem);
~Tabla();
T& operator[](int indice) { return pT[indice]; }
int NElementos() const { return nElementos; }
private:
T *pT;
int nElementos;
};
// Definición:
template <class T>
Tabla<T>::Tabla(int nElem) : nElementos(nElem) {
pT = new T[nElementos];
}
template <class T>
Tabla<T>::~Tabla() {
delete[] pT;
}
#endif |
Fichero de aplicación de plantilla:
|
// Tabla.p: ejemplo de Tabla
//Mayo 2015 Tutoriales En Linea
#include <iostream>
#include "Tabla.h"
using namespace std;
conts int nElementos = 10;
int main() {
Tabla<int> TablaInt(nElementos);
Tabla<float> TablaFloat(nElementos);
for(int i = 0; i < nElementos; i++)
TablaInt[i] = nElementos-i;
for(int i = 0; i < nElementos; i++)
TablaFloat[i] = 1/(1+i);
for(int i = 0; i < nElementos; i++) {
cout << "TablaInt[" << i << "] = "
<< TablaInt[i] << endl;
cout << "TablaFloat[" << i << "] = "
<< TablaFloat[i] << endl;
}
return 0;
} |
Posibles problemas
Ahora bien, supongamos que quieres usar la plantilla Tabla para crear una tabla de cadenas. Lo primero que se nos ocurre hacer probablemente sea:
Tabla<char*> TablaCad(15);
No hay nada que objetar, todo funciona, el programa compila, y no hay ningún error, pero... es probable que no funcione como esperas. Veamos otro ejemplo:
Fichero de aplicación de plantilla:
|
// Tablacad.p: ejemplo de Tabla con cadenas
// C con Clase: Marzo de 2002
#include <iostream>
#include <cstring>
#include <cstdio>
#include "Tabla.h"
using namespace std;
const int nElementos = 5;
int main() {
Tabla<char *> TablaCad(nElementos);
char cadena[20];
for(int i = 0; i < nElementos; i++) {
sprintf(cadena, "Numero: %5d", i);
TablaCad[i] = cadena;
}
stry(cadena, "Modificada");
for(int i = 0; i < nElementos; i++)
cout << "TablaCad[" << i << "] = "
<< TablaCad[i] << endl;
return 0;
} |
Si has compilado el programa y has visto la salida, tal vez te sorprenda algo el resultado: Efectivamente, parece que nuestra tabla no es capaz de almacenar cadenas, o al menos no más de una cadena. La cosa sería aún más grave si la cadena auxiliar fuera liberada, por ejemplo porque se tratase de una variable local de una función, o porque se tratase de memoria dinámica.
TablaCad[0] = Modificada
TablaCad[1] = Modificada
TablaCad[2] = Modificada
TablaCad[3] = Modificada
TablaCad[4] = Modificada
¿Cuál es el problema?
Lo que pasa es que nuestra tabla no es de cadenas, sino de punteros a char. De hecho eso es lo que hemos escrito Tabla<char *>, por lo tanto, no hay nada sorprendente en el resultado. Pero esto nos plantea un problema: ¿cómo nos las apañamos para crear una tabla de cadenas?
Tablas de cadenas
La solución es usar una clase que encapsule las cadenas y crear una tabla de objetos de esa clase.
Veamos una clase básica para manejar cadenas:
|
// CCadena.h: Fichero de cabecera de definición de cadenas
//Mayo 2015 Tutoriales En Linea
#ifndef CCADENA
#define CCADENA
#include <cstring>
using std::stry;
using std::strlen;
class Cadena {
public:
Cadena(const char *cad) {
cadena = new char[strlen(cad)+1];
stry(cadena, cad);
}
Cadena() : cadena(NULL) {}
Cadena(const Cadena &c) : cadena(NULL) {*this = c;}
~Cadena() { if(cadena) delete[] cadena; }
Cadena &operator=(const Cadena &c) {
if(this != &c) {
if(cadena) delete[] cadena;
if(c.cadena) {
cadena = new char[strlen(c.cadena)+1];
stry(cadena, c.cadena);
}
else cadena = NULL;
}
return *this;
}
const char* Lee() const {return cadena;}
private:
char *cadena;
};
std::ostream& operator<<(std::ostream &os, const Cadena& cad) {
os << cad.Lee();
return os;
}
#endif |
Usando esta clase para cadenas podemos crear una tabla de cadenas usando nuestra plantilla:
| // Tabla.p: ejemplo de Tabla de cadenas
//Mayo 2015 Tutoriales En Linea
#include <iostream>
#include <cstdio>
#include "Tabla.h"
#include "CCadena.h"
using namespace std;
const int nElementos = 5;
int main() {
Tabla<Cadena> TablaCad(nElementos);
char cadena[20];
for(int i = 0; i < nElementos; i++) {
{f:sprintf}(cadena, "Numero: %2d", i);
TablaCad[i] = cadena;
}
stry(cadena, "Modificada");
for(int i = 0; i < nElementos; i++)
cout << "TablaCad[" << i << "] = "
<< TablaCad[i] << endl;
return 0;
}
|
Ejecutar este código en codepad.
La salida de este programa es:
|
TablaCad[0] = Numero: 0
TablaCad[1] = Numero: 1
TablaCad[2] = Numero: 2
TablaCad[3] = Numero: 3
TablaCad[4] = Numero: 4 |
Ahora funciona como es debido.
El problema es parecido al que surgía con el constructor copia en clases que usaban memoria dinámica. El funcionamiento es correcto, pero el resultado no siempre es el esperado. Como norma general, cuando apliquemos plantillas, debemos usar clases con constructores sin parámetros, y tener cuidado cuando las apliquemos a tipos que impliquen punteros o memoria dinámica.
Ir al Principio
Comentarios