1. Creating a Basic Program

Writing applications in C++ is a multistep process. You must first define the purpose and needs of the application. Once you know explicitly what an application should do, you can begin the actual coding. When you finish programming, you then compile the C++ code into an executable application. If the compilation process worked, you can then run the executable application to see the results of your hard work. In reality, of course, there’s an interim step of debugging, debugging, and debugging, followed by a wee bit more debugging.

In this chapter, you’ll learn how to program, compile, and run a C++ application. The information presented and the techniques described in this chapter will be the foundation for all of the book’s subsequent material, as well as the basis for your life as a C++ programmer.

This chapter begins with the basic syntax and instructions for creating a quick C++ source file. Then you’ll see how to compile and execute this application. Next up, you’ll learn how to print messages using C++ and how to momentarily pause the execution of an application. The final two coding techniques show how to use blank spaces and comments in your code. Once you are equipped with an understanding of all of these fundamentals, the chapter wraps up by demonstrating how to create basic C++ programs using two free and popular development applications.

Basic C++ Syntax

If you have never programmed before, it may be surprising how easily you can create a simple application. C++ code is merely plain text written in any text editor. The text file is normally given a .cpp extension and will then be compiled—as you’ll see in the next section of this chapter—in order to create an executable application.

The barebones syntax for a C++ file is

int main() {
    return 0;
}

These three lines define a function called main. When a C++ program is executed, this function is automatically called. In other words, when you run an application, whatever you’ve programmed the main() function to do is what will happen. It’s important to note that C++ is generally case-sensitive, so you have to type your code exactly as it is in the book. If you enter Int instead of int, Main instead of main, or RETURN instead of return, the program will not work (you’ll see errors when you go to compile the program).

The contents of a function (the stuff that actually happens) are placed between the opening and closing curly braces. This area is called the body of a function. As a matter of form, a function’s entire body is normally indented so that its relationship to the function is clear.

In this example, the function does only one thing: it returns the number 0. In later chapters you’ll learn more about having functions return values, but for now just remember two things:

1. The type of value returned—a number, a character, or whatever—corresponds to the function’s definition. In this example, the int before main() means that the function will return an integer.
2. As a standard practice, having the main() function return a value of 0 indicates that no problem occurred.

In order to understand the process of programming and compiling a C++ file, the first example in the book will contain just this minimal code. Before you begin, see the sidebar on the various kinds of tools you may use in developing C++ applications.

To create a C++ source file

1. Open your text editor.

   C++ applications begin as plain-text source files. These can be written in any text editor that allows you to save files as plain text (like Notepad on Windows). Obviously some choices (like BBEdit for the Mac or vi or emacs for Unix) are better than others. Some text editors, like TextEdit or WordPad, will always try to save files as Rich Text Format (.rtf) or with an extra extension. You should avoid using these editors for that very reason.

2. Create a new, blank text document.
3. Begin defining the main() function (Script 1.1):

   int main() {
   

   Script 1.1. These three lines represent the minimal code that a C++ program could contain. A program that doesn’t actually do anything, that is!

   

   Again, this line begins the definition of a user-defined function called main. It will return an integer value. The opening curly brace marks the beginning of the function’s body.

4. Add the return line to the function:

   return 0;
   

   Many functions in C++ return a value, even if it’s just the number 0. This value is meant to reflect that no errors occurred.

   Again, this line is normally indented four spaces (or one tab) to indicate that it’s part of the function.

5. Close the main() function:

   }
   

   Don’t forget the closing curly brace! This marks the end of the main() function definition. You may also want to press Return (Mac) or Enter (PC) after the curly brace, or else you’ll see a warning (in some environments) when you go to compile the application.

6. Save the file as first.cpp.

   Remember that C++ source files use the .cpp extension. This one will be called first, as it’s the first—and otherwise pointless—program.

   To maintain a tidy computer, you should probably create a folder in which to store all of the C++ code. Perhaps within this you would create subfolders, one for each chapter in the book. In any case, pay attention as to where you save first.cpp, as you’ll need to remember that location for the next sequence of steps.

Compiling a C++ Program

