C++ 包含指针的结构上的Qsort

我想写一个程序，通过qsort函数按字典顺序对矩阵的行进行排序。由于compare函数需要知道每一行的大小，并且无法传递第三个参数，因此我将每一行设置为包含行大小的行结构。然后将问题简化为按字典顺序对结构进行排序

我编写默认构造函数、复制构造函数和析构函数。我重载赋值运算符

当我在VS2010上运行程序时，它偶尔会报告下面的错误。当我在Linux和g++中运行它时，它可能会将某些元素修改为意外状态或在内核中运行

谁能告诉我应该在哪里修改代码？谢谢

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

using namespace std;

struct ROW
{
    int *ptr;
    int L;
    ROW();
    ROW(ROW &obj);
    ~ROW();
    ROW& operator = (const ROW& obj);
};

ROW::ROW()
{
    ptr = 0;
    L = 0;
}

ROW::ROW(ROW &obj)
{
    L = obj.L;
    ptr = new int [L];
    memcpy(ptr,obj.ptr,L*sizeof(int));
}

ROW::~ROW()
{
    if (ptr)
        delete [] ptr;
    ptr = NULL;
}

ROW& ROW::operator = (const ROW& obj)
{
    if (this != &obj)
    {
        //this->ptr = obj.ptr;
        if (ptr)
            delete [] ptr;
        ptr = new int [L];
        memcpy(ptr,obj.ptr,L*sizeof(int));
    }
    return *this;
}

int MyCMP(const void *a, const void *b)
{
    ROW *L = (ROW*)a;
    ROW *R = (ROW*)b;
    for (int i=0; i < (L->L); i++)
        if ((L->ptr[i]) < (R->ptr[i]))
            return -1;
        else if ((L->ptr[i]) > (R->ptr[i]))
            return 1;
    return 0;
}

int main()
{
    srand(time(0));
    int R_size = 23;
    int R = 7;
    ROW* A = new ROW[R];
    //scanf("%d %d",&R, &R_size);
    R = rand()%20+1;
    R_size = rand()%30+1;
    printf("Row: %d, Column: %d.\n",R,R_size);

    for (int i=0; i<R; i++)
    {
        A[i].ptr = new int [R_size];
        A[i].L = R_size;
        for (int j=0; j<R_size; j++)
        {
            A[i].ptr[j] = rand()%100;
            printf("%d ",A[i].ptr[j]);
        }
        printf("\n");
    }
    printf("After sorting\n");
    qsort(A,R,sizeof(ROW),MyCMP);

    for (int i=0; i<R; i++)
    {
        for (int j=0; j<R_size; j++)
            printf("%d ",A[i].ptr[j]);
        printf("\n");
    }

    /*
    for (int i=0; i<R; i++)
    {
        if (A[i].ptr)
        {
            delete [] (A[i].ptr);
            A[i].ptr = NULL;
        }
    }
    delete [] A; 
    */
    return 0;
}

---

分配后，您将完全更改数组的行维度

int R_size = 23;
int R = 7;            // SET HERE
ROW* A = new ROW[R];  // USED AS ALLOC SIZE HERE

R = rand()%20+1;      // CHANGED HERE
R_size = rand()%30+1;

---

除非

R

最终小于或等于7（赔率为7/20），否则您将调用未定义的行为。如果结果是，那么在分配之后，您就完全改变了数组的行维度

int R_size = 23;
int R = 7;            // SET HERE
ROW* A = new ROW[R];  // USED AS ALLOC SIZE HERE

R = rand()%20+1;      // CHANGED HERE
R_size = rand()%30+1;

---

除非

R

最终小于或等于7（赔率为7/20），否则您将调用未定义的行为。如果结果是，那么在分配之后，您就完全改变了数组的行维度

int R_size = 23;
int R = 7;            // SET HERE
ROW* A = new ROW[R];  // USED AS ALLOC SIZE HERE

R = rand()%20+1;      // CHANGED HERE
R_size = rand()%30+1;

---

除非

R

最终小于或等于7（赔率为7/20），否则您将调用未定义的行为。如果结果是，那么在分配之后，您就完全改变了数组的行维度

int R_size = 23;
int R = 7;            // SET HERE
ROW* A = new ROW[R];  // USED AS ALLOC SIZE HERE

