C语言基础知识【摘抄文章，仅供内部学习，如果涉及版权，立刻删除】

01.C 程序基本结构

一、 C 语言的特点：

1 、 C 语言源程序的基本组成单位是函数；一个 C 程序可由若干个函数组成，其中必须有且仅有一个以 main 命名的主

函数，其余的函数名称可由编程者自行设定。3

2 、 C 程序的执行总是由 main() 函数的第一个可执行语句开始，到 main （）函数的最后一个可执行的语句结束；而其他

函数都是在 main （）函数开始执行以后，通过其他函数的调用才得以运行。

3 、 C 语言系统提供了丰富的库函数，用户在程序中需要调用某个库函数时，必须用 #include 编译预处理命令将描述该

库函数的头文件包含进去。

二、 C 程序的书写格式：

1 、语句可从分开放在任意多行内；

如： printf(“To C,”);

printf(“ or not to C:”);

与 printf(“To C , or not to C:”); 是等价的

2 、一行中可以有若干个语句；

如： a=123;b=345;

3 、每个语句和数据定义的最后必须有一个分号；

三、 C 语言程序的运行：

1 、编译 (Compile) ：将 C 源程序文件翻译成能被计算机识别的二进制形式的 “ 目标 ” 文件；编译时，编译器将检查源程

序每一条语句的语法错误。

2 、建造 (Bulid) ：

C 语言程序示例：显示 “Hello”

#include<stdio.h>

int main(void)

{

printf(“Hello.\n”);

return 0;

}

说明： #include<stdio.h> 是必不可少的，它包含了 C 语言标准输入输出库的相关信息；

printf 函数来自 ” 标准输入输出库 ” ，可以产生格式化输出；

\n 告诉 printf 函数执行完信息显示后要进行换行操作；

return 0 表明程序终止时会向操作系统返回值 0 ；

{ } 来标出 main （）函数的起始和结束。

02. 数据类型

一、 C 语言的特点：

1 、 C 语言源程序的基本组成单位是函数；一个 C 程序可由若干个函数组成，其中必须有且仅有一个以 main 命名的主

函数，其余的函数名称可由编程者自行设定。

2 、 C 程序的执行总是由 main() 函数的第一个可执行语句开始，到 main （）函数的最后一个可执行的语句结束；而其他

函数都是在 main （）函数开始执行以后，通过其他函数的调用才得以运行。

3 、 C 语言系统提供了丰富的库函数，用户在程序中需要调用某个库函数时，必须用 #include 编译预处理命令将描述该

库函数的头文件包含进去。

二、 C 程序的书写格式：

1 、语句可从分开放在任意多行内；

如： printf(“To C,”);

printf(“ or not to C:”);

与 printf(“To C , or not to C:”); 是等价的

2 、一行中可以有若干个语句；

如： a=123;b=345;

3 、每个语句和数据定义的最后必须有一个分号；

三、 C 语言程序的运行： 1 、编译 (Compile) ：将 C 源程序文件翻译成能被计算机识别的二进制形式的 “ 目标 ” 文件；编译时，编译器将检查源程

序每一条语句的语法错误。

2 、建造 (Bulid) ：

C 语言程序示例：显示 “Hello”

#include<stdio.h>

int main(void)

{

printf(“Hello.\n”);

return 0;

}

说明： #include<stdio.h> 是必不可少的，它包含了 C 语言标准输入输出库的相关信息；

printf 函数来自 ” 标准输入输出库 ” ，可以产生格式化输出；

\n 告诉 printf 函数执行完信息显示后要进行换行操作；

return 0 表明程序终止时会向操作系统返回值 0 ；

{ } 来标出 main （）函数的起始和结束。

03, 运算符和表达式

1 、算术运算符和表达式

+ ：加法运算符，如 3 ＋ 5 ；

- ：减法运算符，如 5-3 ；

* ：乘法运算符，如 5*8 ；

/ ：除法运算符，如 3/6 ；参与运算量均为整型时，结果也为整型，舍去小数；若运算量中有一个是实型，则结果为

双精度实型。

% ：模运算符，也称 “ 取余运算符 ” ，用于计算两数相除后的余数，如 5%3=2 ；

2 、赋值运算符和赋值表达式

赋值运算符： ” ＝ ” ，其作用是将一个表达式的值赋给一个变量；

其一般形式为：变量 = 表达式

如：

x=a+b;

赋值表达式的功能是计算表达式的值再赋予左边的变量。赋值运算符具有右结合性。因此 a=b=c=5 可理解为

a=(b=(c=5));

复合赋值运算符： += 、 -= 、 *= 、 /= 、 %= 、 >>= 、 <<= 、 &= 、 ^= 、 |=

构成复合赋值表达式的一般形式为：变量

