C语言教程：lcc-win下的编程入门

原版英文C语言教程

需积分: 9 51 浏览量更新于2024-07-30 收藏 1.14MB PDF 举报

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

30元优惠券

"这是一份详细的原版英文C语言教程，涵盖了C语言的基础知识，包括学习C语言的原因、程序组织、输入输出、编译过程、标准库、循环结构、数据类型、声明与定义等多个方面，适合初学者进行系统学习。" 在C语言中，学习的初衷【1.1 Why learn C?】往往是因为它的简洁性、高效性和广泛的应用，它是许多操作系统和软件开发的基础。理解C语言能帮助开发者更好地理解计算机工作原理。【1.2 Program organization】这部分介绍了程序的基本构造，通常由一个或多个函数组成，每个函数执行特定任务。程序的入口点是`main()`函数。【1.3 Hello.】简单地展示了编写“Hello, World!”程序来入门C语言，这是许多编程教程的传统起点，用于演示基本的输出功能。【1.4 Program input】提到了程序如何获取输入，以及【1.4.1 The runtime environment】中阐述了运行时环境，包括程序的编译、链接和执行过程。在C语言中，编译是将源代码转换为可执行文件的过程，而运行时则涉及程序的实际执行。【1.4.2 An overview of the compilation process】详细讲解了从编写源代码到运行程序的整个流程，包括编译、链接和运行三个阶段。【1.5 An overview of the standard libraries】介绍了C语言的标准库，比如通过`#include <stdio.h>`引入的`stdheaders.h`文件，它包含了输入输出和其他常用功能。【1.5.1 Passing arguments to a program】讨论了如何传递参数给程序，以及实现细节。【1.6 Iteration constructs】这部分涵盖了循环结构，包括【1.6.1 for】循环、【1.6.2 while】循环、【1.6.3 do-while】循环，以及控制循环行为的【1.6.4 break and continue】语句。【1.7 Types】深入讨论了C语言的数据类型，如【1.7.1 What is a type?】中对类型的定义，【1.7.2 Types classification】中的分类，包括【1.7.3 Integer types】整型、【1.7.4 Floating types】浮点型，以及【1.7.5 Compatible types】兼容类型、【1.7.6 Incomplete types】不完整类型、【1.7.7 Qualified types】有修饰符的类型和【1.7.8 Casting】类型转换。【1.7.9 The basic types】列举了C语言的基本类型，如`int`, `float`, `char`等。【1.8 Declarations and definitions】讲解了声明与定义的区别，【1.8.1 Variable declaration】变量声明、【1.8.2 Function declarations】函数声明、【1.8.3 Function definitions】函数定义，以及【1.8.4 Scope of identifiers】标识符的作用域和【1.8.5 Linkage and du】中的连接性与多重定义问题。这份教程全面地介绍了C语言的基础知识，从简单的输出到复杂的类型系统，再到程序结构和控制流，为初学者提供了坚实的学习基础。通过学习，读者可以逐步掌握C语言的编程技巧，为进一步深入学习和实践打下良好基础。

资源详情

资源推荐

16 Chapter 1. Introduction to C

int fn2(void)

{

int b = 7;

fn1(b);

return b;

}

The fn2 function will always return 7, because function fn1 works with a copy of b,

not with b itself. This is known as passing arguments by value. This rule will not be

used for arrays, in standard C. When you see a statement like:

printf("Hello\n");

it means that the address of the ﬁrst element is passed to “printf”, not a copy of the

whole character array. This is of course more eﬃcient than making a copy, but there

is no free lunch. The cost is that the array can be modiﬁed by the function you are

calling. More about this later.

Console mode programs and windows programs

Windows makes a diﬀerence between text mode programs and windows programs. In

the ﬁrst part of this book we will use console programs, i.e. programs that run in a

text mode window receiving only textual input and producing text output. Those are

simpler to build than the more complicated GUI (Graphical User Interface) programs.

Windows knows how to diﬀerentiate between console/windows programs by look-

ing at certain ﬁelds in the executable ﬁle itself. If the program has been marked

by the compiler as a console mode program, windows opens a window with a black

background by default, and initializes the standard input and standard output of the

program before it starts. If the program is marked as a windows program, nothing

