如何在旅途中将地址中的值分配给指针？

Question

Causes a segmentation fault:

int n;
int *variable = scanf("%d",&n);
printf("Printing :%d",*variable);

No problem:

int n;
scanf("%d",&n);
int *variable = &n;
printf("Printing :%d",*variable);

How to achieve the first one without the segmentation fault?

Answer 1

Assuming scanf was successful, it returns 1 (in general it returns the number of variables that were set).

In your second snippet you discard that (useful) information, and you are setting a pointer varaible to the address of n , which is perfectly valid. (If scanf returned 0 then n would be uninitialised, and the behaviour of your printf call undefined .)

In the first snippet you set a pointer to the int constant 0 or 1 depending on the return value of scanf . That's fine too, but the behaviour on dereferencing that pointer with

*variable

is undefined .

If you want to be flashy, and have a robust conversation with your code reviewer, you could use the expression separator operator and write

int n;
int *variable = (scanf("%d",&n), &n);

but that's naughty since, again, you discard the return value of scanf , and n could be uninitialised.

Answer 2

scanf("%d",&n); returns integer not pointer to integer. Below is the prototype of scanf.

int scanf(const char *format, ...);

When you point like below you are actually pointing to invalid address and it will lead to undefined behavior.

int *variable = scanf("%d",&n);

Answer 3

When you declare and initialize the pointer you assign the value to the pointer itself. The * is needed to show the compiler that you are declaring the pointer to the object of some type not the object itself

When you use the * later in the code you dereference that pointer.

void foo(void)
{
   int a;
   int *b = &a;     //you assign the pointer `b` itself - no dereferencing

   *b = 5;          //you dereference the pointer and asssign the the referenced object
}

The "fresh" declared pointer (unless initialized with the reference to the valid object) does not point to the valid object and its dereferencing invokes the Undefined Behavior

void foo(void)
{
   int a;
   int *b = &a;     //b is pointing to the valid object -> the variable `a`
   int *c;     //c is not pointing to valid object
   int *d;     //d is not pointing to valid object

   c = malloc(sizeof(*c));     //now c is pointing to the valid object (if malloc has not failed of course)
   *c = 5      // correct no UB
   *d = 5;         // incorrect - UB


   *b = 5;          //correct no UB 
}

the syntax is similar (the * before the pointer name) but it does something completely different. I have noticed that it is a bit confusing for the beginners