I want to use only studio.h library to convert from decimal number to binary number by using an array to store remainder but the result is not correct, maybe i have problem with memory allocation or return value is wrong, please help me to check it.

Thank you so much!

``#include <stdio.h>int n = 0;int* DecimalToBinary(int number){int a[10];while(number!=0){a[n++] = number%2;number/=2;}return a;}void main(){int *d1 = DecimalToBinary(5);int *d2 = DecimalToBinary(10);for(int i = n-1 ;i>=0;i--)printf(" %d",d1[i]);printf("\n");for(int i = n-1 ;i>=0;i--)printf(" %d",d2[i]);}``

You are returning a pointer to a locally allocated array. It is allocated on the stack, and goes away when the function returns, leaving your pointer pointing to garbage.

You have a few options. You could pass an array in to fill:

``````void DecimalToBinary(int result[10],int number){
while(number!=0){
result[n++] = number%2;
number/=2;
}
return result;
}

// usage example:
int b[10];
DecimalToBinary(b, 42);
``````

Or you could allocate an array on the heap:

``````int* DecimalToBinary(int number){
int *a = (int *)malloc(sizeof(int) * 10);
while(number!=0){
a[n++] = number%2;
number/=2;
}
return a;
}

// usage example
int *b = DecimalToBinary(42);
free(b); // when finished with it
``````

Or you could wrap the array in a struct:

``````typedef struct {
int b[10];
} result;

result DecimalToBinary(int number){
result r;
while(number!=0){
r.b[n++] = number%2;
number/=2;
}
return r;
}

// usage example
result r = DecimalToBinary(42);
``````

If you do the malloc() option, do not forget to free() the returned data when you're done with it, otherwise it will hang around. This is called a memory leak. In more complex programs, it can lead to serious issues.

Note: By the way, if your number is larger than 1023 (10 binary digits), you'll overrun the array. You may also wish to explicitly stop once you've stored 10 digits, or pass the size of the array in, or compute the required size first and allocate that much space. Also, you will get some odd results if your number is negative, you might want to use `number&1` instead of `number%2`.

Note 2: As noted elsewhere, you should make `n` local, or at the very least reinitalize it to 0 each time the function is called, otherwise it will just accumulate and eventually you'll go past the end of the array.

You return a pointer to a local array. That local array is on the stack, and when the function returns the array goes out of scope and that stack memory will be reused when you call the next function. This means that the pointer will now point to some other data, and not the original array.

There are two solutions to this:

1. Declare the array in the function calling `DecimalToBinary` and pass it as an argument.
2. Create the array dynamically on the heap (e.g. with `malloc`) and return that pointer.

The problem with method 2 is that it might create a memory leak if you don't `free` the returned pointer.

As noted by Craig there is a third solution, to make the array `static` inside the function. However in this case it brings other and bigger problems than the two solutions I originally listed, and that's why I didn't list it.

There is also another serious problem with the code, as noted by Uchia Itachi, and that is that the array is indexed by a global variable. If the `DecimalToBinary` function is called with a too big number, or to many times, this global index variable will be to big for the array and will be out of bounds for the array.

Both the problem with dereferencing a pointer to an out-of-scope array and the indexing out of bounds leads to undefined behavior. Undefined behavior will, if you're lucky, just lead to the wrong result being printed. If you're unlucky it will cause the program to crash.

`int[10]` is not the same as `int *`; not only is the former created on the stack, it is a different type alltogether. You need to create an actual `int *` like so:

``````int *a = malloc (10 * sizeof (int));
``````

Of course, don't forget to `free()` it after use!

What you can also do and what is commonly done in C is creating the array where it is called and provide a pointer to that array to the function, this way when the array is on the stack of the function that calls it and not in the function self. We also have to specify the size of the array on to that function, since the function cannot know to how many elements the pointer points to

``````void DecimalToBinary( int number, int* output, unsigned size ) {
/*adapt this to your liking*/
int i;
for ( i = 0; i < size && number != 0; i++) {
output[i] = number%2;
number/2;
}
}
``````

and in you main function you would call it like this:

``````int array[10];
DecimalToBinary( 5, array, sizeof(array)/sizeof(array[0]));
``````

now array has the same result as `a` would have had in your example.

The problem in your code lies here..

``````int * DecimalToBinary(int number){
int a[10];
while(number!=0){
a[n++] = number%2;
number/=2;
}
return a;
``````

}

The array a scope is only till this function. Once this function terminates, the memory allocated for this array will be released, either u need to use dynamic memory allocation or make array a global.

This is the correct program:

``````#include <stdio.h>
int  n = 0;
int a[10] = {0};
int* DecimalToBinary(int number){
n = 0;
while(number!=0){
a[n++] = number%2;
number = number/2;
}
return a;
}

int main(){

int *d1;
int *d2;
int i;
d1 = DecimalToBinary(5);
for(i = n-1;i>=0;i--)
printf(" %d",d1[i]);
printf("\n");
d2 = DecimalToBinary(10);
for(i = n-1;i>=0;i--)
printf(" %d",d2[i]);
printf("\n");
}
``````

Top