What does the C compiler do with different types of declarations?

I understand thi开发者_Python百科s:

int i = 3;  // declaration with definition

It tells the compiler to:

1. Reserve space in memory to hold integer value.
2. Associate name with memory location.
3. Store the value 3 at this location.

But what does this declaration tell the compiler:

int i;  // declaration

The declaration tells the compiler to reserve space for the variable i and associate the name i with that space (your points 1. and 2.).

If i is a global variable it is initialized to 0.

If it is local the value of i is undefined (probably garbage, ie. some random value) and you should assign to it before reading it.

There are two cases: at file scope (i.e. for a global declaration), and in a function.

In a function, the declaration int i; does two things: it declares a variable called i whose type is int, and it reserves some storage in memory to put a value of type int. What it does not do is give the variable a value. The storage used by i will still contain whatever garbage was there before. You need to initialize the variable, i.e. assign a value to it, before you can read a value from it. Good compilers will warn you if you don't initialize the variable.

At file scope, int i also declares a variable called i. The rest depends on other things: this is known as a tentative definition. You can have multiple such declarations in your file. At most one of these is allowed to have an initializer, making it a full-fleged definition. If none of the declarations of i at file scope have an initializer, the declaration is also a definition, and there is an implicit initialization to 0. Thus:

int i;
/* ... more code ...*/
int i;

is valid, and i will be initialized to 0 (assuming these are the only declarations of i at file scope). Whereas:

int i;
int i = 3;

is also valid, and i will be initialized to 3 when the program starts.

In practice, at file scope, there's often a difference between leaving the initialization implicit and explicitly initializing to 0. Many compilers will store an explicit 0 in the binary, but let the operating system initialize implicit zeroes automatically when the program is loaded. Don't worry about this unless you have a large global array (which shouldn't happen often) or you work on tiny embedded systems.

It says to reserve space for an integer called i. As far as what is in there is up to the compiler and is undefined.

It does the same thing as your previous declaration:

1. allocates space on the stack for the integer
2. the compiler associates a name with the space (your running program won't do this, necessarily)
3. the integer is not initialized.

Others have pretty much answered the question, but I will mention two points that (I think ) haven't been mentioned so far:

int i;

defines i to be an int, with garbage in it (unless i is "global"). Such garbage might be a trap representation, which means that using it could be "bad":

A trap representation is a set of bits which, when interpreted as a value of a specific type, causes undefined behavior. Trap representations are most commonly seen on floating point and pointer values, but in theory, almost any type could have trap representations. An uninitialized object might hold a trap representation. This gives the same behavior as the old rule: access to uninitialized objects produces undefined behavior.

Also, int i; could also be a tentative definition, which means that you're telling the compiler: "i is an int, and I will define it later. If I don't, then define it for me.". Here is a very good explanation of why C has tentative definitions.

There are three kinds of memory for objects:

1) external (often called "global" but that really refers to scope). Objects here are created before running the program; 2) stack (created during run time); 3) heap (eg malloced).

"int i;" either creates the object in the external memory or on the stack. If it's in a function, it's created on the stack (if "static" isn't also used.

Objects created in external memory are initialized to zero if they are not explicitly initialized (e.g, "int i = 3";

You can create an external object in a function by using the "static" keyword.

int a; // external memory with "global" scope. Initialized to 0 implicitly.
static int b; // external memory with file (module) scope. Initialized to 0 implicitly.
int c = 3; // external memory initialized to 3.

f()
{
  int d; // created on the stack. Goes away when the block exits. Filled with random trash because there is no initialization.
  int e = 4; // stack object initialized to 3.
  static int f; // "f" is external but not global. Like all externals, it's implicitly initialized to zero.
  static int g = 3; // An external like f but initialized to 3.

}