C语言标准库详解

需积分: 25 166 浏览量更新于2024-07-22 收藏 18.38MB PDF 举报

"《The Standard C Library》是P.J. Plauger撰写的一本关于C语言标准库的著作，书中详细介绍了ANSI和ISO标准规定的C语言编程中的库函数。这本书不仅提供了如何使用这些库函数的指导，还展示了如何实现它们，包含大约9,000行经过测试的、可高度移植的源代码，适用于各种不同的计算机架构。书中特别关注了C标准新增的功能，如多语种支持（多地域文化习惯）和大字符集（如汉字 Kanji）的处理。书中的代码已经过Borland等C编译器的测试验证。" 在《The Standard C Library》一书中，作者P.J. Plauger深入解析了C语言标准库中的核心头文件及其相关的功能，例如： 1. `<stdio.h>`：这是C语言中最基础的输入输出库，包含了`printf`、`scanf`等用于标准输入输出的函数。 2. `<stdlib.h>`：提供了基本的内存管理函数，如`malloc`、`calloc`、`free`，以及整数转换（如`atoi`、`atof`）和退出程序的`exit`函数。 3. `<string.h>`：包含了字符串操作函数，如`strcpy`、`strcat`、`strcmp`等，用于处理和比较C风格的字符串。 4. `<math.h>`：提供了数学运算函数，如平方根`sqrt`、指数`exp`、对数`log`、三角函数`sin`、`cos`等。 5. `<time.h>`：提供了与时间有关的函数，包括获取当前时间`time`、格式化时间`strftime`等。 6. `<limits.h>`：定义了各种类型的最大值和最小值常量，如`INT_MAX`、`CHAR_BIT`等，帮助开发者了解不同数据类型的范围。 7. `<float.h>`：定义了浮点数的相关常量，如浮点精度`FLT_RADIX`、`FLT_DIG`等。 8. `<setjmp.h>`和`<signal.h>`：分别涉及非局部跳转和信号处理，用于异常处理和程序控制流。 9. `<stdarg.h>`：支持可变参数列表的函数，如`printf`家族中的`vprintf`，允许函数接收不确定数量的参数。 10. `<locale.h>`：提供了多语种环境支持，可以处理不同地区的日期格式、货币符号等文化差异。通过阅读这本书，C程序员不仅可以学习到如何有效地利用C标准库进行编程，还能理解这些库函数背后的实现原理，这对于提升编程技能和优化代码性能都极为有益。此外，书中展示的源代码实例对于开发者来说是一份宝贵的参考资料，有助于他们在实际项目中实现跨平台的兼容性和可靠性。

Preface

Finally,

happily acknowledge the contributions made by my family. My

son, Geoffrey, helped with the layout and typographic design of this book.

My wife, Tana, provided much

needed moral and logistical support over

many long months. They, more than anybody, kept this project fun for me.

P.J.

Plauger

Bondi, New South Wales

Chapter

Introduction

Background

libra

is a collection of program components that can be reused in

many programs. Most programming languages include some form of

library. The programming language

is no exception. It began accreting

useful

functions

right from the start. These functions help you classify

characters, manipulate character strings, read input, and write output

to name just a few categories of services.

few

You must

declare

a typical function before you use it in a program. The

definitions

easiest way to do so is to incorporate into the program a

header

that declares

all the library functions in a given category.

header can also define any

associated

type definitions

and

macros.

A header is as much a part of the

library

the functions themselves. Most often, a header is a

text file

just

like the you write to make a program.

You use the

#include

directive in a

source file to make a header part

of the

translation unit.

For example, the header

<stdio.

declares functions

that perform input and output. A program that prints a simple message

with the function

printf

consists of the single

source file:

a simple test program

#include <stdio

int main (void)

