C++ 访问阵列'；直接从指针/地址删除元素

我想：

• 将指向int数组的指针传递给方法
• 使用方法中的值
• 在方法中调整数组的大小
• 然后继续在方法外部使用数组

我的方法声明有func（int**arr\u address），我调用类似func（&arr）的方法。一种可行的方法是在我的方法中分配局部变量，但这似乎很笨拙。我尝试使用的方法是直接访问数组元素，如*arr_address[1]，但这似乎将[1]偏移量应用于指针的内存地址，而不是数组数据在内存中的起始地址

下面是一个带有输出的简单程序，用于说明两种不同的方法：

#include <iostream>
#include <stdlib.h>

void func(int** arr1_address, int** arr2_address)
{
    int* arr1_local = *arr1_address;

    arr1_local[1]=2;     // Works
    *arr2_address[1]=22; // (*) Writes to position 0 of wrong array!

    // These realloc() calls were incorrect in the original question
    //arr1_address = (int**)realloc(*arr1_address, 3*sizeof(int));
    //arr2_address = (int**)realloc(*arr2_address, 3*sizeof(int));
    *arr1_address = realloc(*arr1_address, 3*sizeof(int));
    *arr2_address = realloc(*arr2_address, 3*sizeof(int));

    //arr1_local[2] = 3;
    //*arr2_address[2] = 33;
}

int main()
{
    int* arr1;
    int* arr2;

    arr1 = (int*)calloc( 2, sizeof(int) );
    arr2 = (int*)calloc( 2, sizeof(int) );

    arr1[0] = 1;
    arr2[0] = 11;

    std::cout << "arr1, before func(): " << &arr1 << std::endl;
    std::cout << "arr2, before func(): " << &arr2 << std::endl;

    func(&arr1, &arr2);

    std::cout << "arr1, after func(): " << &arr1 << std::endl;
    std::cout << "arr2, after func(): " << &arr2 << std::endl;

    std::cout << "" << std::endl;

    std::cout << "arr1: " << std::endl;
    std::cout << arr1[0] << std::endl;
    std::cout << arr1[1] << std::endl;
    std::cout << arr1[2] << std::endl;

    std::cout << "" << std::endl;

    std::cout << "arr2:" << std::endl;
    std::cout << arr2[0] << std::endl;
    std::cout << arr2[1] << std::endl;
    std::cout << arr2[2] << std::endl;

    return 0;
}

我很确定我理解为什么标有（*）的行是这样工作的。我想知道是否有类似的方法可以直接从arr2的地址寻址[1]元素

（抱歉，如果以前有人问过这个问题，我已经阅读了很多答案，并在问之前尽了最大努力进行调查。）

编辑：更好的标题，修复realloc（）行中的错误

我想知道是否有类似的方法直接从

arr2

的

[1]

元素的地址寻址

当

[]

应用于

arr2\u地址时，您看到该行为的原因是
[]
的优先级高于
*
。可以通过应用括号强制执行所需的优先级：

(*arr2_address)[1] = 22;

我想知道是否有类似的方法直接从
arr2
的
[1]
元素的地址寻址

当
[]
应用于
arr2\u地址时，您看到该行为的原因是
[]
的优先级高于
*
。可以通过应用括号强制执行所需的优先级：

(*arr2_address)[1] = 22;

您的问题是不理解在指针对指针构造中什么指针指向什么数据。如果有多个级别的指针，请停止并单击

通常情况下，您几乎不应该使用指针对指针。这种情况也不例外。您希望通过引用传递。使用实际的参考资料

void func(int*& arr1, int*& arr2)
{
    arr1[0] = 42; // simple, easy
    arr1 = realloc (arr1, 42*sizeof(int)); // simple, easy
    free (arr2); // simple, easy
    arr2 = malloc (42*sizeof(int)); // simple, easy
}

您的问题是不理解在指针对指针构造中什么指针指向什么数据。如果有多个级别的指针，请停止并单击

通常情况下，您几乎不应该使用指针对指针。这种情况也不例外。您希望通过引用传递。使用实际的参考资料

void func(int*& arr1, int*& arr2)
{
    arr1[0] = 42; // simple, easy
    arr1 = realloc (arr1, 42*sizeof(int)); // simple, easy
    free (arr2); // simple, easy
    arr2 = malloc (42*sizeof(int)); // simple, easy
}

使用std：：vector.Use
std：：vector
。认真地说，使用
std：：vector
。我应该提到，由于我无法控制的要求，我不能使用vector.YAIT（另一个不称职的老师）使用std：：vector.Use
std：：vector
。认真地说，使用
std:：vector
。我应该提到，由于我无法控制的需求，我无法使用vector。YAIT（另一位不称职的老师）谢谢，我不明白这一点。行（*）现在可以工作，但是func（）末尾的等效行在未注释时会导致seg错误。这是因为
arr1_地址=（int**）realloc（*arr1_地址，3*sizeof（int））重新分配应为
*arr1_地址=realloc（*arr1_地址，3*sizeof（int））（无石膏，星号）。谢谢！我刚算出星号部分。既然你提到了这一点，那么没有演员的部分就显而易见了。我将更正问题中的代码。谢谢你的帮助。谢谢，我不明白这一点。行（*）现在可以工作，但是func（）末尾的等效行在未注释时会导致seg错误。这是因为
arr1_地址=（int**）realloc（*arr1_地址，3*sizeof（int））重新分配应为
*arr1_地址=realloc（*arr1_地址，3*sizeof（int））（无石膏，星号）。谢谢！我刚算出星号部分。既然你提到了这一点，那么没有演员的部分就显而易见了。我将更正问题中的代码。感谢您的帮助。谷歌“cpp通过引用传递”的顶级结果只给出了我更熟悉的
func（int&arr1）
等示例。这里唯一的区别是类型，即处理
int
值而不是
int*
值？所以
int**&
在技术上也是有效的（但不一定有用）？伟大的工作“回答问题，你希望我问过”，顺便说一句@Snaptastic当您通过引用传递某个内容时，您可以在函数中修改该内容，并且更改会反映回调用方。在
func（int&arr1）
中，通过引用传递
int
。在
func（int*&arr1）
中，通过引用传递
int*
<在
main
中，code>arr1
是您想要传递的对象，它的类型为
int*
，因此
int*&
是合适的参数类型。您在
main
中没有
int**
变量，但是如果您想使用一个变量并通过引用传递它，
int**&
将是参数类型。“cpp通过引用传递”的谷歌搜索结果顶部只给出了我更熟悉的
func（int&arr1）
之类的示例。这里唯一的区别是类型，即处理
int
值而不是
int*
值？所以
int**&
在技术上也是有效的（但不一定有用）？伟大的工作“回答问题，你希望我问过”，顺便说一句@Snaptastic当您通过引用传递某个内容时，您可以在函数中修改该内容，并且更改会反映回调用方。在
func（int&arr1）
中，通过引用传递
int
。在
func（int*&arr1）
中，通过引用传递
int*
<在
main
中，code>arr1
是您想要传递的对象，它的类型为
int*
，因此
int*&
是合适的参数类型。你没有一个