CS 270 Summer Semester 2019

Recitation R2: More coding in C

Write a C program in a file called R2.c, using the example shown in the Program Structure section below. This program will compute the areas of some geometrical figures based on some command-line arguments. You must declare two global arrays, then write two functions and the main function, which is the entry point for C programs. Do exactly as described in the directions below:

• Create a directory for writing programs, we suggest calling it ~/cs270. 
• Create a subdirectory for the R2 recitation, we suggest calling it ~/cs270/R2. 
• Create a file called R2.c in the R2 subdirectory, and copy the code shown in the Program Structure section below. 
• Personalize the comment block by changing the author and email. 
• Declare a global array of 3 doubles called input. This array will eventually contain the 3 command-line arguments passed in the terminal. 
• Declare a global array of 2 doubles called output. This array will eventually contain the 2 areas computed in the program. 
• In the main entry point, make sure the user provides 3 command-line arguments after the program name. 
• If not, print the following message and return EXIT_FAILURE from main (note that there is a newline character at the end of this message).         usage: ./R2 double double double
  
• If 3 arguments were provided, convert arguments argv[1] to argv[3] from strings to doubles, using the atof function. The first argument is the diameter of a circle. The second and third arguments are the sides of a rectangle. Store the arguments in the input array in this same order (starting at input[0]). 
• Don't worry about argv[0], which always contains the program name. 
• Next write two functions above the main method:
• The first function is computeCircle, which computes the area of a circle given the diameter. It is a void function that takes two parameters: the diameter as a double and a pointer to an output value as a double *. It computes the area of the circle using the following formula:
  
  area = 3.141593 * diameter * diameter / 4
  
  It returns the area through the pointer passed as an argument.
  
  
• The second function is computeRectangle, which computes the area of a rectangle given the two sides. It is a void function that takes three parameters: the first side as a double, the second side as a double, and a pointer to an output value as a double *. It computes the area of the rectangle using the following formula:
  
  area = side1 * side2
  
  It returns the area through the pointer passed as an argument.
  
  
• Next, finish the main function as follows: 
• Call computeCircle with input[0] and the address of output[0]. 
• Call computeRectangle with input[1], input[2], and the address of output[1]. 
• Finally print the results of all computations in the format shown in the Sample Output section. 

Program Structure

The following code can be used as a starting point. Note that the given function computeSphere does not match any of the functions asked for above. It is intended as an example of how to return a value through a pointer. Your TA will explain what pointers are and how they are used in this example. If you want to do well in this class, you will need to become comfortable with pointers. 




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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// R2 Recitation // Author: Chris Wilcox // Date:   08/29/2018 // Class:  CS270 // Email:  wilcox@cs.colostate.edu // Include files #include <stdbool.h> #include <stdio.h> #include <stdlib.h> void computeSphere(double radius, double *addressOfVolume) {     // Compute volume     double result = (4.0 / 3.0) * (3.141593 * radius * radius * radius);     // Dereference pointer to return result     *addressOfVolume = result; } int main(int argc, char *argv[]) {     // Check number of arguments     if (argc != 2) {         printf("usage: ./R2 double\n");         return EXIT_FAILURE;     }     // Parse arguments     double radius = atof(argv[1]);          // Local variable     double volume;     // Call function     computeSphere(radius, &volume);          // Print volume     printf("The volume of a sphere with radius %.5f equals %.5f.\n", radius, volume);     // Return success     return EXIT_SUCCESS; }

Sample output

Your program should print four lines. The sample output below shows how to compile, link, and run the R2 program on Linux using the gcc compiler.

gcc -g -Wall -c R2.c

gcc -g -Wall R2.o -o R2




./R2 1.0 3.0 4.0

CIRCLE, diameter = 1.00000, area = 0.78540.

RECTANGLE, side1 = 3.00000, side2 = 4.00000, area = 12.00000.

Note that there is a newline character after the last line of output. 




GDB (GNU DeBugger)
Although it might not be very useful for this program, now would be a good time to familiarize yourself with the GDB debugger for C programs. GDB is a command line debugger with features similar to Eclipse's debugger for Java. Alternatively, you can use DDD (data display debugger) for a version of GDB with a GUI. In order to use GDB/DDD, you must compile your program with the -g flag. To open GDB or DDD, use one of the following instructions:

gdb ./a.out
ddd ./a.out

Replace a.out with the name of your executable file. Make sure that the last line in the terminal says "Reading symbols from ./a.out...done." If this doesn't show up, you need to recompile with the -g flag and try again.
You can use the break command to set breakpoints now. For example:

break function_name // Sets a breakpoint at the beginning of a function
break file.c:42 // Sets a breakpoint at line 42 in file.c


After placing any desired breakpoints, use run to start your program. run can be used just like the executable in the shell, and can take parameters in the same way. For example:

$ ./a.out param1 < inputFile.txt // In the shell
$ run param1 < inputFile.txt // In GDB

Your program will now stop at any breakpoint it hits, and you can use 'next' (the same as Eclipse's step over) and 'step' (Eclipse's step into) to navigate your program. In addition, you can use the 'print' command to view the value of an expression. Here are some interesting ways to use it:

print varName // Print the value of varName
print charPtr // Print the address the pointer points to, and the string at that address
print arr[2] // Print the value at index 2 of the array
print &someVar // Print the address of someVar
print intVar + 2 // Print 2 more than the value of intVar
print *(ptrVar + 2) // The same as arr[2]

Once finished, you can use 'quit' to exit GDB. It might complain that you have a program running- just use Y to kill the program and exit GDB.




© 2018 CS270 Colorado State University. All Rights Reserved.