CS 31: Lab 2

C Warm-up: Sorting

Due: Tuesday, September 18, 11:59 PM

Handy References:

Lab 2 Goals:

Partner Etiquette

For lab assignments when you are working with a partner you should follow these guidelines:

Taking time to design a plan for your solution together and doing incremental implementation and testing together may seem inefficient, but in the long run it will save you time. By working together it is less likely that you have design or logic errors in your solution, and you will more easily be able to track down and correct bugs.

Partnerships where partners work mostly independently rarely work out well and rarely result in complete, correct and robust solutions. Partnerships where partners work side-by-side for all or most of the time tend to work out very well. You and your partner are both equally responsible for initiating scheduling times when you can meet to work together, and for making time available in your schedule for working together.

Lab Outline

You will implement program that sorts floating point numbers using a sorting algorithm of your choice in C. Your program will read a collection of unsorted floats from a file, store those floats in an array, provide some information about the floats to the user, sort them from smallest magnitude to largest magnitude (i.e., ascending order), and print them out in sorted form to the user.

Lab 2 Starting Point Code

If you haven't already done so, follow the one-time configuration instructions on the weekly lab page.

Next, you'll follow our course git guide to make a local clone of the git repository that you share with your partner. Our organization's name is CS31-F18, and the repository you want to use is named Lab2-user1-user2, where user1 and user2 are the user names of you and your partner.

Cloning the repository will give you the starting point code, which includes:

  1. Makefile: A Makefile simplifies the process of compiling your program. We'll look at these in more detail later in the course. You're welcome to look over this one, but you shouldn't need to edit it for lab 2.

  2. readfile.h and readfile.c:These files contain a library for reading from files. You should make calls to functions in this library in your program to simplify file I/O. The instructions for using this library are explained below.
    You should not modify any code in these two files.

  3. sorter.c: the file into which you will add your C solution and comments. The starting point code includes a helper function for you:
    • get_filename_from_commandline: takes the storage space for a string and the command line arguments and initializes the string storage space with the filename from the command line argument. You should not change this function, but feel free to change where it gets called.

  4. floats.txt, floats2.txt, and floats3.txt: example input files to your program. These are provided for your convenience to help you test your program. You will ultimately want to create new test files to more extensively test your program before you consider it finished.

To compile your program, run make, which will use the Makefile to build your program (and link in the provided readfile library). Running make will show you the compiler output, which you should examine for errors and warnings.

  $ make
  gcc -g -Wall -c readfile.c
  gcc -g -Wall -o sorter sorter.c  readfile.o
  sorter.c: In function 'main':
  sorter.c:23:9: warning: unused variable 'values' [-Wunused-variable]
     float values[ARRAYSIZE];

Program Start-up

Your program will take one command line argument: the name of the input file containing floating point values to sort, one on each line. You should read these values (using the provided library), sort them, and print out the sorted result back to the user. Here is an example of how you invoke the program:

  $ ./sorter floats.txt

File Format

The input file format consists of several lines of an ASCII text file. A properly formatted file will contain a short header, consisting of a single line with one integer and two floats on it. These numbers represent the total number of floats in the file (i.e., the number of subsequent lines), as well as the minimum and maximum to-be-sorted float value in the file. These numbers will be written like this:

For example, here is the header of a valid input file:

  4 0.0 9.0

This header indicates that the file contains a total of 4 floats that need to be sorted. The smallest float value in the file will be 0.0, and the largest will be 9.0. You may not need to know the minimum and maximum values to successfully sort the values, but you will need to inform the user about the range of values being sorted.

Included with the starting point code are a few sample test files you can use to test your code. Every line after the first line in the file will contain a single floating point number. These are the float values that must be sorted. For example, a file containing the header we just saw might look like this (after the first line):


File I/O

For this assignment we'll use functions from the provided readfile library (in the files readfile.c and readfile.h). You should not change any code in these files. The readfile.h file contains function prototypes for the readfile library. There are function comments in this file that describe each function and a high-level comment describes how to use the library.

Here are the general rules for how to use these functions:

  1. Open a file by calling: open_file(), passing in the name of the file to open as a string. The return value of open_file() tells you whether or not the file was opened successfully. It returns 0 if the file is successfully opened, and -1 if the file cannot be opened. You should always check the return value of this function and respond appropriately!

  2. Call the read_int(), read_string(), read_float() functions to read values from the file into your program's variables, where the name of the function you call determines the resulting type of the value that gets filled in. Like open_file(), these functions return 0 on success, and you should always check their return value. If you've reached the end of the file, they will return -1.

  3. These functions take arguments much like scanf does: they need to know the memory location of where to put the value read in.
    For example:
      int x;
      float f;
      char s[20];
      /* These functions return 0 on success or -1 if read fails or
       * if there is nothing left to read (end-of-file has been reached). */
      ret = read_float(&f);
      ret = read_int(&x)
      ret = read_string(s)

  4. Close the file when you're done with it: close_file().

If you are curious, the implementation of these functions is in readfile.c. You can take a look and see how it uses the C FILE * interface and fscanf functions for reading. We will use this interface directly later in the semester. For now, we're hiding it under a layer of abstraction!


Your output should look like this output from an example run of a working program. It doesn't show every possible run or error handling, but should give you some idea of what a correct program will look like. To make my job of grading easier, please make your output match the example as closely as possible.

For full credit, your solution should meet the following requirements:

Implementation Recommendations

The following is the suggested way to implement the lab and fulfill the requirements. If you intend to significantly deviate from this design, please let me know so that I can do a basic sanity check of your proposed changes.



Please remove any debugging output prior to submitting.

To submit your code, simply commit your changes locally using git add and git commit. Then run git push while in your lab directory. Only one partner needs to run the final push, but make sure both partners have pulled and merged each others changes. See the section on Using a shared repo on the git help page.