数组如何传递给函数？

Question

Consider the following:

String[] array = {1,2,3,4};

myFunction(array);

public void myFunction(String[] array){
//some task here
}

I had to answer this question today.

How are arrays passed to a function? Means what is the underlying technique?

When I failed to answer, I was told the following.

The address of first element is passed and other consecutive elements are obtained from the first element's address by adding some x bytes .

Does this happen in every programming language or in just c and c++?

Thank you!

Answer 1

No, in Java for example arrays are objects. They are passed like any other object is passed to a method: the method would take a reference to the array object as a whole, and not a reference to the first element.

Taken from this page :

All class and array types inherit (§8.4.8) the methods of class Object

Java has no concept of "pointers", in the same sense as C or C++ (addresses in memory), ie an object reference does not really point to the memory location where the object is stored.

Answer 2

In theory, every language is different. However:

• In C, a function cannot take an array as an argument. When you declare an array parameter, the type is automatically converted into a pointer, so there is no different between void f( int a[5] ) and void f( int* ) . (This is often summarized by saying that arrays are not first class objects.) For reasons of C compatibility, C++ follows the same rules, but in C++, you wouldn't normally pass an array as a parameter anyway, and if you did, you would pass it by reference, where this conversion to pointer doesn't occur. (Ie void f( int (&a)[5] ) is not the same as void f( int* &a ) .)

• In Java, and a number of other recent languages, everything (or almost), including arrays are objects, and parameters, variables, etc. are pointers to those objects. So in Java, you pass a pointer to the array, but the full array object, with all of the information about its size, etc. Sort of like passing an std::vector<int>* in C++.

• In a lot of languages (mostly older?), like Pascal and languages of the Modula family, and array is an object type just like any other. If you don't take any particular actions, an array will be passed by value, with a complete copy of the array.

• And in the earliest languages, like Fortran or Algol, each language often had its own very particular ways of passing arrays, although in general, they followed the same rules as other types. (Some early languages like Cobol or Basic, didn't even support passing arguments to functions, at least in their earliest variants.)

Amongst the languages you're likely to see today, I think that the Java model predominates. C remains an outlier, and C++ gives you the choice: you can pass an std::vector by value or by reference (but reference is recommended for performance reasons).