CODIGO FUENTE: C++

TEMPLATES Y CONTAINERS

• Francisco González Parrón •

El siguiente código fuente está dirigido a la ordenación de vectores númericos, mediante el método de la burbuja (poco eficiente, fácil de entender y resultón), y que utiliza las conocidas "plantillas" (templates) y "contenedores" (containers) en C++. Con ello conseguimos solo escribir un método de ordenación y que nos sirve para cualquier tipo numérico, aumentando así la productividad. Entonces, para la pregunta ¿ y para los datos definidos por el usuario (registros, clases) ?, tan solo hay que sobrecargar los operadores de comparación y de asignación, definiendo como tienen que ser realizadas estas sobrecargas. Y por supuesto, para mayor eficiencia en la ordenación elegir otro método como puede ser Quick Sort, que queda propuesto como "ejercicio".

CODIGO FUENTE: 

// ----------------------------------------------------------------------------
// Codigo fuente compatible con cualquier compilador de C++ 
// estandard con la norma AT&T 3.0
//
// Autor: Francisco González Parrón
// Versión: Definitiva. 
// ----------------------------------------------------------------------------

#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#include <stdlib.h>

#define TRUE    1
#define FALSE   0

const int MAX = 100; // Nº  máximo de elementos

template < class TipoNum > class Orden
{
  private:
	TipoNum anNum[ 100 ]; // Datos
	void InterCambia( TipoNum &,  TipoNum & ); // Intercambiador
  public:
	Orden();	// Constructor
	~Orden();	// Destructor
	void InitialSet();	// Opciones de visualización
	void VerArray(); 	 // Visualización
	void OrdenaNumeros(); // Ordenación
};

//---------------------------------------------------------------------------
// Declaración de los métodos
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Inicialización de los Arrays
//----------------------------------------------------------------------------

template < class TipoNum > Orden< TipoNum >::Orden()
{
	int nI;
	
for( nI = 0; nI < MAX; nI++ )
   anNum[ nI ] = TipoNum( ( rand() % 100 ) + 1.0 );         // De 1 a 100
}


//----------------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------------

template < class TipoNum > Orden< TipoNum >::~Orden()
{
// No es necesario código 
}

//----------------------------------------------------------------------------
// Modo de visualización.
// Debería estar definida en una clase derivada de Orden<float>,
// ya que a los  enteros no los afecta este tipo de visualización, 
// pero no se ha hecho así para no complicar la visión general 
// del programa
//----------------------------------------------------------------------------

template < class TipoNum > void Orden< TipoNum >::InitialSet()
{
cout << setprecision(2) << setiosflags(ios::fixed) < setiosflags(ios::showpoint);
}
//----------------------------------------------------------------------------
// Muestra los resultados
//----------------------------------------------------------------------------

template < class TipoNum > void Orden< TipoNum >::VerArray()
{
	int nI;
	
cout << "Indice" << "\t" << "Valor \n";
cout << "------" << "\t" << "----- \n";
for( nI = 0; nI < MAX; nI++ )
   cout << nI << "\t" << anNum[ nI ] << "\n";
   
cout << "\n\n";
}

//----------------------------------------------------------------------------
// Intercambio de datos
//----------------------------------------------------------------------------

template < class TipoNum > void Orden< TipoNum >::InterCambia( TipoNum & nI, 									      TipoNum & nJ )
{
	TipoNum nAux;
	
nAux = nI;
nI   = nJ;
nJ   = nAux;
}

//----------------------------------------------------------------------------
// Ordenación de los arrays
//----------------------------------------------------------------------------

template < class TipoNum > void Orden< TipoNum >::OrdenaNumeros()
{
	int nI, nJ;
	int lInterCambio;		// pseudo booleano

nI = 0;
lInterCambio = TRUE;
while( lInterCambio )
  {
   lInterCambio = FALSE;
   for( nJ = 0; nJ < MAX - ( nI + 1 ); nJ++ )
      if( anNum[ nJ ] > anNum[ nJ + 1 ] ) // Si.. realizamos el intercambio
	{
	 InterCambia( anNum[ nJ ], anNum[ nJ + 1 ] );
	 lInterCambio = TRUE;
	}
   nI++;
  }
}

//----------------------------------------------------------------------------
// Programa principal
//----------------------------------------------------------------------------

void main( void )

{
	Orden< int >    IntArray;	// Llamada al "Contenedor" para enteros
	Orden< float >  FloatArray;	// Llamada al "Contenedor" para reales

FloatArray.InitialSet();
IntArray.VerArray();			// Se muestran los datos sin ordenar
FloatArray.VerArray();
IntArray.OrdenaNumeros();
FloatArray.OrdenaNumeros();
IntArray.VerArray();			// Se muestran los datos ya ordenados
FloatArray.VerArray();

}  // Fin del programa de demostración

//----------------------------------------------------------------------------

Francisco González Parrón