C++ cannot convert Student* to DYNVECTOR<Student,24>::Node* in initialization - c++

Question

Im trying to create an iterator for my dynamic vector class that i've implemented,
The thing is I keep getting this error when I try to initilaize some student class for testing
purposes on some assignment for the iterator, I cannot figure out why Im having this error wasted alot of hours on it and its impossible to figure out why this error occurs..
Here is the code
some edit
Here is the main function that im trying to use that takes the iterator from my class
some edit
Just in the intiliaze of the DYNVECTOR class in the main my code fails , I keep on getting
the error:
error: cannot convert 'Student*' to 'DYNVECTOR <Student, 24>::Node*' in initialization
Iter(T *N ) : _pointer(N) { }
EDIT: please guys focus on this part:
inputIterator begin() { return inputIterator(pa);}
this is what is causing the error, the functionality of the push back function and other funtions are still in progress but that is not the reason causing this error.

Answer 1

The Problem
inputIterator begin() { return inputIterator(pa);}
is calling inputIterator's constructor
Iter(T *N ) : _pointer(N) { }
with a pointer to a T, a T *. Iter takes T * happily, but it tries to store that T * into _pointer and _pointer is defined as
Node *_pointer;
which is NOT a T *. The assignment fails because the types don't match.
The Naive Solution
Make the types match. This means you have to pass in a Node *. Bad news: DYNARRAY doesn't have any Node *s to give it. Naive solution fails.
The Proper Solution
Throw out Node. Node is useful if you have a linked list. You don't have a linked list. Kill it. Make it dead. Clean up the mess.
class DYNVECTOR
{
// no nodes
class Iter // directly uses T pointers
{
public:
Iter(T *N) :
_pointer(N) // types match now
{
}
T& operator*() const
{
return *_pointer; // simpler without Node, no?
}
T* operator->() const
{
return _pointer; // simple
}
Iter& operator++()
{
_pointer++; // dead simple
return *this;
}
Iter operator++(int)
{
Iter tmp = *this;
_pointer++; // yawn-city
return tmp;
}
bool operator==(Iter const &rhs) const
{
return _pointer == rhs._pointer; // unchanged
}
bool operator!=(Iter const &rhs) const
{
return _pointer != rhs._pointer; // unchanged
}
private:
T *_pointer; // T *, not Node *
};
private:
size_t someCap, length; //, initCap; don't see the point of initCap
T *pa; // unchanged
public:
typedef Iter inputIterator;
DYNVECTOR():
someCap(Capacity), // Still not sure what Capacity is for, so I used
// it here instead of magic number 24
length(0),
pa(new T[someCap])
{
// used initializer list instead.
}
inputIterator begin()
{
return inputIterator(pa); // unchanged
}
inputIterator end()
{
return inputIterator(&pa[length]); // iterator to one past the end.
// just like std::vector
}
template<class Iter>
DYNVECTOR(const Iter &begin, const Iter &end): // far more versatile if const references
DYNVECTOR() // delegate basic set-up to default constructor
{
for (Iter pointer = begin; pointer != end; pointer++) // loop unchanged
{
push_back(*pointer);
}
}
// make uncopyable (for now anyway) See Rule of Three
// linked below for why
DYNVECTOR(const DYNVECTOR & ) = delete;
DYNVECTOR& operator=(const DYNVECTOR & ) = delete;
~DYNVECTOR() // for my own testing. left as example
{
delete[] pa; // clean up allocated storage
}
void push_back(const T & newb) // for my own testing. left as example
{
if (length == someCap) // need more space
{
int newCap = someCap * 2; // double the size
// you might need to do something different like
// int newCap = someCap + Capacity;
// There's no way for me to know.
// The rest should be right though.
T* newArr = new T[newCap]; // allocate bigger array
for (size_t index = 0; index < length; index++)
{ // copy old array into new
newArr[index] = pa[index];
}
delete[] pa; // discard old array
pa = newArr; // use new array
someCap = newCap; // update capacity
}
pa[length] = newb; // insert new item
length++; // update counter
}
};
Documentation on the Rule of Three and friends. You cannot write complex and efficient C++ unless you understand these rules. Learn them or consign yourself to being a hack.

Answer 2

First of all when you deal with objects it is bad practice to do:
DYNVECTOR<Student, 24> students;
It should be:
DYNVECTOR<Student*, 24> students;
Secondly you never created a constructor for your DYNVECTOR how do you expect the object to be created??