[c++] iteratore che ritorna struct

[DarkSimo]

Salve a tutti!
Ho un problema innanzitutto ecco il codice:

  struct element{
     size_type row;
     size_type col;
     value_type val;
  };

	class iterator {
		friend class const_iterator;
		friend class sparsematrix;

	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),ptrc(0),ptrr(0) {}
			
		iterator(const iterator &other) : ptr(other.ptr),ptrc(other.ptrc),ptrr(other.ptrr) {}
		
		iterator& operator=(const iterator &other) {
			ptr = other.ptr;
			ptrc = other.ptrc;
			ptrr = other.ptrr;
			return *this;
		}
		iterator& operator=(const element &other) {
			element el;
                        el.row = *ptrr;
                        el.col = *ptrc;
                        el.val = *ptr;
                	return ⪙
		}
		~iterator() {}
 	       /**
 		* Operatore di dereferenziamento.
 		* @return struct element
                */
		reference operator*() const {
                	return *ptr;
		}
 	       /**
 		* Operatore freccia.
 		*
 		* @return il puntatore al dato "puntato" dall'iteratore.
 		*/
		pointer operator->() const {
                        element *el;
                        el.row = *ptrr;
                        el.col = *ptrc;
                        el.val = *ptr;
			return el;
		}
               /**
 		* 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 confronto (uguaglianza). 
 		* 
 		* @param other const_iteratore da confrontare
 		* @return true se i due iteratori "puntano" allo stesso dato
 		*/
		bool operator==(const const_iterator &other) const {
			return ptr == other.ptr; // vedi const_iterator
		}
 	       /**
 		* Operatore di confronto (uguaglianza). 
 		* 
 		* @param other const_iteratore da confrontare
 		* @return true se i due iteratori "puntano" a dati diversi
 		*/
		bool operator!=(const const_iterator &other) const {
			return !(*this == other);
		}
 	       /**
 		* Operatore di "elemento successivo". Versione pre-incremento. 
 		* 
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator &operator++() {
			++ptr;
                        ++ptrc;
                        ++ptrr;
			return *this;
		}
 	       /**
 		* Operatore di "elemento successivo". Versione post-incremento. 
 		* 
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator operator++(int) {
			iterator tmp(ptr,ptrc,ptrr);
			++ptr;
                        ++ptrc;
                        ++ptrr;
			return tmp;
		}
	private:
		value_type *ptr;
		size_type *ptrc;
		size_type *ptrr;
	       /**
 		* Costruttore di inizializzazione.
 		* @param p puntatore ai dati
 		* @param ptrc puntatore alle colonne
 		* @param ptrr puntatore alle righe
 		*/
		explicit iterator(value_type *p, size_type *prc, size_type *prr) : ptr(p), ptrc(prc),ptrr(prr){}
	}; // iterator
         
	iterator begin() {
		return iterator(val,pc,pr);
	}
  
	iterator end() {
		return iterator(val + size, pc + size, pr + size);
	}
  
	}

Allora sostanzialmente devo far si che il mio iteratore ritorni una struct e che poi io la possa utilizzare per qualcosa.
Qualunque cosa io faccia lui non mi fa usare la struct, secondo voi cosa devo fare? cosa ho sbagliato?
Per completezza inserisco anche il pezzo di codice dove devo usarla:

sparsematrix<int> sit(2,2,0);
sit.add(0,0,4);
sit.add(1,1,3);

sparsematrix<int>::element *el;
sparsematrix<int>::iterator i = sit.begin();

i->el;

[MItaly]

Originariamente inviato da DarkSimo
Allora sostanzialmente devo far si che il mio iteratore ritorni una struct

cosa intendi? Un iteratore è una classe (o un oggetto), mica ritorna niente...

e che poi io la possa utilizzare per qualcosa.
Qualunque cosa io faccia lui non mi fa usare la struct, secondo voi cosa devo fare?

Anche qui, non sei per nulla chiaro... spiega che cosa provi e che errori ottieni.

[DarkSimo]

Allora sostanzialmente quando scorro l'array lui deve ritornarmi la struct element che contiene il valore e la sua posizione i,j data da ptcr e ptrr.
Per esempio:
devo poter caricare con i dati che posso estrapolare dall'iteratore un vector di struct!

Non so come spiegarmi meglio...

[lovesemiramide]

pointer operator->() 
    element *el;
    el.row = *ptrr;
    el.col = *ptrc;
    el.val = *ptr;
    return el;
}

In questo modo restituisci non l'elemento puntato da ptr, ma una sua copia(occhio che non allochi la memoria necessaria). Basta restituire ptr per accedere alla struct.

[DarkSimo]

Ok ma dove l'alloco?
Nel senso io in realtà non ho una struct la devo creare e poi passare.
Come faccio?

[lovesemiramide]

In begin() e end() potresti modificare il puntatore interno di iterator o fornendo un costruttore che prende un puntatore a value_type come argomento o puoi dichiarare sparse_matrix friend
rispetto a iterator.

[DarkSimo]

sparsematrix è già friend...
Il fatto è che sparse matrix è composta da 3 array:
il valore, la posizione in righe e in colonne.

Da questi 3 io devo creare una struct!

Ora questo è un iteratore base che mi scorre l'array dei valori:

	class iterator {
		friend class const_iterator;  
		friend class sparsematrix;

	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) {}
			
		iterator(const iterator &other) : ptr(other.ptr) {}
		
		iterator& operator=(const iterator &other) {
			ptr = other.ptr;
			return *this;
		}
		~iterator() {}
 	       /**
 		* 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 confronto (uguaglianza). 
 		* 
 		* @param other const_iteratore da confrontare
 		* @return true se i due iteratori "puntano" allo stesso dato
 		*/
		bool operator==(const const_iterator &other) const {
			return ptr == other.ptr; // vedi const_iterator
		}
 	       /**
 		* Operatore di confronto (uguaglianza). 
 		* 
 		* @param other const_iteratore da confrontare
 		* @return true se i due iteratori "puntano" a dati diversi
 		*/
		bool operator!=(const const_iterator &other) const {
			return !(*this == other);
		}
 	       /**
 		* Operatore di "elemento successivo". Versione pre-incremento. 
 		* 
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator &operator++() {
			++ptr;
			return *this;
		}
 	       /**
 		* Operatore di "elemento successivo". Versione post-incremento. 
 		* 
 		* @return l'iteratore che "punta" all'elemento successivo
 		*/
		iterator operator++(int) {
			iterator tmp(ptr);
			++ptr;
			return tmp;
		}
	private:
		value_type *ptr;
	       /**
 		* Costruttore di inizializzazione.
 		* @param p puntatore ai dati
 		*/
		explicit iterator(value_type *p) : ptr(p){}
	}; // iterator
         
	iterator begin() {
		return iterator(val);
	}
  
	iterator end() {
		return iterator(val + size);
	}

A me servirebbe che quando chiamo *i mentre lo sto scorrendo con un for mi spunti fuori una struct.
L'idea sarebbe quella di caricarla con i valori e poi ritornare il puntatore ad essa.
Ma mi dice ovviamente che NON posso fare una conversione fra iterator e struct quando nel main cerco di caricarla in un vector di struct!