Two things:

• You need to use a lot of consts.

Example:

    void setNext(ListNode &node)

    void setNext(const ListNode &node)

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

Since you are using a container, there's really no reason to expose the ListNode class to your users, especially since all it does is hold a value. Instead, you can modify your addFirst and addLast functions to take the value directly and create a ListNode internally:

void addFirst(int val)
{
     ListNode node = new ListNode(val);
     if (isEmpty())
     {
         *head = node;
         *tail = node;
         size = 1;
     }
     else {
         node.setNext(*head);
         head->setPrev(node);
         *head = node;
         size++;
     }
}

Now, if later on you decide to change the way ListNode works, you can change it internally without having to change any code. It's also easier on the user:

LinkedList myList;
myList.addFirst(5);

Lastly, it means that you control how the ListNode objects are actually created, so you can easily control how they are deleted. By leaving their creation to the user, the user might accidentally delete a reference to one and leave your list with a dangling reference. For example, if the user wrote a function like:

LinkedList* createList(std::vector<int> values)
{
    LinkedList* myList = new LinkedList;
    for (int i = 0; i < values.size(); ++i)
    {
        ListNode node(values[i]);
        myList -> addLast(node);
    }
    return myList;
}

All of the node objects were declared in the for scope, so once that exits they become invalid. The user might pick up on the problem if they notice addLast takes a reference, or if your documentation explicitly states that the ListNode objects need to be kept valid, but usually container classes take that burden off the of the user.

Next to what @GutiMac already remarked:

Doing really different things in overloaded constructors is weird.

I would expect the constructor for ListNode to be:

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

If your node has an invalid value by default, this should be filled in in some way. Make sure to initialize everything.

Make your ListNode non-copyable/movable by deleting copy constructor, move constructor, assignment operator and move assignment operator because copying would mean that the new list-node points to the same prev and next. You can always make a new node with the same value by giving the value to the constructor.

Your LinkedList still needs some find/iterator functionality and some remove functionality to be a useful container and the destructor should clean up the nodes.

As it is now, when copying the linked list, two instances will now point to the same data. Either avoid copying (see LinkNode) or make a deep copy of all the nodes in the copy constructor.

Also, but this can be an extension: containers are usually made as templates. There is not that much difference except that templates should be fully implemented in the header file.

Lastly, while it is nice to make your own containers as exercise, in production code, use std::list

Couple of things:

std namespace

using namespace std;

Do not use this. Type "std::" where is needed:

std::cout << empty << std::endl;

std::endl

Do not use std::endl. It does implicit flush. This hurts the performance a lot. Use \n instead:

std::cout << empty << '\n';

system()

Don't use system("PAUSE");.

This forks new shell (probably in your case "cmd.exe") and executes via the shell command "pause".

I do not know what C++ function you should use, but probably getchar will do. However it is C function.

http://www.cplusplus.com/reference/cstdio/getchar/

For this you need to add #include <cstdio>.

pragma once

I see you have used #pragma once. It is well supported, but it is not standard. Try use "include guard" it is what standard way.

https://en.wikipedia.org/wiki/Include_guard

main()

This is perfectly OK:

int main(void){
}

However I would use this instead, even I do not use any arguments. This is because argv[0] is always set.

int main(int atgc, char **argv){
}

return 0 from main()

In latest C++, return 0; from main() is optional. Since is there, do not remove it.

const method

bool LinkedList::isEmpty();

should be const, e.g.

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

Also move this into the .h file. It is so short.

destructor

Your destructor is empty - remove it completely.

default constructor in ListNode

default constructor in ListNode is empty. You can not remove it, because you have one more constructor. However if you have C++11, you can do:

class ListNode
{
public:
    ListNode() = default;
    ListNode(int val);
//...

inline methods in ListNode

inline methods are present into the class definitions. Remove all "inline" keyword, it does not needed.

However ListNode is so small, I would merge it in .h file like this:

class ListNode
{
public:
    ListNode() = default;

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

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

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

constructor class member "initializers"

I may be using incorrect term, but constructor better be like this:

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

possible error:

constructors / destructor of ListNode does not add-up. there is some error somewhere.

possible error in constructor

probably there is an error? why you create prev and next here? I believe you need to set those point to something else, not to allocate new nodes?

or possible error in default constructor and destructor

you have default constructor. what is it purpose? just to have one? it does not initialize prev and next. You probably want to remove it.

probably destructor wants to free the memory? I said to remove it, because it does nothing.

or possible benefit of using "std::unique_ptr"?

you probably want to use automatic memory management using "std::unique_ptr" (C++11 feature)