Simple Linked List that holds an int I am inexperienced in C++.  I was able to get my LinkedList to be fully functional.  I was hoping to get some feedback as to whether or not I followed bad practices and if there are any risks associated with my code.

LinkedList.h

#pragma once

#include &lt;string&gt;

#include "Node.h"

class LinkedList
{
private:
    Node *head;
    int count;
public:
    LinkedList();
    ~LinkedList();
    int get_count();
    void AddNode(int);
    std::string GetList();
    bool Contains(int);
    void Remove(int);
    int GetValue(int);
};


LinkedList.cpp

#include &lt;iostream&gt;

#include "LinkedList.h"

LinkedList::LinkedList()
{
    head = new Node(0);
}

LinkedList::~LinkedList()
{
}

int LinkedList::get_count(){
    return count;
}

void LinkedList::AddNode(int _value){
    Node *node = new Node(_value);
    Node *previousNode = head;
    while (previousNode-&gt;next_node &amp;&amp; previousNode-&gt;next_node-&gt;get_value() &lt;= node-&gt;get_value()){
        previousNode = previousNode-&gt;next_node;
    }
    if (previousNode-&gt;next_node){
        node-&gt;next_node = previousNode-&gt;next_node;
    }
    previousNode-&gt;next_node = node;
    count++;
}

std::string LinkedList::GetList(){
    std::string list;
    Node *currentNode = head;
    while (currentNode-&gt;next_node){
        currentNode = currentNode-&gt;next_node;
        list += std::to_string(currentNode-&gt;get_value()) + " ";
    }
    return list;
}

bool LinkedList::Contains(int number){
    Node *currentNode = head;
    while (currentNode-&gt;next_node){
        currentNode = currentNode-&gt;next_node;
        if (currentNode-&gt;get_value() == number){
            return true;
        }
        if (currentNode-&gt;get_value() &gt; number){
            return false;
        }
    }
    return false;
}

void LinkedList::Remove(int number){
    Node *previousNode = head;
    Node *currentNode = head;
    while (currentNode-&gt;next_node){
        previousNode = currentNode;
        currentNode = currentNode-&gt;next_node;
        if (currentNode-&gt;get_value() == number){
            previousNode-&gt;next_node = currentNode-&gt;next_node;
            delete currentNode;
            count--;
            return;
        }
    }
}

int LinkedList::GetValue(int index){
    Node *currentNode = head;
    int currentIndex = -1;
    while (currentNode-&gt;next_node){
        currentNode = currentNode-&gt;next_node;
        currentIndex++;
        if (index == currentIndex){
            return currentNode-&gt;get_value();
        }
    }
    return -1;
}


Node.h

#pragma once

class Node
{
private:
    int value;
public:
    Node(int);
    ~Node();
    Node *next_node;
    int get_value();
    void set_value(int);
};


Node.cpp

#include "Node.h"

Node::Node(int _value)
{
    value = _value;
}

Node::~Node()
{
}

int Node::get_value(){
    return value;
}
void Node::set_value(int _value){
    value = _value;
}
Instead of having Node use getters and setters, just make it a struct declared within the private section of LinkedList.  It won't need its own files, either.
All but one of your functions are in PascalCase.  Whether you choose that or camelCase, choose just one and maintain that.  This should be kept consistent.
When creating a new linked list, the head should first point to NULL (or nullptr in C++11) to indicate an empty list.  You're instead having the head point to a new node, so the list isn't really considered empty at the start.
You have an empty destructor, even though you allocate memory with new.  In order to prevent memory leaks, the destructor should use delete on each allocated Node.  This is typically done with a loop through the list.
Member functions that don't modify data members should be const.  This also prevents any accidental modifications to data members within these functions.

An example with your get_count() function:

int LinkedList::get_count() const {
    return count;
}