双目运算符 = 表达式

它等价于：变量 = 变量 运算符 表达式

如：

a+=5

等价于 a=a+5

x*=y+7

等价于 x=x*(y+7)

r%=p

等价于 r=r%p

3 、类型转换

如果赋值运算符两边的数据类型不相同，系统将自动进行类型转换，即把赋值号右边的类型换成左边的类型。具体规定如

下：

1) 实型赋予整型，舍去小数部分。前面的例子已经说明了这种情况。

2) 整型赋予实型，数值不变，但将以浮点形式存放，即增加小数部分 ( 小数部分的值为 0) 。

3) 字符型赋予整型，由于字符型为一个字节，而整型为二个字节，故将字符的 ASCII 码值放到整型量的低八位中，高

八位为 0 。整型赋予字符型，只把低八位赋予字符量。

4 、自增、自减运算符：

自增运算符： “++” ，功能是将变量的值加 1 ； 自减运算符： “--” ，功能是将变量的值减 1 ；

可有以下几种形式：

++i

i 自增 1 后再参与其它运算。

--i

i 自减 1 后再参与其它运算。

i++

i 参与运算后， i 的值再自增 1 。

i--

i 参与运算后， i 的值再自减 1 。

注：

（ 1 ） ”++” 、 ”--“ 的操作对象只能是变量；

(2)”++” 、 ”--“ 运算优先级相同，且结合方向自右向左； -i++ 应理解为 - （ i++ ），

【例】自增、自减运算、

#include<stdio.h>

main()

{

int i=8;

printf("%d\n",++i); /* i 先加 1 ，再输出 i ，输出结果为 9 */

printf("%d\n",--i);

/* i 先减 1 ，再输出 i ，结果为 8 */

printf("%d\n",i++); /* 先输出 i ，输出结果为 8 ， i 再加 1 ， */

printf("%d\n",i--); /* 先输出 i ，输出结果为 9 ， i 再减 1 ， */

printf("%d\n",-i++); /* 先加输出 -i ，输出结果为 -8 ， i 再加 1 */

printf("%d\n",-i--); /* 先输出 -i ，输出结果为 -9 ， i 再减 1 */

}

5 、求字节运算符

计算表达式的结果所占字节数或某种数据类型的定义字节数。

一般格式： sizeof( 数据类型标识符 ) 或 sizeof （表达式）

如： sizeof （ float ）的值为 4 ，占 4 个字节；

sizeof （ 2*3 ）的值为 2 ，占 2 个字节；

6 、关系运算符和关系表达式

关系运算符： “<”( 小于 ) 、 “<=”( 小于等于 ) 、 ”>”( 大于 ) 、 ”>=”( 大于等于 ) 、 ”==” （等于）、 “!=” （不等于）

关系表达式：若关系表达式成立，其值为 “ 真 ” ，否则为 “ 假 ” ；在 C 语言中，用 0 代表 “ 假 ” ，用 1 代表 “ 真 ” ；

7 、逻辑运算符和逻辑表达式：

逻辑运算符： “!” （非）、 “&&” （与）、 “||” （或）；运算优先级： !>&&>||

逻辑表达式：用逻辑运算符将表达式连接起来的式子；逻辑表达式的结果仍然是逻辑量（ “ 真 ” 或 “ 假 ” ）

8 、条件运算符：

一般格式： < 表达式 1>?< 表达式 2>:< 表达式 3>

先计算表达式 1 ，若表达式 1 的值为真，则计算表达式 2 的值，且表达式 2 的值为整个条件表达式的值；否则，计算

表达式 3 的值，且表达式 3 的值即为整个条件表达式的值。

9 、逗号运算符和逗号表达式

逗号运算符： ”,” 作为运算符，其功能是将多个表达式组成一个表达式；

一般形式：表达式 1 ，表达式 2 ， … ，表达式 n

求解过程：先计算表达式 1 ，再计算表达式 2 ，依此计算表达式 n ，最终，表达式 n 的值即为整个表达式的值。

04. 顺序结构

一、概述：

顺序语句按照语法形式分为：表达式语句、函数调用语句、复合语句、流程控制语句和空语句。

1 、表达式语句：

语法格式：表达式；

如： a+4 ；

其中赋值语句为最典型的表达式语句，如：

a=5; a=b+3;

特别提示：分号（ ; ）是表达式语句中不可缺少的一部分。

2 、函数调用语句：

如： printf （ ”I am a student ！ ” ） ;

其中： printf() 为系统提供的函数，用于显示信息。

3 、复合语句：

所谓 “ 复合语句 ” 即由一对 “{}” 括起来的一组语句，也称 “ 块语句 ” 或 “ 分程序 ” 。

一般形式为：

