Need help - pointers

[Nezhate]

Hi There,
I'm writing a program that takes a decimal number and returns it's
binary equivalent.
the problem is that I don't know how to return (from function) the
binary value as an array of cocatenated characters. For example : I
want to convert number 3 using 4 bits, ie 3 <----"0011".
After executing, I'm getting this warning:
warning: return from incompatible pointer type
line:49: warning: function returns address of local variable

Here it is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int power (int base, int m);
char* dec2bin(int input, int m);

int main ()
{
int input = 0;
int m = 0;

printf("Number to convert\n");
scanf("%d", &input);
printf ("Number of bits\n");
scanf ("%d",&m);
printf("input %d is converted to %s\n",input,dec2bin(input, m));
exit (0);
}

char* dec2bin(int input, int m)
{
static int i = 0;
char* array[m+1];
int limit = 0;
limit = power(2, m);
const int MASK = limit/2; // the binary equivalent is: 1 + m 0 bits

array[m] = '\0';
for (i= 0; i < m ;i++)
{
if (input & MASK){
strcpy(array[i],"1");}
else{
strcpy(array[i],"0");}
input = input << 1;
}
return (array);
}

int power (int base, int m)
{
static int i;
int p=1;
for (i = 1; i <= m; ++i)
{
p =p * base;
}
return p;
}

[pete]

Nezhate wrote:

Hi There,
I'm writing a program that takes a decimal number and returns it's
binary equivalent.
the problem is that I don't know how to return (from function) the
binary value as an array of cocatenated characters. For example : I
want to convert number 3 using 4 bits, ie 3 <----"0011".
After executing, I'm getting this warning:
warning: return from incompatible pointer type
line:49: warning: function returns address of local variable

Here it is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int power (int base, int m);
char* dec2bin(int input, int m);

int main ()
{
int input = 0;
int m = 0;

printf("Number to convert\n");
scanf("%d", &input);
printf ("Number of bits\n");
scanf ("%d",&m);
printf("input %d is converted to %s\n",input,dec2bin(input, m));
exit (0);
}

char* dec2bin(int input, int m)
{
static int i = 0;
char* array[m+1];
int limit = 0;
limit = power(2, m);
const int MASK = limit/2; // the binary equivalent is: 1 + m 0 bits

array[m] = '\0';
for (i= 0; i < m ;i++)
{
if (input & MASK){
strcpy(array[i],"1");}
else{
strcpy(array[i],"0");}
input = input << 1;
}
return (array);
}

int power (int base, int m)
{
static int i;
int p=1;
for (i = 1; i <= m; ++i)
{
p =p * base;
}
return p;
}

This is the simplest fix
which only addresses the one issue raised by your compiler:

#include <limits.h>

char* dec2bin(int input, int m)
{
static int i = 0;
static char array[sizeof input * CHAR_BIT + 1];
int limit = power(2, m);
const int MASK = limit/2; // the binary equivalent is: 1 + m 0 bits

array[m] = '\0';
for (i= 0; i < m ;i++)
{
if (input & MASK){
array[i] = '1';
} else {
array[i] = '0';
}
input = input << 1;
}
return (array);
}

--
pete

[Richard Heathfield]

Nezhate said:

Hi There,
I'm writing a program that takes a decimal number

No such thing. Numbers are numbers. Decimal is a positional notation
system. Numbers can be represented in lots of different ways.

and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];
size_t b = sizeof n * CHAR_BIT;
size_t i = 0;

while(b-- 0)
{
bin[i++] = '0' + !!(n & (1 << b));
}

return bin;
}

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Iman S. H. Suyoto]

Richard Heathfield wrote:

Nezhate said:

>Hi There,
I'm writing a program that takes a decimal number

No such thing. Numbers are numbers. Decimal is a positional notation
system. Numbers can be represented in lots of different ways.

>and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];

CMIIW. If the + 1 is for the '\0' terminator, don't we need that
terminator there?

size_t b = sizeof n * CHAR_BIT;
size_t i = 0;

while(b-- 0)
{
bin[i++] = '0' + !!(n & (1 << b));
}

return bin;
}

[Richard Heathfield]

Iman S. H. Suyoto said:

Richard Heathfield wrote:

>Nezhate said:

>>Hi There,
I'm writing a program that takes a decimal number

No such thing. Numbers are numbers. Decimal is a positional notation
system. Numbers can be represented in lots of different ways.

>>and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];

CMIIW. If the + 1 is for the '\0' terminator, don't we need that
terminator there?

Yes, and it's there. From 3.5.7 (Initialization):

