Class 3: Hello, Variables!

[Ganon11]

So we've taken a short look at Hello World and can slightly understand some C++ code. But enough looking around at code, it's time to write our own! In order to start off with the basics, we're going to learn about a few data types, such as integers, doubles, strings, and streams. Once we know how to use these very simple tools, we can begin making some useful programs.

A Stream is the fancy word programmers use when talking about input or output. Now, suppose I ask you to enter a number, and you enter 8490. You type this on your keyboard and then hit enter. Somehow, this number gets to my program, and I can use it for calculations or anything else I need. Imagine that this information travels through the computer from they keyboard to my program in a stream - a digital stream of information, with little fishies of data. OK, so there aren't any fishies. But can you imagine now what a stream is? Similarly, if I tell my program to output the words, "Hello World!", this information has to travel through another stream - from my program to your moniter. The two types of streams are called input streams and output streams. Looking back at Hello World, can you figure out what the output stream is?

If you guessed cout, you're correct! This is the standard output device in C++ programs - it has been predefined for us, the programmer, so it is easy to use. All we need to do is include the necessary header file <iostream> (for Input/Output STREAM) and say we're using the group of variables called std. The corresponding predefined input stream variable is called cin - for Common INput.

In order to use input, you need to have some room in the computer to store the value the user gives you. This room is called a variable. If you've taken algebra in school, you already know the basics of a variable. A variable can hold any value, and the way a program runs depends on this value. The user can input the value of, say, an integer, and your program will output the number squared. Obviously, the program cannot know what the user will enter, and so we must use a variable to be able to have our code be applicable to many situations.But in order to use variables, we have to understand some simple data types. Simple data types come in three forms: integral, floating-point, and enumeration. We'll worry about enumeration data types later.

Integral data types come in a few forms. Following is the full name of the data type, followed by its C++ nickname, followed by a description:

Integer (int): An integer data type. An integer is any whole number, such as 5, 2000, or -32. An integer variable, however, cannot hold a decimal number, such as 43.34. The integer data type is very versatile, usually able to hold numbers anywhere from -2147483648 and 2147483647. Therefore, we will be using integers most commonly for number values. I said 'usually able' because the specific size of an integer is determined by different systems. The system I use (Windows XP) has a 4 byte integer (-2147483648 to 2147483647), but some systems use a 2 byte integer (-32,768 to 32,767).

In order to find out which int your system uses, run the following short program in your C++ compiler:

#include <limits>
#include <iostream>
 
int main() {
    std::cout << "Int values range from " << INT_MIN << " to " << INT_MAX << std::endl;
    system("PAUSE");
    return 0;
}

Long (long): Another integer data type. This data type specifies to your system that you want to use the 4 byte int type, with values from -2147483648 to 2147483647.

Short (short): Like the long type, but specifying the 2 byte integer (values from -32,768 to 32,767).

Boolean (bool): If you have taken a precalculus class, you will be familiar with Boolean expressions. A boolean variable holds one of only two possible values - true or false. Boolean variables are used to control certain aspects of your program using if... statements and loops. We'll be going over these structures shortly.

Character (char): Believe it or not, you're already familiar with character data types. A character is any single unit of text - such as 'e', or a backslash '\', or even this period. The computer holds this data as an integer between -128 and 127, since there are only 255 standard characters used in output. Now, because the computer stores characters as numbers, a few irregularities occur. The character 'A' is not 1 - it is actually 65. Also, we can add a number to a character variable to change the symbol it represents - if I added 3 to the preceding 'A', the char variable would then be 68, or 'D'. Finally, the character value of '5' is not 5, so be careful when using characters to hold numbers.

Floating-point data types fill in the final gap - holding decimal numbers. Floating-point data types can also hold integers, but instead of holding 32, this data type would hold 32.0.

Floating-Point (float): An all-purpose decimal number type. This data type can hold any value between -3.4E38 and 3.4E38 (That is, -3.4 * 10^38 and 2.4 * 10^38). Floating-point variables ca hold up to 6 or 7 significant digits in any variable. Thus, if I wanted to store the value 3.141592653589... in a float, the variable would only hold 3.141592 - close enough for common purposes, but not for extremely accurate mathematical purposes. As versatile as the floating-point data type is, C++ programmers generally use...

Double (double): Like the floating point data type, a double holds a decimal number, but the range of a double is -1.7E308 to 1.7E308. That's a lot of values! In addition, the double type holds up to 15 significant digits. In our above example, that's all the digits I entered plus a few more! Obviously, the double data type is much more accurate (and thus useful) then its counterpart - consequently, we will use doubles any time we need a decimal number.

One final data type is called a string.

String (string): A collection of characters that is used to hold words, or text. In Hello World, the "Hello, World!" portion of the code was a string. Can you see how it is a collection of characters? First the character "H', then 'e', then 'l', and so on.

Now, in order to use a variable, we must first declare it. Below are a few examples of variable declarations, and a few statements showing how to set a value into a variable:

int x; // Integer variable called x
long numOfBoxes; // Long variable called numOfBoxes
bool isDone; // Boolean variable called isDone
char decision; // Character variable called decision
string someText;
float pi;
double betterPI;
 
x = 32; // Any time we use x, the value 32 is used instead.  This is called intialization, 
 
as it is the first value set into x.
isDone = false; // Boolean variables can be set to either true or false - these are reserved words in C++.  Anytime you use true or false, the C++ compiler knows what you mean.  NOTE: False and True are different than false and true, since C++ is case-sensitive.
 
