c语言主函数和库函数代码 c语言主函数和库函数代码区别

函数 主函数 被调用函数 库函数是什么

函数是C语言最基本的执行单位，是实现一定功能的代码的集合；

成都创新互联秉承实现全网价值营销的理念，以专业定制企业官网，网站设计、成都网站制作，小程序设计，网页设计制作，成都做手机网站，网络营销推广帮助传统企业实现“互联网+”转型升级专业定制企业官网,公司注重人才、技术和管理，汇聚了一批优秀的互联网技术人才,对客户都以感恩的心态奉献自己的专业和所长。

主函数是main函数，是程序执行的入口；

有函数A和函数B，如果在函数A中调用函数B，则函数A称为主调用函数，函数B称为被调用函数。

库函数：在C语言中，将前人编写好的、实现特定功能的函数，存放在指定的路径中。在源程序编译后，通过连接到这些函数形成可执行文件（.exe）。

求助，关于c语言的。

C语言基础(01-引言及预备知识)： C语言是一门功能强大的编程语言，它也是C++语言的基础。C语言属于中级语言。这里所说的中级是相对于计算机的底层硬件而言的。汇编语言是最低级的语言，它可以直接与硬件打交道。高级语言有Pascal、Basic、Fortran等等。高级语言的一条语句对应低级语言的很多条语句，任何高级语言编写的程序都要经过编译程序的编译、连接才能成为可以运行的程序。编译连接的过程也就是把高级语言翻译成机器语言(二进制机器码)的过程，而汇编语言是基本上与机器语言一 一对应的一种语言。这个翻译过程是由编译程序自动完成的。把C语言定为中级语言是有它的道理的，因为C语言既有汇编语言的存取底层硬件的能力，又具有高级语言的许多特点。熟练掌握了C语言，学习其它的各种编程语言应该是很轻松的了。

C语言的书写格式：

1) 一个C语言编写的源程序，必定有一个主程序(称为main()函数，在C语言中子程序称为“函数”(当然，不要理解成为数学里面的“函数”)。但是决不能有一个以上的main函数(即只能有一个)。

2) 函数语句块用‘{’括号开始， 以‘}’反括号结束。这样的花括号必须成对出现。

3) 表达式写在小括号里面，以‘(’括号开始，以‘)’反括号结束。

4) 函数不能嵌套，即函数里面不能再套函数。(每一个函数是完成一个特定功能的函数模块)

C语言的组成：

C语言是由许多函数组成的。其中只有一个主函数(main()函数)。C程序执行时总是从main函数的‘{’处开始，至main函数的反大括号'}'处结束。当然还有其它一些规则，这将在以后的学习中去熟悉它。

C语言的书写规则：

C语言在书写时有它自身的特点：书写格式比较自由，在一行里可以写多条语句，一个语句也可以分写在多行上。虽然如此，在书写源程序时还是要注意哪些可以自由书写，而哪些必须要按照书写规则来书写。

几条规则写在下面：

1) 一行内可以写几个语句，建议一行不超过两条语句；

2) 一条语句可以写在多行上；

3) C语句不需要写行标号；

4) 每条语句及数据定义的后面要写上分号以表示该语句结束；

5) C语言中注释用 /* */来表示；

6) 建议书写时采用缩进格式；

7) 花括号、小括号都是成对出现的。

一个最简单的C程序的编写：

/* 程序代码*/ /* 注释部分*/

main() /*main是主函数名。紧跟在main后面的括号是放参数的。

括号里面为空说明main函数不需要参数*/

{ /*正写的大花括号表示main函数从这里开始*/

} /*反写的大花括号表示main函数到这里结束*/

说明：由于是一个演示程序，在函数体内并没有任何可以执行的语句，也就是这个程序什么事也不做。

这个程序就是这么简单： 写在一行上就是 main() { }

你在TC的编辑环境下把这段代码输入进去，按F9键编译连接，按CTRL_F5运行，一定很正常。但是什么结果也不会有，因为在main函数里面什么代码也没有。

下面再举一个可以向屏幕上输出一条信息的例子：

main()

{

printf("这就是C语言编写的程序!"); /*这一条语句的作用是向屏幕输出一条信息

”这就是C语言编写的程序!"*/

}

在这个程序中，main函数只有一条语句：printf("这就是C语言编写的程序!");这个语句的作用是向屏幕输出一个字符串。有关这个语句的知识以后再讲。现在要注意的是一个C语言程序的框架是怎样组成的。

C语言程序的几种文件格式：

1、 源程序---在TC集成环境中输入的程序文本称为源程序。源程序是一种文本文件。它是我们看得见并认识的一种文件。其扩展名为.C。例如你把文件保存为TEST，那么在磁盘上应看得到TEST.C这个文件。这样的文件可以用记事本打开。