R = rand()%20+1;      // CHANGED HERE
R_size = rand()%30+1;

---

---

除非

R

最终小于或等于7（赔率为7/20），否则您将调用未定义的行为。如果它最终是我不知道太多的C++，但我认为在使用赋值给<代码> PTR <代码>时，你应该使用<代码> null pTrt//Cube而不是<代码> null <代码> > <代码> 0代码>。如果你使用C++，你真的应该使用更多的STL。也就是说，您不应该使用

newint[]

使用

vector

；您不应该使用

qsort

您应该使用

std:：sort

。我还没有查看过所有的代码，但是看起来你正在访问边界内存，并且使用C++结构会有帮助。在<代码>运算符=< /Cord>之前，你需要做代码< L=Obj.L./C> >，然后使用它分配新的内存<代码>行（行和OBJ）；<代码>应为

行（行常量和对象）比较表返回<代码> 0代码>代码>如果列表长度不同，一个是另一个子集，我不知道太多C++，但是我认为在分配给 PTR 时，你应该使用<代码> NulLPTR < /C>代替原来的代码> NUL>代码> 0 > <代码>。如果你使用C++，你真的应该使用更多的STL。也就是说，您不应该使用
newint[]
使用
vector
；您不应该使用
qsort
您应该使用
std:：sort
。我还没有查看过所有的代码，但是看起来你正在访问边界内存，并且使用C++结构会有帮助。在<代码>运算符=< /Cord>之前，你需要做代码< L=Obj.L./C> >，然后使用它分配新的内存<代码>行（行和OBJ）；<代码>应为
行（行常量和对象）比较表返回<代码> 0代码>代码>如果列表长度不同，一个是另一个子集，我不知道太多C++，但是我认为在分配给 PTR 时，你应该使用<代码> NulLPTR < /C>代替原来的代码> NUL>代码> 0 > <代码>。如果你使用C++，你真的应该使用更多的STL。也就是说，您不应该使用
newint[]
使用
vector
；您不应该使用
qsort
您应该使用
std:：sort
。我还没有查看过所有的代码，但是看起来你正在访问边界内存，并且使用C++结构会有帮助。在<代码>运算符=< /Cord>之前，你需要做代码< L=Obj.L./C> >，然后使用它分配新的内存<代码>行（行和OBJ）；<代码>应为
行（行常量和对象）比较表返回<代码> 0代码>代码>如果列表长度不同，一个是另一个子集，我不知道太多C++，但是我认为在分配给 PTR 时，你应该使用<代码> NulLPTR < /C>代替原来的代码> NUL>代码> 0 > <代码>。如果你使用C++，你真的应该使用更多的STL。也就是说，您不应该使用
newint[]
使用
vector
；您不应该使用
qsort
您应该使用
std:：sort
。我还没有查看过所有的代码，但是看起来你正在访问边界内存，并且使用C++结构会有帮助。在<代码>运算符=< /Cord>之前，你需要做代码< L=Obj.L./C> >，然后使用它分配新的内存<代码>行（行和OBJ）；<代码>应为
行（行常量和对象）
如果列表长度不同，并且其中一个是其他列表的子集，则比较器返回
0
。谢谢！这真是一个天真的错误。我不该那样做的，谢谢！这真是一个天真的错误。我不该那样做的，谢谢！这真是一个天真的错误。我不该那样做的，谢谢！这真是一个天真的错误。我不应该那样做。
Row: 10, Column: 15
13 33 61 44 2 69 89 95 84 29 24 87 16 96 74 
44 60 72 37 78 17 94 6 88 5 61 41 37 33 13 
56 53 26 4 67 32 50 41 21 79 41 21 17 97 85 
88 84 7 93 41 13 46 10 50 70 38 71 3 55 77 
82 53 53 71 77 33 48 36 25 82 73 58 67 63 56 
27 83 5 42 81 4 86 6 51 4 29 16 6 38 78 
94 5 87 13 4 76 66 47 97 72 55 63 96 78 43 
96 2 36 55 64 25 34 27 70 44 21 2 46 54 46 
83 85 23 48 42 14 19 89 37 73 3 15 38 41 41 
98 64 49 9 61 46 49 24 94 76 51 46 98 3 26 
After sorting
2 2 21 25 27 34 36 44 46 46 54 55 64 70 96 
2 13 16 24 29 33 44 61 69 74 84 87 89 95 96 
3 7 10 13 38 41 46 50 55 70 71 77 84 88 93 
3 9 24 26 46 46 49 49 51 61 64 76 94 98 98 
3 14 15 19 23 37 38 41 41 42 48 73 83 85 89 
4 4 5 6 6 16 27 29 38 42 51 78 81 83 86 
4 5 13 43 47 55 63 66 72 76 78 87 94 96 97 
4 17 21 21 26 32 41 41 50 53 56 67 79 85 97 
5 6 13 17 33 37 37 41 44 60 61 72 78 88 94 
25 33 36 48 53 53 56 58 63 67 71 73 77 82 82 

