C ++按升序对指针数组进行排序

Question

我有这个函数，其中两个向量相互比较，程序找到向量的平方差之和。

    double Search::NNS(vector<vector<double>> bb, vector<vector<double>> aa)
    {
        int M = 768; int N = 1024;
        int R = 49; int C = 36;
        //double SSD[] = MainVectorBlock[] - WallyVector[];
        //double SSD[] = SSD[] * SSD[];
        //sum = sum + SSD[];

    vector<vector<double>> &MainIMG = bb;
    vector<vector<double>> &WallyIMG = aa;
    double *SSD = new double[R*C];
    double sum = 0;


    for (int bx = 0; bx < M; bx += R)
        for (int by = 0; by < N; by += C)
        {
            Compare = new double*[R];
            for (int x = 0; ((x < R) && ((bx + x) < M)); ++x)
            {
                Compare[x] = new double[R];
                for (int y = 0; ((y < C) && ((by + y) < N)); ++y)
                {
                    if ((bx + x) >= M)
                    {
                        cout << Compare[bx + x] << Compare[by + y] << " ";

                    }

                    //cout << MainIMG[bx + x][by + y] << " ";
                    Compare[x][y] = MainIMG[bx + x][by + y] - WallyIMG[x][y];
                    Compare[x][y] = Compare[x][y] * Compare[x][y];
                    //sum += Compare[x][y];
                    SSD[R*C] += Compare[x][y];
                    //SSD[R*C] = sum;
                    //cout << Compare[x][y] << " ";
                }

            }
            //cout << "\n\n\n" << endl;
            //cout << sum << endl;
            //cout << SSD[R*C] << "\t" << sum << endl;

            for (int i = 0; i < R*C; i++)
            {
                for (int j = 0; j < R*C; j++)
                {
                    if (SSD[i] > SSD[j])
                    {
                        int temp = SSD[i];
                        SSD[i] = SSD[j];
                        SSD[j] = temp;
                    }
                }
            }

        }
    for (int a = 0; a < R*C; a++)
    {
        cout << SSD[a] << endl;
    }

    return 0;
}

我可以显示所有平方差值的总和，但是当我尝试按升序对值进行排序时，我不断得到这个值 -6.27744e+66。 我尝试更改循环并将其放置在主 for 循环中，但我仍然继续获得该值。

Answer 1

double *SSD = new double[R*C];

您已分配内存但从未将其初始化为某个值。那你就直接用了：

SSD[R*C] += Compare[x][y];

在开始添加值之前将SSD的所有项目初始化为0。

Answer 2

您的代码存在多个问题。

1. 您将二维向量按值传递给 NNS 函数，而它们应该通过 const 引用传递。
2. 您正在嵌套的for 循环中造成内存泄漏。
3. 在总和计算中，您在数组 SSD 的末尾写了一个。
4. 您的 SSD 阵列未初始化为 0。

这是您的函数的一个版本，它没有内存泄漏，并允许您解决上面的第 3) 项。当然这可以改进，但它没有上面提到的问题。

#include <vector>
#include <iostream>
#include <algorithm>

double Search::NNS(const std::vector<std::vector<double>>& bb, 
                   const std::vector<std::vector<double>>& aa)
{
    int M = 768; int N = 1024;
    int R = 49; int C = 36;
    const std::vector<std::vector<double>> &MainIMG = bb;
    const std::vector<std::vector<double>> &WallyIMG = aa;
    std::vector<double> SSD(R * C);
    double sum = 0;

    for (int bx = 0; bx < M; bx += R)
    {
        for (int by = 0; by < N; by += C)
        {
            std::vector<std::vector<double>> Compare(R, std::vector<double>(R));
            for (int x = 0; ((x < R) && ((bx + x) < M)); ++x)
            {
                for (int y = 0; ((y < C) && ((by + y) < N)); ++y)
                {
                    Compare[x][y] = MainIMG[bx + x][by + y] - WallyIMG[x][y];
                    Compare[x][y] = Compare[x][y] * Compare[x][y];
                    SSD.at(R*C) += Compare[x][y];
                }
            }
        }
    }
    std::sort(SSD.begin(), SSD.end());
    for (int a = 0; a < R*C; a++)
        std::cout << SSD[a] << std::endl;
    return 0;
}

问题 1) 通过 const 引用传递 vectors 得到解决。在原始代码中按值传递向量会导致不必要的副本。

问题 2) 已通过使用 std::vector 而不是 new[] 得到解决。现在没有内存泄漏。

问题 3)没有直接解决。所做的是使用std::vector::at() 来证明发生了越界情况。如果在使用at() 时超出范围，将引发std::out_of_range 异常，表明您的数组访问中有错误。一旦执行该行，您的代码就会停止。这是我留给你解决边界条件的地方。

您可能还想在Compare 向量上使用at()，以确保您不会越界。我很懒，不想在脑海中进行计算，但是每当您有for 循环条件不使用vector::size() 作为限制条件时，而是使用计算来确定循环多远，它看起来很可疑，可能会发生越界情况。

此外，当您使用new[] 时，无法保证您会收到此错误，并且根据您的陈述，您没有得到任何迹象表明您做错了什么。使用std::vector 让您有机会使用at() 检查边界条件。

问题 4) 使用 std::vector<double> 解决，因为默认情况下，向量会将内容初始化为 0。

最后，注意使用std::sort 对范围进行排序，而不是慢速冒泡排序。