Declaring Variables in C++

A program that needs data from the user has to pull that data from somewhere. In C++, the place it pulls from is the standard input stream, and the tool that moves data out of that stream and into a variable is the >> operator. Starting from a concrete question makes the rest of the article easier to follow: when a program reads a number into a variable, what decides which value ends up stored there, and how would you find the line responsible if the stored value were wrong?

Before a program can use a piece of data, it needs a way to refer to that data by name. A variable is the everyday tool for this, and declaring a variable is the step that brings it into existence in the program. This article moves in small steps. First you will watch a read move data from the input stream into a variable. Then you will see what a declaration supplies and what the program holds in memory once that declaration has happened. Each step is a change in state, so you can see what is present before and after it.

Think of a single read as a path with four stations. Characters arrive on the standard input. The cin stream holds them. The >> operator takes what the stream provides. The target variable is the place where the result is kept. The variable is the only station on this path that changes as a result of the read. The stream is not emptied into a new place in your program; the operator transfers what it takes into the variable.

The statement is read from left to right the way the operator suggests. The stream cin is the source, the operator >> is the transfer, and the variable named on the right is the target. Here the stream is always written on the left and the destination on the right. Many beginners expect assignment to flow from right to left, so this layout can feel reversed at first. Keeping the direction straight is the first habit to build.

The most important fact about >> is that the type of its right-hand operand determines two things at once: what kind of input is accepted, and what the target of the input operation is. The operator does not have one fixed behavior. It reads according to the variable you give it. The same statement form, cin >> something, can read an integer or a floating-point number depending on how that something is declared.

Setting the two reads side by side makes the pattern clear. The operator and the stream are identical in both cases. Only the target type changes, and with it the kind of number that the read accepts. This is why the declared type of the variable is the first thing to check when a read looks wrong: it governs what the >> operator will attempt to accept.

The source uses a pair of reads that combines both target types. Work through them as a trace, one line at a time, asking at each step what the operator is reading from and what it is writing into. The trace below uses the declarations and input from the previous section.

A declaration does two jobs at once. The first job is to introduce a name, so that the rest of the program can refer to the entity by that name. The second job is to specify a type, so that the entity has a defined kind. The type tells the program which values the entity can hold and which operations can be performed on it.

The source material gives a concrete case: a declaration specifies that inch is of type int. In other words, inch is an integer variable. The name is inch, the type is int, and the declaration tells the program that anything called inch holds integer values. Declaring int inch; creates an integer variable called inch.

Read the statement as two pieces of information. The word int names the type, and the word inch names the entity. Swapping the order, or leaving out the type, would not give the same meaning, because the type is what the declaration is required to specify.

These four terms describe different parts of what a declared name refers to. The variable is a named object. The object holds a value. The value is a set of bits, and the type determines how those bits are interpreted. Reading the connections from the variable name downward gives the chain from name to meaning.

The declaration itself does not describe the stored bits. It establishes the name and the type. The memory and its value belong to the object the name refers to, and the type determines how that value is read.

Trace the program's state across the declaration of inch. Before the declaration, the program has no entity called inch, so the name is not yet available for the rest of the program to use. After the declaration, the name inch refers to an integer variable, which is an object with a type. The new named entity is the element that has changed.

Notice what this diagram does not show. The declaration establishes the name and the type. The bits themselves are part of the object that the name refers to, and their meaning comes from the type. A declared variable therefore exists as a named, typed object before any read gives it a value.

Most errors with the >> operator come from reading its direction or its target incorrectly. The following mistakes are the ones to check first when a read seems to produce the wrong result.

When the trace for a program disagrees with your prediction, the goal is to locate the statement where the two first part ways. For reads with the >> operator, the most useful sequence is fixed and short.