Linked stack implementation in C++ Please feel free to be as harsh as possible.

Implementation file:

#include "Stack.h"
#include &lt;iostream&gt;
using namespace std;

// Initializes an empty Stack.
Stack::Stack() {
    this-&gt;head = new node();
    this-&gt;num_elements = 0;

    // set default values for head
    this-&gt;head-&gt;next = 0;
    this-&gt;head-&gt;value = 0;
}

// Cleans up memory before the Stack's destruction.
Stack::~Stack() {
    while (this-&gt;head-&gt;next != 0) {
        pop();
    }
    delete this-&gt;head;
}

// Pushes value onto the top of the stack.
void Stack::push(int value) {
    node* newTopNode = new node();
    newTopNode-&gt;value = value;

    // currentTopNode may be null if stack is empty
    node* currentTopNode = this-&gt;head-&gt;next;

    this-&gt;head-&gt;next = newTopNode;
    newTopNode-&gt;next = currentTopNode;

    this-&gt;num_elements++;
}

// Pops the top-most value off the stack and returns its value.
int Stack::pop() {
    if (this-&gt;head-&gt;next == NULL) {
        cout &lt;&lt; "\nIllegal State Exception: You cannot pop an empty stack." &lt;&lt; endl;
        return 0;
    } else {
        node* topNodeToRemove = this-&gt;head-&gt;next;

        // save the value of the node before deleting it
        int topNodeValue = topNodeToRemove-&gt;value;

        this-&gt;head-&gt;next = this-&gt;head-&gt;next-&gt;next;

        delete topNodeToRemove;
        this-&gt;num_elements--;

        return topNodeValue;
    }
}

// Returns the value at the top of the stack.  Works similarly to pop(), but
// retains the internal structure of the stack.  That is, it does not remove
// the top-most element.
int Stack::getTopElement() const {
    if (this-&gt;head-&gt;next == NULL) {
        cout &lt;&lt; "\nIllegal State Exception: You cannot get the top element of an empty stack." &lt;&lt; endl;
        return 0;
    } else {
        return this-&gt;head-&gt;next-&gt;value;
    }
}

// Returns the number of elements currently in the stack.
int Stack::size() const {
    return this-&gt;num_elements;
}


Header file:

#ifndef STACK_H_
#define STACK_H_

class Stack {
public:
    Stack();
    ~Stack();
    void push(int);
    int pop();
    int getTopElement() const;
    int size() const;

private:
    struct node {
        int value;
        node* next;
    };

    node* head;
    int num_elements;
};

#endif // STACK_H_
Do not use using namespace std.
In the constructor and push(), it looks like you're calling new on a function.  It should be node.
Prefer nullptr to NULL and 0 for the node pointers if you're using C++11.  Otherwise, you should choose either NULL or 0 for node pointers and keep it consistent.
You don't need this-&gt; everywhere as the code already has the current object in scope.
It's needless to call pop() in the destructor.  For one thing, pop() returns a value.  You should just be using delete.

Instead, have head point to the first element, loop through the stack (stopping when NULL is hit) and call delete on each node.  With this, you won't need to delete head at the end.
pop() and getTopElement() might be best as void.  Here, a 0 is returned if the list is empty.  Sure, no errors happening there.  But then the calling code will take it as an element 0, never knowing whether or not the stack is empty.  If you make them void, you can simply return if the stack is empty.  As for retrieving an element, that's why you have getTopElement().  Once you get the value with getTopElement(), call pop() after that.

Regarding checking for an empty stack, you could make a public empty() function for calling code.  The two functions above should still check for an empty stack, but containers like this usually utilizes such a function.  This could go in the header:

bool empty() const { return num_elements == 0; }

You could make your class more useful by using templates.  This will allow you to populate the stack with any type instead of just ints.