C语言编程教程：第1-2章概要

Programing

Language

需积分: 9 187 浏览量更新于2024-07-27 收藏 1.84MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"《C Programming Language 2nd》是一本介绍C语言编程的教程，包含多个章节，涉及从基础到进阶的多个主题。书中详细讲解了C语言的基本概念、语法和常用编程结构，旨在帮助读者逐步掌握C语言编程技能。" 在本书中，作者首先介绍了C语言的基本入门知识。第1章“教程介绍”涵盖了以下几个关键点： 1.1 “开始编程”部分，引导读者如何启动C语言的编程环境，并进行简单的程序编写。 1.2 “变量与算术表达式”讲述了C语言中的变量定义和基本算术运算。 1.3 “for语句”的讲解，这是C语言中常用的循环控制结构。 1.4 “符号常量”的概念，它允许程序员用有意义的名称替换数值。 1.5 “字符输入与输出”部分，包括文件复制、字符计数、行计数和单词计数等实用示例，帮助理解输入/输出操作。 1.6 “数组”的介绍，讲解了如何存储和操作一组相同类型的数据。 1.7 “函数”的概念，是模块化编程的基础，用于组织代码。 1.8 “参数调用（Call by Value）”，解释了函数参数传递的工作原理。 1.9 “字符数组”，如字符串的处理。 1.10 “外部变量和作用域”，讨论了变量在不同代码段中的可见性和生命周期。第2章“类型、运算符和表达式”深入探讨了C语言的核心要素： 2.1 “变量名”规定了如何为变量命名。 2.2 “数据类型和大小”介绍了C语言中的基本数据类型及其内存占用。 2.3 “常量”涵盖了各种类型的常量，如整型、浮点型和字符型。 2.4 “声明”解释了如何声明变量和函数。 2.5 到2.12章节详细讨论了各种运算符，包括算术、关系、逻辑、类型转换、增量/减量、位运算、赋值运算和条件表达式，以及它们的优先级和求值顺序。第3章“控制流程”讲述了程序的流程控制结构： 3.1 “语句和块”介绍了C语言中的基本语句结构。 3.2 “if-else”和3.3 “else-if”阐述了条件判断。 3.4 “switch”语句提供了多路选择的控制结构。 3.5 和3.6 “while”和“for”循环，以及“do-while”循环，是控制重复执行的关键。 3.7 “break”和“continue”语句用于控制循环中的流程。 3.8 “goto”和标签，虽然不推荐，但在某些情况下可以用来跳转到程序的其他位置。第4章“函数和程序结构”进一步深入到函数的使用和程序的组织架构，可能涉及函数的声明、定义、重载、递归等方面，以及头文件、预处理器指令和模块化编程的概念。这本书对于初学者和有经验的程序员来说都是宝贵的资源，它详细地介绍了C语言的基础知识，并通过丰富的示例帮助读者理解和应用这些概念。通过学习本书，读者能够构建扎实的C语言编程基础，为解决更复杂的编程问题打下坚实的基础。

资源详情

资源推荐

{

intfahr;

for(fahr=0;fahr<=300;fahr=fahr+20)

printf("%3d%6.1f\n",fahr,(5.0/9.0)*(fahr-32));

}

This produces the same answers, but it certainly looks different. One major change is the

elimination of most of the variables; only

fahr

remains, and we have made it an

int

. The

lower and upper limits and the step size appear only as constants in the

for

statement, itself a

new construction, and the expression that computes the Celsius temperature now appears as

thethirdargumentof

printf

insteadofaseparateassignmentstatement.

This last change is an instance of a general rule - in any context where it is permissible to use

the value of some type, you can use a more complicated expression of that type. Since the

third argument of

printf

must be a floating-point value to match the

%6.1f

, any floating-

pointexpressioncanoccurhere.

The

for

statement is a loop, a generalization of the

while

. If you compare it to the earlier

while

, its operation should be clear. Within the parentheses, there are three parts, separated

bysemicolons.Thefirstpart,theinitialization

fahr=0

isdoneonce,beforetheloopproperisentered.Thesecondpartisthe

testorconditionthatcontrolstheloop:

fahr<=300

This condition is evaluated; if it is true, the body of the loop (here a single

ptintf

) is

executed.Thentheincrementstep

fahr=fahr+20

is executed, and the condition re-evaluated. The loop terminates if the condition has become

false. As with the

while

, the body of the loop can be a single statement or a group of

statements enclosed in braces. The initialization, condition and increment can be any

expressions.

The choice between

while

and

for

is arbitrary, based on which seems clearer. The

for

usually appropriate for loops in which the initialization and increment are single statements

and logically related, since it is more compact than

while

and it keeps the loop control

statementstogetherinoneplace.

Exercise1-5.Modifythetemperatureconversionprogramtoprintthetableinreverseorder,

