C语言编程第四版精华

5星 · 超过95%的资源需积分: 10 188 浏览量更新于2024-07-23 1 收藏 47.39MB PDF 举报

"A_Book_on_C_4th_Edition" 《A Book on C》是第四版的一本关于C语言编程的书籍，由AI Kelley和Ira Pohl合著，他们来自加州大学圣克鲁斯分校。这本书是为那些希望深入理解和掌握C语言的读者准备的。作为一本经典的C语言教程，它涵盖了C语言的基础到高级概念，旨在帮助读者从初学者到熟练掌握编程技巧。在第四版中，作者们更新了内容以符合最新的C语言标准，包括C99和可能的部分C11特性。本书可能包括以下关键知识点： 1. C语言基础：介绍C语言的基本语法，如变量、数据类型、运算符、控制结构（如if语句、switch语句、循环）以及函数的使用。 2. 指针与内存管理：详细讲解C语言的核心部分——指针，如何使用指针操作内存，包括动态内存分配和释放。 3. 数组与字符串：讨论数组的声明、初始化和操作，以及C语言中的字符串处理，如字符串常量和字符数组。 4. 结构体与联合体：解释如何定义和使用结构体和联合体来组合不同类型的数据，以及如何进行结构体指针操作。 5. 函数指针与回调：介绍函数指针的概念，以及如何使用它们来实现回调机制。 6. 预处理器：涵盖宏定义、条件编译等预处理器指令的使用。 7. 文件操作：教授如何读写文件，包括打开、关闭文件，以及文件输入/输出流的使用。 8. 错误处理：讨论错误检测和处理策略，包括如何使用errno和assert宏。 9. 位操作：介绍位运算符，如按位与、或、非、左移和右移，以及它们在低级编程中的应用。 10. 标准库和标准头文件：讲解C标准库中的各种函数，如数学函数、字符串处理函数、输入输出函数等。 11. 程序调试：指导读者如何使用调试工具来定位和修复程序中的错误。 12. 性能优化：讨论C语言编程中的性能考虑，包括内存管理和算法效率。 13. C语言的发展和应用：简述C语言的历史，以及它在系统编程、嵌入式开发和其他领域的广泛应用。这本书不仅适合初学者，也适用于有一定经验的程序员想要复习或深入理解C语言的细节。此外，书中的练习题和示例代码提供了丰富的实践机会，帮助读者巩固理论知识并提升实际编程技能。购买大量此书的信息可以在Pearson Education Corporate Sales Division找到，他们提供团体购买的折扣。读者也可以通过访问ADDISON-WESLEY的网站获取更多相关信息和支持。

Chapter 1

Overview

III

pri

ntfO

The C

system

contains a

standard

library

functions

that

can be

used

programs.

This is a function from the library

that

prints

the screen.

included the

header

file

sldio.h

because

provides

certain

information

the

compiler

about

the

function

printfO.

(See

exercise 14, on page 63.)

III "from

sea

shining