is done, and you can’t use the text output or input library functions.

For historical reasons this window is called sometimes a “DOS” window, even if

there is no MSDOS since more than a decade. The programs that run in this console

window are 32 bit programs and they can open a window if they wish. They can

use all of the graphical features of windows. The only problem is that an ugly black

window will be always visible, even if you open a new window.

You can change the type of program lcc-win will generate by checking the corre-

sponding boxes in the “Linker” tab of the conﬁguration wizard, accessible from the

main menu with “Project” then “Conﬁguration”.

Under other operating systems the situation is pretty much the same. Linux oﬀers

a console, and even the Macintosh has one too. In many situations typing a simple

command sequence is much faster than clicking dozens of menus/options till you get

where you want to go. Besides, an additional advantage is that console programs

are easier to automate and make them part of bigger applications as independent

components that receive command-line arguments and produce their output without

any human intervention.

1.4. An overview of the compilation process 17

1.4 An overview of the compilation process

When you press F9 in the editor, a complex sequence of events, all of them invisible

to you, produce an executable ﬁle. Here is a short description of this, so that at least

you know what’s happening behind the scene.

Wedit calls the C compiler proper. This program is called lcc.exe and is in the

installation directory of lcc, in the bin directory. For instance, if you installed lcc in

c:\lcc, the compiler will be in c:\lcc\bin.

This program will read your source ﬁle, and produce another ﬁle called object

ﬁle, that has the same name as the source ﬁle but a .obj extension under windows,

or a .o extension under linux. C supports the separate compilation model, i.e. you

can compile several source modules producing several object ﬁles, and rely in the

link-editor lcclnk.exe to build the executable.

Lcclnk.exe is the link-editor, or linker for short. This program reads diﬀerent

object ﬁles, library ﬁles and maybe other ﬁles, and produces either an executable ﬁle

or a dynamically loaded library, a DLL.

When compiling your hello.c ﬁle then, the compiler produced a “hello.obj” ﬁle,

and from that, the linker produced a hello.exe executable ﬁle. The linker uses several

ﬁles that are stored in the \lcc\lib directory to bind the executable to the system

DLLs, used by all programs: kernel32.dll, crtdll.dll, and many others.

The workings of the lcc compiler are described in more detail in the technical

documentation. Here we just tell you the main steps.

• The source ﬁle is ﬁrst pre-processed. The #include directives are resolved, and

the text of the included ﬁles is inserted into the source ﬁle.

The result of this process can be seen if you call the compiler with the –E

ﬂag. For instance, to see what is the result of pre-processing the hello.c ﬁle

you call the compiler in a command shell window with the command line:

lcc -E hello.c.

The resulting ﬁle is called hello.i. The i means intermediate ﬁle.

• The front end of the compiler proper processes the resulting text. Its task

is to generate a series of intermediate code statements. Again, you can see

the intermediate code of lcc by calling the compiler with lcc -z hello.c.

This will produce an intermediate language ﬁle called hello.lil that contains the

intermediate language statements.

• The code generator takes those intermediate instructions and emits assembler

instructions from them. Assembly code can be generated with the lcc -S

hello.c command. The generated assembly ﬁle will be called hello.asm. The

generated ﬁle contains a listing of the C source and the corresponding transla-

tion into assembly language.

• The assembler takes those assembly instructions and emits the encodings that

the integrated circuit can understand, and packages those encodings in a ﬁle

called object ﬁle that under Windows has an .obj extension, and under Unix a

o, extension This ﬁle is passed then (possibly with other object ﬁles) to the

linker lcclnk that builds the executable.

18 Chapter 1. Introduction to C

Organizing all those steps and typing all those command lines can be boring. To

make this easier, the IDE will do all of this with the F9 function key.

1.4.1 The run time environment

The program starts in your machine. A speciﬁc operating system is running, a certain

ﬁle and hard disk conﬁguration is present; you have so many RAM chips installed,

etc. This is the run-time environment.

The ﬁle built by the linker lcclnk is started through a user action (you double

click in its icon) or by giving its name at a command shell prompt, or by the action

of another program that requests to the operating system to start it.

The operating system accesses the hard disk at the speciﬁed location, and reads