{

say hello

printf

(

"Hello\n"

)

;

return

(0);

translator

converts each translation unit to an

object module,

a form

suitable for use with a given

computer architecture

(or

machine).

linker

combines all the object modules that make up a program. It incorporates

any object modules you use from the

library

well. The most popular

form of translator is a

compilw.

It produces an

executable file.

Ideally at least,

an executable file contains only those object modules from the library that

contain functions actually used by the program. That way, the program

suffers no size penalty as the

library grows more extensive. (Another

form of translator is an

interpreter.

It may include the entire

library as part

of the program that interprets your program.)

Chapter

making a

You can construct your own libraries. Atypical

compiler has a

librarian,

library

a program that assembles a library from the object modules you specify.

The linker knows

select from

any

library only the object modules used

by the program. The

library is not a special case.

You can write part or all of a library in

The translation unit you write

to make a library object module is not that unusual:

Alibrary object module should contain no definition of the

functionmain

with external linkage. Aprogrammer is unlikely to reuse code that insists

on taking control at program startup.

The object module should contain only functions that are easy to declare

and use. Provide a header that declares the functions and defines any

associated types and

maaos.

Most important, a library object module should be usable in a variety of

contexts. Writing code that is highly reusable is a skill you develop only

with practice and by studying successful libraries.

After you have read this book, you should be comfortable designing,

writing, and constructing specialized libraries in

the

The

library itself is typically written in

That is often

not

the case

library

with other programming languages. Earlier languages had libraries writ

ten in

assembly language.

Different computer architectures have different

assembly languages. To move the library to another computer architecture,

you had to rewrite it completely.

lets you write powerful and efficient

code that is also highly

portable.

You can move portable code simply by

translating it with a different

translator.

Here, for example, is the library function

strlen,

declared in

<string.

h>.

The function returns the length of a null

terminated string. Its pointer

argument points to the first element of the string:

strlen

function

#include

<string.h>

size-t

(strlen)

(const

char

*s)

{

find

length

s[]

const

char

*sc;

for

(sc

*sc

'\O'

;

++sc)

return

(sc

;

strlen

is a small function, one fairly easy to write. It is also fairly easy to

write incorrectly in many small ways.

strlen

is widely used. You might

want to provide a special version tuned to a given computer architecture.

But you don't have to. This version is correct, portable, and reasonably

efficient.

Other

contemporary languages cannot be used to write significant

portions of their own libraries. You cannot, for example, write the Pascal

library function

writeln

in portable Pascal. By contrast, you

can

write the

Introduction

equivalent C library function

printf

in portable C. The comparison is a bit

unfair because C type

checking is weaker. Nevertheless, the underlying

point is significant

the C library has been expressible from its earliest

beginnings almost completely in C.

nonpatable

Sometimes the code for a library function cannot be written in

portable

code

C. The code you write in

may work for a large class of computer

architectures, but not all. In such a case, the important thing is to document

clearly the nonportable portions that may have to change. You should also

isolate

nonportable code

much as possible. Even nonportable C code is

easier to write, debug, and maintain than assembly language. You write

assembly language only where it is unavoidable. Those places are few and

far between in the C library.

This book shows you how to use the C library in its current, standardized

form. Along the way, it also shows you how to write the

library in C. That

can help you understand how the library works. And it illustrates many

aspects of designing and writing a nontrivial library in

What the

Standard Says

Dennis Ritchie developed the original version of the programming

IanguageC at AT&T Bell Laboratories in the early 1970s. At first it appeared

to be little more than a

UNIX-specific system

implementation language for

the DEC PDP

11 computer architecture. Others soon discovered, however,

that it modeled a broad class of modern computers rather well. By the late

1970s, several other compiler writers had implemented C for a variety of

popular targets, from microcomputers to mainframes. By the early

1980s,

hundreds of implementations of C were being used by a rapidly growing

community of programmers. It was time to standardize the language.

standards

The American National Standards Institute, or ANSI, standardizes com-

for

puter programming languages in the United States. X3Jll is the name of

the ANSI

authorized committee that developed the standard for C, starting

in 1983. The language is now defined by ANSI Standard X3.159

1989.

The International Standards Organization, or

KO, C has a similar re

sponsibility in the international arena. IS0 formed the technical committee

JTCl/SC22/WG14 to review and augment the work of X3Jll. Currently,

IS0 has adopted a standard for C that is essentially identical to X3.159. It

is called

IS0 9899:1990. The C Standards differ only in format and in the

numbering of sections. The wording differs in a few small places but makes

no substantive change to the language definition.

I quote extensively from the

IS0 C Standard throughout this book. That

way you can see exactly what the

Standard says about every aspect of

the Standard C library. It is the final authority on what constitutes the

programming language. If you think my interpretation disagrees with the

C Standard, trust the C Standard.

may very well be wrong.

Chapter

string

letter

decimal

point

standard

headers

resewed

Identifiers

You will find the

Standard hard to read from time to time. Remember

that it is cast intentionally in a kind of legalese.

standard must be precise

and accurate first. Readability comes a distant second. The document is not

intended to be tutorial.

X3Jll

also produced a Rationale to accompany the

Standard. If you are curious about why

X3Jll

made certain decisions, go

read that document. It might help. I emphasize, however, that the Rationale

is also not a tutorial on the

language.

Here are two quotes from the

IS0

Standard. The first quote introduces

the Library section of the

Standard. It provides a few definitions and lays

down several important ground rules that affect the library

a whole.

Library

7.1 Introduction

7.1.1 Definitions of terms

string

is a contiguous sequence of characters terminated by and including the fust null

character.

AUpointer to

a string is a pointer to its initial (lowest addressed) character. The

length

of a string is the number of characters preceding the null character and its

value

is the sequence

of the values of the contained characters, in order.

letter

is a printing character in the execution character set corresponding to any of the

required lowercase and uppercase letters in the source character set, listed in 5.2.1.

The

decimal

point character

is the character used by functions that convert floating

point

numbers to or from character sequences to denote the beginning of the fractional part of such

character It is represented in the text and examples by a period, but may be changed

by the

setlocale

function.

Forward references: character handling (7.3). the

setlocale

function (7.4.1.1).

7.1.2 Standard headers

Each library function is declared in a

header.89

whose contents are made available by the

#include

preprocessing directive. The header declares a set of related functions, plus any

necessary types and additional macros needed

to facilitate their use.

The standard headers are

If a file with the same name as one of the above

and >delimited sequences, not provided as

part

of the implementation. is placed in any of the standard places for a source file to be included.

the behavior is undefined.

Headers may be included in any order, each may be included more than once in a given

scope,

with no effect different from being included only once, except that the effect of including

<assert.

depends on the definition of

NDEBUG.

If used, a header shall be included outside

of any external declaration or definition, and it shall first be included before the first reference to

any of the functions or objects it declares, or to any of the types or macros it defines. However,

if the identifier is declared or defined in more than one header, the second and subsequent

associated headers may be included after the initial reference to the identifier. The program shall

not have any macros with names lexically identical to keywords currently

defmed prior to the

inclusion.

Forward references: diagnostics (7.2).

7.1.3 Reserved identifiers

Each header declares or defines all identifiers listed in its associated subclause, and optionally

declares or defines identifiers listed in its associated future library directions subclause and

identifiers which are always resewed either for any use or for use as file scope identifiers.

All identifiers that begin with an underscore and either an uppercase letter or another underscore

are always resewed for any use.

剩余513页未读，继续阅读

mpoix

粉丝: 2
资源: 13

C语言标准库详解

C标准库详解：功能演示与跨平台实现

C语言标准库详解

C语言标准库完全解析

C标准库 The Standard C Library

《The Standard C Library》

C标准库.The Standard C Library

The Standard C Library 经典的基础.docx

The standard C Library（C标准库）英文版

C标准库(The Standard C Library)（英文版）

the standard C library书，本书讲述标准C库的一种实现。

最新资源