(\n"

A string constant

C is a series

characters surrounded by double quotes. This string

argument

to the function

pri

ntfO,

and

controls what gets printed. The two

characters

the

end

the

string (read backs lash

represent

a single

character

called newline. It is a nonprinting character.

advances the cursor

the screen

the

beginning

the next line.

III

printf("from

sea

shining

(\n")

This is a call to

the

pri

ntfO

function. In a program, the name

a function followed

parentheses

causes the function to be called, or invoked.

appropriate, the paren-

theses may contain arguments. Here, when the

pri

ntfO

function is invoked,

prints

its argument, a string constant, on the screen.

III

printf("from

sea

shining

(\n");

This is a statement. Many statements in C

end

vvith

a semicolon.

III

return

This is a

retu

rn statement.

causes the value zero to be returned to the operating sys-

tem, which

turn

may

use

the value

some way,

but

not

required to do so.

(See

Sec-

tion 12.7, "Returning the Status,"

page 579, for further discussion.) Our

use

this

return

statement

keeps the compiler happy.

we do

not

use it, the compiler will com-

plain.

(See

exercise

on page 60.) One

the principal rnles

programming is "keep

your compiler happy."

III

}

The right brace matches the left brace above, ending the function definition for main O .

•

1.2 v Program Output

The

function

pri

ntfO

acts to

continuously

across the screen.

moves

the

cursor

the

start

new

line

when

a newline

character

read.

The

screen

is a

two-dimensional display

that

prints

from

left

right

and

top to

bottom.

read-

able,

output

must

appear properly spaced

the screen.

can rewrite

our

first program as follows:

#include

<stdio.h>

ma;

n(voi

{

printf("from

sea

");

printf("shining

C");

printfCII\n");

return

}

Although

different

from

the

first version,

will

produce

the

same

o~tput.

Each

time

pri

ntfO

called,

printing

begins

the

position

w~ere

the

call,

pri

ntfO

left

off. If we

want

our

phrase

three

hnes, we

can

use

newlme

characters.

#include

<stdio.h>

int

mainCvoid)

{

pri

ntf(,'from

sea\n");

printf("to

shining\n(\n");

return

}

When executed, this program will

from

sea

shining

(

10 Chapter

An Overview

Let

write one additional variation

this program, one

that

will box

the

phrase

rectangle

asterisks. It will show how

each

character, including blanks

and

newline

characters, is Significant, and when

is executed,

will give some sense

the screen

proportions.

In file sea2.c

1.3

#include

<stdio.h>

int

main(void)

{

}

printf("\n\n\n\n\n\n\n\n\n\n");

p r i n t f (

'i<'1"h~

'i"hh~

'I,

'{doh"",

,',

'/d,

* \

nil)

;

pri

ntf("

from

sea

i'\n")

;

pri

ntf("

shi

C >"\n") ;

ntf

"'***'~id'*i"hhh~"''''*i''~*1d''~j(\n'')

;

printf("\n\n\n\n\n\n\n\n\n\n");

return

Variables, ExpreSSions, and

Assignment

will write a

program

to convert the distance

marathon

miles

and

yards

kilometers.

English units, a marathon is defined to be 26 miles and 385 yards. These

numbers

are integers. To convert miles to kilometers,

multiply by the conversion

factor

1.609, a real number. In memory, computers represent integers differently

from

reals. To convert yards to miles, we divide by 1760.0, and, as we shall see,

is essential

represent

this

number

as a real

rather

than as an integer.

Our conversion program

will

use variables capable of storing integer values

and

real

values, In

variables

must

be declared,

named,

the beginning

the program.

A variable name, also called

identifier, consists

a sequence

letters, digits,

and

underscores,

but

may

not

start

with a digit. Identifiers should be chosen to reflect their

use

the

program. In this way,

they

serve

documentation, making the

program

more readable.

1.3 " Variables, Expressions, and Assignment

In file marathon.c

f a marathon

kilometers.

Ii' The di

stance

#include

<stdio.h>

int

main(void)

{

}

float

miles,

yards;

kilometers;

miles

26;

yards

385; ,

kilometers

1.609

printf("\nA

marathon

return

(miles

yards

1760.0);

kilometers.\n\n",

kilometers);

The

output

the

program

is.

marathon

42.185970

kilometers.

•

Dissection

the marathon Program

•

The

distance

a marathon

kilometers.

Ii'

I is a comment and is ignored by the

Anyt~ing

written

betwe~nt~e

~~:~~~:

star~

vvith

a comment are listed

the index.

compller.

All

programs m s ,

•

int

miles,

yards;

. d ts

end

with a semicolon. ;

a key-

This

a declaration. DeclaratIOns

::a~~r:~~

language.

informs the compiler that

word

and

is one of

t~e

f~ndamefnta

ty?nt

and

are to take

integer values. Thus, the

the variables followmg

are 0 type 1

variables

and

yards

in this

program

are of type 1

nt.

•

float

kilometers;

. . k word

and

one

the

fundamental

types

the

This is a

de~la:atIOn~:~

~~~~~l:r

~at

the variables following it are of type

f.loat

and

language.

arms

the

variable ki 1

ometers

this

program

type

are to

take

real

va ues. us,

float.

Chapter 1

Overview

miles

26;

yards

385;

These are assignment statements. The equal sign is

assignment operator. The two

numbers

and

385 are integer

constants.

The value 26 is assigned to

the

variable

es.

The value 385 is assigned to the variable

yards.

kilometers

1.609

(miles

yards

1760.0);

This is

assignment statement. The value

the

expression

the right side

the

equal sign is assigned to the variable ki 1

ometers.

The operators

''<,

and

stand

for

multiplication, addition,

and

division, respectively. Operations inside

parentheses

are

performed first. Because division

has

higher precedence

than

addition, the value of the

subexpression

yards

1760.0

calculated

first. (See Appendix

"Operator

Precedence

and

Associativity.")

That

value is added to the value of the variable

to produce a value

that

then

multi-

plied

609. This final value is

then

assigned

the variable ki

lometers.

printf("\nA

marathon

kilometers.\n\n",

kilometers);

This

statement

that

invokes,

calls,

the

pri

ntfO

function.

The

function

pri

ntfO

can

have a variable

number

arguments.

The first

argument

is always a

string, called the

control string. The control string

this example is

"\nA

marathon

kilometers.\n\n"

the

first

argument to

the

function

pri

ntfO.

Inside this string is

the

conversion

specification, or format,

%f.

The formats

a control string, if any, are

matched

with

the remaining arguments

the

pri

ntfO

function.

this case,

matched

'\vith the

argument

kilometers.

Its effect is to

the

value of the variable

kilometers

as a

floating-point

number

and insert it into the

stream

where the format

occurs .

•

Certain words, called keywords are reserved

and

CalIDOt

used

by the programmer

names

of variables. For example, i

nt,

float,

and

double

are keywords. A table of

keywords

appears

Section 2.4, "Keywords,"

page 77. Other

names

are knowll to

the

system

and

normally

would

not

redefined

the

programmer.

The

name

pri

ntf

example. Because

pri

ntf

the

name

of a

function

the

standard

library,

usually is not

used

as the name of a variable.

1.4

The

Use of

#defi

and

ncl

ude

decimal point

a number indicates

that

is a floating-point constant

rather

than

an mteger constant. Thus, the numbers 37

and

37.0

would be treated differently in a

progran:. Although there are three floating

types-float,

double,

and

long

doub 1

and varIables can

declared to be

any of these types, floating constants are auto-

matically of type dou b 1 e.

Expressions

typi~ally

are

f~und

the

right

side

assignment

operators

and

arguments to functlOns. The

SImplest expressions are

just

constants

such

as 385 d

1760.0,

which were

used

in the previous program. The name of a variable itself an

d . d can e

conSI ere

expreSSlOn, an meaningful combinations of

operators

with variables

and constants are also expressions.

!he

evalu.a:i~n

expr~ssions

can

involve

conversion

rules. This

important

pomt. The

dlVIslOn

two mtegers results

integer value, and any remainder is dis-

carded.

T~us,

for

exam~l~,

the

expre~sion

7/2

has

value

The expression

7.0/2,

~owever,

a doubl.e

dlv~ded

lnt.

When the expression

7.0/2

is evaluated, the

value of the expresslOn

2.1S automatically converted to a doubl e, causing

7.0/2

to have

the value 3.5. In the prevlOus program, suppose

that

the

statement

kilometers

1.609

(miles

yards

1760.0);

changed to

1.609

(miles

yards

1760);

lea~s

to a

progra~

bug. Because

the

variable

yards

is of type i

and

has

value

the mteger expresslOn

s integer division, and the result is the i

value

This is

not

what is wanted. Use

constant

1760.0,

which is of type

double,

corrects the bug.

The Use

#defi

ne and

ncl ude

compi~er

~as

a preprocessor built into it. Lines

that

begin '\vith a # are called pre-

~eSSIYla

dIrectIVes.

the lines

LIIVJIT

100

3.14159

Chapter 1 V

Overview

occur

a file

that

is being compiled, the preprocessor first changes all occurrences

the identifier

LIMIT

to 100

and

all occurrences

the

identifier PI to

3.14159,

except

quoted

strings

and

in comments. The identifiers

LIMIT

and

are

called symbolic

constants.

#defi

ne line can occur anywhere

a program.

affects only the lines

the file

that

come after it.

Normally, all

#defi

ne lines are placed

the beginning

the file.

convention, all

identifiers

that

are

be changed by the preprocessor are

'\tv-ritten

capital letters. The

contents

quoted

strings are never changed

the preprocessor. For example,

the

statement

pri

ntf("

%f\n

PI);

only

the

second

will

changed

the

above

#defi

ne directives

the

preproces-

sor. The

use

symbolic

constants

program

make

readable. More impor-

tantly,

a constant has

been

defined symbolically

means of the

#defi

ne facility

and

used

throughout

a program,

is easy

change

later,

necessary. For example,

physics the

letter

c is often

used

to designate the

speed

light, which is apprOximately

299792.458

lan/sec.

write

#define

299792.458

speed

light

km/sec

and

then

use

throughout

thousands

lines

code

represent

symbolically the

constant

299792.458,

will

easy to change

the

code

when

a new phYSical experi-

ment

produces

better

value for the

speed

light. All the code is

updated

simply

changing the constant

the

#defi

ne line.

In a program, a line

such

#include

"my_file.h"

is a preprocessing directive

that

causes a copy

the file my_file.h

be included

this

point

the file

when

compilation occurs. A

ncl

ude line can occur anywhere

a file,

though

is typically at the head

the file. The quotes surrounding the

name

the file

are necessary. An include file, also called a

header

file,

can

contain

#defi

ne lines

and

other

ncl

ude lines.

convention, the

names

header

files

end

.h.

The C

system

provides a

number

standard

header

files. Some examples are stdio.h,

string.h,

and

math.h. These files contain the declarations

functions

the

standard

library, macros,

structure

templates,

and

other

programming elements

that

are

com-

monly used. As we have already seen, the preprocessing directive

#include

<stdio.h>

causes a copy

the standard

header

file stdio.h to be included

the code

when

compi-

lation

occurs.

ANSI

whenever the functions

pri

ntfO

scanfO

are

used,

the

1.4 V The

Use

#defi

and #i ncl ude

1 5

standard

header

file stdio.h

should

be included. This file contains the declarations,

more specifically,

the

function prototypes,

these

functions.

(See

Section

"Func-

tions,"

page 29, for further discussion.)

The

Santa Cruz campus

the University

California overlooks the Monterey

Bay

the Pacific Ocean

and

some

the ocean

just

the

northwest

the bay.

call

this

part

the

ocean

that

is visible from the campus the "Pacific Sea." To illustrate how

the

nc 1 ude facility works, we will 'write a

program

that

prints

the area

the

Pacific

Sea

various

units

measure. First, we create a

header

file

and

put

the following

lines:

file

pacificsea.h

#include

<stdio.h>

#define

AREA

SO-MILES_PE~SO-KILOMETER

SO-FEET_PE~SO-MILE

SO-INCH

ES_PER_SQ_FOOT

ACRES_PER_SO-MILE

we write the function main 0

a .c file.

Measuring

the

Pacific

Sea.

#include

"pacificsea.h"

int

main(void)

{

2337

0.3861021585424458

(5280

5280)

144

640

const

int

double

pacific_sea

AREA;

kilometers

1,/

acres,

sq_miles,

sq_feet,

sq_inches;

printf("\nThe

Pacific

Sea

covers

area");

printf("

square

kilometers.\n",

pacificsea);

sq_miles

SO-MILES_PER_SO-KILOMETER

pacific_sea;

sq_feet

SO-FEET_PER_SO-MILE

sq_miles;

sq_inches

SO-INCHES_PER_SO-FOOT

sq_feet;

acres

ACRES_PER_SO-MILE

-{,

sq_mi 1

es;

printf("In

other

units

measure

this

is:\n\n");

printf("%22.7e

acres\n",

acres);

printf("%22.7e

square

miles\n",

sq_miles);

printf("%22.7e

square

feet\n",

sq_feet);

printf("%22.7e

square

inches\n\n",

sq_inches);

return

-----------~--~~~~~~

--~~-------

Chapter

1 T An Overview

Now

our

program

written

two files, a

file

and

file. The

output

this

pro-

gram is

The

Pacific

Sea

covers

area

2337

square

kilometers.

other

units

measure

this

is:

5.7748528e+05

acres

9.0232074e+02

square

miles

2.515525ge+10

square

feet

3.6223572e+12

square

inches

The new programming ideas are described

the following dissection table.

•

Dissection

the pacific_sea Program

III

#include

"pacific_sea.h"

This

ncl

ude line is a preprocessing directive.

causes a copy

the filepacificsea.h

included when the

program

is compiled. Because this file contains the line

#include

<stdio.h>

the

preprocessor

expands the line

turn

and

includes a copy

the

standard

header

file stdio.h

the code as well.

have included stdio.h because

are using

pri

ntfO.

Five

symbolic

constants

are defined

paci(icsea.h.

III

#define

AREA

2337

This

#defi

ne line is a preprocessing directive.

causes the preprocessor

replace all

occurrences

the identifier

AREA

by 2337

the

rest

the file.

convention, capital

letters

are

used

for

identifiers

that

will

changed

the

preprocessor.

some

future time a new

map

made

and

a new figure for

the

area

the Pacific Sea is com-

puted, only this line

needs

to be changed

update

the program.

III

#define

0.3861021585424458

The floating

constant

0.3861021585424458

is a conversion factor. The

use

a sym-

bolic name for the

constant

makes the

program

readable.

1.4 T The

Use

#defi

and

#i ncl ude

III

#define

(5280

t, 5280)

The

preprocessor

changes occurrences

the first sequence

characters

into

the

sec-

ond.

reader

this

program

knows

that

there

are

5280

feet

a mile,

then

that

reader

will quickly

recognize

that

this

line

code

correct.

Instead

(5280

,',

5280), we could have

vVTitten

27878400; because C compilers expand

constant

expres-

sions during compilation, run-time efficiency is

not

lost. Although the

parentheses

are

not

necessary,

is considered good programming practice

use

them. For technical

reasons

parentheses

are

often

needed

around

symbolic expressions.

(See

Section 8.3,

"Macros with Arguments,"

page 368.)

l1li

canst

int

pacific_sea

AREA;

kilometers

When compiled, the preprocessor first changes

AREA

2337. The compiler

then

inter-

prets

this line as a declaration

the identifier

paci

c_sea.

The variable is declared

as type i

and

initialized to the value 2337. The keyword

canst

is a type qualifier

that

has

been newly introduced

ANSI

means

that

the associated variable

can

ini-

tialized,

but

cannot thereafter have its value changed.

(See

exercise 18,

page 65.) On

some systems this means

that

the variable may be

stored

ROM

(read-only memory).

III

double

acres,

sq_miles,

sq_inches;

These variables are defined to

type

double.

ANSI

floating types are

float,

doub 1 e,

and

long

doub 1

long

double

does

not

exist

traditional

Each

these

types is

used

to store real values. Typically. a

vyill

store 6 significant digits

and

doub

1 e will store 15 significant digits.

Along

double

will store

least as many signif-

icant digits as a daub 1

(See

Section 3.6, "The Floating Types,"

page 119.)

III

printf("%22.7e

acres\n",

acres);

This

statement

causes the line

5.7748528e+05

acres

printed. The

number

is vvritten

scientific

notation

and

interpreted

mean

5.7748528

Numbers written

this

way are

said

be written

e-format. The

conversion specification

causes the system to

a floating expression in

e-for-

mat

vvith default spacing. A format

the form %m.ne, where m

and

n are positive inte-

gers, causes the

system

a floating expression

e-format

m spaces total,

with n digits

the right

the decimal paint.

(See

Section 11.1, "The

Output

Function

pri

ntfO,"

page 493.)

•

剩余375页未读，继续阅读

zheng1401

粉丝: 0
资源: 3

C语言编程第四版精华

Pro_CSharp_5.0_and_the_.NET_4.5_Framework_6th_edition

4th_edition_examples

Elements of forecasting 4th edition_solution

A First Book of C++, 4th Edition

A Primer on Scientific Programming with Python, 5th Edition

Mastering Swift 4, 4th Edition

Beginning JavaScript, 4th Edition

Professional C++, 4th Edition

Starting_Forth on iForth SwiftForth

Learning Cocoa with Objective-C, 4th Edition

最新资源