C: Why can you pass (to a function) a struct by value, but not an array?

int function(int array[10]) and int function(int *array) are the same because of 6.7.5.3 Function declarators (including prototypes) (http://www.open-std.org/JTC1/SC22/wg14/www/docs/n1124.pdf page 118)

7 A declaration of a parameter as ‘‘array of type’’ shall be adjusted to ‘‘qualified pointer to type’’, where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation. If the keyword static also appears within the [ and ] of the array type derivation, then for each call to the function, the value of the corresponding actual argument shall provide access to the first element of an array with at least as many elements as specified by the size expression

.

Of course, you can pass an array by value; all you need to do is wrap it in a struct. But that only works if the array has a definite (and non-variable) size. You can include an indefinitely sized array in a struct, but the resulting type is incomplete and can only be used as the target of a pointer.

That's probably as close as we're going to get to an explanation. The vast majority of arrays passed as arguments are not of fixed size, and passing them by value would not be possible, even if it were intended, which is also unlikely.

There is a similar (but different) decay with functions; a function cannot be passed as an argument, only function pointers. Since it would be tedious to explicitly write & every time you wanted to refer to a function, the language takes care of it for you.

On the whole, questions of the form "Why is this language like this snd not like that?" can only be answered "because that's how it is".

Types are different in both function declarations -

struct tag  /* and */ struct tag *

One is structure variable whereas another is pointer to structure.

You can do similar with structures -

int function(struct tag name[])  /*--> int function(struct tag *name)  */

These above would be equivalent.

structs are used for declaring own kind of data types with primitive data types like int,float,long(or structs of structs) etc. they are supposed to hold a few of them e.g. struct of students will contain id,name,rollno,subjects,etc. so mostly any struct element will contain 10-20 fields at most (in logical cases), so when you pass a struct to a function, it has to copy 40-100 bytes approx. to make copy of that struct variables. where as arrays can be of huge size and are used to store same kind of information. they can be of size 10^7 in case of integers so if we implement a language to copy whole array for function calls it may have to copy (10^7)*4 bytes which is a huge amount and will impact the performance badly.and typical size of arrays is 10^4 to 10^6 which is still a lot. but if you create struct of array of int(or any other array) you can pass it to a function as a copy of that array. e.g.

#include<stdio.h>

typedef struct {
    int arr[10];
}arrayStruct;

void change(arrayStruct a){
    a.arr[2]=5;
}
int main(){
    arrayStruct a;
    for(int i=0;i<10;i++){
        a.arr[i]=i;
    }
    printf("Before:\n");
    for(int i=0;i<10;i++){
        printf("%d ",a.arr[i]);
    }
    change(a);
    printf("\nAfter:\n");
    for(int i=0;i<10;i++){
        printf("%d ",a.arr[i]);
    }
    return 0;
}

this is not done in most of the cases but few times when you need to pass arrays but don't want to alter the contents of them but also require some kind of changes to their copies and want to return that copy you can use this kind of structs of arrays and return them from functions of return type of structs e.g.

arrayStruct returnChange(arrayStruct a){
    a.arr[2]=332;
    return a;
}