Inserting into a linked list segmentation fault 11

[Forgetful]

im trying to insert an initializer_list into a list at a certain position but I get a segmentation fault 11 any idea what's going on?

#include <initializer_list>
#include <iostream>

template <typename T>
class List {
  struct Node;  
  class It;
 public:
  List(std::initializer_list<T> ele) {
    this->operator=(ele);  
  }

  void InsertB(T ele) {
    Node* node = new Node{ele};
    if (this->size == 0) {
      this->start = this->fin = node;
    } else {
      this->fin->next = node;
      node->prev = this->fin;
      this->fin = node;
    }
    ++this->size;
  }

  void InsertF(T ele) {
    Node* node = new Node{ele};
    if (this->size == 0) {
      this->start = this->fin = node;
    } else {
      node->next = this->start;
      this->start->prev = node;
      this->start = node;
    }
    ++this->size;
  }
  void RemoveF() {
    if (size == 0) {
      return;
    }
    Node* temp = start->next;
    delete start;
    start = temp;
    --size;
  }
  void RemoveB() {
    if (size == 0) {
      return;
    }
    if(start == NULL) {
        return;
    }
    if(start->next == NULL) {
        delete start;
        start = NULL;
        return;
    }
    Node* temp = start;
    while (temp->next && temp->next->next != NULL) {
        temp = temp->next;
    }
    delete temp->next;
    temp->next = NULL;
    fin = fin->prev;
    --size;
  }

  List& operator=(std::initializer_list<T> ele) {
    this->size = 0;
    for (auto&& val : ele) this->InsertB(val);
    return *this;
  }

  friend std::ostream& operator<<(std::ostream& out, const List& list) {
    for (auto val = list.start; val; val = val->next) {
      out << val->data;
      if (val->next) out << ",";
    }
    return out;
  }

  template <class It>
  List(It begin, It end) {
    for (; begin != end; ++begin) this->InsertB(*begin);
  }

  It begin() {
    return It(start);
  }
  
  It end() {
    return It(NULL);
  }

  It InsertIt(It pos, const T& ele) {
   if(pos == begin()) {
     InsertF(ele);
     return begin();
   } else if(pos == end()) {
     InsertB(ele);
     return fin;
   } else {
     Node* temp = new Node{ele, pos.cur, pos.cur->prev};
    
     pos.cur->prev->next = temp;
     pos.cur->prev = temp;

     ++size;
     return temp;
   }
  }

  It InsertIt(It pos, std::size_t n, const T& val) {
    for (int i = 0; i < n; i++) {
      InsertIt(pos, val);
    }
    return pos;
  }

  template <typename InputIterator>
  It InsertIt(It pos, InputIterator first, InputIterator last) {
    InputIterator temp = first;
    for (; first != last; first++) {
      InsertIt(pos, *first);
    }
    return ++pos;
  }
 
  It InsertIt(It pos, std::initializer_list<T> list) {
    InsertIt(pos, list.begin(), list.end());
    return ++pos;
  }

private:
  struct Node {
    T data;
    Node* next = nullptr;
    Node* prev = nullptr;

  };

  class It {
    friend class List;
    public:
    // It& operator=(const It& that) {
    //   List<char> first(that.begin(), that.end());
    // }

    It& operator++() {
      this->cur = cur->next;
      return *this;
    }

    It operator++(int) {
      It temp(*this);
      this->operator++();
      return temp;
    }

    T const *operator->() const { return &(**this); }

    T *operator->() { return &(**this); }

    T& operator*() const {return this->cur->data;}
    
    bool operator!=(It val) const { 
       return !(this->operator==(val));
    }

    bool operator==(It val) const { 
       return this->cur == val.cur;
    }

     private:

     Node* cur;
     It (Node *ptr) : cur(ptr) {}
  };

  Node* start = nullptr;
  Node* fin = nullptr;
  std::size_t size = 0;
};

int main() {
List<char> test = {'H', 'e', 'l', 'l', 'o'};
std::cout << test << std::endl;
//List<char> test2 = {' ', 'W', 'o', 'r', 'l', 'd'};
auto iter = test.begin();
iter++;
iter++;
iter++;
iter++;
iter++;
test.InsertIt(iter, {' ', 'W', 'o', 'r', 'l', 'd'});
std::cout << test << std::endl;
}

[Repeater]

Line 149 this->cur = cur->next;

cur is a null pointer. Dereferencing a null pointer causes a seg fault. Make cur point at a node object before you try to use it, or check that it's valid before you try to use it and if it's not, don't use it.