Getting Started: The Basic Elements of C++
- Writing a Simple C++ Program
- A First Look at Input/Output
- A Word About Comments
- Control Structures
- Introducing Classes
- The C++ Program
- Chapter Summary
- Defined Terms
This chapter is from the book
This chapter is from the book
This chapter is from the book
CONTENTS
|
Section 1.1 Writing a Simple C++ Program |
2 |
|
Section 1.2 A First Look at Input/Output |
5 |
|
Section 1.3 A Word About Comments |
10 |
|
Section 1.4 Control Structures |
11 |
|
Section 1.5 Introducing Classes |
20 |
|
Section 1.6 The C++ Program |
25 |
|
Chapter Summary |
28 |
|
Defined Terms |
28 |
This chapter introduces most of the basic elements of C++: built-in, library, and class types; variables; expressions; statements; and functions. Along the way, we'll briefly explain how to compile and execute a program.
Having read this chapter and worked through the exercises, the reader should be able to write, compile, and execute simple programs. Subsequent chapters will explain in more detail the topics introduced here.
Learning a new programming language requires writing programs. In this chapter, we'll write a program to solve a simple problem that represents a common data-processing task: A bookstore keeps a file of transactions, each of which records the sale of a given book. Each transaction contains an ISBN (International Standard Book Number, a unique identifier assigned to most books published throughout the world), the number of copies sold, and the price at which each copy was sold. Each transaction looks like
0-201-70353-X 4 24.99
where the first element is the ISBN, the second is the number of books sold, and the last is the sales price. Periodically the bookstore owner reads this file and computes the number of copies of each title sold, the total revenue from that book, and the average sales price. We want to supply a program do these computations.
Before we can write this program we need to know some basic features of C++. At a minimum we'll need to know how to write, compile, and execute a simple program. What must this program do? Although we have not yet designed our solution, we know that the program must
- Define variables
- Do input and output
- Define a data structure to hold the data we're managing
- Test whether two records have the same ISBN
- Write a loop that will process every record in the transaction file
We'll start by reviewing these parts of C++ and then write a solution to our bookstore problem.
1.1 Writing a Simple C++ Program
Every C++ program contains one or more functions, one of which must be named main . A function consists of a sequence of statements that perform the work of the function. The operating system executes a program by calling the function named main. That function executes its constituent statements and returns a value to the operating system.
Here is a simple version of main does nothing but return a value:
int main()
{
return 0;
}
The operating system uses the value returned by main to determine whether the program succeeded or failed. A return value of 0 indicates success.
The main function is special in various ways, the most important of which are that the function must exist in every C++ program and it is the (only) function that the operating system explicitly calls.
We define main the same way we define other functions. A function definition specifies four elements: the return type, the function name, a (possibly empty) parameter list enclosed in parentheses, and the function body. The main function may have only a restricted set of parameters. As defined here, the parameter list is empty; Section 7.2.6 (p. 243) will cover the other parameters that can be defined for main.
The main function is required to have a return type of int, which is the type that represents integers. The int type is a built-in type, which means that the type is defined by the language.
The final part of a function definition, the function body, is a block of statements starting with an open curly brace and ending with a close curly:
{
return 0;
}
The only statement in our program is a return, which is a statement that terminates a function.
When the return includes a value such as 0, that value is the return value of the function. The value returned must have the same type as the return type of the function or be a type that can be converted to that type. In the case of main the return type must be int, and the value 0 is an int.
On most systems, the return value from main is a status indicator. A return value of 0 indicates the successful completion of main. Any other return value has a meaning that is defined by the operating system. Usually a nonzero return indicates that an error occurred. Each operating system has its own way of telling the user what main returned.
1.1.1 Compiling and Executing Our Program
Having written the program, we need to compile it. How you compile a program depends on your operating system and compiler. For details on how your particular compiler works, you'll need to check the reference manual or ask a knowledgeable colleague.
Many PC-based compilers are run from an integrated development environment (IDE) that bundles the compiler with associated build and analysis tools. These environments can be a great asset in developing complex programs but require a fair bit of time to learn how to use effectively. Most of these environments include a point-and-click interface that allows the programmer to write a program and use various menus to compile and execute the program. Learning how to use such environments is well beyond the scope of this book.
Most compilers, including those that come with an IDE, provide a command-line interface. Unless you are already familiar with using your compiler's IDE, it can be easier to start by using the simpler, command-line interface. Using the command-line interface lets you avoid the overhead of learning the IDE before learning the language.
Program Source File Naming Convention
Whether we are using a command-line interface or an IDE, most compilers expect that the program we want to compile will be stored in a file. Program files are referred to as source files. On most systems, a source file has a name that consists of two parts: a file name—for example, prog1—and a file suffix. By convention, the suffix indicates that the file is a program. The suffix often also indicates what language the program is written in and selects which compiler to run. The system that we used to compile the examples in this book treats a file with a suffix of .cc as a C++ program and so we stored this program as
prog1.cc
The suffix for C++ program files depends on which compiler you're running. Other conventions include
prog1.cxx
prog1.cpp
prog1.cp
prog1.C
Running the Compiler from the Command Line
If we are using a command-line interface, we will typically compile a program in a console window (such as a shell window on a UNIX system or a Command Prompt window on Windows). Assuming that our main program is in a file named prog1.cc, we might compile it by using a command such as:
$ CC prog1.cc
where CC names the compiler and $ represents the system prompt. The output of the compiler is an executable file that we invoke by naming it. On our system, the compiler generates the executable in a file named a.exe. UNIX compilers tend to put their executables in a file named a.out. To run an executable we supply that name at the command-line prompt:
$ a.exe
executes the program we compiled. On UNIX systems you sometimes must also specify which directory the file is in, even if it is in the current directory. In such cases, we would write
$ ./a.exe
The "." followed by a slash indicates that the file is in the current directory.
The value returned from main is accessed in a system-dependent manner. On both UNIX and Windows systems, after executing the program, you must issue an appropriate echo command. On UNIX systems, we obtain the status by writing
$ echo $?
To see the status on a Windows system, we write
C:\directory> echo %ERRORLEVEL%