Burn that book. If you want a real C FAQ that wasn't written by a beginner programmer, use this one: http://c-faq.com/aryptr/index.html.

Syntax-wise, strictly speaking you cannot pass an array by value in C.

void func (int* x); /* this is a pointer */

void func (int x[]); /* this is a pointer */

void func (int x[10]); /* this is a pointer */

However, for the record there is a dirty trick in C that does allow you to pass an array by value in C. Don't try this at home! Because despite this trick, there is still never a reason to pass an array by value.

typedef struct
{
  int my_array[10];
} Array_by_val;

void func (Array_by_val x);

Because this:

void foo(int arr[])

is really just syntax sugar for this:

void foo(int *arr)

So when you call the function, your array decays into a pointer to the first element.

For passing 2D (or higher multidimensional) arrays instead, see my other answers here:

1. How to pass a multidimensional [C-style] array to a function in C and C++, and here:
2. How to pass a multidimensional array to a function in C++ only, via std::vector<std::vector<int>>&

Passing 1D arrays as function parameters in C (and C++)

1. Standard array usage in C with natural type decay (adjustment) from array to ptr

@Bo Persson correctly states in his great answer here:

When passing an array as a parameter, this

void arraytest(int a[])

means exactly the same as

void arraytest(int *a)

Let me add some comments to add clarity to those two code snippets:

// param is array of ints; the arg passed automatically "adjusts" (frequently said
// informally as "decays") from `int []` (array of ints) to `int *` 
// (ptr to int)
void arraytest(int a[])

// ptr to int
void arraytest(int *a)

However, let me add also that the above two forms also:

1. mean exactly the same as

    // array of 0 ints; automatically adjusts (decays) from `int [0]`
    // (array of zero ints) to `int *` (ptr to int)
    void arraytest(int a[0])
   

2. which means exactly the same as

    // array of 1 int; automatically adjusts (decays) from `int [1]`
    // (array of 1 int) to `int *` (ptr to int)
    void arraytest(int a[1])
   

3. which means exactly the same as

    // array of 2 ints; automatically adjusts (decays) from `int [2]`
    // (array of 2 ints) to `int *` (ptr to int)
    void arraytest(int a[2])
   

4. which means exactly the same as

    // array of 1000 ints; automatically adjusts (decays) from `int [1000]`
    // (array of 1000 ints) to `int *` (ptr to int)
    void arraytest(int a[1000])
   

5. etc.

In every single one of the array examples above, and as shown in the example calls in the code just below, the input parameter type adjusts (decays) to an int *, and can be called with no warnings and no errors, even with build options -Wall -Wextra -Werror turned on (see my repo here for details on these 3 build options), like this:

int array1[2];
int * array2 = array1;

// works fine because `array1` automatically decays from an array type
// to a pointer type: `int *`
arraytest(array1);
// works fine because `array2` is already an `int *` 
arraytest(array2);

As a matter of fact, the "size" value ([0], [1], [2], [1000], etc.) inside the array parameter here is apparently just for aesthetic/self-documentation purposes, and can be any positive integer (size_t type I think) you want!

In practice, however, you should use it to specify the minimum size of the array you expect the function to receive, so that when writing code it's easy for you to track and verify. The MISRA-C-2012 standard (buy/download the 236-pg 2012-version PDF of the standard for £15.00 here) goes so far as to state (emphasis added):

Rule 17.5 The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements.

...

If a parameter is declared as an array with a specified size, the corresponding argument in each function call should point into an object that has at least as many elements as the array.

...

The use of an array declarator for a function parameter specifies the function interface more clearly than using a pointer. The minimum number of elements expected by the function is explicitly stated, whereas this is not possible with a pointer.

In other words, they recommend using the explicit size format, even though the C standard technically doesn't enforce it--it at least helps clarify to you as a developer, and to others using the code, what size array the function is expecting you to pass in.

2. Forcing type safety on arrays in C

(Not recommended (correction: sometimes recommended, especially for fixed-size multi-dimensional arrays), but possible. See my brief argument against doing this at the end. Also, for my multi-dimensional-array [ex: 2D array] version of this, see my answer here.)

