Hola a todos.
Estoy haciendo un ejercicio en el que tengo que invertir una secuencia dinámica en c++.
Tengo que realizar este ejercicio para la universidad y tal como lo tengo hecho se me crea un bucle infinito al tratar de sacar los valores por pantalla despues de invertir. ¿Alguien me puede echar una mano?

Este es el código de mi función invertir:

template <class TElem>
void CSecuencia<TElem>::invertir(){
	invertirAux(0, _pri->sig());
};
template <class TElem>
void CSecuencia<TElem>::invertirAux(CNodoSecuencia<TElem> *act, CNodoSecuencia<TElem>*anterior){
if (act==0)
	//caso base
	if (_ant->sig()==0){
		_ant=_pri->sig();
		_pri->_sig=anterior;
		anterior->_sig=_pri;
	}
	else {
		_pri->_sig=anterior;
		anterior->_sig=_pri;
		_ant=_ant->sig()->sig();//Para mantener el punto de interes
	}
	//fin caso base
else if (act!=0){
	invertirAux(act, act->sig());
	act->_sig=_ant;
}
 
};

Y esta es la definición de la secuencia (Está todo bien implementado menos el invertir):

class CSecuencia {
public:
	CSecuencia ();
 	CSecuencia(const CSecuencia<TElem> &other) {copia(other);};
	/*Constructor de copia de la secuencia; debe tener cuidado con la compartición de memoria, es decir, debe hacer una copia completa.
	Parámetros:
	other 	Objeto a copiar.
	*/
 	~CSecuencia() {libera();};
	CSecuencia<TElem>& operator= (const CSecuencia<TElem> &rhs);
	/*Operador de asignación sobre secuencias; se preocupa de duplicar la estructura de la secuencia para que no exista compartición de memoria.
	Parámetros:
	rhs 	Secuencia a copiar.
	Devuelve:
	Una referencia a la nueva secuencia.*/
	void inserta(const TElem &e);
	/*Inserta un nuevo elemento en la secuencia, justo delante del punto de interés.
	Parámetros:
	e 	Elemento a añadir.
	*/
	void borra();
	/*Elimina el elemento apuntado por el punto de interés.
	Excepciones:
	EAccesoIndebido 	si el punto de interés está al final, fuera de la secuencia.
	*/
	const TElem& actual() const;
	/*Devuelve el elemento apuntado por el punto de interés.
	Devuelve:
	Elemento almacenado.
	Excepciones:
	EAccesoIndebido 	si el punto de interés está al final, fuera de la secuencia.*/
	void avanza();
	/*Avanza una posición el punto de interés.
	Excepciones:
	EAccesoIndebido 	si el punto de interés está al final, fuera de la secuencia, es decir, si esFin() == true.
	Ver también:
	CSecuencia::esFin().
	*/
	void reinicia();
	/*Coloca el punto de interés al principio de la secuencia.*/
	bool esFin() const;
	/*Sirve para averiguar si el recorrido de la secuencia ha terminado, es decir, si el punto de interés ya no apunta a un elemento válido de la secuencia.
	Devuelve:
	true si el punto de interés está al final del recorrido.*/
	bool esVacio() const;
	/*Sirve para averiguar si la secuencia no tiene elementos.
	Devuelve:
	true si la secuencia está vacía.*/
	int numElems() const;
	/*Devuelve el número de elementos que tiene la secuencia.
	Esta operación debe tener coste constante (O(1)).
	Devuelve:
	Número de elementos dentro de la secuencia.*/
	void invertir();
	void invertirAux(CNodoSecuencia<TElem> *act, CNodoSecuencia<TElem>*anterior);
private:
	CNodoSecuencia<TElem> *_pri, *_ant;
	int _longitud;
	void libera();
	void copia(const CSecuencia<TElem>& secuencia);
};
 
template <class TElem>
class CNodoSecuencia {
friend CSecuencia<TElem>;
public:
	const TElem& elem() const;
	CNodoSecuencia<TElem>* sig() const;
private:
	TElem _elem;
	CNodoSecuencia<TElem>* _sig;
	CNodoSecuencia();
	CNodoSecuencia(const TElem&, CNodoSecuencia<TElem>* = 0);
};
 

Ya esta solucionado

me faltaba _ult=_prim; delante de _prim=tmp;

Hola.
Estoy haciendo una funcion lShift (int n) que desplace los elementos de la cola a la izquierda n posiciones. Si movieramos una posicion, el primer elemento de la cola seria el que estaba segundo y el último el que estaba primero.

Esta es mi solucion:

//Cambiamos los punteros. movemos a la izquierda n posiciones.
template <class TElem>
void TCola<TElem>::lShift (int n) throw (EAccesoIndebido){
	if (esVacio()) throw EAccesoIndebido("Cola Vacía");
	else if (n>0) {
		_ult->_sig=_prim;//el primero pasa a ser el siguiente al ultimo;
		TNodoCola<TElem>* tmp;
		tmp=_prim->_sig;
		_prim->_sig=0;//el siguiente al primero pasa a NULL;
		_prim=tmp;
		lShift(n-1);
	}
 
}
 

