Returning Array from function in C

Question

For some reason, my function is only returning the first element in my array and I cannot figure out why the rest of the array goes out of scope. The function takes two integer arrays, adds their respective elements, and puts the sum into a third array which is returned.

Here is my code:

#include <stdio.h>
/* count digits, white space, others */

int *sumarrays(int arr1[], size_t arr1len, int arr2[], size_t arr2len);

void main() {

    int arr1[10];
    size_t arr1len = 10;
    int arr2[10] = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
    size_t arr2len = 10;
    int i;

    int *x;

    arr1[0] = 2;
    arr1[1] = 3;
    arr1[2] = 2;
    arr1[3] = 2;
    arr1[4] = 2;
    arr1[5] = 2;
    arr1[6] = 3;
    arr1[7] = 2;
    arr1[8] = 2;
    arr1[9] = 2;

    //printf("%d\t%d\t%d\n", arr1, *arr1, *(arr1 + 1));
    x = sumarrays(arr1, arr1len, arr2, arr2len);

    for (i = 0; i < 10; i++) {
        printf("Array1: %d\tArray 2: %d\tX = %d\n", arr1[i], arr2[i], x[i]);

    }

    //return 0;
}

int *sumarrays(int arr1[], size_t arr1len, int arr2[], size_t arr2len) {
    int i;
    int total[10];

    for (i = 0; i < 10; i++) {
        total[i] = *(arr1 + i) + *(arr2 + i);

    }
    for (i = 0; i < 10; i++) {
        printf("%d\t", total[i]);
    }

    printf("\n");
    return total;
}

Here is the output:

4   5   4   4   4   4   5   4   4   4   
Array1: 2   Array 2: 2  X = 4
Array1: 3   Array 2: 2  X = 1974388256
Array1: 2   Array 2: 2  X = -161927102
Array1: 2   Array 2: 2  X = 2686628
Array1: 2   Array 2: 2  X = 8670801
Array1: 2   Array 2: 2  X = 0
Array1: 3   Array 2: 2  X = 27
Array1: 2   Array 2: 2  X = 2686540
Array1: 2   Array 2: 2  X = 4
Array1: 2   Array 2: 2  X = 2686916

The first line is the sum array elements from within the function. The remainder is what happens in the main().

What am I missing?

*edit* ANSWERED

Thank you everyone for the help! I actually learned C and C++ a while ago but have recently started to go back and fine tune my knowledge. Really appreciate all the help.

The main answers were

1) Statically allocate memory (using the static keyword)

2) Dynamically allocate memory (using malloc())

3) Make the variable global

4) Pass the result total() as an argument to the function so it doesn't go out of scope.

You're missing where total lives, and its existence (or lack thereof) once your function returns. — WhozCraig
– WhozCraig, Commented Jun 30, 2014 at 17:43
This is a good question, with more than one approach to solve the issue. Either use memory on the heap (and free it later) or use globally scoped stack memory. globally scoped variables keep their existence until program exits. Either approach will address your issue. — ryyker
– ryyker, Commented Jun 30, 2014 at 18:54
Thanks a lot! I see that lots of folks are recommending malloc(), but I'd rather steer clear of that. Static variables seem to work fine, is there any danger to it such as there can be with malloc()? I'd also like to steer clear of global variables as much as possible. — Moe45673
– Moe45673, Commented Jun 30, 2014 at 19:40

merlin2011 · Accepted Answer · 2014-06-30 17:43:48Z

2

You are doing stack allocation for your array, and stack-allocated storage goes away when a function returns. Use heap allocation instead.

Change

int total[10];

to

int* total = malloc(10*sizeof(int)).

of course, that means you must also free the memory after you are done with it. In this case, before the return 0; in main, you need to

free(x);

answered Jun 30, 2014 at 17:43

merlin2011

76.4k48 gold badges218 silver badges364 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Clifford · Accepted Answer · 2014-06-30 20:03:42Z

2

my function is only returning the first element in my array and I cannot figure out why the rest of the array goes out of scope.

No, it returns a pointer to the first element - and the entire array goes out of scope. Any data you see that happens to remain as it was in the function is by luck rather than judgement, and you cannot use it as it is released for use by other functions.

Arrays are not first class data types in C - you cannot return an array by copy.

The normal solution is to have the array owned by the caller and to pass its address and size to the function.

int* func( int* arr, int arrlen )
{
    // write to arr[0] to arr[arrlen-1] ;

    return arr ;
}

int main()
{
    int array[256] ;
    func( array, sizeof(arr)/sizeof*(*arr) ) ;
}

Other less common and generally ill-advised possibilities are either to return a struct containing the array (a struct is a first class data type), but to do that is somewhat inefficient in many cases, or to dynamically allocate the array within the function, but it is not a particularly good idea since the caller has the responsibility of freeing that memory and may not be aware of that responsibility - it is a recipe for a memory leak.

edited Jun 30, 2014 at 20:03

answered Jun 30, 2014 at 18:05

Clifford

94.3k14 gold badges93 silver badges176 bronze badges

2 Comments

ryyker Over a year ago

Curious - what do you mean by struct is a first class data type?

Clifford Over a year ago