"If an object that has static storage duration is not initialized
explicitly, it is initialized implicitly as if every member that has
arithmetic type were assigned 0 and every member that has pointer type
were assigned a null pointer constant. If an object that has
automatic storage duration is not initialized explicitly, its value is
indeterminate."

Since the object in question has static storage duration, every member
thereof (less any that are explicitly initialised, which doesn't apply
here) is given the value 0. Note that the above passage also makes it
clear that the same guarantee does *not* apply to objects with automatic
storage duration. (It *would* apply, if the automatic object were partly
initialised - the Standard says this a few paragraphs further on.)

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[s0suk3]

On Aug 11, 6:07*am, Nezhate <ma************@gmail.comwrote:

Hi There,
I'm writing a program that takes a decimal number and returns it's
binary equivalent.
the problem is that I don't know how to return (from function) the
binary value as an array of cocatenated characters. For example : I
want to convert number 3 using 4 bits, ie 3 <----"0011".
After executing, I'm getting this warning:
warning: return from incompatible pointer type
line:49: warning: function returns address of local variable

Here it is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int power (int base, int m);
char* dec2bin(int input, int m);

int main ()
{
* int input = 0;
* int m = 0;

* printf("Number to convert\n");
* scanf("%d", &input);
* printf ("Number of bits\n");
* scanf ("%d",&m);
* printf("input %d is converted to %s\n",input,dec2bin(input, m));
* exit (0);

}

char* dec2bin(int input, int m)
{
* static int i = 0;
* char* array[m+1];
* int limit = 0;
* limit = power(2, m);
* const int MASK = limit/2; // the binary equivalent is: 1 + m 0 bits

* array[m] = '\0';
* for (i= 0; i < m ;i++)
* * {
* * * if (input & MASK){
* * * * strcpy(array[i],"1");}
* * * else{
* * * * strcpy(array[i],"0");}
* * * input = input << 1;
* * }
* return (array);

}

int power (int base, int m)
{
* static int i;
* int p=1;
* for (i = 1; i <= m; ++i)
* * {
* * * p =p * base;
* * }
* return p;

}

This are the alternatives for returning a string from a function:

- Declare the array to be static, as Pete and Richard Heathfield
did
- Use a dynamic memory allocation function to allocate the array,
but remember to free() the string when you no longer need it
- Declare the function to take a pointer to an array as an
argument, and perhaps an integer representing the maximum number of
characters the buffer can hold
- Make the function operate on a global variable (yuck, don't do
this)

I'd go with the second, since it doesn't retain unneeded memory.

Sebastian

[pete]

s0****@gmail.com wrote:

This are the alternatives for returning a string from a function:

- Declare the array to be static, as Pete and Richard Heathfield
did
- Use a dynamic memory allocation function to allocate the array,
but remember to free() the string when you no longer need it
- Declare the function to take a pointer to an array as an
argument, and perhaps an integer representing the maximum number of
characters the buffer can hold
- Make the function operate on a global variable (yuck, don't do
this)

I'd go with the second, since it doesn't retain unneeded memory.

The third would be my default choice.
That way an array with any kind of duration can be used,
and if it's allocated, then the allocation and freeing
can both be done in the calling function,
which is nice from an organizational point of view.

--
pete

[Martien Verbruggen]

On Mon, 11 Aug 2008 12:02:39 +0000,
Richard Heathfield <rj*@see.sig.invalidwrote:

Nezhate said:

>Hi There,
I'm writing a program that takes a decimal number

No such thing. Numbers are numbers. Decimal is a positional notation
system. Numbers can be represented in lots of different ways.

>and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)

Following to your own explanation, above, shouldn't this be called
int2bin(), or maybe num2bin()?

Something called dec2bin probably should have a prototype like:

char *dec2bin(char *dec);

Martien
--
|
Martien Verbruggen | I used to have a Heisenbergmobile. Every time
| I looked at the speedometer, I got lost.
|

[Ben Bacarisse]

Richard Heathfield <rj*@see.sig.invalidwrites:

Nezhate said:

>I'm writing a program that takes a decimal number

<snip>

>and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];
size_t b = sizeof n * CHAR_BIT;
size_t i = 0;

while(b-- 0)
{
bin[i++] = '0' + !!(n & (1 << b));

Warning: this is UB in C99 (a signed shift into the sign bit
position[1]). I presume it is OK in C90, but the wording seems vague
to me ("The result of E1 << E2 is E1 left-shifted E2 bit positions" is
all it says about shifts of signed types).

}

return bin;
}

[1] I am paraphrasing, of course (the result is defined only if 1
times 2 to the power b is representable as an int).

--
Ben.

[Barry Schwarz]

On Mon, 11 Aug 2008 04:07:24 -0700 (PDT), Nezhate
<ma************@gmail.comwrote:

