qsort排序的时候，排序函数发生访问冲突

在使用qsort函数进行结构体的排序时候，自己写的排序函数中显示发生访问冲突


typedef struct
{
    int index;
    int value;

}sort_st;

int compare(const void* a, const void* b)
{
    // 降序排列
    return ((sort_st*)b)->value - ((sort_st*)a)->value;
     
}

void DPC::find_center()
{
    vector<float> R;
    for (int i = 0; i < data_.size(); i++)
    {
        R.push_back(Data_delta_[i] * data_density_[i]);
    }

    vector sort_R(R.size());
    for (int j = 0; j < R.size(); j++)
    {
        sort_R[j].index = j;
        sort_R[j].value = R[j];
    }

    // qsort函数是对数组进行排序，参数分别为数组起始地址，数组元素的个数，每个元素的大小，排序方式
    // sort_R.value 表示排序后的值   sort_R.index表示的是排序之前的索引
    qsort(&sort_R, R.size(), sizeof(sort_st), compare);

    vector<float> gamma;
    for (int k = 0; k < R.size() - 1; k++)
    {
        // 计算排序之后两项之间的差值
        gamma.push_back(abs(sort_R[k + 1].value - sort_R[k].value));
    }

    // 对差值进行降序排列
    vector sort_gamma;
    for (int i = 0; i < gamma.size(); i++)
    {
        sort_gamma[i].index = i;
        sort_gamma[i].value = gamma[i];
    }

    qsort(&sort_gamma, gamma.size(), sizeof(sort_st), compare);

    // 计算距离的平均值
    float he = 0.0;
    for (int i = 1; i < sort_gamma.size(); i++)
    {
        he = he + sort_gamma[i].value;
    }
    float gmeans = he / (gamma.size() - 1);

    // 寻找疑似中心点
    vector temp_center;
    vector<int> temp_center_index;

    for (int m = 0; m < gamma.size(); m++)
    {
        if (gamma[m] > gmeans)
        {
            // m是满足条件的点在gamma中的索引
            // 疑似中心点
            temp_center.push_back(data_[sort_R[m].index]);
            // 疑似中心点的索引值，未排序的时候
            temp_center_index.push_back(sort_R[m].index);
        }
    }

    // 进一步筛选中心点
    Mat temp_center_dist = Mat::zeros(temp_center_index.size(), temp_center.size(), CV_16FC1);
    int temp_center_len = temp_center.size();

    for (int i = 0; i < temp_center.size(); i++)
    {
        for (int j = 0; j < temp_center.size(); j++)
        {
            temp_center_dist.at<float>(i, j) = sqrt((temp_center[i].x - temp_center[j].x) * (temp_center[i].x - temp_center[j].x)
                + (temp_center[i].y - temp_center[j].y) * (temp_center[i].y - temp_center[j].y));
        }
    }

    // 判断中心点之间的距离是否小于2倍的截断距离
    for (int icenter_len = 0; icenter_len < temp_center_len; icenter_len++)
    {
        vector<int> temp_index;
        for (int j = 0; j < temp_center_len; j++)
        {
            // 遍历距离矩阵的某一行进行比较
            if (temp_center_dist.at<float>(icenter_len, j) < 2 * cut_dist_)
            {
                temp_index.push_back(j);
            }
        }

        int max_density = 0;
        int max_density_index = 0;

        for (int i = 0; i < temp_index.size(); i++)
        {
            if (max_density < data_density_[temp_center_index[temp_index[i]]])
            {
                max_density = data_density_[temp_center_index[temp_index[i]]];
                // 返回的是数组中的索引
                max_density_index = i;
            }
        }

        // find函数如果没有在数组中找到目标，返回的是vector.end()
        if (std::find(center_index_.begin(), center_index_.end(), temp_center_index[temp_index[max_density_index]]) == center_index_.end())
        {
            center_.push_back(temp_center[temp_index[max_density_index]]);
            center_index_.push_back(temp_center_index[temp_index[max_density_index]]);
        }
    }
}

img


int compare(const void*a,const void*b){return *(int*)a-*(int*)b;}  //比较函数的写法

参考下这篇文章：
https://blog.csdn.net/wordwarwordwar/article/details/40976681


int compare(const void* a, const void* b)
{
    const sort_st* pa = static_cast<const sort_st*>(a);
    const sort_st* pb = static_cast<const sort_st*>(b);
    return pb->value - pa->value;
}