[C++] iteratore end()

[DarkSimo]

Salve a tutti!
Ho un problema con l'iteratore end() in un progetto, per l'università, non so come mai non viene mai caricato infatti mentre scorro la matrice arrivato alla fine mi si blocca segnalandomi un indirizzo non valido!
Il codice:

iterator end() { 
size_type size = (dz*dx*dy); 
return iterator(g3d+size, dz, dy, dx); 
}

La classe è una matrice a 3 dimensioni...
Vi ringrazio subito per la cortesia.

[shodan]

Cos'è iterator? Una classe? Un typedef? Fornisci qualche dettaglio in più.

[DarkSimo]

è una classe chiamata appunto iterator!

[shodan]

Ok, ma non possiamo aiutarti se non mostri il codice della classe iterator (se l'hai fatta tu), della matrice e il codice che usi per il test.
L'errore è dovuto a un accesso non valido, ma senza vedere il codice non è possibile stabilire ne dove ne quando.

[DarkSimo]

Giusto hai ragione...

class iterator{
         	friend class grid3d;
         	friend class const_iterator;
	    public:
	        typedef std::forward_iterator_tag  iterator_category;
   	        typedef T value_type;
            	typedef ptrdiff_t difference_type;
   	        typedef T* pointer;
            	typedef T& reference;
				
		iterator() : ptr(0),diz(0),diy(0),dix(0), cy(0),cx(0) {}
			
		iterator(const iterator &other) : ptr(other.ptr) {}

		iterator& operator=(const iterator &other) {
			ptr = other.ptr;
			diz = other.diz;
			dix = other.dix;
			diy = other.diy;
			cy = other.cy;
			cx = other.cx;
			return *this;
		}
		~iterator() {} //distruttore iteratore
		/**
 		* Operatore di dereferenziamento. 
 		*
 		* @return il dato "puntato" dall'iteratore.
 		*/
                reference operator*() const {
			return ***ptr;
		}
		/**
 		* Operatore freccia.
 		*
 		* @return il puntatore al dato "puntato" dall'iteratore.
 		*/
		pointer operator->() const {
			return ***ptr;
		}
 	       /**
 		* Operatore di confronto (uguaglianza). 
 		* 
 		* @param other iteratore da confrontare
 		* @return true se i due iteratori "puntano" allo stesso dato
 		*/
		bool operator==(const iterator &other) const {
			return ptr == other.ptr;
		}
 	       /**
 		* Operatore di confronto (disuguaglianza). 
 		* 
 		* @param other iteratore da confrontare
 		* @return true se i due iteratori "puntano" a dati diversi
 		*/
		bool operator!=(const iterator &other) const {
			return !(*this == other);
		}
 	       /**
 		* Operatore di "elemento successivo". Versione pre-incremento. 
 		*
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator &operator++() {
                        cx++;
                        if(cx == dix){
                                     **ptr = 0;
                                     cx = 0;
                                     cy++;
                                     if(cy == diy){
                                     *ptr = 0;
                                     cy=0;
                                     ++ptr;
                                     }else ++(*ptr);
                                     }else ++(**ptr);
                       return *this;
		}
 	       /**
 		* Operatore di "elemento successivo". Versione post-incremento. 
 		* 
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator operator++(int) {
			iterator tmp(ptr,diz,diy,dix,cy,cx);
                        cx++;
                        if(cx == dix){
                                     **ptr = 0;
                                     cx = 0;
                                     cy++;
                                     if(cy == diy){
                                     *ptr = 0;
                                     cy=0;
                                     ++ptr;
                                     }else ++(*ptr);
                                     }else ++(**ptr);
                               return tmp;
		}
	
        	private:
		value_type ***ptr;
		size_type diz;
		size_type diy;
		size_type dix;

		size_type cy;
		size_type cx;

 	       /**
 		* Costruttore di inizializzazione. Sarà usato anche da grid3d.
 		*
 		* @param p puntatore ai dati
 		*/
		explicit iterator(value_type ***p, size_type dz, size_type dy, size_type dx) : ptr(p),diz(dz),diy(dy),dix(dx),cy(0),cx(0) {}
		explicit iterator(value_type ***p, size_type dz, size_type dy, size_type dx, size_type dyo, size_type dxo) : ptr(p),diz(dz),diy(dy),dix(dx),cy(dyo),cx(dxo) {}
         };

Il codice per il test:

grid3d<int> gi(2,2,2,3);
grid3d<int> gi2(2,2,2,3);

transform(gi.begin(),gi.end(),gi2.begin(), add());

Il problema che mi sorge è molto semplice lui scorre TUTTA la matrice poi non so perché anzichè fermarsi all' end() va avanti!

[shodan]

Se espliciti il costruttore di copia devi fare la copia di tutti i dati, invece fai la copia solo del puntatore interno.
Tra l'altro il costruttore di copia e l'operatore di assegnamento non servono nemmeno. Puoi benissimo toglierli.
operator++(int) puoi semplificarlo così:

iterator operator++(int) {
    iterator tmp(ptr,diz,diy,dix,cy,cx);
    ++(*this);
    return tmp;
}

[DarkSimo]

Originariamente inviato da shodan
Se espliciti il costruttore di copia devi fare la copia di tutti i dati, invece fai la copia solo del puntatore interno.
Tra l'altro il costruttore di copia e l'operatore di assegnamento non servono nemmeno. Puoi benissimo toglierli.
operator++(int) puoi semplificarlo così:

iterator operator++(int) {
    iterator tmp(ptr,diz,diy,dix,cy,cx);
    ++(*this);
    return tmp;
}

Con questa modifica mi crasha prima...
Sostanzialmente mi scorre tutta la matrice ma poi mi si blocca perché va a controllare una posizione successiva all'ultimo valore ignorando l'end().
Adesso mi si ferma praticamente subito...

[shodan]

Il senso del post era porre l'attenzione sul costruttore di copia.
Quel codice era solo un suggerimento di implementazione.

[DarkSimo]

Originariamente inviato da shodan
Il senso del post era un altro.

A ok!!!

Vediamo se lo implementassi così:

iterator(const iterator &other){ 
diz = other.diz; 
dix = other.dix; 
diy = other.diy; 
cy = other.cy; 
cx = other.cx; 
for(size_type i = 0; i<other.dix; ++i){ //mi muovo su asse x 
for(size_type j = 0; j<other.diy; ++j){ //mi muovo su asse y 
for(size_type z = 0; z<other.diz; ++z){ 
ptr[z][j][i] = other.ptr[z][j][i]; 
} } } }

In modo da fargli fare la copia completa...

[shodan]

Ricorda che quando espliciti un costruttore di copia e/o assegnamento il codice corretto lo devi scrivere tu per ogni dato membro, dato che stai bypassando i meccanismi interni del compilatore.
Poiché hai un puntatore sempre valido (e di cui non fai mai il delete) e gli altri dati sono int, il costruttore di copia e l'operatore di assegnamento non servono.
Faresti prima a toglierli che non a correggere eventuali errori.