Memory segmentation fault in the double linked list implementation - c++

Question

Below I have a implementation of Linked List.
While there may be more errors because I have not yet finished, let's focus at the four functions: pop_front, push_front, push_back, pop_back.
Everything seems working, until I try to implement push_back. The testing code throws segmentation fault. I don't have idea why, because like it's pretty symmetric operation to the push_front but just at the another end of the list. And the push_front just works.
#include <iostream>
#ifndef LINKED_LIST_H
#define LINKED_LIST_H
#include "AbstractList.hxx"
template <class T>
class LinkedList : public AbstractList<T>
{
public:
struct Node
{
T value;
Node *prev;
Node *next;
};
LinkedList()
{
guard = new Node;
guard->prev = nullptr;
guard->next = nullptr;
}
// copy,move construction and assignment are not relevant to the question
~LinkedList()
{
clear();
}
template <class U>
void push_front(U &&x)
{
Node *fresh = new Node;
fresh->value = std::forward<U>(x);
fresh->prev = nullptr;
fresh->next = guard->next;
guard->next = fresh;
if (empty())
{
guard->prev = fresh;
}
}
T pop_front()
{
if (empty())
throw std::out_of_range("List is empty");
Node *toDelete = guard->next;
int temp = toDelete->value;
guard->next = guard->next->next;
delete toDelete;
return temp;
}
template <class U>
void push_back(U &&x)
{
Node *fresh = new Node;
fresh->value = std::forward<U>(x);
fresh->next = nullptr;
guard->prev = fresh;
if (empty())
{
guard->next = fresh;
}
}
/*
T pop_back()
{
if (empty())
throw std::out_of_range("List is empty");
Node *toDelete = guard->prev;
int temp = toDelete->value;
guard->prev = guard->prev->prev;
delete toDelete;
return temp;
}
*/
struct Iterator
{
public:
Node *ptr;
Iterator(Node *ptr_) : ptr(ptr_){};
Iterator &operator++()
{
ptr = ptr->next;
return *this;
}
Iterator &operator++(int)
{
Iterator *temp = this;
ptr = ptr->next;
return *temp;
}
Iterator &operator--()
{
ptr = ptr->prev;
return *this;
}
Iterator &operator--(int)
{
Iterator *temp = this;
ptr = ptr->prev;
return *temp;
}
bool operator==(const Iterator &b)
{
return ptr == b.ptr;
}
bool operator!=(const Iterator &b)
{
return !operator==(b);
}
T &operator*()
{
return ptr->value;
}
};
Iterator find(const T &x)
{
Iterator point = begin();
while (point != end())
{
if (*point == x)
return point;
point++;
}
// or end()?
return nullptr;
}
// usuwa cala liste
void clear()
{
Node *current = guard->next;
while (current != nullptr)
{
Node *next = current->next;
delete current;
current = next;
}
guard->prev = nullptr;
guard->next = nullptr;
}
Iterator erase(Iterator x)
{
Iterator point = begin();
while (point != end())
{
if (point == x)
{
for (point; point != end(); point++)
{
point = ++x;
}
return ++x;
}
point++;
}
return nullptr;
}
template <class U>
Iterator insert(Iterator it, U &&x)
{
for (Iterator point = it; point != end(); point++)
{
(point + 1) = point;
}
it = std::forward<U>(x);
}
int remove(const T &x)
{
int count = 0;
Iterator point = begin();
Iterator last = end();
while (point != last)
{
Iterator next = point;
++next;
if (*point == x)
{
erase(point);
count++;
}
point = next;
}
return count;
}
int size()
{
Iterator point = begin();
int count = 0;
while (point != end())
{
count++;
point++;
}
return count;
}
bool empty()
{
return guard->next == nullptr;
}
Iterator begin() const
{
return Iterator(guard->next);
}
Iterator end() const
{
return Iterator(guard->prev);
}
private:
// head = next, prev = tail
Node *guard;
};
#endif
Testing code:
#include <iostream>
#include "./LinkedList.hxx"
int main(int argc, char *argv[])
{
LinkedList<int> l1;
std::cout << l1.size() << std::endl;
l1.push_front(1);
l1.push_front(2);
l1.push_front(3);
for (auto itr = l1.begin(); itr != l1.end(); itr++)
std::cout << *itr << std::endl;
std::cout << "fpops: " << l1.pop_front() << std::endl;
std::cout << "fpops: " << l1.pop_front() << std::endl;
std::cout << "if empty " << l1.empty() << std::endl;
std::cout << "fpops: " << l1.pop_front() << std::endl;
for (auto itr = l1.begin(); itr != l1.end(); itr++)
std::cout << *itr << std::endl;
std::cout << l1.size() << std::endl;
std::cout << "if empty " << l1.empty() << std::endl;
l1.push_back(1);
std::cout << l1.size() << std::endl;
}