Arrays!

**Harith** · 10-01-2013

Hello,
I want to pass an array to a function and change the array, how can I do that? Here's my code:

Code:

#include<stdio.h>

/*function to change the array*/
void rearng(int *qw)
{
     int i,j,a;
     int sa[8];  //temp array
     int c = 0;
     int high;
     
     /*find highest number in the array*/
     high = qw[0];
     int u;
     for(u = 1; u < 8; u++)
     {
           if(qw[u] > high)
              high = qw[u];
     }
    
     /*arrange the array from high to low*/
     for(i = 0; i <= high; i++)
     {
           for(j = 0; j < 8; j++)
           {
                 if(i == qw[j])
                 {
                      sa[c] = qw[j];
                      c++;
                 }
           }
     }
    /*make the temp array, real array*/
     qw = sa;
    
}            

int main(void)
{
    int qw[] = {12,43,3,234,21,35,213,12}; //real array
    
    rearng(qw); // call the function
    
    /*problem: s not changing the real array*/
    int i;
    for(i = 0; i < 8; i++)
       printf("%d ",qw[i]);
       
    system("pause");
    return 0;
}

**Adak** · 10-01-2013

The temp array is just that - an automatic variable who automatically goes out of scope (goes to byte heaven), when the function ends.

You could malloc the temp array to make this work, or less efficiently, copy the temp array back to the permanent one. Either way. qw is a constant pointer and can't be changed. You are not receiving a warning about this?

**grumpy** · 10-01-2013

You can't reassign arrays, directly or indirectly.

Also assignments to variables inside function are local to that function.

To understand what is happening though you need to understand the meaning of passing by value.

**Elkvis** · 10-01-2013

with your code, you also risk buffer overruns. what happens if you send an array smaller than 8 elements to rearng()? how do you tell rearng() that the incoming array is less than 8 elements?

**Harith** · 10-01-2013

Originally Posted by Elkvis

with your code, you also risk buffer overruns. what happens if you send an array smaller than 8 elements to rearng()? how do you tell rearng() that the incoming array is less than 8 elements?

I guess by; sizeof(array)/sizeof(int) ; is this correct?

**vart** · 10-01-2013

Originally Posted by Harith

I guess by; sizeof(array)/sizeof(int) ; is this correct?

Depends on where you planning to do it...

And I prefer type independent version

Code:

sizeof(array)/sizeof(array[0]);

**grumpy** · 10-02-2013

Originally Posted by Harith

I guess by; sizeof(array)/sizeof(int) ; is this correct?

Not necessarily.

When passing an array as an argument to a function, the function receives a pointer, not an array.

So

Code:

void fun(int *array)
{
      /* sizeof(array) will be the size of a pointer here .... 4 on a typical 32-bit system */
}

int main()
{
     int array[20];
     /* sizeof(array) will be 20 times sizeof(int) here */

    fun(array);     /*  Note comment above for what sizeof(array) will produce in fun() */ 
}

The "type independent version" mentioned by vart is better practice .... but still won't produce the desired result in fun().

Thread: Arrays!

Thread Tools

Search Thread

Display

Arrays!

Similar Threads

Homework: Arrays & Functions - Print Two Arrays on Same Table After Sorting

Modifying parallel arrays to arrays of structures

Parallel arrays, dynamic memory allocation, and sorting arrays

Sorting Multiple Arrays with complications of 2D arrays and strings.

separating line of arrays into array of arrays

Tags for this Thread