{"id":3051,"date":"2016-06-06T16:54:45","date_gmt":"2016-06-06T15:54:45","guid":{"rendered":"https:\/\/stevepedwards.today\/DebianAdmin\/?p=3051"},"modified":"2023-11-09T02:47:42","modified_gmt":"2023-11-09T02:47:42","slug":"c-programming-chapters-1-4-notes-practical-c-programming-3rd-edition-by-steve-oualline","status":"publish","type":"post","link":"https:\/\/stevepedwards.today\/DebianAdmin\/c-programming-chapters-1-4-notes-practical-c-programming-3rd-edition-by-steve-oualline\/","title":{"rendered":"Chapters 1-4 Notes – Practical C Programming, 3rd Edition By Steve Oualline"},"content":{"rendered":"
<\/div>\n

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

<\/div>\n

https:\/\/www.oualline.com\/<\/a><\/p>\n

Chapter 1 gives a brief description of the C language and its use. This chapter\u00a0includes some background on the history of the language.<\/strong><\/span><\/p>\n

There is only one way to learn how to program and that is to write programs. You'll<\/span><\/p>\n

learn a lot more by writing and debugging programs than you ever will by reading<\/span><\/p>\n

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

Chapter 2 explains the basic programming process and gives you enough<\/p>\n

information to write a very simple program.<\/p>\n

\"\"<\/p>\n

\/*File:hello\/hello.c*\/ \/*comments - prog source file name req*\/<\/span><\/p>\n

#include <stdio.h> \/*comments format for std input\/output library for all progs*\/<\/b><\/span><\/p>\n

int main() \/*comments integer type null for main for all progs, so 0 ouput is no fault, 1 or other is fault*\/<\/b><\/span><\/p>\n

{ \/*comments required nest bracket1 for main*\/<\/b><\/span><\/p>\n

printf(\"Hello World\\n\"); \/*comments note new line char \\n*\/<\/span><\/p>\n

return (0); \/*comments return no output on prog success *\/<\/span><\/p>\n

} \/*comments required nest bracket2 for main*\/<\/b><\/span><\/p>\n

$<\/span> gcc -o hello hello.c<\/span><\/p>\n

$<\/span> ls -l hello<\/span><\/p>\n

-rwxr-xr-x 1 stevee stevee 8551 Jun 6 11:26 hello<\/span><\/p>\n

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

Hello World<\/span><\/p>\n

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

DESCRIPTION<\/span><\/p>\n

When you invoke GCC, it normally does preprocessing, compilation, assembly and linking. <\/b> The \"overall options\" allow you to stop this process at an intermediate stage. For example, the -c option says not to run the linker.<\/span><\/p>\n

Why I don't use debugger or -Wall (all Warnings; gives about same as -g ) in Mint at this stage:<\/p>\n

$ gcc -o<\/span>g<\/b><\/span> hello hello.c<\/span><\/p>\n

hello: In function `_fini':<\/i><\/span><\/p>\n

(.fini+0x0): multiple definition of `_fini'<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_info): relocation 0 has invalid symbol index 7<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_info): relocation 1 has invalid symbol index 8<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_info): relocation 2 has invalid symbol index 9<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_ranges): relocation 0 has invalid symbol index 4<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_ranges): relocation 1 has invalid symbol index 4<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_ranges): relocation 2 has invalid symbol index 5<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_ranges): relocation 3 has invalid symbol index 5<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/..\/..\/..\/x86_64-linux-gnu\/crti.o:(.fini+0x0): first defined here<\/i><\/span><\/p>\n

hello: In function `data_start':<\/i><\/span><\/p>\n

(.data+0x0): multiple definition of `__data_start'<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 0 has invalid symbol index 11<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 1 has invalid symbol index 12<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 2 has invalid symbol index 2<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 3 has invalid symbol index 2<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 4 has invalid symbol index 11<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 5 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 6 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 7 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 8 has invalid symbol index 12<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 9 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 10 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 11 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 12 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 13 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 14 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 15 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 16 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 17 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 18 has invalid symbol index 13<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_info): relocation 19 has invalid symbol index 21<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crt1.o(.debug_line): relocation 0 has invalid symbol index 2<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/..\/..\/..\/x86_64-linux-gnu\/crt1.o:(.data+0x0): first defined here<\/i><\/span><\/p>\n

hello: In function `data_start':<\/i><\/span><\/p>\n

(.data+0x8): multiple definition of `__dso_handle'<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/crtbegin.o:(.data+0x0): first defined here<\/i><\/span><\/p>\n

hello:(.rodata+0x0): multiple definition of `_IO_stdin_used'<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/..\/..\/..\/x86_64-linux-gnu\/crt1.o:(.rodata.cst4+0x0): first defined here<\/i><\/span><\/p>\n

hello: In function `_start':<\/i><\/span><\/p>\n

(.text+0x0): multiple definition of `_start'<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/..\/..\/..\/x86_64-linux-gnu\/crt1.o:\/build\/eglibc-3GlaMS\/eglibc-2.19\/csu\/..\/sysdeps\/x86_64\/start.S:118: first defined here<\/i><\/span><\/p>\n

hello: In function `_init':<\/i><\/span><\/p>\n

(.init+0x0): multiple definition of `_init'<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_line): relocation 0 has invalid symbol index 4<\/i><\/span><\/p>\n

\/usr\/bin\/ld: \/usr\/lib\/debug\/usr\/lib\/x86_64-linux-gnu\/crti.o(.debug_line): relocation 1 has invalid symbol index 5<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/..\/..\/..\/x86_64-linux-gnu\/crti.o:\/build\/eglibc-3GlaMS\/eglibc-2.19\/csu\/..\/sysdeps\/x86_64\/crti.S:64: first defined here<\/i><\/span><\/p>\n

\/tmp\/cc7gKOEV.o: In function `main':<\/i><\/span><\/p>\n

hello.c:(.text+0x0): multiple definition of `main'<\/i><\/span><\/p>\n

hello:(.text+0xed): first defined here<\/i><\/span><\/p>\n

\/usr\/lib\/gcc\/x86_64-linux-gnu\/4.8\/crtend.o:(.tm_clone_table+0x0): multiple definition of `__TMC_END__'<\/i><\/span><\/p>\n

hello:(.data+0x10): first defined here<\/i><\/span><\/p>\n

\/usr\/bin\/ld: error in hello(.eh_frame); no .eh_frame_hdr table will be created.<\/i><\/span><\/p>\n

collect2: error: ld returned 1 exit status<\/i><\/span><\/p>\n

Chapter 3 discusses programming style. Commenting a program is covered, as well<\/p>\n

as writing clear and simple code.<\/p>\n

Contrary to popular belief, programmers do not spend most of their time writing<\/i><\/span><\/p>\n

programs. Far more time is spent maintaining, upgrading, and debugging existing<\/i><\/span><\/p>\n

code than is ever spent on creating new wo rks. According to Datamation, the<\/i><\/span><\/p>\n

amount of time spent on maintenance is skyrocketing. From 1980 to 1990, the<\/i><\/span><\/p>\n

average number of lines in a typical application went from 23,000 to 1,200,000. The<\/i><\/span><\/p>\n

average system age went from 4.75 to 9.4 years.<\/i><\/span><\/p>\n

What's worse, 74% of the managers surveyed at the 1990 Annual Meeting and<\/i><\/span><\/p>\n

Conference of the Software Maintenance Association reported that they \"have<\/i><\/span><\/p>\n

systems in their department, that have to be maintained by specific individuals<\/i><\/span><\/p>\n

because no one else understands them.\"<\/i><\/span><\/p>\n

Programs written only for the machine have two problems:<\/i><\/span><\/p>\n

:They are difficult to correct because sometimes even the author does not<\/i><\/span><\/p>\n

understand them.<\/i><\/span><\/p>\n

:Modifications and upgrades are difficult to make because the maintenance<\/i><\/span><\/p>\n

programmer must spend a considerable amount of time figuring out what<\/i><\/span><\/p>\n

the program does from its code. Ideally, a program serves two purposes:<\/i><\/span><\/p>\n

first, it presents the computer with a set of instructions, and second, it<\/i><\/span><\/p>\n

provides the programmer with a clear, easy-to -read description of what the<\/i><\/span><\/p>\n

program does\u00a6A working but uncommented program is a time bomb waiting to explode. Sooner or<\/i><\/span><\/p>\n

later, someone will have to fix a bug in the program, modify it, or upgrade it, and the<\/i><\/span><\/p>\n

lack of comments will make the job much more difficult. A well -commented, simple<\/i><\/span><\/p>\n

program is a work of art. Learning how to comment is as important as learning how<\/i><\/span><\/p>\n

to code properly.<\/i><\/span><\/p>\n

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

* hello -- program to print out \"Hello World\". *<\/span><\/p>\n

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

Not an especially earth-shattering program.<\/span><\/p>\n

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

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

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

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

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

Demonstration of a simple program.<\/span><\/p>\n

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

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

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

Runs the program and the message appears.<\/span><\/p>\n

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

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

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

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

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

\/* Tell the world hello *\/<\/span><\/p>\n

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

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

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

To set vim to use abbreviations for Comment Blocks:<\/p>\n

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

:ab #b \/********<\/span><\/p>\n

:ab #e *********\/<\/span><\/p>\n

https:\/\/www.oualline.com\/vim\/10\/vimrc.html<\/a><\/p>\n

In a new doc, press i for insert text, then #b to add the comment stars.<\/p>\n

A variable is a place in the computer's memory for storing a value. C identifies that<\/p>\n

place by the variable name. e.g.<\/p>\n

int account_number; \/* Index for account table *\/<\/span><\/p>\n

int balance_owed; \/* Total owed us (in pennies)*\/<\/span><\/p>\n

(Programming tools like editors, cross -referencers, and searching tools such as<\/i><\/span><\/p>\n

grep can also help you quickly find a variable's definition.)<\/i><\/span><\/p>\n

In order to make programs easier to understand, most programmers indent their<\/p>\n

programs. The general rule for a C program is to indent one level for each new block<\/p>\n

or conditional.<\/p>\n

while (! done)<\/span><\/p>\n

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

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

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

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

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

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

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

total = 0;<\/span><\/p>\n

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

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

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

printf(\"You owe %d dollars\\n\", total);<\/span><\/p>\n

all_totals = all_totals + total;<\/span><\/p>\n

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

Chapter 4 introduces you to simple C statements. Basic variables and the<\/p>\n

assignment statement are covered in detail, along with arithmetic operators +, -, *,<\/p>\n

\/, and %.<\/p>\n

The basic structure of a one-function program is:<\/p>\n

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

* ...Heading comments...<\/span><\/p>\n

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

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

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

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

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

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

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

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

Operator Meaning<\/p>\n

* Multiply<\/p>\n

\/ Divide<\/p>\n

+ Add<\/p>\n

- Subtract<\/p>\n

% Modulus (return the remainder after division)<\/p>\n

The general form of a variable declaration is:<\/p>\n

type name; \/* comment *\/<\/span><\/p>\n

where type is one of the C variable types ( int, float, etc.) and name is any valid<\/p>\n

variable name.<\/p>\n

On most UNIX machines, integers are 32 bits (4 bytes), providing a range of<\/p>\n

2147483647 (2 31 -1) to -2147483648. On the PC, most compilers use only 16 bits (2<\/p>\n

bytes), so the range is 32767 (2 15 -1) to -32768. These sizes are typical. The standard header file limits.h defines constants for the various numerical limits.<\/p>\n

#include <stdio.h> \/*std input,output*\/<\/span><\/p>\n

#include <math.h> \/*required for pow function*\/<\/span><\/p>\n

double answer; \/* integer result of our expression via %f*\/<\/span><\/p>\n

int main() \/* always required main function *\/<\/span><\/p>\n

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

answer = pow(2 , 32) ; \/*cant use ^ for power*\/<\/span><\/p>\n

printf(\"Answer is 2 ^ 32 or %.0f\\n\", answer ); \/*to give no decimals*\/<\/span><\/p>\n

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

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

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

Answer is 2 ^ 32 or 4294967296<\/span><\/p>\n

\"\"<\/p>\n

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

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

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

\/* term used in two expressions *\/<\/span><\/p>\n

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

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

term = 3 * 5;<\/span><\/p>\n

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

printf(\"Three times %d is %d\\n\", term, 3*term);<\/span><\/p>\n

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

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

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

Twice 15 is 30<\/span><\/p>\n

Three times 15 is 45<\/span><\/p>\n

The division operator is special. There is a vast difference between an integer divide<\/i><\/span><\/p>\n

and a floating-point divide. In an integer divide, the result is truncated (any<\/i><\/span><\/p>\n

fractional part is discarded). So the value of 19\/10 is 1.<\/i><\/span><\/p>\n

If either the d ivisor or the dividend is a floating-point number, a floating -point divide<\/i><\/span><\/p>\n

is executed. So 19.0\/10.0 is 1.9. (19\/10.0 and 19.0\/10 are also floating -point<\/i><\/span><\/p>\n

divides; however, 19.0\/10.0 is preferred for clarity.)<\/i><\/span><\/p>\n

int integer; \/* an integer *\/<\/i><\/span><\/p>\n

float floating; \/* a floating-point number *\/<\/i><\/span><\/p>\n

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

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

floating = 1.0 \/ 2.0; \/* assign \"floating\" 0.5 *\/<\/i><\/span><\/p>\n

integer = 1 \/ 3; \/* assign integer 0 *\/<\/i><\/span><\/p>\n

floating = (1 \/ 2) + (1 \/ 2); \/* assign floating 0.0 *\/<\/i><\/span><\/p>\n

floating = 3.0 \/ 2.0; \/* assign floating 1.5 *\/<\/i><\/span><\/p>\n

integer = floating; \/* assign integer 1 *\/<\/i><\/span><\/p>\n

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

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

Question 4 -3: Why does 2 + 2 = 5928? (Your results may vary. See Example 4 -5.)<\/p>\n

\/*two.c]*\/<\/span><\/p>\n

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

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

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

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

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

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

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

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

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

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

The answer is 1866226024<\/b><\/span><\/p>\n

The printf function has no \"answer\" def to call for %d:<\/p>\n

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

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

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

Chapter 5 covers arrays and more co mplex variables. Shorthand operators such as<\/p>\n

++ and %= are also described.<\/p>\n

Chapter 6 explains simple decision statements including if, else, and for. A<\/p>\n

discussion of == versus = is presented.<\/p>\n

Chapter 7 takes you through all the necessary steps to create a simple program<\/p>\n

from specification through release. Structured programming, fast prototyping, and<\/p>\n

debugging are also discussed.<\/p>\n

Chapter 8 describes additional control statements. Included are while, break, and\u00a0continue. The switch statement is discussed in detail.<\/p>\n

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

Chapter 10 describes the C preprocessor, which gives the prog rammer tremendous<\/p>\n

flexibility in writing code. The chapter also provides the programmer with a<\/p>\n

tremendous number of ways to mess up. Simple rules that help keep the<\/p>\n

preprocessor from becoming a problem are described.<\/p>\n

Chapter 11 discusses the logical C operators that work on bits.<\/p>\n

Chapter 12 explains structures and other advanced types. The sizeof operator an d<\/p>\n

the enum type are included.<\/p>\n

Chapter 13 introduces C pointer variables and shows some of their uses.<\/p>\n

Chapter 14 describes both buffered and unbuffered input\/output. ASCII and binary<\/p>\n

files are discussed, and you are shown how to construct a simple file.<\/p>\n

Chapter 15 describes how to de bug a program, as well as how to use an interactive<\/p>\n

debugger. You are shown not only how to debug a program, but also how to write a<\/p>\n

program so that it is easy to debug. This chapter also describes many optimization<\/p>\n

techniques for making your program run faster and more efficiently.<\/p>\n

Chapter 16 uses a simple decimal floating-point format to introduce you to the<\/p>\n

problems inherent in floating point, such as roundoff error, precision lo ss, overflow,<\/p>\n

and underflow.<\/p>\n

Chapter 17 describes advanced uses of pointers for constructing dynamic structures<\/p>\n

such as linked lists and trees.<\/p>\n

Chapter 18 shows how to split a program into several files and use modular<\/p>\n

programming techniques. The make utility is explained in more detail.<\/p>\n

Chapter 19 describes the old, pre -ANSI C language and associated compilers.<\/p>\n

Although such compilers are rare today, a lot of code was written for them and there<\/p>\n

are still a large number of programs out there that use the old syntax.<\/p>\n

Chapter 20 describes the problems that can occur when you port a program (move<\/p>\n

it from one machine to another).<\/p>\n

Chapter 21 describes the do\/while statement, the , operator, and the ? and :<\/p>\n

operators.<\/p>\n

Chapter 22 details the steps necessary to take a complex program from conception<\/p>\n

to completion. Information -hiding and modular programming techniques are<\/p>\n

emphasized.<\/p>\n

Chapter 23 lists some programming adages that will help you construct good C<\/p>\n

programs.<\/p>\n","protected":false},"excerpt":{"rendered":"

<\/div>\n

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

<\/div>\n

https:\/\/www.oualline.com\/ Chapter 1 gives a brief description of the C language and its use. This chapter\u00a0includes some background on the history of the language. There is only one way to learn how to program and that is to write programs. You'll learn a lot more by writing and debugging programs than you ever will by ...\u00a0 Chapters 1-4 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-3051","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\/3051","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=3051"}],"version-history":[{"count":2,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/3051\/revisions"}],"predecessor-version":[{"id":10148,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/3051\/revisions\/10148"}],"wp:attachment":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/media?parent=3051"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/categories?post=3051"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/tags?post=3051"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}