lab10, CISC106, Fall 2007

Introduction

Our first experience with C++

lab10 is our first experience with C++. We'll see how working with C++ differs from working with MATLAB—and, more generally, how working with a "compiler" is different from working with a language that has an interpreter

Script file vs. Diary File

Overview

1. You'll copy the files needed for this lab
   
2. You'll learn how to open an XTerm on strauss on the SunRay machines.
   
3. You'll learn how to set up a file that will help you get the right versions of the compilers in this class, a file called .localenv, and how to test whether it is working or not.
   
4. You'll further test whether what you did in step 2 is working by using the C++ compiler to turn a program written in C++ into an executable file in machine language. Your goal will be to show that you can access two different C++ compilers, one called CC and another called g++. However, it is only necessary to show that you can access one of these to get full credit for the lab.
   
5. You'll learn how to change directory into your ~/cisc106/lab10 directory, copy a C++ program from Prof. Conrad's web site, compile it, and run it. The program you copy will be one that converts Fahrenheit to Celsius. You'll then use emacs (or vi) to change that program into a C++ program that converts Celsius to Fahrenheit. You'll script the results, and submit them to your TA via WebCT and on paper.
   
   All the files you create in this step will be stored in your newly created ~/cisc106/lab10 directory (except the .localenv file, which must be placed in your home directory.)
   

Step-by-Step Instructions

Step 1: Preparing your lab10 directory, and copying files you will need

Step 1a: Create a new subdirectory for lab10

Create a new subdirectory ~/cisc106/lab10, and make that your working directory.

Step 1b: Copy the files needed for this week's lab

The files for this week's lab are

• on strauss in the directory /www/htdocs/CIS/106/pconrad/07F/labs/lab10
• which corresponds to the web page http://www.udel.edu/CIS/106/pconrad/07F/labs/lab10

Step 2: Opening an XTerm on Strauss

C++ Programming assignments in CISC106 (and later courses that electrical and computer engineers takes, such as CISC181, CISC220) are done on a computer called strauss. Strauss runs the Unix operating system. You access strauss through a terminal session.

To get a terminal session from a PC at home or in your dorm, you get to strauss using a terminal program such as the "Secure Shell Client" (that's what Dr. Conrad uses on his laptop in lecture.) On the Sun Rays, you use a program called "XTerm"

To open an XTerm terminal session on strauss, go to the upper left hand corner of the screen, select the "Applications" menu, then the submenu "Programming", then the option "Xterm on strauss". In this window, you'll be able to do all the Unix commands you've learned in lecture, and most of the ones that are mentioned in Unix textbooks.

An XTerm looks like this:

"XTerm on Strauss" vs. just plain old "XTerm"

Note that if you accidentally select the Xterm option on the Applications menu that just says "Xterm" (plain old "Xterm", not "Xterm on Strauss"), you'll end up with an Xterm that is running on the SunRay servers (either Vivaldi, Haydn or Schubert.)

Vivaldi, Haydn and Schubert are separate computers from strauss

If you open an XTerm on Vivaldi, Haydn and Schubert, this will allow you to use the Unix commands that work with files. But, only the computer called strauss has the tools like emacs and the C++ compiler that you need to do C++ programming. Strauss is also the only computer with the MATLAB programming environment.

You'll very likely run into difficulty if you try to do your programming here; either the compiler wont be there at all (you'll get messages like "cc: command not found") or you might pick up some off-brand version of the compiler that works differently from what you are used to, confusing you no end. So, make sure you are programming on strauss, and no where else.

To check if you are on strauss, type hostname at the Unix prompt. If it doesn't come back with "strauss.udel.edu", you'll know you have an Xterm on the wrong machine.

Step 3 : Setting up your .localenv file (to manage your path).

Open a terminal window on strauss. In that windows, type the following:

> echo $PATH 

You should see output such as the following. Your output might not match the following exactly, but it will be in the same form:

> echo $PATH
/opt/sfw/bin:/opt/tex/bin:/opt/texutils/bin:/opt/bin:/opt/SUNWspro/bin:/usr/open
win/bin:/usr/bin:/usr/ccs/bin:/usr/ucb:/opt/X11R5/bin
> 

The command echo $PATH tells the shell to print the value of a so-called environment variable called PATH. This variable contains a "colon-separated" list of directory locations where Unix will look for executable programs when you type in a command. (Windows has a similar concept, and I imagine Mac OS X probably does as well.)

It is important for your path to contain the right list of directories so that you can access the compilers we will use in this course. The locations of the compilers change periodically as the compilers are upgraded to newer versions (to fix bugs, and to incorporate new features into the C and C++ languages). If your account was set up a while back, it may not have an up-to-date path.

There are several files that you can customize in your directory in order to modify your path. These files are typically stored in your home directory on unix (the one you are in when you first login, and the one you return to if you type cd at the Unix command prompt.) These files have names that start with a period, which is how Unix implements the concept of "hidden files"; files that start with a period (e.g. .cshrc, .bashrc, .localenv, .emacs) do not typically show up in directory listings unless you specifically request to show hidden files.)

To list the files in your home directory including hidden files, first cd to your home directory, then use the ls -al command. Note that there is a space between ls and -al:

> ls -al
-rw-------   1 pconrad  1173        3391 Oct 19 09:42 %backup%~
drwx--x--x  36 pconrad  4000        8192 Feb  8 20:51 .
drwxr-xr-x 226 root     other       8192 Feb  8 04:08 ..
-rw-------   1 pconrad  4000        2090 Dec  7 10:39 .ICEauthority
-rw-------   1 pconrad  0376        2401 Feb  7 16:40 .TTauthority
drwx------   2 pconrad  2265        4096 Mar 11  2004 .Trash
-rw-------   1 pconrad  0376       13100 Feb  7 18:05 .Xauthority
-rw-------   1 pconrad  4000         814 Jun 11  1996 .ab_library
-rw-------   1 pconrad  1173        1894 Nov  9 15:21 .acrorc
-rw-------   1 pconrad  1173         237 Nov  9 15:21 .acrosrch
-rw-------   1 pconrad  4000         303 Feb 12  1998 .addressbook
-rw-------   1 pconrad  4000        2399 Feb 12  1998 .addressbook.lu
-rw-------   1 pconrad  4000        3071 Sep 20  1995 .article
etc....

The file we are most interested is the file .localenv, which must be located in your home directory. Type the command:

> emacs .localenv

# Set up path to SUN compilers


if -d /opt/SUNWspro then
  setenv NEWPATH /opt/SUNWspro/bin:$NEWPATH
  setenv MANPATH /opt/SUNWspro/man:$MANPATH
  setenv LD_LIBRARY_PATH /opt/SUNWspro/lib:$LD_LIBRARY_PATH
endif


# Set up path to latest version of gcc



if -d /opt/gcc-4.1.1 then
  setenv GCC_HOME /opt/gcc-4.1.1
endif


if $?GCC_HOME then

 if -d ${GCC_HOME}/bin then
   setenv NEWPATH ${GCC_HOME}/bin:${NEWPATH}
 endif

 if  -d ${GCC_HOME}/lib then
   if ($?LD_LIBRARY_PATH) then
     setenv LD_LIBRARY_PATH ${GCC_HOME}/lib:${LD_LIBRARY_PATH}
   else
     setenv LD_LIBRARY_PATH ${GCC_HOME}/lib
   endif
 endif

 if  -d ${GCC_HOME}/man then
   if ($?MANPATH) then
     setenv MANPATH ${GCC_HOME}/man:${MANPATH}
   else
     setenv MANPATH ${GCC_HOME}/man
   endif
 endif

endif


#set up path to latest version of gdb



