Buenos días.

Venía a ver si alguno me podría ayudar con un programa en C++ que tengo confuso. Me explico. El ejercicio consiste en hacer un programa de compresión RLE pero totalmente independiente, es decir, introduzcas caracteres o números, debe funcionar el método.

Es decir;

A A B B --> 2 A 2 B.
1 1 2 2 --> 2 1 2 2.

Tengo una clase RLE, que la dejo por aquí:

class RLE
{ 
 
// La clase RLE no tiene campos.
// Los objetos de la clase sieven para ejecutar los métodos "Codifica"
// y "Descodifica" (esta implementación se diferencia muy poco de escribir
// los dos métodos como funciones globales).
 
private: 
 
public:
 
	/***********************************************************************/
	// Codifica una secuencia de enteros según el código RLE y devuelve 
	// otra secuencia de enteros codificada.
	//
	// Recibe: secuencia_descodificada, la secuencia que se va a codificar.
	// Devuelve: una nueva secuencia, resultado de codificar según RLE 
	// la secuencia recibida "secuencia_descodificada". 
 
	SecuenciaEnteros Codifica (SecuenciaEnteros secuencia_descodificada)
	{
		// Secuencia resultado de la codificación
		SecuenciaEnteros secuencia_codificada; 
 
		int tope, actual, anterior, iguales_hasta_ahora;
 
		// Registrar la longitud de la secuencia
		tope = secuencia_descodificada.TotalUtilizados();
 
		// Guardar el primer valor de la secuencia
		actual = secuencia_descodificada.Elemento(0);
 
		iguales_hasta_ahora = 1;
 
		for (int pos=1; pos<tope; pos++) {
 
			anterior = actual;
			actual = secuencia_descodificada.Elemento(pos);
 
			if (anterior == actual)
 
				iguales_hasta_ahora++; // Continua la serie
 
			else {
 
				// Añade la pareja (valor, num.repeticiones)
				secuencia_codificada.Aniade(iguales_hasta_ahora);
				secuencia_codificada.Aniade(anterior);
 
				iguales_hasta_ahora = 1; // empezar una nueva serie				
			}
		} // for (int pos=1; pos<tope; pos++)
 
		// Añade la última pareja (valor, num.repeticiones)
		secuencia_codificada.Aniade(iguales_hasta_ahora);
		secuencia_codificada.Aniade(actual);
 
		return (secuencia_codificada); 
	}   
 
	/***********************************************************************/
	// Descodifica una secuencia de enteros según el código RLE y devuelve 
	// otra secuencia de enteros descodificada.
	//
	// Recibe: secuencia_codificada, la secuencia que se va a descodificar.
	// Devuelve: una nueva secuencia, resultado de descodificar según RLE 
	// la secuencia recibida "secuencia_codificada". 
 
	SecuenciaEnteros Descodifica (SecuenciaEnteros secuencia_codificada)
	{
		// Secuencia resultado de la descodificación
 
		SecuenciaEnteros secuencia_descodificada; 
 
		// Registrar el número de elementos de la secuencia codificada. 
 
		int tope = secuencia_codificada.TotalUtilizados();
 
		// Ciclo que recorre la secuencia codificada. 
		// La longitud de la secuencia es par (está formada por parejas) así 
		// que el número de parejas es justo la mitad del número de elementos. 
		// Observad que el salto se realiza de 2 en 2 porque en cada iteración 
		// se procesa una pareja. 
 
		for (int pos=0; pos<tope; pos+=2) {
 
			int num_repeticiones = secuencia_codificada.Elemento(pos);
			int valor = secuencia_codificada.Elemento(pos+1);
 
			// Cada pareja es (num_repeticiones, valor). Se trata de escribir
			// "valor" en la secuencia descodificada "num_repeticiones" veces.  
 
			for (int i=0; i<num_repeticiones; i++) 
				secuencia_descodificada.Aniade(valor);
		}
 
		return (secuencia_descodificada);
	}
 
	/***********************************************************************/
 
};
 

Esa implementación funciona perfectamente con números enteros, pero a la hora de tener que tener en cuenta que también pueden introducirse caracteres, me confunde. Se me ocurre hacer una clase SecuenciaParejas y la clase SecuenciaEnteros (ya implementada)

class SecuenciaEnteros 
{
 
private:
 
	static const int TAMANIO = 200; // Número de casillas disponibles
 
	int vector_privado[TAMANIO];
 
	//PRE: 0 <= total_utilizados <= TAMANIO
	int total_utilizados;	// Número de casillas ocupadas
 
public:
 
	/***********************************************************************/
	// Constructor sin argumentos
 
	SecuenciaEnteros() : total_utilizados(0) {}
 
	/***********************************************************************/
	// Métodos de lectura (Get) de los datos individuales 
 
	// Devuelve el número de casillas ocupadas
	int TotalUtilizados (void)
	{
		return (total_utilizados);
	}
 
	// Devuelve el número de casillas disponibles
	int Capacidad (void)
	{
		return (TAMANIO);
	}
 
	/***********************************************************************/
	// Añade un elemento al vector.
	// Recibe: nuevo, el elemento que se va a añadir.
	//
	// PRE: total_utilizados < TAMANIO
	// 		La adición se realiza si hay espacio para el nuevo elemento. 
	// 		El nuevo elemento se coloca al final del vector. 
	// 		Si no hay espacio, no se hace nada.	
 
	void Aniade (int nuevo)
	{
		if (total_utilizados < TAMANIO) {
			vector_privado[total_utilizados] = nuevo;
			total_utilizados++;
		}
	}
 
	/***********************************************************************/
	// Devuelve el elemento de la casilla "indice" 
	//
	// PRE: 0 <= indice < total_utilizados 
 
	int Elemento (int indice)
	{
		return vector_privado[indice];
	}
 
	/***********************************************************************/
	// Calcula si dos objetos son iguales: serán iguales si contienen el 
	// mismo número de elementos, son iguales uno a uno y están en el mismo 
	// orden.
	// 
	// Recibe: otro, la secuencia con la que se compara el objeto implícito. 
	// Devuelve: true, si las dos secuencias son iguales; false, en otro caso. 
 
	bool EsIgualA (SecuenciaEnteros otro)
	{
		bool son_iguales; 
 
		if (total_utilizados == otro.total_utilizados) {
 
			son_iguales = true; 
 
			int pos = 0; 
			bool sigo_comparando = true; 
 
			// Mientras queden por comparar y sigan siendo iguales
 
			while ((pos<total_utilizados) && (sigo_comparando)) {
 
				if (vector_privado[pos] == otro.vector_privado[pos]) {
					pos++;
				}
				else {
					sigo_comparando = false; 
					son_iguales = false;
				}
 
			} // while (sigo_comparando)
 
		}
		else son_iguales = false; // tienen distinto tamaño
 
		return (son_iguales);
	}
 
	/***********************************************************************/
};
 
/////////////////////////////////////////////////////////////////////////////
 

Una vez teniendo SecuenciaEnteros y SecuenciaParejas, a la hora de que el usuario vaya a introducir los valores, hacer un if para comprobar si está metiendo letras o números.


¿Alguna ayuda?

¡Gracias!