all the data in the ﬁle into RAM. Then, it determines where the program starts, and

sets the program counter of the printed circuit in your computer to that memory

location.

The piece of code that starts is the “startup” stub, a small program that does

some initialization and calls the “main” procedure. It pushes the arguments to main

in the same way as for any other procedure.

The main function starts by calling another function in the C library called

“printf”. This function writes characters using a “console” emulation, where the win-

dow is just text. This environment is simpler conceptually, and it is better suited to

many things for people that do not like to click around a lot.

The printf function deposits characters in the input buﬀer of the terminal emula-

tion program, that makes the necessary bits change color using the current font, and

at the exact position needed to display each glyph. Windows calls the graphic drivers

in your graphic card that control the video output of the machine with those bits to

change. The bits change before your hand has had the time to move a millimeter.

Graphic drivers are fast today, and in no time they return to windows that returns

control to the printf function.

The printf function exits, then control returns to main, that exits to the startup,

that calls ExitProcess, and the program is ﬁnished by the operating system

Your hand is still near the return key.

We have the following phases in this process:

• Design-time. We wrote the program ﬁrst.

• Compile-time. We compiled our design.

• Run-time. The compiled instructions are started and the machine executes

what we told it to do.

We wrote the program ﬁrst

The central point in communicating with a printed circuit is the programming lan-

guage you use to deﬁne the sequence of operations to be performed. The sequence is

prepared using that language, ﬁrst in your own circuit, your brain, then written down

with another (the keyboard controller), then stored and processed by yet another, a

personal computer (PC).

1.5. An overview of the standard libraries 19

We compiled our design

Compiled languages rely on piece of software to read a textual representation ﬁrst,

translating it directly into a sequence of numbers that the printed circuit understands.

This is optionally done by assembling several pieces of the program together as a unit.

Run time

The operating system loads the prepared sequence of instructions from the disk into

main memory, and passes control to the entry point. This is done in several steps.

First the main executable ﬁle is loaded and then all the libraries the program needs.

When everything has been mapped in memory, and all the references in each part

have been resolved, the OS calls the initialization procedures of each loaded library.

If everything goes well, the OS gives control to the program entry point.

1.5 An overview of the standard libraries

You remember that we stressed that in our hello.c program you should include the

stdio.h system header ﬁle. OK, but how do you know which header ﬁle you need?

You have to know which header declares which functions. These headers and the

associated library functions are found in all C99 compliant compilers.

Header Purpose

assert.h Diagnostics for debugging help.

complex.h Complex numbers deﬁnitions.

ctype.h Character classiﬁcation (isalpha, islower, isdigit)

errno.h Error codes set by the library functions

fenv.h Floating point environment. Functions concern-

ing the precision

of the calculations, exception handling, and re-

lated items.

See page 228

ﬂoat.h Characteristics of ﬂoating types (ﬂoat, double,

long double, qﬂoat).

See page 216

inttypes.h Characteristics of integer types

iso646.h Alternative spellings for some keywords. If you

prefer writing the

operator && as and, use this header.

limits.h Size of integer types.

locale.h Formatting of currency values using local con-

ventions.

math.h Mathematical functions.

setjmp.h Non local jumps, i.e. jumps that can go past

function boundaries.

See page 87.

signal.h Signal handling. See page 196.

剩余284页未读，继续阅读

reludson

粉丝: 1
资源: 4

C语言教程：lcc-win下的编程入门

C语言编程快速入门教程（英文原版）

C语言相关的中文参考文献

现代编译原理c语言描述修订版pdf

大学python课本英文原版

C Primer Plus PDF

spring cloud pdf 英文原版

深入理解计算机系统epub 英文原版

ptp1588英文原版

ahb的英文原版协议pdf

mc服务器修改合成表,原版数据包修改合成配方教程

xilinx soc 英文原版书

learning opencv3英文原版

deepfacelive直播软件(中英文原版四合一)【软件+模型+教程】

xplane11udp通讯说明文档(中文翻译版,以及英文原版)

nng参考手册第二版英文原版

c++ primer 5th 英文高清版

macosx10.7原版镜像

拯救者15isk 原版系统

arm cortex-m3与cortex-m4权威指南英文原版叫什么

windows xp sp3官方原版

最新资源