Lab 0: Getting Started with C++

Introduction

The main purpose of this lab is to introduce you to the computing environment of your laboratory. You will use the ideas in this lab again and again throughout this course, so you should make every effort to understand not only what, but why you are doing what you are doing at each step.

Before we can begin our session, your instructor must inform you how to begin a session with the computer at your particular institution. The way this is done differs from school to school, according to the kind of computer being used, whether they are networked or stand-alone, whether a security system is in place, and so on. Among the things your instructor will tell you will be the answers to the following questions:

1. Should the computer be turned on at the beginning of the exercise and off at the end of the exercise, or does it remain on all of the time?
2. Do users of the computer have personal accounts (requiring one to login to begin an exercise), or can anyone use the computer?
3. If users have personal accounts:
   1. How do I find out my username (the name by which I am known to the computer)?
   2. How do I find out my password (the secret word that allows access to my account)?
   3. Is it necessary to change my password (and if so, how is it done)?
4. If a windowing environment (X-windows, OpenWindows, etc.) is to be used:
   1. Must I do something special to enter that environment?
   2. What role does the mouse play in that environment?
   3. How do I exit that environment?
5. What must I do to quit a session using the computer?

About this Manual

The distinction between typing something and entering something is as follows:

• to type the letter y, simply press the keyboard key marked y.
• to enter the letter y, press the keyboard key marked y, followed by the key marked Return (it may be marked Carriage Return, CR, or perhaps Enter on your particular machine).

Getting Started with UNIX

   %

   <1>~:

Interacting with the Computer

1. The computer displays a prompt and waits for you to enter a command.
2. You enter a command.
3. The computer executes (performs) that command (if it is able to), and when it is finished, displays another prompt.

The commands we'll ask the computer to perform take different amounts of time to complete. Some will take a fraction of a second. Others may take a several minutes. Others will continue to execute indefinitely, until we specifically ask them to stop.

The way in which you interact with a computer depends upon the computing environment of its operating system. For example, an environment in which you repeatedly:

1. are prompted for a command,
2. enter a command, and
3. the machine displays the result of the command

Another common UNIX environment created at the Massachusettes Institute of Technology (MIT) is the X-window system. The X-window system provides an environment in which you use the mouse to interact with on-screen windows, menus and icons. Such environments are called graphical user interface, or GUI (pronounced gooey) environments.

One of the kinds of windows available in the X-window environment (called an x-term) provides a separate command-line environment. The X-window environment is thus a combination environment, combining the convenience of a GUI with the power of a command-line, making it a favorite of computer scientists around the world. Since both plain UNIX and X-windows require knowledge of command-line commands, we will concentrate on them in this exercise.

In order to use a command-line environment, you must learn those commands that the environment "understands." Let's first see what happens if you type something that the environment does notrecognize. Enter

   % qwerty

If you try other nonsense words, you'll find that the system responds in the same way. It's thus safe to make mistakes and mistype commands -- you won't harm the computer.

Directories and Files

During this course, we'll create dozens of files, and so some means of organizing them is needed. Just as the documents in a filing cabinet are often kept in manila folders, we can create a container in which to keep related files, called a directory. Let's do it! Enter

   % mkdir projects

Viewing the Contents of a Directory

   % ls

   labs     mylib    practice      projects

where $HOME represents our home directory -- the directory where UNIX places us at the beginning of a session.

The ls command can also be used to find out what is in a particular directory. Try entering:

   % ls labs

To get a more detailed listing of the current directory, enter

   % ls -l

The UNIX On-line Manual

   % man ls

Removing a Directory

   % rmdir practice

Whatever directory you specify following the command will be removed from the current directory, provided that the directory being removed is empty. To remove a non-empty directory named DirectoryName, the command

   % rm -r DirectoryName

Using the ls command, verify that practice no longer exists.

Identifying the Working Directory

The directory in which you are working at any given time is called your working directory. (Your home directory never changes, but your working directory can.) To find out the name of the working directory, you can use the pwd command (which stands for path to the working directory).

   % pwd
   /home/adams

UNIX systems utilize what is called a hierarchical directory system, meaning that directories can contain other directories, and that there is one root directory named / that contains all of the other directories in the system. Type

   % ls /

Now, if you compare this to my output from pwd, you can see that pwd begins by displaying / (the root directory) followed by home, followed by a slash (UNIX unfortunately uses slash both for the name of the root directory and to separate directory names) followed by adams. That is, pwd lists the sequence of directories between the root directory and my working directory (which is called the path), with slashes between the directory names. Since my working directory is currently my home directory, the last name that pwd displayed happens to be my home directory (in my case adams). If we use shading to indicate the working directory, then we can visualize the situation this way:

Apply this to the output from your pwd command. What is the name of your home directory?

A last word on the home directory: UNIX treats the tilde character (~) as an abbreviation for your home directory, which can save you a lot of typing if the path to your home directory has lots of characters. We will make use of this abbreviation at the end of the lab.

Changing to a Different Directory

Since we are working on a lab exercise, let's change the working directory to directory labs. Enter

   % cd labs

Next, use the pwd command and note its output: how is it different than it was before?

