C++ Trier un tableau de pointeurs dans l'ordre suivant

Question

J'ai cette fonction où deux vecteurs sont comparés entre eux et le programme trouve la somme de la différence au carré du vecteur.

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; 
} 

Je peux afficher toutes la somme des valeurs de différence au carré, mais lorsque je tente de trier les valeurs dans l'ordre croissant, je continue à obtenir cette valeur -6.27744e + 66. J'ai essayé de changer la boucle et de la placer dans la boucle principale, mais je continue d'obtenir cette valeur.

Answer 1

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

Vous avez alloué de la mémoire mais vous ne l'avez jamais initialisé à une certaine valeur. Ensuite, vous avez utilisé directement:

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

initialize tous les éléments de SSD-0 avant de commencer à ajouter des valeurs à elle.

Answer 2

Il existe plusieurs problèmes avec votre code.

1. Vous êtes de passage des vecteurs 2D en valeur à la fonction NNS, quand ils doivent être transmis par const référence.
2. Vous créez des fuites de mémoire dans la boucle for imbriquée.
3. Vous écrivez au-delà de la fin du tableau SSD dans le calcul de la somme.
4. Votre gamme SSD n'a pas été initialisées à 0.

Voici une version de votre fonction qui ne dispose pas de fuites de mémoire, et permettra vous pour aborder le point 3) ci-dessus. Certes, cela peut être amélioré, mais il n'a pas les problèmes mentionnés ci-dessus.

#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; 
} 

numéro 1) est traitée en faisant passer les vector s par référence const. Passer le vecteur en valeur comme le faisait votre code original entraîne une copie inutile.

Problème 2) est adressée en utilisant std::vector au lieu de new[]. Il n'y a plus de fuites de mémoire.

Problème 3) est pas directement. Ce qui a été fait était d'utiliser std::vector::at() pour démontrer qu'il y a une condition hors limite qui se produit. Une exception std::out_of_range sera levée si vous quittez les limites lorsque at() est utilisé, indiquant une erreur dans les accès au tableau. Votre code aurait cessé dès que cette ligne a été exécutée. Voici où je vous laisse pour résoudre la condition aux limites.

Vous pouvez également utiliser at() sur le vecteur Compare pour vous assurer de ne pas être hors-limites. Je suis paresseux et ne voulais pas faire le calcul dans ma tête, mais chaque fois que vous avez des conditions de boucle for qui n'utilisent pas le vector::size() comme condition limitative et à la place, un calcul est utilisé pour déterminer jusqu'où boucle, il semble suspect et est un candidat pour une situation hors-limites à se produire.

En outre, lorsque vous avez utilisé new[], il n'y a aucune garantie que vous obtiendrez cette erreur, et d'après ce que vous avez déclaré, vous n'avez pas reçu d'indication que vous faisiez quelque chose de mal. L'utilisation de std::vector vous permet de vérifier les conditions aux limites en utilisant at().

numéro 4) est traitée en utilisant std::vector<double>, comme par défaut, le vecteur initialise le contenu à 0.

Dernière, notez l'utilisation de std::sort pour trier la gamme, et pas le genre de bulle lente.