/* linkedlistdemo.cpp */
#include <iostream>
#include <string>
#include <vector>
#include <random>
using namespace std;

/* The console outputs color control */
#define RESET "\033[0m"
#define BLACK "\033[30m"              /* Black */
#define RED "\033[31m"                /* Red */
#define GREEN "\033[32m"              /* Green */
#define YELLOW "\033[33m"             /* Yellow */
#define BLUE "\033[34m"               /* Blue */
#define MAGENTA "\033[35m"            /* Magenta */
#define CYAN "\033[36m"               /* Cyan */
#define WHITE "\033[37m"              /* White */
#define BOLDBLACK "\033[1m\033[30m"   /* Bold Black */
#define BOLDRED "\033[1m\033[31m"     /* Bold Red */
#define BOLDGREEN "\033[1m\033[32m"   /* Bold Green */
#define BOLDYELLOW "\033[1m\033[33m"  /* Bold Yellow */
#define BOLDBLUE "\033[1m\033[34m"    /* Bold Blue */
#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */
#define BOLDCYAN "\033[1m\033[36m"    /* Bold Cyan */
#define BOLDWHITE "\033[1m\033[37m"   /* Bold White */

/* LinkedList Node */
template <typename T>
class Node
{
private:
    T data;
    Node<T> *prev;
    Node<T> *next;

public:
    Node(T data);
    ~Node();
    T get_data();
    void set_data(T data);
    Node<T> *get_prev();
    Node<T> *get_next();
    void set_prev(Node<T> *prev);
    void set_next(Node<T> *next);
    friend ostream &operator<<(ostream &output, Node<T> &N)
    {
        output << "{ *prev: " << N.get_prev() << ", data: " << N.get_data() << ", *next: " << N.get_next() << " }";
        return output;
    }
};

template <typename T>
Node<T>::Node(T data)
{
    this->data = data;
    prev = NULL;
    next = NULL;
}

template <typename T>
Node<T>::~Node()
{
}

template <typename T>
T Node<T>::get_data()
{
    return data;
}

template <typename T>
void Node<T>::set_data(T data)
{
    this->data = data;
}

template <typename T>
Node<T> *Node<T>::get_prev()
{
    return this->prev;
}

template <typename T>
Node<T> *Node<T>::get_next()
{
    return this->next;
}

template <typename T>
void Node<T>::set_prev(Node<T> *prev)
{
    this->prev = prev;
}

template <typename T>
void Node<T>::set_next(Node<T> *next)
{
    this->next = next;
}

/* LinkedList By Node<T> */
template <typename T>
class LinkedList
{
private:
    Node<T> *head;
    Node<T> *tail;
    int length;

public:
    LinkedList();
    ~LinkedList();
    void add_front(T data);
    void add_back(T data);
    int size();
    bool is_empty();
    T remove_front();
    T remove_back();
    void front_to_back();
    void back_to_front();
};

template <typename T>
LinkedList<T>::LinkedList()
{
    this->head = NULL;
    this->tail = NULL;
    this->length = 0;
}

template <typename T>
LinkedList<T>::~LinkedList()
{
    Node<T> *cur;
    while (head)
    {
        cur = head->get_next();
        free(head);
        head = cur;
    }
}

template <typename T>
void LinkedList<T>::add_front(T data)
{
    Node<T> *new_node = new Node<T>(data);
    if (tail == NULL)
    {
        tail = new_node;
    }
    else
    {
        new_node->set_prev(NULL);
        head->set_prev(new_node);
        new_node->set_next(head);
    }
    head = new_node;
    length++;
}

template <typename T>
void LinkedList<T>::add_back(T data)
{
    Node<T> *new_node = new Node<T>(data);
    if (head == NULL)
    {
        head = new_node;
    }
    else
    {
        new_node->set_next(NULL);
        new_node->set_prev(tail);
        tail->set_next(new_node);
    }
    tail = new_node;
    length++;
}

