C++ zusammenhängende Speicheroperation

Question

Ich habe C++ Programm, in der I-Berechnungs bin Determinante einer Matrix normales Array, das wie folgt ist:

/* rand example: guess the number */ 
#include <stdio.h>  /* printf, scanf, puts, NULL */ 
#include <stdlib.h>  /* srand, rand */ 
#include <time.h>  /* time */ 
#include <iostream> 
#include <cstdlib> 
#include <vector> 
using namespace std; 

int** generateStandardMatrix(int dimension); 
void ijMinor(int *matrix[], int *minorMatrix[], int size, int row, int column); 
int determinant(int *matrix[], int size); 

void ijMinor(int *matrix[], int *minorMatrix[], int size, int row, int column) { 
    for (int i = 0; i < size; i++) { 
    for (int j = 0; j < size; j++) { 
     if (i < row) { 
     if (j < column)minorMatrix[i][j] = matrix[i][j]; 
     else if (j == column)continue; 
     else minorMatrix[i][j - 1] = matrix[i][j]; 
     } 
     else if (i == row)continue; 
     else { 
     if (j < column)minorMatrix[i - 1][j] = matrix[i][j]; 
     else if (j == column)continue; 
     else minorMatrix[i - 1][j - 1] = matrix[i][j]; 
     } 
    } 
    } 
} 

int determinant(int *matrix[], int size) { 
    if (size == 1)return matrix[0][0]; 
    else { 
    int result = 0, sign = -1; 
    for (int j = 0; j < size; j++) { 

     int **minorMatrix; 
     minorMatrix = new int*[size - 1]; 
     for (int k = 0 ; k < size - 1 ; k++) 
     minorMatrix[k] = new int[size - 1]; 

     ijMinor(matrix, minorMatrix, size, 0, j); 

     sign *= -1; 
     result += sign * matrix[0][j] * determinant(minorMatrix, size - 1); 
     for (int i = 0; i < size - 1; i++) { 
     delete minorMatrix[i]; 
     } 
    } 

    return result; 
    } 
} 



int main (int argc, char* argv[]) 
{ 

    /* initialize random seed: */ 
    srand (time(NULL)); 
    // int iSecret, iGuess; 
    int dimension = atoi(argv[1]); 

    int rowCount = dimension , colCount = dimension; 
    //2d array storing the integer values 
    int** ary = new int*[dimension]; 

    //vector of vector storing the indices across the array for the threads to pick up from 
    vector<vector<int> > vec; 


    ary = generateStandardMatrix(dimension); 


    printf("Array value : %d\n", ary[0][0]); 
    int detVal = determinant(ary, dimension); 
    printf("determinant value : %d\n", detVal); 


    return 0; 
} 

int** generateStandardMatrix(int dimension) { 
    int** ary = new int*[dimension]; 
    int counter = 0; 
    for (int i = 0; i < dimension; ++i) { 
    ary[i] = new int[dimension]; 
    counter = counter + 1; 
    for (int j = 0; j < dimension; ++j) 
    { 
     ary[i][j] = counter; 
     std::cout << ary[i][j] << "\t" << std::flush; 
    } 
    std::cout << std::endl; 
    } 

    return ary; 
} 

ich es mit Code ersetzt werden soll, in der I-Speicher für die Anordnung zugewiesen vor dem Start des Algorithmus und ändern Sie dann die Determinante und die ijMonor-Funktionen, so dass sie keine neuen Arrays erstellen, sondern nur das gleiche Array verwenden. Die Determinante nimmt Parameter wie: determinant (int * Matrix, int * startOfMyWorkspace, int Größe), so dass es weiß, wo zu starten ist.

Ich bin nicht gut in C++ und bisher konnte ich es nicht tun. Kann jemand bitte einen Beispielcode zur Verfügung stellen. Ich habe etwas Speicher für Array und erstellt und Array zugewiesen, konnte aber nicht die ijMinor und Determinante Funktionen dafür ändern.

Dies ist, wie ich Speicher am Zuteilen:

diese

int main (int argc, char* argv[]) 
{ 

    /* initialize random seed: */ 
    srand (time(NULL)); 
    // int iSecret, iGuess; 
    int dimension = atoi(argv[1]); 

    int *a; 
    size_t const N_BYTES = dimension * dimension * sizeof(int); 

    a = (int*)malloc(N_BYTES); 

    createData(dimension,a); 

    return 0; 
} 

void createData(int const dimension, int* const a) 
{ 
    int row, col; 

    srand((unsigned)time(NULL)); 
    int counter; 
    for(int row = 0; row < dimension; row++) { 
     counter = counter + 1; 
     for(int col = 0; col < dimension; col++) { 
      int i = col + row * dimension; 
      a[i] = counter; 
      std::cout << a[i] << "\t" << std::flush; 
     } 
     std::cout << std::endl; 
    } 
} 

Answer 1

Versuchen. Hinweis: Wenn Sie new verwenden, um ein Array zuzuordnen, müssen Sie delete[] verwenden, um alle zu befreien. Sie kommen mit delete (d. H. Es wird nicht abstürzen), aber dies wird nur das erste Element frei. Ihre anderen Funktionen sind die gleichen wie Sie gepostet haben.

Sie reservieren dynamisch Speicherplatz für minorMatrix in determinant-Funktion, aber es ist schwer zu sehen, wie das vorab zugewiesen werden könnte. Ich habe determinant Funktion geändert, um allocate_arr und deallocate_arr zu verwenden.

int ** allocate_arr(int dimension) 
{ 
    int** a = new int*[dimension]; 
    for (int i = 0; i < dimension; ++i) 
     a[i] = new int[dimension]; 
    return a; 
} 

void deallocate_arr(int dimension, int **a) 
{ 
    for (int i = 0; i < dimension; ++i) 
     delete[] a[i]; 
    delete[] a; 
} 

int determinant(int *matrix[], int size) { 
    if (size == 1)return matrix[0][0]; 
    else { 
     int result = 0, sign = -1; 
     for (int j = 0; j < size; j++) { 

      int **minorMatrix = allocate_arr(size - 1); 
      ijMinor(matrix, minorMatrix, size, 0, j); 

      sign *= -1; 
      result += sign * matrix[0][j] * determinant(minorMatrix, size - 1); 
      deallocate_arr(size - 1, minorMatrix); 
     } 
     return result; 
    } 
} 

void generateStandardMatrix(int dimension, int**ary) { 
    int counter = 0; 
    for (int i = 0; i < dimension; ++i) { 
     counter = counter + 1; 
     for (int j = 0; j < dimension; ++j) 
     { 
      ary[i][j] = counter; 
      std::cout << ary[i][j] << "\t" << std::flush; 
     } 
     std::cout << std::endl; 
    } 
} 

int main(int argc, char* argv[]) 
{ 
    srand(time(NULL)); 

    int dimension = atoi(argv[1]); 
    int** a = allocate_arr(dimension); 

    generateStandardMatrix(dimension, a); 
    printf("Array value : %d\n", a[0][0]); 
    int detVal = determinant(a, dimension); 
    printf("determinant value : %d\n", detVal); 

    // ... do more computations here, reusing `a` ... 

    deallocate_arr(dimension, a); 
    return 0; 
}