The focus of this effort is to provide interesting and particularly-focused challenges that will help the evolving programmer reach into the niches needed for accelerated comprehension and practice, along with information helpful to that end. A few notable things to know about my particular approach:

• All content is intended for a UNIX-like context (UNIX, Linux, BSD, etc…), as I'm not interested in using or working with, let alone teaching or propogating, Microsoft technologies.
• I don't want to reproduce content/effort that is already well-done and freely available on the internet, so I will frequently refer to such other free tutorial content.
• It is expected that exercises will compel a learner to ask questions, so anyone using this tutorial content should do so while having someone they feel comfortable asking about places they might get stuck on.

Here are the locations of existing free tutorial content that I have reviewed, and seen fit to refer to:

• TutorialsPoint C tutorial

The first portion of this exercise is to complete the TutorialsPoint C-Environment Setup tutorial phase (but skip the “Try It Option Online” part).
Once that is complete, proceed with:

• Make sure you have the “Hello world” program from TutorialsPoint in a .c file
• Compile your program (you can use this step if you like)
• Read the man page for the GNU make command
• Write a Makefile to build your program
• Ensure your Makefile also supports a clean target, which removes products of compilation
• Test out all aspects of your Makefile to ensure it operates as expected

Remember to have your work reviewed by, as well as to seek help/advice from, your instructor.

Here is a sample Makefile as a kick-start:

PGM = hello

all : $(PGM)
        @echo Done

clean :
        @rm -f $(PGM) *.o

$(PGM) : hello.c
        gcc -g -o $(PGM) hello.c

Read these sections in the TutorialsPoint tutorial:

• Basic Syntax
• Data Types
• Variables

… then, read the manpage for printf.

Once complete with these readings, write a program that stores integer values in four different integer variables, and prints each out using the printf function, making sure the name of the variable is shown before the value.
Once you have completed that, read this TutorialsPoint section, and then alter your program to do a number of typical arithmetic operations upon your variables, printing out both a label showing the calculation being done and the result for each.

Read these sections in the TutorialsPoint tutorial:

• Decision Making
• Loops

… then, alter your program to start with one number (as one of your variables), and compute the result of n2 - 1 for n up to a higher number (as another of your variables). Make sure that the calculation being performed and the result are printed for each iteration.

When that program is complete, read this TutorialsPoint section, and then move your calculations into a function that takes the beginning and ending for your loop as parameters.

Read this section in the TutorialsPoint tutorial:

• Arrays

… then, refactor your program to use an array of integers for n, and perform the calculation for each of the n in the array.

Once that is complete and working, read this section at TutorialsPoint, and then add a new function that creates a string, fills it with some text, and then iterates over the string to print each character out on a separate line.

Read this section in the TutorialsPoint tutorial, in this order:

• Structures
• Pointers

… then, create a new function that declares a local variable of a structure type, which you will also have to define at the top of your source file. The structure should have an integer and a character array of a length suitable for your name. In your function, fill the name field of the structure in with your name, set the integer to a value, then print out both.

Once that is working, refactor this function to take a pointer to your structure type as a parameter, and print out the integer and name from the structure passed in. Initialize a variable of your structure type to pass into the function from where you call it.

One important aspect of maintaining the simplicity, extensibility, and managability of your code is “modularity”, and there are also various aspects of modularity to pay attention to.

For this exercise, we're going to focus on the arrangement of your code into files, and the respective build mechanics. After reading this TutorialsPoint section on C headers, proceed with:

• Refactor all code written so far into functions
• Merge all “main” functions into one central “main” function, which will be capable of deciding which functions to call for running the various tests
• Make sure that there are multiple .c files, with your functions located in whichever files makes the most sense to you
• Create a header (.h) file with function prototypes for all the functions that will need to be called from the “main” function
• Refactor your Makefile with a two-pass process - include rules for building each .c file into a .o file, and then linking all .o files into the executable.
• Make sure your Makefile is driven by dependencies, so that a .o file is only created when its respective .c file changes, and the executable is likewise only created when one or more of the .o files changes

Read this section of the TutorialsPoint tutorial: Command Line Arguments, then:

• Change your main function to the correct prototype for accepting command-line arguments
• Read in command-line arguments to determine which of your scenarios to run
• Read in command-line arguments for the various values that you pass to your functions
• Have your program print usage instructions if there are no command-line arguments

Links: Tech Info … Mantis Area