Simply put, a compiler does the critical task of taking your C++ source code and turning it into an executable program (one that can be run). It takes high-level instructions and generates the proper low-level machine code that the computer can understand. Every C++ source code file must be compiled in order to execute it, and you must recompile a file after making any changes.

There are two ways you can compile and run your C++ code:

• By using a command-line prompt with a stand-alone compiler

• By using the compiler and features built into an IDE

In the following steps, you will see how to use a command-line compiler. At the end of the chapter you’ll see how to use an IDE’s built-in compiler. Obviously, using an IDE is the easier method, but knowing how to use command-line tools is worthwhile.

Of the existing compilers, g++ is commonly used for C++. The simplest syntax for compiling a file is

g++ filename.cpp

That line tells the g++ compiler to compile the filename.cpp file. If the compilation process worked, an object file will be created called filename.o. If there are problems with your code, error messages will be displayed (Figure 1.1).

Figure 1.1. The compiler will report on any problems it finds in your C++ code.

If the compilation succeeded, the compiler will then automatically invoke a linker, which combines all the necessary code into one nice, executable file. The result will be the oddly named a.out on Unix systems (including Mac OS X) and a.exe on Windows. (Most linkers will automatically delete the original .o file at this point, too.) You can give the resulting application a specific name by using the -o flag with g++:

g++ -o testing filename.cpp

This line will compile filename.cpp and, if successful, will create an executable called testing.

To try your hand at this critical step, you can compile first.cpp. Keep in mind that you can follow these steps only if you’ve installed a compiler on your system. For instructions, see Appendix A, “C++ Tools.”

To compile C++ from the command line

1. Access a command-line prompt.

   How you do this depends upon your operating system:

   • On Windows, you should click the Start menu, select Run, type cmd in the Open text box (Figure 1.2), and press Enter or click OK. This will bring up a DOS prompt (Figure 1.3).

   Figure 1.2. To access a command-line prompt in Windows, run the cmd utility.

   

   Figure 1.3. You can perform all of the necessary command-line steps from within this Windows console.

   

   • For Mac OS X and Unix, use the Terminal application (Figure 1.4). Open it by double-clicking its icon in the Utilities or Applications folder (depending on your OS).

   Figure 1.4. The Terminal application (here, on Mac OS X) provides a command-line interface to your computer.

   

   (We’ve customized the look and prompts in our applications, so don’t worry if what you see looks different.)

2. Type cd /path/to/directory and press Return (Mac) or Enter (PC).

   To compile your first.cpp application, you’ll want to be within the directory where it was saved. The cd command will accomplish that, but you’ll need to change /path/to/directory to correspond to the location of the file and the operating system being used. You might end up using something like

   cd C:Documents and SettingsLarry UllmanCppCh01 (Windows)

   or

   cd ~/Documents/Programming/Cpp/Ch01 (Mac OS X, where ~ represents your home directory)

3. Type g++ -o first first.cpp and press Return or Enter (Figure 1.5).

   Figure 1.5. Compiling the first application using g++ on Windows.

   

   Assuming that g++ has been installed on your computer, this command will compile the first.cpp file. If no errors occurred (which really should be the case, as there are only three lines), the result will be a file called first (formally first.exe on Windows).

   If you do not have the g++ compiler on your computer (in which case, you’ll see an error message saying as much), you’ll need to install it per the instructions in Appendix A. Alternatively, if the command indicated that the compiler could not be found, you may need to use an absolute path to the compiler in order to use it. For example:

   /usr/bin/g++ -o first first.cpp (Unix and Mac OS X)

   C:ing++ -o first first.cpp (Windows)

4. Check the contents of the directory to make sure that the build worked.

   You can either view the directory in the Explorer (Windows) or Finder (Mac OS X) or use the proper command-line prompt. This would be either

   dir (Windows)

   or

   ls (Unix and Mac OS X, as shown in Figure 1.6)

   Figure 1.6. The current directory now contains both the original C++ source code file (first.cpp) and the newly created executable (first).

   

5. Type exit and press Enter or Return to close the console session.

   This will close the console window on Windows; other users may need to close the window or quit the application as a separate step.

Printing Text

