文章目录
本博文参考用书
第一章 绪论
1.1 程序、程序设计及程序设计语言
1.1.1 程序与程序设计
程序：能够实现特定功能的指令序列的集合，这些指令序列描述了计算机求解某一问题的工作步骤
指令：计算机可以识别的命令
程序设计：给出解决特定问题的程序的过程，是软件构造活动中的重要组成部分。
程序设计往往以某种程序设计语言为工具，给出用这种语言编写的程序。
程序员：专业的程序设计人员
1.1.2 程序设计语言
- 1GL-------机器语言
- 2GL-------汇编语言
- 3GL-------高级语言：
结构化程序设计语言：C
面向对象程序设计语言：Java、C++、C#.....
- 4GL-------非过程式语言
- 5GL-------知识型语言
1.2 程序的基本构成
良好的编程风格对于程序学习来说起这事半功倍的效果，希望大家在学习程序语言的时候一定要意识到。
#include <stdio.h>
int main()
{
printf("Hello World！\n");
return 0;
}
#include <stdio.h>
int Add(int x,int y);
int main()
{
int x,y,z;
scanf("%d%d",&x,&y);
z=Add(x,y);
printf("%d",z);
return 0;
}
int Add(int x,int y)
{
return x+y;
}
1.2.2 基本字符集（C语言)
英语字母
数字
空白符
特殊字符
1.2.3 词法单位
单词：程序设计语言的词法单位
- 关键字：是程序设计语言预先声明的单词，具有特殊的含义和作用。如
int - 标识符：是编程人员声明的单词，用来表示各种程序对象（变量、类型、函数、文件等）的名字
C语言中标识符的构成规则：
以字母或下划线_开始
由字母、下划线_或数字组成
大写字母和小写字母代表不同的标识符
- 3.运算符 如：
+、-、*、/等 - 4.分隔符 如：
#、 (、 )、 {、 }、 ，、 ：、 ；、 " 、 '等 - 5.修饰符 如：
const等
1.2.4 语法单位
1.表达式
2.语句
3.函数：库函数、自定义函数
1.2.5 程序
1.程序的结构
2.预处理指令：以#开头的命令
预处理：将程序翻译成机器指令之前，对程序进行的某些编辑处理，如滤掉注释、文件包含等。
#include：将某个库文件包含到程序中，包含了库文件就可以直接调用该文件中的所有库函数。
3.注释
4.main函数
5.输入输出操作
scanf("%d",&x);
printf("%d",x);
1.3 程序的上机过程
具体的可以看我这篇博文
1.3.1 编程环境
利用程序设计语言进行程序开发的程序设计环境
交互式集成开发环境（Integrated Design Environment ,IDE)
1.3.2 程序编辑
1.3.3 程序编译
C语言采用编译的方式，即先由编译程序（也称编译器）把源程序翻译成目标程序，然后再由计算机执行目标程序。
目标程序指的是源程序的二进制形式
1.3.4 程序连接
1.3.5 运行调试
调试：在程序中查找错误并修改错误的过程
1.4 程序风格
1.4.1 标识符的命名规则(驼峰写法)
符号常量：大写字母表示 PI
变量：num、studentName
函数：Max、PrintTri
自定义数据类型：StudentType DateType
全局变量：Gnum、Gsecret
1.4.2 注释
//
/**/
1.4.3 缩进
1.4.4 行文格式
// K&R风格
int main(){
return 0;
}
// Allman风格
int main()
{
return 0;
}
1.5问题求解与程序设计
1.5.3 程序设计实例——鸡兔同笼问题
/*程序设计实例——鸡兔同笼问题*/
#include <stdio.h>
int main()
{
int M,N;
int chicken,rabbit;
scanf("%d%d",&M,&N);
for(chicken=0;chicken<=M;chicken++)
{
rabbit=M-chicken;
if(2*chicken+4*rabbit==N)break;
}
if(chicken<=M)
printf("%d %d",chicken,rabbit);
else
printf("NO ANSWER");
return 0;
}
第二章 数据存储与表示
引例 2.1 计算圆的面积
#include <stdio.h>
#define PI 3.14
int main()
{
int radius; double area;
radius=10;
area=PI*radius*radius;
printf("%6.2f\n",area);
return 0;
}
2.1 数据的存储
2.1.1 二进制
2.1.2 内存
位（bit)
字节（byte):8位二进制
每个存储单元的编号称为存储地址（简称地址）
2.2 基本数据类型
关于这一部分的内容，大家了解一下类型表示范围就行，具体部分和计算机组成原理相关。
2.2.1 整型
int 4个字节
n位二进制能够表示的整数范围：-2^(n-1)~2^(n-1)-1
溢出：超出了系统能够表示的整数范围
2.2.2 实型
(float) 4个字节 10^(-38)~10^(38)
(double) 8个字节 10^(-308)~10^(308)
2.2.3 字符型
char 1个字节
char ch='a';
ch-32='A';
char ch='5';
ch-'0'=其对应的数值
2.2.4 逻辑型
（布尔型，bool）
2.3 常量
2.3.1 字面常量
常量 1.数值型常量 1.1整型常量 eg:123
1.2实型常量 eg:3.14
2.字符型常量 2.1字符常量 eg:'a'
2.2字符串常量 eg:"abc"
转义字符：以反斜线\开头,其含义是将反斜线后面的字符转换成另外的含义。
2.3.2 符号常量
用标识符来代表字面常量（实际上就是为字面常量起个名字）
1.用#define定义符号常量
#define PI 3.14
2.用const定义符号常量
const double PI=3.14；
2.4 变量
2.4.1 变量
地址：变量所在存储单元的地址
变量名：变量所在存储单元的助记符
变量值：存储在相应存储单元中的数据，即该变量所具有的值
类型：变量所属的数据类型
2.4.2 变量的定义和初始化
int a;
a=1;
2.4.3 变量的赋值
int a=1;
a=a+10;
第三章 数据的运算处理
3.1 算术运算
引例 3.1 求平均值
#include <stdio.h>
int main()
{
int x=3,y=5,z=8;
int sum;
sum=x+y+z;
printf("%6.2f\n",(double)sum/3);
return 0;
}
3.1.1算术运算
数值运算，由算术运算符、运算对象和圆括号组成的式子称为算术表达式。
3.1.2运算符的优先级和结合性
3.2 逻辑运算
引例 3.2 判断闰年
#include<stdio.h>
int main()
{
int year=2014;
if((year%4==0&&year%100！=0)||(year%400==0))
printf("yes");
else
printf("no");
return 0;
}
3.2.1 关系运算
比较运算，也就是将两个值进行比较。
由关系运算符、运算对象和圆括号组成的式子称为关系表达式。
a>b
a>=b
a<b
a<=b
a==b
a!=b
3.2.2 逻辑运算
由逻辑运算符、运算对象和圆括号组成的式子称为逻辑表达式。
(a%2==0) && (a<=100)
(x!=0) || (y!=0)
3.3 赋值运算
3.3.1 赋值运算
用赋值运算符将变量和表达式连接起来的式子称为赋值表达式。
x=5;
3.3.2 自增/自减运算
int a=3,b;
b=a++; //b=3,a=4
b=++a; //b=4,a=4
3.4 其他运算
3.4.1 逗号运算
int x,y,z;
x=3,y=4,z=x+y;
3.4.2 取长度运算
sizeof(类型或表达式）
3.4.3 条件运算
int i=2,j=3,k;
k=i>j?i:j;
3.5 运算对象的类型转换
3.5.1 自动转换
char->short->int->long->float->double
3.5.2 强制转换
编程人员强制地改变某个数据的类型。（也称为显式类型转换）
（类型说明符） （表达式）
（）：强制类型转换符
double x=3.6,y=3.8;
int a;
a=x+y;
a=(int)(x+y);
a=(int)x+y; //变量x的数据类型仍然是floa型，变量x的值仍然是3.6
tips:无论是自动转换还是强制转换，都只是为了执行本次运算而对数据的类型进行临时性的转换，是将某个数据的值转换成一个中间量，不改变原数据的类型。
第四章 程序的基本控制结构
4.1 顺序结构
引例 4.1 整数的逆值
#include<stdio.h>//二位数的逆值
int main()
{
int num,x,y,numDevo;
scanf("%d",&num);
x=num%10;
y=num/10;
numDevo=x*10+y;
printf("%d",numDevo);
return 0;
}
printf("%d %d %5.2f\n",x,y,(double)x/y);
复合语句：由一对花括号括起来的若干条语句组成。
{
temp=x;x=y;y=temp;
}
4.2 选择结构
引例 4.2 水仙花数
#include<stdio.h>//水仙花数
int main()
{
int x,x1,x2,x3,y;
scanf("%d",&x);
x1=x%10;y=x/10;
x2=y%10;x3=y/10;
if(x1*x1*x1+x2*x2*x2+x3*x3*x3==x)
printf("yes");
else
printf("no");
return 0;
}
4.2.1 逻辑值控制的选择结构
1.单分支的选择结构（if语句）
max=x;
if(max<y)
max=y;
2.双分支的选择结构（if-else语句）
if(x>=y)
max=x;
else
max=y;
tips:
判等运算符== ：
赋值运算符= ：语句if(i=0)…则是先把0赋值给变量i，然后测试赋值表达式的结果是否为0。此时，表达式的运算结果一定为假。
3.分支结构的嵌套
if(x>y)
{
if(y>z) x=0;
}else
x=1;
4.2.2 算术值控制得的选择结构
switch语句（开关语句或选择语句）
switch((int)score/10)
{
case 10 :
case 9 : grade='A';break;
case 8 : grade='B';break;
case 7 : grade='C';break;
case 6 : grade='D';break;
default : grade='E';break;
}
4.3 循环结构
循环条件
循环体
循环变量
引例4.3 欧几里得算法
#inlcude<stio.h>//欧几里得算法，算最大公约数
int mian()
{
int m,n,r;
scanf("%d%d",&m,&n);
r=m%n;
while(r!=0)
{
m=n;n=r;r=m%n;
}
printf("%d\n",n);
return 0;
}
4.3.1 当型循环 （while循环）
while （表达式）
/* 计算n!*/
result=1;i=1;
while(i<=n)
{
result=result*i;
i++;
}
4.3.2 直到型循环（do-while循环）
do
{
语句；
}while(表达式)；
/* 计算n!*/
result=1;i=1;
do
{
result=result*i;
i++;
}while(i<=n);
4.3.3 计数型循环（for循环）
for(表达式1；表达式2；表达式3)
循环的初值 循环条件 循环变量的修正
{
语句；
}
/* 计算n! */
for(result=1,i=1;i<=n;i++)
result=result*i;
i=0;
for(;i<n;i++)
.......
for(i=0;;i++)
{
if(i>=n) break;
}
for(i=0;i<n;)
{
i++;
}
4.3.4 循环结构的比较
/*整数的逆值*/
#include<stdio.h>
int main()
{
int x,y=0,unit;
scanf("%d",&x);
while(x!=0)
{
unit=x%10;
y=y*10+unit;
x=x/10;
}
printf("%d\n",y);
return 0;
}
/*计算整数中所含数字的位数*/
#include<stdio.h>
int main()
{
int x,digits=0;
scanf("%d",&x);
do
{
digits++;
x=x/10;
}while(x!=0);
printf("%d\n",digits);
return 0;
}
/*计算2+4+6+...+100的值*/
#include<stdio.h>
int mian()
{
int sum=0,i;
for(i=2;i<=100;i=i+2)
{
sum=sum+i;
}
printf("%d\n",sum);
return 0;
}
4.3.5 循环结构的嵌套
/*九九乘法表的打印*/
for(i=1;i<=9;i++)
{
for(j=1;j<=i;j++)
printf("%d*%d=%2d",j,i,i*j);
printf("\n");
}
4.4 其他控制语句
引例 4.4 素数判定
/*素数判定*/
#include <stdio.h>
int main()
{
int x,i;
scanf("%d",&x);
for(i=2;i<x;i++)
{
if(x%i==0)
break;
}
if(i<x)
printf("yes");
else
printf("no");
return 0;
}
4.4.1 break语句
/*从键盘上输入10个整数，判断是否含有负数*/
for(flag=0,i=1;i<=10;i++)
{
scanf("%d",&x);
if(x<0)
{
flag=1;
break;
}
}
if(flag==1)
printf("yes");
else
printf("no");
4.4.2 continue语句
/*从键盘上输入10个整数，输出其中的负数*/
for(count=0,i=1;i<=10;i++)
{
scanf("%d",&x);
if(x>=0)continue;
printf("%4d",x);
count++;
}
printf("\n%d\n",count);
4.5 程序设计实例
/*将三个整数由小到大输出*/
#include<stdio.h>
int main()
{
int x,y,z,temp;
scanf("%d%d%d",&x,&y,&z);
if(x>y)
{
temp=x;x=y;y=temp;
}
if(z<x)
{
temp=z;z=y;y=x;x=temp;
}
else if(z<y)
{
temp=y;y=z;z=temp;
}
printf("%3d%3d%3d\n",x,y,z);
return 0;
}
/*今年已经过去多久了*/
#include<stdio.h>
int main()
{
int yy,mm,dd;
int i,days,sumDay=0;
scanf("%d%d%d",&yy,&mm,&dd);
for(i=1;i<mm;i++)
{
switch(i)
{
case 1:case 3:case 5:case 7:case 8:case 10:case 12:
days=31;break;
case 4:case 6:case 9:case 11: days=30;break;
case 2: days=28;
if((yy%4==0&&yy%100!=0)||(yy%400==0))
days++;
break;
}
sumDay=sumDay+days;
}
printf("%d\n",sumDay);
return 0;
}
/*百元买百鸡*/
#include<stdio.h>
int main()
{
int x,y,z;
int count=0;
for(x=0;x<=20;x++)
{
for(y=0;y<=33;y++)
{
z=100-x-y;
if((z%3==0)&&(5*x+3*y+z/3==100))
{
count++;
printf("%d %d %d",x,y,z);
}
}
}
if(count==0)
printf("this problem have not answer");
return 0;
}
/*哥德巴赫猜想*/
#include <stdio.h>
int main()
{
int n,n1,n2,i;
scanf("%d",&n);//输入一个偶数
for(n1=2;n1<=n/2;n1++)
{
n2=n-n1;
for(i=2;i<n1;i++)
{
if(n1%i==0)
break;
}
if(i<n1)
continue;
for(i=2;i<n2;i++)
{
if(n2%i==0)
break;
}
if(i>=n2)
break;
}
printf("%d=%d+%d",n,n1,n2);
return 0;
}
第五章 批量同类型数据的组织———数组
5.1 一维数组
引例 5.1 舞林大会
/*引例5.1 舞林大会*/
#include<stdio.h>
#define N 5
int main()
{
double a[N];
double sum=0,max=0,min=10;
int i;
for(i=0;i<N;i++)
{
scanf("%lf",&a[i]);
sum=sum+a[i];
if(max<a[i]) max=a[i];
if(min>a[i]) min=a[i];//并不知道其最小值是多少，但可以从最大值来开始比较，效果一样
}
printf("%4.lf\n",(sum-max-min)/(N-2));
return 0;
}
5.1.1 一维数组的定义和初始化
1.数组的定义：
基类型 数组变量名[整型常量表达式]；
数组元素的类型 数组名 数组长度
//合法的一维数组定义
int a[10];
double b[5];
char c[80]; //数组长度不能是变量
const int N=10;
int a[N]; //N是符号常量，相当于int a[10]
2.一维数组元素的引用：
数组变量名 [整型表达式]
数组下标
3.一维数组的初始化
基类型 数组变量名[整型常量表达式]={初值表}；
缺省则为初值个数
int a[10]={0,1,2,3,4,5,6,7,8,9};
int a[10]={0,1,2,3,4}; //相当于int a[10]={0,1,2,3,4,0,0,0,0,0};
int a[10]={0}; //此时数组a元素都为0
int a[]={0,1,2,3,4}; //省略数组长度
5.1.2 一维数组的操作
1.输入/输出操作
int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
int i,a[10]={1,2,3,4,5,6,7,8,9,10};
for(i=0;i<10;i++)
printf("%d",a[i]);
2.赋值操作
//在C语言中，除了在数组初始化时对数组进行整体赋值，就没有提供数组整体赋值的语句
//<string.h>中的库函数memcpy,
//memcpy(a,b,sizeof(b)) 把数组b复制给数组a
int a[10],i;
for(i=0;i<10;i++)
a[i]=2*i; //为数组元素赋值需要注意数组下标不能越界（编译器通常不提供数组下标越界检查）
3.其他操作
//本质上，数组元素是一个简单变量，因此，数组元素的使用方法与同类型简单变量的使用方法相同
int a[10];
a[0]=1;a[1]=2;
a[2]=a[0]+a[1]*5;
/*例5.1*/
#include<stdio.h>
#define n 5
int main()
{
int r[n]={2,4,8,5,6},i,x;
scanf("%d",&x);
for(i=0;i<n;i++)
if(r[i]==x) break;
if(i<n)
printf("yes");
else
printf("no");
return 0;
}
5.2二维数组
引例 5.2 哥尼斯堡七桥问题
/*引例5.2 哥尼斯堡七桥问题*/
#include <stdio.h>
int main()
{
int mat[4][4]={{0,1,2,2},{1,0,1,1},{2,1,0,0},{2,1,0,0}};
int i,j,count=0,degree;
for(i=0;i<4;i++)
{
degree=0;
for(j=0;j<4;j++)
{
degree=degree+mat[i][j];
}
if(degree%2!=0)
count++;
}
if(count==0)
printf("it have a way");
else
printf("no way");
return 0;
}
5.2.1 二维数组的定义和初始化
1.二维数组的定义
基类型 数组变量名[整型常量表达式] [整型常量表达式];
数组元素的类型 数组名 行数 列数
int a[10][5];
double b[5][10];
char ch[5][80];
2.二维数组元素的引用
3.二维数组的初始化
int a[2][3]={1,2,3,4,5,6};
int b[2][3]={{1,2,3},{4,5,6}};
int c[2][3]={{1},{2}};
int d[2][3]={0};
5.2.2 二维数组的操作
1.输入输出操作
2.赋值操作
3.其他操作
/*例5.2*/
#include<stdio.hL>
int main()
{
int a[10][10],max,i,j,m,n;
scanf("%d%d",&m,&n);
printf("%d",m*n);
for(i=0;i<m;i++)
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
max=a[0][0];
for(i=0;i<m;i++)
for(j=0;j<n;j++)
if(max<a[i][j])
max=a[i][j];
printf("%d",max);
return 0;
}
5.3 程序设计实例
/*实例1——折半查找*/
#include<stdio.h>
#define N 5
int main()
{
int r[N],k,i;
int low=0,high=N-1,mid;
for(i=0;i<N;i++)
scanf("%d",&r[i]);
scanf("%d",&k);
while(low<=high)
{
mid=(low+high)/2;
if(k<r[mid]) high=mid-1;
else if(k>r[mid]) low=mid+1;
else break;
}
if(low>high)
printf("the answer is wrong");
else
printf("%d",mid+1);//物理序号+1
}
/*实例2——合并有序数组*/
#include<stdio.h>
#define M 5
#define N 6
int main()
{
int A[M]={1,3,5,6,8},B[N]={1,2,5,7,8,9},C[M+N];
int i=0,j=0,k=0;
while(i<M&&j<N)
if(A[i]<B[j]) C[k++]=A[i++];
else C[k++]=B[j++];
while(i<M)
C[k++]=A[i++];
while(j<N)
C[k++]=B[j++];
for(k=0;k<M+N;K++)
printf("%3d",C[k]);
return 0;
}
/*实例3——对角线元素之和*/
#include<stdio.h>
int main()
{
int a[10][10],i,j,n,sum=0;
scanf("%d",&n);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
for(i=0;i<n;i++)
sum=sum+a[i][i];
for(i=0;i<n;i++)
sum=sum+a[i][9-i];
printf("%d",sum);
return 0;
}
第六章 程序的组装单元——函数
6.1 用户定义的函数——自定义函数
引例6.1 欧几里得算法
/* 引例6.1 欧几里得算法 */
#include <stdio.h>
int ComFactor(int m,int n);
int main()
{
int x,y,factor;
scanf("%d%d",&x,&y);
factor=ComFactor(x,y);
printf("the max gcd is %d\n",factor);
return 0;
}
int ComFactor(int m,int n)
{
int r;
r=m%n;
while(r!=0)
{
m=n;
n=r;
r=m%n;
}
return 0;
}
6.1.1 函数定义
类型标识符 函数名（形参表） 函数原型（函数头）
{
语句 //函数体，可以为空，但花括号不能省略
}
- 有返回值函数
有返回值函数在函数执行结束后向调用者返回一个执行结果，称为函数的返回值。
int Fun(int x,int y)
{
int z;
z=x*x+2*x*y+y*y;
return z;
}
Tips: 如果形参表中有多个参数，每个形参前面的类型必须分别写明，
int Fun(int x,int y)不能写成int Fun(int x,y)
如果形参表为空，良好的编程习惯是将形参制定为void ，以明确该函数为无参函数。 int Fun(void)
2.无返回值函数
无返回值函数只完成某种特定的数据处理，函数执行后无须向调用者返回执行结果。
无返回值函数在函数定义时必须将返回值的类型说明为void（空类型），
函数体中的return语句只结束函数的执行。
void Table99(void)
{
int i,j;
for(i=1;i<=9;i++)
{
for(j=1;j<=i;j++)
{
for(j=1;j<=i;j++)
printf("%d×%d=%2d",j,i,i*j);
printf("\n");
}
}
return;
}
函数体可以为空，即函数体中可以没有任何语句，称为空函数。
void Table99(void)
{
}
Tips:
空函数对于较大规模程序的编写、调试和扩充很有用。对于较大程序不能写出所有函数再进行调试，对于那些还没有具体内容的函数可以只写出空函数，需要扩充函数功能时或相应函数调试完后再补上具体内容。
6.1.2 函数调用
通常把调用其他函数的函数称为主调函数，被调用的函数称为被调用函数。
实际参数表
函数名（实参表） //括号不能省略
/* 例6.3 */
#include <stdio.h>
int Fun(int x)
{
int y;
y=x*x+2*x+1;
return y;
}
int main()
{
int a=10,b;
b=Fun(5);
printf("%d",b);
b=Fun(a);
printf("%d",b);
b=Fun(a+8.5);
printf("b");
return 0;
}
6.1.3 函数声明
C语言规定：函数必须先定义后调用。
Tips:如果在所有函数之前声明函数原型，则该函数原型的作用域是整个程序，
即在程序的任何位置都可以调用这个函数；
如果在某个函数内部声明函数原型，则该函数原型的作用域只在这个函数内部。
#include<stdio.h>
int Fun(int x);
int main()
{
int a=10,b;
b=Fun(a);
printf("%d",b);
return 0;
}
int Fun(int x)
{
int y;
y=x*x+2*x+1;
return y;
}
Tips:尽管编译器不关心函数原型中形参的名字，在函数声明时，最好不要忽略形参的名字，因为形参的名字可以注释每个形参的目的，并且提醒编程人员在函数调用时如何安排实参的顺序。
6.2 系统定义的函数——库函数
引例 6.2 素数判定
编译系统提供了大量库函数用于实现常见的基本功能。
/* 引例 6.2 素数判定 */
#include <stdio.h>
#include <math.h>
int Prime(int x);
int main()
{
int a;
scanf("%d",&a);
if(Prime(a)==1)
printf("%d是素数\n",a);
else
printf("%d不是素数\n",a);
return 0;
}
int Prime(int x)
{
int i,n;
n=sqrt(x);
for(i=2;i<=n;i++)
{
if(x%i==0)
return 0;
}
return 1;
}
6.2.1 头文件与文件包含
在C语言的编译系统中，库函数一般按功能（例如数学函数、字符串处理函数等）组织在相应的头文件中。
在使用库函数时，需要在程序中包含该库函数所在的头文件。
C语言提供了#include文件包含预处理指令，将一个头文件包含到源程序文件中。
6.2.2 标准输入输出函数
1.字符数据的输入输出函数
int getchar(void)
eg:
char ch;
ch=getchar();
Tips: 从键盘上输入数据是，不是键入一个字符就送入键盘缓冲区，而是按Enter（回车）键以后才送入键盘缓冲区
为了正确接收从键盘输入的字符，一般在调用getchar函数之前要清空键盘缓冲区。
C语言提供了清空键盘缓冲区函数fflush(stdin),其函数原型在头文件stdio.h中。
int putchar(表达式)
char ch='A';
putchar(ch);
putchar(ch+1);
putchar('\n');
2.格式化输入输出函数
int scanf("格式控制"，地址列表)
int a; scanf("%d",&a);
int a; scanf("%x",&a);
int a; scanf("%o",&a);
float x; scanf("%f",&x);
double x; scanf("%lf",&x);
int printf("格式控制"，输出列表)
printf("%d",a);
Tips:
编译器通常不会检查函数printf和scanf中格式符的个数和列表中项的个数是否匹配，也不会检查格式符是否适合列表中每个项的数据类型。
因此，如果使用了不正确的格式符，运行程序可能会得到莫名其妙的结果。
6.2.3 随机函数
int rand(void) :产生并返回一个随机整数。
void srand(unsigned int seed): 提供用于rand函数的随机种子值
unsigned int time(NULL):获得当前系统时间，其中NULL是在头文件stdio.h中定义的符号常量，其ASC11码值为0。
6.2.4 其他常用的库函数
6.3 变量的作用域
引例 6.3 鸡兔同笼问题
#include <stdio.h>
int Chicken = 0, Rabbit = 0; //全局变量
void CRP(int M, int N);
int main()
{
int M, N; //局部变量
printf("请输入头的个数和脚的个数：");
scanf("%d%d", &M, &N);
CRP(M, N);
if (Chicken != 0 || Rabbit != 0)
printf("鸡有%d只，兔子有%d只\n", Chicken, Rabbit);
else
printf("输入数据不合理，无解\n");
return 0;
}
void CRP(int M, int N)
{
for (Chicken = 0; Chicken <= M; Chicken++)
{
Rabbit = M - Chicken;
if (2 * Chicken + 4 * Rabbit == N) break;
}
if (Chicken > M)
{
Chicken = 0;
Rabbit = 0;
}
return;
}
6.3.1 局部变量
局部变量是在函数内部或复合语句内部定义的变量。
6.3.2 全局变量
全局变量是定义在所有函数（包括main函数）之外的变量
6.4 变量的生存期
6.4.1 自动变量
局部变量都属于自动变量。
自动变量用关键字auto修饰，但通常省略修饰符auto。
6.4.2 静态变量
静态变量一经分配内存空间，在程序的运行过程中就始终占用该内存空间。
静态变量用关键字static修饰。
第七章 变量的间接访问——指针
7.1 指针
7.1.1 指针的概念
- 指针与地址
普通的变量是存储数据，而指针是存储地址的变量。
拓展资料C语言指针详解
- 与指针相关的运算符
取地址运算符&
简接引用运算符*
C语言中
*可能是间接引用运算符，或者是指针定义符，
一般来说，在等号左边是指针定义符，右边是间接引用运算符。
7.1.2 指针变量的定义和初始化
基类型 *指针变量名=内存地址;
eg：
int x=10;
int *p=&x;
int *q=p;
7.1.3 指针变量的操作
- 指针变量的赋值
只有基类型相同的指针变量才可以相互赋值。
通用指针（可以指向任何类型的指针）
void *指针变量名;
- 指针变量的算术运算
数组名相当于一个指针，它指向数组首地址
int sum, a[5] = {1,2,3,4,5};
int *p=a, *q; //指针p指向a[0]
q=p+4; //相当于q=p+4*sizeof(int)，将q指向a[4]
sum=q-p; //指针q和p之间的元素个数，值为4
- 指针变量的关系运算
p==q //判断指针P和q是否指向同一存储单元
7.1.4 指针所指变量的操作
7.2 指针作为函数的参数
引例 7.2 鸡兔同笼问题
#include <stdio.h>
void CR(int M, int N, int *p, int *q);
int main()
{
int M, N;
int x = 0, y = 0;
printf("请输入笼子里动物头的个数和脚的个数：");
scanf("%d%d", &M, &N);
CR(M, N, &x, &y);
if (x != 0 || y != 0)
printf("鸡有%d只，兔子有%d只\n", x, y);
else
printf("输入数据矛盾，无解.\n");
return 0;
}
void CR(int M, int N, int *p, int *q)
{
int chicken, rabbit;
for (chicken = 0; chicken <= M; chicken++)
{
rabbit = M - chicken;
if (2 * chicken + 4 * rabbit == N) break;
}
if (chicken <= M)
{
*p = chicken;
*q = rabbit;
}
else
{
*p = 0;
*q = 0;
}
return;
}
C语言
return语句只能返回一个计算结果，而用指针可以返回多个计算结果，方便程序员编写程序。
7.3 数组作为函数的参数
引例 7.3 顺序查找
#include <stdio.h>
#define N 10
int SeqSearch(int r[ ], int n, int k); //形参不用写数组长度，编译器不检查
int main()
{
int r[N] = {20, 10, 15, 24, 6, 12, 35, 40, 98, 55};
int i, k, index;
printf("请输入待查找的元素值：");
scanf("%d", &k);
index = SeqSearch(r, N, k);
printf("查找序列是：");
for (i = 0; i < N; i++)
printf("%3d", r[i]);
printf("\n");
if (index == 0)
printf("序列中没有元素%d\n", k);
else
printf("%d在序列中的序号是%d\n", k, index);
return 0;
}
//数组r[1] ~ r[n]存放查找集合
int SeqSearch(int r[ ], int n, int k)
{
int i;
for (i = 0; i < n; i++)
if (r[i] == k) return i+1;
return 0;
}
第八章 字符数据的组织——字符串
8.1 字符串变量的定义和初始化
8.1.1 字符数组
char 串变量名[整型常量表达式]=字符串变量;
char str[6]="China";
8.1.2 字符串指针
char *字符串指针变量名;
char *str="China";
8.2 字符串的操作
8.2.1 输入输出操作
- 字符串输入输出函数
char *gets(char *str)
char str[80];
gets(str);
int puts(char *str)
char ch[]="I love China !";
char *str="I love China !";
puts(ch);
puts(str);
puts("I love China !");
- 标准输入输出函数
int scanf("%s", char *str);
char str[80];
scanf("%s", str);
int printf("%s", char *str);
char ch[]="I love China !";
char *str="I love China !";
printf("%s\n", ch);
printf("%s\n", str);
printf("I love China !\n");
gets可以输入空格，以回车键为结束标志
scanf以空格、回车键为结束标志
8.2.2 赋值操作
char *strcpy(char *strDestination, char *strSource)
char ch1[20],ch2[]="I love China !";
char *str= "I love China !";
strcpy(ch1,ch2);
strcpy(ch1,str);
strcpy(ch1,"I love China !");
8.2.3 字符串的比较
int strcmp(char *string1, char *string2)
8.2.4 常用字符串库函数
第九章 自定义数据类型
9.1 可枚举数据的组织——枚举类型
9.2 不同类型数据的组织——结构体类型
9.2.1 结构体类型的定义
struct 结构体类型名
{
成员列表
};
struct DateType
{
int year,month,day;
};
9.2.2 结构体变量的定义和初始化
1
struct 结构体类型名 变量名列表 ={初值列表};
struct DateType
{
int year,month,day;
};
struct DateType birthday={1968,3,26};
2
struct 结构体类型名
{
成员列表
} 变量名列表={初值列表};
struct DateType
{
int year,month,day;
}birthday={1968,3,26}; //定义后无法再定义这个类型的其他结构体变量
9.2.3 结构体变量的操作
结构体变量名.成员名
birthday.year
9.3 批量不同类型数据的组织——结构体数组
9.3.1 结构体数组的定义和初始化
1
struct 结构体类型名 数组变量名[数组长度]={{初值表},{初值表},.....,{初值表}};
struct StudentType
{
char no[10],name[10];
double foreign,spec1,spec2;
};
struct StudentType stu[10]={{001,陆宇,87,67,88},{002,李明,68,85,78}};
2
struct 结构体类型名
{
成员列表
}数组变量名[数组长度]={{初值表},{初值表},.....,{初值表}};
struct StudentType
{
char no[10],name[10];
double foreign,spec1,spec2;
}stu[10]={{001,陆宇,87,67,88},{002,李明,68,85,78}};
9.3.2 结构体数组的操作
结构体数组名[下标].成员名
stu[i].name
9.4 为自定义数据类型定义别名
typedef 数据类型 类型名;
1
struct DateType
{
int year,month,day;
};
typedef struct Date DateType;
2
typedef struct DateType
{
int year,month,day;
}DateType;
第十章 再谈函数
10.1 函数的嵌套调用
10.2 函数的递归调用
第十一章 再谈指针
11.1 指针与数组
11.1.1 用指针访问一维数组
1
int a[10] ={0};
a[2]=5;
2
int a[10]={0};
*(a+2)=5;
3
int a[10],*p=a;
*(p+2)=5;
11.1.2 用指针访问二维数组
1
int a[3][4]={0};
a[2][3]=5;
2
int a[3][4]={0};
*(*(a+2)+3)=5;
3
int a[3][4]={0},*p=&a[0][0];
*(*(p+2)+3)=5;
一般来说，对于数组的访问，通过下标访问更常见。
11.1.3 指针数组
11.2 指针与结构体
11.2.1 指向结构体的指针
- 结构体指针的定义
结构体类型 *指针变量名
- 通过指针引用结构体成员
(*指针).成员
指针->成员
struct DateType
{
int year,month,day;
};
struct StudentType
{
char name[10];
struct DateType birthday;
};
struct StudentType stu={"小言",{1997,1,4}};
struct StudentType *p=&stu;
printf("%s的生日是%d月%d日",p->name,p->birthday.month,p->birthday.day);
11.2.2 结构体指针作为函数参数
11.3 动态存储分配
11.3.1 申请与释放存储空间
1 申请存储空间
void *malloc(unsigned int size)
int *p=NULL;
p=(int *)malloc(sizeof(int));
2 释放存储空间
void free(void *block)
int *p=NULL;
p=(int *)malloc(sizeof(int));
*p=10;
free(p);
11.3.2 动态数组
int i, *base=NULL, *p=NULL;
base=(int *)malloc(10*sizeof(int));
for(i=1,p=base;i<=10;i++)
*(p++)=i;
free(base);
11.3.3 链表
struct 结点类型名
{
类型名 data;
struct 结点类型名 *next;
};
struct Node
{
int data;
struct Node *next;
};
扫一扫
2343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
