Teach Yourself Visual C++® 5 in 24 Hours

Previous chapterNext chapterContents


- Hour 2 -
Writing Simple C++ Programs

In the previous hour, you compiled some simple programs. Now it's time to learn some more details about how C++ programs work. Even simple C++ programs demonstrate basic concepts that are shared by all applications.

In this hour, you will learn

In this hour you will build a simple C++ program that accepts input from the user and echoes it back on the screen.

The Common Elements of a C++ Program

Computer programs are composed of instructions and data. Instructions tell the computer to do things, such as to add and subtract. Data is what the computer operates on, such as the numbers that are added and subtracted. In mature programs, the instructions don't change as the program executes (at least they're not supposed to). Data, on the other hand, can and usually does change or vary as the program executes. A variable is nothing more than the name used to point to a piece of this data.

Fundamental C++ Data Types

The C++ language offers several fundamental data types. As in most other programming languages, these built-in types are used to store and calculate data used in your program. In later chapters, you use these fundamental types as a starting point for your own more complex data types.

C++ has a strong type system, which is used to make sure that your data variables are used consistently and correctly. This makes it easy for the compiler to detect errors in your program when it is compiled rather than when it is executing. Before a variable is used in C++, it must first be declared and defined as follows:

int    myAge;

This line declares and defines a variable named myAge as an integer. A declaration introduces the name myAge to the compiler and attaches a specific meaning to it. A definition like this also instructs the compiler to allocate memory and create the variable or other object.

When the Visual C++ compiler reads the myAge definition, it will do the following:


Time Saver: It's possible to define several variables on a single line, although as a style issue, many people prefer to declare one variable per line. If you want to make your source file more compact, you can separate your variables by a comma, as follows:

int    myAge, yourAge, maximumAge;

This line defines three integer variables. Declaring all three variables on one line of code doesn't make your code execute any faster, but it can sometimes help make your source code more readable.


Understanding Type Safety

New Term: Some languages enable you to use variables without declaring them. This often leads to problems that are difficult to trace or fix. When using C++, you must declare all variables before they are used. This enables the compiler to catch most of the common errors in your software program. This capability to catch errors when your program is compiled is sometimes referred to as type safety.

You can think of type safety as a warranty that the compiler helps to enforce in your C++ program. For example, if you try to use an int when another type is expected, the compiler either complains or converts the variable into the expected type. If no conversion is possible, the compiler generates an error and you have to correct the problem before the program can be compiled.

For example, character values are normally between 0 and 127 and are stored in variables of type char. In Visual C++, a char is a single byte variable and is quite capable of storing all character values. If the compiler detects that you are attempting to store a number larger than 127 in a char, it will complain about it and issue a warning message. Listing 2.1 is an example of a program that tries to store a value that is too large in a char.

TYPE: Listing 2.1. An example of a problem that can be caught by the compiler.

#include <iostream>

using namespace std;

// This program will generate a compiler warning

int main()

{

    char distance = 765;

    cout << "The distance is " << distance << endl;

    return 0;

}

To see an example of a type mismatch that is caught by the compiler, create a console mode project with Listing 2.1 as the only source file, following the steps used in Hour 1, "Introducing Visual C++ 5." The compiler flags line 6 with a warning; however, it still generates an executable program.

In order to get the program to compile with no warnings and run as expected, you must change line 5 so that the distance variable is defined as an integer:

int distance = 765;

The new version of the source code is shown in Listing 2.2.

TYPE: Listing 2.2. A corrected version of the previous example.

#include <iostream>

using namespace std;

// This program will compile properly.

int main()

{

    int distance = 765;

    cout << "The distance is " << distance << endl;

    return 0;

}

New Term: Another common data type is the floating-point value, or a number with a decimal point. Floating-point values are stored in float or double variables in C++ programs. These are the only two built-in (or fundamental) variable types that can store floating-point values.

Using Different Variable Types

So far, you've used int and double variables, two of the fundamental types available in C++. They're called fundamental types because they are the basic data types that are a part of the language definition. There is also a set of derived types that will be covered in the next few hours. In addition, as you saw earlier with the string class, you can define your own types that work just like the built-in types. The names of the built-in types used in C++ include the following:

New Term: Some of the variables in the preceding list can be declared as unsigned. When a variable is declared as unsigned, it can store only non-negative values. When a variable is declared as an int, it can store both negative and positive numbers. However, an unsigned int can store a much larger positive value than a plain old int.

An unsigned int can store a larger positive value because the computer must use one bit of data in the memory location to handle the sign. This sign indicates whether the variable is positive or negative. Because using the sign bit reduces the number of bits that are available for storage, the maximum value for the variable is reduced by half. Figure 2.1 is an example of a variable that has been declared as int and another variable that has been declared as unsigned int.

Figure 2.1.
Most computers can use a sign bit to determine whether a variable is positive or negative.

The fundamental variable types require different amounts of storage. As a rule of thumb, the char data type is large enough to contain all the characters in the machine's native language, or eight bits. The int type is usually the "natural" variable size for the target machine, so int variables are 32 bits in Visual C++. Table 2.1 lists the number of bytes required to store each of the fundamental types.


Just a Minute: Earlier versions of Visual C++ that were used with Windows 3.1 were 16-bit compilers. The natural variable size under Windows 3.1 was 16 bits, so the int type was 16 bits. The last version of Visual C++ that used 16-bit integers was Visual C++ 1.5.

Table 2.1. Storage required for fundamental C++ types.

Type Size (in bytes)
bool 1
char 1
short 2
int 4
long 4
float 4
double 8
long double 8

Variable Naming

One important part of programming is the selection of names for your variables and other parts of your programs. The program listings you've seen so far have been very simple. As you become a more experienced user of Visual C++, you will need to establish some sort of naming convention for your identifiers.

When naming your variables, use names that are as long as necessary to indicate how the variable is used. A variable name in C++ is an example of an identifier. Identifiers in C++ are used to name variables and functions, among other things. In Visual C++, your identifiers can be literally hundreds of characters long and can include any combination of letters, numbers, and underscores, as long as the first character is a letter or underscore. Listing 2.3 is an example of several different variable declarations.

TYPE: Listing 2.3. Some examples of good and bad variable names.

#include <iostream>

using namespace std;

int main()

{

    // Good declarations

    int     nEmployees;      // Number of employees

    char    chMiddleInitial; // A middle initial



    // Declarations that could be improved

    int     i, n, k;         // What are these vars used for ?

    float   temp;            // May not be enough information

    char    ch;              // Should have more information



    return 0;

}

No matter which technique you use to name your variables, it's important to be consistent. For example, most of the sample programs and online help examples provided as part of Visual C++ use a naming convention known as Hungarian Notation.

When Hungarian is used properly, it's easy to tell the logical type of variable at a glance without searching for its declaration. For example, most scalar variables such as int, long, or short are prefixed with an n. Variables that are used to store characters are prefixed with ch, as in chEntry and chInitial. Most of the sample code available from Microsoft uses Hungarian Notation, which will be used for the remainder of the code listings in this book. A listing of common Hungarian prefixes is provided in Appendix D, "Hungarian Notation."


DO/DON'T:
DO
use meaningful names for your variables.
DO be consistent in your naming conventions.
DO use variable types that match your data.
DON'T depend on capitalization to differentiate between variables.

Assigning Values to Variables

In assigning values to variables, the assignment operator is just an equals sign used as follows:

nFoo = 42;

This line assigns the integer value 42 to nFoo.

If a floating-point decimal value is assigned, it's assumed by the compiler to be a double, as follows:

dFoo = 42.4242;

You can assign to a variable of type char in two ways. If you are actually storing a character value, you can assign the letter using single quotes as shown here:

chInitial = `Z';

The compiler converts the letter value into an ASCII value and stores it in the char variable. Small integer values can also be stored in a char, and the assignment is done just like an int variable.

chReallyAnInt = 47; 


Time Saver: The char variable type is sometimes used to store small integer values. This is useful if you are storing a large number of values, because an int takes up four times the storage of a char.

A Simple C++ Program

In Hour 1, you created a C++ project named Hello that displayed a simple "Hello World!" message. This hour you will make a simple modification to the Hello project--the Hello2 project will ask you for a name and then use the name in the greeting. Building this project will help demonstrate some common elements found in C++ programs.

Creating the Hello2 Project

The first step in writing any Visual C++ program is to create a project, as you did in the first hour. To review, these are the steps required to create a console-mode project:

1. Begin by selecting File | New from the Visual C++ main menu. This will display the New dialog box.

2. Select the Projects tab in the New dialog box. A list box containing different types of projects will be displayed.

3. Select the icon labeled Win32 Console Application, as shown in Figure 2.2. You must also provide a name for the project--a default location will be provided for you automatically.

Figure 2.2.
The New Projects dialog box.

After you have selected the project type and the subdirectory, click OK to create the project.

Creating the Source File for Your Program

The source file for the Hello2 project is shown in Listing 2.4. Unlike your first Hello program, this version collects input from the user and then outputs a greeting.

TYPE: Listing 2.4. A console mode program that accepts input.

#include <iostream>

#include <string>

using namespace std;



// Prompt the user to enter a name, collect the name,

// and display a message to the user that contains

// the name.

int main()

{

    string userName;



    cout << "What is your name? :";

    cin >> userName;

    cout << "Hello " << userName << "!" << endl;



    return 0;

}

Open a new C++ source file and type the code shown in Listing 2.4. Remember that C++ is case-sensitive. Save the file as Hello2.cpp in the project's directory. To review, these are the steps required to open a new C++ source file and add it to the project:

1. Select File | New from the main menu, and select the Files tab in the New dialog box.

2. Select the icon labeled C++ Source File.

3. Check the Add to Project check box, and enter Hello2.cpp as the filename.

4. Click OK to close the dialog box and open the file for editing.

Compile the Hello2 project by selecting Build | Build Hello2.exe from the main menu (or press F7). If the source code was entered correctly, the project will be built with no errors, and the last line in the status window will read

Hello2.exe - 0 error(s), 0 warning(s)

If there are errors or warnings, check the source code for typographical errors and build again.

Running the Hello2 Program

Open a DOS window and change to the DEBUG subdirectory under the Hello2 project directory. Run the Hello2 program by typing Hello2 at the DOS prompt. The program produces the following output:

What is your name? :Alex

Hello Alex!

The Hello2 program accepts any name as input and uses that name for its Hello World message.

Analyzing the Hello2 Program

Let's take a look at the Hello2 program because it has a lot in common with much larger C++ programs. Even though it is fairly short, it has many of the elements that you will see in more complicated Windows programs later in this book.

Include Statements

The first line of Hello2.cpp is a message to the compiler to include another file when compiling Hello2.cpp:

#include <iostream>

This #include statement tells the compiler to look for the file named iostream and insert it into your source file. Actually, the #include statement is read by the preprocessor, a part of the compiler that scans the source file before the file is compiled.

New Term: Statements read by the preprocessor are known as preprocessor directives because they aren't actually used by the compiler. Preprocessor directives always begin with a #. You will learn more about preprocessor statements throughout the rest of the book.

New Term: The file iostream is an example of a header file. A header file contains declarations or other code used to compile your program. In order to perform common input and output operations, you must #include the iostream file.


Just a Minute: Traditionally, C++ header files have an .h or .hpp file extension; the standard C++ library includes files such as iostream that have no extension. For backward compatibility, the Visual C++ compiler includes older versions of the include files that have the .h extension.

The #include preprocessor directive is seen in two basic forms:

The second line of Hello2.cpp is also an #include directive:

#include <string>

The string header file is part of the standard C++ library. Including the string header file enables a C++ source file to use the standard string class, which simplifies using text strings in a C++ application.

The std Namespace

New Term: A collection of names and other identifiers in C++ is known as a namespace. By default, any name that is introduced in a C++ program is in the global namespace. All names found in the standard C++ library are located in the std namespace.

Namespaces make it easier to manage names in large C++ projects, especially when using libraries or code developed by different groups of people. Before namespaces were introduced to C++, it wasn't unusual to have two or more libraries that were incompatible with each other simply because they used conflicting names.

Namespaces allow libraries to place their names into a compartment that itself has a name. As shown in Figure 2.3, two namespaces can each use a common name, in this case string; because each namespace provides a compartment for the name string, the two names do not conflict with each other.

Figure 2.3.
Namespaces provide separate compartments for names used in a C++ program.

When using a name from a namespace, the namespace must be prefixed, like std::string or codev::string. Alternatively, a using namespace directive can be used to tell the compiler that an identifier can be found in the global namespace, as in the next line of the program, which tells the compiler that the names found in the program can be found in the std namespace:

using namespace std;

Using Comments to Document Your Code

New Term: A comment is a note provided to the person reading the source code. It has no meaning to the compiler or computer.

The next line begins with //, which is used to mark the beginning of a single-line comment in a C++ program. By default, comments are colored green by the Developer Studio editor. In contrast, int and return are colored blue to indicate that they are C++ keywords.


Time Saver: It's a good idea to use comments to document your code. After time has passed, you can use your comments to help explain how your code was intended to work.

The main Function

The next line of Hello2.cpp is the beginning of the main function.

int main()

The first line inside the main function is a variable declaration.

string userName;

Don't worry too much about what this means--for now, it's enough to know that userName is a string variable. A string is not one of the fundamental data types; instead, it's part of the standard library. The string type enables you to use strings of text as though they are built-in fundamental types.

Following the declaration of userName is a statement that displays a message to the user as a prompt for the user's name:

cout << "What is your name? :";

This particular statement in Hello2.cpp displays a line of characters to the console window by using the iostream object cout. The iostream library is included with every C++ compiler, although it is not technically part of the C++ language definition; instead, it's part of the standard C++ library. Performing standard input and output for your console mode program is easy using the iostream library.

The iostream library uses the << symbol for output and the >> for input to and from IO streams. Think of a stream as a sequence of bytes, like a disk file, or the output to a printer or a character-mode screen.


Just a Minute: One simple rule of thumb is that when you see the << symbol, the value to the right of the symbol will be output to the IO object on the left. When you see the >> symbol, data from the IO object on the left is stored in a variable to the right.

The next line of Hello2.cpp accepts input from the user and stores it in userName:

cin >> userName;

The variable userName now contains whatever value was entered by the user.

The next line displays the Hello greeting and adds the contents of the userName variable. When using cout, several different components can be output one after another by separating them with the << symbol:

cout << "Hello " << userName << "!" << endl;

The last line of the main function is a return statement. When a return statement is executed, the function returns or stops executing, and the caller of the function is passed the value provided after the return keyword. Because this return statement is inside main, the value 0 is passed back to the operating system. The return keyword can appear almost anywhere in a function. However, as a matter of style, most people prefer to have a single return statement in a function if possible.

Summary

In this hour, you have learned more details about C++ programs. You wrote a simple console-mode program and analyzed its parts. You also learned about the C++ preprocessor, type-safety, and variables.

Q&A

Q When I compile the Hello2 project and enter my first and last name, only the first name is displayed. How can I display my first and last names?

A When using cin to gather input as shown in the Hello2 project, white space such as the space between your first and last name will cause your names be parsed into two separate variables. You can use cin with multiple variables much like you use cout with multiple variables; just separate the variables with the >> operator. A new version of Hello2 that displays first and last names looks like this:
#include <iostream>

#include <string>

using namespace std;

int main()

{

    string strFirstName;

    string strLastName;



    cout << "Please enter your first and last name:";



    cin >> strFirstName >> strLastName;



    cout << "Hello " << strFirstName << strLastName << endl;

    return 0;

}
Q When I declare a variable, sometimes I get strange error messages from the compiler in the Build window. This is the line that causes the error:
int my age;
A In C++, all variables must be a single identifier. The compiler complains because after using the identifier as a variable name, it can't figure out what to do with the identifier name. One coding style is to separate the words that make up a variable name with an underscore, like this:
int my_age;

Workshop

The Workshop is designed to help you anticipate possible questions, review what you've learned, and begin thinking ahead to putting your knowledge into practice. The answers to the quiz are in Appendix B, "Quiz Answers."

Quiz

1. What is the difference between the cout and cin iostream objects?

2. What are the two forms of the #include preprocessor directive?

3. What type of variable is used to store character values?

4. What is the purpose of a C++ namespace?

5. How can you declare more than one variable on a single line?

6. What is type-safety?

7. What types of variable are used to store floating-point values?

8. How do you assign a value to a variable?

9. What type of variable is normally used to store integer values?

10. Why would you declare a variable as unsigned?

Exercise

1. Modify the Hello2 program to ask for your age in addition to your name; display the name and age in the Hello message.


Previous chapterNext chapterContents


Macmillan Computer Publishing USA

© Copyright, Macmillan Computer Publishing. All rights reserved.