La historia es que no  me funciona como quiero.
Tengo una cola de 11 elementos: 1 2 3 4 5 6 7 8 9 10 11
y al moverlo dos posiciones a la izquierda (cola.lShift(2)) me devuelve
3 4 5 6 7 8 9 10 11 2

¿Alguien ve el error?

Gracias.

Al final consegui resolverlo implementando una funcion invertir. Muchas gracias por tu ayuda.

template <class TElem>
void TPila<TElem>::invertir() {
	TElem e;
	if(!esVacio()){
		e=_cola.primero();
		_cola.quitaPrim();
		invertir();
		_cola.ponDetras(e);
 
	}//end if
}
 
template <class TElem>
const TElem& TPila<TElem>::cima() throw (EAccesoIndebido){
 
if(esVacio()) throw EAccesoIndebido("Error: no existe cima de la pila vacía");
else {
	invertir();
	TElem e=_cola.primero();
	invertir();
	return e;}
}
 

Gracias por tu ayuda pero con un struct tampoco me vale. Alguna otra forma?

La historia es que tampoco puedo acceder a los atributos ni operaciones privadas de la cola (prohibido por el ejercicio en cuestión).

La cola es el único atributo de la clase TPila y sólo puedo acceder a su parte pública.

En caso de cambiar la definición de la cima como lo harías (recursivamente)?
Me estoy volviendo loco...

EI: juntando mensajes.

De la cola puedo acceder a esto.

template <class TElem>
class TCola {
public:
	//constructora destructora y operador de asignacion
	TCola();
	TCola(const TCola<TElem>&);
	~TCola();
	TCola<TElem>& operator=(const TCola<TElem>&);
//Operaciones de las colas
 
	void ponDetras(const TElem&);
	//Pre:true
	//post: se añade elem al final de la cola
 
	const TElem& primero() const throw (EAccesoIndebido);
	//Pre:!esVacio()
	//Post: Devuelve el primer elementos de la Cola
	//Lanza Excepcion si la cola está vacía
 
	void quitaPrim() throw (EAccesoIndebido);
	//Pre !esVacio();
	//Post Elimina el primer elemento de la cima
	//Lanza la excepción 
 
	bool esVacio() const;
	//Pre true
	//Posr Devuelve true o false dependiendo de si la cola esta o no vacia

El caso es que con tipos auxiliares no hay problema pero no me dejan usarlos.

template <class TElem>
const TElem& TPila<TElem>::cima() const throw (EAccesoIndebido){
TCola <TElem> colaAux;
colaAux=_cola;	 
if(esVacio())
    throw EAccesoIndebido("Error: no existe cima de la pila vacía");
	else	{
	TElem aux;
	while (!colaAux.esVacio()) {
 aux=colaAux.primero();
 colaAux.quitaPrim();}
	return aux;
	}	//fin else
}

Existe alguna forma de hacerlo sin tipos auxiliares y sin cambiar la definición de la operación?
Quizás con una función auxiliar?? Yo lo he intentando pero tampoco me deja.

template <class TElem>
TElem TPila<TElem>::cimaAux(){
	TElem aux;
	aux=_cola.primero();
	_cola.
	cimaAux();
	_cola.ponDetras(aux);
	return aux;
 
}
 
template <class TElem>
const TElem& TPila<TElem>::cima() const throw (EAccesoIndebido){
 
	 if(esVacio())
    throw EAccesoIndebido("Error: no existe cima de la pila vacía");
	 else {	
		 return cimaAux();}
	//fin else
}

Buenas, estoy intentando resolver un ejercicio en el que hay que implementar una pila usando como único atributo una cola y junto con la restricción de no poder usar TADs auxiliares.

Mi problema es que no se como obtener la cima sin utilizar una cola auxiliar. La definición de la operación es esta:

const TElem& cima() const throw (EAccesoIndebido);
	//pre: !esVacio
	//post: devuelve la cima
	//Lanza excepcion si la pila esta vacia
 
Tendrá que ser por recursión pero dentro de esta funcion no puedo usa _cola.quitaPrimero() ni _cola.ponUltimo()porque me da error C2662.
 
alguien me ayuda?
 
Yo había pensado algo así (pero da error C2662)
template <class TElem>
const TElem& TPila<TElem>::cima() const throw (EAccesoIndebido){
 
	 if(esVacio())
    throw EAccesoIndebido("Error: no existe cima de la pila vacía");
	 else {
	 TElem aux;
	 aux=_cola.primero();
	 _cola.
	 cima();
	 _cola.ponDetras(aux);
	 return aux;}
	//fin else
}