2、二进制文件---写完了源程序后接着要做的是编译这个文件。在TC集成环境里是按ALT_F9键，编译后生成了一个二进制文件，这个二进制文件名为TEST.OBJ，也就是扩展名为OBJ的目标文件。

3、运行文件---最后一步是make(或Link)，在TC集成环境里是按F9键Make之后生成了一个可以在DOS下运行的文件，其扩展名为EXE。如TEST.EXE。这个EXE文件是由第2步中的OBJ文件生成的。OBJ文件虽然是二进制文件，而电脑又是可以运行二进制文件的，为什么还要把OBJ文件Link为EXE文件才能运行？这里的知识就比较多了，这里不能多讲。但是要明白一点，在DOS下仅仅有了一个二进制文件还不能运行，因为操作系统要把这些二进制文件加以规划，把相应的数据、程序代码放到应该放的内存位置，这样的经过严密规划和组织好了的二进制文件才能运行。而这些只有在生成的EXE文件里面才做完了这些工作。

---------------------------------------

作业题：

1、下列程序中格式错在( )处。

A. main() B. int a,b,z;

C. a=2:b=3; D. z=a+b;

分析：A,B,D 没有错误。 C 中在a=2后面应该是分号而不应是":"号

答： C

2、C语言允许将一条语句写在两行上，下列语句不正确的是

A. int a,

B;

B. int a

,b;

C. int

a,b

D. int a,b

;

分析：C语言规定可以在语句中的任何一个分隔符或空格处换行。上面4个选项中D.有问题因为在D.中第一行的最后没有分隔符，而第二行只有一个分号，可以看做一个语句。所以D中的错误为：第一行是一个独立的语句，但是少了一个分号。

答： D

3. C语言的一行写不下时，可以

A. 用逗号换行 B. 用分号换行

C. 在任意一空格处换行 D. 用回车符换行

分析：C语言可以在任何一个分隔符或空格处换行，所以此题的正确答案是 C

答： C

4. 下列程序段中，哪一个是错误的注释方法？

A. #in/*包含*/cludestdio.h

void main()

{

}

B. #includestdio.h

void main/* */(/*主函数*/)

{

}

C. #includestdio.h

void main()

{ int x/*初始化*/=10;

/*打印*/printf("%d",x);

}

D. #includestdio.h

void main()

{

int x=10;

printf("%d",x);

/*打印x的值*”*=10*/

}

分析：根据C语言的规定：注释不能插在标识符的中间，在其它有分隔符的地方都可以插入注释，上面四个程序段中只有A是将注释插入在标识符的中间了。所以A是错误的。

答： A

5. C语言程序是由( )组成的？

答：C程序是由函数组成的。

6. C程序运行时，运行的是什么文件？

数据的类型：

在程序中要处理大量的数据，把这些数据按其特点分为几种基本的数据类型，它们分别是：

1 、整型 2 、字符型 3 、实型

还有其它的一些扩展的数据类型，但是开始学习时要先熟悉这三种基本数据类型。

在 C 语言中这几种数据类型用符号表示如下：

整型数据类型 int /* 一般指可以运算的数，如自然数就是整型数据类型 */

字符数据类型 char /* 一般指文字，如英文字母；字符类型的 '1''2''3''4' 等 */

实型 float /* 也称作浮点型，记住 float 类型的数都是有小数位的，如 425.23*/

常量和变量：

常量――程序运行过程中其值不变的量，如一个整数 134, 一个字符 ‘a'

变量――程序运行过程中其值可以变化的量，如 int a; char b; 那么 a 和 b 都是变量。

符号常量 ――用一个“符号”来表示的一个“常量”称为“符号常量”。

符号常量有什么好处 ――在给符号常量命名的时候，按习惯取的名字与实际上的含义相符，可以“见名识意”；另外在需要修改常量的值的时候，只需要修改符号常量的定义部分即可，非常方便。

符号常量的定义方法 ―― #define 符号 常量

例： #define NUMBER 30 /* 定义了一个符号常量，在这里是用符号 NUMBER 表示整数 30 ，以后在程序里就可以

用符号 NUMBER 代替整数 30 进行运算 */

main()

{

int a=20; /* 把常量 20 赋给整型变量 a*/

int c; /* 定义了整型变量 c*/

c=NUMBER+a; /* 变量 c 的值此时为 50 ，符号常量 NUMBER 参与了运算 */

}

变量的定义方法 ――在变量的名字前面加上一个变量的数据类型，以说明已定义的变量可以用来存放什么样类型的数据。

例： int a; /* 定义了一个整型变量，以后这个变量只能存放整型类型的数 */

char b; /* 定义了一个字符型变量，以后这个变量只能存放符字符型数据 */

怎样把常量值赋给已定义了的变量 ――用一个 = 号赋值。

例： int a; /* 定义一个整型娈量 a*/

char b; /* 定义了一个字符型变量 b*/

a=20; /* 用 = 号完成赋值，赋值后变量 a 的值此时为 20*/

