{"id":8885,"date":"2016-06-07T14:53:32","date_gmt":"2016-06-07T13:53:32","guid":{"rendered":"http:\/\/probook\/DebianAdmin\/?p=3065"},"modified":"2023-10-28T21:43:19","modified_gmt":"2023-10-28T20:43:19","slug":"chapter-5-notes-practical-c-programming-3rd-edition-by-steve-oualline-2","status":"publish","type":"post","link":"https:\/\/stevepedwards.today\/DebianAdmin\/chapter-5-notes-practical-c-programming-3rd-edition-by-steve-oualline-2\/","title":{"rendered":"Chapter 5 Notes \u2013 Practical C Programming, 3rd Edition By Steve Oualline"},"content":{"rendered":"
<\/div>\n

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

<\/div>\n

Chapter 5 covers arrays and more complex variables. Shorthand operators such as\u00a0++ and %= are also described.<\/span><\/strong><\/p>\n

A lot of info in this chapter - difficult to summarise - almost totally copied...a few successful progs written up to now for 2 full days of study of this PDF - bed ridden with a bad ankle!! - jeez, things must be bad if I'm learning programming!<\/span><\/p>\n

\"progstochap5.png\"<\/p>\n

To archive the source files:<\/span><\/p>\n

tar -cf progs.tar *.c<\/span><\/p>\n

To list them after:<\/span><\/p>\n

 <\/p>\n

$<\/span> tar -tf progs.tar<\/span>
\n2plus2.c<\/span>
\narray.c<\/span>
\narrayprob.c<\/span>
\navg.c...<\/span><\/p>\n

ls -ls progs.tar<\/span>
\n40 -rw-r--r-- 1 stevee stevee 40960 Jun 8 06:44 progs.tar<\/span><\/p>\n

Check text file byte sizes (each char is a byte remember, so idea of total text):<\/span> ls -als *.c<\/span>
\n4 -rw-r--r-- 1 stevee stevee 213<\/strong>\u00a0Jun 7 13:14 2plus2.c<\/span>
\n4 -rw-r--r-- 1 stevee stevee 572 Jun 6 20:05 array.c<\/span>
\n4 -rw-r--r-- 1 stevee stevee 587 Jun 6 19:57 arrayprob.c<\/span>
\n4 -rw-r--r-- 1 stevee stevee 425 Jun 6 17:12 avg.c...<\/span><\/p>\n

or lines\/chars:\u00a0<\/span>$ wc -lm *.c<\/span>
\n9 213 2plus2.c<\/span>
\n 32 572 array.c<\/span>
\n 27 587 arrayprob.c<\/span>
\n 17 425 avg.c...<\/span><\/p>\n

Check text file disk allocation sizes:<\/span> du -h *.c<\/span><\/p>\n

4.0K 2plus2.c<\/span>
\n4.0K array.c<\/span>
\n4.0K arrayprob.c...<\/span><\/p>\n

To compile and run them in Mint: $<\/span>\u00a0gcc -o 2plus2 2plus2.c <\/span><\/p>\n

then $<\/span>\u00a0.\/2plus2
\nThe answer is 4<\/span><\/span><\/p>\n

Download them here:<\/span>\u00a0progs.tar<\/a><\/span><\/p>\n

Chapter 5 covers arrays and more complex variables. Shorthand operators such as ++ and %= are also described.<\/span><\/p>\n

\/* List of data to be sorted and averaged *\/<\/i><\/span><\/p>\n

int data_list[3];<\/i><\/span><\/p>\n

The above example declares data_list to be an array of three elements.<\/i><\/span><\/p>\n

data_list[0], data_list[1], and data_list[2] are separate variables. <\/i><\/span><\/p>\n

To reference an element of an array, you use a number called the index\u2014the number<\/i><\/span><\/p>\n

inside the square brackets ([ ]). C is a funny language that likes to start counting at<\/i><\/span><\/p>\n

0.<\/i><\/span><\/p>\n

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

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

float data[5]<\/b>; \/* data [0]-[4] to average and total *\/<\/span><\/p>\n

float total; \/* the total of the data items *\/<\/span><\/p>\n

float average; \/* average of the items *\/<\/span><\/p>\n

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

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

data[0]<\/b> = 34.0;<\/span><\/p>\n

data[1]<\/b> = 27.0;<\/span><\/p>\n

data[2]<\/b> = 45.0;<\/span><\/p>\n

data[3]<\/b> = 82.0;<\/span><\/p>\n

data[4]<\/b> = 22.0;<\/span><\/p>\n

total = data[0] + data[1] + data[2] + data[3] + data[4];<\/span><\/p>\n

average = total \/ 5.0;<\/span><\/p>\n

printf(\"Total %.0f Average %.0f\\n\", total, average); \/*no dec places*\/<\/span><\/p>\n

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

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

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

Total 210 Average 42<\/span><\/p>\n

Strings are sequences of characters. C does not have a built-in string type; instead,<\/i><\/span><\/p>\n

strings are created out of character arrays. In fact, strings are just character arrays<\/i><\/span><\/p>\n

with a few restrictions. One of these restrictions is that the special character '\\0'<\/i><\/span><\/p>\n

(NUL) is used to indicate the end of a string.<\/i><\/span><\/p>\n

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

char name[4];<\/span><\/p>\n

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

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

name[0] = 'S';<\/span><\/p>\n

name[1] = 'a';<\/span><\/p>\n

name[2] = 'm';<\/span><\/p>\n

name[3] = ' \\0';<\/b><\/span><\/p>\n

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

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

Note that we had to allocate<\/b><\/i><\/span><\/p>\n

one character for the end-of-string marker.<\/b><\/i><\/span><\/p>\n

To initialize the variable name to Sam, we would write:<\/span><\/p>\n

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

char name[4];<\/span><\/p>\n

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

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

strcpy (name, \"Sam\"); \/* Legal *\/<\/span><\/p>\n

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

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

C uses variable -length strings. For example, the declaration:<\/i><\/p>\n

#include <string.h><\/b><\/i><\/span><\/p>\n

char string[50];<\/i><\/span><\/p>\n

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

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

strcpy(string,\"Sam\");<\/i><\/span><\/p>\n

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

creates an array (string ) that can contain up to 50 characters. The size of the array<\/i><\/p>\n

is 50, but the length of the string is 3. Any string up to 49 characters long can be<\/i><\/p>\n

stored in string. (One character is reserved for the NUL that indicates<\/i><\/p>\n

end-o f-string.)<\/i><\/p>\n

\"\"<\/p>\n

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

#include <string.h><\/b><\/span><\/p>\n

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

char name<\/b>[30]; \/* First name of someone *\/<\/span><\/p>\n

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

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

strcpy(name<\/b>, \"Sam\"); \/* Initialize the name *\/<\/span><\/p>\n

printf(\"The name is %s<\/b>\\n\", name<\/b>);<\/span><\/p>\n

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

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

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

The name is Sam<\/span><\/p>\n

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

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

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

char first[100]; \/* first name *\/<\/span><\/p>\n

char last[100]; \/* last name *\/<\/span><\/p>\n

char full_name[200]; \/* full version of first and last name *\/<\/span><\/p>\n

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

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

strcpy(first, \"Steve\"); \/* Initialize first name *\/<\/span><\/p>\n

strcpy(last, \"Oualline\"); \/* Initialize last name *\/<\/span><\/p>\n

strcpy(full_name, first); \/* full = \"Steve\" *\/<\/span><\/p>\n

\/* Note: strcat not strcpy *\/<\/span><\/p>\n

strcat(full_name, \" \");<\/span><\/p>\n

strcat(full_name, last);<\/span><\/p>\n

\/* full = \"Steve \" *\/<\/span><\/p>\n

\/* full = \"Steve Oualline\" *\/<\/span><\/p>\n

printf(\"The full name is %s\\n\", full_name);<\/span><\/p>\n

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

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

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

The full name is Steve Oualline<\/span><\/p>\n

The standard function fgets<\/b> can be used to read a string from the keyboard. The<\/i><\/span><\/p>\n

general form of an fgets call is:<\/i><\/span><\/p>\n

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

The arguments are:<\/i><\/p>\n

name<\/b><\/i><\/p>\n

is the name of a character array. The line (including the end -o f-line character) is read into this array.<\/i><\/p>\n

sizeof( name )<\/b><\/i><\/p>\n

indicates the maximum number of characters to read (plus one for the end-o f-string character). The sizeof function provides a convenient way of limiting the number of characters read to the maximum numbers that the variable can hold. This function will be discussed in more detail in Chapter 14 .<\/i><\/p>\n

stdin<\/b><\/i><\/p>\n

is the file to read. In this case, the file is the standard input or keyboard.<\/i><\/p>\n

Suddenly, a real jump in complexity for what happens re array space re-allocation etc! Not sure in my comments what really happens here\u2026? <\/b><\/i><\/span><\/p>\n

\/*full1.c*\/<\/i><\/span><\/p>\n

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

#include <string.h><\/b><\/i><\/span><\/p>\n

char first<\/b>[100]; \/* First name of person we are working with *\/<\/i><\/span><\/p>\n

char last<\/b>[100]; \/* His last name *\/<\/i><\/span><\/p>\n

\/* First and last name of the person (computed) *\/<\/i><\/span><\/p>\n

char full[200]<\/b>; \/*sum of both first<\/b>+last<\/b> arrays *\/<\/i><\/span><\/p>\n

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

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

printf(\"Enter first name: \"); \/*screen prompt 1*\/<\/i><\/span><\/p>\n

fgets(first<\/b>, sizeof(first<\/b>), stdin); \/*takes keys input + EOL string size and places in first<\/b> array?*\/<\/i><\/span><\/p>\n

first[strlen(first<\/b>)-1] = '\\0'; \/*sizeof(first<\/b>)<\/b> array space becomes first<\/b>-1= input chars+\\n-1 and sets [input chars+\\n-1] and [n-1] set to \\0 to remove \\n newline \u2013 see below*\/<\/i><\/span><\/p>\n

printf(\"Enter last name: \"); \/*screen prompt 2*\/<\/i><\/span><\/p>\n

fgets(last<\/b>, sizeof(last<\/b>), stdin); \/*takes keys input + EOL string size and places in last<\/b> array?*\/<\/i><\/span><\/p>\n

last[strlen(last)-1] = '\\0'; \/*sizeof(last<\/b>)<\/b> array space becomes last<\/b>-1=input chars+\\n-1 and [n-1] set to \\0 to remove \\n newline \u2013 see below*\/<\/i><\/span><\/p>\n

strcpy(full, first); \/*catcopies -first<\/b>\u201d array chars to -full\u201d string mem space?*\/<\/i><\/span><\/p>\n

strcat(full, \" \"); \/*catcopies -blank\u201d space char to -full\u201d string mem space?*\/<\/i><\/span><\/p>\n

strcat(full, last); \/*catcopies -last<\/b>\u201d array chars to -full\u201d string mem space?*\/<\/i><\/span><\/p>\n

printf(\"The name is %s\\n\", full); \/*screen prints contents of final -full\u201d array space*\/<\/i><\/span><\/p>\n

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

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

Fully commented:<\/span><\/p>\n

\/*full1.c*\/<\/span>
\n#include <stdio.h><\/span>
\n#include <string.h><\/span>
\nchar first[100]; \/* first name array; 0-99 less 2 chars long max*\/<\/span>
\nchar last[100]; \/* last name array; 0-99 less 2 chars long max*\/*<\/span>
\n\/* first and last name of the person (computed) and printed to screen*\/<\/span>
\nchar full[200]; \/* first + last name array space*\/<\/span>
\nint main() <\/span>
\n{<\/span>
\nprintf(\"Enter first name: \"); \/* user input first name *\/<\/span>
\nfgets(first, sizeof(first), stdin); \/* user chars put into first array, chars counted, from keybd *\/<\/span>
\nfirst[strlen(first)-1] = '\\0'; \/*sets default penultimate char newline \\n to \\0 so final result is o\/p on one line*\/<\/span>
\nprintf(\"Enter last name: \"); \/* user input last name *\/<\/span>
\nfgets(last, sizeof(last), stdin); \/* user chars put into first array, chars counted, from keybd *\/<\/span>
\nlast[strlen(last)-1] = '\\0'; \/*sets default newline \\n to \\0*\/<\/span>
\nstrcpy(full, first); \/*copies contents of first array into full array space*\/<\/span>
\nstrcat(full, \" \"); \/*cats a space char into full array space*\/<\/span>
\nstrcat(full, last); \/*cats contents of last array into full array space*\/<\/span>
\nprintf(\"The name is %s\\n\", full); \/*prints contents of full array space*\/<\/span>
\nreturn (0);<\/span>
\n}<\/span><\/p>\n

\"full1.c.png\"<\/a><\/p>\n

For example, the name \"John\" would be stored as:<\/i><\/p>\n

first[0] = 'J'<\/i><\/p>\n

first[1] = 'o'<\/i><\/p>\n

first[2] = 'h'<\/i><\/p>\n

first[3] = 'n'<\/i><\/p>\n

first[4] = '\\n'<\/i><\/p>\n

first[5] = '\\0'<\/i><\/p>\n

\/* end of string *\/<\/i><\/p>\n

By setting first[4] to NUL ('\\0'), we can shorten the string by one character and<\/i><\/p>\n

get rid of the unwanted newline. This change can be done with the statement:<\/i><\/p>\n

first[4] = '\\0';<\/i><\/p>\n

By setting first[4] to NUL ('\\0'), we can shorten the string by one character and<\/i><\/p>\n

get rid of the unwanted newline. This change can be done with the statement:<\/i><\/p>\n

first[4] = '\\0';<\/i><\/p>\n

The problem is that this method will work only for four -character names. We need a<\/i><\/p>\n

general algorit hm to solve this problem. The length of this string is the index of the<\/i><\/p>\n

end-o f-string null character. The character before it is the one we want to get rid of.<\/i><\/p>\n

So, to trim the string, we use the statement:<\/i><\/p>\n

first[strlen(first)-1] = '\\0';<\/i><\/p>\n

$ .\/full1<\/span> <\/i><\/p>\n

Enter first name: steve<\/i><\/span><\/p>\n

Enter last name: edwards<\/i><\/span><\/p>\n

The name is steve edwards<\/i><\/span><\/p>\n

Arrays can have more than one dimension. The declaration for a two-dimensional array is:<\/i><\/p>\n

type variable[size1][size2]; \/* Comment *\/<\/i><\/p>\n

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

int matrix[2][4]; \/* a typical matrix *\/<\/i><\/p>\n

Notice that C does not follow the notation used in other languages of<\/b><\/i><\/p>\n

matrix[10,12].<\/b><\/i><\/p>\n

Question 5-1 : Why does Example 5 -7 print the wrong answer? (Click here for the<\/p>\n

answer Section 5.15)<\/p>\n

\/* Example 5-7. p_array\/p_array.c *\/<\/span><\/p>\n

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

int array[3][2]; \/* Array of numbers *\/<\/span><\/p>\n

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

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

int x,y; \/* Loop indicies *\/<\/span><\/p>\n

array[0][0] = 0 * 10 + 0;<\/span><\/p>\n

array[0][1] = 0 * 10 + 1;<\/span><\/p>\n

array[1][0] = 1 * 10 + 0;<\/span><\/p>\n

array[1][1] = 1 * 10 + 1;<\/span><\/p>\n

array[2][0] = 2 * 10 + 0;<\/span><\/p>\n

array[2][1] = 2 * 10 + 1;<\/span><\/p>\n

printf(\"array[%d] \", 0); \/*wrong C format! Needs [x] [y]*\/<\/b><\/span><\/p>\n

printf(\"%d \", array[0,0]);<\/b><\/span><\/p>\n

printf(\"%d \", array[0,1]);<\/b><\/span><\/p>\n

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

printf(\"array[%d] \", 1);<\/b><\/span><\/p>\n

printf(\"%d \", array[1,0]);<\/b><\/span><\/p>\n

printf(\"%d \", array[1,1]);<\/b><\/span><\/p>\n

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

printf(\"array[%d] \", 2);<\/b><\/span><\/p>\n

printf(\"%d \", array[2,0]);<\/b><\/span><\/p>\n

printf(\"%d \", array[2,1]);<\/b><\/span><\/p>\n

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

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

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

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

array[0] 6295648 6295656 <\/span><\/p>\n

array[1] 6295648 6295656 <\/span><\/p>\n

array[2] 6295648 6295656<\/span><\/p>\n

Correct Arrays<\/span><\/p>\n

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

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

int array[3][2];<\/span><\/p>\n

\/* Array of numbers *\/<\/span><\/p>\n

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

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

int x,y;<\/span><\/p>\n

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

array[0][0] = 0 * 10 + 0;<\/span><\/p>\n

array[0][1] = 0 * 10 + 1;<\/span><\/p>\n

array[1][0] = 1 * 10 + 0;<\/span><\/p>\n

array[1][1] = 1 * 10 + 1;<\/span><\/p>\n

array[2][0] = 2 * 10 + 0;<\/span><\/p>\n

array[2][1] = 2 * 10 + 1;<\/span><\/p>\n

printf(\"array[%d] \", 0);<\/span><\/p>\n

printf(\"%d \", array[0][0])<\/b>;<\/span><\/p>\n

printf(\"%d \", array[0][1]);<\/span><\/p>\n

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

printf(\"array[%d] \", 1);<\/span><\/p>\n

printf(\"%d \", array[1][0]);<\/span><\/p>\n

printf(\"%d \", array[1][1]);<\/span><\/p>\n

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

printf(\"array[%d] \", 2);<\/span><\/p>\n

printf(\"%d \", array[2][0]);<\/span><\/p>\n

printf(\"%d \", array[2][1]);<\/span><\/p>\n

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

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

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

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

array[0] 0 1 <\/span><\/p>\n

array[1] 10 11 <\/span><\/p>\n

array[2] 20 21<\/span><\/p>\n

The function scanf is notorious for its poor end-of-line handling, which makes scanf useless for all but an expert.<\/p>\n

However, we've found a simple way to get around the deficiencies of scanf\u2014we don't use it. Instead, we use fgets to read a line of input and sscanf to convert the text into numbers. (The name sscanf stands for \"string scanf\". sscanf is like scanf, but works on strings instead of the standard input.)<\/p>\n

Normally, we use the variable line for lines read from the keyboard:<\/p>\n

char line[100]; \/* Line of keyboard input *\/<\/p>\n

When we want to process input, we use the statements:<\/p>\n

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

sscanf(line, format, &variable1, &variable2 . . .;<\/p>\n

Here fgets reads a line and sscanf processes it. format is a string similar to the<\/p>\n

printf format string. Note the ampersand (& ) in front of the variable names. This<\/p>\n

symbol is used to indicate that sscanf will change the value of the associated<\/p>\n

variables.<\/p>\n

If you forget to put & in front of each variable for sscanf, the result could be a \"Segmentation violation core dumped\" or \"Illegal memory access\" error. In some cases a random variable or instruction will be changed. On UNIX, damage is limited to the currentprogram;<\/p>\n

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

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

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

int value; \/* input line from console *\/ <\/span><\/p>\n

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

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

printf(\"Enter a value: \"); \/* a value to double *\/<\/span><\/p>\n

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

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

printf(\"Twice %d is %d\\n\", value, value * 2<\/b>);<\/span><\/p>\n

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

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

Notice that there is no<\/i><\/span><\/p>\n

\\n at the end of Enter a value:. This omission is intentional because we do not want the computer to print a newline after the prompt.<\/i><\/span><\/p>\n

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

Enter a value: 4<\/span><\/p>\n

Twice 4 is 8<\/span><\/p>\n

Example 5 -9 computes the area of a triangle, given the triangle's width and height. For some strange reason, the compiler refuses to believe that we declared the variable width. The declaration is right there on line 2, just after the definition of height. Why isn't the compiler seeing it?<\/p>\n

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

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

int height; \/* the height of the triangle<\/b><\/span><\/p>\n

int width; \/* the width of the triangle *\/<\/span><\/p>\n

int area; \/* area of the triangle (computed) *\/<\/span><\/p>\n

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

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

printf(\"Enter width height? \");<\/span><\/p>\n

fgets(line<\/b>, sizeof(line), stdin); \/*stdin takes chars, sizeof counts chars then stores in line<\/b> array*\/<\/span><\/p>\n

sscanf(line, \"%d %d<\/b>\", &width, &height); *sscanf reads\/converts line<\/b> int data and stores in <\/b>&width, &height \u2013 note the space between %d<\/b>%d<\/b> is not required to store spaced input \u2013 is it because the space between inputs is not an int???<\/b>*\/<\/b><\/span><\/p>\n

area = (width * height) \/ 2;<\/span><\/p>\n

printf(\"The area is %d\\n\", area);<\/span><\/p>\n

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

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

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

Enter width height? 3 4<\/span><\/p>\n

The area is 6<\/span><\/p>\n

C allows variables to be initialized in the declaration statement.<\/p>\n

int counter = 0; \/* number cases counted so far *\/<\/span><\/p>\n

Arrays can also be initialized in this manner. The element list must be enclosed in curly braces ({}). For example:<\/p>\n

int product_codes[3] = {10, 972, 45}; \/* Product numbers for the parts we are making \u2013 remember, array of 3 starts at 0,1,2*\/<\/span><\/p>\n

The previous initialization is equivalent to:<\/p>\n

product_codes[0] = 10;<\/span><\/p>\n

product_codes[1] = 972;<\/span><\/p>\n

product_codes[2] = 45;<\/span><\/p>\n

The number of elements in {} does not have to match the array size. If too many<\/span><\/p>\n

numbers are present, a warning will be issued. If an insufficient amount of n umbers<\/span><\/p>\n

are present, C will initialize the extra elements to 0.<\/span><\/p>\n

If no dimension is given, C will determine the dimension from the number of<\/p>\n

elements in the initialization list. For example, we could have initialized our variable<\/p>\n

product_codes with the state ment:<\/p>\n

\/* Product numbers for the parts we are making *\/<\/span><\/p>\n

int product_codes[] = {10, 972, 45};<\/span><\/p>\n

Initializing multidimensional arrays is similar to initializing single -dimension arrays.<\/p>\n

A set of brackets ([ ]) encloses each dimension. The declaration:<\/p>\n

int matrix[2][4]; \/* a typical matrix *\/<\/span><\/p>\n

can be thought of as a declaration of an array of dimension 2 with elements that are<\/span><\/p>\n

arrays of dimension 4. This array is initialized as follows:<\/span><\/p>\n

\/* a typical matrix *\/<\/span><\/p>\n

int matrix[2][4] =<\/span><\/p>\n

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

{1, 2, 3, 4},<\/span><\/p>\n

{10, 20, 30, 40}<\/span><\/p>\n

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

Strings can be initialized in a similar manner. For example, to initialize the variable<\/span><\/p>\n

name to the string \"Sam\", we use the statement:<\/span><\/p>\n

char name[] = {'S', 'a', 'm', '\\0'};<\/span><\/p>\n

C has a special shorthand for initializing strings: Surround the string with double<\/span><\/p>\n

quotes (\"\" ) to simplify initialization. The previous example could have been written:<\/span><\/p>\n

char name[] = \"Sam\";<\/span><\/p>\n

The dimension of name is 4, because C allocates a place for the ' \\0' character that<\/span><\/p>\n

ends the string.<\/span><\/p>\n

The following declaration:<\/span><\/p>\n

char string[50] = \"Sam\";<\/span><\/p>\n

is equivalent to:<\/span><\/p>\n

char string[50];<\/span><\/p>\n

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

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

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

strcpy(string,\"Sam\");<\/span><\/p>\n

An array of 50 characters is allocated but the length of the string is 3.<\/span><\/p>\n

The long qualifier informs C that we wish to allocate extra storage for the integer. If we are going to use small numbers and wish to reduce storage, we use the qualifier short. For example:<\/span><\/p>\n

short int year; \/* Year including the 19xx part *\/<\/span><\/p>\n

C guarantees that the size of storage for short <= int <= long. In actual practice, short almost always allocates two bytes, long four bytes, and int two or four bytes.<\/span><\/p>\n

(See Appendix B, for numeric ranges.)<\/span><\/p>\n

The type short int usually uses 2 bytes, or 16 bits. 15 bits are used normally for the<\/b><\/span><\/p>\n

number and 1 bit for the sign. <\/b><\/span><\/p>\n

This format gives the type a range of -32768 (-2^15 ) to<\/span><\/p>\n

32767 (2^15 - 1). An unsigned short int uses all 16 bits for the number, giving it the<\/span><\/p>\n

range of to 65535 (2^16 ). All int declarations default to signed, so that the declaration:<\/span><\/p>\n

signed long int answer; \/* final result *\/<\/span><\/p>\n

is the same as:<\/span><\/p>\n

long int answer; \/* final result *\/<\/span><\/p>\n

Character variables use 1 byte. They can also be used for numbers in the range of -128 to 127 ( signed char) or to 255 (unsigned char). Unlike integers, they do not default to signed ; the default is compiler dependent. Very short integers may be printed using the integer conversion (%d ).<\/span><\/p>\n

You cannot read a very short integer directly. You must read the number into an integer and then use an assignment statement. For example:<\/p>\n

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

signed char ver_short;<\/span><\/p>\n

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

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

\/* A very short integer *\/<\/span><\/p>\n

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

\/* A temporary number *\/<\/span><\/p>\n

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

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

\/* Read a very short integer *\/<\/span><\/p>\n

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

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

very_short = temp;<\/span><\/p>\n

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

%Conversion Uses<\/p>\n

%hd (signed) short int<\/p>\n

%d (signed) int<\/p>\n

%ld (signed) long int<\/p>\n

%hu unsigned short int<\/p>\n

%u unsigned int<\/p>\n

%lu unsigned long int<\/p>\n

long int<\/b> declarations allow the program to explicitly specify extra precision where it<\/p>\n

is needed (at the expense of memory).<\/p>\n

short int <\/b>numbers save space but have a more limited range. The most compact integers have type char.<\/b> They also have the most limited range.<\/p>\n

unsigned numbers provide a way of doubling the positive range at the expense of eliminating negative numbers. They are also useful for things that can never be negative, like counters and indices.<\/p>\n

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

\/* Variable for computation results *\/<\/span><\/p>\n

short <\/b>int answer;<\/span><\/p>\n

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

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

answer = 2 + 2;<\/span><\/p>\n

printf(\"The answer is %d\\n\", answer); \/* correct answer needed printf definition \"answer\" *\/<\/span><\/p>\n

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

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

$ .\/2plus2 <\/span><\/span><\/p>\n

The answer is 4<\/span><\/p>\n

The float type also comes in various flavors. float denotes normal precision<\/p>\n

(usually 4 bytes = 32 bits). double indicates double precision (usually 8 bytes = 64 bits).<\/p>\n

Double-precision variables give the programmer many times the range and<\/p>\n

precision of single-precision (float) variables.<\/p>\n

The qualifier long double denotes extended precision. On some systems, this is the same as double; on others, it offers additional precision. All types of floating -point numbers are always signed.<\/p>\n

% Conversion Uses Notes<\/p>\n

%f float printf only.<\/p>\n

%lf double sscanf only.<\/p>\n

%Lf long double Not available on all compilers. (gcc OK, obviously 2106!! hehe\u2026)<\/b><\/p>\n

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

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

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

long double height; \/* the height of the triangle*\/<\/b><\/span><\/p>\n

long double width; \/* the width of the triangle *\/<\/b><\/span><\/p>\n

long double area; \/* area of the triangle (computed) *\/<\/b><\/span><\/p>\n

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

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

printf(\"Enter integers for: width height \");<\/span><\/p>\n

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

sscanf(line, \"%Lf%Lf<\/b>\", &width, &height);<\/span><\/p>\n

area = (width * height) \/ 2;<\/span><\/p>\n

printf(\"The area is %Lf<\/b>\\n\", area);<\/span><\/p>\n

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

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

.\/triang2<\/span><\/p>\n

Enter integers for: width height 12345678910 12345678910<\/span><\/p>\n

The area is 76207893874409394048.000000<\/span><\/p>\n

Double -precision instructions gain accuracy at the expense of time and storage. In most cases, float is adequate; however, if accuracy is a problem, switch to double.<\/span><\/p>\n

const<\/b> float PI = 3.1415927; \/* The classic circle constant *\/<\/span><\/p>\n

By convention, variable names use only lowercase and constant names use only uppercase. However, the language does not require this case structure.<\/b><\/span><\/p>\n

If we tried to reset the value of PI to 3.0, we would generate an error message:<\/span><\/p>\n

PI = 3.0; \/* Illegal *\/<\/span><\/p>\n

Integer numbers are specified as a string of digits, such as 1234, 88, -123, etc.<\/p>\n

These strings are decimal (base 10) numbers: 174 or 17410. Computers deal with<\/p>\n

binary (base 2) numbers: 10101110. The octal (base 8) system easily converts to<\/p>\n

and from binary. Each group of three digits (2 3 = 8) can be transformed into a single<\/p>\n

octal digit. Thus, 10101110 can be written as 10 101 110 and changed to the octal<\/p>\n

256. Hexadecimal (base 16) numbers have a similar conversion; only 4 bits are<\/p>\n

used at a time.<\/p>\n

The C language has conventions for representing octal and hexadecimal values.<\/p>\n

Leading zeros are used to signal an octal constant. For example, 0123 is 123 (octal)<\/p>\n

or 83 (decimal). Starting a number with \"0x\" indicates a hexadecimal (base 16)<\/p>\n

constant. So, 0x15 is 21 (decimal). Table 5 -4 shows several numbers in all three<\/p>\n

bases.<\/p>\n

\"\"<\/p>\n

Frequently, the programmer wants to increment (increase by 1) a variable. Using a normal assignment statement, this operation would look like:<\/p>\n

total_entries = total_entries + 1;<\/span><\/p>\n

C provides us with a shorthand for performing this common task. The ++ operator is used for incrementing:<\/p>\n

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

A similar operator, --, can be used for decrementing (decreasing by 1) a variable:<\/p>\n

--number_left;<\/span><\/p>\n

\/* is the same as *\/<\/span><\/p>\n

number_left = number_left - 1;<\/span><\/p>\n

But suppose that we want to add 2 instead of 1. Then we can use the following notation:<\/p>\n

total_entries += 2;<\/span><\/p>\n

This notation is equivalent to:<\/p>\n

total_entries = total_entries + 2;<\/span><\/p>\n

Operator Shorthand Equivalent Statement <\/span><\/p>\n

+= x += 2; x = x + 2; <\/span><\/p>\n

-= x -= 2; x = x \u2013 2; <\/span><\/p>\n

*= x *= 2; x = x * 2; <\/span><\/p>\n

\/= x \/= 2; x = x \/ 2;<\/span><\/p>\n

%= x %= 2; x = x % 2;<\/span><\/p>\n

Unfortunately, C allows the programmer to use side effects<\/b><\/i>. A side effect is an operation that is performed in addition to the main operation executed by the statement. For example, the following is legal C code:<\/p>\n

size = 5;<\/span><\/p>\n

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

The first statement assigns to size the value of 5. The second statement assigns to<\/p>\n

result the value of size (main operation) and increments size (side effect).<\/p>\n

But in what order are these processes performed? There are four possible answers.<\/p>\n

1. result is assigned the value of size (5), and then size is incremented.<\/p>\n

result is 5 and size is 6.<\/p>\n

2. size is incremented, and then result is assigned the value of size (6).<\/p>\n

result is 6 and size is 6.<\/p>\n

3. The answer is compile r-dependent and varies from computer to computer.<\/p>\n

4. If we don't write code like this, then we don't have to worry about such<\/p>\n

questions.<\/p>\n

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

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

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

int size = 5 ;<\/span><\/p>\n

printf(\"size is %d\\n\", size);<\/span><\/p>\n

int result = ++size ; \/*BAD CODE*\/<\/b><\/span><\/p>\n

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

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

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

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

size is 5<\/span><\/p>\n

size is 6<\/span><\/p>\n

result is 6<\/span><\/p>\n

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

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

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

int size = 5 ;<\/span><\/p>\n

printf(\"size is %d\\n\", size);<\/span><\/p>\n

++size ; \/*<\/b>BETTER CODE, SAME RESULT \u2013 op order is clear<\/b>*\/<\/b><\/span><\/p>\n

int result = size ; \/*<\/b>BETTER CODE, SAME RESULT<\/b>*\/<\/b><\/span><\/p>\n

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

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

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

In order to avoid trouble and keep the program simple, always put ++ and -- on a line by themselves.<\/b><\/i><\/p>\n

5.1: Temp<\/b><\/i><\/p>\n

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

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

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

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

float F; \/* temp in F *\/<\/span><\/p>\n

float C; \/* temp in C *\/<\/span><\/p>\n

float resultF; \/* resultF (computed) *\/<\/span><\/p>\n

float resultC; \/* resultC (computed) *\/<\/span><\/p>\n

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

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

printf(\"Enter temp in F: \");<\/span><\/p>\n

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

sscanf(line, \"%f \", &F );<\/span><\/p>\n

resultC = ( (F - 32) \/ (9.0 \/ 5.0) ) ; \/*must have dec point for no zero div*\/<\/span><\/p>\n

printf(\"The temp in C is %0.2f degC \\n \", resultC);<\/span><\/p>\n

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

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

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

Enter temp in F: 212<\/span><\/p>\n

The temp in C is 100.00 degC<\/span><\/p>\n

5.1 Vsphere<\/span><\/p>\n

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

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

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

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

\/*float F;*\/ \/* temp in F *\/<\/span><\/p>\n

float r; \/* radius sphere *\/<\/span><\/p>\n

\/*float resultF; *\/ \/* resultF (computed) *\/<\/span><\/p>\n

const float PI = 3.142; \/* PI made unchangeable value*\/<\/span><\/p>\n

float result; \/* volume result (computed) *\/<\/span><\/p>\n

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

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

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

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

sscanf(line, \"%f \", &r );<\/span><\/p>\n

\/*resultC = ( (F - 32) \/ (9.0 \/ 5.0) ) ;*\/ \/*must have dec point for no zero div*\/<\/span><\/p>\n

result = 4.0\/3.0 * PI * (r*r*r);<\/span><\/p>\n

printf(\"The volume is %0.2f \\n \", result);<\/span><\/p>\n

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

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

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

Enter sphere radius: 1<\/span><\/p>\n

The volume is 4.19<\/b> <\/span><\/p>\n

stevee@AMDA8 ~\/hello $ .\/vsphere <\/span><\/p>\n

Enter sphere radius: 2<\/span><\/p>\n

The volume is 33.51<\/b> <\/span><\/p>\n

stevee@AMDA8 ~\/hello $ .\/vsphere <\/span><\/p>\n

Enter sphere radius: 3<\/span><\/p>\n

The volume is 113.11<\/b> <\/span><\/p>\n

stevee@AMDA8 ~\/hello $ .\/vsphere <\/span><\/p>\n

Enter sphere radius: 4<\/span><\/p>\n

The volume is 268.12<\/b><\/span><\/p>\n

\"\"<\/p>\n

Exercise 5-3 : Write a program that prints the perimeter of a rectangle given its<\/b><\/i><\/span><\/p>\n

height and width. perimeter = 2 * (width + height)<\/b><\/i><\/span><\/p>\n

Exercise 5 -4 : Write a program that converts kilometers per hour to miles per hour.<\/b><\/i><\/span><\/p>\n

miles = (kilometer \u00b7 0.6213712)<\/b><\/i><\/span><\/p>\n

Exercise 5-5 : Write a program that takes hours and minutes as input, and then<\/b><\/i><\/span><\/p>\n

outputs the total number of minutes. (1 hour 30 minutes = 90 minutes).<\/b><\/i><\/span><\/p>\n

Exercise 5 -6 : Write a program that takes an integer as the number of minutes, and<\/b><\/i><\/span><\/p>\n

outputs the total hours and minutes (90 minutes = 1 hour 30 minutes).<\/b><\/i><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

<\/div>\n

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

<\/div>\n

Chapter 5 covers arrays and more complex variables. Shorthand operators such as\u00a0++ and %= are also described. A lot of info in this chapter - difficult to summarise - almost totally copied...a few successful progs written up to now for 2 full days of study of this PDF - bed ridden with a bad ankle!! ...\u00a0 Chapter 5 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-8885","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\/8885","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=8885"}],"version-history":[{"count":3,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/8885\/revisions"}],"predecessor-version":[{"id":10041,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/8885\/revisions\/10041"}],"wp:attachment":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/media?parent=8885"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/categories?post=8885"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/tags?post=8885"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}