We use ampersand during user input but Why we don't need this during assignment in C?

Question

We use ampersand(&) operator during user input. It means we are assigning the particular value to the memory address of the particular variable. But during assignment of a value, we don't need ampersand. How is the value being passed without any memory address specification? Sample code is given below.

#include<stdio.h>

int main()
{
    int a, b, total;
    scanf("%d%d", &a, &b); //& for memory address
    total = a+b;           //how the value is being tranfarred to total without any memory address?   
    printf("%d", total);

    return 0;
}

Answer 1

The scanf function has to access the object into which a value is being read. All C function arguments are passed by value, so if you wrote

int a, b;
scanf("%d%d", a, b); // THIS IS WRONG

the scanf function would only be able to see the values of a and b as they were when the function was called. It would have no way to modify a.

Assignment requires an lvalue as its left operand. An lvalue (to simplify slightly) is an expression that designates an object; the name of a variable is the most common kind of lvalue. Since the assignment operator = is built into the language, it can have special rules that apply to it. In particular, the lvalue on the LHS of the = identifies the object being assigned to; it doesn't yield the (previous) value of that object. That's how assignment is defined by the language.

For example, if you write:

a = b;

both a and b are lvalues, but they're treated differently because of their context. a refers to the object whose name is a. b also refers to an object, but in that context it yields the current value of that object.

If assignment were implemented as a function call, it would have to take the address of the object being assigned to:

int assign(int *lhs, int rhs);
assign(&a, b);

The language could have required an address for the LHS of an assignment, but allowing just the name of the target object is much more convenient.

(To explain the simplification above, the current standard's definition of lvalue is "an expression (with an object type other than void) that potentially designates an object". The word "potentially" is there because, for example, *ptr where ptr is a pointer is an lvalue even if the current value of ptr is NULL. Being an lvalue is a compile-time concept. Attempting to assign a value to *ptr is legal, but has undefined behavior.)

Answer 2

Assignment is a C language construct.

C knows that an assignment doesn't work with the value of its left hand side operand but rather with its address*. You don't need to say & explicitly.

With user-defined functions, and especially prototypeless old-style functions (unspecified argument types) and variadic functions like scanf, C can't know what they want -- they might want the address or they might equally well want the value and so you have to specify that by prepending or not prepending the ampersand.

Now with a prototyped function like:

void take_address(int *x);

you could theoretically extend the language so that

void use_take_address(void){ int x=42;  take_address(x); }

would implicitly take the address of the argument (C++ does something like that with references, after all), but it would, arguably, harm readability.

With &x you can be sure that the function can at least theoretically modify x; without & you can be more or less sure it can't (unless x is an array).

It's a language design choice.

---

*This is actually not 100% accurate. An assignment might as well be working with a register-based variable that does not have an address and using & on a variable in C actually disqualifies it from being explicitly markable with register, but those are details that a good optimizer can get past.

Answer 3

Variables are an abstract unit that has addresses associated with it. Variables declared with syntaxes such as int var represent a value located on the particular address &var.

scanf expects POINTERS to variables, i.e address, which is why you use the ampersand. This is needed because when you pass variables to functions (without the ampersand), you only pass their value, not the address information of the actual variable. Some people like to say that when you pass a variable to a function, the function takes "a copy" of the value of the variable.

If you want to decalre pointers (variables that represent addresses of their particular type, instead of values) you do it as such: int* var; This variable will be used to try to access another variable of type int, by assigning its address to it. int* var = &some_int

Take for example the following scenario. You want to make a function that stores some value in a variable passed to it. To do that you must define your function like that:

void foo (int* var)
{
*var = 1; // * is the de-reference operator which shows the value of the address `var` and we assign the value to 1.
}