This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
haas:spring2015:cprog:projects:cbf0 [2015/03/22 13:26] – [Task] wedge | haas:spring2015:cprog:projects:cbf0 [2015/03/22 15:15] (current) – [Program] wedge | ||
---|---|---|---|
Line 10: | Line 10: | ||
=====Objective===== | =====Objective===== | ||
To practice manipulating binary data in a C program (for fun and glory). | To practice manipulating binary data in a C program (for fun and glory). | ||
- | |||
- | =====Prerequisites/ | ||
- | In addition to the new skills required on previous projects, to successfully accomplish/ | ||
- | |||
- | * can perform this trick in your head/by hand (if you can't do it on your own, you have no business trying to tell the computer how to do it) | ||
- | * understand the pattern/ | ||
- | * digit length will depend upon size of user input variable (including signedness) | ||
- | * ability to deploy loops to simplify your process | ||
- | * ability to use arrays to facilitate the storage of your processed values | ||
- | * use of functions to modularize your code | ||
- | |||
- | =====Scope===== | ||
- | The allure of using (and learning) a programming language is to be able to effectively use it to solve problems, which in and of themselves are simulations of some process we can do in "the real world" | ||
- | |||
- | In this case, we will be writing a program which will implement the mental math techniques for subtracting certain numbers from left to right-- seemingly against the grain from everything we've been taught. | ||
=====Background===== | =====Background===== | ||
Line 70: | Line 55: | ||
If you are successful, the image should render itself in the browser, and you should be able to recognize it (vs. it being unreadable and unrecognizable). The image is intended to be meme-like in original, and hopefully will invoke a mild sense of humor (that of course is optional). | If you are successful, the image should render itself in the browser, and you should be able to recognize it (vs. it being unreadable and unrecognizable). The image is intended to be meme-like in original, and hopefully will invoke a mild sense of humor (that of course is optional). | ||
- | =====Functions===== | ||
- | As indicated, this task shares many attributes with the **mbe1** project; in fact, the mental math process itself may be slightly simpler. That affords us the opportunity to introduce and learn about further programming optimizations, | ||
- | |||
- | Specifically, | ||
- | |||
- | We've been using functions all along (everytime you use **fprintf()** or **fscanf()**, | ||
- | |||
- | ====Function prototype==== | ||
- | Like variables, functions need to be declared. | ||
- | |||
- | We can declare them at various scopes (file/ | ||
- | |||
- | If a particular function is only to be used by a specific function, and no others, you can opt to declare it local scope (ie within the function that will be calling it). | ||
- | |||
- | A function is basically a module or subroutine. It is a mini-program, | ||
- | |||
- | Like a program, it takes input, does processing, and provides output. | ||
- | |||
- | Unlike a program, its input may not come from the keyboard, but instead from particular variables, and may not send output to the screen, but instead channel output in a way that it can be stored into a variable. | ||
- | |||
- | This distinctions aside, a function can in many ways be viewed as a micro- or sub-program/ | ||
- | |||
- | Keeping everything in ONE file, ONE big function in that one file, is rather monolithic. In time, with sufficiently large programs, such an arrangement would become a tad unwieldy. So functions help to keep our focus short yet attentive. | ||
- | |||
- | To create a function we must first declare (or prototype) it. This needs to happen BEFORE said function is ever used (just as with variables- you must declare a variable before it is first used, otherwise the compiler yells). | ||
- | |||
- | A function, in many ways, is like a programmable variable (or is a variable with programming attached). | ||
- | |||
- | As such, it has a return value of a type (the function' | ||
- | |||
- | We see this with main()... here are two variations of a **main()** function declaration (technically also the start of the definition as well, in the case of **main()**): | ||
- | |||
- | ===Parameterless function=== | ||
- | |||
- | <code c> | ||
- | int main() | ||
- | </ | ||
- | |||
- | In this example, we see the declaration of main() where it has a return value of **int**, meaning, upon completion, main() will return a value corresponding with an int data type (also in main()' | ||
- | |||
- | main(), in this case, takes no parameters (just an empty set of parenthesis)... due to this, we refer to this function as a parameterless function. A function without parameters. Without input. | ||
- | |||
- | Now: this is technically a different form of input and output than you are used to. Input doesn' | ||
- | |||
- | Additionally, | ||
- | |||
- | ===Parametered function=== | ||
- | |||
- | <code c> | ||
- | int main(int argc, char **argv) | ||
- | </ | ||
- | |||
- | In this case, our **main()** function actually takes parameters- two, in fact: | ||
- | |||
- | - an integer, we are calling **argc** | ||
- | - a double pointer, we are calling **argv** | ||
- | |||
- | This function takes two parameters, two pieces of input, available to us in the form of variables, by those names, of those types. We make use of them as we need to in accomplishing the program at hand. | ||
- | |||
- | So, when we wish to create functions of our own, we need: | ||
- | |||
- | * the return type | ||
- | * the function name | ||
- | * 0 or more parameters, identifying their order and type | ||
- | |||
- | For example, let us make a sum() function. Here would be a likely prototype (we'd place it above main()): | ||
- | |||
- | < | ||
- | int sum(int *, int); | ||
- | </ | ||
- | |||
- | A function prototype (vs. its definition) will have a terminating semi-colon, as you see above. | ||
- | |||
- | In our case, our sum() function has the following: | ||
- | |||
- | * a return type of **int** (particular variable name doesn' | ||
- | * the function' | ||
- | * a comma-separated list of types corresponding to the parameters (again, variable names do not matter, but the type is important). | ||
- | |||
- | Our sum() function will take an integer array (denoted by the int pointer above), and a size (the second, regular int). | ||
- | |||
- | Now, parameter order very much matters. In our case, an "int *" came first, followed by an " | ||
- | |||
- | ====Function definition==== | ||
- | While a function prototype is technically optional (you can put the definition in place of the prototype-- we just often use prototypes to further allow organization), | ||
- | |||
- | Our sum() function will be defined (below the main() function) as follows: | ||
- | |||
- | <code c> | ||
- | int sum(int *array, int size) | ||
- | { | ||
- | int result = 0; | ||
- | int i = 0; | ||
- | | ||
- | for (i = 0; i < size; i++) | ||
- | result = result + array[i]; | ||
- | | ||
- | return(result); | ||
- | } | ||
- | </ | ||
- | |||
- | ====function calling==== | ||
- | Once we've declared (prototyped) and defined our function, now all we have to do is use it! When you make use of a function, we refer to it as // | ||
- | |||
- | Here would be an example of calling the above-mentioned **sum()** function: | ||
- | |||
- | <code c> | ||
- | int scores[4]; | ||
- | int tally = 0; | ||
- | |||
- | scores[0] = 88; | ||
- | scores[1] = 47; | ||
- | scores[2] = 96; | ||
- | scores[3] = 73; | ||
- | |||
- | tally = sum(scores, 4); | ||
- | </ | ||
- | |||
- | Note, that it is rather important to match the type and order of parameters. Due to the nature of the array (especially the form of array declaration) used, certain pointer-related details are being hidden from us, giving somewhat of a false impression. Further discussion about pointers will begin to shed light on that. | ||
- | |||
- | |||
- | =====Program===== | ||
- | It is your task to write a program that obtains a long integer value from the user, and processes that single value into separate array elements (one digit per array element). Determining the number of digits, you are to perform this "all from nine, last from ten" subtraction method on the number using array transactions, | ||
- | |||
- | Your program should: | ||
- | * obtain its input from STDIN. | ||
- | * input should be in the form of a single (long) long integer value (you want a 64-bit data type) | ||
- | * determine the number of digits of the inputted value (store this in a variable) | ||
- | * process that input long integer into separate array elements- one digit per element. | ||
- | * you may assume a maximum array size of the maximum number of digits you're theoretically able to input that can be stored in a 64-bit value. | ||
- | * perform the "all from nine, the last from ten" operation on the array, storing the result in another array. | ||
- | * display the problem being solved, along with the answer | ||
- | * use functions to modularize your code: | ||
- | * have an **longint2array()** function that takes the long int, and returns an array (the function itself handles the processing of splitting up the long int into individual digits). | ||
- | * have a **printarray()** function, whose responsibility it is to display the indicated array to STDOUT. | ||
- | * have a **allfromnine()** function that takes the source array, does the processing, and returns ther result array. | ||
- | |||
- | I might suggest the following function prototypes: | ||
- | |||
- | <code c> | ||
- | unsigned char *longint2array(unsigned long int); | ||
- | void printarray(unsigned char *, unsigned char); | ||
- | unsigned char *allfromnine(unsigned char *); | ||
- | </ | ||
- | |||
- | Some questions to contemplate: | ||
- | |||
- | * Why an array of unsigned chars when we're starting with a long (long) int? | ||
- | * Why is that the "best fit" size-wise? | ||
- | * Why will that not result in lost data? | ||
- | * Why unsigned? | ||
- | * What impact will that have on our input value' | ||
- | * Why represent the size of the usable array as an unsigned char? | ||
- | * Why is this the "best fit" size-wise? | ||
- | =====Execution===== | ||
- | An example of your program in action: | ||
- | |||
- | <cli> | ||
- | lab46: | ||
- | Enter value: 31415926535897 | ||
- | Digits detected: 14 | ||
- | |||
- | | ||
- | - 31415926535897 | ||
- | | ||
- | 68584073464102 | ||
- | lab46: | ||
- | </ | ||
=====Submission===== | =====Submission===== | ||
Line 244: | Line 61: | ||
* Code must compile cleanly (no warnings or errors) | * Code must compile cleanly (no warnings or errors) | ||
- | * Output | + | * Final image must be viewable. |
* Code must be nicely and consistently indented (you may use the **indent** tool) | * Code must be nicely and consistently indented (you may use the **indent** tool) | ||
- | * Code must utilize the algorithm | + | * Code must utilize the specifications |
* Code must be commented | * Code must be commented | ||
* have a properly filled-out comment banner at the top | * have a properly filled-out comment banner at the top | ||
Line 252: | Line 69: | ||
* Track/ | * Track/ | ||
* Submit a copy of your source code to me using the **submit** tool. | * Submit a copy of your source code to me using the **submit** tool. | ||
+ | * You are to submit 3 files: | ||
+ | * your C source code to accomplish this task | ||
+ | * your copy of out.file | ||
+ | * your processed cbf0.jpg file | ||
To submit this program to me using the **submit** tool, run the following command at your lab46 prompt: | To submit this program to me using the **submit** tool, run the following command at your lab46 prompt: | ||
<cli> | <cli> | ||
- | $ submit cprog afn0 afn0.c | + | $ submit cprog cbf0 cbf0.c out.file / |
- | Submitting cprog project "afn0": | + | Submitting cprog project "cbf0": |
- | -> afn0.c(OK) | + | -> cbf0.c(OK) |
+ | -> out.file(OK) | ||
+ | -> / | ||
SUCCESSFULLY SUBMITTED | SUCCESSFULLY SUBMITTED |