If you were to run the successfully compiled first.cpp program, you’d see, well, nothing (Figure 1.7). This makes perfect sense, as the main() function only returns a value of 0 without doing anything else. To make an application that does a little something, have C++ print a message using this syntax:

int main() {
    std::cout << "Testing";
    return 0;
}

Figure 1.7. Although the first C++ program has been compiled and can be run, it doesn’t actually do anything as of yet.

This construct looks rather strange to a new C++ programmer, so we’ll break it down into its parts. First of all, cout, which stands for console out, is a stream, an avenue through which data can be transferred (the std:: also has special meaning, which you’ll learn in time). The << is an operator used to insert the following text (Testing) into the cout stream. Finally, the line concludes with a semicolon, which indicates the completion of a statement. All statements in C++ must end with a semicolon, as you already saw with return. So in short, this line of code says “take this string of text and put it in the console output.”

Unfortunately, printing messages is slightly more complicated than just that one line. The cout stream is defined in a special library of code called a header file. In order to refer to cout, the header file itself must be brought into this code, using a preprocessor directive (see the sidebar “Preprocessor Directives” later in this chapter). It sounds complicated, but it’s just a matter of coding

#include <iostream>

This line states that the iostream package should be included as part of this application. Including a library has the same effect as making that file’s contents part of this document (but without the extra typing or lines of code). Note that preprocessor directives are placed outside of, and before, the main() function.

The complete code is therefore

#include <iostream>
int main() {
    std::cout << "Whew!";
    return 0;
}

Script 1.2. This, your second C++ program, prints a message to the console window using the cout stream.

While all of this code may seem like a lot of work just to print a simple message, it will become second nature as you master the underlying purposes of each element. Using this new bit of code, you can modify the existing application so that it actually does something.

To print text in C++

1. Open first.cpp (Script 1.1) in your text editor.
2. Before the main() function definition, add the following (Script 1.2):

   #include <iostream>
   

   To use cout in your program, this library must be included.

3. Within the main() function but before the return line, add

   std::cout << "Hello, World!";
   

   You haven’t programmed until you’ve written a classic Hello, World! example. This is a staple of every programming book and tutorial.

4. Save the file as hello.cpp.

   So as not to overwrite the first example, you should give this file a new name, one that is descriptive of what the file does.

5. Compile hello.cpp using the instructions outlined in the preceding section of this chapter (Figure 1.8).

   Figure 1.8. Compiling hello.cpp using g++ on Mac OS X.

   

   You’ll need to access the same directory where hello.cpp is found using a command-line interface. Then invoke the compiler with

   g++ -o hello hello.cpp
   

Running a Compiled Program

Now that you’ve written and compiled two C++ applications (albeit simple ones), it’s time to actually execute them to see the results of your work. Once you’ve successfully compiled an application (in other words, no errors were found), you are left with an executable file. Regardless of the operating system, you can run this application from the command line, just as you compiled it using a command-line compiler.

On Windows, you can simply type the full name of the application to run it:

first

You can also use the formal

first.exe

This will work as long as you are in the same directory as the executable. Otherwise, you could use a full path:

C:Documents and SettingsLarry UllmanCppCh01first

On Unix and Mac OS X, you can also type the full path to the executable:

/Users/larry/Cpp/Ch01/first

If you are in the same directory as the file, you’ll need to precede the executable’s name with ./, like so:

./first

To run a C++ program

1. Access a command-line prompt.

   To reiterate, this means you either...

   • Click the Start menu, select Run, type cmd in the Open text box, and press Enter (for Windows users).

   or

   • Use the Terminal application that came with your operating system (Unix and Mac OS X).

2. Type cd /path/to/directory and press Return (Mac) or Enter (PC).

   Again, you’ll want to be within the directory where the hello.cpp file was saved and compiled. Change /path/to/directory to correspond to the location of the file and the operating system being used.

3. Run the file.

   The syntax for running the file will depend on your operating system:

   hello (Windows; see Figure 1.9)

   Figure 1.9. By running the hello application, you can see the results of the programming.

   

   or

   ./hello (Mac OS X, see Figure 1.10, and Unix)

   Figure 1.10. Running the same C++ code on Mac OS X (although compiled separately on the Mac). Notice how the next command prompt appears immediately after the Hello, World! message (you’ll learn how to fix that later in the chapter).

   

