C++ смежной работа с памятью

Question

У меня есть С Программой ++, в котором я расчетливый определитель матрицы, используя нормальный массив, который выглядит следующим образом:

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

Я хочу, чтобы заменить его кодом, в котором я выделить память для массива до начала алгоритма, а затем изменить определитель и функции ijMonor, чтобы они не создавали новый массив, а использовали только один и тот же массив. Определитель примет параметр: детерминант (int * matrix, int * startOfMyWorkspace, int size), чтобы он знал, с чего начать.

Я плохо разбираюсь в C++, и до сих пор я не мог этого сделать. Может кто-то, пожалуйста, укажите пример кода. Я выделил некоторую память для массива и создал и массив, но не смог изменить функции ijMinor и определителя для этого.

Это, как я распределение памяти:

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

Попробуйте это. Обратите внимание, что если вы используете new для выделения массива, вам нужно использовать delete[], чтобы освободить все. Вы уйдете с delete (т. Е. Он не будет сбой), но это освободит только первый элемент. Ваши другие функции такие же, как и вы.

Вы динамически выделяете пространство для minorMatrix в функции determinant, но трудно понять, как это можно было бы предусмотреть. Я изменил функцию determinant для использования allocate_arr и deallocate_arr.

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