Home > Articles

Variables and Constants

  • Print
  • + Share This
This chapter is from the book

Hour 3: Variables and Constants

What You'll Learn in This Hour:

  • How to declare and define variables and constants
  • How to assign values to variables and manipulate those values
  • How to write the value of a variable to the screen

What Is a Variable?

From a programmer's point of view, a variable is a location in your computer's memory in which you can store a value and from which you can later retrieve that value.

To understand this, you must first understand a bit about how computer memory works. Your computer's memory can be thought of as a series of cubby holes, all lined up in a long row. Each cubby hole—or memory location—is numbered sequentially. These numbers are known as memory addresses.

Variables not only have addresses, they have names. For example, you might create a variable named myAge. Your variable is a label on one of these cubby holes so that you can find it easily, without knowing its actual memory address.

Figure 3.1 is a visual representation of this idea. As you can see from the figure, we've declared a variable named myVariable. myVariable starts at memory address 103.

Figure 3.1Figure 3.1 A visual representation of memory.

What Is RAM?

RAM is Random Access Memory. It is the electronic memory your computer uses while executing programs. Any information in RAM is lost when your computer is turned off. When you run your program, it is loaded into RAM from the disk file (hard drive storage). All variables are created in RAM as well. When programmers talk of memory, it is usually RAM to which they are referring.

Setting Aside Memory

When you define a variable in C++, you must tell the compiler not only what its name is, but also what kind of information it will hold: integer, character, and so forth. This is the variable's type. Another word for type that you may see is datatype. The type of the variable tells the compiler how much room to set aside in memory to hold the variable's value.

Each cubby is one byte large. If the type of variable you create is two bytes in size, it needs two bytes of memory, or two cubbies. The type of the variable (for example, int) tells the compiler how much memory (how many cubby holes) to set aside for the variable. Because computers use bits and bytes to represent values, and because memory is measured in bytes, it is important that you understand and are comfortable with these concepts.

Size of Integers

A char variable (used to hold characters) is most often one byte long. A short int is two bytes on most computers; a long int is usually four bytes, and an int (without the keyword short or long) can be two or four bytes. If you are running Windows 95/98, Windows XP, or Windows NT/2000/2003, you can count on your int being four bytes as long as you use a modern compiler.

But you should not count on that being true on your system—check. You are assured that the size of a short int will be smaller than or the same as the size of an int, and that the size of an int will be the same or smaller than the size of a long. Floating point data types are another story entirely and will be discussed shortly.

Listing 3.1 will help you determine the exact size of these types on your computer using your particular compiler.

Listing 3.1 -sizer.cpp Determines the Size of Variable Types on Your Computer

 0: #include <iostream>
 1: 
 2: int main()
 3: {
 4:   std::cout << "The size of an int is:\t\t";
 5:   std::cout << sizeof(int) << " bytes.\n";
 6:   std::cout << "The size of a short int is:\t"; 
 7:   std::cout << sizeof(short) << " bytes.\n";
 8:   std::cout << "The size of a long int is:\t";
 9:   std::cout << sizeof(long) << " bytes.\n";
 10:   std::cout << "The size of a char is:\t\t";
 11:   std::cout << sizeof(char) << " bytes.\n";
 12:   std::cout << "The size of a bool is:\t\t";
 13:   std::cout << sizeof(bool) << " bytes.\n";
 14:   std::cout << "The size of a float is:\t\t";
 15:   std::cout << sizeof(float) << " bytes.\n";
 16:   std::cout << "The size of a double is:\t";
 17:   std::cout << sizeof(double) << " bytes.\n";
 18: 
 19:   return 0;
 20: }

Output

The size of an int is     4 bytes.
The size of a short int is   2 bytes.
The size of a long int is   4 bytes.
The size of a char is     1 bytes.
The size of a bool is     1 bytes.
The size of a float is     4 bytes.
The size of a double is    8 bytes.

Your Results May Vary

On your computer, the number of bytes presented might be different!

Analysis

Most of Listing 3.1 should be familiar. The one new feature is the use of the sizeof() function in lines 5 through 15. sizeof() is provided by your compiler, and it tells you the size of the object you pass in as a parameter. For example, on line 5 the keyword int is passed into sizeof(). Using sizeof(), I was able to determine that on my computer, an int is equal to a long int, which is four bytes.

signed and unsigned

In addition, all these types come in two varieties: signed and unsigned. Sometimes you need negative numbers, and sometimes you don't. Integers (short and long) without the word "unsigned" are assumed to be signed. signed integers are either negative or positive. unsigned integers are always positive. Remember: signed is the default for integer variables.

Because you have the same number of bytes (and therefore the number of bits) for both signed and unsigned integers, the largest number you can store in an unsigned integer is twice as big as the largest positive number you can store in a signed integer. An unsigned short integer can handle numbers from 0 to 65,535. Half the numbers represented by a signed short are negative, thus a signed short can only represent numbers from –32,768 to 32,767.

Bit for signed and unsigned Integers

For signed integers, one bit is used to handle the sign itself; for unsigned that bit is used for more numbers. If you counted all the possible numbers available in signed and unsigned, you would find that you have the same count. The difference is how they are represented!

Fundamental Variable Types

Several other variable types are built into C++. They can be conveniently divided into integer variables (the type discussed so far), floating-point variables, and character variables.

Floating-point variables have values that can be expressed as fractions—that is, they are real numbers. Character variables hold a single byte and are used for holding the 256 characters and symbols of the ASCII and extended ASCII character sets.

The ASCII character set is the set of characters standardized for use on computers. ASCII is an acronym for American Standard Code for Information Interchange. Nearly every computer operating system supports ASCII, though many support other international character sets as well.

The types of variables used in C++ programs are described in Table 3.1. This table shows the variable type, how much room this book assumes it takes in memory, and what kinds of values can be stored in these variables. The values that can be stored are determined by the size of the variable types, so check your output from Listing 3.1.

Table 3.1 Variable Types

Type

Size

Values

unsigned short int

2 bytes

0 to 65,535

short int

2 bytes

–32,768 to 32,767

unsigned long int

4 bytes

0 to 4,294,967,295

long int

4 bytes

–2,147,483,648 to 2,147,483,647

int

4 bytes

–2,147,483,648 to 2,147,483,647

unsigned int

4 bytes

0 to 4,294,967,295

char

1 byte

256 character values

bool

1 byte

true or false

float

4 bytes

1.2e–38 to 3.4e38

double

8 bytes

2.2e–308 to 1.8e308


Although many consider it poor programming practice, you can use a char variable as a very small integer.

  • + Share This
  • 🔖 Save To Your Account