How to implement Front() method to return the first element of a templated doubly linked list C++?

Question

Whenever I implement the front() method (to return the first element of the doubly linked list) in the main I get a segmentation fault even though the back() method (returning the info of tail) that was implemented in a similar manner works. Can someone help?

template <class T>
class Node {
    public:
    T info;
    Node<T>* next;
    Node<T>* prev;

    Node(const T info){
        this->info = info;
        next = NULL;
        prev =  NULL;

    } 
    Node* getNode(T info){
        Node* newnode = (Node *)malloc(sizeof(Node));
    }
};

template <class T> 
class DLlist {
    private:
    Node<T>* head;
    Node<T>* tail;
    int size;

    public:
    DLlist();
    T front();
    T back();
};

template<class T> 
DLlist<T>::DLlist(){
    head = NULL;
    tail = NULL;
    size = 0;
}

template <class T> 
void DLlist<T>::addback(const T newdata){
     if (isEmpty()){
        Node<T> *newnode = new Node<T>(newdata);
        head = tail = newnode;
        size++;
        return;
    }

    Node<T> *newnode;
    newnode = new Node<T>(newdata);
    newnode->prev = tail;
    newnode->next = NULL;
    tail->prev = newnode;
    tail = newnode;

    size++;
}

template <class T> 
T DLlist<T>::front(){
     return (head->info);
}

Answer 1

In your addback() function:

    Node<T> *newnode;                // Two lines where
    newnode = new Node<T>(newdata);  // one suffices
    newnode->prev = tail;
    newnode->next = NULL;  // Unnecessary, your constructor did this
    tail->prev = newnode;  // THIS IS YOUR PROBLEM
    tail = newnode;

    size++;

Your tail should be setting its next pointer to the new node, not its previous. Drawing this stuff out on a piece of paper can go a long way in better understanding how it should work.

I am always willing to chalk up poor formatting on this site to copy/paste, but there are other things you can do to simplify your code, make it a bit more modern, etc.

So here's your code again, cleaned up a tad (This code went through clang-format using the Webkit style):

#include <iostream>

template <class T>
struct Node {
    T info;
    Node<T>* next = nullptr;
    Node<T>* prev = nullptr;

    Node(const T& info)
        : info(info)
    {
    }
    // Don't know why you need this, so just deleting it because it's a bad
    // function
};

template <class T>
class DLlist {
private:
    Node<T>* head = nullptr;
    Node<T>* tail = nullptr;
    int size = 0;

public:
    DLlist() = default;
    bool isEmpty() { return head == nullptr && tail == nullptr; }
    void push_back(const T& newdata);
    const T front() const;
    const T back() const;
};

template <class T>
void DLlist<T>::push_back(const T& newdata)
{
    if (isEmpty()) {
        head = new Node<T>(newdata);
        tail = head;
        size++;
        return;
    }

    Node<T>* newnode = new Node<T>(newdata);
    newnode->prev = tail;
    tail->next = newnode; // THIS WAS PROBABLY YOUR ISSUE
    tail = newnode;

    size++;
}

template <class T>
const T DLlist<T>::front() const
{
    return head->info;
}

template <class T>
const T DLlist<T>::back() const
{
    return tail->info;
}

int main()
{
    DLlist<int> list;
    list.push_back(42);
    list.push_back(54);
    std::cout << list.front() << '\n';  // 42 prints just fine, Debian w/ LLVM 9
}