C语言标准C89/C90-ISO_IEC_9899_1990官方PDF

9899:1990

PDF

1星需积分: 48 101 浏览量更新于2023-03-03 2 收藏 10.33MB PDF 举报

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

30元优惠券

"C Standard C89 C90-ISO_IEC-9899-1990-含书签.pdf" 是一份关于C语言编程标准的重要文档，源自ISO/IEC 9899:1990，通常被称为C90标准。这个标准是C语言的第一个国际标准化版本，由国际电工委员会（International Electrotechnical Commission, IEC）和国际标准化组织（International Organization for Standardization, ISO）联合发布。C90是对先前的美国国家标准协会（American National Standards Institute, ANSI）C标准（也称为C89）的确认和扩展。 C90标准定义了C语言的核心语法、类型系统、控制结构、预处理器、输入/输出系统以及错误处理等方面的规定。它引入了包括函数原型、void指针、const关键字、typedef、#include预处理器指令等关键特性，这些特性极大地增强了C语言的可读性和可维护性。在标准文档中，"含完整书签"意味着用户可以方便地导航到各个章节和子章节，快速找到所需的信息。书签通常会按照标准的不同部分进行组织，例如基本概念、数据类型、表达式和语句、声明、函数、预处理器等，这对于理解和学习C语言的标准规范非常有帮助。 C90标准之后，C语言经历了多次更新，包括C99、C11、C17和C18等版本，这些版本增加了更多的特性，如变量长度数组（Variable Length Arrays, VLA）、内联函数、增强的浮点运算符、复杂的字面量表示法、多线程支持等。如果你对不同版本的C语言标准有兴趣，可以通过提供的链接访问C99、C11、C17和C18的官方PDF文档。值得注意的是，尽管C语言标准的存在，但其使用完全是自愿的。无论是制造商、市场营销者还是消费者，都可以选择遵循或不遵循这些标准。标准的存在旨在促进兼容性和互操作性，但并不强制执行。 C89/C90 ISO/IEC 9899:1990标准对于C语言的开发者和爱好者来说是极其宝贵的参考资料，它定义了C语言的基本框架，并为后来的版本提供了基础。通过深入学习这个标准，程序员可以更好地理解C语言的本质，写出更高效、更可靠的代码。

资源详情

资源推荐

ISOAEC 9899: 1990 (E)

5. Each source character’ set member and escape sequence in character constants and string

literals is converted to a member of the execution character set.

6. Adjacent character string literal tokens are concatenated and adjacent wide string literal

tokens are concatenated.

7. White-space characters separatin,

0 tokens are no longer significant. Each preprocessing

token is converted into a token. The resulting tokens are syntactically and semanticall!

analyzed and translated.

8 Ail external object and function references are resolved

Library components are linked to

satisfy external references to functions and objects not defined in the current translation

Ail such translator output is collected into a program image uhii-h contains information

needed for execution in its execution environment. -

Forward references:

lexical elements (6 I). preprocessin,

u directives (6.8). trifraph sequences

(5.2.1.1)

5.1.1.3 Diagnostics

A conforming implementation shall produce at least one diagnostic message (identified in an

implementation-defined manner) for every translation unit that contains a violation of any syntax

rule or constraint. Diagnostic messages need not be produced in other circumstances.h

5.1.2 Execution environments

Two execution environments are defined. fivr.~rur~S~~~~ and hosted. In both cases, p~jgrunl

srarnrp occurs when a designated C function is called by the execution environment. All objects

in static storage shall be

initialized

(set to their initial values) before program startup. The

manner and timing of such initialization are otherwise unspecified. Pro~~nt

reminarion

returns

control to the execution environment.

Forward references:

initialization (6.57).

5.1.2.1 Freestanding environment

In a freestanding environment (in which C program execution may take place without any

benetit of an operating system), the name and type of the function called at program startup are

implementation-detined There are otherwise no reserved external identitiers. Any library

tacilities available to a freestanding propram are implementation-defined.

The effect of program termination in a freestanding environment is implementation-defined,

5.1.2.2 Hosted environment

A hosted environment need not be provided. but shall conform to the following specifications

if present

5.1.2.2.1 Program startup

The function called a~ propram startup I\ named main

The implementation declares no

prototype for thrs function. It can be detined v.ith no parameters

int main(void) { /*...*/ }

or with two parameters (referred to here ;I argc and

argv.

though any names may be used, as

the) are local to the tunction in which the) arc dcclarcd)

h The intent 15 that an implementation should ~dcnt~l! the nature 01.

and where possible localize. each

violai1on Ot course. an implementatmn I\ tree IO produce an> number of diagnostics as long as a valid

program I\ htill correctI> rramlated II ma! al\o \ucLe\\full> translate an invalld program

Environment

