Got a problem with scanf. The code is below. The problem exactly is
such:

As I understand, pointer is the variable, which hold address of other
object as a value. Because of it, one can call scanf without & in
string args.

Imagine, that &a[0] is 0xbffffdd4. When I call scanf("%s", a), it uses
0xbfffdd4 as address (the value of a). Is everything correct beyond
this point ?

OK. Now I call read_store_binary(a); a is a char*, so it is going into
function by value.  It's ok, 'cause the value of the pointer is the
address it is _pointing to_. So, in call to read_store_binary(a),
formal argument s becomes s == 0xbffffdd4 (Confirmed by GDB); So, as I
understand it is pointing to _the same_ memory location as a in
main(). Of course the address of s itself (&s) will be different from
a. Everything okay beyond this point ?

Let's continue. The dragon is in call to scanf() in
read_store_binary(). After that call, the s pointer points somewhere
to 0xbffffd90, and scanf() return "non 1".

I looked through the C faq and did some googling, but it seems i can't
figure out why scanf() behaviour is such. Please help me.

I use Redhat 5.2
x86 linux 2.0.36
gcc version 2.7.2.3
glibc version 2.0.7-29

<-- Cut here -->
#include <stdio.h>
#include <stdlib.h>
#define INTBITS 8 * sizeof(int)
void read_store_bin(char *s);

int main(void)
{
        char a[ INTBITS + 1];
        char b[ INTBITS + 1];

        printf("a: %p\n", a);
        printf("&a: %p\n", &a);
        printf("&a[0]: %p\n", &a[0]);

        read_store_bin(a);
        read_store_bin(b);

        /* processing ... */

        return 0;

        sprintf(fmt, "%%%d[01]", INTBITS);
        printf("Input binary value(up to %d bits).\n", INTBITS);
        if (scanf(fmt, s) != 1) {       /* DRAGON HERE ! */
                fprintf(stderr,"Non-binary value.\n");
                exit(1);
        }

   int x;
   char s[123];

   scanf ("%d %s, &x, s);

As you can see the important thing is not the '&', but the fact that an
address is passed, conforming to the format string:

"%d" -> (int *)
"%s" -> (char *)

In that case, and according to the definitions given by the standard, 's' is
a short form for 's + 0' or '&(*(s + 0))' or '&s[0]'.

#define INTBITS (8 * sizeof(int))
or
#define INTBITS (CHAR_BIT * sizeof(int))

(not fully portable, but it's not the point)

      printf("a: %p\n", (void*) a);

void read_store_bin (char const *s)

       "%16[01]"

sounds weird... What do you want exactly?

What pointer variables (or parameters) do enable is passing
different addresses, incuding different arrays, at different times;
or passing the address of a scalar without using & in the call,
but only if it was previously taken with & and stored.

It is the SECOND call to read_store_binary, with argument b,
where the scanf() fails, reaching the printf("Non-binary value"),
and now the value of s is &b[0], which is different from &a[0].
This second scanf fails because the \n left after the first value
was entered and parsed does not match %[01], and %[ and
%c unlike other scanf specifiers do not skip whitespace.
FAQ 12.18.  If I enter 2*INTBITS contiguously on the first
input line, BEFORE the second prompt, it "works".

Aside: we don't call problems or errors "dragons" in English.
But it was obvious enough what you intended.

...

...

I applied all (i hope) recomendations to my source. Here is final
version. And it's working for me. Any suggestions? Comments?

I really tried hard.

Thanks,
Oleg

<-- Cut here -->
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

/* macros are tricky :) CHAR_BIT is more portable, than '8' */
#define INTBITS (CHAR_BIT * sizeof(int))

void read_store_bin(char *s);

int main(void)
{
        char a[ INTBITS + 1];
        char b[ INTBITS + 1];

        /* Pointer of type pointer-to-T (array first element), FAQ 6.12*/
        printf("a: %p\n", (void*) a);

/* Pointer-to-array-of-T (entire array), FAQ 6.12*/
        printf("&a: %p\n", (void*) &a);      

        /* Ponter of type pointer-to-T (first element) ?? */
        printf("&a[0]: %p\n", &a[0]);

        read_store_bin(a);
        read_store_bin(b);

        /* processing ... */

        return 0;

        /* Limit input to characters 0 and 1. Maximal character count is
        number of bits in int on _that_ machine */
        sprintf(fmt, "%%%u[01]", (unsigned)INTBITS);

        printf("Input binary value(up to %u bits).\n", (unsigned) INTBITS);

        /* problem were here (due to lack of '\0' in format string)!
         it went away now, though :)*/

        if (scanf(fmt, s) != 1) {                      
                fprintf(stderr,"Non-binary value.\n");
                exit(1);
        }
        /* if got so far,  kill line */
        while (getchar() != '\n') ;

<Borland C memory 'SMALL'>

a: FFE4
&a: FFE4
&a[0]: FFE4
Input binary value(up to 16 bits).
0101
Input binary value(up to 16 bits).
012

(sounds that the scanf() with the '[01]' thing is broken. I don't use
scanf(). Too tricky for me).

<Borland C memory 'LARGE'>

a: 8FEC:0FEE
&a: 8FEC:0FEE
&a[0]: 8FEC:0FEE
Input binary value(up to 16 bits).
0101
Input binary value(up to 16 bits).
012

<DJGPP>

a: 0253FDF8
&a: 0253FDF8
&a[0]: 0253FDF8
Input binary value(up to 32 bits).
0101
Input binary value(up to 32 bits).
012

As you can see, portability issues is not just a mind game. It's a reality.

- You can say in advance how will the pointers value be displayed
- The sizeof an int is changing with the implementation (on the same
machine, I insist)

sizeof (T) returns the number of bytes of an object of type T, not a number
of bits, because some of them could be used for other purposes (trap
representation for example).

The effective range of the plain types in your implementation is defined in
<limits.h>

INT_MIN
INT_MAX
etc.

regardless their width in number of bits.