Teach Yourself C++

Preface

Teach Yourself C++ is a tutorial approach to learning C++ by using the book in front of you while you run example programs on a PC. I wrote the first edition in 1990. The work is now in its 7th edition, with an 8th planned for sometime much later.

This is the e-book edition, which contains the text and programs from the 7th print edition published in 2003. It is a comprehensive study of C++ up to C++98, which was the most current standard in 2002 when I wrote the book. The latest Standard release, C++11, was approved in August, 2011. My next edition of this work will cover as much of the new language and library features as I can work in and for which contemporary compilers provide support. The language is growing faster than most of us can keep up with. More about that later this year.

This is the second release of this book in e-book format. The first one was formatted to work on the Kindle. This edition is more adaptable now to epub devices, such as the iPad, than the earlier one was.

The e-book Paradigm

Presenting source code in a format suitable for e-book presentation is a challenge. My objective was to make this content as universally accessible as possible, which means that no matter which e-reader you have, you can read the book. Page width and fonts are problems. Unlike print media, the user chooses those things from what the device offers, and the iPad, for one example is less than hospitable to monospace fonts, an absolute necessity for the presentation of readable code. With a bit of experimentation and by looking at the e-book code of other programming books, I was able to make it work.

This book displays properly on the lowest common iPad denominator, the iPad 1, which is my testing platform for the epub edition. Other formats—Kindle and PDF—are supported too. I find it works best on the Kindle 1 and Kindle Paperwhite if I read the book in landscape viewing mode. Please let me know if you have problems reading this book on your device.

When you download the example source code—see below—you might notice that sometimes the format in the book is not the same as that in the source code for the same program. That's because the source code was originally formatted to fit the pages of a 7.25 x 9.25 trade paperback book. The printed editions have more room for code. To fit the code onto the optimum e-reader display, I had to insert some line breaks, delete some space characters, and whatever else was necessary to present the material in an accurate representation while retaining its legibility.

The source code, tables, and illustrations in this e-book display best when the default font is set to its smallest readable size. I tested the book on an iPad 1 with the Times New Roman font selected at its next-to-smallest configuration. That seems to work well.

The C++ Language

C++ is the C Programming Language with object-oriented extensions and other additions and improvements. The C and C++ programming languages are, between them, older than many—perhaps even most—of the programmers who use them. C was developed in the early 1970s, and C++ was released in 1980. In the time since, C++ has evolved from a small toolset built for personal use by research laboratory programmers into the worldwide object-oriented language of choice for several generations of programmers. There are C++ compilers for virtually every computer and operating system, and C++ now enjoys the distinction of being the language with which most contemporary mini- and microcomputer applications are written.

C++ initially became an international standard programming language in 1998 with the approval and publication of a ponderous document titled impressively, International Standard ISO/IEC 14882:1998(E), Programming Languages – C++. 

This book is a tutorial approach to learning Standard C++ programming. Standard C++ is a platform-independent programming language specification, and Standard C++ compilers exist for most platforms. C++ is the dominant programming language in use today. Knowing C++ is a step towards a successful career as a computer programmer.

Starting with Chapter 1, you learn C++ from the ground up. Subsequent chapters slowly add details and complexity to your understanding until you have a grasp of the basic C++ programming language.

Compiler Included

The compiler suite that accompanies this book and the book’s example programs are available for free download at:

http://www.alstevens.com/tycpp

Al Stevens

March, 2013

Part I The C++ Language

Part I, Chapters 1 through 13, describes the basic elements of the C++ language, primarily those things that are most like the C language but with a few new things to learn.

Chapter 1 - An Introduction to Programming in C++

In This Chapter

The Core C++ language

The Standard C++ Library

Writing small C++ programs

This chapter describes C++ at its most elementary level. It is an overview, so you might not fully understand the details this chapter presents, but don't worry; you will learn about all of these concepts and much more in the chapters that follow. As you proceed through the lessons beginning in Chapter 2, return from time to time to this introduction and watch everything fall into place.

A Brief History

In the early 1970s, Dennis Ritchie, a programmer at AT&T Bell Laboratories, adapted the minicomputer programming language BCPL into the first version of what he named C, a language that allows a program to access hardware similar to assembly language but with the structured programming constructs of high-level languages.

C ran on the Unix operating system, also an internal AT&T project. Eventually Ritchie rewrote the C compiler in C itself, and Ken Thompson rewrote Unix in C, a new concept, a compiler written in the language it compiles. By porting the C compiler to other computers, the developers made Unix into a portable operating system, a revolutionary idea at the time. These achievements distinguished C as a high-level language for writing systems programs, portable applications, and utility programs.

For years C and Unix remained internal AT&T software assets. Eventually AT&T offered Unix to universities, and a generation of students was exposed to Unix and C. As those students entered the programming world of business and industry, the Unix and C influence found its way into corporate America. The C language began to enjoy mainstream support in circles previously dominated by COBOL at the top level and assembly language at the bottom.

In the late 1970s developers built C compilers for personal computers. Whereas BASIC had been the dominant microcomputer programming language, vendors began publishing C compilers, and programmers of home computers began making the switch. The IBM PC, introduced in 1981, continued this trend. C became most programmers' favorite language for writing PC programs. At one time, more than a dozen C compilers were available for the PC. Most applications and systems software for the PC are written in C and C++.

C was defined in 1981 in The C Programming Language (Prentice Hall), by Brian Kernighan and Dennis Ritchie. Although not a formal language specification, the book, nicknamed K&R for the initials of its authors' last names, described C the way Ritchie had implemented it at AT&T. The dialect of C that K&R describes is called K&R C. Compiler builders added features to K&R C, and as the industry accepted the best of those extensions, a de facto standard evolved.

