5

I understand this:

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
Jonathan Leffler
  • 730,956
  • 141
  • 904
  • 1,278
user784276
  • 51
  • 1

6 Answers6

4

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.

sverre
  • 6,768
  • 2
  • 27
  • 35
  • 1
    It will contain a garbage value (from memory that was previously at that location). –  Jun 04 '11 at 21:13
  • AFAIK the value of `i` is equal to the number represented by the "garbage" (sequence of bits) that is at that specific space in the memory. – Matyas Jun 04 '11 at 21:15
  • 1
    You are assuming this is a local variable. If it's a global `i` will be 0. – Ben Jackson Jun 04 '11 at 21:20
  • 3
    @matyas, some implementations have bit patterns that don't represent a valid value. The only type that is guaranteed to represent all bit patterns for its particular width is `unsigned char`. – Jens Gustedt Jun 04 '11 at 21:30
  • 2
    At file scope, this is incomplete: `int i;` is a tentative definition, and `i` could be initialized to some other value if there's a definition with an initializer elsewhere. – Gilles 'SO- stop being evil' Jun 04 '11 at 21:50
  • There **are no global variables in C**. There are variables with file scope and external linkage. – Jens May 23 '12 at 13:13
3

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.

Gilles 'SO- stop being evil'
  • 104,111
  • 38
  • 209
  • 254
  • Tentative definitions must become real definitions by the end of the current translation unit. So, `int i;` in `a.c` followed by `int i;` in `b.c` is multiple definitions (and thus undefined behavior). GNU `ld` accepts this as long as the multiple definitions agree. (I think it also accepts this if the definitions don't agree, but I am not sure.) – Alok Singhal Jun 04 '11 at 22:02
  • @Alok: You're right. What I was describing was in fact the gcc behavior, which is an extension to the standard. Gcc (tried with 4.4, with or without `-ansi`) accepts `a.c` containing `int i;` and `b.c` containing `int i=3;`, but not `a.c` and `b.c` both containing `int i=3;`. – Gilles 'SO- stop being evil' Jun 04 '11 at 22:09
  • @Alok: This is not so much "gcc behavior" as the traditional Unix linker behavior. It's possible gcc on some targets (without GNU ld) doesn't support it, and of course it works on all traditional Unix-like targets whether you're using gcc or another compiler. – R.. GitHub STOP HELPING ICE Jun 05 '11 at 12:00
1

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.

Joshua Weinberg
  • 28,598
  • 2
  • 97
  • 90
0

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.
Marvo
  • 17,845
  • 8
  • 50
  • 74
0

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.

Community
  • 1
  • 1
Alok Singhal
  • 93,253
  • 21
  • 125
  • 158
0

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.

}
davep
  • 90
  • 2