The cd command changes our location within the directory hierarchy, effectively changing the working directory. The effect is to change the preceding picture as follows:

Since pwd outputs the path (from the root) to the working directory, the output of pwd changes each time you cd to a different directory.

To see everything in a directory, enter

   % ls -a 

In the UNIX file system, . is another name for the working directory (whatever directory you are in); and .. is another name for the parent of the working directory.

For example: We created labs within our home directory. The cd labs command took us from that directory "down" into labs. How do we get from labs back "up" to the directory where we began? Enter the command:

   % cd ..

(Note that since that directory is our home directory, we could also have used cd to accomplish the same thing, because cd without an argument always returns you to your home directory.) Use pwd to verify that you are currently "in" your home directory.

To wrap up this section, do the following:

1. Change directory back "down" into labs;
2. Make a new directory (inside labs) named 0;
3. Use ls to verify that 0 was created successfully; and
4. Change directory from labs "down" into 0.

Your First Program

1. Writing a source program in a high-level language (i.e., C++) and storing that program in a file; and
2. Translating that source program into a machine-language program (i.e., a binary executable).

Once we have created a file containing our source program, the second step can be accomplished through the use of a C++ compiler: a program that translates C++ programs into machine language (the binary 1s and 0s that a computer "understands." Graphically the process can be pictured as follows:

As we shall see in a later lab exercise, this is a bit of a simplification, but it is sufficiently accurate to give you an idea of what is occuring.

The C++ compiler used throughout this manual is named g++ and it (like emacs) is a freeware product of the Free Software Foundation.

Editing a File

   % xemacs bases.cpp &

Since the file bases.cpp does not exist in the working directory, xemacs will create a new, blank editing window (called a buffer) named bases.cpp into which you can type a program. (If a file named bases.cpp existed in the working directory, then xemacs would create a blank buffer, open that file and read the file into the buffer). Note that xemacs displays the name of the buffer status bar near the bottom of the window, and that the name of a buffer is the name of the file it is displaying.

Within the bases.cpp buffer, we are going to enter (and personalize) the following C++ source program:

/* bases.cpp demonstrates basic I/O in C++.
 *
 * Written by: Jane Doe, Feb 29, 1999.
 * Written for: CS I, at City University.
 *
 * Specification:
 *   Input(keyboard): aNumber, an integer;
 *   Output(screen): the base 10, 8 and 16 representations of aNumber.
 ***********************************************************************/

#include <iostream>
using namespace std;

int main()
{
   // declare an integer container to hold the input number
   int aNumber;

   // 0. print a message explaining the purpose of the program.
   cout << "\nThis program inputs a base-10 integer"
        << "\n\tand displays its value in bases 8 and 16\n";

   // 1. ask the user to enter an integer.
   cout << "\nPlease enter an integer: ";

   // 2. input an integer, storing it in variable aNumber.
   cin >> aNumber;

   // 3. output the base-8 and base-16 representations of aNumber.
   cout << "\n\nThe base-8 representation of " << aNumber << " is "
        << oct << aNumber
        << ",\n\tand the base-16 representation is "
        << hex << aNumber
        << "\n\n";
}

In the X-window system, a block of text can be selected by dragging (holding down the left mouse button while moving the mouse) from the beginning to the end of the desired text.

Most X environments support a copy-paste short-cut:

1. drag the mouse over the text you want to copy, selecting it;
2. position the cursor where you want to paste by pointing the mouse there and clicking the left mouse button; and
3. paste by pressing the middle mouse button.

Using one of these methods, copy the program shown above into the xemacs bases.cpp buffer.

Personalizing the Program

If you are using xemacs in the X-windows environment, you can use the mouse to position the cursor at an arbitrary point by pointing at that point and clicking the left mouse button.

The editor command C-d (typing the Control and d keys simultaneously) can be used to delete the character beneath the cursor, and C-k can be used to delete from the cursor to the end of the line.

If you are running xemacs outside of the X-windows environment, you can move the cursor by the editor commands:

• C-p (previous line) to move up one line,
• C-n (next line) to move down one line,
• C-b (back) to move left one character, and
• C-f (forward) to move right one character.

If you make a mistake, you can always undo the effects of any xemacs command, either by using the undo command: C-x u (type Control and x simultaneously, then type the u key by itself), or by using the Undo button on the xemacs menu bar.

The undo command can be used to undo the effects of an xemacs command that has completed. However some xemacs commands take a significant length of time, and you may wish to get out of the command while it is still being performed. For this, you can use the get-out command: C-g, which we find to be useful in a wide variety of situations.

Saving Your Work.

   Save file .../labs/0/bases.cpp? (y, n, !, ., q or C-h)

   Save file .../labs/0/bases.cpp? (y, n, !, ., q or C-h) y

Translating Your Program

   Compile command: make -k

For simple programs like this one, the easiest way to translate our program is to replace the make -k with an explicit call to the GNU C++ compiler g++. Using the delete (or backspace) key, erase the make -k and replace it as follows:

   Compile command: g++ bases.cpp -Wall -o bases

Once you have edited the compile command, press the Return key and xemacs will split its window in two, displaying the bases.cpp buffer (containing your source program) in one half and displaying a new *compilation* buffer (containing the results of your compile command) in the other half. If bases.cpp is free of errors, then you should see a message like:

   Compilation finished at Mon Sep 5 9:12:44

   bases.cpp: In function `int main()':
   .
   .
   .
   Compilation exited abnormally with code 1 at Mon Sep 5 9:12:44

Use ls to verify that your directory contains the executable file named bases (it may also contain additional files, such as automatic back-up files created by xemacs).

Running Your Program from the Command-Line.

If you are using the X-window environment, the xemacs window is just one of many independently running windows. Locate a different window in which the system prompt is displayed (i.e., the xterm window from which you invoked xemacs). Simply move the mouse into this window (or perhaps click in it) and the cursor should appear, indicating that it is ready for your command.

If you are using a terminal or telnet instead of the X-window system, use the xemacs suspend command: C-z. The operating system will then suspend xemacs and display the system prompt, indicating it is ready to accept a command.

Once you are at the operating system prompt, use pwd to check that your working directory is your 0 subdirectory. (If not, change directory to make it so.) Then use ls to display the contents of 0, to make sure that both the source file bases.cpp and the binary executable bases are there. At that point, you can enter

   % bases

Returning from the Command-line to Xemacs

If you are using a terminal or telnet and you suspended xemacs using C-z, then enter:

   % fg

Printing a Hard Copy

In an AT&T UNIX command-line environment, you can usually print a hard copy of this file by entering

   % lp bases.cpp

   % lp -d PrinterName bases.cpp

   % lpr bases.cpp

   % lpr -PPrinterName bases.cpp

Applying the Scientific Method

Observe

Hypothesis

Experiment

Then modify bases.cpp as necessary to perform your experiment, re-translate bases.cpp into machine language, and run it. If the resulting behavior indicates that your hypothesis is false, repeat the preceding Observe-Hypothesis-Experiment steps until you form a hypothesis that is not false.

When your experimental hypothesis is not proven false, print a hard copy of your modified bases.cpp. On that hard copy, write down your hypothesis, your experiment, and circle that part of the program that performs your experiment.

As noted above, an experiment in which your hypothesis is not rejected does not prove that it is correct!

Miscellaneous Other Useful Commands

Quitting xemacs

Copying a File

   % cp bases.cpp bases.2

Use the ls command to verify that cp command worked.

It's more often the case that we need to make a copy of a file in a directory different from the one in which the file currently resides. How are we to do this? The key is to learn a bit about how files and directories are named. Both of the names bases.cpp and bases.save are the relative names of these files. To use these names, we must be in the same directory as they are.

However, every file or directory also has an absolute name: a name that starts with the root directory (i.e., /), and lists each directory between there and the file name, just as we saw in the output from pwd. For example, the absolute name of bases.cpp on my machine is as follows: /home/adams/C++/labs/0/bases.cpp (or more briefly ~/C++/labs/0/bases.cpp.

To use a file's (or directory's) absolute name, you need not be in the same directory as that file! For example, try entering:

   % mkdir ~/projects/0

Almost all of the UNIX file manipulation commands accept either relative or absolute file names. For example, you don't need to be "in" a directory to see its contents: Enter

   % ls ~/projects

Similarly, to put a copy of bases.cpp in that new directory, you can enter:

   % cp bases.cpp ~/projects/0

The cp command thus behaves differently, depending on whether you specify a file or a directory as the second name: if you specify a file as the second name, then the cp command will store the copy in a file with that name. If you specify a directory as the second name, then cp will place a copy in that directory with the name as the original.

Using ls and an absolute path name, verify that there is a copy of bases.cpp in ~/projects/0.

Renaming a File

   % mv bases.2 bases.save

It can be used with both relative and absolute file names, and can be used to rename directories.

Creating and Printing a Hard Copy of an Execution

1. record the output of the program in a file; and
2. print that file using lp (or lpr).

   % script

   % exit

Cleaning Up Your Directory

   % rm bases.save

Use the rm command to remove the files typescript, bases.cpp~ (a back-up file created by xemacs) and the executable file bases. Then use the ls command to verify that all of the files except bases.cpp are gone. If there are other files remaining in your 0 directory, use the rm command to remove them, as well.

Then end your session with the computer, following your instructor's instructions.

Note: If your head feels ready to explode, don't panic! This first lab covers a great deal of material, that you will use over and over again, and as you do so, you will begin to naturally memorize those commands that you use most frequently. You can speed up the process by reviewing each of the steps you took in this exercise.

Until such a time as you remember the various commands, here are two quick reference pages to help you "look up" commands: one listing some of the commonly used UNIX commands and one listing some of the commonly used xemacs commands. Print hard copies of these, and store them in a convenient place!

To learn to use these quick references, I would recommend that you review today's exercise, and find each of the commands we used in the exercise on the appropriate quick reference sheet. Then study the description of that command on the quick reference sheet, so that you associate the two in the future.

Submit:

Phrases you should now understand:

Back to This Lab's Home Page

Back to the Prelab Questions

Forward to the Homework Projects