Linked List & Iterators

[Forgetful]

I'm having issues with my linked list and including iterators I get the error code

helpme.cpp:281:27: error: no member named 'begin' in 'LL<char>::It'
LL<char> first(that.begin(), that.end());
~~~~ ^
helpme.cpp:270:13: note: in instantiation of member function 'LL<char>::It::operator=' requested here
this->operator=(other);
^
helpme.cpp:245:21: note: in instantiation of member function 'LL<char>::It::It' requested here
for (; first != last; ++first) this->InsertBack(*first);
^
helpme.cpp:321:12: note: in instantiation of function template specialization 'LL<char>::LL<LL<char>::It>' requested here
LL<char> temp (list.begin(),list.end());
^
1 error generated.

also testing lines 264-267.

#include <cstddef>
#include <initializer_list>
#include <iostream>
#include <algorithm>


template <typename T>
class LL {
  struct node;
  class It;  

 public:
  LL() {
  }
  
  LL(std::initializer_list<T> content) {
    this->operator=(content);  
  }

  LL(const LL<T>& diff) {
    this->operator=(diff);
  }
  
  ~LL() {
    while (this->start) {
      node* oldStart = this->start;  
      this->start = oldStart->next;  
      delete oldStart;               
    }
  }
  std::size_t Size() const {
    return size;
  }
  bool Empty() const {
    if (Size() == 0) { return true; }
    else { return false; }
  }
  T& First() const {
    if (Empty() == true) {
      throw std::domain_error("Error 404");
    }
    return start->data;
  }
  T& Last() const {
    if (Empty() == true) {
      throw std::domain_error("Error 404");
    }
    return last->data;
  }
 
  void InsertBack(T val) {
    node* new_node = new node{val};
    if (this->size == 0) {
      this->start = this->last = new_node;
    } else {
      this->last->next = new_node;
      new_node->prev = this->last;
      this->last = new_node;
    }
    ++this->size;
  }
  
  void InsertFront(T val) {
    node* new_node = new node{val};
    if (this->size == 0) {
      this->start = this->last = new_node;
    } else {
      new_node->next = this->start;
      this->start->prev = new_node;
      this->start = new_node;
    }
    ++this->size;
  }
  void RemoveFront() {
    if (Empty() == true) {
      return;
    }
    node* cur = start->next;
    delete start;
    start = cur;
    --size;
  }
  void RemoveBack() {
    if (Empty() == true) {
      return;
    }
    if(start == NULL) {
        return;
    }
    if(start->next == NULL) {
        delete start;
        start = NULL;
        return;
    }
    node* cur = start;
    while (cur->next && cur->next->next != NULL) {
        cur = cur->next;
    }
    delete cur->next;
    cur->next = NULL;
    last = last->prev;
    --size;
  }
  void Resize(std::size_t n, const T &fill_value) {
    int count = 0;
    node* cur = start;
    while (cur != NULL) {
      count++;
      cur = cur->next;
    }
    if (count > n) {
      n = count - n;
      for (int i = 0; i < n; i++) {
        RemoveBack();
      }
    } else {
      n = n - count;
      for (int i = 0; i < n; i++) {
        InsertBack(fill_value);
      }
    }
  }
  void Clear() {
    while (this->start) {            
      node* old_head = this->start;  
      this->start = old_head->next;  
      delete old_head;               
    }
  }
  void RemoveAll(const T& val) {
    if (Empty() == true) {
      return;
    }
    node* cur = this->start;
    node* temp = this->start;
    while (cur != last) {
      if (cur->data == val) {
        if(cur == start) {
        start = cur->next;
        delete cur;
        cur = start;
        } else {
        temp->next = cur->next;
        delete cur;
        cur = temp->next;
        }
      } else {
      temp = cur;
      cur = cur->next;
      }
    }
  }
  void RemoveDuplicate() {
      node* cur = this->start;
    node* temp = this->start;
    while (cur != last) {
      if (cur->data == cur->next->data) {
        if(cur == start) {
        start = cur->next;
        delete cur;
        cur = start;
        } else {
        temp->next = cur->next;
        delete cur;
        cur = temp->next;
        }
      } else {
      temp = cur;
      cur = cur->next;
      }
    }
  }
  void Reversing() {
    if (start == NULL) {
      return;
    } else if (Size() == 1) {
      return;
    }
    node* cur = start;
    node* temp = start->next;
    while (cur->next != last) {
      temp = cur->next;
      cur->next = cur->next->next;
      temp->next = start;
      start = temp;
    }
  }
  LL& operator=(std::initializer_list<T> content) {
    Clear();
    
    this->size = 0;
    for (auto&& val : content) this->InsertBack(val);
    return *this;
  }
  LL& operator=(const LL& diff) {
    Clear();
    node* cur = diff.start;
    while (cur != NULL) {
      this->InsertBack(cur->data);
      cur = cur->next;
    }
    return *this;
  }
  bool operator==(const LL&diff) {
    node* cur = diff.start;
    if (diff.Size() != Size()) {
      return false;
    }
    while (start != NULL) {
      if (cur->data != start->data) {
        return false;
      }
      cur = cur->next;
      start = start->next;
    }
    return true;
  }
  bool operator!=(const LL&diff) {
     node* cur = diff.start;
    if (diff.Size() == Size()) {
      return false;
    }
    while (start != NULL) {
      if (cur->data == start->data) {
        return false;
      }
      cur = cur->next;
      start = start->next;
    }
    return true;
  }
  
