C++ QuickSort Algorithm keeps crashing

Your partition algorithm is about twice as much code as it needs to be. You seem to be always choosing the last element in the sequence for your pivot, and although not advisable, it will work for academic demonstration.

Your Crash

You're defining two pIndex values, only one of which is actually deterministic. You also declare two pivot variables, but that does NOT cause your crash (the first one is never used). It should be cleaned up none-the-less, but the death knell in your code is duplicate pIndex

int pivot;
int pIndex;     // HERE
if(start<end){
    int pivot=A[end];
    int pIndex=start; // HERE AGAIN
    for(int x=0;x<end;x++){
        if(A[x]<A[end]){
            swap(A[x],A[pIndex]);
            pIndex=pIndex+1;   
        }   
    }
    swap(A[pIndex],A[end]);
}
swap(A[pIndex],A[end]); // uses non-determined pIndex
return pIndex; // returns non-determined pIndex

Changing int pIndex=start; to simply be pIndex=start; will solve your crash, but your partition method still needs... help.

The "Sweep" Partition Method

The "sweep" method of partitioning is generally done like this for a pivot value that is assumed to be right-tailed, and you would be hard pressed to get this simpler (invoking std::partition not withstanding):

size_t Partition(int *A, size_t len)
{
    if (len < 2)
        return 0;

    size_t pvt = 0;
    for (size_t i=0; i<end; ++i)
    {
        if (A[i] < a[len-1])
            std::swap(A[i], A[pvt++])
    }
    std::swap(A[pvt], a[len-1]);
    return pvt;
};

The above algorithm includes only the necessities needed for a partition: the sequence iterator (a pointer in your case), and the sequence length. Everything else is deterministic based on those two items. A quick sample program of how this works follows, with a purposely placed 5 for the pivot value:

#include <iostream>

size_t Partition(int *A, size_t len)
{
    if (len < 2)
        return 0;

    size_t pvt = 0;
    for (size_t i=0; i<len-1; ++i)
    {
        if (A[i] < A[len-1])
            std::swap(A[i], A[pvt++]);
    }
    std::swap(A[pvt], A[len-1]);
    return pvt;
};

int main()
{
    int arr[] = { 4, 8, 7, 3, 9, 2, 1, 6, 5 };
    size_t n = Partition(arr, sizeof(arr)/sizeof(*arr));
    std::cout << "Partition : " << n << '\n';
    for (auto x : arr)
        std::cout << x << ' ';
    std::cout << '\n';
}

Output

Partition : 4
4 3 2 1 5 7 8 6 9 

How To Invoke From QuickSort

Invoking a partition in quicksort sets up the pivot location, which becomes the "end" iteration point of the bottom segment, and the one-BEFORE iteration point of the top segment. It is critical the pivot location returned from an invoke of Partition() should NOT be included in either subsequence when recursing.

void QuickSort(int *A, size_t len)
{
    if (len < 2)
        return;

    size_t pvt = Partition(A, len);
    QuickSort(A, pvt++);        // NOTE: post increment...
    QuickSort(A+pvt, len-pvt);  // ...which makes this skip the pivot
}

Yeah, pointer arithmetic rocks, don't you think?

Putting It All Together

The program below incorporates both the Partition and QuickSort :

#include <iostream>

size_t Partition(int *A, size_t len)
{
    if (len < 2)
        return 0;

    size_t pvt = 0;
    for (size_t i=0; i<len-1; ++i)
    {
        if (A[i] < A[len-1])
            std::swap(A[i], A[pvt++]);
    }
    std::swap(A[pvt], A[len-1]);
    return pvt;
};

void QuickSort(int *A, size_t len)
{
    if (len < 2)
        return;

    size_t pvt = Partition(A, len);
    QuickSort(A, pvt++);            // NOTE: post increment
    QuickSort(A+pvt, len-pvt);
}

int main()
{
    int arr[] = { 4, 8, 7, 3, 9, 2, 1, 6, 5 };
    QuickSort(arr, sizeof(arr)/sizeof(*arr));
    for (auto x : arr)
        std::cout << x << ' ';
    std::cout << '\n';
}

Output

1 2 3 4 5 6 7 8 9 

I hope it helps.