Purpose
The purpose of this lab is to make sure that everyone can:

1. Get up and running using your account on the Linux operating sytstem on a computer in EPS254,
2. Answer questions about the use of basic Linux (or Unix) commands.
3. Use an text editor (emacs, vi, or pico) on Linux.
4. Write and compile a simple C++ program.

What to do

1. To begin:
   • Each person should work individually on this assignment.
   • Be sure your computer is running Linux. If not, reboot into Linux.
   • Log in to your account
2. First, you will experient with text editors, and decide which one you want to use.
3. Next, you will run a Unix tutorial, then answer some questions, and experiment with Unix.
4. Finally, you will use the text editor to write a simple C++ program, compile it, then run it.

Text Editors
Unix has several text editors you may use. The simplest to use is probably pico but emacs and vi are more powerful, although may take longer to learn to use. Start up the editor of your choice, and use the help feature to learn to use it.

• $ emacs & (for the emacs editor)
• $ vi & (for the vi editor)
• $ pico & (for the pico editor)
  (The emacs family has some nice features for programming, but you can use another text editor if you like.)

Unix
There are many Unix tutorials available on the World Wide Web. Go to this one, bookmark it, and then take some time to see what is available, then read at least the first two sections and then answer the following questions.

1. Type ls. What happens and why?
2. How is ls -l different than simply ls?
3. Explain how to make a directory called cs210. (Do it.)
4. Explain how to make cs210 your working directory. (Do it.)
5. From your cs210 directory, describe three separate ways to go back to your home directory.
6. From your cs210 directory, show the exact directory structure from the root of esus to your 210 directory.
7. Navigate our Unix system enough to estimate the number of students with esus accounts. Explain how you derived your estimate.

Write, compile and run a C++ program

1. When you have completed the above exercises, go to your cs210 directory and create a subdirectory called inlab1.
2. Go to the inlab1 subdirectory and use a text editor to create a file called lab1.cpp. Write a C++ program that prompts the user for the width, height, and depth of a box and then prints out its volume. Assume that all numbers are integers. A sample run is shown below.

     Box volume program.
   
     Enter the width of the box: 2
     Enter the height of the box: 3
     Enter the depth of the box: 4
   
     The volume of the box is 24.

3. Compile your program by typing g++ lab1.cpp
4. Run your program by typing a.out.

Purpose
The purpose of this lab is to gain experience
1. Writing functions
2. Using strings and the vector container,
3. Getting input from a file, and sending output to a file.

What to do
Your assignment is to do #7 on page 34 of the Weiss text, inputting the strings from a file you will create. Specific instructions are below.

Using vectors


• Write a function that accepts a vector of strings as an argument and returns a another vector that contains only the strings that have the longest length.
  • In other words, if there are ten strings that are tied for being the longest length, the return value is a vector of size ten containing those longest strings.
• Then test your function in main( ) by reading in an abitrary number of strings(from a file), call the function, and output the strings returned by the vector.

Using file input/output
There are notes with examples on the lecture from Tuesday, January 27, but here are the important points.

• For input from a file you must create an object to use with the extraction operator instead of cin which accepts input from the standard input device (usually the keyboard). To create this object
  • Put #include < fstream> at the beginning of your file
  • Declare an ifstream file object to connect to the disk file with this statement
    ifstream fileIn ("c:\\filename.dat")
    
  • fileIn can be any variable name, and the string inside the parentheses is the name and location on disk of the data file.
  • The ifstream object is then used just exactly like cin except the input will come from a file, not from the keyboard.
• For output to a file you must create an object to use with the insertion operator instead of cout which writes to the screen. To create this object
  • Put #include < fstream> at the beginning of your file
  • Declare an ofstream file object to connect to the disk file with this statement
    ofstream fileOut ("c:\\filename.dat")
    
  • fileOut can be any variable name, and the string inside the parentheses is the name and location on disk of the data file.
  • The ofstream object is then used just exactly like cout except the output will be to a file, not to the screen
• Your program should:
  1. have a function that creates the data file.
  2. have another function that reads from the data file and puts the strings into the first vector.
  3. have the function that accepts a vector of strings as an argument and returns a another vector that contains only the strings that have the longest length.
  4. These three functions should be called from main( ). Use prototypes so that the first function in your program is main( ).
Hand in:

• Have your source code ready to hand in at the beginning of lab next week.
• Be ready to demo your program at the beginning of lab next week.

Purpose
The purpose of this week's lab is to gain experience working with pointers. First you will read through some C++ code until you understand what it is doing, drawing diagrams to help you understand, then modify the code.

