Returning arrays from functions in C++. Variable scope issuse.

>> though I appreciate how clean Java is by comparrison.
C++ requires a bit more effort to get things done correctly. Especially pointers (as you noticed) can cause a lot of problems if you don't know what's going on exactly. That's what I'll try to clarify a bit in this reply.

>> One of the issues I am having some issues with is array pointer scope.
An array created like this :

    int array[10];

will be on the stack. The stack is the space in memory used for local variables and function parameters. Variables on this stack go out of scope once the block where they were declared ends. So, if you declare an array in a function, it will not be available any more when you return from that function.

An array created like this :

    int *array = new int[10];

will be on the heap. The heap is the space in memory for dynamically allocated data blocks. Variables on the heap will stay there untill you explicitly delete them :

    delete [] array;

The danger here of course is : if you don't delete them, they still take up memory, and you've got a memory leak. So, always clean up your dynamically allocated data from the moment you don't need it any more.

>> In Java I can return an array from a method. I have tried to do the same thing in C++ but it does not seem to be working correctly when I run the debugger.

I suspect you returned an array that was located on the stack and not on the heap.

>> I know that the other C++ way of doing things is to supply the method a pointer to an array and have the method simply populate it.

That's a very common way of doing it. It's cleaner, and it allows you to return something else from the function (like a result code). However, it's not less valid to return the array, if that fits your code better.

In both cases, you have to make sure that the array is still in scope when you're using it.

I'll give an example of both of the discussed options. First passing as argument :

    void fun(int *arr, int len) {
      for (int i = 0; i < len; i++) arr[i] = i;
    }

    int array[10] = { 0 };
    fun(array, 10);

And returning from the function :

    int *fun(int len) {
      int *tmp = new int[len];
      for (int i = 0; i < len; i++) tmp[i] = i;
      return tmp;
    }

    int *array = fun(10);

Note that I didn't add any error checks for clarity.

>> Can anyone give me some pointers for dealing with C++ arrays and issues relating to variable scope.
I hope I did that ... if something is still not clear, then please ask.

>> I know that an array is equivelant to a pointer
This is only true in a way : you can treat an array as a pointer, and vice versa, but they're two different concepts.
An array is a number of items of the same type that are stored consecutively in memory (on the stack).
A pointer is basically just an address in memory - it points to a location in memory. By giving a type to a pointer (for example int* or pointer to int), you tell the compiler that the data at that address should be interpreted as an int. You can use that same pointer to retrieve the data after that first int, and also interprete it as an int, and so on. This way, you emulate an array (on the heap), that is accessed through a pointer.

I know this is confusing, but it is something that you have to understand if you want to be a successful C++ coder. Please ask for clarification wherever I wasn't clear enough.

>> and that there is no protection to stop navigation beyond the bounds of the array.
That's indeed something you have to keep track of yourself, and is a cause of a lot of common mistakes and bugs.

>> Can an object method return an array or will it only work if the array is created outside the method and passed as an argument?
You can return an array from an object method the same way you can for a function. They behave exactly the same.