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 : %dn", ary[0][0]);
  int detVal = determinant(ary, dimension);
  printf("determinant value : %dn", 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（即它不会崩溃），但这只会释放第一个元素。您的其他功能与您发布的相同。

您正在determinant函数中为minorMatrix动态分配空间，但很难看出如何预分配空间。我已经修改了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 : %dn", a[0][0]);
    int detVal = determinant(a, dimension);
    printf("determinant value : %dn", detVal);
    // ... do more computations here, reusing `a` ...
    deallocate_arr(dimension, a);
    return 0;
}