In 1983, the American National Standards Institute (ANSI) and the International Standards Organization (ISO) formed a committee to standardize C. Their charter was to codify the language as it existed. They published a C Standard document in 1990. A second edition of the K&R book describes Standard C, also called ANSI C, obscuring somewhat the identity of K&R C.

Bjarne Stroustrup, an AT&T Bell Labs researcher, designed and developed the C++ programming language circa 1980 to answer a need for a simulation language with the features of object-oriented programming, then a relatively new programming paradigm. Chapter 40 describes object-oriented programming. Dr. Stroustrup decided to build C++ upon the C language, writing a C++ compiler that emits C source language. The C source language could be compiled on any computer system that supported C. Stroustrup called his translator program cfront. Many implementations of C++ are ports of cfront and its successors, the source code of which is available under license from AT&T. The C++ language has been available outside AT&T since about 1985.

A joint ANSI/ISO committee formed in 1989 to define Standard C++. Their work was completed with the publication of the C++ international standard in 1998, or so many of us had thought. It was only the beginning of a standard for the language

I wish to make mention now of the passing of Dennis Ritchie in August, 2012. His contributions to computer science are many, and he was a brilliant man, always willing to share his time and knowledge with others. I interviewed Mr. Ritchie in 1989 for Dr. Dobb's Joournal. I interviewed Bjarne Stroustrup the same day. You can read those interviews by touching here.

In case you do not have Internet access from your e-reader device, here is the URL, which you can type into your browser's address field: http://tinyurl.com/b5m6z6n

Introduction to C++

There are two parts to the C++ language. First is the core language itself, those elements that the compiler processes into native machine instructions. Second is the Standard C++ Library, a huge collection of functions and classes, written in the core language, which are heavily dependent on each other, and that implement console and file input and output, string processing, object containers, algorithms, and internationalization. To understand the libraries, you must understand the core language.

C++ is an extensible language. Programmers extend the language by adding libraries of classes, functions, algorithms and containers, beyond those provided by the standard definition. The Standard Library supports a generic operating environment that includes text standard input and output and file input and output. Platform-dependent extensions, such as the MFC and OWL applications frameworks, implement specific features for a particular operating platform. Programmers further extend C++ by adding libraries to support their particular problem domains.

The Core C++ Language

C++ is a procedural programming language with object-oriented extensions. This means that you can design and code programs as procedural modules, and you can declare classes and instances of classes. Procedural modules in a C++ program are called functions. Instances of classes are called objects.

Functions

Here’s what a C++ function looks like: 

void donothing()

{

    return;

}

The function just shown is named donothing and, as its name suggests, it does nothing except return to its caller. Its name is assigned by the programmer. It is a void function, which means that it returns no value.

Other programming languages would call the donothing function a procedure or subroutine because in mathematics and computer programming, functions traditionally return values, whereas in programming, procedures and subroutines perform some operation without returning anything. In C++, though, both kinds of code blocks are called functions.

Some C++ functions do return values. Here’s what one looks like:

int April()

{

    return 4;

}

The caller of such a function can code the function call on the right side of an assignment statement, assigning the returned value to a named data variable like this.

month = April();

You can also code a function call as the argument that provides the parameter value to another function call, as an initializer to a local data variable, or as an element in an expression. Chapter 2 explains assignments, constants, variables, initializers, and expressions.

Functions may declare parameters like this.

int daysinmonth(int month)

{

    int days[] = 

      {31,28,31,30,31,30,31,31,30,31,30,31};

    return days[month];

}

The daysinmonth function has a month parameter and returns the number of days in the specified month without considering leap years and without validating the argument passed into its month parameter.

The function uses an initialized array named days and uses the month parameter to subscript into the array to retrieve a value to return. Chapter 7 explains arrays.

The caller of the function passes arguments that the function uses as the values for its parameters like this.

numberofdays = daysinmonth(10);

The constant value 10 is an argument that is copied to the function's month parameter when the function is called. An argument can be any C++ expression that returns a compatible type. A caller’s argument types must match the types of the parameters declared for the function, or the compiler must know how to convert the argument’s type to the parameter’s type. For example, you can pass an integer argument to a function that is expecting a floating point parameter and the compiler knows how to make the conversion.

A function starts execution at its first, topmost statement and continues until the last, bottommost statement executes or until the function executes a return statement from inside the function body. Each function, upon completion, returns to its caller, and execution continues with the next statement in the calling function.

Chapter 3 explains functions in more detail.

Classes

Classes are aggregate definitions that consist of data members and member functions. A class encapsulates the implementation and interface of a user-defined data type and constitutes an abstract data type.

Here’s what a C++ class looks like:

class newtype {

   // members

};

The class just shown is named newtype. Its name is assigned by the programmer. A class describes to the compiler some kind of data type or other abstraction that the programmer uses in the program. The class shown here has nothing inside its declaration except a comment, the line that begins with the characters //. Chapter 2 explains source code comments. Classes usually contain data members and member functions to define the class’s behavior and interface for the program that uses it.

The class's implementation—its aggregate private members—usually is hidden from the class user (the programmer who instantiates objects of the class). The class's public interface usually is revealed to the class user in the form of methods: class member functions that operate on the data members of the class.

The class user instantiates objects of the class and invokes class methods against those objects by calling the class's member functions for the objects. A class is said to have behavior, which is another way of saying that an object of the class responds to its methods in ways that are understood by the class user at an abstract level without necessarily revealing the details of that behavior.

Chapter 6 introduces classes and Part II explains classes in more detail.

