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.