为什么地址运算符（＆）对于通过函数传递的数组很重要？

Question

I am having trouble understanding how the & operator works and its importance.

I found this example online:

 #include <stdio.h>

void main()
{
  int a = 10;
  printf("\nValue of n is : %d" ,n);
  printf("\nValue of &n is : %u", &n);
}

Output :

Value of  n is : 10
Value of &n is : 1002

Firstly, why does the &n print out those two extra numbers?

Secondly, why is this important?

Answer 1

The & operator is the "address of" operator. so &a means the address of a , not just the value of a.

What this is telling you is that the address of a is 1002 (or as dreamlax pointed out, quite possibly not the real address due to oddities with how printf is being used), even though the value is 10 . Note that there is no strict correlation between the two values, you could just as easily have a=121765 and &a=494260 .

Knowing the address of a variable allows you to manipulate that specific value/object the variable is "referring" or "pointing" to. If you wish for a function to manipulate that specific value/object rather than manipulate a copy, you should pass the variable's address.

Take the following code (not necessarily complete code):

int main(void)
{
    int a = 10;
    doIt(a);
    printf("after doIt: %d", a);
    doItByReference(&a);
    printf("after doItByReference: %d", a);
}

void doIt(int val)
{
    val = 13;
}

void doItByReference(int *val)
{
    *val = 15;
}

Calling doIt passes the value held by a , and a new integer variable at a different address gets that value copied into it. The function is free to make any changes to this duplicate copy and no modifications will be seen in the original a variable.

However, calling doItByReference passes the address of a . Any changes made to the value at the given address will reflect as changes made to a .

This by itself is useful if you want to make changes to a given object and have those changes be reflected in the original copy. However, even if you don't want to modify a value in the original copy this is useful performance wise because you avoid having to copy any values. For a simple int which may be say 4 bytes (exact value isn't important), this is insignificant.

However, say you had a struct which was thousands or millions of bytes:

struct LargeStruct
{
    int buffer[134217728];
};

void doIt(LargeStruct buffer)
{
    // ... do something
}

void doItByReference(LargeStruct *buffer)
{
    // ... do something
}

This time, every call to doIt will have to copy the entire LargeStruct object which is millions of bytes, where-as a call to doItByReference simply uses the existing object and no copy is required.

Answer 2

n is a variable. It represents a value.
&n is a reference to n. It represents the address in memory where n is store.

As to why it is important:

When you pass an array in C, the function is usually expecting a pointer. (ie: int* as opposed to just int).
If you were to pass 'n' to the function, it would complain when compiling because the types don't match up (n=int, function expects int*).
If you pass in &n, however you are passing in an address to 'n' which is what the function expects.

Answer 3

To print out an address in C, you normally should use %p in stead of %u .

Note %p prints out address in hexadecimal number.

Answer 4

The address of operator, & , returns the memory address of the following variable. This is important because:

1. it allows referring to large memory chunks (structures, arrays, dynamically allocated unstructured memory regions) with a light weight handle

2. it provides means to access internal representations of data structures

3. it allows us to process different types of data through the same interface