Lab materials

• Slides: Introduction
• Slides: Pointers

Reminder on style

• Coding style must be uniform throughout all the code files
• Your code should be easily readable and maintainable
• Prefer simple over bloated and overengineered code
• Divide your code into functions
  • Functions should be simple, short, do only one thing and do it well
  • Keep computational and input/output functions separate. If a function produces a result, it should avoid side effects if possible.
  • Functions should be easily reusable. This will help you during the test and the exam.
  • main function should be the first function in a file. All user-defined functions should be positioned after the main function.
• Use reasonably fast algorithms within the ones we’ve studies so far
• Avoid global variables in most situations, there are a few where it’s okay and those situations will be mentioned separately during the course.

Tasks

There are two lab tasks in this class. The first task focuses on passing data using pointers and the second task is about how arrays and pointers work together. Second task is divided into two parts and extended by an extra task.

Lab task 1 [W01-1]: Pointer to a variable

This is a classical swap the two values in a function task. Try to solve this task by instructions and slides alone, without using outside help or materials.

Download the starter code here: https://blue.pri.ee/ttu/files/iax0584/aluskoodid/t1_swap_template.c

Theory nugget 1: stderr standard stream

This semester we will start to separate error outputs from normal outputs. All error outputs will go to stderr standard error stream. This is common for most programming languages, including C. It allows to filter out errors from the normal output, look up “redirect stderr to file” for more information.

Old way: print all errors to stdout  standard output stream: printf("Error! ....");

From now on: print all errors to stderr  standard error stream: fprintf(stderr, "Error! ...");

Theory nugget: New macros introduced in the starter code

When reading through the starter code, you’ll notice a new element  __FUNCTION__  – this is a string that prints the function name where it is used. It will be resolved when you compile the code – do not attempt to modify it. Starting from C99 standard, you can also use  __func__  – both achieve the same thing.

In addition, there are two more macros that are often used for debugging code:

• __LINE__ prints the line number where the macro is used
• __FILE__ prints the name of the file where the macro is used

Using those, we could write something like

This makes it easier to observe in which file, in which function and on which line an error occurred.

Requirements

• Use the starter code provided
• All parts you need to complete are marked with TODO  in the starter code
• Create two functions according to function comments in the starter code. One to read values, second to swap values. Call the functions.
• Print out the memory addresses where the data is stored in three different locations
  1. In the main()  function, show where the variables are declared at in memory
  2. In the reading function, show the addresses where you are storing the values to
  3. In the swap function, show the location where the values are you are swapping
• Explain the significance of the address values when defending!

Testing

Lab task 2 part 1 [W01-2]: Pointer to an array

The purpose of the second task is to show how arrays and pointers are related to each other. In addition, we will explore pointer arithmetic and and do a reminder from last semester, where we learned about files and command line arguments.

The program needs a data file that contains integers. Create the data file yourself! Numbers can either be separated by spaces or newlines.

Requirements

Create a program that fulfills the following requirements

• Reads 10 integers from a file and stores them into an array
• The name of the file is read as a command line argument
• Show the array base address in the main function
• Print out the read integers and their memory addresses
• Find the minimum and maximum value from the array

Additional requirements that must be met

• During this task, you are not permitted to use square brackets []  for indexing the array (limitation does not apply to declaring an array). Use pointer arithmetic in all functions
• The program is halted if the file doesn’t exist or it was unable to read integers from the file – i.e. file contains something else
• You must complete the list of functions specified in the requirements
• All functions must be called from the main()  function
• The minimum and maximum value must be printed in the main()  function
• All error messages must be printed to the stderr  standard stream.

Create the following functions

• Create a function, that reads 10 numbers  from a file and stores them in an array.
  • Optional: if you wish, you can print out the addresses during reading for self-checking and comparison against other functions
  • Parameters: array, the array size (limit), name of input file
  • Return: how many numbers were read
  • You must avoid reading more numbers than can fit into the array
  • You can use the following partial solution for the function and fill in the gaps highlighted by TODO. It should be relatively similar to week 8 in programming one, but with the addition of the file
    
    C

    int ReadValuesFromFile(int *arr, int arrayMaxSize, const char *fileName) { // TODO: Open the file and check if it opened // Read a maximum of arrayMaxSize integers int i = 0; while (i < arrayMaxSize) { // TODO: Read a number from file and store the return value for checking int ret = fscanf(); // Something happened - either file ended or input format was incorrect if (ret != 1) { // Stop reading integers and return the number of members read break; } // Increment successfully read integer count i++; } // TODO: Close the input file fclose(); // TODO: Return the number of integers read return ; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

    int ReadValuesFromFile(int *arr, int arrayMaxSize, const char *fileName) {     // TODO: Open the file and check if it opened          // Read a maximum of arrayMaxSize integers     int i = 0;     while (i < arrayMaxSize)     {         // TODO: Read a number from file and store the return value for checking         int ret = fscanf();                  // Something happened - either file ended or input format was incorrect         if (ret != 1)         {             // Stop reading integers and return the number of members read             break;         }                  // Increment successfully read integer count         i++;     }          // TODO: Close the input file         fclose();          // TODO: Return the number of integers read     return ; }

  • Additional hint: For a readable solution of calling this function, you can store the command line argument in a pointer as follows:
    
    C

    // Grab the file name char *inputFile = argv[1]; // Read data from file, int numCnt = ReadValuesFromFile(nums, LEN, inputFile);

    1 2 3 4 5

    // Grab the file name char *inputFile = argv[1];   // Read data from file, int numCnt = ReadValuesFromFile(nums, LEN, inputFile);

• Create a function that prints out all numbers and their memory addresses
  • Parameters: name of the array, number of integers read from the file
• Create a function that  find both the minimum and maximum number
  • You can only call this function once – it must find both results in one go and store them
  • Function can’t return anything, i.e. the function return type must be void .
  • Assume that only one minimum and maximum exists
  • Use the concept of pointers from task 1 to solve getting multiple values from a function.
    • Do not use an array to store min/max values!
    • Do not print the results in this function.

Testing

When testing the base task, test for four different results

1. Command line arguments are missing, program prints an error and closes
2. File does not open, program prints an error and closes
3. There are no integers in the file, program prints an error and closes
4. There are some integers in the file. At most 10 will be read and printed. Minimum and maximum value will be printed.

Lab task 2 part 2 [W01-3]: Interpretation of array concept

The purpose of the second part of the task is to make sure you understood the concept that an array can be interpreted as the pointer to the first member.

Requirements

• Create (or reuse 😉 ) a function that is able to print n numbers and their memory addresses in the array.
• The function can only have two parameters.
• The function must be built in a way that it is able to print any arbitrary array
• To demonstrate that you wrote this function correctly (and understood the topic correctly), call the function 3 times, so that
  • it will print out all members of the array
  • it will print out elements 0 to 4
  • it will print out elements 3 – 9
• NB! What happens if you got less numbers from the file?

Hint 1: Think before acting! This part of the task is about the concept of pointers and arrays rather than creating some very clever and devious solution! Do not attempt to over-engineer the solution!

Hint 2: The text preceding the printed array members should be printed in the main() function, before the function call.

Testing

Part two has two possible results

1. Array is long enough, program will print the requested sequences
2. Array does not contain enough members, program will print an error.

The example shows expected output if enough members were read.

Extra task [W01-4]: MinMax task with addresses

In this task, we will recreate the minmax function from part 1 of task 2 . We add the ability to also print the memory addresses and indexes for the minimum and maximum value.

You are recommended to leave the original implementation in place and create a new function.

Requirements

• Create a new function to find the locations of the minimum and maximum elements in the array in one go.
• The return type of this function must be void .
• The function must have 4 parameters
  • Array
  • Length of the array
  • 2 pointers or double pointers – figure out what to store in them!
• In the main function, print out the following results
  • The min and max value
  • The addresses of where the min and max are stored in the array
  • The index of min and max value in the array.
  • NB! You must calculate the results, not loop through the array

Testing

Expected output of extra task

After the class, you should

• Understand the requirements for this subject, including how to get a grade
• Understand what a pointer is
• Understand the significance of memory addresses
• Understand virtual and physical addresses
• Know what affects the address length
• Know the extra memory requirements for explicit use of pointers
• Be able to declare pointers
• Know the coding style aspects of declaring and using pointers
• Know what’s the importance of pointer data types
• Know the significance and use for NULL pointers
• Know the two pointer operators and where to use them
• Have some understanding of possible use cases for pointers
• Know how to use pointer arithmetic
• Have a better understanding of the scanf arguments and how pointers come into play here
• Understand why we said that arrays were editable when passed to a function, but variables were not
• Be able to pass the addresses of variables to functions as pointers
• Be able to edit multiple variables in a function
• Understand the concept of double pointers
• Know how to use a ternary operator
• Know how to use GCC macros for listing the name of the file, function and line number
• Know how and when to use stderr standard stream

Additional content

• Predefined macros
  https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
• Beej’s Guide to C Programming: Pointers—Cower In Fear!
  https://beej.us/guide/bgc/html/split/pointers.html#pointers
• Beej’s Guide to C Programming: Pointers II: Arithmetic
  https://beej.us/guide/bgc/html/split/pointers2.html#pointers2
• C pointers
  https://www.geeksforgeeks.org/c-pointers
• Pointers – CS50 shorts
  https://www.youtube.com/watch?v=XISnO2YhnsY

Lab materials

• Slides: Enumeration
• Additional example: calculator with enums
• Additional example: enumerations

Tasks

The lab has two tasks. These tasks cover a lot of topics from Programming 1, but are enriched with the enumeration topic introduced this week.  Both tasks also benefit from the pointers covered last week.

Lab task [W02-1]: File categorization

In this task, you will create a utility that will be able to count how many files of each category exist (e.g. how many image files in a directory and its subdirectories).  We will only create the part that categorizes files and counts the totals.

To find the names of files, we will use knowledge from the Linux task last semester. We will use a tool called find  to find the files recursively and pipe them to our program. By doing this, we will be able to index and categorize any amount of files recursively in all subdirectories.

Note: To demonstrate the potential of combining programs you need have access to a bash environment. Easiest way is to test in the university environment (use the lab computer, remote desktop or create an SSH tunnel to one of our servers or lab computers).

Requirements

Create a program that

• Accepts an unknown number of file names from the standard input ( stdin ).
  • You are not allowed to preemptively ask for number of inputs or have a designated string to stop reading inputs.
  • To stop reading the strings and show the statistics, listen for the EOF  (end of file) signal.
• Categorizes those files to groups based on the identifiable extensions and counts how many files in each category.
• Display how many files were in each category.
• Categories must be identified as enumeration type in code.
• One of the functions you need to have is specified for you. It needs to  take the file extension as a parameter and returns the enum of the category. Proposed function prototype:
  enum FileCategory GetFileCategory(char *extension);
• Your program can provide a prompt when started (i.e. instructions), but must not write anything to the output in between inputs.

Categories and extensions

This is a list of categories that you are expected to test against. The results of files using these extensions is also given as a test set.

• Archives: zip, rar, 7z, tar, gz
• Data: csv, xls, xlsx, ods
• Documents: pdf, doc, docx, rtf, odt
• Code: c, h, cpp, hpp, py
• Text: txt
• Images: jpg, jpeg, png, svg,
• Other: all files with extensions, but not in the previously listed types
• No extension

Template for the task

In order to give you a bit better idea on the expected structure and how the reading and processing would work, you are provided a template to base your task on.

Recommended steps for solving the task

1. Add a function that will fix the trailing newline in the read string
   e.g.. void FixTrailingNewline(char *str);
2. Add a function that will find the location of the last point ( . ) symbol in the string to identify the start of the file extension.
   e.g. int GetLastPointPos(char *str);
3. Add the category enumeration to your code and create an initialized array of counters for the categories.
4. Add a function to print the array of counters (result)
   e.g. void PrintFileCntPerCategory(int *categoryCounters, int numOfCategories);
5. Add a function that will, based on the given extension, find the category of the file.
   NB! Look at the flying object identification code example for inspiration!
   e.g.  enum FileCategory GetFileCategory(char *extension);

Hints and warnings:

• Check out the additional enum example on this page. It is based on a similar categorization task, it will offer quite a few ideas on code structure.
• You should recognize various subtasks from last semester – i.e. parts of the first and second strings lab task and age classifier home work.
• If you add a count item after the last enumerated item, it will tell you the number of items in the list. This will only work if you allow it to automatically number all items!
  enum FileCategory { CAT_DATA, CAT_DOCUMENTS, CAT_IMAGES, CAT_CODE, CAT_ARCHIVE, CAT_TEXT, CAT_OTHER, CAT_NO_EXT, CAT_COUNT };

  1 2 3 4 5 6 7 8 9 10 11 12

  enum FileCategory {     CAT_DATA,     CAT_DOCUMENTS,     CAT_IMAGES,     CAT_CODE,     CAT_ARCHIVE,     CAT_TEXT,     CAT_OTHER,     CAT_NO_EXT,     CAT_COUNT };

  This allows you to automatically declare the correct length array for counters.

• By using what you learned about pointers last week (i.e. pointer arithmetic),  you can use the location of the point symbol as an offset to calculate the address where the extension starts. That new address would also be pointing at a string.
• The length of the reading loop is of unknown length. fgets()  returns NULL  when EOF  (end of file, indicating no more inputs) is reached.
• fgets()  stores the trailing newline character which needs to be corrected for.
• Input for your program comes from a pipe to your programs stdin
• To quickly test without the command line, you can hit ctrl+d  to send the EOF  signal

Testing manually when creating the program

To test manually, we can run the program normally, type in the names of files, pressing enter after each file name. Once done, hit ctrl+d  to send the EOF (end of file) signal.

Testing correctness

To test the correctness, we will index a folder that I have prepared for you. If you are on the lab computer, you can access it directly over the network. If you are using your own computer, download the archive provided and change the path for find . Your numbers for each category should match the ones presented in this example.

We use a tool called find  to search for files and folders and limit it to only show files and print without the path. First we show the location where we are searching in, then we specify to only show files (omit folders) and we then print the names of files without the path. The output of find (from stdout , standard output stream) will be piped into our programs stdin  (standard input stream).

Command executed: find ~/M/risto.heinsar/lab_cat/ -type f -printf '%f\n' | ./task1_category

Hint: if you’re curious, you can also test your own P drive and add extensions and/or categories.

Lab task 2 [W02-2]: Distance conversion

You have been provided activity data from a group of employees in an international company. The data files are provided after the requirements section. Your task is to convert the data in the files to the desired output units, show the results of the conversion and provide basic statistics.

Requirements

• Program takes two command line arguments
  • First argument is the name of the input file
  • Second argument is the desired output unit of distance (available options: m  for meters, ft  for feet and km  for kilometers)
• Input file is a basic ASCII text file (first command line argument).
  • Each line in the file contains one entry
  • Each entry consist of two fields, separated by a space: <distance> <unit>
  • Distances are given as real numbers
  • Units are given as strings. Units in the input file can only be in feet or meters.
• Calculate and display all distances, converted to the desired output unit
• Calculate and output the average and total distances walked.
• All distances are shown with 2 places after the comma.
• Units must be handled using enums. Recommended list is provided:
  
  enum Unit {UNIT_M, UNIT_FT, UNIT_KM, UNIT_UNKNOWN};

  1	enum Unit {UNIT_M, UNIT_FT, UNIT_KM, UNIT_UNKNOWN};

• Conversion coefficients are also provided
  
  #define FT_IN_M 0.3048f #define FT_IN_MI 5280.00f #define M_IN_KM 1000.00f

  1 2 3

  #define FT_IN_M 0.3048f #define FT_IN_MI 5280.00f #define M_IN_KM 1000.00f

• Look at hints for getting ideas how the functions might look like for more optimum code division.

Data files

There are 3 files provided for you to test your program with. Look under the paragraph Testing for what you should look out for when testing with each of the files!

Download the test files: https://blue.pri.ee/ttu/files/iax0584/andmefailid/2_2_converter_data.zip

Hints and tricks

Hint 1: Conversion function

Remember to not overcomplicate your functions. Your convert function should only handle conversion from one unit type to another. Do not try to decode the string into a unit in that function.  Just pass it the decoded enum types and the value that needs converison.

E.g. some ideas for the prototype of that function

Hint 2: Decoding the unit

To decode both the input and the output units, use the same function – both are strings with just the unit. It should be a function that would return the unit type.

E.g.   enum Unit GetDistanceUnitType(char *unit);

Hint 3: Printing the units

There are a lot of units in play. Printing the correct one can be a bit tricky. There are two ideas to help you with:

Option 1: Create a function to print the unit and call it when you need it. Call it whenever you need to print the correct unit according to the task.

Option 2: Create a function that will return you a pointer to a string containing the unit.  Since it is written as a constant, it will be available in the memory after the function returns. It makes this really convenient to use it in print statements – e.g. printf("%.2f %s\n, distance, ReturnPrintableUnit(unit));

Testing

This program has a lot of ways it can go wrong. Make sure to test for all constraints!

Test 1 – 3: Invalid arguments

This test actually is comprised of 3 different tests, but all of them have wrong arguments passed to the program.

Test 4, 5: Problematic arguments

The next two tests are about parsing the arguments themselves and making sure that both the file exist and the unit is within the allowed list.

Test 6: empty file

The purpose of this test is to make sure that our program does not crash when there is no data to process.

task2_data1.txt contents:

And the results for this data file: 

Test 7 – 9: Conversion tests

In these tests we will go over all of the possible input and output unit conversions. We use a simple data file that allows us to easily observe if our answers are correct.

task2_data2.txt contents:

And the results for this data file:

Test 10: Different file

The emphasis for this test is to test your program with a different data file – just different length and units to make sure that nothing got passed us by.

task2_data3.txt contents:

And the results for this data file:

Sidenote: did you notice what we didn’t test for, but cold also be improtant?

Extra task [W02-3]: comprehensive converter

The extra task is based on lab task 2 and must be an extension of the base task. Disregard the concept of “walking” and consider the task as just a distance converter with statistics.

Requirements

• Add support for additional distance units
  • Yard (yd)
  • Inch (in)
  • Decimeter (dm)
• You must allow all 6 units to be both inputs and outputs for the program.
• Design the conversions in a expandable fashion so that if we would add additional units, it wouldn’t require large overhauls of the code. The complexity of adding another unit must not expand the codebase exponentially!

Warning! Even though the expected  method for conversion is simple to implement and manage, it may increase the error of the final result due to rounding of the conversion coefficients outside of metric system. Be careful with tasks requiring high precision!

After the class, you should

• Have gone over many of the topics covered last semester, including command line arguments, parsing strings, reading from files etc
• Be able to work with enumerations
  • Declaring new enum types
  • Know how the auto-numeration for enums works
  • Declaring variables based on enum types
  • Pass enums to functions, return enums from functions

Additional content

Note: most sites explaining enumerations can’t even follow the same coding style on a single page! Use the style guide provided by us!

• BeeJ’s guide to Enums
  https://beej.us/guide/bgc/html/split/enumerated-types-enum.html#enumerated-types-enum
• Enumeration (or enum) in C
  https://www.geeksforgeeks.org/enumeration-enum-c/
• Enumerations
  https://en.cppreference.com/w/c/language/enum
• C enums
  https://www.programiz.com/c-programming/c-enumeration

Lab content

 

After the class, you should be able to

• Understand what a pointer is
• Declare different types of pointers
• Understand some of the use cases for pointers
• Understand what a NULL pointer is
• Understand the dereference and address operators
• Understand why some variables when reading with scanf() required & and some didn’t
• Find the address of any variable
• Pass addresses of variables to functions (by reference)
• Better understand the difference of passing arguments to functions by value and by reference (originally simplified as copy, original)
• Understand how arrays are actually passed to functions and thus why we can alter them without any extra steps
• Understand pointer arithmetics
• Know what a memory address looks like
• Understand that there are different width memory addresses and why  it is like that

Additional content