Find the Error or memory leak

I was writing LinkedList Program in C++ Here is the Code. Find the Error and Memory Leak or anything else. I want to write a perfect code.

#ifndef LEARN_REVERSELINKLIST_H
#define LEARN_REVERSELINKLIST_H

#include <string>
#include <utility>
#include <iostream>
#include <boost/assert.hpp>

class ReverseLinkList {
private:
    struct Node {
        std::string string;
        Node *Previous{};
        Node *Next{};
    };

    Node *head;
    Node *tail;

    int count;

public:
    ReverseLinkList();
    ~ReverseLinkList();

    void insert(std::string string);
    void insertAt(std::string string, int position);
    void iterator() const;
    void reverseIterator() const;
    void remove(const std::string &string);
    void removeAt(int position);
    int size() const;
    Node *getHead() const;
    Node *getTail() const;
};

#endif //LEARN_REVERSELINKLIST_H

and Here is the CC File

#include "ReverseLinkList.h"

ReverseLinkList::~ReverseLinkList() {
    Node *temp = head;

    while(temp != tail->Next) {
        delete temp;
        temp = temp->Next;
    }
    tail = nullptr;
    head = nullptr;
}

ReverseLinkList::ReverseLinkList() :
        head(nullptr), tail(nullptr), count(0) {
}

void ReverseLinkList::iterator() const {
    BOOST_ASSERT_MSG(count != 0, "List is empty");
    Node *temp;
    temp = head;

    while(temp != tail->Next) {
        std::cout << temp->string << std::endl;
        temp = temp->Next;
    }
}

void ReverseLinkList::reverseIterator() const {
    BOOST_ASSERT_MSG(count != 0, "List is empty");
    Node *temp;
    temp = tail;

    while(temp != head->Previous) {
        std::cout << temp->string << std::endl;
        temp = temp->Previous;
    }
}

void ReverseLinkList::insert(std::string string) {
    auto *newNode = new Node;

    newNode->string = std::move(string);
    count++;

    if(head == nullptr && tail == nullptr) {
        newNode->Previous = nullptr;
        newNode->Next = nullptr;
        head = newNode;
        tail = newNode;
    }
    else {
        tail->Next = newNode;
        newNode->Next = nullptr;
        newNode->Previous = tail;
        tail = newNode;
    }
}

int ReverseLinkList::size() const {
    return count;
}

void ReverseLinkList::remove(const std::string &string) {
    BOOST_ASSERT_MSG(count != 0, "List is empty");
    if(head->string == string) {
        Node *temp;
        temp = head->Next;
        delete head;
        head = temp;
        head->Previous = nullptr;
        count--;
        return;
    }
    if(tail->string == string) {
        Node *temp;
        temp = tail->Previous;
        delete tail;
        tail = temp;
        temp->Next = nullptr;
        count--;
        return;
    }

    Node *temp;
    temp = head;
    bool verbose = true;

    while(temp != tail->Next) {
        if(temp->string == string) {
            verbose = false;
            break;
        }
        temp = temp->Next;
    }

    if(verbose) {
        std::cerr << "Node not present" << std::endl;
        return;
    }

    Node *previous, *next;
    previous = temp->Previous;
    next = temp->Next;

    delete temp;
    previous->Next = next;
    next->Previous = previous;
    count--;
}

void ReverseLinkList::insertAt(std::string string, int position) {
    BOOST_ASSERT_MSG(count != 0, "List is empty");
    if(position > count)
        return;

    if(position == count)
        insert(string);

    Node *temp;
    temp = head;

    while(position != 1) {
        temp = temp->Next;
        position--;
    }

    Node *next;
    next = temp->Next;

    auto *newNode = new Node;
    newNode->string = string;

    temp->Next = newNode;
    newNode->Previous = temp;
    newNode->Next = next;
    next->Previous = newNode;

    count++;
}

ReverseLinkList::Node *ReverseLinkList::getHead() const {
    return head;
}

ReverseLinkList::Node *ReverseLinkList::getTail() const {
    return tail;
}

void ReverseLinkList::removeAt(int position) {
    BOOST_ASSERT_MSG(count != 0, "List is empty");
    if(position > count)
        return;

    Node *temp;
    if(position == 0) {
        temp = head->Next;
        delete head;
        head = temp;
        head->Previous = nullptr;
        return;
    }

    if(position == count) {
        temp = tail->Previous;
        delete tail;
        tail = temp;
        tail->Next = nullptr;
        return;
    }

    temp = head;
    while(position != 0) {
        temp = temp->Next;
        position--;
    }

    Node *previous;
    Node *next;

    previous = temp->Previous;
    next = temp->Next;
    delete temp;
    previous->Next = next;
    next->Previous = previous;
    count--;
}

I would like to have some suggestion how can I write better code and Implement it. If you have some functions you would like to add please do post. My next move is to make this code using templates