Linked list using dynamic memory I created a simple linked list to test what I've learned so far and if I manage everything correctly. If you see syntax errors is't because of copy-paste. I just want to know if i'm making everything in the right way without 
having leak and memory problems.

Node class

#include "Node.h"


//Constructor.
Node::Node(int v)
:next(nullptr), value(v)
{
}


//Deconstrucor (not in use).
Node::~Node()
{
}


//Set next.
void Node::set_next(Node *new_node)
{
    this -&gt; next = new_node;
}


//Set previous.
void Node::set_prev(Node *new_node)
{
    this -&gt; prev = new_node;
}


//Set value.
void Node::set_value(int v)
{
    this -&gt; value = v;
}


//Get next.
Node *Node::get_next()
{
    return this -&gt; next;
}


//Get previous.
Node *Node::get_prev()
{
   return this -&gt; prev;
}


//Get value
int Node::get_value()
{
    return this -&gt; value;
}


LinkedList class

#include "LinkedList.h"
#include "Node.h"
#include &lt;new&gt;
#include &lt;iostream&gt;


//Constructor.
LinkedList::LinkedList()
:head(nullptr), tail(nullptr), moving_ptr(nullptr)
{
}


//Deconstrucor (not in use).
LinkedList::~LinkedList()
{
}


//Append a new item on the list.
void LinkedList::append(int v)
{

    //Allocate a new node.
    Node *new_node = new (std::nothrow)Node(v);


    //If memory is full, exit the program.
    if (new_node == nullptr){
        std::cout &lt;&lt; "Memory is full, program will exit." &lt;&lt; std::endl;
        exit(0);
    }


    //If this is the first node.
    if (head == nullptr || tail == nullptr)
        {
            head       = new_node;
            tail       = new_node;
            moving_ptr = new_node;
        }


    //Append other node.
    else
        {
            tail -&gt; set_next(new_node); //Link it after the tail of the list.
            new_node -&gt; set_prev(tail); //Set the previous node.
            tail = new_node;            //Update the tail pointer.
        }
}



//Remove a node from the list.
bool LinkedList::remove_item(int v)
{

    //Starting node.
    Node *curr = head;


    //----Find the node that contains v----//
    while (curr != nullptr)
    {

        //Found.
        if (curr -&gt; get_value() == v)
            break;


        //Keep going.
        else
            curr = curr -&gt; get_next();
    }
    //----Find the node that contains v----//



//The item was not found into the list.
if (curr == nullptr)
    return false;



//Make necessary links!!!
curr -&gt; get_prev() -&gt; set_next( curr -&gt; get_next() );


//Delete current node.
delete curr;

return true;
}



//Get the next item.
int LinkedList::nextItem()
{

    //Temp that hold current value.
    int temp = moving_ptr -&gt; get_value();


    //Move to the next node.
    moving_ptr = moving_ptr -&gt; get_next();

    //Return the value.
    return temp;
}


//Return true if moving_ptr is not null.
bool LinkedList::hasNext()
{
    return moving_ptr != nullptr;
}


//Reset moving_ptr.
void LinkedList::reset()
{
    moving_ptr = head;
}


Am I handling everything correctly? I also tried to fill all my memory with an infinite loop to see what happens and everything run's smoothly. The program terminates when memory is full.
Memory Leaks

You aren't cleaning up after your LinkedList.  When the class is destroyed you want to make sure that all of the memory it has allocated is cleaned up.  At a minimum, you're going to want to:

LinkedList::~LinkedList()
{
    delete head;
}


However you also need to consider each node in the list.  You can either have ~Node delete it's next, or you can put a loop in to delete all the items in the list from the tail backwards.  Usually you would also implement this in a public function like clear or flush so that the whole list can be easily emptied.  For example, something like this would clear up the list:

void clearList() {
    Node *tmp = head;
    while(tmp) {
        head = tmp-&gt;get_next();
        delete tmp;
        tmp = head;
    }
}


Exit

You exit if there is insufficient memory to allocate a node.  The exitcode 0 is usually reserved for a successful program exit.  You should be passing a different value to exit (usually a negative number) to indicate failure.

Heads or Tails

In your remove_item method, you're not updating your tail pointer, what is going to happen if the tail happens to be pointing at the node that contains the value you remove?  Similarly, what happens if moving_ptr is pointing at the node that's removed?

reset

I'd honestly expect this to clear/flush/empty the list, not just reset the pointer that's used for iterating over items in the list.  This is likely to be confusing.

templates

Depending on what it is you're practising for, a good next step would be to adapt your Node so that it can support a templated value type.  You could then extend the list to store and retrieve values of any type.