@ryyker : Added a link in the answer, but essentially a first-class data type can be passed as a parameter, returned from a function and assigned to a variable. You can do neither directly in C with an array - in function arguments and return values they "degrade" to pointers (by reference) and assignment <array> = <array> is not legal - you can do <pointer> = <array> (again by reference), or an element-by-element (or byte-by-byte) copy.

John Bode · Accepted Answer · 2014-06-30 19:48:45Z

The problem is that when sumarrays returns, the total array ceases to exist¹, so the pointer value that main receives is no longer valid. In short, you cannot return arrays from a function like this.

You have several options.

The first (and IMO the preferred option) is to pass the total array as one of your parameters, and make the caller responsible for setting aside enough memory:

void sumarrays(int arr1[], size_t arr1len, int arr2[], size_t arr2len, int *total, size_t totallen) 
{
  ...
  for (i = 0; i < totalLen; i++) {
      total[i] = *(arr1 + i) + *(arr2 + i);
  ...
}

#define ARRLEN 10

int main( void )
{
  ... 
  int x[ARRLEN];
  ...
  sumarrays( arr1, ARRLEN, arr2, ARRLEN, x, ARRLEN);

In this method, the caller (main) is responsible for knowing how big the target array needs to be and setting aside the memory for it. The helps decouple the sumarrays function from main because it doesn't have to rely on information that isn't explicitly specified by the parameter list (such as the array sizes). With this approach, you're not limited to arrays of size 10.

A second option is to declare total such that it doesn't go away after sumarrays exits. You can do this by either declaring it at file scope (as in ryyker's answer), or by declaring it static within the sumarrays function:

int *sumarrays(int arr1[], size_t arr1len, int arr2[], size_t arr2len) {
    int i;
    static int total[10];
    ...

With this approach, the total array will be allocated at program startup and held until the program terminates. What makes this approach less desireable is that you have only a single instance of that total array, which is shared across all calls to sumarrays. The function is no longer re-entrant; if sumarrays called another function that called sumarrays, then whatever the first call had written to total would be clobbered by the second call (the strtok library function has this problem, which has caused much heartburn in the past). Your code obviously doesn't have this problem, but it's something to be aware of. Don't declare things static if you don't have to.

The final option is for sumarrays to allocate the memory for total dynamically (as in haccks' and merlin2011's answers). That avoids the re-entrancy issue, but now you have to deal with memory management. C isn't your mother and won't clean up after you, so any memory you allocate with malloc or calloc you have to release with free².

^{1. Logically speaking, anyway; the memory is obviously still there, but it's been made available for the rest of the system to use, and has been overwritten in the time it took for your program to return to the main function.

2. Most platforms will reclaim dynamically allocated memory when the program exits, but a few (admittedly older, oddball platforms) may not. Also, for long-running programs (servers, daemons, etc.), you have to be very careful to release any memory you allocated and no longer need, otherwise you will eventually run out.}

A great response. I'm quite aware of the problem with "magic numbers" and avoid them in longer pieces of code, but a short experiment like this I don't bother. I think the potential problems with malloc() are worse than those with static, but it's been a while since I've looked into it. I will do so very soon.

haccks · Accepted Answer · 2014-06-30 17:43:24Z

1

You can't return a pointer to an automatic local variable. total is an automatic local variable and it doesn't exist after function body executed.

Pointer to static local variable or dynamically allocated variable can be returned. Change
int total[10]; to

int *total = malloc(10 * sizeof(int));

answered Jun 30, 2014 at 17:43

haccks

107k28 gold badges181 silver badges274 bronze badges

Comments

ryyker · Accepted Answer · 2014-06-30 18:57:38Z

0

I agree with every other answer regarding automatic (stack) and heap memory. All good approaches, however global variables on the stack are also an option. It is important to note that it was not that you chose to use stack memory, but that it was also local in scope. Locally scoped automatic variables die when the function that created them returns. However, globally scoped variables, also stored using stack memory, live for the duration of your program, and therefore provide an alternative approach to solve your problem...

A one line change will result in your code running, change your local copy of total (automatic scope) to a global:

int total[10];//Put this here,  outside of any function block in same file, i.e. (will give it global scope)
//note, commented this in function below

int *sumarrays(int arr1[], size_t arr1len, int arr2[], size_t arr2len) {
    int i;
    //int total[10];//move this to global scope


    for (i = 0; i < 10; i++) {
        total[i] = *(arr1 + i) + *(arr2 + i);

    }
    for (i = 0; i < 10; i++) {
        printf("%d\t", total[i]);
    }

    printf("\n");
    return total;
}

With this approach, global scope of variable allows your return to be successful. The array total keeps it's existence on stack until program exits.

edited Jun 30, 2014 at 18:57

answered Jun 30, 2014 at 18:31

ryyker

23.2k3 gold badges46 silver badges96 bronze badges

1 Comment

Clifford Over a year ago

sumarrays returns a pointer to total - total never "exists on the stack" in this case. If total is not referenced outside the single translation unit, its scope should be reduced by declaring it static (static linkage as opposed to static storage class). Generally truly global variables having external linkage should be discouraged.

Collectives™ on Stack Overflow

Returning Array from function in C

5 Answers 5

Comments

2 Comments

1 Comment

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

2 Comments

1 Comment

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related