b='d' /* 把常量字符 'd' 赋给变量 b ，此时变量 b 的值是字符 'd'*/

变量赋值时一种更灵活的方法 ――可以在一行上给多个相同数据类型的变量赋值，变量之间用逗号分隔。

例： int a,b,c,d; /* 定义了 4 个整型变量 */

char e,f,g; /* 定义了 3 个字符型变量 */

深入理解变量 ―― 1 ） 1 个变量必须有一个变量名。 2 ）变量必须有其指定的数据类型

3 ）变量一旦被定义，它就在内存中占有一个位置，这个位置称做该 变量的地址 。

4 ）每一个变量都有其对应的值。

l 一定要牢记变量的这 4 个特性。

变量使用时的注意事项 ―― 1 ）变量在使用之前一定要先定义，使用一个没有定义的变量是错误的。

2 ）变量必须在一个函数的开始部分定义。（这个限制在 C++ 中不存在）

例题：写一个 2 个整数相加的程序。

/* 解题思路：求 2 个整数相加，必定要先定义 2 个变量来存放这 2 个数，另外还需要 1 个变量用来存放

相加的和，所以共需要定义 3 个整型变量 */

/* 注意每次在写 C 程序的时候一定要注意书写格式 */

main()

{

int a,b,c;

a=20,b=30; /* 在这里指定变量的值，因为还没有讲输入输出函数，只能这样了。 */

c=a+b;

}

想一想，这样简单的一个题，需要知道的知识面却不少。 用到了上面所讲的哪些知识？

C语言中的库函数――我们编写C语言程序时要写许多代码，这些代码是用基本程序语句如运算符、表达式、几种语句结构来组成。这些语句组成了多个不同的函数，由多个函数组成一个完整的程序。实际上如果程序中的语句都要由自己来写的话，那么工作量是很大的了。并且有一些完成基本任务的函数如输入输出函数是经常需要使用的。这样的一些常用的完成基本任务的函数有许多已经由提供编译程序的公司为我们写好了。这些已经写好的函数放在TC或者BC编译器的文件中。所谓“库函数”，就是存放“函数”的“仓库”。在TC中，函数的“仓库”在哪里呢？在TC的.\LIB目录中。编写程序的时候，如果我们需要使用某个库函数，就要在这个程序开头指明这库函数存放在哪里，以便让编译程序到这个地方去找。这个指明库函数路径的语句称为“包含”语句，写做#include。完整的写法是：

#include stdio.h

#include 是包含的意思，stdio.h 是指明要使用的库函数在 stdio.h这个文件里面有说明。尖括号是必须要写的。而实际上，编译程序在stdio.h之个文件里根据库函数名可以在.\LIB目录下的LIB文件里找到相关的代码，写进程序里面去。使用不同的库函数时要用不同的包含，关于怎样使用#include，可以查看库函数的帮助。

有了众多的库函数，给编写程序带来了很大的方便。就象做房子要用砖和瓦一样。如果没有砖和瓦，做房子自己要挖土烧砖，可想而知，那样做房子的难度有多大。写程序也是这样，有了库函数，在需要完成某些任务时，找到相应的库函数调用一下就可以了，不需要自己一点一点的写代码。在学习编程的同时要多多了解一些库函数的特点及用法，对编写程序是有很大的好处的。

（在Windows下编写程序，需要了解的“库函数”就更多了，可以说不了解库函数就不会编程。VC中用的是MFC，Win32中用的是API，它们都是函数库）

先了解二个库函数――1、scanf函数 /*格式化控制台输入函数*/

函数原型：int scanf(control_string....); /*看上去很复杂。没关系，以后自然会明白的*/

使用例：

void main()

{

int a,b,c; /*定义了三个整型变量*/

scanf("%d%d",a,b); /*从键盘输入二个整数到娈量a和b中*/

c=a+b; /*把变量a与b相加的和送给变量c*/

}

下面仔细讲一下scanf函数各参数的用法：

可以看到在小括号里有二个%d，后面有二个变量a和b。二个%d的写法为"%d%d"，注意凡是这样的符号都要写在双引号里面，而变量则写在双引号的外面并用逗号分隔。这个%d我们称为格式化说明符，第一个%d用于说明第一个变量a，第二个%d用于说明第二个变量b，这样的顺序是一一对应的。%d格式符说明了后面输入的变量值是整型数。

另外注意的是二个%d是靠在一起的 %d%d，凡是这样的写法，在输入数时，对于二个数之间的分隔是用“空隔键”来实现的。如输入30和50这二个数形式为 30 50 如果二个%d写成%d，%d中间有一个逗号，那么在输入数据时也一定要在输入的数之间加上逗号，如 30，50。

再来看一下变量的写法，可以看到在每一个变量名的前面都有一个号，这个号是取变量地址的意思，那么a写在一起就是变量a的地址，b写在一起就是变量b的地址。

