C++ 포인터 배열을 오름차순으로 정렬

Question

이 함수는 2 개의 벡터가 서로 비교되고 프로그램이 벡터와의 차의 제곱의 합을 찾는다. 내가 값을 오름차순으로 정렬하려고 할 때 제곱 차이 값의 합을 모두 표시 할 수 있습니다

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-loop 전체에 배치하려고 시도했지만 그 값을 계속 유지합니다.

Answer 1

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

메모리를 할당했지만 어떤 값으로 초기화하지 않았습니다. 그럼 당신은 직접 사용하고 있습니다 :

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

가 시작이 값을 추가하기 전에 0에 SSD의 모든 항목을 초기화합니다.

Answer 2

코드에 여러 가지 문제가 있습니다. 그들은 const 참조에 의해 전달되어야하는 경우

1. 당신은 NNS 함수 값으로 2D 벡터를 전달하고 있습니다.
2. 중첩 된 for 루프 내에서 메모리 누수가 발생합니다.
3. 합계 계산에서 배열 SSD의 끝에 1을 쓰고 있습니다.
4. 는 귀하의 SSD 어레이는 여기에 메모리 누수가없는 함수의 버전이며, 당신 위) 항목 3을 해결하기 위해 수 0

으로 초기화되지 않았습니다. 이 기능을 향상시킬 수는 있지만 위에서 언급 한 문제는 없습니다.

#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)은 vector을 const 참조로 전달하여 해결됩니다. 원본 코드에서 수행 한대로 벡터 값을 전달하면 불필요한 복사가 발생합니다.

문제 2)는 대신 std::vector을 사용하여 해결됩니다. 이제는 메모리 누수가 없습니다.

3 호)는 이 아니며이 직접 처리됩니다. 수행 된 작업은 범위를 벗어나는 조건이 있음을 입증하기 위해 std::vector::at()을 사용하는 것이 었습니다. at()을 사용할 때 경계를 벗어나면 배열 액세스에 오류가 있다는 것을 나타내는 std::out_of_range 예외가 발생합니다. 해당 코드가 실행되는 즉시 코드가 중지되었습니다. 여기서 경계 조건을 풀기 위해 당신에게 맡깁니다.

Compare 벡터에서 at()을 사용하여 범위를 벗어나지 않도록 할 수도 있습니다. 나는 게으르며 내 머리 속에 계산을하고 싶지는 않지만 for 루프 조건에서 제한 조건으로 vector::size()을 사용하지 않고 대신 루프가 얼마나 멀리 떨어져 있는지를 판단하는 데는 의심스러워 보입니다. 한계를 벗어나는 상황이 발생할 수있는 후보입니다.

또한 new[]을 사용할 때이 오류가 발생할 것이라는 보장은 없으며 명시된 것부터 잘못된 것을하고 있다는 징후를 얻지 못했습니다. std::vector을 사용하면 at()을 사용하여 경계 조건을 확인할 수 있습니다.

문제 4) 기본적으로, 벡터의 범위를 정렬 std::sort의 사용을주의, 마지막 0

에 내용을 초기화하지 느린 버블 정렬됩니다, std::vector<double>를 사용하여 해결됩니다.