4. Type exit and press Enter or Return to close the console session.

   This should close the DOS prompt on Windows. On other operating systems you may need to formally quit the application or close the Terminal window after exiting the session.

Pausing Execution

There is, in fact, another way you can run your compiled application: simply double-click it in the Explorer (Windows) or Finder (Mac OS X). On Mac OS X, the application will open in a new Terminal window, execute the program, and then log out of that window (Figure 1.11). On Windows a new console window will open, the application will run, and the console window will close, all in the blink of an eye. Without the benefit of time-lapse photography or superhero powers, you won’t be able to see the results for yourself.

Figure 1.11. Double-clicking a compiled C++ application on Mac OS X runs that program in a new Terminal window.

In order to give yourself the chance to see your program in action, a little trick can be used. By adding the line

std::cin.get();

to your C++ source code, you force the compiled application to wait until the user presses Enter or Return before it can continue executing. As you might infer, whereas cout stands for console out, cin is console in, which takes input from (in this case) the keyboard.

To keep your application open

1. Open hello.cpp (Script 1.2) in your text editor.
2. After the Hello, World! line and before return, add the following lines (Script 1.3):

   std::cout << "Press Enter or Return to continue.";
   std::cin.get();
   

   Script 1.3. In this version of the Hello, World! application, the program waits for the user to press Enter or Return before completing its steps.

   

   The std::cin.get() call should be the penultimate line in the main() function, coming after the Hello, World! message but before the return. The end result of this is that the function will print the message, wait for the user, and then return 0 and exit.

   To indicate to the user that they need to do something, an instructional message is added as well.

3. Save the file as pause.cpp.
4. Compile the file (Figure 1.12).

   g++ -o wait pause.cpp
   

   Figure 1.12. While compiling the pause.cpp file on Windows, the application is given a new, unique name (because Windows already has a pause command).

   

   Because the -o flag allows you to give the compiled application any name you choose, the executable can be called wait (or trout or doodle or whatever). This is necessary on Windows, as there is already a built-in utility named pause.

5. Run the compiled wait application (Figure 1.13).

   Figure 1.13. The wait application requires that the user press Enter or Return before it finishes its execution.

   

   You can run this application using the command line (as shown in the preceding sequence of steps) or by double-clicking the executable file itself. Figure 1.14 shows the results of running the same application on Mac OS X.

   Figure 1.14. How the wait application looks when executed on Mac OS X.

   

Understanding White Space

While the functionality of the applications created so far is just dandy, there is room for improvement before getting into meatier examples. If you look at Figures 1.13 and 1.14, you’ll notice that all of the printed text appears on one line (meaning also that Press is immediately next to the exclamation mark ending Hello, World!). Furthermore, the source code itself (Script 1.3) is bunched together. By judiciously understanding and using white space—spaces, tabs, carriage returns, and newlines, both the raw code and the resulting application can be much improved.

C++, like many languages, is generally white space insensitive. This means that you can add blank lines to make your scripts easier to read and you can use spaces to indent code, as you’ve already seen. This is a critical concept in making your code more approachable.

A related issue is how to add white space to the messages printed by an application. For example, to add a newline to the outputted message, print the newline character:

std::cout << "There will be a break here: ";

An alternative is to use the special marker endl. The endl indicates that all of the preceding information should be sent to the output and then the cursor should be moved to the next line:

std::cout << "Some text" << std::endl;

The syntax for using endl is different than that for using (because endl must also be inserted into the stream), but the end result will be the same.

To demonstrate how white space works in C++, you’ll fix the pause.cpp example so that the source code is spaced out a little nicer and so that the result is more legible.

To add white space to your file

1. Open pause.cpp (Script 1.3) in your text editor.
2. After the #include line, press Return or Enter once to add a blank line (Script 1.4).

   This blank line will help to separate out the preprocessor directive from the main() function itself.

   Script 1.4. Spacing has been added to the source code and to the executed result (thanks to the newline character) for a more legible and professional application.

   