>Hi There,
I'm writing a program that takes a decimal number and returns it's
binary equivalent.
the problem is that I don't know how to return (from function) the
binary value as an array of cocatenated characters. For example : I
want to convert number 3 using 4 bits, ie 3 <----"0011".
After executing, I'm getting this warning:
warning: return from incompatible pointer type
line:49: warning: function returns address of local variable

Here it is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int power (int base, int m);
char* dec2bin(int input, int m);

int main ()
{
int input = 0;
int m = 0;

printf("Number to convert\n");
scanf("%d", &input);
printf ("Number of bits\n");
scanf ("%d",&m);
printf("input %d is converted to %s\n",input,dec2bin(input, m));
exit (0);
}

char* dec2bin(int input, int m)
{
static int i = 0;
char* array[m+1];

This defines an array of pointers, not an array of char which you
need.

You have a C99 compiler which allows you to use variable length
arrays?

int limit = 0;
limit = power(2, m);
const int MASK = limit/2; // the binary equivalent is: 1 + m 0 bits

Not after you divide by 2. The binary equivalent has only m-1 zero
bits after the one.

>
array[m] = '\0';

This sets array[m] to NULL.

for (i= 0; i < m ;i++)
{
if (input & MASK){
strcpy(array[i],"1");}

This invokes undefined behavior. array[i] does not point to memory
you own. It was never assigned a value so it is indeterminate.

else{
strcpy(array[i],"0");}
input = input << 1;

Using this approach with a large input and 32 bit int will invoke
undefined behavior when a 1 bit is shifted into the sign bit.

}
return (array);

return is a statement, not a function. The parentheses are
unnecessary.

The expression array has type array of pointer to char. By rule, it
is converted to the address of the first element of the array with
type pointer to array element (essentially &array[0]). In this case,
element type is char* so the expression is converted to type char**.
char** is incompatible with the specified return type (char*) of the
function. And since array is an automatic variable in the function,
it ceases to exist once the function exits so any attempt by the
calling program to evaluate this address invokes undefined behavior.

>}

int power (int base, int m)
{
static int i;

What do you think the static buys you?

int p=1;
for (i = 1; i <= m; ++i)
{
p =p * base;
}
return p;
}

--
Remove del for email

[Richard Heathfield]

Martien Verbruggen said:

On Mon, 11 Aug 2008 12:02:39 +0000,
Richard Heathfield <rj*@see.sig.invalidwrote:

>>
char *dec2bin(int n)

Following to your own explanation, above, shouldn't this be called
int2bin(), or maybe num2bin()?

int2bin would be favourite, I suppose. But of course I was lazy enough to
retain the OP's function name rather than take the trouble to think about
it.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Richard Heathfield]

Ben Bacarisse said:

Richard Heathfield <rj*@see.sig.invalidwrites:

>Nezhate said:

>>I'm writing a program that takes a decimal number

<snip>

>>and returns it's binary equivalent.

Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];
size_t b = sizeof n * CHAR_BIT;
size_t i = 0;

while(b-- 0)
{
bin[i++] = '0' + !!(n & (1 << b));

Warning: this is UB in C99 (a signed shift into the sign bit
position[1]).

In 6.5.7(4), we have: "The result of E1 << E2 is E1 left-shifted E2 bit
positions; vacated bits are filled with zeros. If E1 has an unsigned type,
the value of the result is E1 × 2E2, reduced modulo one more than the
maximum value representable in the result type. If E1 has a signed type
and nonnegative value, and E1 × 2E2 is representable in the result type,
then that is the resulting value; otherwise, the behavior is undefined."

So yes, you're right, as a result of which I had another stab at this, but
fell foul of right-shifting an int (where the sign bit propagation is a
problem), and I thought about a couple of other approaches, but then I
decided it would be a lot easier just to drink my coffee and wake up
slowly. :-)

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Iman S. H. Suyoto]

Richard Heathfield wrote:

Iman S. H. Suyoto said:

>Richard Heathfield wrote:

>>Here's one way:

#include <limits.h>
#include <stddef.h>

char *dec2bin(int n)
{
static char bin[sizeof n * CHAR_BIT + 1];

CMIIW. If the + 1 is for the '\0' terminator, don't we need that
terminator there?

Yes, and it's there. From 3.5.7 (Initialization):

"If an object that has static storage duration is not initialized
explicitly, it is initialized implicitly as if every member that has
arithmetic type were assigned 0 and every member that has pointer type
were assigned a null pointer constant. If an object that has
automatic storage duration is not initialized explicitly, its value is
indeterminate."

Right. Sorry, I forgot about that.

Thanks, Richard.