if -d /opt/gdb-6.6.0 then
  setenv GDB_HOME /opt/gdb-6.6.0
endif


if $?GDB_HOME then

 if -d ${GDB_HOME}/bin then
   setenv NEWPATH ${GDB_HOME}/bin:${NEWPATH}
 endif

 if  -d ${GDB_HOME}/lib then
   if ($?LD_LIBRARY_PATH) then
     setenv LD_LIBRARY_PATH ${GDB_HOME}/lib:${LD_LIBRARY_PATH}
   else
     setenv LD_LIBRARY_PATH ${GDB_HOME}/lib
   endif
 endif

 if  -d ${GDB_HOME}/man then
   if ($?MANPATH) then
     setenv MANPATH ${GDB_HOME}/man:${MANPATH}
   else
     setenv MANPATH ${GDB_HOME}/man
   endif

 endif

endif


# this comment ensure that the file has a newline after the last command

Note: when you type in this file, it is important that the file be input exactly as shown here; follow all the punctuation, spacing, and upper vs. lowercase exactly.

In addition, it is important to add a blank line or a comment at the end of the file. If you fail to do so, you may get an error such as the following

then: then/endif not found.

In this case, one compiler or the other will likely not work.

(Full disclosure: to be precise, a blank line is not strictly necessary, but the file must end in a newline character. It may be difficult for a Unix beginner to know for sure if the file ends in a newline. Making sure that there is a blank line—or better yet, two or three blank lines—is one easy way to ensure that the file ends with a newline character.)

The .localenv file is a startup script for your shell written in the "C shell command language". If you are interested in learning more, this language is documented in your Unix textbook. Here is a brief explanation that can suffice for the time being:

The first line, if -d /opt/sfw/bin then tests whether the directory /opt/sfw/bin exists or not; this directory contains files for the GNU C and C++ compilers known as gcc (for C programming) and g++ (for C++ programming.) The GNU compilers are "open source" compilers, written by volunteer programmers. If /opt/sfw/bin exists, three setenv commands are used to set the values of three environment variables called NEWPATH, MANPATH and LD_LIBRARY_PATH. These three variables control the path for executables, manual pages, and load libraries respectively (you'll learn more about all three of these over the course of the semester.)

The next few lines do exactly the same thing but for the directory /opt/SUNWspro which contains the latest version of Sun's C and C++ compilers. These compilers are produced commercially by Sun Microsystems, the manufacturer of the strauss computer system. Until recently, these were closed source, proprietary compilers (they cost money). I don't know if that is still true or not; that may have changed. In any case, the development history of these two compilers is quite different. Although correctly written programs should produce the same results from both compilers, incorrectly written programs can produce very different error messages or error behavior. Comparing the results from both compilers can be very helpful in debugging, so it is important to be able to use both.

Once you have made the changes in the .localenv file, save the file and logout, then log back in.

You should then be able to do the following commands, and get exactly the results shown. These results indicate that you are able to use the correct versions of both the GNU and Sun compilers for both C and C++. If your output does not match that in the box below, review the .localenv file and try again, and/or ask your TA or instructor for assistance before proceeding.

> which gcc
/opt/gcc-4.1.1/bin/gcc
> which g++
/opt/gcc-4.1.1/bin/g++
> which cc
/opt/SUNWspro/bin/cc
> which CC
/opt/SUNWspro/bin/CC
>

The which command tells you the full path of the file that gets executed if you type in a particular command. For example, in the script above, you see that if you type in gcc, the actual file that gets executed is /opt/sfw/bin/cc. You'll include the commands above in a script later in this lab; for now, once you are successful in getting the output above, you are done with this step.

Step 4 : Compiling C++ programs on Strauss

In this step, you will enter the traditional "first C++ program" just to make sure that you understand how to create a C++ program, compile it, run it, and script it.

1. If you are not already there, change to the directory ~/cisc106/lab10 with the command:
   
   cd ~/cisc106/lab10
   
   The ~ character here stands for your home directory. Putting this at the front means you'll go directly to your cisc106/lab10 directory under your home directory no matter what your current directory is. Without it, Unix looks for cisc106/lab10 under the current directory, which might not always be what you want (if you are already in, for example, your lab08 directory).
   
2. Use emacs to create a file hello.cc that contains the following (except substitute your name and Unix user id for those of Jane Doe, and use today's date.)
   
   DO NOT include your student number (NEVER include that number in anything you submit in this class!)

   // hello.cc Jane Doe doej@udel.edu 09/01/04 CISC106 section 099
   // traditional first program (Anderson, p. 383)
   
   #include <iostream>
   using namespace std;

   int main()
   {
    cout << "Hello, world!" << endl;
    return 0;
   }

3. Once you've created this program, use the following command to compile it (compile means: translate from C++ into machine language, or it cannot be translated because of errors, report the errors) with one of the following commands. At this point in the semester, you may use either one (later on, I may tell you to use one or the other.) Note that the first command is CAPITAL CC, not lowercase cc.

   CC hello.cc

   OR

   g++ hello.cc
   

   The first command (CC) is a commercial compiler, supplied by Sun Microsystems. The second command, g++ is an open source compiler, supplied by the GNU project, which is staffed by volunteer programmers. From time to time, we may discover differences, but for now, I don't care which one you use. Sometimes if you have a tricky syntax error it is useful to try both, because sometimes one gives you more useful error messages than the other.

4. In both cases, a new file is produced called a.out. To execute this file (run your program, type the following:

   ./a.out

   You might be able to get away with just typing a.out without the leading ./, or you might not; it all depends on how your account is set up. (It has to do with the Unix concept of the "path"; we'll talk about this in lecture.)

   If all goes well, you should see something like the following:

   > CC hello.cc
   > ./a.out 
   Hello, world!
   >

5. You are now ready to use the script command to make a record of your work.

   Note that you must be careful when using the script command. The script command will wipe out your work if you are not careful!

   The thing to remember is: on the command line, type script followed by the name of a .txt file; for example:

   script lab10a.txt

   This is correct!!!!

   Never put script followed by the name of a .cc file. It will wipe out your .cc file!

   script hello.cc

   WRONG!!! WRONG !!!! WRONG!!!!

   Ok, now that we have that out of the way...

   Type script lab10a.txt. Then go through the following steps:

   • list your program (type cat hello.cc to do this.)
   • compile your program (type CC hello.cc or g++ hello.cc to do this)
   • run your program (type ./a.out)
   • exit from the script (type exit).

And finally, you are done with Goal 4! We'll return the file lab10a.txt and hello.cc files in the final step of this lab, where you'll submit those to WebCT along with the files you create in Goal 5:

Step 5 : C++ programming on Strauss

1. If you are not already there, change directory into ~/cisc106/lab10 with the command:

    cd  ~/cisc106/lab10

2. Do a pwd command to be sure that you are in the ~/cisc106/lab10 subdirectory. Then, use the following command to copy a program from Prof. Conrad's directory into your current working directory. BEFORE YOU TYPE THIS COMMAND, look over it carefully. You will notice that there is a space between the cp and the /www near the start of the command, and there is a space between the tempConv.cc and a period ( . ) which is at the end of the command. Those spaces are very important, and the period at the end is especially important. Be sure you type the command exactly as it appears here:
   
   cp /www/htdocs/CIS/106/pconrad/07F/labs/lab10/tempConv.cc .

The cp command in Unix is used to copy a file. The file is copied from a directory under Prof. Conrad's home directory. Note that ~ by itself refers to your home directory, but ~pconrad refers to "pconrad's home directory". Similar, you can refer to any user's home directory on strauss if you know that user's login name; e.g. jsample's home directory can be accessed via ls ~jsample.
   
   The period by itself at the end is the "target" of the copy command, i.e. the place we are copying the file "to". A period, all by itself, refers to the "current working directory", the same one that comes up when you type pwd (print working directory). So, since the current working directory is ~/cisc106/lab10, we could also have done the same copy command using the following:
   
   cp /www/htdocs/CIS/106/pconrad/07F/labs/lab10/tempConv.cc ~/cisc106/lab10

   but the command was already pretty long, so using the . is a nice shortcut.
   
3. Now, do an ls command, and you should see the tempConv.cc file in your directory. Your next step is to list the contents of the file, then compile the program, and run the program. Before you look at the list of commands below (which do those three steps), see if you can figure out what you would type to accomplish this. Then scroll down and see if you were right.
   
   scroll down for the answer
   
   keep scrolling down for the answer
   
   still further
   
   almost there
   
   ok here's the answer:
   
   cat tempConv.cc
g++ tempConv.cc
./a.out

Did you get it right? Note: you could also have done more tempConv.cc in the first step (if the file is too large to fit on the screen all at once), and CC tempConv.cc for the second step.
   
   An aside about the more program: note that you should never use more inside a script file; only use cat inside a script file. The more program is only for when you are looking at the file in "real time", not for scripts that you are going to print or submit electronically.
   
4. Run the program a few times with different values, and look it over to see how it works.
   
5. Now, the actual thinking work starts (though admittedly, this is still pretty darn easy.) This program, implements an algorithm to convert from Fahrenheit to Celsius (subtract 32, divide by 9, multiply by 5.) Your job is to edit the program (e.g. using emacs tempConv.cc or vi tempConv.cc) so that it converts, instead, from Celsius to Fahrenheit.
   
   You will need to modify (at least) the following:
   
   
   • The comments that explain the purpose of the program, the name of the programmer, and the date
   • The name of fahrenToCelsius function. Give it a different name, as appropriate, one that indicates that the conversion goes the other way.
   • The formula in the function
   • The prompts in the main program that tell the user what to type in, and the labels that explain the output.
     
6. Once you have finished editing, try compiling and running again. Test your program with several different values to be sure the conversion is working properly.
7. Now you are ready to script your tempConv.cc program. We'll do that in the "finishing up" step.
   

Finishing up: What to turn in for this lab

1. Change to the ~/cisc106/lab10 subdirectory. Make a script called lab10b.txt that contains all of the following steps. Note that we are showing that your program compiles with both CC and g++. Typically, it is only necessary to compile with one or the other.
   

   
script lab10b.txt   to start the script
   echo $PATH
which g++
which CC
cat ~/.localenv
cd ~/cisc106/lab10
pwd
ls
cat tempConv.cc
CC tempConv.cc
g++ tempConv.cc
./a.out    repeat this step with several different inputs
   exit  to end the script

2. Then, upload your lab10b.txt file and your tempConv.cc to WebCT, along with the lab10a.txt and hello.cc files you did in an earlier step.
3. You should now have four files uploaded: lab10a.txt, hello.cc, lab10b.txt, and tempConv.cc. Now you can hit submit.

Grading: 100 pts
Due: Tue, 11/20/2007 11:55PM (note that this is sooner than usual!)

• correctly changing your default shell and default group is worth 10 points
• correctly setting up your .localenv file is worth 10 points
• correctly scripting the hello.cc "Hello World" Program is worth 10 points (in the file lab10a.txt)
• correctness of the tempConv.cc algorithm and C++ code (temperature conversion) is worth 30 points
• formatting and style of hello.cc and tempConv.cc is worth 20 points (indentation, comments, etc.)
• correctness and neatness of the script file lab10b.txt is worth 20 points
  

Special Late Penalty Schedule for Lab10:

Each day shows the penalty if turned in by 11:55pm on that day.
Note that late penalties are suspended during Thanksgiving break.

End of lab10 for CISC106, Fall 2007 (100 pts)