need help for implement a doubly linked list

[nuderobmonkey]

Here I'm trying to implement a List-container with its iterator. I'm not sure how I represent the empty list and the list-end so that an iterator iterates correctly backward from list-end.

/*
 * Implementation of a doubly linked list.
 */

#include <initializer_list>

namespace test
{

//======= class Link ===============

// represents a node of the list
template <typename Elem>
struct Link
{
    public:
    
        Link * prev;    // previous Link
        Link * succ;    // subsequent Link
        Elem val;     // element
        
};


//======= class List ===============

template <typename Elem>
class List
{
    private:
    
        Link<Elem> * first;  // first node
        Link<Elem> * last;   // last node
        
        long long int m_size;
        
    public:
        
        class iterator;  // nested class
    
// this seems wrong implemented
        List()
        : first{ nullptr }
        {
            first = last;
        }
        
        List( std::initializer_list<Elem> izl )
        {
           for (auto iter = izl.begin(); iter != izl.end(); ++ iter)
           {
               push_back( * iter );
           }
        }
        
        long long int size() const { return m_size; }
    
        iterator begin() { return iterator( first); }
        
// Here seems something wrong        
        iterator end()   { return iterator( last->succ); }
        
        iterator insert( iterator p, const Elem& v)
        {
            // not implemented
        }
        iterator erase( iterator p)
        {
            // not implemented
        }  //  curly brace added at edit
        void push_back(  const Elem & v)
        {
            // not implemented
        }
        
        void push_front( const Elem & v)
        {
            // not implemented
        }
        
        void pop_back()
        {
            if (!first) { return; }  // if empty List
            
            // not implemented
            
        }
        
        void pop_front()
        {
            if(!first) { return; } // if empty List
            
            //not implemented
        }
            
            
        Elem& front() { return first->val; }
        Elem& back()  { return last->val;  }
};


//======= class List<Elem>::iterator =======

template <typename Elem>
class List<Elem>::iterator
{
    private:
    
        Link<Elem> * curr;    // current Link
    
    public:
    
        // constructor
        iterator( Link<Elem> * p)
        : curr{ p }
        {}
        
        // forward iteration
        iterator& operator ++ ()
        {
            curr = curr->succ;
            return * this;
        }
        
        // backward iteration
        iterator& operator -- ()
        {
            curr = curr->prev;
            return * this;
        }
        
        // element access
        Elem& operator * ()
        {
            return curr->val;
        }
        
        bool operator == ( const iterator& other) const { return curr == other.curr; }
        bool operator != ( const iterator& other) const { return curr != other.curr; }
};

} // namespace test


//====== testing the List =====

#include <iostream>
#include <string>
int main ()
{
    test::List<std::string> list = { "banana", "orange", "apple", "cherry" };
    
    for (test::List<std::string>::iterator iter = list.begin(); iter != list.end(); ++iter)
    {
        std::cout << *iter << ' ';
    }
}

*edited, line 70

[nuderobmonkey]

I've seen now, at line 70 was missed a closing curly brace, sorry for that. And then i don't know how i could tackle the forward declaration of class iterator.