return a pointer to array from a function

If you don't want to use an std::vector then the only other option is to return return both a pointer to the array and the number of elements.

int MyFunc(int** pointerToFill)
{
  *pointerToFill = new int;
  return numElements;
}
HRESULT MyFunc(int** pointerToFill, int& iNumElements)
{
  *pointerToFill = new int;
  iNumElements = numElements;

  return SUCCESS;
}

I don't think there really is a 'smarter' way.
Replacing the regular array with an std::vector shouldn't really cause that many problems though. You can still use it exactly the same as an array but instead of having an extra variable to store the number of elements it will contain the number itself and you don't need to worry so much about allocating and freeing memory. To save a little typing you can also set up a typedef.

typedef std::vector<int> MyIntArra

Unless there's a specific reason not to use a std::vector, I'd just have the method declaration return that.

std::vector<int> MyFunc()</int>

That way you don't have to return the number of items returned as an out parameter, the std:vector will know how many items it's holding.


Hope this helps,
Fredrik

There are many ways you can do this depending on the situation.

I quite often use out parameters to avoid copying (since the move constructor isn't available on all compilers, and for other reasons)

One thing I try to tell people is to avoid allocating memory in a function and return it for someone else to clean up. This is the #1 reason for memory leaks. It's hard to see the allocation scope if it crosses functions, translation units and, God forbid, module boundaries. A good rule is to free memory as close to the allocation point as possible. This might result in letting the caller allocate memory instead of the callee. You will need a query mechanism to get the size needed, but this approach can have some real performance benefits when it comes to reusing allocated space. (This applies to GC languages too)

This is of course not always possible, but for most of the other cases you can write a class that takes care of the memory management.

...and then we have your case where you for one reason or another need a specific function signature. Return newly allocated memory pointers if you know you have things under control, but avoid letting them out to the public.

Depending on how the array is used, you can create a class that has an operator (int*) and return such an instance.
You can have function-local memory caching or maybe use a memory pool to increase the level of control and performance.

oops. Time's up.

Thanks for the quick reply.
Unfortunately the function must return an array and not a vector.
The overall idea of my work is to upgrade an application with minimal changes in the original code (all the changes are implemented via an interface).

dj4400