thatis,from300degreesto0.

1.4SymbolicConstants

A final observation before we leave temperature conversion forever. It's bad practice to bury

``magic numbers''like 300 and 20 in a program; they convey little information to someone

who might have to read the program later, and they are hard to change in a systematic way.

One way to deal with magic numbers is to give them meaningful names. A

#define

line

definesasymbolicnameorsymbolicconstanttobeaparticularstringofcharacters:



#define

namereplacementlist

Thereafter, any occurrence of name (not in quotes and not part of another name) will be

replaced by the corresponding replacement text. The name has the same form as a variable

name: a sequence of letters and digits that begins with a letter. The replacement text can be

anysequenceofcharacters;itisnotlimitedtonumbers.

#include<stdio.h>

#defineLOWER0/*lowerlimitoftable*/

#defineUPPER300/*upperlimit*/

#defineSTEP20/*stepsize*/

/*printFahrenheit-Celsiustable*/

main()

{

intfahr;

for(fahr=LOWER;fahr<=UPPER;fahr=fahr+STEP)

printf("%3d%6.1f\n",fahr,(5.0/9.0)*(fahr-32));

}

The quantities

LOWER

UPPER

and

STEP

are symbolic constants, not variables, so they do not

appear in declarations. Symbolic constant names are conventionally written in upper case so

they can ber readily distinguished from lower case variable names. Notice that there is no

semicolonattheendofa

#define

line.

1.5CharacterInputandOutput

We are going to consider a family of related programs for processing character data. You will

findthatmanyprogramsarejustexpandedversionsoftheprototypesthatwediscusshere.

The model of input and output supported by the standard library is very simple. Text input or

output, regardless of where it originates or where it goes to, is dealt with as streams of

characters. A text stream is a sequence of characters divided into lines; each line consists of

zero or more characters followed by a newline character. It is the responsibility of the library

to make each input or output stream confirm this model; the C programmer using the library

neednotworryabouthowlinesarerepresentedoutsidetheprogram.

The standard library provides several functions for reading or writing one character at a time,

of which

getchar

and

putchar

are the simplest. Each time it is called,

getchar

reads the

nextinputcharacterfromatextstreamandreturnsthatasitsvalue.Thatis,after

c=getchar();

the variable

contains the next character of input. The characters normally come from the

keyboard;inputfromfilesisdiscussedinChapter7.

Thefunction

putchar

printsacharactereachtimeitiscalled:

putchar(c);

prints the contents of the integer variable

as a character, usually on the screen. Calls to

putchar

and

printf

may be interleaved; the output will appear in the order in which the

callsaremade.

1.5.1FileCopying

Given

getchar

and

putchar

, you can write a surprising amount of useful code without

knowing anything more about input and output. The simplest example is a program that

copiesitsinputtoitsoutputonecharacteratatime:

readacharacter

while(charaterisnotend-of-fileindicator)

outputthecharacterjustread

readacharacter

ConvertingthisintoCgives:

#include<stdio.h>

/*copyinputtooutput;1stversion*/

main()

{

intc;

c=getchar();

while(c!=EOF){

putchar(c);

c=getchar();

}

}

Therelationaloperator

means``notequalto''.

What appears to be a character on the keyboard or screen is of course, like everything else,

stored internally just as a bit pattern. The type

char

is specifically meant for storing such

character data, but any integer type can be used. We used

int

for a subtle but important

reason.

The problem is distinguishing the end of input from valid data. The solution is that

getchar

returns a distinctive value when there is no more input, a value that cannot be confused with

any real character. This value is called

EOF

, for ``end of file''. We must declare

to be a type

big enough to hold any value that

getchar

returns. We can't use

char

since

must be big

enoughtohold

EOF

inadditiontoanypossible

char

.Thereforeweuse

int

.

EOF

is an integer defined in <stdio.h>, but the specific numeric value doesn't matter as long as

it is not the same as any

char

value. By using the symbolic constant, we are assured that

nothingintheprogramdependsonthespecificnumericvalue.

TheprogramforcopyingwouldbewrittenmoreconciselybyexperiencedCprogrammers.In

C,anyassignment,suchas

c=getchar();

is an expression and has a value, which is the value of the left hand side after the assignment.

This means that a assignment can appear as part of a larger expression. If the assignment of a

character to

is put inside the test part of a

while

loop, the copy program can be written this

way:

#include<stdio.h>

/*copyinputtooutput;2ndversion*/

main()

{

intc;

while((c=getchar())!=EOF)

putchar(c);

}

The

while

gets a character, assigns it to

, and then tests whether the character was the end-

of-file signal. If it was not, the body of the

while

is executed, printing the character. The

while

then repeats. When the end of the input is finally reached, the

while

terminates and so

does

main

.