As @Winger Sendon points out in a comment below my answer, we can force C to treat an array type to be different based on the array size!

Quick summary

// `a_p` is a pointer to an array of 2 integers
int (*a_p)[2]; 

// Now, assuming you have this array of 2 integers:
int my_array[2];

// ...you can make `a_p` point to `my_array` like this:
a_p = &my_array;

// This, however, would be **illegal**, since `my_array2` is the wrong size
int my_array2[3]; // Ok: array of 3 `int`s
a_p = &my_array2; // ERROR! `a_p` is a ptr to an array of 2 ints, not 3 ints, 
                  //        so this assignment is not allowed!

Details

First, you must recognize that in my example just above, using the int array1[2]; like this: arraytest(array1); causes array1 to automatically decay into an int *. HOWEVER, if you take the address of array1 instead and call arraytest(&array1), you get completely different behavior! Now, it does NOT decay into an int *! This is because if you take the address of an array then you already have a pointer type, and pointer types do NOT adjust to other pointer types. Only array types adjust to pointer types. So instead, the type of &array1 is int (*)[2], which means "pointer to an array of size 2 of int", or "pointer to an array of size 2 of type int", or said also as "pointer to an array of 2 ints". So, you can FORCE C to check for type safety on an array by passing explicit pointers to arrays, like this:

// `a` is of type `int (*)[2]`, which means "pointer to array of 2 ints"; 
// since it is already a ptr, it can NOT automatically decay further
// to any other type of ptr 
void arraytest(int (*a)[2])
{
    // my function here
}

This syntax is hard to read, but similar to that of a function pointer. The online tool, cdecl, tells us that int (*a)[2] means: "declare a as pointer to array 2 of int" (pointer to array of 2 ints). Do NOT confuse this with the version withOUT parenthesis: int * a[2], which means: "declare a as array 2 of pointer to int" (AKA: array of 2 pointers to int, AKA: array of 2 int*s).

Now, this function REQUIRES you to call it with the address operator (&) like this, using as an input parameter a POINTER TO AN ARRAY OF THE CORRECT SIZE!:

int array1[2];

// ok, since the type of `array1` is `int (*)[2]` (ptr to array of 
// 2 ints)
arraytest(&array1); // you must use the & operator here to prevent
                    // `array1` from otherwise automatically decaying
                    // into `int *`, which is the WRONG input type here!

This, however, will produce a warning:

int array1[2];

// WARNING! Wrong type since the type of `array1` decays to `int *`:
//      main.c:32:15: warning: passing argument 1 of ‘arraytest’ from 
//      incompatible pointer type [-Wincompatible-pointer-types]                                                            
//      main.c:22:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
arraytest(array1); // (missing & operator)

You may test this code here.

To force the C compiler to turn this warning into an error, so that you MUST always call arraytest(&array1); using only an input array of the corrrect size and type (int array1[2]; in this case), add -Werror to your build options. If running the test code above on onlinegdb.com, do this by clicking the gear icon in the top-right and click on "Extra Compiler Flags" to type this option in. Now, this warning:

main.c:34:15: warning: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Wincompatible-pointer-types]                                                            
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’    

will turn into this build error:

main.c: In function ‘main’:
main.c:34:15: error: passing argument 1 of ‘arraytest’ from incompatible pointer type [-Werror=incompatible-pointer-types]
     arraytest(array1); // warning!
               ^~~~~~
main.c:24:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
 void arraytest(int (*a)[2])
      ^~~~~~~~~
cc1: all warnings being treated as errors

Note that you can also create "type safe" pointers to arrays of a given size, like this:

int array[2]; // variable `array` is of type `int [2]`, or "array of 2 ints"

// `array_p` is a "type safe" ptr to array of size 2 of int; ie: its type
// is `int (*)[2]`, which can also be stated: "ptr to array of 2 ints"
int (*array_p)[2] = &array;

