Variable names with parameters [closed] - c

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 6 years ago.
Improve this question
So I have some code here that I have been studying. It converts decimal numbers to binary. The code runs smoothly but what's bugging me are the variables. The code is as follows:
#include <stdio.h>
int main()
{
long int decimalNumber, remainder, quotient;
int binaryNumber[100], i=1, j;
printf("Enter any decimal number: ");
scanf("%ld",&decimalNumber);
quotient = decimalNumber;
while (quotient!=0) {
binaryNumber[i++]= quotient % 2;
quotient = quotient / 2;
}
printf("Equivalent binary value of decimal number %d: ", decimalNumber);
for (j = i -1 ; j> 0; j--)
printf("%d",binaryNumber[j]);
return 0;
}
I really find the variables confusing. Can someone tell me what is actually happening with the variables? Especially the one with binaryNumber[100],binaryNumber[i++], binaryNumber[j], and the expression binaryNumber[i++] = quotient % 2

Answer 1

binaryNumber is an array of ints, i.e. of integers. It is of size 100. It goes from 0...99 (binaryNumber[0] is the first element and binaryNumber[99] is the last). The array can contain 100 integers, of different or equal values. They don't actually have to be of value 0...99 but anything else that is in the range of int (read comment).
When you perform int binaryNumber[100] you define this array.
When you perform binaryNumber[i++] you access the element in the location i of this array, and then increment i. Meaning you perform i = i + 1;.
Same goes for binaryNumber[j].
When you perform binaryNumber[i++] = quotient % 2 you assign the value of quotient % 2 to the binaryNumber array at position i like stated before (and increment i).
If you're wondering about the modulus operator (%) read here.

Answer 2

binaryNumber[100]: This is actually an array of 100 integers. The first integer in the array could be accessed by binaryNumber[0] etc.
binaryNumber[j]: This means the (j-1)th integer in the array.
binaryNumber[i++]: Lets say i=3 when this statement runs. binaryNumber[i++] is equivalent to binaryNumber[3], which is the 4th integer. However, after this statement is executed, i is incremented to 4.
quotient % 2:
% is actually the modulus operator. Example: 13 % 4 = remainder of 13/4 = 1.

Answer 3

binaryNumber[100] : it is an array , a sepuence of elements of type "long int" you can access a spesific element using "array[index] = value" .
binaryNumber[i++] : access the element nember i then increament i , example if i=1 then you acces binaryNumber[1] then i become 2 (after usage ).
binaryNumber[j] : access the element nember j , j is a variable and can be used as a index , then you will acces the element nember the current value of j .
binaryNumber[i++] = quotient % 2 : it tell the compiler to let the element nember i in the binaryNumber take the value of quotient % 2 that is the math modulos , like 9%2=1 ; 5%3=2 , the rest of the quotient pear 2
comment for more informations .

Answer 4

A simple way to do the conversion is a loop and shift. You can put it in a function to make the conversion look nice. Here is an example:
#include <stdio.h>
#include <stdlib.h>
#include <limits.h> /* for CHAR_BIT */
void binprn (const unsigned long v);
int main (int argc, char **argv) {
long unsigned a = argc > 1 ? strtoul (argv[1], NULL, 10) : 4327;
printf ("\n %lu decimal, binary: ", a);
binprn (a);
putchar ('\n');
return 0;
}
/** unpadded binary representation of 'v'. */
void binprn (const unsigned long v)
{
if (!v) { putchar ('0'); return; };
size_t sz = sizeof v * CHAR_BIT;
unsigned long rem = 0;
while (sz--)
if ((rem = v >> sz))
putchar ((rem & 1) ? '1' : '0');
}
Use/Output
$ ./bin/dec2bin
4327 decimal, binary: 1000011100111
$ ./bin/dec2bin 10
10 decimal, binary: 1010
$ ./bin/dec2bin 127
127 decimal, binary: 1111111