I m trying to perfect my Doubly linked list iterator but i am missing a few things

[danolascott]

Hi people I m working on a doubly linked list of type vector with its own user defined iterator functions,I think my at method is bad and i also need an insert method that returns an iterator to the new element inserted, the one i have simply inserts with no return type

#ifndef _FLEXARRAY_H_
#define _FLEXARRAY_H

#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <exception>
#include <stdexcept>

using std::vector;
using std::endl;
using std::cerr;
using std::ostringstream;
using std::runtime_error;
using std::string;

class RangeEx : public runtime_error {
 public:
   RangeEx() : runtime_error("Index out of range") { }
   explicit RangeEx(string st) : runtime_error(st) { }
};


template <typename T>    //REQ: T has T() and T.str()
class FlexArray;

//template <typename T>
//class FlexArray::iterator;


template <typename T>
class ChunkNode {
   vector<T>* elements;
   ChunkNode* prev;          //optional, to make doubly-linked list

   ChunkNode<T>* next;       //typename is illegal here
   //FlexArray<T>* myList;   //unnecessary?
   size_t mySize;            //INV: # of elements actually stored
   friend class FlexArray<T>;
   friend class FlexArray<T>::iterator;   //begin lab with this line
   
   
   public:
     ChunkNode<T>(FlexArray<T>* myList, ChunkNode<T>* myPrev,
                                        ChunkNode<T>* myNext) 
     : elements(new vector<T>()), prev(myPrev), next(myNext),
       myList(myList), mySize(0)
    {}
     
	 ~ChunkNode<T>{
                if ( prev )
                    prev->next = next ;
                if ( next )
                    next->prev = prev ;
            }
         };

};


 template <class T>
class FlexArray{
ChunkNode<T>* firstNode;
ChunkNode<T>* endNode;
size_t nodeCap;
size_t numNodes;



public:

   explicit FlexArray<T>(size_t nodeCap)
   : firstNode(new ChunkNode<T>(this,NULL,NULL))
   , endNode(firstNode)
   , nodeCap(nodeCap)
   , numNodes(1)
    {} 

 
  FlexArray<T>()
    : firstNode(new ChunkNode<T>(this,NULL,NULL))
    , endNode(firstNode)
    , nodeCap(40)
    , numNodes(1)
   { }

   class iterator {     //does not need "template <typename T>" since nested
   const FlexArray<T> myFlex;
    ChunkNode<T>* node;
    size_t localIndex;
  
   friend class FlexArray<T>;
   iterator( const FlexArray<T>* holder, ChunkNode<T>* node, size_t index): myFlex(holder),node(node),localIndex(index){}   
    
public:
   
   T& operator*(){
       
      if(node == NULL || node == myFlex-> endNode){
         throw runtime_error("Attemt to de-reference end iterator");
            
            }else{
          return node->elements->at(localIndex);
           }
       }
   iterator& operator++(){
         if(node == myFlex -> endNode){
              throw RangeEx("Attempted to move past the end positon"); 
          }
        else{if(node== NULL){
           node = myFlex->firstNode;
           localIndex = 0;
              }
             else{
                     localIndex++;
                     if(localIndex== node->mySize){
                  node=node->next;
                  localIndex=0;
                 }    
              } 
          }
        return *this;
       }
     
  iterator operator++(int ignored){
     iterator copy = *this;
     operator++();
     return copy; 
  }
    
    bool operator==(const iterator& rhs) const{           
 return node== rhs.node && localIndex == rhs.localIndex&& myFlex == rhs.myFlex;
} 
    bool operator!=(const iterator& rhs) const{
  return(!(*this == rhs));
}
};
 
   

 iterator begin(){return iterator(this, firstNode, 0);}
 iterator end(){return iterator(this, endNode, 0);}
 iterator rbegin() {return iterator (this,endNode->prev, endNode->prev->MySize-1);}
      


T at(int j){
myFlex.begin();
for(int i =0; i<j; i++){
     operator++();
 }
  return operator*();
  
iterator erase(iterator it){
if (it != end()) 
   {
        if ( firstNode == it.node)
            firstNode = it.node->next ;
        if ( lastNode == it.node)
            lastNode == it.node->prev ;

       --localIndex ; 
       delete (it++).node ;
   }
   return it ;
}

void insert(size_t j, const T& item){
    ChunkNode<T> *newNode;
	ChunkNode<T> *nodePtr;
	ChunkNode<T> *previousNode = NULL;
	newNode = new ChunkNode<T>;
	newNode -> T = T;
	nodePtr = firstNode;
	previousNode = NULL;
	for(int i = 0; i < j; ++i) { // iterate to the two nodes you want to insert between
		previousNode = nodePtr;
		nodePtr = nodePtr->next;
	}
	if (previousNode) { // if there is a previous node
		previousNode->next = newNode; // point the next of the node before to the new node
		newNode->next = nodePtr; // point the new node to the next node
	} else { // there is no previous node, nodePtr must be at firstNode
		firstNode = newNode; // point firstNode to new node
		newNode->next = nodePtr; // point next to the old first
	}

}

};
 
#endif