Section 1.1. Writing a Simple C Program

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.

Note the semicolon at the end of the return statement. Semicolons mark the end of most statements in C++. They are easy to overlook, but when forgotten can lead to mysterious compiler error messages.

When the return includes a value such as , 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 is an int .

On most systems, the return value from main is a status indicator. A return value of 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 namefor 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

Invoking the GNU or Microsoft Compilers

The command used to invoke the C++ compiler varies across compilers and operating systems. The most common compilers are the GNU compiler and the Microsoft Visual Studio compilers. By default the command to invoke the GNU compiler is g++ :


$ g++ prog1.cc -o prog1

where $ is the system prompt. This command generates an executable file named prog1 or prog1.exe , depending on the operating system. On UNIX, executable files have no suffix; on Windows, the suffix is .exe . The -o prog1 is an argument to the compiler and names the file in which to put the executable file. If the -o prog1 is omitted, then the compiler generates an executable named a.out on UNIX systems and a.exe on Windows.

The Microsoft compilers are invoked using the command cl :


C:\directory> cl -GX prog1.cpp

where C:directory> is the system prompt and directory is the name of the current directory. The command to invoke the compiler is cl , and -GX is an option that is required for programs compiled using the command-line interface. The Microsoft compiler automatically generates an executable with a name that corresponds to the source file name. The executable has the suffix .exe and the same name as the source file name. In this case, the executable is named prog1.exe .

For further information consult your compiler's user's guide.

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%

Exercises Section 1.1.1

Exercise 1.1:
Review the documentation for your compiler and determine what file naming convention it uses. Compile and run the main program from page 2.

Exercise 1.2:
Change the program to return -1 . A return value of -1 is often treated as an indicator that the program failed. However, systems vary as to how (or even whether) they report a failure from main . Recompile and rerun your program to see how your system treats a failure indicator from main .