ISO/IEC OX99 I990 (E J

int main(int

argc, char *argv[]) { /*. . . */ 1

If they are defined. the parameters to the main function shall obey the following constraints

The value of argc shall be nonnegative.

argv

[argc]

shall be a null pointer.

- If the value of argc is greater than zero,

the array members argv[O] through

argv [argc-l] inclusive shall contain pointers to strings.

which are given implementation-

defined values by the host environment prior to program startup

The intent is to supply to

the program information determined prior to program startup from elsewhere in the hosred

environment If the host environment is not capable of supplying strings with letters in both

uppercase and lowercase. the implementation shall ensure that the strings are received in

lowercase

- If the value of argc is greater than zero. the string pointed to by argv [0] represents the

/~r~,~r-cmr IKMIC.

argv

[0] [0] shall be the null character if the program name is not available

trom the host environment. If the value of

argc

is greater than one, the strings pointed to

by argv [ l] through

argv

[ argc-l] represent the program parmnerer s

The parameters argc and

arg-v

and the strings pointed to by the argv array shall be

modifiable by the program. and retain their last-stored values between program startup and

program termination

5.1.2.2.2 Program execution

In a hosted environment. a program may use ail the functions, macros, type definitions. and

objects described in the library clause (clause 7).

5.1.2.2.3 Program termination

A return from the initial call to the main function is equivalent to calling the exit function

with the value returned by the main function as its argument. If the main function executes a

return that specifies no value. the termination status returned to the host environment is

undetined

Forward references:

definition of terms (7 I I). the exit function (7.10.4.3)

5.1.2.3 Program execution

The semantic descriptions in thi\ International Standard describe the behavior of an abstract

machine in which issues of optimization are irrelevant

Accessing a volatile object. modilying an object, modifying a file, or calling a function that

doe\ any of those operations arc all tit/c eJc( [\. which are changes in the state of the execution

envtronmcnt Evaluation of an expression may produce side effects At certain specified points

in the execution sequence called \I’L/I~‘HI c /~oirtr\.

all side effects of previous evaluations shall be

complrtc and no side ettects ot suh\cqucnt evaluations shall have taken place

In the abstract machtnc. all expresston\ are evaluated as specified by the semantics An actual

implrmentatton need not evaluate part ol an expression if it can deduce that its value is not used

and that no needed side ellect\ arc produced (including any caused by calling a function or

accessing a volatile object)

When the processing oi the ab\tr;Ict machine is interrupted by receipt of a signal. only the

value\ 01 objects as ot the prcvmu\ sequence point may be relied on

Objects that may be

modified between the previou\ scqucnce point and the next sequence point need not have

received their correct values yet

An Instance of each object with automatic storage duration is associated with each entry into m

its block Such an object exists and retains its last-stored value during the execution of the block

and while the block is suspended (hy a call of a function or receipt of a signal)

Environment

ISO/IEC 9899: 1990 (El

The least requirements on a conforming implementation are.

At sequence points. volatile objects are stable in the sense that previous evaluations are

complete and subsequent evaluations have not yet occurred.

At program termination. all data written into files shall be identical to the result that execution

of the program according to the abstract semantics would have produced.

The input and output dynamics of interactive devices shall take place as specitied in 7.93.

The intent of these requirements is that unbuffered or line-buffered output appear as soon as

possible. to ensure that prompting messages actually appear prior to a program waiting for

input.

What constitutes an interactive device is implementation-defined.

More stringent correspondences between abstract and actual semantics may be defined by

each implementation.

Examples

An implementation might define a one-to-one correspondence between abstract and actual

semantics: at every sequence point. the values of the actual objects would agree with those

specified by the abstract semantics.

The keyword volatile would then be redundant.

Alternatively. an implementation might perform various optimizations within each

translation unit. such that the actual semantics would agree with the abstract semantics only

when making function calls across translation unit boundaries. In such an implementation.

at the time of each function entry and function return where the calling function and the

called function are in different translation units. the values of all externally linked objects

and of all objects accessible via pointers therein would agree with the abstract semantics.

Furthermore, at the time of each such function entry the values of the parameters of the

called function and of all objects accessible via pointers therein would agree with the

abstract semantics. In this type of implementation. objects referred to by interrupt service

routines activated bv the signal function would require explicit specification of

volatile storage. as well as other implementation-detined restrictions

In executing the fragment

char

cl, c2;

/*. . .*/

cl =

cl + c2;

the

“integral promotions” require that the abstract machine promote the value of each

variable to int size and then add the two ints and truncate the sum. Provided the

addition 01 two

chars

can be done without creating an overflow exception. the actual

execution need only produce the same result. possibly omitting the promotions.

Similarly. in the fragment

float fl, f2;

double d;

/*...*/

fl =

* d;

the multiplication may be executed using hingle-preciston arithmetic if the implementation

can ascertain that the result would be the same a\ if it were executed using double-

precision arithmetic (f ?r example. if

were replaced by the constant 2.0. which has type

double) Alternatively. an operation involving only ints or

floats may be executed

using double-precision operations if neither range nor precision is lost thereby.

4. TO illustrate the grouping behavior of expressions. in the following fragment

Environment

ISO/IEC 9899.1990 (E)

int a, b;

/*...*/

a = a + 32760 + b + 5;

the expression statement behaves exactly the same as

a = (((a + 32760) + b) + 5);

due to the associativity and precedence of these operators. Thus. the result of the sum ” (a

+ 32760)”

is next added to

and that result is then added to 5 which results in the

value assigned to a. On a machine in which overflows produce an exception and in which

the range of values representable by an int is i-32768.+32767]. the implementation

cannot rewrite this expression as

a = ((a + b) + 32765);

since if the values for

and

were, respectively. -32754 and - 15. the sum a + b would

produce an exception while the original expression would not; nor can the expression be

rewritten either as

a = ((a + 32765) + b);

a = (a + (b + 32765));

since the values for

and

might have been. respectively, 4 and -8 or - 17 and 12.

However on a machine in which overflows do not produce an exception and in which the

results of overflows are reversible, the above expression statement can be rewritten by the

implementation in any of the above ways because the same result will occur.

5. The grouping of an expression does not completely determine its evaluation. In the

following fragment

#include <stdio.h>

int sum;

char *p;

/*...*/

sum = sum * 10 - '0' + (*p++ = getchar(

the expression statement is grouped as if it were written as

sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())

but the actual increment of

can occur at any time between the previous sequence point

and the next sequence point (the

; ). and the call to

getchar

can occur at any point prior

to the need of its returned value

Fomard references:

compound statement. or block (6.6.2). expressions (6.3). tiles (7.93).

sequence points

(6.3. h 6).

the

signal

tunction (7 7). type qualifiers (6 5.3)

Environment

ISO/IEC 9899: 1990 (E)

5.2 Environmental considerations

5.2.1 Character sets

Two sets of characters and their associated collating sequences shall be defined: the set in

which source files are written, and the set interpreted in the execution environment. The values

of the members of the execution character set are implementation-defined. any additional

members beyond those required by this subclause are locale-specific.

In a character constant or string literal. members of the execution character set shall be

represented by corresponding members of the source character set or by esc.upr seqrtolc cs

consisting of the backslash \ followed by one or more characters. A byte with all bits set to 0.

called the null char-orrev. shall exist in the basic execution character set: it is used to terminate a

character string literal.

Both the basic source and basic execution character sets shall have at least the following

members: the 26 uppercase letters of the English alphabet

ABCDEFGEIJKLM

NOPQRS

TUVWXYZ

the 26 lowercase letters of the English alphabet

abcdefghij klm

n 0

P 9 = =

tuvwxyz

the 10 decimal digits

0123456789

the following 29 graphic characters

! I8 # % 6 ’ ( ) * + , - . / :

;

< = > ?

t\lA-(I)-

the space character. and control characters representing horizontal tab, vertical tab. and form feed.

In both the source and execution basic character sets. the value of each character after 0 in the

above list of decimal digits shall be one greater than the value of the previous In source tiles.

there shall be some way of indicating the end of each line of text; this International Standard

treats such an end-of-line indicator as if it were a single new-line character. In the execution

character set. there shall be control characters representing alert. backspace, carriage return, and

new line. If any other characters are encountered in a source file (except in a character constant,

a string literal, a header name. a comment, or a preprocessing token that is never converted to a

token). the behavior is undefined.

Forward references:

character constants (6. I .? 4). preprocessing directives (6.8). string literals

(6.1.1). comments (6 1.9).

5.2.1.1 Trigraph sequences

All occurrences in a source file of the following sequences of three characters (called rri,q~uph

scy~e~c rs’) are replaced with the corresponding single character

The trigraph sequences enable the input of character\ thar are not detined in the Invariant Code S,r as

described in IS0 636:19X3. which is a subser ot the seven-bit

ASCII

code set

Environment

剩余229页未读，继续阅读

RiskAI

粉丝: 137
资源: 42

C语言标准C89/C90-ISO_IEC_9899_1990官方PDF

C语言规范标准-C99(中文版)

C语言标准（ANSI+C+C89+C99）

c99标准（pdf格式）

431 [C] Function argument points to a more heavily qualified type. REFERENCE - ISO:C90-6.3.2.2 Function calls

ISO C90和iSO C99的区别

修复问题if(TRUE == ResetRequiredFlag) ^ Msg(2:1251) Suffixed integer constant causes implicit conversion of other operand. Msg(2:2100) Integral promotion : unsigned char promoted to signed int. REFERENCE - ISO:C90-6.2.1.1 Characters and Integers { Mcu_PerformReset(); }

sonar-scanner.bat -D"sonar.projectKey=java" -D"sonar.sources=." -D"sonar.host.url=http://localhost:9000" -D"sonar.token=sqp_b604bfee02401613c90a8e2f4b557ab25a505ef7"

iso c90 pdf

如何查看编译器适用哪儿钟c语言标准

iso/iec 9899:1999

empty macro arguments are undefined in iso c90 and iso c++98 [-werror]

I2C.py 文件首行为# -*- coding: utf-8 -*- sonarqube也设置了sonar.sourceEncoding=UTF-8 执行的时候还是报错

c89/c90、c99和c11的区别

gcc工具如何使用c90编译

inline __inline __inline__

ISO C90 不允许混合使用声明和代码 ,如何在makefile中解决

最新资源

I2C.py 文件首行为# -- coding: utf-8 -- sonarqube也设置了sonar.sourceEncoding=UTF-8 执行的时候还是报错

inline inline inline__