C++连续存储器操作

Question

我有C++程序，其中我使用普通阵列是如下计算的矩阵的行列式：

/* 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函数，以便它们不会创建新数组，而只使用相同的数组。 行列式将采用如下参数：determinant（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; 
}