What to do


You will be working with a linked list class. The linked list is a circular, doubly linked list with a dummy header node. Before beginning the lab, download the following file List3.cpp.   Open it, and familiarize yourself with the code in the file. Then do at least the first part in the lab today. You should have the TA or a consultant check your diagram before you leave the lab.. Do not be concerned if it takes you a long time to understand the code. It is not especially easy, and is really difficult without diagrams. When you finish with your diagrams, start on the modifications

Understanding the code


1. On a sheet of paper, walk through Initialize( ), drawing the new node created and the pointers.
2. Then add each node using Insert( ), reassigning the pointers as directed by the code.
3. Draw a new diagram for each new insertion. You should have four diagrams, each with one more node than the former. Keep this paper to hand in; it should be reasonably neat, showing how four nodes in the linked list are connected.

Modifying the code


1. Change the Insert( ) method so that it does not allow an element that is already in the linked list to be inserted again.
   • In this case an appropriate error message should be printed.
   • You will have to change main to add the new elements. You can hardcode the input for this exercise if you want, or you can make it more elegant.
2. Change the Insert( ) method so that it keeps the elements in sorted order as they are inserted
3. Add an method called Print_Backwards( ) that prints the elements in the linked list in reverse sorted order. Make sure that you don't print out the dummy header record!
4. Add an method called Remove ( ) that removes an element (if it exists) from the linked list. Remove should print a message stating whether or not the removal was successful.

Hand in:

• Be ready to demo your code in lab next week.
• Hand in a printout of your modified code, and your diagrams.

Purpose
The purpose of this lab is to gain experience working with double-subscripted arrays, and arrays of C-strings.

What to do
Download the code for the card shuffling program that we went over in lecture. Compile and run it so that you can see what it does. As we said in class, this code is quite inefficient. You will need to modify the shuffle and deal functions to make them more efficient, then deal and alalyze some poker hands.

Modify the shuffle function


• As it now stands, the shuffle function can lead to indefinite postponement.
  • It may take almost forever to find the empty spot to put the 52nd card.
• A better way
  • Initialize the deck so that it is initialized as shown below.

    	0	1	2	3	4	5	6	7	8	9	10	11	12
    0	1	2	3	4	5	6	7	8	9	10	11	12	13
    1	14	15	16	17	18	19	20	21	22	23	24	25	26
    2	27	28	29	30	31	32	33	34	35	36	37	38	39
    3	40	41	42	43	44	45	46	47	48	49	50	51	52

  • Modify the shuffle function to loop through every element in the array, swapping with a randomly selected element of the array.
  • Test the resulting array to be sure your shuffle function is working well
    • You may want to shuffle several times before dealing

Modify the deal function


• As it now stands the dealing function locates and deals a card, then it continues searching though the remainder of the deck.
  • This is very inefficient.
• A better way:
  • Modify the function so that once a card is dealt, no further attempts are made to match that card number, and the function immediately proceeds with dealing the next card, if one is to be dealt.

Deal and analyze some poker hands


• Modify the program so that the card dealing function deals a five-card poker hand.
• Then write functions to accomplish each of the following:
  • Determine if the hand contains a pair
  • Determine if the hand contains two pair
  • Determine if the hand contains three of a kind
  • Determine if the hand contains four of a kind
  • Determine if the hand contains a flush (all five cards one suit)
  • Determine if the hand contains a straight (five cards of consecutive face values)
• Modify main to deal a hand, then output the cards in the hand, and tell what it contains (i.e. a pair, etc.)

Extra credit

• Modify the program so that it deals two five-card poker hands, evaluates each hand, then determines which hand is better
• Output all the necessay information so that the user can see what the hands are, and if the evaluation is correct.

Hand in


• Have your source code ready to hand in at the beginning of lab February 25.
• Be ready to demo your program at the beginning of lab February 25.

Due dates:
March 3:  In lab next week you will be expected to hand in and discuss with the TA (or helper)your design for the solution of this problem and to demonstrate a working Makefile before the end of the lab. You can stub in the implementation of the member functions.
March 10: In two weeks from today the implementation will be due at the beginning of lab.

Purpose


The purpose of this lab is to work with classes, and to keep the separate parts of your program in different files, and use a Make file to tell the compiler and linker how to put your program together

Part 1 -- Design your program
Your design should include