上面的scanf函数的作用就是把从键盘上输入的二个整数分别送到变量a和变量b的地址里面去。这个号是非常重要，不要写漏了。

scanf函数的格式说明符（格式说明符说明了下一步将读的是什么类型的数据）

格式码 含义

%c 读一单字符

%d 读一整数

%i 读一个浮点数

%e 读一个浮点数

%f 读一个浮点数

%g 读一个浮点数

%o 读一个八进制数

%s 读一字符串

%x 读一十六进制数

%p 读一指针

%n 读一个指针收一个等于到目前为止输入的字符数止的整数

%u 读一无符号整数

%[] 扫描一字符集

例：从键盘输入二个字符，一个大写，一个小写，然后把这个小写字符转换成大写，大写字符转换成小写。

#includestdio.h /*因为在程序里用到了库函数scanf，所以要使用包含#includestdio.h*/

void main()

{

char ch,chh; /*定义了二个字符型变量*/

scanf("%c%c",ch,chh); /*从键盘输入二个字符，一个大写，另一个小写*/

ch=ch+32; /*大写转成小写*/

chh=chh-32; /*小写转成大写*/

}

2、printf函数 /*格式化输出函数*/

函数原型：int printf(const char *control_string....);

说明：printf把变量的值或常量字符串输出到控制台（一般是显示屏）

使用例：

#includestdio.h

void main()

{

int a,b,c;

scanf("%d%d",a,b);

c=a+b;

printf("输出二个整数相加的和"); /*输出字符串常量，这里没有用到格式化说明符*/

printf("%d",c); /*把变量c的值用整型格式输出，这里%d是整型格式说明符*/

}

如果有几个变量的值要输出，用这样的形式：printf("%d %d %d",a,b,c);

从这个printf输出的格式中看出，每一个格式符对应一个变量，其对应顺序也是一一对应的，第一个%d对应第一个变量a，以此类推。注意在printf函数中，变量前面就不要加符号了。