...but I do NOT necessarily recommend this (using these "type safe" arrays in C), as it reminds me a lot of the C++ antics used to force type safety everywhere, at the exceptionally high cost of language syntax complexity, verbosity, and difficulty architecting code, and which I dislike and have ranted about many times before (ex: see "My Thoughts on C++" here).

For additional tests and experimentation, see also the link just below.

References

See links above. Also:

1. My code experimentation online: https://onlinegdb.com/B1RsrBDFD

See also:

1. My answer on multi-dimensional arrays (ex: 2D arrays) which expounds upon the above, and uses the "type safety" approach for multi-dimensional arrays where it makes sense: Why can't I pass a C-style multidimensional array to a function taking an array of int*?
2. C pointers : pointing to an array of fixed size

In general, you can't.

The caller can do something like this;

int main()
{
    int abc[]={5,1,2,9};

    {
         int temp[sizeof (abc)/sizeof (*abc)];
         memcpy(temp, abc, sizeof(abc));
         Foo(temp);
    }
}

Bear in mind that Foo() does not receive any information about the number of elements in the array passed.

If you want Foo() to do a similar thing, so the caller doesn't need to, it is necessary to pass the number of elements as a separate argument.

void Foo(int arr[], size_t size)    /*  C99 or later */
{
       int temp[size];   //   VLA
       memcpy(temp, arr, size*sizeof(int));
         /* whatever */
}

or (before C99).

void Foo(int arr[], size_t size)    /*  Before C99 */
{
       int *temp = malloc(size * sizeof (int));
       memcpy(temp, arr, size*sizeof(int));
         /* whatever */
       free(temp);
}

To avoid a memory leak, it is necessary to ensure, in the second case, that the function does not return before calling free(temp).

In both versions of Foo() above, additional error checking may be needed (e.g. to detect null pointer or zero sizes being passed, that malloc() succeeds, etc).

C only pass arguments to functions by value.

From the mighty Kernighan & Ritchie, 2nd edition:

(1.8, Call by value) "In C all function arguments are passed by "value"

1) you can use c++ swap function instead using a temp variable

swap(arr[i], arr[j]);

2) your for loops should look like this

for(int i = 0; i < 5; i++) {
    for(int j = i; j < 5; j++) {

The outer loop has to iterate through the whole array (from 0 to 4) and the inner has to iterate through the 'right side' of the array, because the left side is already sorted

so we can't pass array by value

https://stackoverflow.com/a/16137997/6521788 https://stackoverflow.com/a/16137995/6521788

You can just copy the values into a new array

Use:

sample(d);

instead of:

sample(d[3][2]);

d[3][2] is simply the value of an element of the array and this is not what you want to pass.

Also:

int d[3][2]={(2,3),(4,2),(5,2)};

this is not how you initialize an array.

int d[3][2]={{2, 3}, {4,2}, {5, 2}};

is the correct way.

An array passed to a function is converted to a pointer. When you pass a pointer as argument to a function, you simply give the address of the variable in the memory. So when you modify the value of the cell of the array, you edit the value under the address given to the function.

When you pass a simple integer to a function, the integer is copied in the stack, when you modify the integer within the function, you modify the copy of the integer, not the original.

Reminder of the different kinds of memory in C

In C, we can use three types of memory :

• the stack, used for local variables and functions calls: when we create a variable in main(), we use the stack to store the variable, and when a function is called, the parameters given to the method are register in the stack. When we exit a function, we "pop" these parameters to return to the original state, with the used variable before the call of the function. (anecdote: a stackoverflow is when we hack the stack to use previous variables in a function without passing it as parameters)
• the heap which corresponds to the dynamicly allocated memory: when we need large amount of data, we use this heap because the stack is limited to a few megabytes.
• the code where the program instructions are stored

In the case of this array passed by a function, which is a pointer (address to an other variable), it is stored in the stack, when we call the function, we copy the pointer in the stack.

In the case of the integer, it is also stored in the stack, when we call the function, we copy the integer.

If we want to modify the integer, we can pass the address of the integer to modify the value under the pointer, like this:

void function(int *integer)
{
    *integer = 2;
}

int main()
{
    int integer = 1;
    function(&integer);

    printf("%d", integer);

    return 0;
}