LinkedList of int nodes in C++ I'm new to C++ programming. I'm experienced in Java and its OOP paradigm.
This code works well. I just need to make sure whether it's correct in terms of C++ programming standard.

main.cpp

#include &lt;iostream&gt;
#include "ListNode.h"
#include "LinkedList.h"

using namespace std;

int main(void) {

    LinkedList l;
    ListNode a(10);
    ListNode b(5);
    ListNode c(3);
    l.addFirst(a);
    l.addFirst(b);
    l.addLast(c);

    bool empty = l.isEmpty();

    cout &lt;&lt; l.listSize() &lt;&lt; endl;

    cout &lt;&lt; empty &lt;&lt; endl;

    system("PAUSE");
    return 0;
}


LinkedList.h

#pragma once
#include "ListNode.h"

class LinkedList
{
public:
    LinkedList();
    ~LinkedList();
    void addFirst(ListNode &amp;node);
    void addLast(ListNode &amp;node);
    bool isEmpty();
    int listSize();

private:
    ListNode *head;
    ListNode *tail;
    int size;
};


LinkedList.cpp

#include "LinkedList.h"



LinkedList::LinkedList()
{
    head = new ListNode();
    tail = new ListNode();
}


LinkedList::~LinkedList()
{
}

void LinkedList::addFirst(ListNode &amp; node)
{
    if (isEmpty())
    {
        *head = node;
        *tail = node;
        size = 1;
    }
    else {
        node.setNext(*head);
        head-&gt;setPrev(node);
        *head = node;
        size++;
    }
}

void LinkedList::addLast(ListNode &amp; node)
{
    if (isEmpty())
    {
        *tail = node;
        *head = node;
        size = 1;
    }
    else
    {
        tail-&gt;setNext(node);
        node.setPrev(*tail);
        *tail = node;
        size++;
    }
}

bool LinkedList::isEmpty()
{
    return size == 0;
}

int LinkedList::listSize()
{
    return size;
}


ListNode.h

#pragma once
class ListNode
{
public:
    ListNode();
    ListNode(int val);
    ~ListNode();

    inline void setPrev(ListNode &amp;node) { *prev = node; }
    inline ListNode *getPrev() { return prev; }
    inline void setNext(ListNode &amp;node) { *next = node; }
    inline ListNode *getNext() { return next; }
    inline void setValue(int val) { value = val; }
    inline int getValue() { return value; }

private:
    ListNode *prev;
    ListNode *next;
    int value;
};


ListNode.cpp

#include "ListNode.h"



ListNode::ListNode()
{
}

ListNode::ListNode(int val)
{
    prev = new ListNode;
    next = new ListNode;
    value = val;
}


ListNode::~ListNode()
{
}


Am I do it correctly as usually done by C++ programmer? Or there is something I need to fix.
I heavily put my focus on pointer/reference usage.
Two things:


You need to use a lot of consts.


Example:

    void setNext(ListNode &amp;node)

    void setNext(const ListNode &amp;node)



You call to new in some places of your code but never call to delete