注意printf函数中几个%d之间留了一些空格，这里的用法与scanf相比有一点不同。在printf函数中格式符之间留多少空隔，输出的时候每一个输出的值之间就有多少空隔。如printf("%d %d %d",a,b,c);输出则为：20 30 50 (这里的数是假设的）。如果写为printf("%d，%d，%d",a,b,c);则输出形式为 20，30，50

printf函数的格式符：

格式码 格式

%c 单个字符

%d 十进制数

%i 十进制数

%e 科学法表示

%E 科学法表示

%f 十进制浮点数

%g 用%e或%f中较短的的一个（如果是%e,用小写e）

%G 用%e或%f中较短的的一个（如果是%E,用大写E）

%o 以八进制形式输出

%s 字符串

%u 无符号十进制数

%x 十六进制数（小写）

%X 十六进制数（大写）

%p 显示一个指针

%n 相关变量是整型指针，它所指处存放至今要写入字符的总数

%% 打印一个%号

printf函数使用例：

1）char ss="abcdefghijk"; printf("%s",ss); /*输出一个字符串，屏幕上显示"abcdefghijk"*/

2）unsigned int a=65535; printf("%u",a); /*以十六进制形式输出一个无符号数，显示为ffff*/

3）int a=123,b=456,c=687; printf("%d\t%d\n%d",a,b,c);

输出形式为：

123 456 /*'\t'是一个制表符，所以要移动一个制表位这么多空格数*/

687 /*'\n'是换行转义符，在前面字符常量里讲过。所以要换一行再输出687*/

C语言基础(05-运算符和表达式)：运算符（也叫操作符）－－运算符是一个表示特定的数学或逻辑操作的符号。如'+'号，表示了一个相加运算；''号表示了一个逻辑‘与’的运算。由运算符把需要进行运算的各个量（常量或变量）连接起来组成一个表达式。

下面要讲的是标准的运算符，在C＋＋中还有另外的一些运算符。运算符 进行的运算 所属类别 备注

[ ] 间隔符 标点符号

( ) 间隔符 标点符号

· 直接分量选择 双目操作符

- 间接分量选择 双目操作符

++ 前增量、后增量 单目操作符

-- 前减量、后减量 单目操作符

+ 加 双目操作符、单目操作符

- 减 双目操作符、单目操作符

* 1）乘 2）间接引用 双目操作符、单目操作符

/ 除 双目操作符

% 求余 双目操作符

1）位‘与’2）取地址 双目操作符、单目操作符

! 逻辑‘非’ 单目操作符

逻辑‘与’ 双目操作符

|| 逻辑‘或’ 双目操作符

左移位 双目操作符

右移位 双目操作符

小于 双目操作符

大于 双目操作符

== 等于 双目操作符

!= 不等于 双目操作符

^ 位‘异或’ 双目操作符

+= 和赋值 双目操作符

-= 差赋值 双目操作符

*= 乘赋值 双目操作符

/= 商赋值 双目操作符

= 左移赋值 双目操作符

= 右移赋值 双目操作符

= 按位‘与’赋值 双目操作符

^= 按位异或赋值 双目操作符

|= 按位或赋值 双目操作符

%= 模赋值 双目操作符

= 赋值 双目操作符

?: 按条件取值 双目操作符

, 间隔符 标点符号

# 预处理符号 标点符号

## 预处理符号 标点符号

sizeof 求字节数

~ 按位求反

| 位‘或’

： 间隔符

； 间隔符

... 间隔符

要把表中的运算符仔细的分类是不容易的，因为同一个运算符，在不同的地方其含义是不同的。如＊运算符，当作为乘运算时是双目操作符（所谓双目操作符，即运算时需要二个操作数），如3＊6，那么3与6总共是二个操作数。当作为取值运算时就是单目操作符（所谓单目操作符是只需要一个操作数）如对一个数求反：!a，这里只有一个操作数a。

要记住运算符的二个特点，一个是运算符的操作对象，另一个就是运算符的优先级别。其中运算符的优先级别是最不容易搞清楚和最容易出错的地方。

在讲运算符之前讲一下“表达式”的概念：所谓表达式，就是用运算符把各个操作数连接成符合C语法规则的进行运算的式子。这里说的“符合C语法的规则”也很重要。如 a+b+5就是一个用算术运算符连接起来的表达式。

1、算术运算符：＋、－、＊、/、%

1）＋、－、＊、/ 分别是相加、相减、相乘、相除

2）% 求二个数运算的模。所谓求模就是求二个数相除后的余数。例：25/3的余数是1，可以说25%3的模是1。要注意的是求模运算时二个操作数必须是整数。如果求25.3/3.1这样是不能运算的。

下面写一个例子：

#includestdio.h /*程序中要用到输入输出库函数，所以包含了stdio.h*/

void main()

{

int a=10,b=20,c=30; /*定义了3个整型变量，并同时进行了初始化赋值*/

a=a*b+c; /*a*b+c组成了一个算术表达式，运算后的结果为230并把值*/

/*赋给变量a*/

printf("%d",a); /*以整型格式输出变量a的值。这里输出230*/

a=a%b; /*进行求模运算。因为没有余数，最后的模为0*/

printf("%d",a); /*输出变量a的值。这里输出0*/

}

下面是一个要考虑运算符优先级的例子：

#includestdio.h

void main()

{

int a=10,b=20,c=30;

a=c-a*b; /*这里就要考虑运算符优先级，＊运算符的优先级比－运算符*/

/*的高，所以先进行乘运算。这里最后结果为-170*/

}

由上面这个例子看到，在一个有多个运算符连接起来的表达式中需要考虑运算符的优先级，这个例子很简单。关于运算符优先级的概念其实在小学生的算术运算中就有这样的概念了，只不过这里的运算符多了一些，要考虑的情况也就复杂了。

如果这个式子改写一下，写成：a=(c-a)*b;在运算时就以括号中的运算优先。

几个简化的运算表达式：

在C语言的程序中，经常看到这样的运算,如：i++;或者k--;这是运算符号的简化写法。

1、加1运算的简写

当一个变量进行加1运算时，如a=a+1;这是变量自身加1，简写为a++;

2、减1运算的简写

当一个变量进行减1运算时，如a=a-1;这是变量自身减1，简写为a--;

3、加1个常量运算的简写

当一个变量与一个常量相加时，如a=a+5;这是变量自身加5，简写为a+=5;

4、减一个常量运算的简写

当一个变量与一个常量相减时，如a=a-5;这是变量自身减5，简写为a-=5;

5、乘一个常量运算的简写

当一个变量与一个常量相乘时，如a=a*5，这是变量自身乘5，简写为a*=5;

6、除一个常量运算的简写

当一个变量与一个常量相除时，如a=a/5;这是变量自身除5，简写为a/=5;

运算符的结合性（或称作关联性）

在一个复杂的表达式中，常常有许多运算符和变量，这时就要判断优先级和结合性这二个因素。

例：-5+7; 这样的一个表达式用结合性来判断，因为运算符'-'和'+'相对于运算的数来说是‘左’结合的，所以就有'-5'和'+7'所以运算的结果为 2。

通过这个例子要知道什么是“左结合性”和“右结合性”

左结合性－－变量（或常量）与左边的运算符结合

右结合性－－变量（或常量）与右边的运算符结合

运算符的优先级和结合性表

优先级 运算符（高 －－－－－－→低） 结合率 运算符类型

高 ( ) [ ] - . 从左至右 双目运算符

! ~ ++ -- （类型） sizeof + - * 从右至左 单目运算符

* / % 从左至右 双目运算符

+ - 从左至右 双目运算符

从左至右 双目运算符

= = 从左至右 双目运算符

== != 从左至右 双目运算符

从左至右 双目运算符

^ 从左至右 双目运算符

| 从左至右 双目运算符

从左至右 双目运算符

|| 从左至右 双目运算符

?: 从右至左 三目运算符

低 = += -= *= /= %= = ^= |= = = 从左至右 双目运算符

高 －－－－－－－－－－－－－→ 低

从表中可以看出一个规律，凡是单目运算符都是“右结合”的，凡是双目运算符都是“左结合”的。其中有一个?:运算符是三目运算符是右结合的，记住了这个规律，运算符的结合性也就掌握了。

如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。

由于将表熟记是比较困难的，为了防止产生歧义并提高可读性，应当用括号确定表达式的操作顺序。例如：

d = (high 8) | low /*用括号把需要先运算的括起来*/

if ((a | b) (a c)) /*用括号把需要先运算的括起来*/

例：

下列程序输出的结果是

#includestdio.h

void main()

{

int a=2;

a%=4-1;

printf("%d",a);

a+=a*=a-=a*=3;

printf("\n%d",a);

}

A. 2,0 B. 1,0

C. -1,12 D. 2,12

分析：由于%＝运算符的优先级别低于－运算，a%=4-1即是a%=3，等价于a=a%3即a=2%3=2，所以选项B和C是错误的。表达式a+=a*=a-=a*=3，计算时注意赋值类表达式的值和变量的值随时被更新，计算表达式的值，开始时a=2，表达式赋值是从左至右进行的，表达a*=3使得a=6，此表达式的值也为6，于是表达式a-=a*=3相当于a-=6=6-6=0，a的值为0，后面的计算就不用做了，所以a的值最终为0。

答：A

下列语句中错误的是

A.x=sizeof int;

B.x=sizeof 3.14

C.printf("%d",a=a+1,b--,c+1);

D.printf("%d",++x,x++);

分析：此题的选项A的作用是测试int类型所占内存的字节数，因为类型符要用括号括起来，这时缺少括号是错误的。

选项B是正确的。

选项C从表面上看似乎复杂一些，但其中的a=a+1,b--,c+1是一个逗号表达式，C语言允许使用这种表达式所以D也是正确的。

答案：A

下面的语句中，符合C语言语法的赋值语句是

A.a=7+b+c=a+7; B.a=7+b++=a+7;

C.a=7+b,b++,a+7; D.a=7+b;c=a+7;

分析：一般情况下，表达式不能放在赋值号的左边，所

c语言中函数,主函数,被调用高数,库函数的含意

主函数就是程序最先执行的函数，程序的入口，只有一个“main”函数，被调用函数就是别的一个函数调用另一个函数时被调用的那个函数，库函数是C语言已经定义好的函数不用你自己写，直接引入头文件然后调用

#include stdio.h

void main()

{

printf("This is myprint!\n");

}

这里主函数就是main

被调用函数就是printf，也是库函数头文件stdio.h定义的

C语言中的main（）函数

一、定义

main函数,又称主函数,是程序执行的起点，main是相对来说的,如同音学理论之主调于泛音,泛音即程序中的除main之外的其他函数，迎合人们的思考方式而生成的而非必定的模式.有主有次，执行起来条清缕析，既可将程序模块化又实现了一个闭合的整体。

二、main()函数的形式

在最新的 C99 标准中，只有以下两种定义方式是正确的：

int main( void )  /* 无参数形式 */

{

...

return 0;

}

int main( int argc, char *argv[] ) /* 带参数形式 */

{

...

return 0;

}

int指明了main()函数的返回类型 ，函数名后面的圆括号一般包含传递给函数的信息。void表示没有给函数传递参数。

三、main()函数的返回值

从前面我们知道main()函数的返回值类型是int型的，而程序最后的 return 0; 正与之遥相呼应，0就是main()函数的返回值。那么这个0返回到那里呢？返回给操作系统，表示程序正常退出。

因为return语句通常写在程序的最后，不管返回什么值，只要到达这一步，说明程序已经运行完毕。而return的作用不仅在于返回一个值，还在于结束函数。

四、main()函数的参数

C编译器允许main()函数没有参数，或者有两个参数 （有些实现允许更多的参数，但这只是对标准的扩展）。这两个参数，一个是int类型，一个是字符串类型。

第一个参数是命令行中的字符串数。按照惯例（但不是必须的），这个int参数被称为argc（argument count）。第二个参数是一个指向字符串的指针数组。命令行中的每个字符串被存储到内存中，并且分配一个指针指向它。

按照惯例，这个指针数组被称为argv（argument value）。系统使用空格把各个字符串格开。一般情况下，把程序本身的名字赋值给argv[0]，接着，把最后的第一个字符串赋给argv[1] ，等等。

扩展资料

C++中的main函数的应用：

C++继承了C语言的大部分特性，因此保留了“程序总是从main函数开始执行，且总是默认从main函数的return语句或结尾处结束运行”这一传统，但是要注意，C++中的main函数要想作为程序执行的出入口，必须写在全局(Global)范围，不能写成某个结构体或某个类的成员。

虽然main函数可以作为结构体或者类的成员函数，但相应地会失去作为程序出入口的功能。C++中全局main函数的书写格式与C语言完全相同，功能也完全相同，且同一C++程序同样只能有一个全局main函数。

参考资料：百度百科——main函数

c语言函数的构成是什么?

c语言函数由主函数main和其他函数组成。

C语言函数是一种函数，用来编译C语言，所在库函数为ctype.h，分为分类函数，数学函数，目录函数，进程函数，诊断函数，操作函数等。“函数”是从英文function翻译过来的，其实，function在英文中的意思即是“函数”，也是“功能”。

从本质意义上来说，函数就是用来完成一定功能的。这样对函数的概念就很好理解了，所谓函数名就是给该功能起个名字，如果该功能是用来实现数学运算的，就是数学函数。

相关知识：

C语言是目前世界上流行、使用最广泛的面向过程的高级程序设计语言。C语言对操作系统和系统使用程序以及需要对硬件进行操作的场合，用C语言明显优于其它高级语言。

许多大型应用软件都是用C语言编写的。C语言是以函数形式提供给用户的，这些函数可方便的调用，并具有多种循环、条件语句控制程序流向，从而使程序完全结构化。

C语言库函数如何编写？

/***

*printf.c - print formatted

*

* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.

*

*Purpose:

* defines printf() - print formatted data

*

*******************************************************************************/

#include

#include

#include

#include

#include

#include

#include

/***

*int printf(format, ...) - print formatted data

*

*Purpose:

* Prints formatted data on stdout using the format string to

* format data and getting as many arguments as called for

* Uses temporary buffering to improve efficiency.

* _output does the real work here

*

*Entry:

* char *format - format string to control data format/number of arguments

* followed by list of arguments, number and type controlled by

* format string

*

*Exit:

* returns number of characters printed

*

*Exceptions:

*

*******************************************************************************/

int __cdecl printf (

const char *format,

...

)

/*

* stdout ''PRINT'', ''F''ormatted

*/

{

va_list arglist;

int buffing;

int retval;

va_start(arglist, format);

_ASSERTE(format != NULL);//断言宏。如果输出格式字符串指针为空，则在DEBUG版下断言，报告错误。

_lock_str2(1, stdout);

buffing = _stbuf(stdout);//stdout:指定输出到屏幕

retval = _output(stdout,format,arglist);

_ftbuf(buffing, stdout);

_unlock_str2(1, stdout);

return(retval);

}

以上为printf()的源代码

1、从含有可选参数函数中获得可选参数，以及操作这些参数

typedef char *va_list;

void va_start( va_list arg_ptr, prev_param );

type va_arg( va_list arg_ptr, type );

void va_end( va_list arg_ptr );

假定函数含有一个必选参数和多个可选参数，必选参数声明为普通数据类型，且能通过参数名来获得该变量的值。可选参数通过宏va_start、va_arg和va_end（定义在stdarg.h或varargs.h中）来进行操作，即通过设置指向第一个可选参数指针、返回当前参数、在返回参数后重新设置指针来操作所有的可选参数。

va_start:为获取可变数目参数的函数的参数提供一种便捷手段。设置arg_ptr为指向传给函数参数列表中的第一个可选参数的指针，且该参数必须是va_list类型。prev_param是在参数列表中第一个可选参数前的必选参数。

va_arg：返回由arg_ptr所指向的参数的值，且自增指向下一个参数的地址。type为当前参数的类型，用来计算该参数的长度，确定下一个参数的起始位置。它可以在函数中应用多次，直到得到函数的所有参数为止，但必须在宏va_start后面调用。

va_end:在获取所有的参数后，设置指针arg_ptr为NULL。

下面举例说明：

#include

#include

int average( int first, ... );

void main( void )

{

/* Call with 3 integers (-1 is used as terminator). */

printf( "Average is: %d\n", average( 2, 3, 4, -1 ) );

/* Call with 4 integers. */

printf( "Average is: %d\n", average( 5, 7, 9, 11, -1 ) );

/* Call with just -1 terminator. */

printf( "Average is: %d\n", average( -1 ) );

}

int average( int first, ... )

{

int count = 0, sum = 0, i = first;

va_list marker;

va_start( marker, first ); /* Initialize variable arguments. */

while( i != -1 )

{

sum += i;

count++;

i = va_arg( marker, int);

}

va_end( marker ); /* Reset variable arguments. */

return( sum ? (sum / count) : 0 );

}

返回值为：

Average is: 3

Average is: 8

Average is: 0

综上所述，在printf()函数中，可以只输出一个字符串，也可按照一定的形式输出含有多个可选参数的字符串信息。因此，首先就要通过这些宏来获取所有的可选参数。在上面的源码可以看出printf()中，只使用了宏at_start,将可选参数的首地址赋给了arglist。

2、锁定字符串及输出字符串到屏幕

#define _lock_str2(i,s) _lock_file2(i,s)

void __cdecl _lock_file2(int, void *);

#define _unlock_str2(i,s) _unlock_file2(i,s)

void __cdecl _unlock_file2(int, void *);

int __cdecl _stbuf(FILE *);

void __cdecl _ftbuf(int, FILE *);

int __cdecl _output(FILE *, const char *, va_list);

在output函数中，读取格式字符串中的每一个字符，然后对其进行处理，处理方式根据每一个字符所代表的意义来进行，如：普通字符直接利用函数WRITE_CHAR(ch, charsout);输出到控制台。

其中的主要部分是对转换说明符（d,c,s,f）的处理，现在将对其中的部分代码进行详细说明，这里只说明最基本的转换说明符，对这些须基本的转换说明符进行修饰的修饰符，程序中单独进行处理。下面是函数output()(output.c)部分源代码：

case ST_TYPE:

//表示当前处理的字符的类型为转换说明符。

...

switch (ch) {

//下面对参数的获取都是利用宏va_arg( va_list arg_ptr, type );来进行的。

case ''c'': {

//从参数表中获取单个字符，输出到缓冲字符串中，此时，type=int

buffer[0] = (char) get_int_arg(argptr); /* get char to print */

text = buffer;

textlen = 1; /* print just a single character */

}

break;

case ''s'': {

//从参数表中获取字符串，输出到缓冲字符串中，此时，type=char*

int i;

char *p; /* temps */

text = get_ptr_arg(argptr);

...

}

break;

case ''w'': {

//对宽字符进行处理

...

} /* case ''w'' */

break;

...

case ''e'':

case ''f'':

case ''g'': {

//对浮点数进行操作

...

#if !LONGDOUBLE_IS_DOUBLE

/* do the conversion */

if (flags FL_LONGDOUBLE) {

_cldcvt((LONGDOUBLE*)argptr, text, ch, precision, capexp);

va_arg(argptr, LONGDOUBLE);

//对长双精度型进行处理，此时，type=long double

}

else

#endif /* !LONGDOUBLE_IS_DOUBLE */

{

//对双精度型进行处理，此时，type=double

_cfltcvt((DOUBLE*)argptr, text, ch, precision, capexp);

va_arg(argptr, DOUBLE);

}

...

break;

//对整型变量处理

case ''d'':

case ''i'':

...

goto COMMON_INT;

case ''u'':

radix = 10;

goto COMMON_INT;

case ''p'':

...

goto COMMON_INT;

case ''o'':

...

注：对于浮点型double和long double，有相应的转换说明符（%f表示双精度型，%lf表示长双精度型），而float却没有。其中的原因是，在KRC下，float值用于表达式或用作参数前，会自动转换成double类型。而ANSI C一般不会自动把float转换成double。有些程序已假定其中的float参数会被转换成double,为了保护大量这样的程序，所有printf()函数的float参数还是被自动转换成double型。因此，在KRC或ANSI C下，都无需用特定的转换说明符来显示float型。

综上所述，转换说明符必须与待打印字符的类型。通常，用户有种选择。例如，如要打印一个int类型的值。则只可以使用%d,%x或%o。所有这些说明符都表示要打印一个int类型的值；它们只不过提供了一个数值的几种不同表示。类似一，可以用%f、%g和%e来表示double类型的值。但如果转换说明与类型不匹配，将会出现意想不到的结果。为什么呢？问题就在于C向函数传递信息的方式。

这个失败的根本细节与具体实现相关。它决定了系统中的参数以何方式传递。函数调用如下：

float n1;

double n2;

long n3;

long n4;

...

printf("%ld,%ld,%ld,%ld",n1,n2,n3,n4);

这个调用告诉计算机，要把变量n1,n2,n3和n4的值交给计算机，它把这些变量放进称作栈（stack）的内存区域中，来完成这一任务。计算机把这些值放进栈中，其根据是变量的类型而不是转换说明符，比如n1,把8个字节放入栈中（float被转换成double），类似地，为n2放了8字节，其后给n3和n4各放了4个字节。接着，控制的对象转移到printf()；此函数从栈中读数，不过在这一过程中，它是在转换说明符的指导下，读取数值的。说明符%ld指定printf()应读4个字节(va_arg( va_list arg_ptr, type )中type=long)，因此printf()读入栈中的4个字节，作为它的第一个值。但是这只是n1的前半部分，这个值被看成一个long整数。下一个说明符%ld读入4个字节，这正是n1的后半部分，这个值被看成第二个long整数。类似地，第三、第四次又读入n2的前后两部分。因此，尽管我们对n3和n4使用了正确的说明符，printf()仍然会产生错误。

新闻标题：c语言主函数和库函数代码 c语言主函数和库函数代码区别
文章起源：http://mswzjz.cn/article/hphojd.html