  friend std::ostream& operator<<(std::ostream& out, const LL& c) {
    out << '[';
    for (auto cur = c.start; cur; cur = cur->next) {
      out << cur->data;
      if (cur->next) out << ", ";
    }
    out << ']';
    return out;
  }
  
  template <class It>
  LL(It first, It last) {
    for (; first != last; ++first) this->InsertBack(*first);
  }
  
  It begin() { return It(start); }

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

 private:
  struct node {

    T data;  
    node* next = nullptr;
    node* prev = nullptr;
  };

  class It {
    friend class LL;
    explicit It(LL::node* val) : cur(val) {}
    public:
    using It_category = std::bidirectional_iterator_tag;
    using value_type = T;
    using difference_type = int;
    using pointer = T*;
    It() {}
    It(const It& other) {
      this->operator=(other);
    }
    ~It() {
      while(this->cur) {
        typename LL<T>::node* temp;
        temp = cur;
        cur = ++temp;
        delete temp;
      }
    }
    It& operator=(const It& that) {
      LL<char> first(that.begin(), that.end());
    }

    It& operator++() {
      this->cur = cur->next;
      return *this;
    }
    It operator++(int) {
      It temp(*this);
      this->operator++();
      return temp;
    }
    It& operator--() {
      this->cur = cur->prev;
      return *this;
    }
    It operator--(int) {
      It temp(*this);
      this->operator--();
      return temp;
    }
    bool operator!=(It that) const { return !(this->operator==(that));}
    bool operator==(It that) const { return this->cur == that.cur;}
    T& operator*() const {return this->cur->data;}
    It* operator->() const {return this;}
    private:
    typename LL<T>::node* cur;
  };

  node* start = nullptr;
  node* last = nullptr;
  std::size_t size = 0;

};

int main() {
  LL<char> list;
  std::cout << list << std::endl;
  for (auto c : std::string("Hello World!")) list.InsertBack(c);
  std::cout << list << std::endl;
  LL<char> temp (list.begin(),list.end());
  temp.RemoveBack();
  std::cout << temp << " = It test"<< std::endl;
  if (list.begin() == temp.begin()) {
    std::cout << "True they are equal" << std::endl;
  } 
  LL<char> first (list);
  LL<char> copy = list;
  copy.Resize(10, '!');
  list.RemoveAll('o');
  copy.RemoveDuplicate();
  std::cout << list << std::endl << copy << std::endl;
}

[ne555]

    It& operator=(const It& that) {
      LL<char> first(that.begin(), that.end());
    }

on your iterator class
`that' is an iterator, ¿does an iterator have `.begin()' and `.end()' member functions?
¿why is an assignment operator for iterators trying to create a list?
you should simply copy the `cur' member variable, which is what the default assignment operator does.

[tpb]

The list itself has the begin() and end() methods, not the iterator. So this doesn't make sense because "that" is an iterator, not a list.

    It& operator=(const It& that) {
      LL<char> first(that.begin(), that.end());    // and <char> should presumably be <T>
    }

There's too much code for me to look through in detail but I noticed a couple of things. For instance operator!= can be simplified to this:

  bool operator!=(const LL&diff) {
      return !operator==(diff);
  }

Don't say if (Empty() == true)
Just say if (Empty())
That's how booleans work.

Also, don't say:

  bool Empty() const {
    if (Size() == 0) { return true; }
    else { return false; }
  }

Just say

  bool Empty() const {
    return (Size() == 0);
  }