1. The header file for the class Fraction. Remember the header file for a class includes:
   • The prototypes for all the member functions, along with comments for each function that tell a client the conditions that must be true before the function is called (preconditons), the number and type of argument, what the function does, and what, if anything, it returns.
   • The data members of the class.
2. The design of the driver you intend to use to test your fraction class. Often the driver is implmented before or in parallel with the implementation of a class. Knowing how a class will be used often helps in the design.
3. Keep in mind as you design your class that when the client instantiates an object of type Fraction, that object should be ONE fraction. If the client wants more than one fraction, they will instantiate them.
4. Here are some tips to help you in the design and implementation:
   • In the design phase, you must decide on the name, return type and type and number of parameters for each member function, and the pre and post conditions.
   • When that is done, you can begin implementation of the simplier methods.
   • Before you try to implement the more complex methods, (the add and reduce to lowest terms) you must analyze carefully how you perform these calculations. You should design an algorithm in English of the steps involved in adding two fractions before you try to implement it.
   • If you cannot clearly state in English the steps to solve a problem, the chances that you will be able to do so in C++ are pretty slim.
   • When you have the add method tested and working correctly then design the method to reduce to lowest terms. Be sure to design it before trying to implement it.

Part 2 -- Implement your program and driver
The class Fractions that you design should have as a minimum (to get a C):

• Private data members (both of these should be integers)
  • numerator and
  • denominator.
• Member functions
  • constructors using default arguments and an initializer list
  • mutator and access methods as needed,
  • a method to add two fraction objects,
  • a method to reduce a fraction object to lowest terms.
  • overloaded insertion and extraction operators to allow you to output an object of type fraction directly.

  To earn an A or B you should implement other methods to subtract, multiply and divide the fractions. The more of these you implement, the higher the grade.

The driver (client) of your Fraction class

The client, or driver program should present the user with a menu asking what they want to do. (The menu itself will depend on how much you decide to implement.) It should then prompt the user for the numerator and denominator for the fractions. Then it should echo the input, and output the answer. The answer should be a fraction reduced to lowest terms.

	The sum of 1/2 and 1/3 is 5/6

• After everyting above is working correctly, you may want to add to your program.
• In main( ), declare an array of ten objects of type Fraction.
• In a loop, ask the user to input values into the ten fractions.
• Find the sum of the ten fractions, and output it in reduced form (you may use an improper fraction, or a mixed number; your choice).
• Find the largest of the ten fractions in the array. One way to do this would be to overload the > operator in the Fraction class.
• Your menu will have to be modified to allow the user the choice of using this part of your program.

Due dates:
March 24:  In lab next week you will be expected to hand in and discuss with the TA (or helper)your design for the solution of this problem and any problems you are having with the implementation.
March 31: The implementation will be due at the beginning of lab. You should be ready to demo your program.

The address book
You should start this assignment by thinking about what features would be nice in an electronic address book. At a minimum, you should be able to type in a name, and the program responds with the address and phone number of that person. Also necessary is the ability to save the names, addresses, and phone numbers etc. to a disk file, so the names in your address book grows over time. You should think of other functionality.

What to do


1. Before you leave the lab today, you must have the TA or consultant check off that you have shown them a list of the functionality you would like to include in your address book. Discuss with them the pros and cons of different operations. You can alter this list of functionality later if you want, but you must start knowing what you want your program to do.

2. Design your program. The choice of data structures to use in your program can make implementation easy or a nightmare, so you need to think about it carefully, and discuss it with others so you are sure to consider several options. I am going to make one requirment, and several suggestions.
   Requirment:  
   • You must create a Person class that will encapsulate
     1. the data members (name, address, phone, etc.) of each object of type Person in your address book and
     2. the operations on an object of type Person. Operations might include outputting, ability to do comparisons (overload the > operator), accessors and mutators, etc.
   Suggestions:
   • You are going to need a container to hold the objects of type Person. You have quite a few choices, among them:
     • arrays
     • linked lists
     • vectors
     • other STL containers, if you want to read ahead.
   • If you want to output the entire address book, the names should be listed alphabetically.

3. Implement the program.
   • Separate your interface and implementation files
   • Use exceptions to handle errors.
   • Make the menu that allows the user to choose what they want to do user friendly.
   • If you find that you have many functions that deal with manipulating the array of Persons (or vector, or linked list, or whatever) you may want to encapsulate them with the array in a class. I will talk more about this in class, after you get started on the problem

As you would expect, the more functionality you include in your address book, and the more friendly the user interface, the better your grade will be. Each person must work independently, but you definately should discuss with your classmates different aspects of this program.