Brainfuck interpreter w/ error checking

#include <vector>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <cstdlib>

using namespace std;

class Memory
{
public:
    Memory()
    {
        memory.reserve(MAX_MEMORY);
        zeroMemory();
        pointer = memory.begin();
    }

    void forward()
    {
        ++pointer;

        if (pointer == memory.end())
        {
            // Exception: memory limit exceeded
            throw runtime_error("Memory limit exceeded");
        }
    }

    void backward()
    {
        --pointer;
    }

    void add()
    {
        ++(*pointer);
    }

    void sub()
    {
        --(*pointer);
    }

    void putchar()
    {
        cout << *pointer;
    }

    void getchar()
    {
        cin >> *pointer;
    }

    unsigned char getValue()
    {
        return *pointer;
    }
private:
    const unsigned int MAX_MEMORY = 30000;
    vector<unsigned char> memory;
    vector<unsigned char>::iterator pointer;

    void zeroMemory()
    {
        for (size_t i = 0; i < MAX_MEMORY; i++)
        {
            memory.push_back(0);
        }
    }
};

class Brainfuck
{
public:
    static const unsigned char addition    = '+';
    static const unsigned char subtraction = '-';
    static const unsigned char forward     = '>';
    static const unsigned char backward    = '<';
    static const unsigned char putchar     = '.';
    static const unsigned char getchar     = ',';
    static const unsigned char loopStart   = '[';
    static const unsigned char loopEnd     = ']';

    Brainfuck(string input) : code(input)
    {
        buffer = code.begin();
    }

    void run()
    {
        for (; buffer != code.end(); ++buffer)
        {
            switch (*buffer)
            {
            case Brainfuck::addition:
                mem.add();
                break;
            case Brainfuck::subtraction:
                mem.sub();
                break;
            case Brainfuck::forward:
                mem.forward();
                break;
            case Brainfuck::backward:
                mem.backward();
                break;
            case Brainfuck::putchar:
                mem.putchar();
                break;
            case Brainfuck::getchar:
                mem.getchar();
                break;
            case Brainfuck::loopStart:
                startLoop();
                break;
            case Brainfuck::loopEnd:
                endLoop();
                break;
            default:
                break;
            }
        }
    }

private:
    Memory mem;
    string code;
    string::iterator buffer;
    vector<string::iterator> loopPosition;

    void startLoop()
    {
        if (mem.getValue())
        {
            loopPosition.push_back(buffer);
        }
        else
        {
            while (*buffer != Brainfuck::loopEnd)
                ++buffer;
        }
    }

    void endLoop()
    {
        if (loopPosition.empty())
        {
            // Exception: unbalanced brackets
            throw runtime_error("Unbalanced brackets");
        }

        if (mem.getValue())
        {
            buffer = loopPosition.back();
        }
        else
        {
            loopPosition.pop_back();
        }
    }
};

int main(int argc, char* argv[])
{
    string inData;
    if (argc == 2)
    {
        wstring codeFile = argv[1];
        ifstream file(codeFile, ios::in);
        char buff;

        file >> skipws;

        while (file >> buff)
            inData += buff;

        file.close();
    }
    else
    {
        cout << "Useage: " << argv[0] << " <source file>" << endl;
        std::cin.get(); // Press enter to exit
        exit(0);
    }

    try
    {
        Brainfuck bf(inData);
        bf.run();
    }
    catch (exception &e)
    {
        cerr << e.what() << endl;
    }


    std::cin.get(); // Press enter to exit

    return 0;
}