CODEWITHSUNDEEP
carrayspointers
TridentineMass
TridentineMass

Reputation: 19

How to properly sum the elements of an array w/out getting large random outputs

I wrote two functions and call the functions in main.

Function 1 – I wrote a function that returns void and takes an int * (pointer to integer array) or int[], and int (for the size). The function needs to initialize all the elements of the array to non-zero values.

Function 2 – I wrote another function that returns int and takes an const int * (pointer to integer array) or int[], and int (for the size). The function should sum all the elements of the array and return the sum.

In main I defined an integer array of size 5. Called function 1 in main to initialize the values of the array. Called function 2 in main to get the sum and print the value of the sum to the console.

My problem is the program runs but the print out for sum we are getting is a large (in the millions), random, number and is not the expected answer of 15. Anyone who can help us get the correct answer would be greatly appreciated 

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#pragma warning(disable: 4996)

void func1(int* ptr, int size);
int func2(const int* ptr, int size);

int main()
{
    int grid[5];

    func1(grid, 5);
    func2(grid, 5);
}

void func1(int* ptr, int size)
{
    *ptr = 1, 2, 3, 4, 5;
}

int func2(const int* ptr, int size)
{
    int sum;

    sum = ptr[0] + ptr[1] + ptr[2] + ptr[3] + ptr[4]; // *(ptr + 0); putting an asterisk makes it so that it changes the entire "ptr" value and the "[0]" value

    printf("\n\nThe sum of the integers in the array is %d.\n\n", &sum);
}

Upvotes: 1

Views: 866

Answers (2)

paxdiablo
paxdiablo

Reputation: 881103

*ptr = 1, 2, 3, 4, 5;

does not do what you think it does. It actually evaluates all the integer constants but sets ptr[0] to be 1 (see comma operator for more detail), leaving all the others at some arbitrary value.

Note that it is not evaluating *ptr = (1, 2, 3, 4, 5) (which would set *ptr to 5) but is actually evaluating (*ptr = 1), 2, 3, 4, 5 - this works because something like 42 is actually a valid C statement, albeit not very useful.

If you're trying to set the array to increasing values, just use something like:

for (int i = 0; i < size; i++)
    ptr[i] = i + 1;

You probably also want to do that when summing the values since it should depend on the passed-in size rather than just summing five values:

int sum = 0;
for (int i = 0; i < size; i++)
    sum += ptr[i];

Additionally, the value you are printing out is not the sum, it's the address of the variable containing the sum (a decent compiler will warn you about this). You should be using sum in your printf rather than &sum.

And, as a final note, the signature for func2 indicates that you should actually be returning the sum rather than just printing it. So I would suggest removing the printf from that function and simply doing:

return sum;

Then you can put the printf into the caller (main) as follows:

int main(void)
{
    int grid[5];

    func1(grid, sizeof(grid) / sizeof(*grid));
    int sum = func2(grid, sizeof(grid) / sizeof(*grid));
    printf("The sum of the integers in the array is %d.\n\n", sum);
    return 0;
}

Note the use of sizeof(grid) / sizeof(*grid), which is basically the number of array elements in grid - this will allow you to resize grid by simply changing it in one place to something like int grid[42] and still have all the code work with the updated size.

Not actually necessary for your code but it's best to get into good programming habits early (more descriptive names for your functions may also be a good idea).

Upvotes: 4

dage5
dage5

Reputation: 96

Line *ptr = 1, 2, 3, 4, 5; assigns ptr[0] value and leaves other spots unitilized so when you sum it, it will be random memory.

You should use for like this to initialize

   for(int i=0;i<size;i++)
   {
          ptr[i] = i+1;
   }

and similiar aproach to sum it.

Upvotes: 2

Related Questions