{"id":3212,"date":"2016-06-25T13:00:06","date_gmt":"2016-06-25T12:00:06","guid":{"rendered":"https:\/\/stevepedwards.today\/DebianAdmin\/?p=3212"},"modified":"2016-06-25T13:00:06","modified_gmt":"2016-06-25T12:00:06","slug":"chapter-9","status":"publish","type":"post","link":"https:\/\/stevepedwards.today\/DebianAdmin\/chapter-9\/","title":{"rendered":"Chapter 9 Notes Practical C Programming, 3rd Edition By Steve Oualline"},"content":{"rendered":"
<\/div>\n

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

<\/div>\n

Chapter 9 introduces local variables, functions, and parameters.<\/strong><\/p>\n

A big vim tip here for prog editing\/writing:<\/p>\n

Lesson 4.3: MATCHING PARENTHESES SEARCH<\/em><\/span>
\n ** Type % to find a matching ),], or } . **<\/em><\/span><\/p>\n

1. Place the cursor on any (, [, or { in the line below marked --->.<\/em><\/span><\/p>\n

2. Now type the % character.<\/em><\/span><\/p>\n

3. The cursor will move to the matching parenthesis or bracket.<\/em><\/span><\/p>\n

4. Type % to move the cursor to the other matching bracket.<\/em><\/span><\/p>\n

5. Move the cursor to another (,),[,],{ or } and see what % does.<\/em><\/span><\/p>\n

---> This ( is a test line with ('s, ['s ] and {'s } in it. ))<\/em><\/span>
\nNOTE: This is very useful in debugging a program with unmatched parentheses!<\/em><\/span><\/p>\n

2. Press G to move you to the bottom of the file.
\nType gg to move you to the start of the file.<\/em><\/span><\/p>\n

All variables have two attributes: scope and class. The scope of a variable is the area of the program in which the variable is valid. A global variable is valid everywhere (hence the name global), so its scope is the whole program. A local variable has a scope that is limited to the block in which it is declared and cannot be accessed outside that block.<\/p>\n

<\/p>\n

You can declare a local variable with the same name as a global variable. Normally, the scope of the variable count (first declaration) would be the whole program. The declaration of a second local count takes precedence over the global declaration inside the small block in which the local count is declared.<\/p>\n

<\/p>\n

The variable count is declared as both a local variable and a global variable.<\/p>\n

Normally, the scope of count (global) is the entire program; however, when a\u00a0variable is declared inside a block, that instance of the variable becomes the active\u00a0one for the length of the block. The global count has been hidden by the local count\u00a0for the scope of this block. The shaded block in the figure shows where the scope of\u00a0count (global) is hidden.<\/p>\n

A problem exists in that when you have the statement:<\/p>\n

count = 1;<\/p>\n

you cannot tell easily to which count you are referring. Is it the global count, the one\u00a0declared at the top of main, or the one in the middle of the while loop? You should\u00a0give these variables different names, like total_count , current_count , and\u00a0item_count.<\/p>\n

The class of a variable may be either permanent or temporary. Global variables are\u00a0always permanent. They are created and initialized before the program starts and\u00a0remain until it terminates. Temporary variables are allocated from a section of\u00a0memory called the stack at the beginning of the block. If you try to allocate too\u00a0many temporary variables, you will get a \"Stack overflow\" error. The space used by\u00a0the temporary variables is returned to the stack at the end of the block. Each time\u00a0the block is entered, the temporary variables are initialized.<\/p>\n

The size of the stack depends on the system and compiler you are using. On many\u00a0UNIX systems, the program is automatically allocated the largest possible stack.<\/p>\n

Local variables are temporary unless they are declared static.<\/p>\n

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

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

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

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

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

\/* loop counter *\/<\/span><\/p>\n

for (counter = 0; counter < 3; ++counter)<\/span><\/p>\n

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

int temporary = 1; \/* A temporary variable *\/<\/span><\/p>\n

static int permanent = 1; \/* A permanent variable *\/<\/span><\/p>\n

printf(\"Temporary %d Permanent %d\\n\",<\/span><\/p>\n

temporary, permanent);<\/span><\/p>\n

++temporary;<\/span><\/p>\n

++permanent;<\/span><\/p>\n

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

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

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

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

Temporary 1 Permanent 1<\/span><\/p>\n

Temporary 1 Permanent 2<\/span><\/p>\n

Temporary 1 Permanent 3<\/span><\/p>\n

<\/p>\n

Functions allow us to group commonly used code into a compact unit that can be<\/b><\/i><\/span><\/p>\n

used repeatedly. We have already encountered one function, main. It is a special<\/b><\/i><\/span><\/p>\n

function called at the beginning of the program. All other functions are directly or<\/b><\/i><\/span><\/p>\n

indirectly called from main.<\/b><\/i><\/span><\/p>\n

Suppose we want to write a program to compute the area of three triangles. <\/span><\/p>\n

We could write out the formula three times, or we could create a function to do the work. <\/span><\/p>\n

(Content summary:<\/span><\/p>\n

printf(\"Triangle #1 %f\\n\", triangle(1.3, 8.3));<\/span><\/p>\n

printf(\"Triangle #2 %f\\n\", triangle(4.8, 9.8));<\/span><\/p>\n

printf(\"Triangle #3 %f\\n\", triangle(1.2, 2.0));<\/span><\/p>\n

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

)<\/span><\/p>\n

Each function should begin with a comment block containing the following:<\/span><\/p>\n

Name Name of the function<\/span><\/em><\/strong><\/p>\n

Description Description of what the function does<\/span><\/em><\/strong><\/p>\n

Parameters Description of each of the parameters to the function<\/span><\/em><\/strong><\/p>\n

Returns Description of the return value of the function<\/span><\/em><\/strong><\/p>\n

Our function to compute the area of a triangle begins with:<\/span><\/p>\n

\/*************<\/span><\/p>\n

* triangle -- Computes area of a triangle.<\/span><\/p>\n

*<\/span><\/p>\n

* Parameters<\/span><\/p>\n

*<\/span><\/p>\n

* width -- Width of the triangle. *<\/span><\/p>\n

* height -- Height of the triangle. *<\/span><\/p>\n

*<\/span><\/p>\n

* Returns<\/span><\/p>\n

*<\/span><\/p>\n

area of the triangle.<\/span><\/p>\n

*<\/span><\/p>\n

*************\/<\/span><\/p>\n

\/*tri-sub.c*\/<\/span><\/p>\n

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

\/************<\/span><\/p>\n

* triangle -- Computes area of a triangle. *<\/span><\/p>\n

*<\/span><\/p>\n

*<\/span><\/p>\n

* Parameters<\/span><\/p>\n

*<\/span><\/p>\n

* width -- Width of the triangle. *<\/span><\/p>\n

* height -- Height of the triangle. *<\/span><\/p>\n

*<\/span><\/p>\n

*<\/span><\/p>\n

* Returns<\/span><\/p>\n

*<\/span><\/p>\n

*<\/span><\/p>\n

area of the triangle.<\/span><\/p>\n

*<\/span><\/p>\n

************\/<\/span><\/p>\n

float triangle(float width, float height)<\/span><\/p>\n

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

float area;<\/span><\/p>\n

\/* Area of the triangle *\/<\/span><\/p>\n

area = width * height \/ 2.0;<\/span><\/p>\n

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

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

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

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

printf(\"Triangle #1 %f\\n\", triangle(1.3, 8.3));<\/span><\/p>\n

printf(\"Triangle #2 %f\\n\", triangle(4.8, 9.8));<\/span><\/p>\n

printf(\"Triangle #3 %f\\n\", triangle(1.2, 2.0));<\/span><\/p>\n

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

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

Declaring a prototype for a function without parameters is a little tricky. You can't<\/span><\/p>\n

use the statement:<\/span><\/p>\n

int next_index();<\/span><\/p>\n

because the C compiler will see the empty parentheses and assume that this is a<\/span><\/p>\n

Kernighan & Richie-style function declaration. The keyword void is used to indicate an empty parameter list. So the prototype for our next_index function is:<\/span><\/p>\n

int next_index(void);<\/span><\/p>\n

void is also used to indicate that a function does not return a value.<\/span><\/p>\n

Question 9-1 : Example 9 -4 should compute the length of a string. [3] Instead, it\u00a0<\/span>insists that all strings are of length 0. Why?<\/span><\/strong><\/p>\n

\/*Example 9-4. len\/len.c*\/<\/span><\/p>\n

\/********<\/span><\/p>\n

* Question:<\/span><\/p>\n

* Why does this program always report the length<\/span><\/p>\n

* of any string as 0?<\/span><\/p>\n

* A sample \"main\" has been provided.<\/span><\/p>\n

It will ask for a string and then print the length.<\/span><\/p>\n

********\/<\/span><\/p>\n

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

\/********<\/span><\/p>\n

* length -- Computes the length of a string.<\/span><\/p>\n

* Parameters<\/span><\/p>\n

string -- The string whose length we want.<\/span><\/p>\n

* Returns the length of the string.<\/span><\/p>\n

*<\/span><\/p>\n

********\/<\/span><\/p>\n

int length(char string[]) \/*char array name*\/<\/span><\/p>\n

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

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

\/* index into the string *\/<\/span><\/p>\n

\/*<\/span><\/p>\n

* Loop until we reach the end of string character<\/span><\/p>\n

*\/<\/span><\/p>\n

for (index = 0; string[index] != '\\0'; ++index)<\/span><\/p>\n

\/* do nothing *\/<\/span><\/p>\n

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

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

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

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

char line[100];<\/span><\/p>\n

\/* Input line from user *\/<\/span><\/p>\n

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

printf(\"Enter line:\");<\/span><\/p>\n

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

printf(\"Length (including newline) is: %d\\n\", length(line));<\/span><\/p>\n

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

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

Now that we have learned about functions, we can talk about u sing structured\u00a0<\/span>programming techniques to design programs. These techniques are ways of\u00a0<\/span>dividing up or structuring a program into small, well -defined functions. They make\u00a0<\/span>the program easy to write and easy to understand. I don't claim that this method is\u00a0<\/span>the absolute best way to program. It happens to be the method that works best for\u00a0<\/span>me. If another system works better for you, use it.<\/span><\/p>\n

Example 9-5. Solve the World's Problems<\/span><\/p>\n

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

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

init();<\/span><\/p>\n

solve_problems();<\/span><\/p>\n

finish_up();<\/span><\/p>\n

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

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

Of course, some of the details will have to be filled in later.<\/span><\/p>\n

Start by writing the main function. It should be less than three pages long. If it\u00a0<\/span>grows longer, consider splitting it up into two smaller, simpler functions. After the\u00a0<\/span>main function is complete, you can start on the others.<\/span><\/p>\n

This type of structured programming is called top-down programming. You start at\u00a0<\/span>the top (main) and work your way down.<\/span><\/p>\n

Another type of coding is called bottom -up programming . This method involves\u00a0<\/span>writing the lowest-level function first, testing it, and then building on that working\u00a0<\/span>set. I tend to use some bottom-up techniques when I'm working with a new\u00a0<\/span>standard function that I haven't used before. I write a small function to make sure\u00a0<\/span>that I really know how the function works, and then continue from there. This\u00a0<\/span>approach is used in Chapter 7 to construct the calculator program.<\/span><\/p>\n

So, in actual practice, both techniques are useful. A mostly top -down, partially\u00a0<\/span>bottom-up technique results. Computer scientists have a term for this methodology:\u00a0<\/span>chaos. The one rule you should follow in programming is \"Use what works best.\"<\/span><\/p>\n

9.5 Recursion<\/span><\/strong><\/p>\n

Recursion occurs when a function calls itself directly or indirectly. Some\u00a0<\/span>programming functions, such as the factorial, lend themselves naturally to recursive\u00a0<\/span>algorithms.<\/span><\/p>\n

A recursive function must follow two basic rules:<\/span><\/p>\n

: It must have an ending point.<\/span><\/p>\n

: It must make the problem simpler.<\/span><\/p>\n

A definition of factorial is:<\/span><\/p>\n

fact(0) = 1<\/span><\/p>\n

fact(n) = n * fact(n-1)<\/span><\/p>\n

In C, this definition is:<\/span><\/p>\n

int fact(int number)<\/span><\/p>\n

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

if (number == 0)<\/span><\/p>\n

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

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

return (number * fact(number-1));<\/span><\/p>\n

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

This definition satisfies our two rules. First, it has a definite ending point (when\u00a0<\/span>number == 0). Second, it simplifies the problem because the calculation of\u00a0<\/span>fact(number-1) is simpler than fact(number).<\/span><\/p>\n

Factorial is legal only for number >= 0. But what happens if we try to compute\u00a0<\/span>fact(-3)? The program will abort with a stack overflow or similar message.<\/span><\/p>\n

fact(-3) calls fact(-4), which calls fact(-5), etc. No ending point exists. This\u00a0<\/span>error is referred to as an infinite recursion error.<\/span><\/p>\n

Many things that we do iteratively can be done recursively\u201dfor example, summing\u00a0<\/span>up the elements of an array. We define a function to add elements m-n of an array\u00a0<\/span>as follows:<\/span><\/p>\n

: If we have only one element, then the sum is simple.<\/span><\/p>\n

: Otherwise, we use the sum of the first element and the sum of the rest.<\/span><\/p>\n

In C, this function is:<\/span><\/p>\n

int sum(int first, int last, int array[])<\/span><\/p>\n

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

if (first == last)<\/span><\/p>\n

return (array[first]);<\/span><\/p>\n

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

return (array[first] + sum(first+1, last, array));<\/span><\/p>\n

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

For example:<\/span><\/p>\n

Sum(1 8 3 2) =<\/span><\/p>\n

1 + Sum(8 3 2) =<\/span><\/p>\n

8 + Sum(3 2) =<\/span><\/p>\n

3 + Sum (2) =<\/span><\/p>\n

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

3 + 2 = 5<\/span><\/p>\n

8 + 5 = 13<\/span><\/p>\n

1 + 13 = 14<\/span><\/p>\n

Answer = 14<\/span><\/p>\n

Answer 9 -1 : The programmer went to a lot of trouble to explain that the for loop\u00a0<\/b><\/span>did nothing (except increment the index). However, there is no semicolon ( \ud83d\ude09 at the\u00a0<\/b><\/span>end of the for. C keeps on reading until it sees a statement (in this case<\/b><\/span><\/p>\n

return(index))..<\/b>duh..look carefully at the most common faults...<\/i><\/span>with the semi colon it gives:<\/i><\/span><\/span><\/p>\n

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

Enter line:1<\/span><\/p>\n

Length (including newline) is: 2<\/span><\/p>\n

Enter line:12<\/span><\/p>\n

Length (including newline) is: 3<\/span><\/p>\n

Enter line:123<\/span><\/p>\n

Length (including newline) is: 4<\/span><\/p>\n

len2.c - again, find the fault...<\/span><\/p>\n

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

int length(char string[])<\/span><\/p>\n

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

int index; \/* index into the string *\/<\/span><\/p>\n

\/*<\/span><\/p>\n

* Loop until we reach the end-of-string character*\/<\/span><\/p>\n

for (index = 0; string[index] != '\\0'; ++index) continue; \/* do nothing *\/<\/span><\/p>\n

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

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

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

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

char line[100]; \/* Input line from user *\/<\/span><\/p>\n

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

printf(\"Enter line:\");<\/span><\/p>\n

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

printf(\"Length (including newline) is: %d\\n\", length(line));<\/span><\/p>\n

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

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

9.7 Programming Exercises<\/span><\/strong><\/p>\n

Exercise 9 -1 : Write a procedure that counts the number of words in a string. (Your\u00a0<\/span>documentation should describe exactly how you define a word.) Write a program to\u00a0<\/span>test your new procedure.<\/span><\/p>\n

Exercise 9-2 : Write a function begins(string1,string2) that returns true if\u00a0<\/span>string1 begins string2. Write a program to test the function.<\/span><\/p>\n

Exercise 9-3 : Write a function count(number, array, length) that counts the\u00a0<\/span>number of times number appears in array. The array has length e lements. The\u00a0<\/span>function should be recursive. Write a test program to go with the function.<\/span><\/p>\n

Exercise 9 -4: Write a function that takes a character array and returns a primitive\u00a0<\/span>hash code by adding up the value of each character in the array.<\/span><\/p>\n

Exercise 9-5 : Write a function that returns the maximum value of an array of\u00a0<\/span>numbers.<\/span><\/p>\n

Exercise 9 -6: Write a function that scans a character array for the character - and\u00a0<\/span>replaces it with _.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

<\/div>\n

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

<\/div>\n

Chapter 9 introduces local variables, functions, and parameters. A big vim tip here for prog editing\/writing: Lesson 4.3: MATCHING PARENTHESES SEARCH ** Type % to find a matching ),], or } . ** 1. Place the cursor on any (, [, or { in the line below marked --->. 2. Now type the % character. ...\u00a0 Chapter 9 Notes 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-3212","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\/3212","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=3212"}],"version-history":[{"count":0,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/3212\/revisions"}],"wp:attachment":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/media?parent=3212"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/categories?post=3212"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/tags?post=3212"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}