{"id":8887,"date":"2016-06-08T18:09:26","date_gmt":"2016-06-08T17:09:26","guid":{"rendered":"http:\/\/probook\/DebianAdmin\/?p=3083"},"modified":"2016-06-08T18:09:26","modified_gmt":"2016-06-08T17:09:26","slug":"chapter-7-notes-practical-c-programming-3rd-edition-by-steve-oualline-2","status":"publish","type":"post","link":"https:\/\/stevepedwards.today\/DebianAdmin\/chapter-7-notes-practical-c-programming-3rd-edition-by-steve-oualline-2\/","title":{"rendered":"Chapter 7 Notes \u2013 Practical C Programming, 3rd Edition By Steve Oualline"},"content":{"rendered":"
<\/div>\n

<\/path><\/svg><\/i> \"Loading\"<\/p>\n

<\/div>\n

Chapter 7 takes you through all the necessary steps to create a simple program\u00a0from specification through release. Structured programming, fast prototyping, and\u00a0debugging are also discussed.<\/strong><\/span><\/p>\n

It's just a simple matter of programming.<\/i><\/span><\/p>\n

\u2014Any boss who has never written a program<\/i><\/span><\/p>\n

The major steps in making a program are:<\/b><\/i><\/p>\n

\u2022Requirements. Programs start when someone gets an idea and starts to implement it. The requirement document describes, in very general terms, what is wanted.<\/b><\/i><\/p>\n

\u2022Program specification. The specification is a description of what the program does. In the beginning, a preliminary specification is used to describe what the program is going to do. Later, as the program becomes more refined, so does the specification. Finally, when the program is finished, the specification serves as a complete description of what the program does.<\/b><\/i><\/p>\n

\u2022Code design. The programmer does an overall design of the program. The design should include major algorithms, module definitions, file formats, and data structures.<\/b><\/i><\/p>\n

\u2022Coding. The next step is writing the program. This step involves first writing\u00a0<\/b><\/i>a prototype and then filling it in to create the full program.<\/b><\/i><\/p>\n

\u2022Testing. The programmer should design a test plan and then use it to test his program. When possible, the programmer should have someone else test the program.<\/b><\/i><\/p>\n

\u2022Debugging. Unfortunately, very few programs work the first time. They must be corrected and tested again.<\/b><\/i><\/p>\n

\u2022Release. The program is packaged, documented, and sent out into the world to be used.<\/b><\/i><\/p>\n

\u2022Maintenance. Programs are never perfect. Bugs will be found and will need\u00a0<\/b><\/i>correction. This step is the maintenance phase of programming.<\/b><\/i><\/p>\n

\u2022Revision and updating. After a program has been working for a while, the\u00a0<\/b><\/i>users will want changes, such as more features or more intelligent algorithms. At this point, a new specification is created and the process starts again.<\/b><\/i><\/p>\n

For this chapter, we assume that we have the requirement to \"write a program that acts like a four-function calculator.\"<\/p>\n

We implement the smallest portion of the specification that will still do something. In our case, we will cut our four functions down to a one-function calculator. After we get this small part working, we can build the rest of the functions onto this stable foundation.<\/p>\n

calc1.c<\/p>\n

#include <stdio.h><\/span><\/p>\n

char line[100];\/* line of data from the input *\/<\/span><\/p>\n

int result;<\/span><\/p>\n

char operator; \/* operator the user specified *\/<\/span><\/p>\n

int value;<\/span><\/p>\n

\/* the result of the calculations *\/<\/span><\/p>\n

\/* value specified after the operator *\/<\/span><\/p>\n

int main()<\/span><\/p>\n

{<\/span><\/p>\n

result = 0; \/* initialize the result *\/<\/span><\/p>\n

\/* Loop forever (or till we hit the break statement) *\/<\/span><\/p>\n

while (1) <\/span><\/p>\n

{<\/span><\/p>\n

printf(\"Result: %d\\n\", result);<\/span><\/p>\n

printf(\"Enter operator and number: \");<\/span><\/p>\n

fgets(line, sizeof(line), stdin);<\/span><\/p>\n

sscanf(line, \"%c %d\", &operator, &value);<\/span><\/p>\n

if (operator = '+') \/*mistake here! Should be == remember? If not, then next else does not happen *\/ <\/span><\/p>\n

{<\/span><\/p>\n

result += value;<\/span><\/p>\n

} <\/span><\/p>\n

else <\/span><\/p>\n

{<\/span><\/p>\n

printf(\"Unknown operator %c\\n\", operator);<\/span><\/p>\n

}<\/span><\/p>\n

}<\/span><\/p>\n

}<\/span><\/p>\n

So far, we only recognize the plus ( +) operator. As soon as this operator works correctly, we will add more operators by adding more if statements.<\/span><\/p>\n

Finally, if an illegal operator is entered, the line:<\/span><\/p>\n

} else {<\/span><\/p>\n

printf(\"Unknown operator %c\\n\", operator);<\/span><\/p>\n

}<\/span><\/p>\n

writes an error message telling the user that he made a mistake. <\/span><\/p>\n

So far this prog treats any other operator as a + only, and does not printf(\"Unknown operator %c\\n\", operator);<\/span><\/span><\/p>\n

$ .\/calc <\/span><\/p>\n

Result: 0<\/span><\/p>\n

Enter operator and number: +1<\/span><\/p>\n

Result: 1<\/span><\/p>\n

Enter operator and number: +2<\/span><\/p>\n

Result: 3<\/span><\/p>\n

Enter operator and number: x<\/span><\/p>\n

Result: 5<\/span><\/p>\n

Enter operator and number: x5<\/span><\/p>\n

Result: 10<\/span><\/p>\n

Enter operator and number: \/5<\/span><\/p>\n

Result: 15<\/span><\/p>\n

Enter operator and number: q<\/span><\/p>\n

Result: 20<\/span><\/p>\n

Enter operator and number: ^C<\/span><\/p>\n

This is fixed with the == added, but should not be done yet so the insight to the Makefile section debugs it for you...but so you know what the prob is here...:<\/span><\/p>\n

$ .\/calc <\/span><\/p>\n

Result: 0<\/span><\/p>\n

Enter operator and number: +1<\/span><\/p>\n

Result: 1<\/span><\/p>\n

Enter operator and number: +1<\/span><\/p>\n

Result: 2<\/span><\/p>\n

Enter operator and number: x3<\/b><\/span><\/p>\n

Unknown operator x<\/b><\/span><\/p>\n

Interesting insight into a Makefile's structure:<\/b><\/span><\/p>\n

The make utility is responsible for one of the nastiest surprises for unsuspecting users. The line:<\/i><\/span><\/p>\n

$(CC) $(CFLAGS) -o calc1 calc1.c<\/i><\/span><\/p>\n

must begin with a tab. Eight spaces won't work. A space and a tab won't work. The line must start with a tab. Check your editor and make sure that you can tell the difference between a tab and bunch of spaces.<\/i><\/span><\/p>\n

https:\/\/www.gnu.org\/software\/make\/manual\/make.html<\/a><\/i><\/span><\/p>\n

Note this copies incorrectly from the PDF due to formatting:<\/b><\/span><\/p>\n

File: calc1\/makefile.gcc<\/i><\/span><\/p>\n

#-----#<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

Makefile for UNIX systems<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

using a GNU C compiler<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

#-----#<\/i><\/span><\/p>\n

CC=gcc<\/i><\/span><\/p>\n

CFLAGS=-g -D__USE_FIXED_PROTOTYPES__ -ansi<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

# Compiler flags:<\/i><\/span><\/p>\n

# -g<\/i><\/span><\/p>\n

-- Enable debugging<\/i><\/span><\/p>\n

# -Wall<\/i><\/span><\/p>\n

-- Turn on all warnings (not used since it gives away<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

the bug in this program)<\/i><\/span><\/p>\n

-D__USE_FIXED_PROTOTYPES__<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

#<\/i><\/span><\/p>\n

-- Force the compiler to use the correct headers<\/i><\/span><\/p>\n

-ansi<\/i><\/span><\/p>\n

-- Don't use GNU extensions.<\/i><\/span><\/p>\n

Stick to ANSI C.<\/i><\/span><\/p>\n

calc1: calc1.c<\/i><\/span><\/p>\n

$(CC) $(CFLAGS) -o calc1 calc1.c<\/i><\/span><\/p>\n

clean:<\/i><\/span><\/p>\n

rm -f calc1<\/i><\/span><\/p>\n

Should look like this in vi??:<\/span><\/p>\n

\"\"<\/p>\n

To run the makefile understand make<\/b><\/i> a bit first: <\/span><\/p>\n

man make<\/span><\/p>\n

To prepare to use make, you must write a file called the makefile that describes the rela?<\/span><\/p>\n

tionships among files in your program, and the states the commands for updating each file.<\/span><\/p>\n

In a program, typically the executable file is updated from object files, which are in turn<\/span><\/p>\n

made by compiling source files.<\/span><\/p>\n

Once a suitable makefile exists, each time you change some source files, this simple shell<\/span><\/p>\n

command:<\/span><\/p>\n

make<\/span><\/p>\n

-f file, --file=file, --makefile=FILE<\/span><\/p>\n

Use file as a makefile.<\/span><\/p>\n

-d Print debugging information in addition to normal processing.<\/b><\/span><\/p>\n

stevee@AMDA8 ~\/Cprogs\/calc1 $ ls<\/span><\/p>\n

calc.c makefile<\/span><\/p>\n

Seems to have a problem..:<\/span><\/b><\/span><\/p>\n

$ make<\/span><\/p>\n

make: *** No rule to make target `calc1\/makefile', needed by `calc1'. Stop.<\/span><\/p>\n

Have to come back to that...<\/span><\/p>\n

Most systems have C debugging programs; however, each system is different.<\/span><\/p>\n

Some systems have no debugger. In such a case, we must resort to a diagnostic print statement. The technique is simple: put a printf at the points at which you know the data is good (just to make sure the data is really good). Then put a printf at points at which the data is bad. Run the program and keep putting in printf statements until you isolate the area in the program that contains the mistake.<\/span><\/p>\n

It's good to re-arrange the brackets to suit your clarity preference then comment each function so you write it in your own way you understand what each is doing, as I tried below:<\/i><\/span><\/p>\n

\/**calc2.c*\/<\/span><\/p>\n

#include <stdio.h><\/span><\/p>\n

char line[100]; \/* line of text from input *\/<\/span><\/p>\n

int result; \/* the result of the calculations *\/<\/span><\/p>\n

char operator; \/* operator the user specified *\/<\/span><\/p>\n

int value; \/* value specified after the operator *\/<\/span><\/p>\n

int main()<\/span><\/p>\n

{<\/span><\/p>\n

result = 0; \/* initialize the result *\/<\/span><\/p>\n

\/* loop forever (or until break reached) *\/<\/span><\/p>\n

while (1) <\/span><\/p>\n

{<\/span><\/p>\n

printf(\"Result: %d\\n\", result); \/*result matches int decl.*\/<\/span><\/p>\n

printf(\"Enter operator and number: \");<\/span><\/p>\n

fgets(line, sizeof(line), stdin); \/*puts chars in line array; counts chars; from keys*\/<\/span><\/p>\n

sscanf(line, \"%c %d\", &operator, &value); \/*op and value matches char and int decl.*\/<\/span><\/p>\n

if ((operator == 'q') || (operator == 'Q')) \/*for caps lock on: either Qq input*\/<\/span><\/p>\n

break;<\/span><\/p>\n

if (operator == '+') <\/span><\/p>\n

{<\/span><\/p>\n

result += value;<\/span><\/p>\n

} <\/span><\/p>\n

else if (operator == '-') <\/span><\/p>\n

{<\/span><\/p>\n

result -= value;<\/span><\/p>\n

} <\/span><\/p>\n

else if (operator == '*') <\/span><\/p>\n

{ <\/span><\/p>\n

result *= value;<\/span><\/p>\n

} <\/span><\/p>\n

else if (operator == '\/') <\/span><\/p>\n

{<\/span><\/p>\n

if (value == 0) \/*final nested if else for div by 0 BEFORE op \/: Why not have another elsif for a 0 input at end of all these ???*\/ <\/span><\/p>\n

{<\/span><\/p>\n

printf(\"Error:Divide by zero\\n\");<\/span><\/p>\n

printf(\"operation ignored\\n\");<\/span><\/p>\n

} <\/span><\/p>\n

else<\/span><\/p>\n

result \/= value;<\/span><\/p>\n

} <\/span><\/p>\n

else <\/span><\/p>\n

{<\/span><\/p>\n

printf(\"Unknown operator %c\\n\", operator);<\/span><\/p>\n

}<\/span><\/p>\n

}<\/span><\/p>\n

return (0);<\/span><\/p>\n

}<\/span><\/p>\n

It looks much nicer zoomed out in VIM to fit all, with a yellow BG:<\/span><\/p>\n

\"\"<\/p>\n

We expand our test plan to include the new operators and try it again:<\/span><\/p>\n

+ 123 Result should be 123<\/span><\/p>\n

+ 52<\/span><\/p>\n

x 37 Result should be 175<\/span><\/p>\n

Error message should be output<\/span><\/p>\n

- 175 Result should be zero<\/span><\/p>\n

+ 10 Result should be 10<\/span><\/p>\n

\/ 5 Result should be 2<\/span><\/p>\n

\/ 0 Divide by zero error<\/span><\/p>\n

* 8 Result should be 16<\/span><\/p>\n

q Program should exit<\/span><\/p>\n

While testing the prog ram, we find that, much to our surprise, the program works.<\/span><\/p>\n

The word \"Preliminary\" is removed from the specification, and the program, test<\/span><\/p>\n

plan, and specification are released.<\/span><\/p>\n

This programme works to the test plan for all the functions designed for: (0+-*\/qQ and ignoring non integers). Now there is the stable base for adding functionality.<\/b><\/i><\/span><\/p>\n

$ .\/calc2<\/b><\/span><\/p>\n

Result: 0<\/span><\/p>\n

Enter operator and number: +2<\/span><\/p>\n

Result: 2<\/span><\/p>\n

Enter operator and number: -1<\/span><\/p>\n

Result: 1<\/span><\/p>\n

Enter operator and number: *3<\/span><\/p>\n

Result: 3<\/span><\/p>\n

Enter operator and number: \/1.5 \/*missed out from PDF test plan\u2026 *\/<\/b><\/span><\/p>\n

Result: 3<\/span><\/p>\n

Enter operator and number: \/3<\/span><\/p>\n

Result: 1<\/span><\/p>\n

Enter operator and number: \/0<\/span><\/p>\n

Error:Divide by zero<\/span><\/p>\n

operation ignored<\/span><\/p>\n

Result: 1<\/span><\/p>\n

Enter operator and number: *10<\/span><\/p>\n

Result: 10<\/span><\/p>\n

Enter operator and number: \/2<\/span><\/p>\n

Result: 5<\/span><\/p>\n

Enter operator and number: -3<\/span><\/p>\n

Result: 2<\/span><\/p>\n

Enter operator and number: Q<\/span><\/p>\n

Electronic archaeology is the art of digging through old code to discover amazing things (like how and why the code works).<\/span><\/p>\n

Unfortunately, most programmers don't start a project at the design step. Instead, they are immediately thrust into the maintenance or revision stage and must face the worst possible job: understanding and modifying someone else's code.<\/span><\/p>\n

Your computer can aid greatly in your search to discover the true meaning of someone else's code. Many tools are available for examining and formatting code. <\/span><\/p>\n

Some of these tools include: ...are pretty obsolete for this PDF!<\/span><\/p>\n

Text Editor: One of the best tools for going through someone else's code is your text editor.<\/span><\/p>\n

Suppose you want to find out what the variable sc is used for. Use the search command to find the first place sc is used...you can easily do a global search and replace to change sc to\u00a0<\/span>sequence_counter. (Disaster warning: Before you make the change, make sure\u00a0<\/span>that sequence_counter is not already defined as a variable or part of another declaration!!<\/span><\/p>\n

Take a printout of the program and make notes all over it. Use red or blue ink so that you can tell the difference between the printout and the notes. Use a highlighter to emphasize important sections. These notes are useful; put them in the program as comments, then make a new printout and start the process again.<\/span><\/p>\n

Exercise 7-1 : Write a program to convert English units to metric (i.e., miles to\u00a0<\/b><\/span>kilometers, gallons to liters, etc.). Include a specification and a code design.<\/b><\/span><\/p>\n

Exercise 7-2: Write a program to perform date arithmetic such as how many days\u00a0<\/b><\/span>there are between 6\/6\/90 and 4\/3\/92. Include a specification and a code design.<\/b><\/span><\/p>\n

Exercise 7-3 : A serial transmission line can transmit 960 characters each second.<\/b><\/span><\/p>\n

Write a program that will calculate the time required to send a file, given the file's\u00a0<\/b><\/span>size. Try the program on a 400MB (419,430,400 -byte: 400 x 1024 x 1024b) file. Use appropriate units.<\/b><\/span><\/p>\n

Exercise 7 -4 : Write a program to add an 8% sales tax to a given amount and round\u00a0<\/b><\/span>the result to the nearest penny.<\/b><\/span><\/p>\n

Exercise 7-5 : Write a program to tell if a number is prime.<\/b><\/span><\/p>\n

Exercise 7-6 : Write a program that takes a series of numbers and counts the\u00a0<\/b><\/span>number of positive and negative values.<\/b><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

<\/div>\n

<\/path><\/svg><\/i> \"Loading\"<\/p>\n

<\/div>\n

Chapter 7 takes you through all the necessary steps to create a simple program\u00a0from specification through release. Structured programming, fast prototyping, and\u00a0debugging are also discussed. It's just a simple matter of programming. \u2014Any boss who has never written a program The major steps in making a program are: \u2022Requirements. Programs start when someone gets an ...\u00a0 Chapter 7 Notes \u2013 Practical C Programming, 3rd Edition By Steve Oualline<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-8887","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"a3_pvc":{"activated":true,"total_views":1,"today_views":0},"_links":{"self":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/8887","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/comments?post=8887"}],"version-history":[{"count":0,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/8887\/revisions"}],"wp:attachment":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/media?parent=8887"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/categories?post=8887"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/tags?post=8887"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}