Something passed to a function as pointers to type [duplicate]

Solution 1:

In the both cases when a variable as you are saying is passed to a function or an array is passed to a function there is passed a value.

But in the first case there is passed the value of the variable while in the second case there is passed the value of the pointer to first element of an array.

Arrays used in expressions with rare exceptions are converted to pointers to their first elements.

From the C Standard (6.3.2.1 Lvalues, arrays, and function designators)

3 Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. If the array object has register storage class, the behavior is undefined.

So having a pointer to an object you can change the pointed object.

Let's assume that you have two functions.

void f( int x )
{
   x = 10;
}

and

void g( int *px )
{
    *px = 10;
}

and their calls

int n = 0;

f( n );
g( &n );

You can imagine the function definitions and their calls the following way

int n = 0;

f( n );
g( &n );

//...

void f( /* int x */ )
{
   int x = n;
   x = 10;
}

void g( /* int *px */ )
{
    int *px = &n;
    *px = 10;
}

That is the both functions deal with copies of values of the expressions used as function arguments. But in case of the function g as the function gets the value of the address of the pointed object n you can change the pointed object n using the pointer (address).

In the terms of C passing an object to a function indirectly through a pointer to the object is called passing by reference.

From the C Standard

— A pointer type may be derived from a function type or an object type, called the referenced type. A pointer type describes an object whose value provides a reference to an entity of the referenced type. A pointer type derived from the referenced type T is sometimes called ‘‘pointer to T’’. The construction of a pointer type from a referenced type is called ‘‘pointer type derivation’’. A pointer type is a complete object type.

Pay attention to that a function declaration like this

void f( int a[], size_t n );

is equivalent to the following declaration

void f( int *a, size_t n );

And the both declare the same one function.

If you have an array as for example

#define N 10
//...
int a[N];

then it is passed to the function like

f( a, N );

then as it is followed form the first quote from the C Standard the array designator is converted to pointer to its first element. And having this pointer in the function you can change any element of the array because each element of the array in fact is passed by reference. Using the pointer arithmetic you can change any element of the pointed array. For example

void f( int *a, size_t n )
{
    for ( int i = 0; i < n; i++ )
    {
        a[i] = i;
        // that is the same as
        // *( a + i ) = i;
    }
}

Solution 2:

When you pass an array, you are actually passing the base address of the same, which is a pointer to the first array element in the memory. It is inherently a call by reference, so you don't need to explicitly use a reference or & while passing into your swap function. arr decays to &(arr[0]).

On the other hand, variables are not by default passed by value, and you need to explicitly use a & to pass them by reference to get their values swapped in their memory locations and not just specific to the scope of the swap function.

Something passed to a function as pointers to type [duplicate]

Solution 1:

Solution 2:

Related

Recent Posts