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

C ++连续内存操作

1 个答案: