Unable to send int array into a function in C - c

Question

I tried to write a function that performs binary search. the code I wrote is as follows:
int binarySearch (int num[], int value, int left, int right)
{
if (left > right)
return -1;
else
{
int middle = (left+right)/2;
if (num[middle] = value)
return middle;
else
{
if (value < num[middle])
return binarySearch(num, value, left, middle-1);
else
return binarySearch(num, value, middle+1, right);
}
}
return 0;
}
void main()
{
int num[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int result;
result = binarySearch(num,6,0,15);
printf("The result is: %d", result);
}
While trying to debug it I found out the num[] array doesn't being send into the function. When I look at the array outside of the function it contains 16 numbers. when I jump into the function with F11 the array that arr[] receives contains only 0. Nothing I try seems to solve it. Does someone understands what goes wrong?
Thank you very much,
Robert

Answer 1

In binarySearch function num acts as pointer. So, when you debug, it shows only first value (0) pointed by num.
If you want to pass a single-dimension array as an argument in a function, you would have to declare a formal parameter in one of following three ways and all three declaration methods produce similar results because each tells the compiler that an integer pointer is going to be received.
int func(int arr[], ...){
.
.
.
}
int func(int arr[SIZE], ...){
.
.
.
}
int func(int* arr, ...){
.
.
.
}
However, by mistake you did an assignment instead of comparison, in if (arr[middle] = value).
Thanks !!!

Answer 2

Arrays cannot be sent as function arguments in C. Arguments declared as array are converted to pointers that point at the element of array, according to N1570 6.7.6.3.
Arrays used in expressions are automatically converted to pointers pointing the first element of the array except for some exceptions such as operands of unary & operator and sizeof operator, according to N1570 6.3.2.1.
Therefore, the acutual type of arr is int* and it seems that the debugger recognized only the elemente pointed at directly by the pointer.

Answer 3

There are a few syntax errors that are stopping your code from working. (e.g. while loop has a ";" ignoring the loop content).
The biggest issue with your code is that you calculated the middle index incorrectly.
Incorrect:
middle = (left + right) / 2;
Correct:
middle = ((right - left) / 2) + left;
You need to subtract to get the actual distance between left and right, then divide by 2 to get the middle. Then add back to the smaller value to reach the middle between the left and right sides.
Here is your code with syntax fixed and a mid function to make things easier. Enjoy.
int mid(int min, int max) {
return ((max - min) / 2) + min;
}
int binarySearch(int value, int arr[], int left, int right)
{
int middle = mid(left,right);
while (left < right)
{
if (arr[middle] == value)
return middle;
if (value < arr[middle])
middle = mid(left, middle);
else
middle = mid(middle, right);
}
return -1;
}

Answer 4

You should just use the int * syntax in your function signature. C will handle this by passing a pointer to the first element of the array. In C, arrays are not passed like they are in Java or other high-level languages.
Note that you can still use the [] operator on a pointer, similarly to an array. In your example, you can refer to the 2nd element of the array by using this syntax:
int x = num[1]; /* get the second element of the num array */
This would be the updated function (copied "as is" from the original), with only changes made specific to the array usage:
int binarySearch (int *num, int value, int left, int right)
{
if (left > right)
return -1;
else
{
int middle = (left+right)/2;
if (num[middle] = value)
return middle;
else
{
if (value < num[middle])
return binarySearch(num, value, left, middle-1);
else
return binarySearch(num, value, middle+1, right);
}
}
return 0;
}
void main()
{
int num[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int result;
result = binarySearch(num,6,0,15);
printf("The result is: %d", result);
}
One additional thing that you typically need to do is pass the length of the array as a separate argument. This is so that the function can know how many elements are in the array. C does not automatically pass the array length the pointer to the first array element, so you have to take care of it manually.
The OP's code does not use the length of the array, so length is not added to that function signature. However, requiring access to the length of a C array and passing it to a function is so common that it bears an clear example. Consider this example function to sum the values of an array:
int summation_function(int * array, size_t length)
{
int sum = 0;
size_t i = 0;
for (; i < length; ++i) {
sum += array[i];
}
return sum;
}
To call summation_function, you can do something like this:
int values[] = {1,2,4,8,16,32};
int sum = summation_function(values, sizeof(values)/sizeof(int));
printf("Summation of the values [1,2,4,8,16,32] is %d\n", sum);
Note the use of this code in this example:
sizeof(num)/sizeof(int)
What this does is find the allocated number of bytes in the array (the sizeof(num)) and divide by the number of bytes in an int (the sizeof(int)). The result is the exact number of elements in the array. With this, you can avoid hard-coding array lengths. This code is idiomatic of C array handling, so it becomes second nature to understand it after the first few uses.