C++ problema funzione friend per concatenare due liste

[drudox]

Salve a tutti .. ho creato una semplice lista concatenata .. che funziona bene .. ma quando chiamo il costruttore dopo aver utilizzato la funzione concatenate (una funzione friend che concatena due liste) vedo che l'oggetto viene distrutto ma i caratteri stamapati a video sono dei caratteri ascii tipo @ ` .. per una lista e` istanziata per caratteri e degli interi che non han niente a che fare con la lista nel caso di liste di interi .. posto i codici

classe list e classe nodo e main senza funzione friend concatenate funzionano alla grande .. (mi sono ispirato a degli esempi presi in un libro) il problema e` solo la concatenate .. che e` evidente compromette il RHS (che e` const ) dopo di che` il contruttore non lo ritrova piu` ..

sapete aiutarmi ?



la classe template nodo

# ifndef LISTNODE_H
# define LISTNODE_H 

#include  <iostream>                                     // 
using std::cout;
using std::endl;


template<typename NODETYPE> class List;                  // forward declaretion .. 

template<typename T>
void concatenate( List<T> & , const List<T> & );

template<class NODETYPE>
class ListNode
{
	friend class List<NODETYPE> ;    				 			// list class is friend 
	friend void concatenate<>( List<NODETYPE> & , const List<NODETYPE> & ); 
	
	public:
	  ListNode(const NODETYPE& );             								
	  ~ListNode();  
	  NODETYPE getData()const;
	private:	
	  NODETYPE data ;
	  ListNode<NODETYPE> * NextPtr ;
};

template<class NODETYPE>
ListNode<NODETYPE>::ListNode(const NODETYPE & value) 
		  : data(value) , NextPtr(0) 
{ }

template<class NODETYPE> 
ListNode<NODETYPE>::~ListNode()
{ }


template<class NODETYPE>
NODETYPE ListNode<NODETYPE>::getData()const 
{
	  return data ; 
}

# endif

la Lista :

#  include <iostream>
using std::cout;
using std::endl;

#	include "listnode.h"


template<typename T>
void concatenate( List<T> & , const List<T> &);


template<class NODETYPE>
class List 
{
	friend void concatenate<>( List<NODETYPE> & , const List<NODETYPE> &); 

	public:
	List();
	~List();
	void insertAtFront(const NODETYPE&);		  
	void insertAtBack (const NODETYPE&);		 
	bool removeFromFront(NODETYPE&);
	bool removeFromBack (NODETYPE&);
	
	bool isEmpty()const ;
	void print ()const ;

	private:
	ListNode<NODETYPE> * firstPtr ;
	ListNode<NODETYPE> * lastPtr ;

	ListNode<NODETYPE> * getNewNode(const NODETYPE&);       // ! utility function get new memory 

};


template<class NODETYPE>
 List<NODETYPE>::List()
	:firstPtr(0), lastPtr(0)     				// empty list at the begin 
 { }									


template<class NODETYPE>
 List<NODETYPE>::~List()
{
	if(!isEmpty())
	{ 
		cout << "destroying node ..\n" ;	  
		ListNode<NODETYPE> * currentPtr = firstPtr ;	 
		ListNode<NODETYPE> * tempPtr ;	 

		while(currentPtr != 0)
		{
			tempPtr = currentPtr  ;	  
		   cout << tempPtr->data << '\n';
			currentPtr = currentPtr-> NextPtr ;
	  		delete tempPtr ;	
		}
		cout << endl;
  	}
}


template<class NODETYPE>
ListNode<NODETYPE>* List<NODETYPE>::getNewNode(const NODETYPE& value)
{
	ListNode<NODETYPE> * NewNode = new ListNode<NODETYPE>(value) ;
	return NewNode ;
}



template<class NODETYPE>
 void List<NODETYPE>::insertAtFront(const NODETYPE& value) 
{
	ListNode<NODETYPE> *NewPtr = getNewNode(value);

	if( isEmpty() )            // empty list 
	{
		firstPtr = lastPtr = NewPtr ;
	}
	else
	{
		NewPtr->NextPtr = firstPtr;
		firstPtr        = NewPtr  ;
	}
}

template<class NODETYPE>
 void List<NODETYPE>::insertAtBack(const NODETYPE& value) 
{		  
	List<NODETYPE> *NewPtr = getNewNode(value) ;

	if(isEmpty())
	{
		firstPtr = lastPtr = NewPtr ;
	}
	else
	{
		lastPtr->NextPtr = NewPtr;
		lastPtr = NewPtr ;
		lastPtr->NextPtr = 0;
 	}
}

template<class NODETYPE>
bool List<NODETYPE>::removeFromFront(NODETYPE& value) 
{
	if(isEmpty())
	{
		return false;
	}
	else
	{
	  ListNode<NODETYPE> * tempPtr = firstPtr;     // node to be remove
	//	
		if( firstPtr == lastPtr )                     // if only one node ...	
			 firstPtr = lastPtr = 0 ;                 // list without node after elimination 
		else
	      firstPtr = firstPtr->NextPtr ;
	  
	  value = tempPtr->data ;
	  delete tempPtr ;	
	  return true ; 
	}
}		  


template<class NODETYPE>
 bool List<NODETYPE>::removeFromBack(NODETYPE& value) 
{
	if( isEmpty()) 
		return false ;
	else 
	{
	  ListNode<NODETYPE> * tempPtr = lastPtr;     // node to be remove
	

		if( firstPtr == lastPtr )     				 // only one node
				  firstPtr = lastPtr = 0  ;      	 // list without node after elimination 
		else
		{ 
			ListNode<NODETYPE> * currentPtr = firstPtr;     // node for iterate long the list 
			
			while( currentPtr->NextPtr != lastPtr)
					  currentPtr = currentPtr->NextPtr ;      // flows long the list
			
			lastPtr = currentPtr;
			currentPtr->NextPtr = 0 ; 								// now this is the last node!  
		}	
	 
	  value = tempPtr->data ;
	  delete tempPtr ;	
	  return true ; 
	}
}



template<class NODETYPE>
 bool List<NODETYPE>::isEmpty()const 
{
	return ( firstPtr ==  0) ? true : false ; 
}

template<class NODETYPE>
void List<NODETYPE>::print()const 
{	
	if(isEmpty()) 
	{
		cout << "Empty list !" << endl;	    
	}
	else
	{
		ListNode<NODETYPE> * currentPtr = firstPtr ;

		cout << "The list is :\n "; 
		while( currentPtr != 0 )
		{
			cout << currentPtr-> data << " " ; 
			currentPtr = currentPtr->NextPtr ;
		}
		cout << endl;
	}
}


template<typename T>
void concatenate( List<T> & A , const List<T> & B )
{
		  
	if( !A.isEmpty() && !B.isEmpty() )           // se le due liste non son vuote	
	{
		A.lastPtr->NextPtr = B.firstPtr ;
		A.lastPtr = B.lastPtr ;
	}
}

e questo il main

 
# include <iostream> 
//# include <>


# include "listnode.h"
# include "list.h"



using namespace std;

int main(){
	
	

	List<int> A ;
	List<int> B ;

	A.insertAtFront( 1 ) ;
	A.insertAtFront( 2 ) ;
	A.insertAtFront( 3 ) ;
	A.print();

	B.insertAtFront( 4 ) ;
	B.insertAtFront( 5 ) ;
	B.insertAtFront( 6 ) ;
	B.print();


	concatenate(B,A) ;

	A.print();
	B.print();


	cout << "Every thing right " << endl ;

	A.print();
	B.print();


	return 0;
}

[drudox]

sono fuso .. e` ovvio !! in questo modo quando viene distrutto l'oggetto che e` stato unito vengono distrutti i nodi della lista unita (secondo argomento) .. ok risolto !!!