This version centralizes the input - there is now only one reference to

getchar

- and shrinks

the program. The resulting program is more compact, and, once the idiom is mastered, easier

to read. You'll see this style often. (It's possible to get carried away and create impenetrable

code,however,atendencythatwewilltrytocurb.)

The parentheses around the assignment, within the condition are necessary. The precedence

is higher than that of

, which means that in the absence of parentheses the relational

test

wouldbedonebeforetheassignment

.Sothestatement

c=getchar()!=EOF

isequivalentto

c=(getchar()!=EOF)

This has the undesired effect of setting

to 0 or 1, depending on whether or not the call of

getchar

returnedendoffile.(MoreonthisinChapter2.)

Exercsise1-6.Verifythattheexpression

getchar()!=EOF

is0or1.

Exercise1-7.Writeaprogramtoprintthevalueof

EOF

.

1.5.2CharacterCounting

Thenextprogramcountscharacters;itissimilartothecopyprogram.

#include<stdio.h>

/*countcharactersininput;1stversion*/

main()

{

longnc;

nc=0;

while(getchar()!=EOF)

++nc;

printf("%ld\n",nc);

}

Thestatement

++nc;

presents a new operator,

, which means increment by one. You could instead write

nc =

nc + 1

but

++nc

is more concise and often more efficient. There is a corresponding operator

todecrementby1.Theoperators

and

canbeeitherprefixoperators(

++nc

)orpostfix

operators (

nc++

); these two forms have different values in expressions, as will be shown in

Chapter2, but

++nc

and

nc++

both increment

. For the moment we will will stick to the

prefixform.

The character counting program accumulates its count in a

long

variable instead of an int.

long

integers are at least 32 bits. Although on some machines,

int

and

long

are the same

size, on others an

int

is 16 bits, with a maximum value of 32767, and it would take relatively

little input to overflow an

int

counter. The conversion specification

%ld

tells

printf

that the

correspondingargumentisa

long

integer.

It may be possible to cope with even bigger numbers by using a

double

(double precision

float

). We will also use a

for

statement instead of a

while

, to illustrate another way to write

theloop.

#include<stdio.h>

/*countcharactersininput;2ndversion*/

main()

{

doublenc;

for(nc=0;gechar()!=EOF;++nc)

;

printf("%.0f\n",nc);

}

printf

uses

for both

float

and

double

;

%.0f

suppresses the printing of the decimal point

andthefractionpart,whichiszero.

The body of this

for

loop is empty, because all the work is done in the test and increment

parts. But the grammatical rules of C require that a

for

statement have a body. The isolated

semicolon, called a null statement, is there to satisfy that requirement. We put it on a separate

linetomakeitvisible.

Before we leave the character counting program, observe that if the input contains no

characters, the

while

for

test fails on the very first call to

getchar

, and the program

produces zero, the right answer. This is important. One of the nice things about

while

and

for

is that they test at the top of the loop, before proceeding with the body. If there is nothing

to do, nothing is done, even if that means never going through the loop body. Programs

should act intelligently when given zero-length input. The

while

and

for

statements help

ensurethatprogramsdoreasonablethingswithboundaryconditions.

1.5.3LineCounting

The next program counts input lines. As we mentioned above, the standard library ensures

that an input text stream appears as a sequence of lines, each terminated by a newline. Hence,

countinglinesisjustcountingnewlines:

#include<stdio.h>

/*countlinesininput*/

main()

{

剩余213页未读，继续阅读

庐陵小松

粉丝: 1
资源: 7

C语言编程教程：第1-2章概要

The C Programming Language 2nd Edition（英文原版，包含答案）

The C Programming Language 2nd.pdf

《The C Programming Language》---2nd---英文PDF

the c programming language 2nd

the c programming language 2nd中文版

the rust programming language 2nd edition pdf

the c programming language (2nd edition), by brian w. kernighan and dennis m

github c语言学习

c语言自学先看哪本书

C语言常见的参考文献

c语言推箱子设计参考文献

请给出C语言学习的书籍，同时列出书的链接。

推荐几个练习 C++ 的GitHub项目，并给出网址

!"C:\Program Files\ANSYS Inc5\v211\icemcfd\win64_amd\bin\icemcfd.bat" -batch -script "C:\Temp\penguang2nd\4.1jiaoben.rpl"改写一下同功能的代码

java编程思想 文献_JAVA编程思想英文参考文献和翻译

数据结构实验报告(集合)

MythwareStudentHacker-main.zip

《金智慧RFID高校固定资产管理平台解决方案》.doc

大连东软信息学院在广东2021-2024各专业最低录取分数及位次表.pdf

湖南财政经济学院在广东2021-2024各专业最低录取分数及位次表.pdf

最新资源

java编程思想文献_JAVA编程思想英文参考文献和翻译