Помоги мне, пожалуйста, разобраться с ошибкой! 
Ошибка	C2259	"PersistentDoublyLinkedListImpl<int>": невозможно создать экземпляр абстрактного класса. Она возникает в функции testPersistentDoublyLinkedList() в моменте создания экземпляра класса PersistentDoublyLinkedListImpl
Вот мой код:
Файл Source.cpp:
#include <iostream>
#include "persistent_doubly_linked_list.h"
void testPersistentDoublyLinkedList()
{
    PersistentDoublyLinkedListImpl<int> list{};

}

int main()
{
   testPersistentDoublyLinkedList();
    return 0;
}

Файл persistent_doubly_linked_list.h:
#ifndef PERSISTENT_DOUBLY_LINKED_LIST_H
#define PERSISTENT_DOUBLY_LINKED_LIST_H

#include "persistent.h"
#include <iostream>
#include <vector>
#include <stdexcept>

template <typename T>
class PersistentDoublyLinkedListImpl : public PersistentDoublyLinkedList<T>
{
private:
	// List node
	struct Node
	{
		T value;
		Node* prev;
		Node* next;

		Node(const T& val) : value(val), prev(nullptr), next(nullptr) {}
	};

	// List of versions
	struct Version
	{
		Node* head;
		Node* tail;
		size_t size;

		Version(Node* h = nullptr, Node* t = nullptr, size_t s = 0) : head(h), tail(t), size(s) {}
	};

	std::vector<Version> versions{};

	Node* copyList(Node* head)
	{
		if (!head)
		{
			return nullptr;
		}

		Node* newHead = new Node(head->value);
		Node* current = head->next;
		Node* newCurrent = newHead;

		while (current)
		{
			Node* newNode = new Node(current->value);
			newNode->prev = newCurrent;
			newCurrent->next = newNode;
			newCurrent = newNode;
			current = current->next;
		}

		return newHead;
	}

public:

	// Empty Constructor
	PersistentDoublyLinkedListImpl() = default;

	// Append element to the end
	void append(const T& value) override
	{
		Node* newNode = new Node(value);

		// Copy last version
		Version newVersion = versions.empty() ? Version() : Version(copyList(versions.back().head), nullptr, versions.back().size);

		if (!newVersion.head)
		{
			newVersion.head = newVersion.tail = newNode;
		}
		else
		{
			newNode->prev = newVersion.tail;
			newVersion.tail->next = newNode;
			newVersion.tail = newNode;
		}

		newVersion.size++;

		versions.push_back(newVersion);
	}

	// Get an element
	T get(int index) const override
	{
		if (versions.empty())
		{
			throw std::runtime_error("List is not initialized.");
		}
		if (index < 0 || index >= static_cast<int>(versions.back().size))
		{
			throw std::out_of_range("Index is out of range.");
		}

		Node* current = versions.back().head;

		for (int i = 0; i < index; i++)
		{
			current = current->next;
		}

		return current->value;
	}

	// Print all versions
	void printAllVersions() const override
	{
		if (versions.empty())
		{
			throw std::runtime_error("List is not initialized.");
		}

		for (size_t i = 0; i < versions.size(); i++)
		{
			std::cout << "Version " << i << ": ";

			Node* current = versions[i].head;
			while (current)
			{
				std::cout << current->value << " ";
				current = current->next;
			}

			std::cout << std::endl;
		}
	}

	// Delete element
	void remove(int index) override
	{
		if (versions.empty())
		{
			throw std::runtime_error("List is not initialized.");
		}
		if (index < 0 || index >= static_cast<int>(versions.back().size))
		{
			throw std::out_of_range("Index is out of range.");
		}

		// Copy last version
		Version newVersion = Version(copyList(versions.back().head), nullptr, versions.back().size);

		Node* current = newVersion.head;
		for (int i = 0; i < index; i++)
		{
			current = current->next;
		}

		// Delete node
		if (current->prev) current->prev->next = current->next;
		if (current->next) current->next->prev = current->prev;
		if (current == newVersion.head) newVersion.head = current->next;
		if (current == newVersion.tail) newVersion.tail = current->prev;
		delete current;

		newVersion.size--;

		versions.push_back(newVersion);
	}

	// Number of versions
	size_t versionCount() const override
	{
		return versions.size();
	}

};

#endif PERSISTENT_DOUBLY_LINKED_LIST_H

Файл persistent.h:
#ifndef PERSISTENT_H
#define PERSISTENT_H

#include <vector>
#include <string>

// Common interface for all data structures
template <typename T>
class PersistentStructure
{
public:
    virtual void insert(int index, const T& value) = 0;

    virtual void remove(int index) = 0;

    virtual T get(int index) const = 0;

    virtual void addVersion(int baseVersionIndex, int changeIndex, const T& newValue) = 0;

    virtual void printAllVersions() const = 0;

    virtual size_t versionCount() const = 0;

    virtual ~PersistentStructure() {}
};

template <typename T>
class PersistentDoublyLinkedList : public PersistentStructure<T>
{
public:
    // Append element to the end
    virtual void append(const T& value) = 0;

    // Getting slice of a list
    virtual std::vector<T> slice(int start, int end) const = 0;

    // Destructor
    virtual ~PersistentDoublyLinkedList() {}
};

#endif // PERSISTENT_H