C++ For Dummies (2014)
Part I
Getting Started with C++ Programming
Visit www.dummies.com for great Dummies content online.
In this part…
· Explaining the building blocks
· Declaring variables
· Defining mathematical operators
· Using logical operators
· Visit www.dummies.com for great Dummies content online.
Chapter 1
Writing Your First C++ Program
In This Chapter
Finding out about C++
Installing Code::Blocks on Windows, Ubuntu Linux, or Macintosh OS X
Creating your first C++ program
Executing your program
Okay, so here we are: No one here but just you and me. Nothing left to do but get started. Might as well lay out a few fundamental concepts.
A computer is an amazingly fast but incredibly stupid machine. A computer can do anything you tell it (within reason), but it does exactly what it’s told — nothing more and nothing less.
Perhaps unfortunately for us, computers don’t understand any reasonable human language — they don’t speak English either. Okay, I know what you’re going to say: “I’ve seen computers that could understand English.” What you really saw was a computer executing a program that could meaningfully understand English.
Computers understand a language variously known as computer language or machine language. It’s possible but extremely difficult for humans to speak machine language. Therefore, computers and humans have agreed to sort of meet in the middle, using intermediate languages such as C++. Humans can speak C++ (sort of), and C++ can be converted into machine language for the computer to understand.
Grasping C++ Concepts
A C++ program is a text file containing a sequence of C++ commands put together according to the laws of C++ grammar. This text file is known as the source file (probably because it’s the source of all frustration). A C++ source file normally carries the extension .CPP just as an Adobe Acrobat file ends in .PDF or an MS-DOS (remember that?) batch file ends in .BAT.
The point of programming in C++ is to write a sequence of commands that can be converted into a machine-language program that actually does what we want done. This conversion is called compiling and is the job of the compiler. The machine code that you wrote must be combined with some setup and teardown instructions and some standard library routines in a process known as linking. Together, compiling and linking are known as building. The resulting machine-executable files carry the extension .EXE in Windows. They don't carry any particular extension in Linux or Macintosh.
That sounds easy enough — so what’s the big deal? Keep going.
To write a program, you need two specialized computer programs. One (an editor) is what you use to write your code as you build your .CPP source file. The other (a compiler) converts your source file into a machine-executable file that carries out your real-world commands (open spreadsheet, make rude noises, deflect incoming asteroids, whatever).
Nowadays, tool developers generally combine compiler and editor into a single package — a development environment. After you finish entering the commands that make up your program, you need only click a button to build the executable file.
Fortunately, there are public-domain C++ environments. I use one of them in this book — the Code::Blocks environment. This editor will work with a lot of different compilers, but the version of Code::Blocks combined with the GNU gcc compiler used to write this book is available for download for Windows, Macintosh, and various versions of Linux, as described in the installation section of this chapter.
Although Code::Blocks is public domain, you’re encouraged to pay some small fee to support its further development. You don’t have to pay to use Code::Blocks, but you can contribute to the cause if you like. See the Code::Blocks website for details.
I have tested the programs in this book with Code::Blocks 13.12 which comes bundled with gcc version 4.7.1. This version of gcc implements most of the C++ 2011 standard.
You can use different versions of gcc or even different compilers if you prefer, but they may not implement the complete '11 standard. For that reason, 2011 extensions are marked with the '11 icon seen here.
The gcc compiler does not implement any of the extensions added in the C++ 2014 standard as of this writing, but I have included them, where applicable, because some day it will.
Okay, I admit it: This book is somewhat Windows-centric. I have tested all of the programs in the book on Windows 2000/XP/Vista/7/8, Ubuntu Linux, and Macintosh OS X. I flag any differences between operating systems in the text. In addition, I include installation instructions for each of the above three operating systems in this chapter. Versions of Code::Blocks and gcc are available for other flavors of Linux and other versions of the Macintosh OS. The programs should work with these, as well.
The Code::Blocks/gcc package generates 32-bit programs, but it does not easily support creating “windowed” programs. The programs in this book run from a command line prompt and write out to the command line. As boring as that may sound, I strongly recommend that you work through the examples in this book first to learn C++ before you tackle windowed development. C++ and windows programming are two separate things and (for the sake of your sanity) should remain so in your mind.
Follow the steps in the next section to install Code::Blocks and build your first C++ program. This program’s task is to convert a temperature value entered by the user from degrees Celsius to degrees Fahrenheit.
Installing Code::Blocks
The www.dummies.com/extra/cplusplus website includes the most recent version of the Code::Blocks environment at the time of this writing for Windows, Ubuntu Linux, and Macintosh OS X 10.6 or later. Follow the installation instructions below that apply to your operating system.
Windows
The Code::Blocks environment comes in an easy-to-install, compressed executable file that is compatible with all versions of Windows after Windows 2000. Here’s the rundown on installing the environment:
1. Download the executable codeblocks-13.12.mingw-setup.exe from www.dummies.com/extra/cplusplus.
Save the executable to your desktop or some other place that you can easily find it.
This includes the 4.71 version of the GCC compiler. This is not the newest version of GCC but it's the version recommended by Code::Blocks. If you want the newer but perhaps slightly buggy 4.81 version, you can download and install codeblocks-13.12.mingw-setup-TDM-GCC-481.exe instead. I tested the programs in this book with both versions but I used 4.71 during its writing.
2. Double-click the program once it has completed downloading.
3. Depending on what version of Windows you’re using, you may get the ubiquitous “An unidentified program wants access to your computer” warning pop-up. If so, click Allow to get the installation ball rolling.
4. Click Next after closing all extraneous applications as you are warned in the Welcome dialog box to the Code::Blocks Setup Wizard.
5. Read the End User License Agreement (commonly known as the EULA) and then click I Agree if you can live with its provisions.
It’s not like you have much choice — the package really won’t install itself if you don’t accept. Assuming you do click OK, Code::Blocks opens a dialog box showing the installation options. The default options are fine.
6. Click the Next button.
The installation program allows you to install only some subset of the features. You must select at least the Default Install and the MinGW Compiler Suite. The default is to install everything — that's the best choice.
If the MinGW Compiler Suite is not an option, then you must have downloaded a version of Code::Blocks that does not include gcc. This version will not work correctly.
7. Click Install and accept the default Destination Folder.
Code::Blocks commences to copying a whole passel of files to your hard drive. Code::Blocks then asks “Do you want to run Code::Blocks now?”
8. Click Yes to start Code::Blocks.
Code::Blocks now asks which compiler you intend to use. The default is GNU GCC Compiler, which is the proper selection.
9. From within Code::Blocks, choose Settings⇒Compiler.
10. Select the Compiler Flags tab.
11. Make sure that the following three flags are selected, as shown in Figure 1-1:
· Enable All Compiler Warnings
· Have g++ Follow the Coming C++0x ISO C++ Language Standard
· Have g++ Follow the C++11 ISO C++ Language Standard
The C++ 2011 standard was originally supposed to be the C++ 2008 or 2009 standard. Since it wasn't clear, the standard became known as the 0x standard. The standard wasn't completely accepted until 2011. Within gcc, C++0x and C++11 refer to the same standard.
12. Select the Toolchain Executables tab. Make sure that it appears like Figure 1-2.
The default location for the gcc compiler is the MinGW\bin subdirectory of the Code::Blocks directory.
Figure 1-1: Ensure that the Enable All Compiler Warnings and the C++ 2011 flags are set.
If the default location is empty, then Code::Blocks does not know where the gcc compiler is, and it will not be able to build your programs. Make sure that you downloaded a version of Code::Blocks that includes gcc and that you included MinGW during the installation. If you are using an existing gcc compiler that you've already installed, then you will need to point Code::Blocks to where it is located on your hard drive.
13. Close the Settings dialog box.
14. Click Next in the Code::Blocks Setup dialog box and then click Finish to complete the setup program.
The setup program exits.
Ubuntu Linux
Code::Blocks does not include gcc on Linux, so installation is a two-step process. First you will need to install gcc. Then you can install Code::Blocks.
Figure 1-2: Ensure that the Compiler's installation directory is correct.
Installing gcc
The gcc compiler is readily available for Linux. Follow these steps to install it:
1. Enter the following commands from a command prompt:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install g++
The standard Ubuntu Linux distribution includes a GNU C compiler, but it does not include the C++ extensions and, in particular, not the C++ 2011 standard extensions. The first two commands update and upgrade the tools you already have. The third command installs C++.
2. Enter the following command from a command prompt:
gcc --version
My Ubuntu 13.04 downloaded GNU C++ version 4.7.3. You'll be fine with version 4.7.1 or later. If you have an earlier version, some of the C++ 2011 features may not work properly, but otherwise, it should be okay.
If you are using Debian Linux, the commands are the same. If you’re using Red Hat Linux, replace the command apt-get with yum so that you end up with
sudo yum install g++
Installing Code::Blocks
Fortunately for all concerned, an Ubuntu-ready version of Code::Blocks is available in the Ubuntu Software Center. Many other versions of Linux include something similar to the Software Center. Follow these steps to install Code::Blocks:
1. Click on the Software Center icon on the Ubuntu desktop.
2. Select Code::Blocks from the list of available software.
This will start the installation process.
Code::Blocks searches your hard drive for your C++ compiler. It should be able to find it without a problem, but if it doesn’t, then execute the following steps.
3. Start Code::Blocks.
4. Select Settings⇒Compiler.
5. Select the Compiler Flags tab.
6. Make sure that the following three flags are selected, as shown in Figure 1-1:
· Enable All Compiler Warnings
· Have g++ Follow the Coming C++0x ISO C++ Language Standard
· Have g++ Follow the C++11 ISO C++ Language Standard
7. Select the Toolchain Executables tab.
8. Select the “…” button.
9. Navigate to /usr, unless you installed your gcc compiler someplace other than the default location of /user/bin.
10. The “C compiler” should be gcc, the “C++ compiler” should be g++ and the “Linker for dynamic libs” should be g++.
11. Select OK to close the dialog box.
Macintosh
The Macintosh version of Code::Blocks relies on the Xcode distribution from Apple for its compiler. I have divided the installation into three separate parts for this reason.
Installing Xcode
Xcode is a free development package offered by Apple that you will need. Follow these steps to install it first:
1. Open the Safari browser and go to http://developer.apple.com.
2. Click on Download Xcode to get the most recent version.
This will open the Xcode download dialog box shown in Figure 1-3.
Figure 1-3: The Xcode download dialog box allows you to install Xcode for free.
3. Click on the Free icon to change it to Install App. Click on it again.
4. Enter your system password (the one you log in with when your Mac boots up).
The icon changes to Installing.
The download and installation takes quite some time, as Xcode is a little over 2GB as of this writing.
Installing the Command Line Tools
As big as Xcode is, you would think that it has everything you need, but you would be wrong. You need one more package from Apple to make your joy complete and to get a working gcc compiler on your Macintosh. Follow these steps to install the Command Line Tools for Xcode:
1. Open the Safari browser and go to http://developer.apple.com/downloads.
You may be asked to sign up for an Apple Developer ID. Go ahead and do so — it's free.
2. Search for Command Line Tools for Xcode. Select the application shown in Figure 1-4. Click on the Download icon.
3. Double-click on the mpkg package that downloads to install it.
4. Accept all of the default values.
The installation should finish with Installation Was Successful.
Installing Code::Blocks
Now, you can finish your installation by downloading the Code::Blocks editor:
1. Open the Safari browser and go to www.codeblocks.org/downloads.
2. Click on Downloads⇒Binaries.
Figure 1-4: You must install both Xcode and the Command Line Tools for Xcode to get the gcc compiler for Macintosh.
3. Click on Mac OS X.
4. Select either the BerliOS or Sourceforge.net mirror for the most recent version.
At the time of this writing, CodeBlocks-13.12 -mac.zip was the most recent.
5. Install the downloaded Zip file into the Applications folder.
If you have never installed an application from a third-party site, you may need to execute these extra steps before you can do so:
1. Click on System Preferences.
2. Click on Security and Privacy.
3. Click the padlock in the lower-left corner of the dialog box to allow changes.
4. Click on Allow Applications Downloaded from: Anywhere, as shown in Figure 1-5.
Once you have completed the installation of Code::Blocks, you may choose to return to this dialog box and restore the settings to Mac App Store.
Figure 1-5: You will need to allow third-party applications to be installed before you can install Code::Blocks on your Macintosh.
6. Double-click on the Code::Blocks icon.
The first time you do this, the Mac OS will ask, “Are you sure you want to open it?”
7. Select Don't Warn Me When Opening Applications on This Disk Image and click Open.
Code::Blocks should start and find the gcc compiler installed with the Command Line Tools.
8. Select the gcc compiler, as shown in Figure 1-6. Click on Set as Default and then click on OK to continue starting Code::Blocks.
Code::Blocks will open with a banner page followed by a menu across the top of the dialog box.
9. Select Settings⇒Compiler, then click the Have g++ Follow the Coming C++0x ISO C++ Language Standard. Click on OK to close the dialog box.
You are now ready to build your first C++ program.
Figure 1-6: Code::Blocks automatically finds the gcc compiler the first time you execute it.
Creating Your First C++ Program
In this section, you create your first C++ program. You enter the C++ code into a file called CONVERT.CPP and then convert the C++ code into an executable program.
Creating a project
The first step to creating a C++ program is to create what is known as a project. A project tells Code::Blocks the names of the .CPP source files to include and what type of program to create. Most of the programs in the book will consist of a single source file and will be command-line style:
1. Start up the Code::Blocks tool.
2. From within Code::Blocks, choose File⇒New⇒Project.
3. Select the Console Application icon and then click Go.
4. Select C++ as the language you want to use from the next dialog box. Click Next.
Code::Blocks and gcc also support plain ol’ C programs.
5. In the Folder to Build Project In field, select the “…” icon.
6. Click on Computer and then the C: drive on Windows.
On Linux and Macintosh, you can select the Desktop.
7. Select the Make New Folder button at the lower left of the screen.
8. Name the new folder CPP_Programs_from_Book.
The result should look like Figure 1-7.
Figure 1-7: Put your project in the C:\CPP_Programs_from_Book folder on Windows.
9. In the Project Title field, type the name of the project, in this case Conversion.
The resulting screen is shown in Figure 1-8 on Windows. The Linux and Macintosh version look the same except for the path.
Figure 1-8: I created the project Conversion for the first program.
10. Click Next.
The next dialog box gives you the option of creating an application for testing or the final version. The default is fine.
11. Click Finish to create the Conversion project.
Entering the C++ code
The Conversion project that Code::Blocks creates consists of a single, default main.cpp file that displays the message “Hello, world”. The next step is to enter our program:
1. In the Management dialog box on the left, double-click main.cpp, which is under Sources, which is under Conversion.
Code::Blocks opens the empty main.cpp program that it created in the code editor, as shown in Figure 1-9.
Figure 1-9: The Management dialog box displays a directory structure for all available programs.
2. Edit main.cpp with the following program exactly as written.
Don’t worry too much about indentation or spacing — it isn’t critical whether a given line is indented two or three spaces, or whether there are one or two spaces between two words. C++ is case sensitive, however, so you need to make sure everything is lowercase.
You can cheat by using the files at www.dummies.com/extra/cplusplus, as described in the next section.
//
// Conversion - Program to convert temperature from
// Celsius degrees into Fahrenheit:
// Fahrenheit = Celsius * (212 - 32)/100 + 32
//
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int nNumberofArgs, char* pszArgs[])
{
// enter the temperature in Celsius
int celsius;
cout << "Enter the temperature in Celsius:";
cin >> celsius;
// calculate conversion factor for Celsius
// to Fahrenheit
int factor;
factor = 212 - 32;
// use conversion factor to convert Celsius
// into Fahrenheit values
int fahrenheit;
fahrenheit = factor * celsius/100 + 32;
// output the results (followed by a NewLine)
cout << "Fahrenheit value is:";
cout << fahrenheit << endl;
// wait until user is ready before terminating program
// to allow the user to see the program results
cout << "Press Enter to continue..." << endl;
cin.ignore(10, '\n');
cin.get();
return 0;
}
3. Choose File⇒Save to save the source file.
I know that it may not seem all that exciting, but you’ve just created your first C++ program!
Cheating
All the programs in the book are included online, along with the project files to build them. You will need to download them and install them onto your hard drive before you can use them by following this procedure:
The following instructions are for Windows. The steps to follow for Linux or Macintosh are very similar.
1. Open your Internet browser.
2. Migrate to www.dummies.com/extras/cplusplus.
3. Click on the CPP_programs link.
A dialog box appears asking you where you want to download the specified file.
4. Click on Save File.
Windows will copy the CPP_programs.zip file to the default download location. This may be either your Downloads folder or the Desktop.
5. Right-click on the CPP_programs.zip file and select Open.
A dialog box opens containing the single directory CPP_Programs_from_Book.
6. Copy this folder to the C: drive.
This will copy all of the sources used in the book to the directory C:\CPP_Programs_from_Book.
You can put the CPP_Programs_from_Book folder at some other location, but don't put your source files in a directory that includes a space. On Windows, that means don't put any of your Code::Blocks folders in My Documents or on the Desktop, as they both include a space in their paths.
You can use these files in two ways: One way is to go through all the steps I describe in the book to create the program by hand first, but copy and paste from the provided files into your program if you get into trouble (or your fingers start cramping). This is the preferred technique.
A second approach is that you can use the sources and project file provided as-is:
1. Double-click AllPrograms.workspace in C:\CPP_Programs_from_Book.
A workspace is a single file that references one or more projects. The AllPrograms.workspace file contains references to all the projects defined in the book.
2. Right-click the Conversion project in the Management dialog box on the left. Choose Activate Project from the context-sensitive menu that appears.
Code::Blocks turns the Conversion label bold to verify that this is the program you are working on right now. When you subsequently select Build, Code::Blocks, it always builds the active project.
3. Double-click the main.cpp file to open the file in the editor.
The problem with this approach is that you tend to learn very little about C++ if you don't enter the code yourself.
Building your program
After you’ve saved your C++ source file to your hard drive, it’s time to generate the executable machine instructions.
To build your Conversion program, you choose Build⇒Build from the menu or press Ctrl-F9. Almost immediately, Code::Blocks takes off, compiling your program with gusto. If all goes well, the happy result of 0 Errors, 0 Warnings appears in the lower-right dialog box, as shown in Figure 1-10.
Code::Blocks generates a message if it finds any type of error in your C++ program — and coding errors are about as common as ice cubes in Alaska. You’ll undoubtedly encounter numerous warnings and error messages, probably even when entering the simple Conversion.cpp. To demonstrate the error-reporting process, change Line 16 from cin >> celsius; to cin >>> celsius;.
Figure 1-10: Code::Blocks builds the Conversion program quickly.
This seems an innocent enough offense — forgivable to you and me perhaps, but not to C++. Choose Build⇒Build to start the compile and build process. Code::Blocks almost immediately places a red square next to the erroneous line. The message in the Build Message tab is a rather cryptic error: expected primary-expression before '>' token. To get rid of the message, remove the extra > and recompile.
You probably consider the error message generated by the example a little mysterious, but give it time — you’ve been programming for only about 30 minutes now. Over time, you’ll come to understand the error messages generated by Code::Blocks and gcc much better.
Code::Blocks was able to point directly at the error this time, but it isn’t always that good. Sometimes it doesn’t notice the error until the next line or the one after that, so if the line flagged with the error looks okay, start looking at its predecessor to see if the error is there.
Executing Your Program
It’s now time to execute your new creation … that is, to run your program. You will run the Conversion program file and give it input to see how well itworks.
To execute the Conversion program on Windows Code::Blocks, choose Build⇒Build and Run, or press F9. This rebuilds the program if anything has changed and executes the program if the build is successful.
A dialog box opens immediately, requesting a temperature in Celsius. Enter a known temperature, such as 100 degrees. After you press Enter, the program returns with the equivalent temperature of 212 degrees Fahrenheit as follows:
Enter the temperature in Celsius:100
Fahrenheit value is:212
Press Enter to continue…
The message Press Enter to continue … gives you the opportunity to read what you’ve entered before it goes away. Press Enter, and the dialog box (along with its contents) disappears. Congratulations! You just entered, built, and executed your first C++ program.
Notice that Code::Blocks is not truly intended for developing windowed programs like those used in Windows. In theory, you can write a Windows application by using Code::Blocks, but it isn’t easy. (Building windowed applications is so much easier in Visual Studio.)
Windows programs show the user a visually oriented output, all nicely arranged in onscreen windows. Conversion.exe is a 32-bit program that executes under Windows, but it’s not a Windows program in the visual sense.
If you don’t know what 32-bit program means, don’t worry about it. As I said, this book isn’t about writing Windows programs. The C++ programs you write in this book have a command line interface executing within an MS-DOS box.
Budding Windows programmers shouldn’t despair — you didn’t waste your money. Learning C++ is a prerequisite to writing Windows programs. I think that they should be mastered separately: C++ first, Windows second.
Reviewing the Annotated Program
Entering data in someone else’s program is about as exciting as watching someone else drive a car. You really need to get behind the wheel yourself. Programs are a bit like cars, as well. All cars are basically the same with small differences and additions — okay, French cars are a lot different than other cars, but the point is still valid. Cars follow the same basic pattern — steering wheel in front of you, seat below you, roof above you, and stuff like that.
Similarly, all C++ programs follow a common pattern. This pattern is already present in this very first program. We can review the Conversion program by looking for the elements that are common to all programs.
Examining the framework for all C++ programs
Every C++ program you write for this book uses the same basic framework, which looks a lot like this:
//
// Template - provides a template to be used as the
// starting point
//
// the following include files define the majority of
// functions that any given program will need
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int nNumberofArgs, char* pszArgs[])
{
// your C++ code starts here
// wait until user is ready before terminating program
// to allow the user to see the program results
cout<< "Press Enter to continue..." <<endl;
cin.ignore(10, '\n');
cin.get();
return 0;
}
Without going into all the boring details, execution begins with the code contained in the open and closed braces immediately following the line beginning main().
I’ve copied this code into a file called Template.cpp located in the main CPP_Programs_from_Book folder.
Clarifying source code with comments
The first few lines in the Conversion program appear to be freeform text. Either this code was meant for human eyes or C++ is a lot smarter than I give it credit for. These first six lines are known as comments. Comments are the programmer’s explanation of what she is doing or thinking when writing a particular code segment. The compiler ignores comments. Programmers (good programmers, anyway) don’t.
A C++ comment begins with a double slash (//) and ends with a newline. You can put any character you want in a comment. A comment may be as long as you want, but it’s customary to keep comment lines to no more than 80 characters across. Back in the old days — “old” is relative here — screens were limited to 80 characters in width. Some printers still default to 80 characters across when printing text. These days, keeping a single line to fewer than 80 characters is just a good practical idea (easier to read; less likely to cause eyestrain; the usual).
A newline was known as a carriage return back in the days of typewriters — when the act of entering characters into a machine was called typing and not keyboarding. A newline is the character that terminates a command line.
C++ allows a second form of comment in which everything appearing after a /* and before a */ is ignored; however, this form of comment isn’t normally used in C++ anymore.
It may seem odd to have a command in C++ (or any other programming language) that’s specifically ignored by the computer. However, all computer languages have some version of the comment. It’s critical that the programmer explain what was going through her mind when she wrote the code. A programmer’s thoughts may not be obvious to the next colleague who tries to use or modify her program. In fact, the programmer herself may forget what her program meant if she looks at it months after writing the original code and has left no clue.
Basing programs on C++ statements
All C++ programs are based on what are known as C++ statements. This section reviews the statements that make up the program framework used by the Conversion program.
A statement is a single set of commands. Almost all C++ statements other than comments end in a semicolon. (You see one other exception in Chapter 10.) Program execution begins with the first C++ statement after the open brace and continues through the listing, one statement at a time.
As you look through the program, you can see that spaces, tabs, and newlines appear throughout the program. In fact, I place a newline after every statement in this program. These characters are collectively known as whitespace because you can’t see them on the monitor.
You may add whitespace anywhere you like in your program to enhance readability — except in the middle of a word:
See wha
t I mean?
Although C++ may ignore whitespace, it doesn’t ignore case. In fact, C++ is case sensitive to the point of obsession. The variable fullspeed and the variable FullSpeed have nothing to do with each other. The command int is completely understandable, but C++ has no idea what INTmeans. See what I mean about fast but stupid compilers?
Writing declarations
The line int celsius; is a declaration statement. A declaration is a statement that defines a variable. A variable is a “holding tank” for a value of some type. A variable contains a value, such as a number or a character.
The term variable stems from algebra formulas of the following type:
x = 10
y = 3 * x
In the second expression, y is set equal to 3 times x, but what is x? The variable x acts as a holding tank for a value. In this case, the value of x is 10, but we could have just as well set the value of x to 20 or 30 or -1. The second formula makes sense no matter what the value of x is.
In algebra, you’re allowed but not required to begin with a statement such as x = 10. In C++, the programmer must define the variable x before she can use it.
In C++, a variable has a type and a name. The variable defined on line 11 is called celsius and declared to hold an integer. (Why they couldn’t have just said integer instead of int, I’ll never know. It’s just one of those things you learn to live with.)
The name of a variable has no particular significance to C++. A variable must begin with the letters A through Z, the letters a through z, or an underscore (_). All subsequent characters must be a letter, a digit 0 through 9, or an underscore. Variable names can be as long as you want to make them.
It’s convention that variable names begin with a lowercase letter. Each new word within a variable begins with a capital letter, as in myVariable.
Try to make variable names short but descriptive. Avoid names such as x because x has no particular meaning. A variable name such as lengthOfLine Segment is much more descriptive.
Generating output
The lines beginning with cout and cin are known as input/output statements, often contracted to I/O statements. (Like all engineers, programmers love contractions and acronyms.)
The first I/O statement says “Output the phrase Enter the temperature in Celsius to cout” (pronounced “see-out”). cout is the name of the standard C++ output device. In this case, the standard C++ output device is your monitor.
The next line is exactly the opposite. It says, in effect, “Extract a value from the C++ input device and store it in the integer variable celsius.” The C++ input device is normally the keyboard. What we have here is the C++ analog to the algebra formula x = 10 just mentioned. For the remainder of the program, the value of celsius is whatever the user enters there.
Calculating Expressions
All but the most basic programs perform calculations of one type or another. In C++, an expression is a statement that performs a calculation. Said another way, an expression is a statement that has a value. An operator is a command that generates a value.
For example, in the Conversion example program — specifically, in the two lines marked as a calculation expression — the program declares a variable factor and then assigns it the value resulting from a calculation. This particular command calculates the difference of 212 and 32; the operator is the minus sign (-), and the expression is 212-32.
Storing the results of an expression
The spoken language can be very ambiguous. The term equals is one of those ambiguities. The word equals can mean that two things have the same value as in “a dollar equals one hundred cents.” Equals can also imply assignment, as in math when you say that “y equals 3 times x.”
To avoid ambiguity, C++ programmers call = the assignment operator, which says (in effect), “Store the results of the expression to the right of the assignment sign in the variable to the left.” Programmers say that “factor is assigned the value 212 minus 32.” For short, you can say “factor gets 212 minus 32.”
Never say “factor is equal to 212 minus 32.” You’ll hear this from some lazy types, but you and I know better.
Examining the remainder of Conversion
The second expression in the Conversion program presents a slightly more complicated expression than the first. This expression uses the same mathematical symbols: * for multiplication, / for division, and + for addition. In this case, however, the calculation is performed on variables and not simply on constants.
The value contained in the variable called factor (which was calculated as the results of 212 - 32, by the way) is multiplied by the value contained in celsius (which was input from the keyboard). The result is divided by 100 and summed with 32. The result of the total expression is assigned to the integer variable fahrenheit.
The next two commands output the string Fahrenheit value is: to the display, followed by the value of fahrenheit — and all so fast that the user scarcely knows it’s going on.
The final three statements prompt the user to press Enter and then waits for him to do so. This is because on some systems the program can display the results and then close the console dialog box so rapidly you don't even see that anything's happened.
On many systems, you can skip these three lines — Code::Blocks will keep the dialog box open until you press Enter anyway — but these lines never hurt.
The final return 0 returns control to the operating system.