3. After the initial function definition line, add another blank line.
4. Use blank lines within the main() function to separate out unrelated blocks of code.
5. Change the initial cout line to read as follows:

   std::cout << "Hello, World! ";
   

   The addition of at the end of the string will create a break after that text, as if you pressed Return (or Enter). The end result will be a little bit clearer when the application is executed.

6. Save the file as space.cpp.
7. Compile and run space.cpp using the methods already covered (Figure 1.15).

   Figure 1.15. The addition of the newline character makes the second sentence print on its own line (compare with Figure 1.14).

   

Adding Comments to Your Source Code

Although they do nothing for the functionality of an application, comments are a critical part of any programming language. Comments are necessary to remind yourself—while you’re initially developing an application or when you come back months later—why you did certain things. These are some of the most common uses for comments:

• State the purpose of a file.

• Document who created a file and when.

• Note the thinking behind a function.

• Clearly indicate the meaning of variables.

• Explain why particular numbers are used.

• Mark contingencies or assumptions being made.

C++ supports two comment formats. The first and standard format uses two slashes together:

// This is a comment.

By using a double slash, you indicate that anything from that point until the end of the line is a comment, so it can even be used after some code:

return 0; // No problems.

The second format, which comes from C, uses opening and closing characters to indicate where a comment begins and ends. This format allows you to write comments over multiple lines:

/* Multiline comments have start and end delineators. */

While allowed in C++, this style of comment is less often used.

With this in mind, let’s rewrite space.cpp so that it’s properly documented.

To add comments

1. Open space.cpp (Script 1.4) in your text editor.
2. As the very first line, before #include, add comments describing this file (Script 1.5):

   // comment.cpp - Script 1.5
   // Created by Larry Ullman and Andreas Signer
   // July 15, 2005
   

   Script 1.5. Comments are used to document the purpose of a program as well as the role of individual lines of code.

   

   C++ should begin with documentation such as this, indicating the purpose of the file, who created it, when, why, etc. Throughout the rest of the book, you’ll see that the very first comment in every program indicates both the name and script number of the file.

3. Before the cin.get() line, add a comment indicating its purpose:

   // Wait for the user to press Enter or Return.
   

   This simple comment states exactly why the function is being called. It’s useful here, as nothing is ever done with the result of the function, which could be confusing when you revisit this code at a later date.

4. Insert a double slash before the first cout line.

   // std::cout << "Hello, World! ";
   

   By inserting these characters before some code, you render that code inert. The result in this particular case will be that the Hello, World! message is never sent to the console because that cout line is commented out.

5. Save the file as comment.cpp.
6. Compile and run comment.cpp (Figure 1.16).

   Figure 1.16. Comments do not have any effect on the results of an application unless you comment out a line of code (compare with Figure 1.15).

   

Using an IDE

All of the examples to this point have used the most basic of tools: a text editor and a command-line compiler. As we mentioned at the beginning of this chapter, you can also develop your C++ applications using an integrated development environment (IDE). There are many benefits to using an IDE:

• The text editor will probably have C++ syntax highlighting, indicating reserved words and structures like functions and other code blocks.

• You can often compile and run your program in one step.

• There will be a built-in debugger.

• You don’t need to use the command line at all.

• Most IDEs will create a standard C++ template for you.

To wrap up this chapter, we’ll quickly discuss how to create, compile, and execute a simple Hello, World! application using the Dev-C++ IDE on Windows and Xcode on Mac OS X. Both are free and truly excellent.

After this chapter, none of the examples will be reliant upon whether you’re using the basic tools or an IDE. Decide for yourself how you want to develop your applications. All of the remaining material focuses on the C++ code itself.

Using Dev-C++ on Windows

Although using Dev-C++ is pretty straightforward, understanding how to use it with respect to the code and steps in this book merits discussion. The instructions for creating the examples in this book are somewhat generic—so that users on any computer using any text editor or IDE can follow along—but here is how we envision your going through the material, if you choose to use Dev-C++.

To use Dev-C++

1. Open Dev-C++.
2. Select File > New Project to create a whole new project.

   We like the idea of working with projects even though most of the applications in this book use only a single file at a time. Getting into the habit of creating projects will help you down the line when you’re developing larger-scale C++ tools.

   Alternatively, you can select File > New Source file to begin creating a single C++ source document.

