Creating Variables and Constants in C++
- What Is a Variable?
- Defining a Variable
- Assigning Values to Variables
- Using Type Definitions
- Constants
- Summary
- Q&A
- Workshop
- Activities
This chapter is from the book
This chapter is from the book
This chapter is from the book
What You'll Learn in This Hour:
- How to create variables and constants
- How to assign values to variables and change those values
- How to display the value of variables
- How to find out how much memory a variable requires
What Is a Variable?
A variable is a location in computer memory where you can store and retrieve a value. Your computer's memory can be thought of as a series of cubbyholes lined up in a long row. Each cubbyhole is numbered sequentially. The number of each cubbyhole is its memory address.
Variables have addresses and are given names that describe their purpose. In a game program, you could create a variable named score to hold the player's score and a variable named zombies for the number of zombies the player has defeated. A variable is a label on a cubbyhole so that it can be accessed without knowing the actual memory address.
Figure 3.1 shows seven cubbyholes with addresses ranging from 101 to 107. In address 104, the zombies variable holds the value 17. The other cubbyholes are empty.
)
Figure 3.1 A visual representation of memory.
Storing Variables in Memory
When you create a variable in C++, you must tell the compiler the variable's name and what kind of information it will hold, such as an integer, character, or floating-point number. This is the variable's type (sometimes called data type). The type tells the compiler how much room to set aside in memory to hold the variable's value.
Each cubbyhole in memory can hold 1 byte. If a variable's type is 2 bytes in size, it needs 2 bytes of memory. Because computers use bytes to represent values, it is important that you familiarize yourself with this concept.
A short integer, represented by short in C++, is usually 2 bytes. A long integer (long) is 4 bytes, an integer (int) can be 2 or 4 bytes, and a long long integer is 8 bytes.
Characters of text are represented by the char type in C++, which usually is 1 byte in size. In Figure 3.1 shown earlier, each cubbyhole holds 1 byte. A single short integer could be stored in addresses 106 and 107.
True-false values are stored as the bool type. The values true and false are the only values it can hold.
The size of a short always is smaller than or the same as an int. The size of an int is always the same or smaller than a long. Floating-point numeric types are different and are discussed later this hour.
The usual type sizes thus far described do not hold true on all systems. You can check the size a type holds in C++ using sizeof(), an element of the language called a function. The parentheses that follow sizeof should be filled with the name of a type, as in this statement:
std:cout << sizeof(int) << "\n";
This statement displays the number of bytes required to store an integer variable. The sizeof() function is provided by the compiler and does not require an include directive. The Sizer program in Listing 3.1 relies on the sizeof() function to report the sizes of common C++ types on your computer.
Listing 3.1. The Full Text of Sizer.cpp
1: #include <iostream>
2:
3: int main()
4: {
5: std::cout << "The size of an integer:\t\t";
6: std::cout << sizeof(int) << " bytes\n";
7: std::cout << "The size of a short integer:\t";
8: std::cout << sizeof(short) << " bytes\n";
9: std::cout << "The size of a long integer:\t";
10: std::cout << sizeof(long) << " bytes\n";
11: std::cout << "The size of a character:\t";
12: std::cout << sizeof(char) << " bytes\n";
13: std::cout << "The size of a boolean:\t\t";
14: std::cout << sizeof(bool) << " bytes\n";
15: std::cout << "The size of a float:\t\t";
16: std::cout << sizeof(float) << " bytes\n";
17: std::cout << "The size of a double float:\t";
18: std::cout << sizeof(double) << " bytes\n";
19: std::cout << "The size of a long long int:\t";
20: std::cout << sizeof(long long int) << " bytes\n";
21:
22: return 0;
23: }
This program makes use of a new feature of C++0x, the next version of the language. The long long int data type holds extremely large integers. If your compiler fails with an error, it may not support this feature yet. Delete lines 19–20 and try again to see if that's the problem.
After being compiled, this program produces the following output when run on a Linux Ubuntu 9.10 system:
The size of an integer: 4 bytes The size of a short integer: 2 bytes The size of a long integer: 4 bytes The size of a character: 1 bytes The size of a boolean: 1 bytes The size of a float: 4 bytes The size of a double float: 8 bytes The size of a long long int: 8 bytes
Compare this output to how it runs on your computer. The sizeof() function reveals the size of an object specified as its argument. For example, on line 16 the keyword float is passed to sizeof(). As you can see from the output, on the Ubuntu computer an int is equivalent in size to a long.
Signed and Unsigned Variables
All the integer types come in two varieties specified using a keyword. They are declared with unsigned when they only hold positive values and signed when they hold positive or negative values. Here's a statement that creates a short int variable called zombies that does not hold negative numbers:
unsigned short zombies = 0;
The variable is assigned the initial value 0. Both signed and unsigned integers can equal 0.
Integers that do not specify either signed or unsigned are assumed to be signed.
Signed and unsigned integers are stored using the same number of bytes. For this reason, the largest number that can be stored in an unsigned integer is twice as big as the largest positive number that a signed integer can hold. An unsigned short can handle numbers from 0 to 65,535. Half the numbers represented by a signed short are negative, so a signed short represents numbers from -32,768 to 32,767. In both cases, the total number of possible values is 65,535.
Variable Types
In addition to integer variables, C++ types cover floating-point values and characters of text.
Floating-point variables have values that can be expressed as decimal values. Character variables hold a single byte representing 1 of the 256 characters and symbols in the standard ASCII character set.
Variable types supported by C++ programs are shown in Table 3.1, which lists the variable type, the most common memory size, and the possible values that it can hold. Compare this table to the output of the Sizer program when run on your computer, looking for size differences.
Table 3.1. Variable Types
|
Type |
Size |
Values |
|
unsigned short |
2 bytes |
0 to 65,535 |
|
short |
2 bytes |
–32,768 to 32,767 |
|
unsigned long |
4 bytes |
0 to 4,294,967,295 |
|
long |
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 |
|
long long int |
8 bytes |
-9.2 quintillion to 9.2 quintillion |
|
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 |
The short and long variables also are called short int and long int in C++. Both forms are acceptable in your programs.
As shown in Table 3.1, unsigned short integers can hold a value only up to 65,535, while signed short integers can hold half that at maximum. Although unsigned long long int integers can hold more than 18.4 quintillion, that's still finite. If you need a larger number, you must use float or double at the cost of some numeric precision. Floats and doubles can hold extremely large numbers, but only the first 7 or 19 digits are significant on most computers. Additional digits are rounded off.
Although it's considered poor programming practice, a char variable can be used as a very small integer. Each character has a numeric value equal to its ASCII code in that character set. For example, the exclamation point character (!) has the value 33.