Row: 19, Column: 17
28 40 51 8 76 81 57 43 66 4 52 81 88 88 92 16 16 
39 38 78 10 50 24 53 72 4 43 87 92 75 51 20 62 45 
76 93 5 84 35 92 54 33 1 41 96 8 70 80 21 25 10 
1 58 19 24 42 39 17 93 53 35 64 73 27 13 96 34 55 
13 99 94 54 52 14 73 50 32 2 16 64 40 14 71 70 62 
39 7 43 60 72 66 21 70 74 95 25 29 35 95 56 42 80 
74 41 88 51 55 73 45 41 8 17 8 2 64 91 66 25 37 
23 34 45 71 70 25 63 39 85 38 51 32 75 54 99 44 28 
76 84 81 52 1 22 20 89 13 11 48 82 8 21 67 9 15 
2 16 34 51 54 35 14 86 78 84 93 47 35 77 36 4 20 
23 13 36 24 14 83 38 7 84 9 97 87 62 82 27 43 3 
78 28 8 52 50 24 8 76 36 7 45 75 34 67 30 62 49 
27 52 90 65 19 88 81 78 44 53 51 59 22 51 75 52 40 
89 63 56 65 77 52 91 32 68 2 99 73 94 90 23 34 2 
67 18 43 46 30 16 44 10 86 27 76 7 71 22 15 60 20 
59 59 42 79 24 27 11 98 36 82 29 82 58 85 10 77 15 
44 83 58 21 1 33 30 77 17 94 16 81 36 40 73 46 28 
99 78 78 59 41 75 49 84 41 15 57 55 9 72 64 83 54 
48 15 4 92 37 13 76 1 46 68 52 66 39 29 76 21 70 
After sorting
1 4 13 15 21 29 37 39 46 48 52 66 68 70 76 76 92 
1 5 8 10 21 25 33 35 41 54 70 76 80 84 92 93 96 
1 8 9 11 13 15 20 21 22 48 52 67 76 81 82 84 89 
1 13 17 19 24 27 34 35 39 42 53 55 58 64 73 93 96 
1 16 17 21 28 30 33 36 40 44 46 58 73 77 81 83 94 
2 2 23 32 34 52 56 63 65 68 73 77 89 90 91 94 99 
2 4 14 16 20 34 35 35 36 47 51 54 77 78 84 86 93 
2 8 8 17 25 37 41 41 45 51 55 64 66 73 74 88 91 
2 13 14 14 16 32 40 50 52 54 62 64 70 71 73 94 99 
3 7 9 13 14 23 24 27 36 38 43 62 82 83 84 87 97 
4 8 16 16 28 40 43 51 52 57 66 76 81 81 88 88 92 
4 10 20 24 38 39 43 45 50 51 53 62 72 75 78 87 92 
7 8 8 24 28 30 34 36 45 49 50 52 62 67 75 76 78 
7 10 15 16 18 20 22 27 30 43 44 46 60 67 71 76 86 
7 21 25 29 35 39 42 43 56 60 66 70 72 74 80 95 95 
9 15 41 41 49 54 55 57 59 64 72 75 78 78 83 84 99 
10 11 15 24 27 29 36 42 58 59 59 77 79 82 82 85 98 
19 22 27 40 44 51 51 52 52 53 59 65 75 78 81 88 90 
23 25 28 32 34 38 39 44 45 51 54 63 70 71 75 85 99