Delete[] array breaks my C++ program

I have had this issue for a while now. Every time my grow function calls the delete line, the program breaks. It doesn't give me an error besides it has reached a break point. I have not found a solution to this online during my Google searches. Can anyone help? UPDATE After hitting continue on the error screen a few times if finally came up with a different error. It states that CrtIsValidHeapPointer(pUserData)

Driver.cpp

#include <iostream>
#include "MyVector.h"     
using namespace std;

// the printV function
// used to test the copy constructor
// parameter: a MyVector object
void printV(MyVector);

int main()
{
    cout << "\nCreating a vector Sam of size 4.";
    MyVector sam(4);

    cout << "\nPush 12 values into the vector.";
    for (int i = 0; i < 12; i++)
        sam.push_back(i);

    cout << "\nHere is sam: ";
    cout << sam;
    cout << "\n---------------\n";

    cout << "\nCreating a vector Joe of size 4.";
    MyVector joe(4);
    cout << "\nPush 6 values into the vector.";
    for (int i = 0; i < 6; i++)
        joe.push_back(i * 3);

    cout << "\nHere is joe: ";
    cout << joe;
    cout << "\n---------------\n";

    cout << "\nTest the overloaded assignment operator \"joe = sam\": ";
    joe = sam;

    cout << "\nHere is sam: ";
    cout << sam;
    cout << "\n---------------\n";

    cout << "\nHere is joe: ";
    cout << joe;
    cout << "\n---------------\n";

    // pass a copy of sam by value
    printV(sam);


    cout << endl;
    system("PAUSE");
    return 0;
}

void printV(MyVector v)
{
    cout << "\n--------------------\n";
    cout << "Printing a copy of a vector\n";
    cout << v;
}

My Vector.h

#include <iostream>
#include <ostream>
using namespace std;
#pragma once


class MyVector
{
private:
    int vSize;
    int vCapacity;
    int* vArray;
    void grow();

public:
    MyVector();
    MyVector(int n);
    MyVector(const MyVector& b);
    int size() const;
    int capacity() const;
    void clear();
    void push_back(int n);
    int& at(int n) const;
    MyVector& operator=(const MyVector& rho);
    ~MyVector();
};

ostream& operator<<(ostream& out, const MyVector& rho);

MyVector.cpp

#include "MyVector.h"
#include <iostream>
#include <ostream>
using namespace std;


MyVector::MyVector()
{
    vArray = nullptr;
    vSize = 0;
    vCapacity = 0;
}

MyVector::MyVector(int n)
{
    vArray = new int[vCapacity];
    vSize = 0;
    vCapacity = n;
}

MyVector::MyVector(const MyVector& b)
{
    vSize = b.size();
    vArray = new int[vSize];
    for (int i = 0; i < b.size(); i++)
    {
        this->vArray[i] = b.vArray[i];
    }
}

int MyVector::size() const
{
    return vSize;
}

int MyVector::capacity() const
{
    return vCapacity;
}

void MyVector::clear(void)
{
    if (vArray != nullptr)
    {
        delete[] vArray;
        vArray = nullptr;
        vSize = 0;
        vCapacity = 0;
    }
}

void MyVector::push_back(int n)
{
    if (vCapacity == 0)
    {
        vCapacity++;
        int* tmp = new int[vCapacity];
        delete[] vArray;
        vArray = tmp;
    }

    if (vSize >= vCapacity)
    {
        grow();
    }
    vArray[vSize] = n;
    vSize++;
}

void MyVector::grow()
{
    vCapacity = vCapacity + vCapacity;
    int* tmp = new int[vCapacity];
    for (int i = 0; i < vSize+1; i++)
    {
        tmp[i] = vArray[i];
    }
    delete[] vArray;
    vArray = tmp;
}

int& MyVector::at(int index) const
{
    if (index >= 0 && index<vSize)
    {
        return vArray[index];
    }
    else
    {
        throw index;
    }
}

MyVector& MyVector::operator=(const MyVector& rho)
{
    // test for self assignment
    if (this == &rho)
        return *this;

    // clean up array in left hand object (this)
    delete[] this->vArray;

    // create a new array big enough to hold right hand object's data
    vSize = rho.size();
    this->vArray = new int[vSize];

    // copy the data
    for (int i = 0; i < rho.size(); i++)
    {
        this->vArray[i] = rho.vArray[i];
    }

    // return this object
    return *this;
}

MyVector::~MyVector()
{
    if (vArray != nullptr)
    {
        clear();
    }
}

ostream& operator<< (ostream& out, const MyVector& rho)
{
    for (int i = 0; i < rho.size(); i++)
    {
        out << rho.at(i);
    }
    return out;
}