template <typename T>
int LinkedList<T>::size()
{
    return length;
}

template <typename T>
bool LinkedList<T>::is_empty()
{
    return head == NULL ? true : false;
}

template <typename T>
T LinkedList<T>::remove_front()
{
    Node<T> *cur = head;
    T data = cur->get_data();
    head = head->get_next();
    free(cur);
    head->set_prev(NULL);
    length--;
    return data;
}

template <typename T>
T LinkedList<T>::remove_back()
{
    Node<T> *cur = tail;
    T data = cur->get_data();
    tail = cur->get_prev();
    free(cur);
    tail->set_next(NULL);
    length--;
    return data;
}

template <typename T>
void LinkedList<T>::front_to_back()
{
    cout << "[";
    Node<T> *cur = head;
    while (cur != NULL)
    {
        cout << *cur << RED << " <===> " << RESET;
        cur = cur->get_next();
    }
    cout << " NULL]\n\n";
}

template <typename T>
void LinkedList<T>::back_to_front()
{
    cout << "[";
    Node<T> *cur = tail;
    while (cur != NULL)
    {
        cout << *cur << RED << " <===> " << RESET;
        cur = cur->get_prev();
    }
    cout << " NULL]\n\n";
}

int main()
{
    cout << "Hello World !" << endl;

    // LinkedList by self !
    LinkedList<int> linklist = LinkedList<int>();
    for (int i = 0; i < 10; i++)
    {
        linklist.add_back(i * i);
    }
    cout << linklist.size() << endl;
    cout << linklist.is_empty() << endl;
    linklist.front_to_back();
    linklist.back_to_front();
    cout << linklist.remove_back() << endl;
    cout << linklist.remove_front() << endl;
    linklist.front_to_back();
    linklist.add_front(100);
    linklist.front_to_back();
    cout << linklist.size() << endl;

    // vector by STL
    vector<int> vt;
    default_random_engine e;
    uniform_int_distribution<unsigned> u(0, 100);
    for (int i = 0; i < 10; i++)
    {
        vt.push_back(u(e));
    }
    vector<int>::iterator v_pointer = vt.begin();
    while (v_pointer != vt.end())
    {
        cout << *v_pointer << " ";
        v_pointer++;
    }
    return 0;
}

$ g++ linkedlistdemo.cpp
$ ./a.exe
[{ *prev: 0, data: 0, *next: 0xf09868 } <===> { *prev: 0xf09fc0, data: 1, *next: 0xf09880 } <===> { *prev: 0xf09868, data: 4, *next: 0xf09898 } <
===> { *prev: 0xf09880, data: 9, *next: 0xf098b0 } <===> { *prev: 0xf09898, data: 16, *next: 0xf098c8 } <===> { *prev: 0xf098b0, data: 25, *next: 
0xf098e0 } <===> { *prev: 0xf098c8, data: 36, *next: 0xf098f8 } <===> { *prev: 0xf098e0, data: 49, *next: 0xf09910 } <===> { *prev: 0xf098f8,
 data: 64, *next: 0xf09928 } <===> { *prev: 0xf09910, data: 81, *next: 0 } <===>  NULL]

[{ *prev: 0, data: 100, *next: 0xf09868 } <===> { *prev: 0xf09fc0, data: 1, *next: 0xf09880 } <===> { *prev: 0xf09868, data: 4, *next: 0xf09898 }
 <===> { *prev: 0xf09880, data: 9, *next: 0xf098b0 } <===> { *prev: 0xf09898, data: 16, *next: 0xf098c8 } <===> { *prev: 0xf098b0, data: 25, *next
: 0xf098e0 } <===> { *prev: 0xf098c8, data: 36, *next: 0xf098f8 } <===> { *prev: 0xf098e0, data: 49, *next: 0xf09910 } <===> { *prev: 0xf098f
8, data: 64, *next: 0 } <===>  NULL]