{

语句 1

语句 2

...

语句 n

}

如：

{

i++;

j=a+3;

printf("%d,j=",i,j);

}

特别提示：复合语句中的最后一条语句的分号不得缺少；复合语句的 “}” 之后不得有分号。

4 、空语句 :

“ 空语句 ” 即为一个独立的分号。

如：

main （）

{

...

;

...

}

二、数据的输入输出

C 语言提供了一些输入输出函数，如 printf() 和 scanf() ，在程序中调用这些输入输出函数时，必须将标准输入输出头文

件 “stdio.h” 包含到用户所编写的源程序中。

如： #include <stdio.h>

其中： #include 命令一般写在程序的开头位置。

1 、格式输入输出

1 、格式输出函数 printf()

(1) 一般格式： printf( 格式字符串，输出列表 )

其中： “ 格式字符串 ” 包括 “ 输出字符 ” 和 “ 格式控制字符 ”( 由 % 和格式字符组成，指定输出项的输出格式）。

• d 格式符：用于输出十进制整数；

%d: 以十进制形式显示输出变量的值；

%5d ：以十进制形式显示变量的值，且至少占用 5 个字符的空间，若不够 5 位数字，则左侧补空格；

%-5d ：以十进制形式显示变量的值，且至少占用 5 个字符的空间，左对齐；

%5.3d ：以十进制形式显示变量的值，且至少占用 5 个字符的空间并至少有 3 位数字 , 若不够 3 位数字，则左

侧补 0 ；

如： #include<stdio.h>

main()

{

int i;

i=40;

printf(“%d\n”,i); printf(“%5d\n”,i);

printf(“%-5d\n”,i);

printf(“%5.3d\n”,i);

}

• f 格式符：用于以小数形式输出实数；

%10.3f: 以定点十进制形式显示变量的值，且总共用 10 个字符，其中，整数位 6 位，小数位 3 位，小数点 1

位；

如： #include<stdio.h>

main()

{

float x;

x=839.21f;

printf(“%10.3f\n”,x);

}

• c 格式符：用于输出一个字符；

如： x=”a”,y =”b”,

则 printf(%c %c",x,y) 的输出结果为： a b

若变量的值为整数，则输出该整数值为 ASCII 码的字符：

如 x=65,y=98 ，则 printf(“%c, %c”,x,y) 的输出结果为： A, b;

同理，一个字符的数据也可以以整数的形式输出；

如 x=’a’,y=’B’ ，则 printf(“%d,%d”,x,y) 的输出结果为： 97,66

• s 格式符：用于输出一个字符串。

如： printf(“%s”,”I am a student !”)

• e,E 格式符：用于以指数形式输出实数。

如： printf(“%e”, 123.456) ，则输出结果为： 1.234560e+002;

• g,G 格式符：用于输出实数，根据数值的大小自动选择 f 格式或 e 格式。

2 、格式输入函数 scanf()

(1) 一般格式：

scanf( 格式字符串，变量地址表 )

其中：格式字符串使用双引号括起来的字符串，包括 “ 普通字符 ” （按原样输入）、 “ 格式控制字符 ” （由 % 和格式

字符组成，用来标定输入数据的格式）。

变量地址表是由若干个变量地址组成的表列，可以是变量的地址，也可以使字符串的首地址。

• d 格式：用于输入十进制整数；

如： scanf(“%d,%d”,&x,&y); 则输入格式为： 123 ， 3456

•u 格式：用于输入十进制无符号整数；

•f 格式：用于输入以小数形式的实数；

如： scanf(“%f,%f”,&x,&y); 则输入格式为： 123.23,23.456

•c 格式：用于输入一个字符；

如 :scanf(“%c,%c”,&x,&y); 则输入格式为： a,b

•s 格式：用于输入一个字符串；

如： scanf(“%s”,a); 假定 a 为字符数组，则输入格式为： abcdef

注：输入的字符串中间不能包含空格。

特别说明：

• 对于变量， ”&” 加变量名即为该变量的地址；如： &a 、 &b 等分别表示变量 a 和变量 b 的地址；

• 对于字符串数组或字符指针型变量，数组名和指针变量名本身即为其地址；

• 可以在 % 和格式字符之间加表示位数的数字；如： scanf(“%5s”,p); 表示只能输入 5 个字符给字符串指针 p ；

3 、字符数据的输入输出：

(1)putchar() 函数：是向标准输入输出设备输出一个字符；

其调用格式为： putchar(ch); 其中： ch 为一个字符变量或常量；

putchar() 函数作用等同于 printf(“%c”,ch) ； (2)getch() getche() 和 getchar() 函数：

•getch() ：从键盘上读入一个字符，但不显示在屏幕上；

•getche() ：从键盘上读入一个字符，显示在屏幕上；

•getchar() ：从键盘上读入一个字符，并显示在屏幕上，但直到输入回车键时才结束输入，第一个字符为其函数的返

回值。

05. 选择结构

一、 if 语句：

一般格式：

if( 表达式 ) 语句；

表示：当 “ 表达式 ” 成立时，则执行 “ 语句 ”; 否则跳过 “ 语句 ” ；

如： if (a>b) printf(“a>b!”);

例：若用户输入的数为 3 的倍数，则显示 ”OK”

#include<stdio.h>

main()

{

int a;

scanf(“%d”,&a);

if(a %3==0) printf(“OK”);

}

二、 if-else 语句：

一般格式：

if ( 表达式 )

语句 1;

else

语句 2;

例：给出用户输入的两个整数的较大者

#include<stdio.h>

main()

{

int a,b;

scanf(“%d,%d”,&a,&b);

if(a>b)

printf(“the max=%d”,a);

else

printf(“ the max=%d”,b);

}

三、 if 语句的嵌套

1 、 if 子句中嵌套：

• if( 表达式 1)

if( 表达式 2) 语句 1;

else 语句 2;

else 语句 3;

• if( 表达式 1)

{ if( 表达式 2) 语句 1; }

else 语句 2; 2 、 else 子句中嵌套

• if ( 表达式 1) 语句 1;

else

if( 表达式 2) 语句 2;

else 语句 3;

• if( 表达式 1) 语句 1;

else

if( 表达式 2) 语句 2;

3 、嵌套一般格式：

if ( 表达式 1) 语句 1;

else if ( 表达式 2) 语句 2;

else if ( 表达式 3) 语句 3 ;

…

else if( 表达式 n) 语句 n;

else 语句 n+1;

例：将用户输入的成绩按以下规则转换成等级成绩：

分数： 90~100

等级：优

分数： 80~89

等级：良

分数： 70~79

等级：中

分数： 60~69

等级：及格

分数： 60 以下

等级：不及格

# include<stdio.h>

main()

{

int d;

printf(“ 输入分数： ”);

scanf(“%d”,&d);

if(d>=90 ) printf(“ 优 ”);

else if(d>=80) printf(“ 良 ”);

else if(d>=70) printf(“ 中 ”);

else if(d>=60) printf(“ 及格 ”);

else printf(“ 不及格 ”);

}

四、条件语句：

表达式 1 ? 表达式 2 : 表达式 3

执行的过程：若表达式 1 的值为非 0 时，该条件语句的职位表达式 2 ，否则为表达式 3 ；

例：求一个整数的绝对值

#include<stdio.h>

main()

{

int i,absi;

scanf(“%d”,&i);

absi=i>0 ? i : -i;

printf(“%d 绝对值是 %d\n”,i,absi);

}

五、 switch 语句 switch （表达式）

{

case 常量表达式 1 ：

语句 1 ;

break;

case 常量表达式 2 ：

语句 2 ;

break;

…

case 常量表达式 n ：

语句 n ;

break;

default:

语句 n+1;

}

例：商店卖货物，每一件 3.5 元，按购买的数量给与优惠：

购买 100 件，优惠 5% ；

购买 200 件以上，优惠 6% ；

购买 300 件以上，优惠 8% ；

购买 400 件以上，优惠 10% ；

购买 500 件以上，优惠 15% ；

#include<stdio.h>

main()

{

int n;

float p,price;

scanf("%d",&n);

switch(n/100)

{

case 1:

p=0.05;

break;

case 2:

p=0.06;

break;

case 3:

p=0.08;

break;

case 4:

p=0.10;

break;

case 5:

p=0.15;

break;

}

price=3.5*n*(1-p);

printf("% 应付款 =%7.2f\n",price);

}

06. 循环结构

一、 for 语句： 一般格式： for( 表达式 1 ; 表达式 2; 表达式 3) 语句 ;

表示：先计算表达式 1 的值，再计算表达式 2 的值，若表达式 2 的值为 0 ，则跳出循环体，转去执行循环体后面的程序

命令；若表达式 2 的值非 0 ，则执行循环体中的语句，接着计算表达式 3 的值；而后，再从计算表达式 2 的值开始重复上

诉操作，直到表达式 2 的值为 0 时结束。

例：计算 sum=1+2+3+…+100 的值 ”

#include<stdio.h>

main()

{

int i,sum;

sum=0;

for(i=1;i<=100;i++)

sum=sum+i;

printf(“sum=%d”,sum);

}

二、 while 语句：

一般格式：

while< 表达式 >

语句 ;

表示：先计算表达式的值，若为非 0 ，则执行循环体语句，然后再计算表达式的值，重复上述过程，直到计算表达

式的值为 0 时结束循环。

例：计算 sum=1+2+3…+100 的值

#include<stdio.h>

main()

{

int i,sum;

i=1;

sum=0;

while(i<=100)

{

sum=sum+i;

i++;

}

printf(“sum=%d”,sum);

}

三、 do-while 语句

1 、一般格式：

Do

语句；

While< 表达式 >;

表示：先执行一次循环语句，然后计算表达式的值，若表达式的值非 0 ，则再执行循环语句，然后从计算表达式的值

开始重复上述过程，直到计算表达式的值为 0 ，循环结束。

例：计算 sum=1+2+3…+100 的值

#include<stdio.h>

main()

{

int i,sum;

i=1;

sum=0; do

{

sum=sum+i;

i++;

}while(i<=100);

printf(“sum=%d”,sum);

}

四、 break 和 continue 语句：

1 、 break 语句：

使用 break 语句可以提前结束由 while 、 for 、 do-while 语句构成的循环，而去执行循环下面的语句。

例：判定用户输入的一个数是否为素数

#include<stdio.h>

main()

{

int a,d;

printf(“ 请输入一个整数： ”);

scanf(“%d”,&a);

for(d=2;d<a;d++)

if(a%d==0)

break; // 跳出当前的循环，执行循环后面的语句

if(d<a)

printf(“%d 不是素数 ”, a);

else

printf(“%d 是素数 “,a);

}

2 、 continue ：

continue 语句用于 for 、 while 、 do-while 语句中，其作用是结束本次循环，接着进入下一次是否执行循环的判断。

例：输入 10 个非 0 的整数并求和。

#inclu de<stdio.h>

main()

{

int i,n=0,sum=0;

while(n<10)

{

printf(“ 请输入整数： ”);

scanf(“%d”,&i);

if(i==0)

continue; // 若为 0 ，则继续输入下一个数

sum+=i;

n++;

}

printf(“%d”,sum);

}

五、三种循环的比较：

1 、三种循环可以处理同一个问题，一般情况下可以相互代替；

2 、 while 和 do-while 循环语句只在 while 语句之后指定循环条件，在循环体内应包含使循环趋于结束的语句； for 循

环语句可以在 < 语句 3> 中包含使循环趋于结束的语句；

3 、对于 while 和 do-while 循环语句，循环变量的初始化应在 while 和 do-while 语句之前完成； for 循环语句可以在 <

表达式 1> 中进行；

4 、 while 和 for 语句是先判断表达式，后执行循环； do-while 循环语句是先执行循环，后判断表达式； 07 数组

数组是一组具有同一名字、不同下标的变量。数组中带下标的变量称为数组元素，每个数组元素由数组名字和下标唯一地

来确定；同一数组中的元素数据类型相同。

一、一维数组：

1 、定义：只有一个下标的数组。

2 、定义格式： 类型说明符 数组名 [ 常量表达式 ]

如： int a[3]; // 定义了一个一维数组，名称为 a ，数据类型为整型，含 3 个数组元素 a[0] 、 a[1] 、 a[2] ；

说明：

• 类型说明符：是指数组的数据类型；

• 常量表达式：是一个值为正整数的表达式，用来表示该数组的元素的个数，即数组的大小；

3 、数组的引用： 数组名 [ 下标 ];

如： a[2]

4 、数组的初始化：

• 对数组的全部因素赋初值：

如： int a[3]={10,20,30}; 则该语句执行后， a[0]=10,a[1]=20,a[2]=30 ；

• 对数组的部分元素赋初值 :

如： int b[3]={12,11}; 则该语句执行后， b[0]=12,b[1]=11,a[2]=0 ；

• 对数组的全部元素赋初值时，也可将数组定义为一个不确定长度的数组：

如： int c[ ]={10,15,20}; 则该语句执行后，数组 c 的长度自动确定为 3 ， c[0]=10,c[1]=15,c[2]=20 ；

例：将输入的 10 个整数按反序输出

#include<stdio.h>

main()

{

int a[10],i;

printf(" 请输入 10 个整数： ");

for(i=0;i<10;i++)

scanf("%d",&a[i]);

printf(" 反序输出 :" ） ;

for(i=9;i>=0;i--)

printf("%d",a[i]);

printf("\n");

}

例：计算 Fibonacci 数列的前 20 项

Fibonacci 数列定义：

f(1)=1

f(2)=1

f(n)=f(n-1)+f(n-2) (n>2)

#include<stdio.h>

main()

{

int f[21],i;

f[1]=1;

f[2]=1;

for (i=3;i<=20;i++)

f[i]=f[i-1]+f[i-2];

for (i=1;i<=20;i++)

{

printf("%8d",f[i]);

// 每个数字占 8 位 if(i%5==0)

printf("\n");

// 按 5 个一行输出

}

}

二、二维数组：

具有两个下标的数组为二维数组。

1 、定义格式： 类型说明符 数组名 [ 常量表达式 ][ 常量表达式 ]

如： int a[3][2]; // 定义了一个二维数组，名称数组名为 a ，含有 6 个元素： a[0][0] 、 a[0][1] 、 a[1][0] 、 a[1][1] 、 a[2][0] 、

a[2][1] ；

说明：

• 第一个常量表达式指出的是数组的行数；第二个常量表达式指出的是数组的列数；

• 二维数组元素的顺序是：按行存放；即先顺序存放第一行的元素，再存放第二行的元素 … 以此类推；

其存储格式：

a[0][0]

a[0][1]

a[1][0] a[1][1]

a[2][0] a[2][1]

2 、二维数组的初始化：

同一维数组。

• 分行为二维数组赋初值：

int a[3][2]={{1,2},{3,4},{5,6}}; 则该语句执行后， a[0][0]=1, a[0][1]=2, a[1][0]=3,a[1][1]=4, a[2][0]=5, a[2][1]=6 ；

• 按数组在存储时的排列次序赋初值：

int a[3][2]={1,2,3,4,5,6};

• 对数组的部分元素赋初值：

int a[3][2]={{1},{2,3},{4}};

• 忽略第一维的长度 , 对二维数组赋初值：

int a[][2]={1,2,3,4,5,6}; 该语句执行后， C 语言系统自动计算出第一维的长度为 6/2=3 ，同样有： a[0][0]=1,

a[0][1]=2,a[1][0]=3,a[1][1]=4, a[2][0]=5, a[2][1]=6 ；

例：将两个 2 行 3 列的矩阵相加，并显示结果。

#include<stdio.h>

main()

{

int a[2][3]={1,3,5,7,9,11};

int b[2][3]={2,4,6,8,10,12};

int c[2][3],sum=0,i,j;

for(i=0;i<2;i++)

//i 表示第 1 行到第 3 行

for(j=0;j<3;j++)

//j 表示第 1 列到第 3 列

c[i][j]=a[i][j]+b[i][j];

for(i=0;i<2;i++)

for (j=0;j<3;j++)

{

printf(“%5d”,c[i][j]);

if((j+1)%3==0) printf(“\n”);

}

}

08 字符数组

字符数组是用来存放字符的数组，字符数组中的一个元素存放一个字符。

1 、字符数组的定义：

char a[10]; 2 、字符串：字符串是借助于字符数组来存放的，并规定以字符 ’\0’( 占用存储空间，但不计入字符串的长度 ) 为字符串

的结束标记。

3 、字符串处理函数：

•scanf(“%s”,a); // 以格式符 %s 输入字符串，输入的字符串自动以 ’\0’ 结尾；输入的字符数组名前不加 ”&” 前缀；

•printf(“%s”,a); // 以格式符 %s 输出字符串，输出的字符串以 ’\0’ 结尾；

•gets(a); //a 为字符数组名，输入的字符可以包含 ’\0’ 字符；

•puts(a); //a 为字符数组名，输入的字符可以包含 ’\0’ 字符；

•strcat( 字符串 1, 字符串 2); // 把字符串 2 连接到字符串 1 后；

•strcpy( 字符数组 1, 字符串 2); // 把字符串 2 拷贝到字符数组 1 中；

如： str 为字符数组，将字符常量赋予 str ： strcpy （ str ， "abcdef");

•strcmp( 字符串 1, 字符串 2); // 比较两个字符串，若相等，则返回 0 ，若字符串 1> 字符串 2 ，则返回 1 ，否则返回 -1 ；

如：比较两个字符串 str1 、 str2 ： if(strcmp(str1,str2)==1) printf("str1>str2");

•strlen( 字符数组 ); // 返回字符数组中包含的字符串的长度；

•strlwr( 字符串 ); // 将字符串的大写字符转换为小写；

•strupr( 字符串 ); // 将字符串的小写字符转换为大写；

例：不使用 strlen() 函数，计算一个字符串的长度

#include<stdio.h>

main()

{

int i=0;

char str[30];

printf(“ 输入一个字符串 :”);

gets(str);

while (str[i]!=’\0’)

i++;

printf(“ 字符串长度为： %d\n”,i);

}

例：将一字符串逆转

#include<stdio.h>

#include<string.h>

main()

{

char str[20],temp;

int i,j;

printf(“ 输入一个字符串： ”);

gets(str);

for(i=0;i<strlen(str)/2;i++)

{

j=strlen(str)-1;

temp=str[i];

str[i]=str[j-i];

str[j-i]=temp;

}

printf(“ 倒置的字符串为 :%s\n”,str);

}

09 指针

字符数组是用来存放字符的数组，字符数组中的一个元素存放一个字符。

1 、字符数组的定义： char a[10];

2 、字符串：字符串是借助于字符数组来存放的，并规定以字符 ’\0’( 占用存储空间，但不计入字符串的长度 ) 为字符串

的结束标记。

3 、字符串处理函数：

•scanf(“%s”,a); // 以格式符 %s 输入字符串，输入的字符串自动以 ’\0’ 结尾；输入的字符数组名前不加 ”&” 前缀；

•printf(“%s”,a); // 以格式符 %s 输出字符串，输出的字符串以 ’\0’ 结尾；

•gets(a); //a 为字符数组名，输入的字符可以包含 ’\0’ 字符；

•puts(a); //a 为字符数组名，输入的字符可以包含 ’\0’ 字符；

•strcat( 字符串 1, 字符串 2); // 把字符串 2 连接到字符串 1 后；

•strcpy( 字符数组 1, 字符串 2); // 把字符串 2 拷贝到字符数组 1 中；

如： str 为字符数组，将字符常量赋予 str ： strcpy （ str ， "abcdef");

•strcmp( 字符串 1, 字符串 2); // 比较两个字符串，若相等，则返回 0 ，若字符串 1> 字符串 2 ，则返回 1 ，否则返回 -1 ；

如：比较两个字符串 str1 、 str2 ： if(strcmp(str1,str2)==1) printf("str1>str2");

•strlen( 字符数组 ); // 返回字符数组中包含的字符串的长度；

•strlwr( 字符串 ); // 将字符串的大写字符转换为小写；

•strupr( 字符串 ); // 将字符串的小写字符转换为大写；

例：不使用 strlen() 函数，计算一个字符串的长度

#include<stdio.h>

main()

{

int i=0;

char str[30];

printf(“ 输入一个字符串 :”);

gets(str);

while (str[i]!=’\0’)

i++;

printf(“ 字符串长度为： %d\n”,i);

}

例：将一字符串逆转

#include<stdio.h>

#include<string.h>

main()

{

char str[20],temp;

int i,j;

printf(“ 输入一个字符串： ”);

gets(str);

for(i=0;i<strlen(str)/2;i++)

{

j=strlen(str)-1;

temp=str[i];

str[i]=str[j-i];

str[j-i]=temp;

}

printf(“ 倒置的字符串为 :%s\n”,str);

}

10 函数

C 程序是由函数组成的，有且只有一个主函数 main() ，由主函数调用其他函数，其他各函数也可以相互调用。 1 、函数的定义：

一般格式：

类型说明 函数名 ( 形式参数表 )

// 函数头

{

说明部分；

// 函数体

执行部分；

}

其中：类型说明：是指函数返回值的数据类型；默认为 int ；

函数名：为一标识符；代表了函数的入口地址；

形式参数表：是用逗号分隔的一组变量说明，指出每一个形式参数的类型和名称；

函数值的返回：有时，调用函数是为了计算一个结果，这是需要使用返回语句将就是结果返回给主调函数，

此值即为函数的返回值；

一般格式： return ( 表达式 );

其中，圆括号可以省略；

当函数不需要返回值时，可以写成： return;

例：编写一个函数 power () ，用于计算 x 的 n 次方的值

#include<stdio.h>

float power(float x,int n)

{

int i;

float s;

s=1;

for(i=1;i<=n;i++)

s=s*x;

return (s);

}

2 、函数的调用：

C 语言中函数调用的一般格式：

函数名 ( 实参表 ) ；

如： float f ；

f=power(3,10);

3 、数组作为函数的参数

• 数据元素作为函数实参

在函数调用时，把数组元素作为实参传递给形参，实现单向的值传递；

如：判别各个元素的值，大于 0 ，则输出该值，小于或等于 0 ，则输出 0

#include<stdio.h>

void func(int x)

{

if (x>0)

printf(“%4d”,x);

else

printf(“%2d”,0);

}

main()

{

int a[5],i;

printf(“ 请输入 5 个数： ”);

for(i=0;i<5;i++)

scanf(“%d”,&a[i]);

for(i=0;i<5;i++)

func(a[i]); // 将数组元素作为实参传递

} • 数组名作为函数参数

（ 1 ）使用数组名作为函数参数时，形参和实参是同类型的数组；

（ 2 ）在主调函数和被调函数中分别定义数组；

（ 3 ）数组名代表了数组的起始地址，数组名作为函数参数传递的是该数组的起始地址，而不是该数组元素的值；

例：将数组中的元素的和计算并显示出来。

#include<stdio.h>

func(int b[])

{

int sum=0,i;

for(i=0;i<10;i++)

sum+=b[i];

return sum;

}

main()

{

int a[]={1,2,3,4,5,6,7,8,9,10},s;

s=func(a);

// 将数组 a 组为参数传递给函数 func

printf("s=%d",s);

}

4 、内部函数和外部函数

• 内部函数：在定义函数时，在其类型名之前加 “static” ，则所定义的函数为内部函数，只能被所在的源文件中的函数

调用，其他源文件若有同名的内部函数，互不干扰。

• 外部函数：在定义函数时，在其类型名之前加 “extern” （也可省略），则所定义的函数为外部函数（也称全局函数），

可被其他源程序的函数调用。

如： static int func_1()

// 内部函数

{

...

}

extern func_2 （）

// 外部函数

{

...

}

综合测试

~~~~~ 给定程序为：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。以后每天早上都吃了前一天

剩下的一半零一个。到第 10 天早上只剩一个桃子。求第一天共摘了多少桃子。由主函数输出第一天共摘桃子数。输出结

果为 1534 。

#include<stdio.h>

int fun(int n)

{ }

main()

{

int n=10,sum;

sum=fun(n);

printf("sum=%d",sum);

}

解析：根据题意，第 n+1 天剩下的桃子数为 x(n+1) ，第 n 天剩下的桃子数为 x(n) ，则满足： x(n)=2*(x(n+1)+1);

第十天剩下 1 个桃子，可推算出第九天剩下的数量；可利用 for 循环，递推出其他天数剩下的桃子数：

int fun(int n)

{

int x,i;

x=1;

// 第十天剩下的数量

for(i=n-1;i>=1;i--) // 从第九天开始推算

{

x=2*(x+1);

}

return x;

}

~~~~~~ 给定程序的功能是：从键盘输入 10 个整数求其中的最大值。

#include<stdio.h>

main()

{

int fun(int b[],int n);

int max;

int i,a[10];

for(i=0;i<10;i++)

scanf("%d",&a[i]);

max=fun(a,10);

printf("max=%d",max);

}

int fun(int b[],int n)

{

}

解析：比较最大值的一般算法：设置一个变量 max ，第一步：将第一个数赋予 max ；第二步：利用 for 循环，将剩下的 9

个数依次与 max 相比较，每次比较， max 均等于大的数；

int fun(int b[],int n)

{

int max,i;

max=b[0]; // 将第一个数赋予 max

for(i=1;i<=n-1;i++)

// 将剩下的 9 个数依次与 max 比较；

if(max<b[i]) max=b[i];

return max;

}

~~~~~~~ 给定程序的功能是：将给定字符串中所有的小写字母转换成大写字母 ( 大写字母 A 的 ASCII 码为 65 ，小写字母 a 的 ASCII 码为 97 ）。

#include<stdio.h>

#include<string.h>

void hs(char c[])

{

}

main()

{

char a[]={"AgRbhLfFGjI"};

hs(a);

printf("%s",a);

}

解析：将给定字符串的每一个字符取出，判断是否介于 'a' 和 'z' 之间，若是，则将其转换为大写字符，即其 ASC 码值－ 32 。

void hs(char c[])

{

unsigned int i;

for(i=0;i<strlen(c);i++)

if(c[i]>='a' && c[i]<='z')

c[i]=c[i]-32;

return;

}

~~~~~~~ 给定程序的功能是：求 1+2+3+4+5+6+......+n （ n 的值由键盘输入）。

include<stdio.h>

main()

{

int fac(int n);

int n,sum;

scanf("%d",&n);

sum=fac(n);

printf("sum=%d",sum);

}

int fac(int n)

{

}

解析：函数 fac 的功能是计算 1-n 之间整数的累计和。

int fac(int n)

{

int i,sum;

sum=0;

// 累计和的初始值为 0

for(i=1;i<=n;i++)

sum+=i;

// 将 1-n 之间的整数累加起来

return sum;

}

~~~~~~~~~ 给定程序的功能是：从键盘输入 10 个整数 , 求其中的最小值。

#include "stdio.h"

main() {

int fun(int x[],int n);

int a[10],i,min;

printf("please input 10 numbers:\n");

for(i=0;i<10;i++)

scanf("%d",&a[i]);

min=fun(a,10);

printf("min=%d\n",min);

}

int fun(int x[],int n)

{

}

解析：比较最小值的一般算法：设置一个变量 min ，第一步：将第一个数赋予 min ；第二步：利用 for 循环，将剩下的 9

个数依次与 min 相比较，每次比较， min 均等于小的数；

int fun(int x[],int n)

{

int min,i;

min=x[0]; // 将第一个数赋予 min

for(i=1;i<=n-1;i++)

// 将剩下的 9 个数依次与 min 比较；

if(min>x[i]) min=x[i];

return min;

}