Clases genéricas
Ejemplo
En el presente ejemplo se ha cambiado el diseño de un caso anterio
( 4.9.18d1); pero aquí
mVector es ahora una clase genérica (
4.12.2) en vez de una clase específica como en el original. Se trata de una versión "tal
cual", es decir, intentando reducir al mínimo los cambios al diseño original.
Observe que los cambios se refieren casi exclusivamente a la sintaxis de la definición de mVector (L.13) y a la sustitución de las referencias a Vector por el argumento T.
Los únicos cambios introducidos en la función main se refieren a la sintaxis empleada en M.1, M.8 y M.13 para instanciar objetos mVector utilizando <Vector> como argumento.
#include <iostream>
using namespace std;
class Vector { // clase auxiliar
public: int x, y;
Vector& operator= (const Vector& v) {
x = v.x; y = v.y;
return *this;
}
void showV() { cout << "X = " << x << "; Y = " << y << endl; }
};
template<class T> class mVector { // L.13 plantilla mVector
int dimension;
public:
T* mVptr;
mVector& operator=(const mVector& mv) { // Operador =
delete [] mVptr;
dimension = mv.dimension;
mVptr = new T[dimension];
for(int i = 0; i<dimension; i++) {
mVptr[i]= mv.mVptr[i];
}
return *this;
}
mVector(int n = 1) { // constructor por defecto
dimension = n;
mVptr = new T[dimension];
}
~mVector() {
// destructor
delete [] mVptr;
}
mVector(const mVector& mv) { // constructor-copia
dimension = mv.dimension;
mVptr = new T[dimension];
for(int i = 0; i<dimension; i++) {
mVptr[i]= mv.mVptr[i];
}
}
T& operator[](int i) { return mVptr[i]; }
void showmem (int); // Función auxiliar
void show ();
// Función auxiliar
};
template <class T> void mVector<T>::showmem (int i) {
if((i >= 0) && (i <= dimension)) mVptr[i].showV();
else cout << "Argumento incorrecto! pruebe otra vez" << endl;
}
template <class T> void mVector<T>::show () {
cout << "Matriz de: " << dimension << " elementos." << endl;
for (int i = 0; i<dimension; i++) {
cout << i << "- ";
mVptr[i].showV();
}
}
void main() { // =====================
mVector<Vector> mV1(5); // M.1
mV1[0].x = 0; mV1[0].y = 1;
mV1[1].x = 2; mV1[1].y = 3;
mV1[2].x = 4; mV1[2].y = 5;
mV1[3].x = 6; mV1[3].y = 7;
mV1[4].x = 8; mV1[4].y = 9;
mV1.show();
mVector<Vector> mV2 = mV1; // M.8
mV2.show();
mV1[0].x = 9; mV1[0].y = 0;
mV2.showmem(0);
mV1.showmem(0);
mVector<Vector> mV3(0); // M.13
mV3.show();
mV3 = mV1; mV3.show();
}
Salida:
Matriz de: 5 elementos.
0- X = 0; Y = 1
1- X = 2; Y = 3
2- X = 4; Y = 5
3- X = 6; Y = 7
4- X = 8; Y = 9
Matriz de: 5 elementos.
0- X = 0; Y = 1
1- X = 2; Y = 3
2- X = 4; Y = 5
3- X = 6; Y = 7
4- X = 8; Y = 9
X = 0; Y = 1
X = 9; Y = 0
Matriz de: 0 elementos.
Matriz de: 5 elementos.
0- X = 9; Y = 0
1- X = 2; Y = 3
2- X = 4; Y = 5
3- X = 6; Y = 7
4- X = 8; Y = 9
Comentario
Como cabía esperar, la salida es exactamente la misma que en el ejemplo tomado como modelo, por lo que remitimos al mismo para cualquier detalle al respecto.