如何在两个不同的函数中访问动态数组C ++

Question

I need to access a dynamic array in two different functions. The changes made to it in one need to transfer over to the other.

These are the functions:

void populate(int size, int *ptr)
{
    ptr = new int[size];
    for (int i = 0; i < size; i++)
    {
        ptr[i] = rand() % 51;
    }
}

void display(int size, int *ptr)
{
    for (int i=0; i < size; i++)
    {
        cout << ptr[i] << endl;
    }
}

it is called in the main as

int* ptr = NULL;

Answer 1

In populate , you are attempting to make a pointer you pass to the function point to a dynamically allocated array. But you pass the pointer by value . This has no effect on the caller side, and results in a memory leak. You need to pass either the pointer by reference:

void populate(int size, int*& ptr)
                            ^

or return it

int* populate(int size)
{
   int* ptr = new int[size];
   ....
   return ptr;
}

But the easiest and safest thing to do would be to use an std::vector<int> for both functions instead. For example

std::vector<int> populate(size_t size)
{
    std::vector<int> v(size);
    for (auto& i : v)
    {
        i = rand() % 51;
    }
    return v;
}

void display(const std::vector<int>& v)
{
  for (auto i : v)
  {
    std::cout << ptr[i] << std::endl;
  }
}

This way, it is clear what is being returned, and the caller doesn't have to read up on whether they have to manage the resources pointed at by a raw pointer.

Note that populate can be replaced by a call to std::generate , and display by a call to std::copy .

Answer 2

You have to remember that when passing arguments to a function, they are passed by value , meaning they are copied. So when you pass a pointer to a function, the pointer is copied, and when you modify that pointer (like eg ptr = new int[size] ) you only modify the local copy.

In C++ you can pass arguments by reference which means that you can modify the arguments and their changes will be reflected in the calling function:

void populate(int size, int*& ptr)

Answer 3

A simple solution is to make the first function return the pointer and store it in another variable. You can then send it to the second function.

Answer 4

usually when you need to pass a pointer to a function which does the initialization of the pointer, you either pass p* ointer to pointer * or the function returns a pointer .

The easiest way to do it is to simply return a pointer from the populate function:

int* populate(int size, int *ptr)
{
    ptr = new int[size];
    for (int i = 0; i < size; i++)
    {
        ptr[i] = rand() % 51;
    }
    return ptr;
}

 int*p = populate(N,p);   


display(int size, int *ptr)
{
    for (int i=0; i < size; i++)
    {
        cout << ptr[i] << endl;
    }
}

The reason why simply passing the pointer does not work is that the pointer is passed by value, which means a local copy of the pointer is created locally in your function ; that local copy is being initialized and destroyed when you exit the function