The main Function

A C++ program begins execution in a function named main and terminates when the  main function returns. Which brings us to the first of the exercise programs.

Program 1-1: The minimum C++ program

int main()

{

    return 0;

}

End of Program 1-1

This is a good time to turn to open and learn how to use Quincy to run the tutorial listings. You can compile and run Program 1-1 if you want to, but it does nothing except return to the operating system.

Program 1-1 declares and defines the main function. That's all the program does. The program begins executing with the first statement in main and terminates when the main function returns.

The operating system calls main, which  returns its integer value to the operating system. The main function is the entry and departure points of your a C++. No place in your program is allowed to call the main function.

The main function may call other, lower-level functions, which in turn may call even lower-level functions. Chapters 3 and 5 have further discussions of main.

Anatomy of a Function

The  function in Program 1-1 illustrates several things about C++ functions in general. Unlike the donothing function, main returns a value. The first line provides the main function's return type and identifier. The main function returns an integer value and always has the identifier main. The int keyword specifies the function's integer return type. You learn about integers and other data types in Chapter 2.

The parentheses after the function's name contain the function's parameter list. In this case, main has no parameters, so the parameter list is empty. An empty parameter list is represented by the () character sequence.

The function body follows the parameter list. The function body begins with a left brace character ({) and ends with a right brace character (}). In between are the function's statements—the lines of code that execute when the function is called. Program 1-1 has only one statement, the return statement that terminates the main function and, consequently, the program.

A brace-surrounded group of statements is called a statement block. Statement blocks may be nested. You see how this nesting contributes to program flow control in Chapter 4. Every function has at least one statement block; Program 1-1's main function has only one statement block.

A function finishes executing immediately after its last statement executes, or when the  statement executes. Program 1-1's main function terminates when its  statement returns the integer constant 0. A return statement can be positioned anywhere inside the function. A void function can return without using a return statement. We could have written donothing like this:

void donothing()

{

}

After a void function executes the last statement in its outermost statement block, the function returns to the function that called it.

Statements

Each function consists of one or more blocks of statements. The blocks are nested (one enclosed within the other).

Statements fall into one of the following categories:

Definitions: Define instances of variables and functions

Procedural Statements: Executable code statements that reside inside a function's definition

Variables

Each statement block can declare local variables, which remain in scope as long as statements in that block are executing. An example:

void dosomething()

{

    int amount;

    // ...

}

The dosomething function has as its first statement the declaration of an integer variable named amount.

Observe the semicolon at the end of the statement. Every C++ statement is terminated with a semicolon.

A C++ program also can have variables declared outside any function. Those variables are said to have global scope, because the statements in all the functions in the same source file can reference them. Here’s an example:

int external_amount;

void dosomething()

{

    // ...

}

The external_amount integer variable has global scope because it is declared outside any function definition.

Chapter 7 explains the scope of program elements in a C++ program.

A variable declaration specifies the variable's storage class, data type, type qualifier, level of indirection (if it is a pointer), name, and dimensions (if it is an array). Chapter 7 explains these things.

A function declaration (more frequently called its prototype) declares the function's return type, name, and the number and types of its arguments. Chapter 3 explains these things.

A variable definition includes the components of a declaration and may include an initializer if the variable has an initializing value. Chapter 2 explains initializers. A definition defines the instance of the variable and reserves memory for it. A function definition contains the function's executable code.

Usually, a variable's declaration and definition are the same statement. A function's prototype and definition are usually in different places. If the function's definition appears in the source code file ahead of all calls to the function, however, the function's definition may also serve as its prototype.

Identifiers and Keywords

You assign names to things in a C++ program. Those names are called identifiers, and they may consist of letters, digits and underscore characters. You've already seen some of these in the program fragments in this chapter. Some identifiers are reserved for the core language, and those identifiers are called keywords. This chapter has examples of some keywords, too. Chapter 2 explains identifiers in more detail and provides a list of reserved keywords. You learn the meaning and use of all the keywords as the lessons in later chapters proceed.

Procedural Statements

Procedural statements are assignments, expressions, or program flow control statements. Here’s an example:

float compute_pay(float wage, int hours)

{

    float pay;

    pay = wage * hours;

    if (hours > 40)

        pay = pay + (hours – 40) * wage / 2;

    return pay;

}

The compute_pay function has two integer parameters, wage and hours and returns a floating point value. We can probably assume from the name of the function and the names of its parameters that the function returns the pay value for an employee based on the employee’s wage and the number of hours the employee worked. Nothing in C++ requires you to assign meaningful names to things, but it's good practice to do so.

As you’ve probably guessed, integer values do not include fractional parts whereas floating point values do. For this simple example, we can assume that C++ floating point arithmetic is sufficient to manage dollars and cents. Chapter 2 has more information about float variables.