decision = 'Y'; // In order to let C++ know that Y is a character, we enclose the letter in single-quotation marks.
someText = "This is a sample string."; // Like the character, we need to let C++ know that the following text is a string.  To do so, we enclose the text in double-quotation marks.
pi = 3.141592;
betterPI = 3.141592653589;
 
int y = 16; // This is the same as two statements - one to declare y, and another to set y to 16.  We can type it like this, however, to save some time.

Now for some more fancy things to do with our variables, such as getting user input and declaring multiple variables in one line.

int a = 0, b = 1; // Declares a and b, both integer types, and sets them to 0 and 1, respectively.
 
cin >> a; // This will wait for the user to enter in a value, and then store that value inside a.  Note that, since the user is inputting to a, any previous information a held is lost.  That is, a no longer holds 0 - that 0 is gone forever.
 
double q = 0.0; // Same as initializing to 0, but use a decimal number with doubles in order to remind yourself that it is a decimal.
 
bool amICool = true, amILame = false;
 
cin >> b >> q; // This waits for two values from the user.  The first goes into b, and whatever remains goes into q.

Now to explain some irregularities with cin.

cin skips all whitespace characters when determining input. A whitespace character is a space (' '), a newline character (represented as '\n', and made when you hit the 'enter' key), or a tab (represented as '\t'). Note that the tab key and newline character, even though they are represented to us as two characters - the backslash and a letter - are considered by C++ to be one character. These are called escape sequences, and will be explained next chapter. Since cin skips whitespace, it uses the positions of spaces and such to determine when a value starts or stops. For instance, consider the following examples:

// User is prompted for input
cin >> a; // User enters 34 and hits enter; 34 goes into a
 
cin >> b; // User enters a space, then 4, then another space, then 7, then enter.  4 goes into b, 6 is still in the input stream
cin >> a; // The 6 from the last input goes into a, since it was still in the stream
 
double m;
cin >> q >> m; // User enters 12.3, then a space, then 65.77, then hits enter.  q gets 12.3 and m gets 65.77.
 
cin >> a >> q; // Inputting into two different data types!  Note that this is completely legal.  User enters 3, then a space, then 5; a gets 3, q gets 5.0 (since it is a double)
 
cin >> a >> q; // User enters 34.05, then enter.  You may think this would be wrong, but it actually works.  Since a is an integer, cin looks for the first integer - namely, 34.  a gets 34, and q gets the leftover - 0.05.
 
string myMessage;
cin >> myMessage; // User enters "Sunshine", "Sunshine" goes into myMessage;
cin >> someText; // User enters "The Rain in Spain."  Since cin skips whitespace, only "The" 
 
is stored in someText - the rest of the data is stored for later.
// If we want to get the whole line inside someText, we have to use a function called getline, as follows:
getline(cin, someText); // User enters "The Rain in Spain." and all this text is stored in someText.  getline gets all text from the start of the stream until the newline character.
cin >> decision; // User enters a; decision now stores 'a'
cin >> decision; // User enters abcd; decision now stores 'a', and 'bcd' is stored for later.
cin >> decision >> a; // User enters 25; decision gets '2', and a gets 5.

Finally, a short explanation of output.

In order to output, you have to use cout, as in Hello World. You type cout, then the insertion operation (known in C++ as <<), then whatever you wish to display. You can display any of these simple data types, since C++ knows what they are and how to use them. You can also display text that is not stored inside a variable by enclosing this text in quotation marks. Hello World took advantage of this ability. One final note about cout is that different elements must be seperated by the << operation. Thus, if you want to display some text, you can type the text to be displayed, end the text using a final quotation mark, then <<, then type in a varible name, then <<, then endl to go to a new line. The moniter will display your text, the variables value, and then go to a new line. Consider some examples of simple output:

cout << "What's up?" << endl; // Moniter displays the text What's up?
cout << "5 + 3 = " << 5 + 3 << endl; // Moniter displayes 5 + 3 = 8.  The left side of the equation was enclosed in quotation marks, so no operations are performed on the numbers.  The right side, however, was not enclosed - C++ adds these numbers together to get 8, and displays 8.
cout << "a^2 = " << a * a << endl; // Moniter displays a^2 = , and then the value of a squared.  There is no ^ operation in C++, so if we want to, say, cube a, we must write a * a * a.  In C++, * means multiplicatiopn, instead of x or X.  Similarly, / means division.
cout << "Please enter an integer: "; // Displays the text, but does not go to a new line!  This looks good if you want to follow this display with a prompt for user input, as the user's input will appear on the same line.
string message = "Hello, World!";
cout << message << endl; // Moniter displays Hello, World! - the value stored in message.

Hopefully, this short explanation of output, input, and variables has not utterly confused you! In order to see if you understand the basics, I'd like you to write a program that

does the following:

1) Declares 3 integer variables, a, b, and c
2) Displays a message asking the user for input
3) Prompt the user for input into a, b, and c
4) Displays a message including the values of a, b, and c
5) Declares 2 string variables
6) Displays a message asking the user for input into the string
7) Prompt the user for input using cin
8) Prompt the user for input into the second string using getline
9) Displays the text entered by the user
10) The final two lines of your program must be:

system("PAUSE");
return 0;

Use the basic shell of a C++ program below to get started:

#include <iostream>
using namespace std;

int main() {
// Variable declarations
// Other statements
// Display statements

system("PAUSE");
return 0;
}

and PM me your resulting code if you'd like to have me check your work.

Until next time, when we'll look at more stream functions and escape characters!