3. In the New Project window (Figure 1.17), do the following:

   • Click the Console Application icon.

   • Ensure that the C++ Project button is selected.

   • Ensure that Make Default Language is selected.

   • Give the project a name.

   Figure 1.17. Creating a new C++ project in Dev-C++.

   

   Certainly Dev-C++ has more to offer—as you can tell from the New Project window—than a plain console application, but for the purposes of this book, that’s where you’ll want to start out.

   For your project name, use the basename of whatever file is being created. So if the example is making a file called hello.cpp, name your project hello.

4. Click OK.
5. Select the project’s location (Figure 1.18).

   Figure 1.18. Store your projects in an organized manner, for example, corresponding to chapters in this book.

   

   We recommend using a separate directory for each project, keeping them organized by chapter, to help maintain the organization of your work.

6. Click Save.

   After going through these steps, you’ll be given a C++ source template (Figure 1.19) that looks only slightly different than what you’ve seen so far.

   Figure 1.19. This is a default C++ template created by the Dev-C++ application.

   

7. Enter your C++ code.

   You can now follow the particular instructions for an example, typing all of your code in the template so that it matches that in the book.

   You can keep most of the templated code without a problem, in particular the int argc, char *argv[] within the main() function definition (you’ll learn about what these mean in Chapter 14, “Extended Topics”). The EXIT_SUCCESS instead of 0 that is returned is also not a problem (EXIT_SUCCESS just represents the system-specific value for successful execution of the program).

8. Select File > Save All.

   This will let you save the C++ source file itself. You can name it either hello.cpp (a name matching the project name) or main.cpp.

9. Select Execute > Compile or press Ctrl+F9.

   The compiler is linked to the Dev-C++ application, so you can compile your C++ code within it.

10. If the application compiled successfully, select Execute > Run or press F9.

    This will create a new console window (a DOS prompt) and begin running the compiled application.

11. If the application did not compile successfully, check the compiler tab (at the bottom of the screen) for error messages.

    Any syntax errors in your code will be listed in the Compiler tab. The specific line number where the problem occurred is listed as well.

Using Xcode on Mac OS X

Simply put, Apple’s Xcode is the kind of development environment programmers are used to paying hundreds of dollars for. It’s a top-notch IDE, with loads of features and support for many languages.

Xcode is part of a series of Developer Tools Apple releases with the operating system. If you have a set of Mac OS X discs, you should check for the Developer Tools CD to save yourself a large download. If you don’t already have a copy or if you want the latest version, Xcode is freely available from Apple’s Developer Connection (ADC) Web site (http://developer.apple.com/tools/xcode/). You’ll need to be an ADC member, but membership is free.

Once you’ve installed Xcode, take this quick tour to learn how to use it to create C++ applications.

To use Xcode

1. Launch Xcode.
2. Select File > New Project.
3. In the resulting window (Figure 1.21), select C++ Tool under Command Line Utility and click Next.

   Figure 1.21. The list of available project types in Xcode.

   

   As you can see in the description (at the bottom), this option is intended for building command-line tools written in C++, which is exactly what you’re doing in this book.

4. Enter the project name, select the project directory, and click Finish (Figure 1.22).

   Figure 1.22. Enter the project’s name and determine where it should be saved.

   

   For your project name, use the basename of whatever file is being created. So if the example is making a file called hello.cpp, name your project hello.

5. Click main.cpp in the project window (Figure 1.23).

   Figure 1.23. The Xcode interface can be displayed as three panels, letting you edit code quickly and easily.

   

   Xcode uses these project windows to manage your projects. After you choose the project type, Xcode automatically creates some files for you. The most important in terms of this book is the main.cpp file, which is your main C++ source code.

6. If the main.cpp code does not appear in the bottom section of the window, click the Editor button (to the right of the stop sign).

   You can edit main.cpp by double-clicking it—which will make it appear in its own window—or by using the built-in editor. If you click Editor, the project window will be broken into three panes, with the editor at the bottom right.

7. After you’ve entered your code, select File > Save or press Command+S.
8. Select Build > Build and Run or press Command+R to compile and execute the application.
9. Press Command+R again to rerun your application.

   The executable application itself can be found in the project_name/build folder.