Let’s look at the compute_pay function one statement at a time. The statements begin following the open brace character ({) that follows the function’s declaration header.

The compute_pay function’s first statement declares a floating point variable named pay.

The second statement assigns to the pay integer the value returned by an expression that multiplies the wage parameter times the hours parameter. This statement is an assignment of the expression to a variable.

The third statement, which is on two lines of code, compares the hours parameter to the integer constant 40. That part of the statement is a conditional statement based on the boolean value returned by an expression. Chapter 4 explains conditional statements and boolean expressions.

If hours is greater than 40, the employee is paid time and a half for the extra hours worked. The pay variable already contains standard pay for all the hours, so, in the fourth statement, the function adds the overtime pay as one half the hourly rate times the hours over forty that were worked.

An expression is a program statement that returns a value. In the compute_pay function, the expression wage * hours returns the product of wage and hours. An expression such as hours > 40 returns a boolean true or false value. An expression such as

 pay + (hours – 40) * wage / 2

is a combination of several expressions, which, in this case, compute the pay amount.

An expression can stand on its own or be on the right side of an assignment statement as shown by this statement in the compute_pay function.

pay = pay + (hours – 40) * wage / 2;

Expressions consist of combinations of variables, constants, operators, and function calls. Chapter 2 has more detail about expressions.

Program Flow Control

C++ uses the control structures of structured programming, which include sequence (one statement executing after another), iteration (for and while loops), and selection (if-then-else and switch-case control structures). C++ also permits unstructured programming with the goto statement. Chapter 4 is all about controlling program flow with these language features.

Exception Handling

C++ supports exception handling with the throw/try/catch mechanism, which permits a program to make an orderly jump to a defined location higher in the program's executing hierarchy. Chapter 35 is about exception handling.

Templates

C++ supports the development of generic functions through its function template mechanism explained in Chapter 12.

C++ supports the design of generic parameterized types through its class template mechanism, a device that enables you to define and instantiate objects of generic data types. Chapter 25 explains class templates.

Namespaces

C++ addresses the issue of global namespace pollution with the namespace feature explained in Chapter 36. You can ensure that the global identifiers in your program do not conflict with those in third party libraries that you use by placing your code inside a unique namespace. The Standard C++ Library places all its global identifiers in the std namespace for just that reason.

Order of Declarations

You read a C++ program from the top to the bottom, but the functions do not have to be coded in that sequence. However, declarations of functions and variables must be coded in the program above any statements that reference them. That is, a function must be declared before the program calls it, and a variable must be declared before the program references it. You can declare a function by providing a function prototype that describes its name, return value, and parameters to the compiler. You must provide a function's prototype ahead of any calls to the function; you can put the function itself anywhere in the program. The function's declaration and all calls to it must match the prototype with respect to its return type and the types of its parameters. However, if the function itself is positioned in the source code ahead of any calls to it, the function can serve as its own prototype.

Let’s look now at a program that uses some of what you just learned.

Program 1-2: A Simple C++ program

float compute_pay(float wage, int hours)

{

    float pay;

    pay = wage * hours;

    if (hours > 40)

        pay = pay + (hours – 40) * wage / 2;

    return pay;

}

int main()

{

    float paycheck;

    paycheck = compute_pay(12.50, 43);

    return 0;

}

End of Program 1-2

Program 1-2 computes the paycheck value, but it doesn’t do anything with what it computes. You can step through the program with Quincy’s debugger and watch the variables change, but a real program ought to have input and output. We’ll remedy that situation in the next discussion.

The Standard C++ Library

The second part of the C++ language is the Standard C++ Library, which is a library of classes and functions written in C++ that support things common to most programming projects, including input and output.

Unlike languages such as COBOL, BASIC, and FORTRAN, C++ has no built-in input/output statements. Instead, input and output are implemented by C++ classes in the Standard C++ Library. Many features that are intrinsic parts of other languages are performed by classes in C++. Data conversions, string manipulations, and output formatting are three examples of operations that C++ supports with Standard C++ Library classes and functions rather than with intrinsic language features.

To demonstrate, we’ll use the Standard C++ Library iostreams to add input/output functionality to the program we just wrote.

 Program 1-3: A Simple C++ program with console I/O

#include

float compute_pay(float wage, int hours)

{

    float pay;

    pay = wage * hours;

    if (hours > 40)

        pay = pay + (hours – 40) * wage / 2;

    return pay;

}

int main()

{

    float paycheck;

    float wage;

    int hours;

    std::cout << Enter wage and hours: ;

    std::cin >> wage;

    std::cin >> hours;

    paycheck = compute_pay(wage, hours);

    std::cout << Pay = ;

    std::cout << paycheck;

    return 0;

}

End of  Program 1-3

Program 1-3 adds a lot to what you've seen so far. It includes a header file named by using the #include preprocessor directive. #include is explained in Chapter 2. Preprocessor directives are explained in Chapter 11. is introduced in Chapter 2 and discussed in more detail in Chapter 27.

Program 1-3's main function declares variables and writes a prompt to the std::cout object, which represents the standard output device, which is usually the console monitor. Then it reads data into variables from the std::cin device, which represents the standard input device, which is usually the console keyboard. The program then calls the compute_pay function, passing the input data as arguments. The compute_pay function computes and returns the pay amount, and the main function writes the returned amount to std::cout after which the main function returns zero to the operating system.

The std:: prefix on the cin and cout object references tells the compiler that those identifiers are in the std namespace, which is reserved for the Standard C++ Library.

Source Code Files

A C++ source-code module is a text file (usually ASCII) that you can read and modify with any text editor, such as the Windows Notepad applet. The Quincy development system (http://www.alstevens.com/tycpp) that accompanies this book integrates a programmer's editor with a compiler and debugger.

Like most contemporary compiled programming languages, C++ programs typically consist of multiple source-code modules that are compiled into object-code modules, which are then linked with object-code modules from libraries into a single executable program module. Much of the object code in a typical C++ program comes from packaged libraries of previously compiled, reusable software components implemented as classes or functions. Chapter 13 discusses the organization of a program into source code modules.

Summary

This chapter got you started toward your goal of learning the C++ programming language. You gained an initial, if cursory, insight into the fundamental structure of the C++ language. It's a lot to absorb in only a few lessons; do not expect to start writing complex C++ programs after having read only this one chapter. The chapters that follow start at the beginning and lead you through these topics one at a time in a sequence designed to build each lesson on what you have learned in previous lessons.

Chapter 2 - Writing Simple C++ Programs

In This Chapter

The main function

Identifiers and keywords

Source code comments

Variables and types

Expressions, assignments, and initializers

Console input and output

This chapter is the starting point, or, more precisely, the starting-over point. You saw three small programs in Chapter 1, but you didn't find out exactly what makes them tick. Now we'll start back at the beginning, learning every component of a C++ program one piece at a time in this and the following chapters.

Your First Program

As you learned in Chapter 1, C++ programs consist of variables and functions. A function consists of variable declarations and executable statements organized into nested statement blocks. As Program 1-1 demonstrates, a C++ program begins executing with a function named main. The best way to get started is with a real program. Program 2-1 is your first C++ program; one that has a main function and several other fundamental C++ language constructs.

Program 2-1: Your first C++ program

#include

int main()

{

    // write to the screen

    std::cout << My first C++ program;

    return 0;

}

End of Program 2-1

Program 2-1 is a tiny program that illustrates a lot of what makes up a C++ program. It has source-code comments, includes a standard library header file, and—from its main function—writes a message on the screen.

Program 2-1 displays a message onscreen and returns to the operating system. It does all that with only eight lines of code in a source-code file. The following sections examine Program 2-1 one line at a time.

The #include Directive

The first line of code in Program 2-1 looks like this:

#include

This statement is a preprocessing directive. I discuss the preprocessor in more detail in Chapter 11. The #include directive tells the compiler to include a different source-code file in the program. Program 2-1 includes the file named , a standard library header file that describes classes, functions, and global values used for console input and output. The listing includes the header file so that the program can use the cout object. Most programs in this book include . Don't worry about what else the header file contains just yet.

The file name in the #include directive is enclosed by angle brackets, another name for the combined use of the less-than and greater-than symbols. This usage identifies header files that the compiler system supplies. When you include your own header files, you surround those names with double quotes. Chapter 11 has more details about this usage.

White Space

The second line in Program 2-1 is a blank line. The C++ language is a free-form language, which means that white-space characters—newlines, spaces, tabs, and blank lines—are extra. Except for the rare occasion when two keywords or identifiers are separated by a space (such as else if) or inside string constants (described later), a program needs no white space at all to compile. Without white space, however, most programs are hard to read. Here is what Program 2-1 looks like without much white space:

#include int main(){// write to the screen

std::cout << My first C++ program;return 0;}

Programmers use white space to indent and separate code in various styles to make their programs legible. There are many styles for writing C++ code. I take no position with regard to style, although the exercises reflect my preferences. You will see other styles that use different conventions for indenting and the placement of brace characters, but there is no one right way. Choose a style that works for you, make it legible, and be consistent in its use.

The main Function Declaration

Line 3 in Program 2-1 looks like this:

int main()

This line declares the main function as a function that returns an integer (int) value and that accepts no arguments. Chapter 3 discusses function declarations in more detail.

The main Function's Statement Block

Line 4 consists of a single left brace ({) character to define the start of main's outermost  statement block. The statement block continues until the matching right brace (}) character on line 8. This portion of the program, which comprises the main function's single program block, looks like this:

{

    // write to the screen

    std::cout << My first C++ program;

    return 0;

}

Source-Code Comments

Line 5 contains a program comment in this format:

// write to the screen

Comments in a program's source code document the meaning of the code. They have no effect on the executable program itself. C++ comments begin with the characters // and continue to the end of the source-code line.

C++ also supports the traditional C comment format. C comments begin with the /* character sequence and continue through the */ character sequence like this:

/* write to the screen */

C comments may span several source-code lines and may not be nested. They may occupy lines of their own, or they may appear on lines that have other code.

C++'s // comments may not span source-code lines, because there is no comment termination code like the C */ token. This book uses C++'s // comment format exclusively, except in the rare C source-code module that contributes to a C++ program.

Use comments throughout your programs. Make them meaningful with respect to what they convey to programmers who might be reading your code. Do not make the two common mistakes that many programmers make: assuming that you will be the only programmer who reads your code and assuming that you will always remember why you wrote a program a certain way. Comments document your intentions. Use them.

At the same time, don't depend only on comments to convey the code's meaning. Strive to write code that is itself clear and meaningful. With properly written code you can keep comments to a minimum, using them only to add to what the code already says to the reader.

Writing to the Console

Line 6 is the most complicated line in the program. That line looks like this:

std::cout << My first C++ program;

This line's cryptic code tells the compiler to display a string constant on the screen. You learn more about displaying output later in this and subsequent chapters.

The return Statement

Line 7 is the statement that tells the main function to terminate processing and return a constant integer zero value to the operating system. Chapter 3 addresses the return statement in more detail. Constant expressions are discussed later in this chapter.

Terminating the Statement Block

Line 9, the last line in the program, contains the right brace (}) character that defines the end of the main function's statement block.

Identifiers

A C++ program consists of many elements—variables, functions, classes, and so on— all of which have names. The name of a function, variable, or class is called its identifier. As the programmer, you assign identifiers to the parts of your program. Other identifiers are assigned in the Standard C and C++ libraries. Following are the rules for identifiers in the C++ language.

An identifier must begin with a letter. (Underscores are permitted in the first character, but leading underscores are reserved for identifiers that the compiler defines.)

Identifiers are case sensitive. For example, MyFunc and myfunc are different identifiers.

An identifier may be any length, but only the first 32 characters are significant. Some early C implementations restricted the significance of external identifiers (ones with global scope) to six characters. This was because of limitations in the particular linker program and not because of any limitation in the C language.

An identifier may not be one of the reserved C++ keywords, as listed in the following section.

Keywords

The C++ language reserves a number of keywords. You must not use these keywords as identifiers in your program. Table 2-1 lists the C++ keywords.

Table 2-1: Standard C++ Keywords

C++ includes other keywords that also cannot be used as identifiers. These keywords—alternatives to the Standard C trigraphs—are designed for international keyboards that do not have the special characters used in English to express some operators. The Committee added these keywords so that international programs would be more readable. This book does not use any of these keywords, listed in Table 2-2, in any program.

Table 2-2: International C++ Keywords

The Standard Output Stream

The std::cout variable, seen in Program 2-1, is the C++ standard output stream object, which writes to the console:

std::cout << My first C++ program;

The string to be written is specified in the string constant, which is the character sequence between the double quotes. Just as a BASIC programmer knows that the PRINT statement writes data to the screen, a C++ programmer knows that the standard std::cout object does somewhat the same thing. The important difference is that PRINT is part of the BASIC language—an intrinsic operator—whereas cout happens to be the name that a programmer many years ago gave to the standard output stream object, which usually displays data on the console monitor, and std:: is the namespace for objects that the compiler defines for the Standard C++ Library.

A namespace is a way to isolate identifiers from other parts of the program and to prevent name collisions when various library writers and the programmers themselves inadvertently use the same identifier for different external declarations. You learn all about namespaces in Chapter 36. For now, accept the fact that identifiers that the Standard C++ Library (Part III) defines are in the namespace named std and that to reference those identifiers, you must prefix the references with the std:: prefix. Thus, all references to the cout object are made like this: std::cout. You see the std:: prefix on many other identifiers throughout this book.

The << operator is, in this context, the output operator. It is called the stream insertion operator, because you use it to insert data objects into the output stream. The operator points symbolically from what is being sent to where it is going.

You can think of std::cout, std::cin, and std::cerr (std::cin and std::cerr are described later in this chapter) as devices. In C++ stream input/output, std::cout, std::cin, and std::cerr are identifiers that name objects (instances) of classes. In the example just given, the string is being written to the std::cout object, which displays data on the standard output device, which is usually the console monitor. Later in this chapter, you learn how to display other data types.

This example is your first experience with C++ classes, the foundation of C++'s data abstraction and object-oriented programming support. A full understanding of the stream classes requires a thorough understanding of classes. For now, however, you need to understand only how a program uses objects of these classes so that you can manage console input/output. You learn more about classes beginning in Chapter 14.

Variables

You saw in Program 2-1 how a C++ program declares a function—in this case, the main function. Programs declare data variables, too. A variable is a storage location that contains a data value. Every variable has a type. The type defines the format and behavior of the variable. C++ supports character, integer, and floating-point data types. C++ has six intrinsic data types, also called built-in types. They are bool, char, wchar_t, int, float, and double. Here is how a program would instantiate an integer variable, for example.

int amount;

You can extend C++ and define your own types using the class, struct, and union constructs. We’ll talk more about these constructs in Chapter 6.

Each variable declaration in a program provides the variable's type and identifier. Variables can have other properties, as well. Integer type specifiers can include unsigned, long, or short to further define the type, like these examples.

long int bigamount;

unsigned int counter;

short int smallamount;

A double also can be a long double, increasing its precision.

You can use the static, extern, register, and auto storage classes to further define where a variable is stored and how it behaves in the program. There are const and volatile type qualifiers, too. You learn about these data properties in this and later chapters.

The size of a variable depends on its type. The size of each type depends on the C++ implementation and usually is expressed as the number of bytes an object of the type occupies in memory. The examples in this book use data types with sizes typical of 32-bit C++ compilers for the PC.

The bool Type

A bool variable is a two-state logical type that can contain one of two values: true or false. If you use a bool variable in an arithmetic expression, the bool variable contributes the integer value 0 or 1 to the expression depending on whether the variable is false or true, respectively. If you convert an integer to a bool, the bool variable becomes false if the integer is zero or becomes true if the integer is nonzero. Variables of type bool typically are used for runtime Boolean indicators and can be used in logical tests to alter program flow. Program 2-2 is an example of how the bool type is used.

Program 2-2: Using a bool variable

#include

int main

{

    bool senior;    // bool variable

    senior = true;  // set to true.

    // Test the senior variable.

    if (senior)

        std::cout << Senior citizen rates apply;

    return 0;

}

End of Program 2-2

Program 2-2 begins by declaring a bool variable named senior. The program introduces the assignment statement, which you study in more detail later in this chapter. An assignment statement assigns the value of an expression to a variable. The value can be any complex expression that returns a value of a compatible type. Until you learn more, however, the example programs use simple constants. In the case of Program 2-2, the constant is the reserved C++ keyword true, which, according to the rules of C++ semantics, can be assigned to a bool variable. The opposite of true is, of course, false.

Another new construct that you see in Program 2-2 is the C++ if statement, which tests whether the expression in parentheses is true or false. In this case, it is true, so the program executes the statement that follows, which displays a message on std::cout. You learn more about program flow control later in this chapter and in Chapter 4.

The char Type

A char variable contains one character from the computer's character set. Characters in PC implementations of the C++ language are contained in 8-bit bytes using the ASCII character set to represent character values. A program declares a character variable with the char type specification:

char ch;

This declaration declares a variable of type char with the identifier ch. Once you declare a variable in this manner, the program can reference it in expressions, which I discuss in the next section. Program 2-3 illustrates the use of a char variable.

Program  2-3: Using the char variable

#include

int main

{

    char c;          // char variable

    c = 'b';         // assign 'b' to c

    std::cout << c;  // display 'b'

    c = 'y';         // assign 'y' to c

    std::cout << c;  // display 'y'

    c = 'e';         // assign 'e' to c

    std::cout << c;  // display 'e'

    return 0;

}

End of Program  2-3

Program 2-3 employs std::cout three times to display three single characters on the screen:

bye

Program 2-3 also uses assignment statements to assign values to a char variable. The 'b', 'y', and 'e' values are ASCII character constant expressions in the C++ language.

If you think that there must be a better way to display the bye message, you're right. At the very least, you can send a bye string constant to std::cout as in Program 2-1. Program 2-3, however, contrives to show you how to declare and use the char data type.

The char data type is, in fact, an integer 8-bit numerical type that you can use in numerical expressions just as you use any other integer type. As such, a char variable can be signed or unsigned. You declare an unsigned char variable this way:

unsigned char c;

Unless they are unsigned, char variables behave like 8-bit signed integers when you use them in arithmetic and comparison operations.

The wchar_t Type

C++ includes the wchar_t type to accommodate character sets that require more than eight bits. Many foreign language character sets have more than 256 characters and cannot be represented by the char data type. An international standard character definition named Unicode is 16 bits wide. The wchar_t data type typically is 16 bits wide, but its actual width depends on the compiler implementation.

The Standard C++ iostream class library includes classes and objects to support wide characters. Program 2-4 repeats Program 2-3, but with the std::wout object—which is the wide-character version of the std::cout object.

Program 2-4: Using a wchar_t variable

#include

int main

{

    wchar_t wc;         // wide char variable

    wc = 'b';           // assign 'b' to wc

    std::wout << wc;    // display 'b'

    wc = 'y';           // assign 'y' to wc

    std::wout << wc;    // display 'y'

    wc = 'e';           // assign 'e' to wc

    std::wout << wc;    // display 'e'

    return 0;

}

End of Program 2-4

The GNU Compiler Collection (GCC) Standard C++ Library that Quincy uses does not yet implement wide character library classes and stream objects. Consequently, Program 2-4 does not compile and run with the compiler. You can, however, compile and run it with many commercial Standard C++ compilers.

The int Type

Variables of integral types come in several varieties. The basic integer is a signed quantity that you declare with the int type specifier, like this:

int Counter;

An integer can be signed, unsigned, long, short, or a plain signed integer such as the one just shown. The following declarations display some of the different kinds of integers:

long int Amount;           // long integer

long Quantity;             // long integer

signed int Total;          // signed integer

signed Kellie;             // signed integer

unsigned int Offset;       // unsigned integer

unsigned Offset;           // unsigned integer

short SmallAmt;            // short integer

short int Tyler;           // short integer

unsigned short Landon;     // unsigned short integer

unsigned short int Woody;  // unsigned short integer

As the examples show, you can omit the int keyword when you specify long, short, signed, or unsigned. A long integer usually is 32 bits. A short integer usually is 16 bits. Quincy uses 16-bit short integers and 32-bit integers and long integers.

The signed qualifier is redundant, because the integral types are signed unless you specify the unsigned qualifier. C++ includes the signed keyword mainly to preserve symmetry in the language specification. Program 2-5 illustrates the use of the int data type.

Program 2-5: Using an int variable

#include

int main

{

    int Amount;           // an int variable

    Amount = 123;         // assign a value

    std::cout << Amount;  // display the int

    return 0;

}

End of Program 2-5

Program 2-5 declares an int variable named Amount. Next, it assigns an integer constant value to the variable. Then, it displays the variable on the console.

When a type has several properties, you can place the type keywords in any sequence. The following declarations are all the same:

// 8 ways to declare an unsigned long integer.

unsigned long Tyler1;

long unsigned Tyler2;

unsigned long int Tyler3;

unsigned int long Tyler4;

long unsigned int Tyler5;

long int unsigned Tyler6;

int unsigned long Tyler7;

int long unsigned Tyler8;

Floating-Point Numbers

C++ supports three kinds of floating-point numbers, which are distinguished by their precision. Following are declaration examples for all three:

float Amount;                 // single precision

double BigAmount;             // double precision

long double ReallyBigAmount;  // long double precision

Standard C++ does not specify the range of values that floating-point numbers can contain. These ranges depend on the particular implementation of the C++ language. The standard defines a header file, , with global symbols that identify the ranges.

Now that you know about the ranges of floating-point numbers, you can forget about them for a while. This book has very little math, using only what you need in Chapter 26 to demonstrate some standard math functions. If you are mathematically inclined, you already know about precision, mantissas, exponents, scientific notation, and so on. If not, you can write C++ programs for the rest of your life without ever having to know more about math than you do now. Program 2-6 illustrates the declaration and use of the float data type.

Program 2-6: Using a float variable

#include

int main

{

     float realValue;         // a float variable

     realValue = 1.23;        // assign a value

     std::cout << realValue;  // display the float

     return 0;

}

End of Program 2-6

Program 2-6 declares a float variable named realValue. Next, it assigns a constant value to the variable. Then, it displays the value.

Constants

The next section explains C++ expressions, which consist of variables, operators, and constants. You already have learned about variables, and you have used some constants in the exercises. Now, let's discuss constants in a C++ program.

Constants, in this context, are what some languages call literals and others call immediate values. They are constant values that you use explicitly in expressions. A constant is distinguished from a variable in two ways. First, it has no apparent compiled place in memory except inside the statement in which it appears. Second, you cannot address the constant or change its value. Be aware that these constants are not the same as the const variable type qualifier discussed in Chapter 5.

Character Constants

Character constants specify values that a char variable can contain. Program 2-3 assigns character constants to a char variable. You can code a character constant with an ASCII expression – as shown in Program 2-3 or as an escape sequence surrounded by single quote characters The following statements are assignments of character constants to char variables:

ch1 = 'A';    // ASCII char constant

ch3 = '\x2f'; // char constant expressed as hex value

ch3 = '\013'; // char constant expressed as octal value

Escape Sequences

The backslash in the second and third examples just shown begins an escape sequence. It tells the compiler that something special is coming. In this case, \x means that the characters that follow are hexadecimal digits, and \0 (backslash-zero) means that the characters that follow are octal digits. Other escape sequences—consisting of a backslash and other characters that represent ASCII values—do not have a displayable character (one that you can type and print) in the character set. These escape sequences apply to character constants and string constants, as described later. Table 2-3 shows all the escape sequences.

Table 2-3: Constant Escape Sequences

The backslash-backslash (\\) escape sequence enables you to code the backslash character itself into the constant so that the compiler does not translate it as an escape sequence. The single quote (\') and double quote (\") escape sequences allow you to include those characters in character and string constants so that the compiler does not interpret them as the terminating character of the constant itself.

The newline (\n) escape sequence probably is the one you will use the most. When a screen output function finds a newline character in the output data, it resets the cursor to the leftmost column on the screen and moves the cursor down one line. The newline character acts like a carriage return on a typewriter.

Integer Constants

An integer constant specifies a long or short, signed or unsigned integer value.

Quincy supports signed short integer values of -32768 to +32767, and unsigned short integer values of 0 to 65535. These are the ranges that you can represent in a 16-bit integer.

The int and the long int are both 32 bits in Quincy. Quincy supports signed long integer values of -2147483648 to +2147483647 and unsigned long integer values of 0 to 4294967295. These are the ranges that you can represent in a 32-bit integer.

You can specify an integer constant as a decimal, hexadecimal, or octal value, as shown in these statements:

Amount = -129;     // decimal integer constant HexAmt = 0x12fe;   // hexadecimal integer constant

OctalAmt = 0177;   // octal integer constant

The leading 0x specifies that the constant is a hexadecimal expression. It can contain the digits 0-9 and the letters A-F in mixed uppercase or lowercase. A leading zero alone specifies that the constant is octal and may contain the digits 0-7.

You can specify that a constant is long or unsigned by adding the L or U suffix to the constant:

LongAmount = 52388L;    // long integer constant

LongHexAmt = 0x4fea2L   // long hex constant

UnsignedAmt = 40000U;   // unsigned integer constant

The suffixes can be uppercase or lowercase. On compiler systems in which int and long are the same length (Quincy, for example), the L suffix is unnecessary; but you should use it if you expect your program to be portable across compiler platforms that support other int lengths. Many older MS-DOS compilers, for example, have 16-bit integers and 32-bit long integers.

Floating-Point Constants

A floating-point constant consists of integer and fractional parts separated by a decimal point. Some floating-point constants use scientific, or exponential, notation to represent numbers too big or too small to express with normal notation. Here are some examples:

Pi = 3.14159;      // regular decimal notation

SmNbr = 1.234E-40; // 1.234 x 10 to the -40th power

BigNbr = 2.47E201; // 2.47 x 10 to the 201st power

Floating constants default to the double type unless you provide a suffix on the constant:

FloatNbr = 1.23E10F    // float constant

LongDoubleNbr = 3.45L  // long double constant

The suffixes can be uppercase or lowercase.

Address Constants

When you begin to use pointers in C++ programs, a subject covered in Chapter 8, you use address constants. Variables and functions have memory addresses, and C++ enables you to reference their addresses with address constants as shown here:

CounterPtr = &Counter;   // address of a variable

FunctPtr = &DoFunction;  // address of a function

Address expressions of array elements can be non-constant expressions, too. Chapter 7 discusses arrays.

String Constants

Program 2-1 passes My first C++ program, a string constant (also called a string literal), to the std::cout object. You code a string constant as a sequence of ASCII characters surrounded by double quote characters. Escape sequences inside the string constant work the same as they do in character constants. Here are some examples of string constants:

cp = hello, dolly;

std::cout << \nEnter selection: ;

std::cout << \aError!;

The first statement apparently assigns a string constant to a variable, but it really assigns the address of the string constant to a pointer variable (refer to Chapter 8). The compiler finds a place in memory for the string constant and compiles its address into the statement.

The same thing happens in the second and third statements in the example. The compiler passes the addresses of the string constants to the std::cout object.

The string constants in the second and third statements include escape sequences. The second statement's escape sequence is \n, the newline character. The third statement's escape sequence is \a, the audible alarm character, which beeps the computer's speaker.

Adjacent string constants concatenate to form a single string constant. This feature allows you to code long string constants on multiple source-code lines, as shown in Program 2-7.

Program 2-7: Concatenated string constants

#include

int main

{

    std::cout <<

     This is the beginning of a very long message\n

     that spans several lines of code.\n

     This format allows a program to build long\n

     string constants without going past the\n

     program editor's right margin.\n;

    return 0;

}

End of Program 2-7

Expressions

Statements in a function body consist of individual expressions terminated by the semicolon (;) character. All statements and declarations in C are terminated that way. The statement is not complete until the semicolon appears.

An expression is a combination of constants, variables, function calls, and operators that, when evaluated, returns a value. Following are some typical C++ expressions:

1+2;Counter*3;

GrossPay-(FICA+GrossPay*WithHoldingRate);

By themselves, these expressions do nothing. They return values, but they have no effect because the program does nothing with the returned