C++ 我可以删除作为参数传递给函数的double*吗？

我编写了以下函数来动态地将内存分配给

double*

数组：（我还为

int*

编写了类似的函数）

void add_内存（double*double_数组，int current_idx，int max）
{
max=max*2；
double*temp_double_数组=新的double[max]；
对于（int i=0；i

我这样称呼这个函数：

int n_max = 10;
int m_max = 10;
double* val = new double[n_max];
int* col_ind = new int[n_max];
int* row_ptr = new int[m_max];
int n = 0;
int m = 0;

for (int i = 0; i < sz; i++) {
  int first_val_ind = -1;
  for (int j = 0; j < sz; j++) {
    if (B[i][j] == 0) {
      if (n == n_max) {
        add_memory(val, n, n_max);
        add_memory(col_ind, n, n_max);
        n_max = n_max * 2;
      }
      val[n] = B[i][j];
      col_ind[n] = j;
      if (first_val_ind == -1) {
        if (m == m_max) {
          add_memory(row_ptr, m, m_max);
          m_max = m_max * 2;
        }
        first_val_ind = n;
        row_ptr[m] = first_val_ind;
        m++;
      }
      n++;
    }
  }
}

int n_max=10；
int m_max=10；
double*val=新的双精度[n_max]；
int*col_ind=新int[n_max]；
int*row_ptr=新int[m_max]；
int n=0；
int m=0；
对于（int i=0；i

我得到了一个错误，根据似乎正在发生，因为我正在删除我尚未声明的内存

我的错误是：

***glibc检测到***./mm2:free（）：下一个大小无效（fast）：0x00000000016ae220***

---

是因为我试图在本地删除一个全局变量吗？

问题是您删除同一数组两次。考虑一下这里发生的事情：

void add_memory(double* double_array, int current_idx, int max)
{
    // ...
    delete [] double_array;
    double_array = temp_double_array; // <== double_array is local to add_memory
                                      // so this line has no effect
}

然后您必须覆盖

val

：

val = add_memory(val, n, n_max);

请注意，在程序结束时，您仍然必须

删除[]

所有阵列，因为现在它们正在泄漏

---

（关于在此处使用

vector

的标记注释）。

问题是删除同一数组两次。考虑一下这里发生的事情：

void add_memory(double* double_array, int current_idx, int max)
{
    // ...
    delete [] double_array;
    double_array = temp_double_array; // <== double_array is local to add_memory
                                      // so this line has no effect
}

然后您必须覆盖

val

：

val = add_memory(val, n, n_max);

请注意，在程序结束时，您仍然必须

删除[]

所有阵列，因为现在它们正在泄漏

---

（关于在此处使用

vector

的标记注释）。

问题是删除同一数组两次。考虑一下这里发生的事情：

void add_memory(double* double_array, int current_idx, int max)
{
    // ...
    delete [] double_array;
    double_array = temp_double_array; // <== double_array is local to add_memory
                                      // so this line has no effect
}

然后，您必须覆盖

val

：

val = add_memory(val, n, n_max);

请注意，在程序结束时，您仍然必须

删除[]

所有阵列，因为现在它们正在泄漏

---

（关于在此处使用

vector

的标记注释）。

问题是删除同一数组两次。考虑一下这里发生的事情：

void add_memory(double* double_array, int current_idx, int max)
{
    // ...
    delete [] double_array;
    double_array = temp_double_array; // <== double_array is local to add_memory
                                      // so this line has no effect
}

然后您必须覆盖

val

：

val = add_memory(val, n, n_max);

请注意，在程序结束时，您仍然必须

删除[]

所有阵列，因为现在它们正在泄漏

---

（关于在此处改用

向量的标记注释）。
将引用传递给指针应该有效：

void add_memory(double*& double_array, int current_idx, int max)
{
  max = max * 2;
  double* temp_double_array = new double[max];
  for (int i = 0; i < current_idx; i++) {
    temp_double_array[i] = double_array[i];
  }
  delete [] double_array;
  double_array = temp_double_array;
}

void add_内存（double*&double_数组，int current_idx，int max）
{
max=max*2；
double*temp_double_数组=新的double[max]；
对于（int i=0；i

这不需要您返回任何内容。
传递对指针的引用应该可以：

void add_memory(double*& double_array, int current_idx, int max)
{
  max = max * 2;
  double* temp_double_array = new double[max];
  for (int i = 0; i < current_idx; i++) {
    temp_double_array[i] = double_array[i];
  }
  delete [] double_array;
  double_array = temp_double_array;
}

void add_内存（double*&double_数组，int current_idx，int max）
{
max=max*2；
double*temp_double_数组=新的double[max]；
对于（int i=0；i

这不需要您返回任何内容。
传递对指针的引用应该可以：

void add_memory(double*& double_array, int current_idx, int max)
{
  max = max * 2;
  double* temp_double_array = new double[max];
  for (int i = 0; i < current_idx; i++) {
    temp_double_array[i] = double_array[i];
  }
  delete [] double_array;
  double_array = temp_double_array;
}

void add_内存（double*&double_数组，int current_idx，int max）
{
max=max*2；
double*temp_double_数组=新的double[max]；
对于（int i=0；i

这不需要您返回任何内容。
传递对指针的引用应该可以：

void add_memory(double*& double_array, int current_idx, int max)
{
  max = max * 2;
  double* temp_double_array = new double[max];
  for (int i = 0; i < current_idx; i++) {
    temp_double_array[i] = double_array[i];
  }
  delete [] double_array;
  double_array = temp_double_array;
}

void add_内存（double*&double_数组，int current_idx，int max）
{
max=max*2；
double*temp_double_数组=新的double[max]；
对于（int i=0；i

这不需要您返回任何内容。
您需要通过引用进行删除，我想我可以问一下这是做什么用的吗？它看起来像C，而不是C++。也就是说，研究C++习语对于一个更干净的解决方案可能有用。@ Jujuabyar不是真的。所以你有一个指针，内存，使用多少，总大小。这就是
std:：vector
，它能以更少的努力为您提供正确的代码。您需要通过引用进行删除，我想我可以问问这是干什么用的吗？它看起来像C，而不是C++。也就是说，研究C++习语对于一个更干净的解决方案可能有用。@ Jujuabyar不是真的。所以你有一个指针，内存，使用多少，总大小。这就是
std:：vector
，它能以更少的努力为您提供正确的代码。您需要通过引用进行删除，我想我可以问问这是干什么用的吗？它看起来像C，而不是C++。也就是说，研究C++习语对于一个更干净的解决方案可能有用。@ Jujuabyar不是真的。所以你有一个指针，内存，使用多少，总大小。这就是
std:：vector
，它能以更少的努力为您提供正确的代码。您需要通过引用进行删除，我想我可以问问这是干什么用的吗？它看起来像C，而不是C++。也就是说，研究C++习语对于更干净的解决方案可能是有用的。@ Jujuabyar不是真的。所以你有一个指针指向内存，一个Cou.