第一章 C语言概述
C语言的特点
语言简洁,紧凑,使用方便,灵活。
运算符丰富。
数据类型丰富。
具有控制语句(if...else.. while..switch...cese...for)。
语法限制不太严格。
C语言允许直接访问无力地址,能进行位操作,能实现汇编语言的大部分功能,可以直接进行操作。
声称目标代码质量高,执行程序效率高。
用C语言编写的程序可移植性好。
简单的c语言程序
每个函数都必须要有一个main函数,main是函数的名字,表示主函数,main前面的Int表示此函数执行后返回一个整型值。函数体用花括号{}括起来。’\n’为换行符,即在输出C语言后换行。如果函数有返回值,我们用return关键字返回结果,此程序返回的整型数为0.
另外在写程序时一定要注意中英文的书写,如果不小心很可能导致程序出错。
第二章 C语言数据类型、运算符和表达式
C语言的数据类型
C语言包括的数据类型有:整型(short int、int、long int);实型(float、double、longdouble),字符型(char)和枚举类型。
常量
整型常量有指数形式,一个实数的指数形式分为尾数部分和指数部分。尾数部分可以是整数行书或小数形式,指数部分是一个字母“e”后跟一个整数。其中“e”前面必须有数字,“e”后面必须是整数。
在c语言中,字符型类型用于表示一个字符值,但字符类型的内部表示是字符的ASCll代码,并非字符本身。
特别值得主意的是字符常量一定要用单引号(‘’)括起来
字符串常量是用一对双引号(“”)括起来的字符序列.
其中有一些转义字符:\n (换行) \t (水平指标) \b (退格) \r(回车) \f(换页) \\(代表反斜杠)
\’(代表单引号)
\”(代表双引号)
\ddd (1到3位八进制代表字符) \xhh(1到2位十六进制代表的字符)
变量
变量的定义形式:
基本变量类型有char(字符型)、int(整型)、float、double(实型)、void(无值型第一是明确地表示一个函数不返回任何值,第二是产生一个通用类型的指针)。
类型
变量名表
例如
int a;
float b; char c;
在书写变量说明时要注意:
允许在一个类型说明符后,说明多个类型的变量。各变量名用逗号隔开。类型说明符与变量名之间至少用一个空格间隔
最后一个变量名之后要以“:”结尾。
变量说明必须放在变量使用之前。一般放在函数体的开头部分。
控制台赋值:&取地址符
char ch; scanf(%c,&ch);
int a;
scanf(“%d”,&a);
float
b;scanf(%f,&b);
尤其要注意给控制台的时候
一定要加取地址符!
类型转化
显式类型转化
(类型说明符)(表达式)例如(float)a 就是把a转换为实行
(int)(x+y)就是把x+y的结果转换为整型
在强制转换时要注意以下几点
类型说明符和表达式的都必须加括号(单个变量可以不加括号),如把(int)(x+y)写成(int)x+y则成了把x转换成int型之后在于y相加了
无论是强制转换或是隐式转换,都只是为了本次运算的需要而对变量的数据长度进行的临时性转换,而不改变数据说明时对该变量定义的类型
隐式转换
隐式转换发生在不同数据类型的量混合运算时,由编译系统自动完成。自动转换遵循以下规则
若参与运算量的类型不痛,则先转换成同一类型,然后进行运算。
转换按数据长度增加的方向进行,以保证精度不降低,如int型和long型运算时,先把int转换成long型后在进行运算。
所有的浮点运算都是以双精度进行的,即使仅含float单精度运算的表达式,也要先转换成double型,在运算
char型和short型参与运算时,必须先转换成int型。
在赋值运算中。赋值号两边量的数据类型不同时,赋值号右边的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时,将丢失一部分数据,这样会降低精度,丢失的部分按四舍五入向前舍入。下图为自动转换规则
double
float
long
unsigned
int
char
运算符和表达式
运算符
算数运算符包括:加(+)、减(-)、乘(*)、除(/)、取余(或称为模运算,%)、自增(++)、自减(--)。
关系运算符:大于(>)、小于(<)、等于(=)、大于等于(>=)、小于等于(<=)、和不等于(!=)
逻辑运算符:&&(与)、或(||)、非(!)
位操作运算符:位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>).
赋值运算符:简单赋值(=)、复合赋值(+=,-=,*=,/=,%=)和复合运算赋值(&=,|=,^=,>>=,<<=).
条件运算符:三目运算符用于条件求值(?
:).
逗号运算符:用于把若干表达式组合成一个表达式(,)。
指针运算符:用于取内容(*)和(&)二种运算。
求字节运算符:用于计算数据类型所占的字节数(size of).
特殊运算符:有括号(),下标[],等几种
其中需要注意的是++,--和?
:
i++
i--
i参与运算后,i的值在自增(减)1.
++i
--i
i参与运算前,i的值自增(减)1.
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int i=8;
printf("%d\n%d\n%d\n%d\n",++i,--i,i++,i--);//输出结果9 8 8 9
第一个i先++所以输出9,这时i的值为9 第二个--i所以的i值为8
第三个i++所以第三个i输出也是8 第四个i是9因为第三个i++,这时在输出i为8因为第四个i--
}
return 0;
}
?
: 是具有三个操作数的运算符,表达形式
表达式1?表达式2:表达式3
含义为:先求表达式1的直如果为真(非零),则求表达式2的值,并把它作为整个表达式的值,如果表达式为假(0),则求表达式3的值,并把它作为整个表达式的值
#include
int main(int argc, const char * argv[])
{
int a=10,b=5,c=6,d=0;
d = ((a+b)*(c-b)/(c%4))+a++;
printf("d is%d",d);
printf("%d",a);
return 0;
}
#include
int main(int argc, const char * argv[])
{
int a=10,b=9;
int c=a & b;
int d=a|b;
char str[]="hello";
printf("sizeof(a) = %ld\n",sizeof(a));//获取int类型的长度
printf("sizeof(str)=%ld\n",sizeof(str));//获取字符数组的长度注意结束符号
应该是6
printf("a&b =%d\n",c);//电脑是转换成2进制进行运算
printf("a|b =%d\n",d);
printf("a左移一位: %d\n",a<<1);
printf("a / b=%d",a/b);
}
第三章 分支循环
分支
if(表达式)语句
if(a>b)printf(“%d”,a);
2 if(表达式)语句1 else语句2
if(x>y)
printf(“%d”,x);
else
printf(“%d”,y);
3 if(表达式1)语句1
else if(表达式2)语句2
else if(表达式3)语句3
else if (表达式4)语句4
..........
另外if大括号不用加分号
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
char c1 = 0;
printf("请输入字符");
scanf("%c",&c1);
if (c1<='9'&&c1>='0')
{
printf("输入的是数字");
}
else if (c1>='A'&&c1<='Z')
{
printf("你输入的是大写字母");
}
else if (c1>='a'&&c1<='z')
{
printf("你输入的是小写字母");
}
else
{
printf("你输入的是其他字符");
}
}
return 0;
}
if
语句的嵌套
if()
if()语句1
else语句2
else
if()语句3
else语句4
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a,b;
printf("请输入2个数(用空格隔开)");
scanf("%d%d",&a,&b);
if (a==b) {
printf("输入的2数相等");
}
else
{
if (a>b)
{
printf("a>b");
}
else
{
printf("a
}
}
}
return 0;
}
? : 是具有三个操作数的运算符,表达形式
表达式1?表达式2:表达式3
含义为:先求表达式1的直如果为真(非零),则求表达式2的值,并把它作为整个表达式的值,如果表达式为假(0),则求表达式3的值,并把它作为整个表达式的值
这里要说一下这个 跟if else 有点像
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
//判断2数大小
int a,b;
scanf("%d%d",&a,&b);
printf("%d",(a>b)?a:b);
}
return 0;
}
switch语句
switch(表达式)
{
case常量表达式1:语句1
break;
case常量表达式2:语句2
break;
....
default:语句n
break;
}
尤其要注意加 break;break跳出循环,继续执行switch语句下面的语句。如果不加break会把下面的也给输出出来。
break语句不能用于循环语句和switch之外的任何语句中。
continue语句作用是结束本次循环,即跳出循环体中下面尚未执行的语句,接着惊醒下一次是否执行循环的判断。
continue和break的区别是:continue语句只是结束本次循环,而不是终止整个循环的执行。而break语句是结束整个循环过程,不在判断执行循环的条件是否成立。
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a,c;
char b;
printf("请输入a+(-*/)b\n");
scanf("%d%c%d",&a,&b,&c);
switch (b) {
case '+':
printf("%d",a+c);
break;
case '-':
printf("%d",a-c);
break;
case '*':
printf("%d",a*c);
break;
case '/':
printf("%d",a/c);
break;
default:
printf("输入有误");
break;
}
}
return 0;
}
使用switch语句要注意以下几点:
在case后的各常量表达式的值不能相同,否则会出现错误
在case后,允许有多个语句,用{}括起来
在各case和default句子的先后顺序可以改变,而不会影响程序执行结果。
default句子可以省略不用
循环
while(表达式)语句
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int i=1,sum=0;
while (i<=100) {//循环条件,当i>100时跳出循环
sum+=i;//
i++;
}
printf("%d",sum);
}
return 0;
}
注意:1循环体如果包含一个以上语句,应该用花括号括起来,以复合语句出现。
如果不加花括号,则while语句范围只到while后面第一个分号处,例如上例,只能到sum+=i
2循环体要有使循环体趋向结束的语句。例如上例循环结束语句i>100,应要有导致i>100的语句。如果没有 会造成死循环
do while 循环语句
do
循环体语句
while(表达式);
while与do while 区别在于while是当条件满足时才执行循环体,do while 是先执行循环体,后判断表达式的“当型”循环。
for循环
for(循环变量赋初值;循环条件;循环变量增值)
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int sum;
for (int i=0; i<=100; i++) {
sum+=i;
}
printf("%d",sum);
}
return 0;
}
for循环也可以改写成while循环形式
表达式1;
while表达式2
{
语句
表达式3
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int i=1,sum=0;
while (i<=100) {//循环条件,当i>100时跳出循环
sum+=i;//
i++;
}
printf("%d",sum);
}
return 0;
}
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a,b=1;
for (a=0; a<5; a++) {
for (b=5; b>a; b--) {
printf(" ");
}
for (b=0; b
printf("* ");
}
printf("\n");
}
for(int j=0;j<=5;j++)
{
for (int x=5; x>j; x--) {
printf("* ");
}
printf("\n");
for (int x=0; x
{
printf(" ");
}
}
}
return 0;
}
关于杨辉三角
![C语言总结]()
100内素数
#import
int main(int argc, const char * argv[])
{
//求100以内所有素数
int i=0;
for (int n=2; n<100; n++)//能够得到2到100之内的数
{
for (i=2; i
{
if (n%i==0)//条件语句,能被整除
break;//结束这次循环
}
if (i>=n)//条件语句假如除数等于被除数
{
printf("%d ",n);//输出除数
}
}
return 0;
}
#import
int main(int argc, const char * argv[])
//猴子吃桃问题
{
@autoreleasepool {
int a;
for (int i=0; i<10; i++) {//吃的天数
a=(a+1)*2;// 倒数第二天剩余6个,吃一半剩3个,在吃一个剩2个, 倒数第一天吃一半剩余1个,在吃一个剩余0个,
}
printf("%d",a);
}
return 0;
}
#import
int main(int argc, const char * argv[])
//找出数组中重复的数
{
@autoreleasepool {
int a[10]={1,2,3,4,5,5,6,7,8,9};
for (int i=0; i<9; i++)
{
if (a[i]==a[i+1])//注意程序中的‘==’才等于‘=’
{
printf("%d ",a[i]);
}
}
}
return 0;
}
第四章函数 数组 结构体
函数
库函数:由C系统提供,用户无需顶峰一,也不必在程序中作类型说明,只需在程序前包含有该函数原型的头文件即可在程序中直接调用。例如printf、scanf、getchar、putchar、gets、puts、strcat等
用户定义函数:由用户按需要写的函数。又分有返回值和无返回值
从主调函数和被调函数又分有参函数和无参函数两种
函数的声明与定义
函数的声明,标准编译器,对函数的调用,都要先声明才能调用
有参函数定义的一般形式
类型标示符 函数名(形参列表)
{
声明部分
语句部分
}
#import
void max(int a,int b)
{
if (a>b) {
printf("%d",a);
}
else
printf("%d",b);
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a,b;
scanf("%d%d",&a,&b);
max(a,b);//调用函数
}
return 0;
}
数组
一维数组的定义
类型说明符 数组名[常量表达式]
int a[10];
一维数组的引用
数组的定义必须要有大小 int a[ 3]={1,2,3};
数组只能存放一种类型
数组的元素用下标表示
数组下标从0开始 int a[0] int a[1]
#import
int main(int argc, const char * argv[])
//将10个数导入数组中
{
@autoreleasepool {
int a[10];
printf("请输入10个数");
for (int i=0; i<10; i++) {
scanf("%d",&a[i]);
}
for (int j=0; j<10; j++) {
printf("%d",a[j]);
}
}
return 0;
}
冒泡排序
#import
void paixu(int a[],int n)
{
for (int i=0; i
for (int j=0; j
if (a[j]>a[j+1]) {//实现两两交换
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a[]={};//定义一个数组
printf("请输入10个数");
for (int i=0; i<10; i++)
{
scanf("%d",&a[i]);//向数组中输入数
}
paixu(a, 10);//调用函数
for (int j=0; j<10; j++) {
printf("%d",a[j]);
}
}
return 0;
}
二维数组的定义
类型说明符 数组名 [常量表达式][常量表达式]
#import
int main(int argc, const char * argv[])
{
//穷举法 找最大数
@autoreleasepool {
int hang,lie,max;
int a[3][4]={{1,2,3,15},{7,8,9,55},{10,25,99,100}};//定义2维数组
max=a[0][0];
for (int i=1; i<=3; i++) {//行进行3次比较
for (int j=1; j<=4; j++) {//列进行4次比较
if (max
max=a[i][j];//把大的赋予max
hang=i+1;//找到行数
lie=j+1;//找到列数
}
}
}
printf("最大数=%d在%d行在%d列",max,hang,lie);
}
return 0;
}
结构体
struct 结构体名
{
成员列表;
}变量名表列;
结构体数组
当输入的时候注意是(&结构体数组名.成员列表)
typedef struct student stu;//宏定义变量(创建结构体时可以用stu)
#import
struct student{//定义结构体
int num;
char name[20];
char sex;
int score;
};
int main(int argc, const char * argv[])
{
@autoreleasepool {
stu a[5];//创建结构体数组
for (int i=0; i<5; i++) {//进行5次循环,输入5组数据
printf("请输入学号");
scanf("%d",&a[i].num);//输入学号
printf("请输入姓名");
scanf("%s",a[i].name);//字符串不用加取地址符
printf("输入性别");
scanf("%c",&a[i].sex);//输入学号
scanf("%c",&a[i].sex);//如果不多打一个 会把也当作字符
printf("请输入成绩");
scanf("%d",&a[i].score);//输入学号
}
for (int j=0; j<5; j++)
{
printf("%d%s%c%d",a[j].num,a[j].name,a[j].sex,a[j].score);
}
}
return 0;
}
写一个结构体变量,包括年月日,计算该日是本年的第几天,注意闰年问题
#import
struct date{//定义一个结构体
int year;
int month;
int days;
};
int main(int argc, const char * argv[])
{
@autoreleasepool {
struct date input;
int sum;//总天数
int a[12]={31,28,31,30,31,30,31,31,30,31,30,31 };//定义一个数组包含每个月的天数,用来对应后面计算多少天
printf("请输入年月日(比如2012 10 9)");
scanf("%d%d%d",&input.year,&input.month,&input.days);//输入年月日储存到结构体理
if (input.year@0==0||(input.year%4==0&&input.year0!=0))
{//判断是否闰年
if (input.month>=2)//判断月份是否大于2月
{
for (int i=0; i
{
sum+=a[i];//加上每个月的天数
}
sum+=1;//因为是闰年 所以多加1
}
sum+=input.days;//在加上自己输入的天数
}
else
{
if (input.month>=2)
{
for (int i=0; i
{
sum+=a[i];
}
}
sum+=input.days;
}
printf("%d",sum);
}
return 0;
}
在升序数组中插入一个数,并且保持该数组仍为升序数组的函数
#import
//进行冒泡排序
void sort(int a[],int n)
{
for (int i=0; i
for (int j=0; j
if (a[j]>a[j+1]) {
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a[6]={0,7,3,5,2,INT32_MAX};//定义一个数组
int input;//定义要输入的数
int in;//定义要插的位置
sort(a, 6);//调用函数 进行冒泡排序
printf("请输入要插入的数");
scanf("%d",&input);
for (int j=0; j<5; j++) {//循环5次
if (input
in=j;//把要插入的位置的数赋给要插的位置in
for (int i=5; i>in; i--)//移动位置 从大到小开始移动(i=5)另外i要大于前面不需要排列的数所以i>in
{
a[i]=a[i-1];//实现移位
}
a[in]=input;//把插入的值赋给要插入的位置
break;//结束循环
}
}
for (int i=0; i<6; i++) {
printf("%d",a[i]);//输出数组
}
}
return 0;
}
第五章 指针
指针就是一个地址,而指针变量就是存放地址的变量
类型 *名称[=地址]
直接访问:已知变量a,根据此地址直接对变量a的储存单元进行存取访问
间接访问:不知道a的地址,但是我们知道b中储存了a的地址,我们先访问b,取到a的地址后,再去访问a
int *a;
1定义上代表指针
2内容指的是对象的内容
如何确定指针所指向的类型
char *a 是指向char型变量的指针变量
int *a是指向int型变量的指针变量
#import
int changeValue2(int x,int y)
{
int temp=0;
temp=x+y;
return temp;
}
void changeValue1(int *x,int *y)
{
int temp = 0;
temp = *x;
*x = *y;
*y = temp;
}
void changeValue3(int x,int y)
{
int temp=0;
temp=x;
x=y;
y=temp;
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a=10;
int b=20;
//changeValue2(a,b)
//printf("%d%d",a,b);
changeValue3(a,b);//不能交换ab的值
printf("%d %d\n",a,b);
changeValue1(&a,&b);
printf("%d %d ",a,b);
}
return 0;
}
数组与指针
通过指针引用数组元素
如果p的初值指向&a[0]
p+i和a+i就是a[i]的地址,或者说他们指向a数组的第i个元素
*(p+i)h或*(a+i)是p+i或a+i所指向的数组元素,即a[i]例如*(p+5)或*(a+5)就是a[5],即*(p+5) *(a+5) a[5]三者等价。在编译时实际是a[i]就是按照*(a+i)处理的可以看出[]实际上时变址运算符
指向数组的指针变量就是也可以带下标 如p[i]与*(p+i)等价
根据以上所述引用一个数组元素 可以用:
下表法,如a[i]形式
指针法,如*(a+i)或者*(p+i),其中a是数组名,p是指向数组元素的指针变量其初值p=a
#import
void paixu(int *p,int n)
{
int temp;
for (int i=0; i
for (int j=0; j
if (p[j]>p[j+1]) {
temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a[10]={0};//定义数组
printf("请输入数");
for (int i=0; i<10; i++) {//给数组赋值
scanf("%d",&a[i]);
}
int *p=a;//定义整型指针指向数组a的首地址
paixu(p, 10);//调用函数
for (int j=0; j<10; j++,p++) {
printf("%d",*p);//输出数组
}
}
return 0;
}
指针数组 数组全是指针 数组指针 指向数组的指针
允许对指针进行运算操作 运算是基于数组指针才可以的
//字符指针
char *str="hello";
printf("%c\n",*str);
printf("%c\n",*++str);
printf("%c\n",*str+4);
printf("%c\n",*(str+3));//注意加括号
数组不能进行运算 指针可以进行运算
数组的地址是常量
#import
void paixu(char *p[],int n)//因为是数组形参 也要是数组
{
char *temp;
for (int i=0; i
for (int j=0; j
if (strcmp(p[j], p[j+1])<0) {//比较字符串的大小用strcmp函数,因为是指针数组,包含三个指针,所以p[j]相当与指针数组的首地址,所以得用指针来接首地址 所以要定义指针temp
temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
char *str[3]={"red","yellow","blue"};//定义一个指针数组
paixu(str, 3);//调用
for (int i=0; i<3; i++) {
printf("%s",str[i]);//输出指针数组
}
}
return 0;
}
#import
void paixu(int *p,int n)
{
int temp;
for (int i=0; i
for (int j=0; j
if (p[j]
temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a[3]={3,1,9};//定义一个数组;
int *p=a;//当把数组地址赋予指针时,不用加取地址符。
paixu(p,3);
for (int i=0; i<3; i++)
{
printf("%d",*p++);
}
}
}
指针与结构体
结构体指针
struct student{
int num;
}
struct student *p;
p->num=10//给指针指向的NUM赋值
#import
typedef struct student
{
char sex;
int num;
char *name;
}stu;//结构体定义及类型重定义 typedef struct student stu 相同作用
int main(int argc, const char * argv[])
{
@autoreleasepool {
//指针与结构体
stu s2;//声明结构体变量
stu *p2;//声明指针指向stu类型的内容
p2=&s2;
s2.sex='m';
s2.num=1;
s2.name="hello";
printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
p2->sex='f';
printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
p2->name="word";
printf("性别%c 学号%d 姓名%s\n",s2.sex,s2.num,s2.name);
指针高级
指针的指针
int a=10,b=20; 地址2000(内容10) 2500 (20)
int *p=&a,*q=&b 3000(2000 ) 3500(2500)
(int *)*m=&p,**n=&q 4000(3000) 4500(3500)
**m=10 *m=3000 **n=20 *n=3500
#import
int main(int argc, const char * argv[])
{
@autoreleasepool {
int a=10,b=50;
int *p=&a,*q=&b;
int **m=&p,**n=&q;
printf("%p\n",p);
printf("**m=%d *p=%d a=%d *m=%p\n",**m,*p,a,*m);
printf("%p\n",q);
printf("**n=%d *q=%d b=%d *n=%p\n",**n,*q,b,*n);
**m=30;
printf("%d",a);
}
return 0;
}
宏定义
用一个制定的标识符(即名字)来代表一个字符串
不带参数
#define 标识符 字符串
#define PI 3.1415926
带参数
#define 标识符(参数表)字符串
#define LEAP(A) if(A@0==0||(A%4==0&&A0!=0)){printf("100");}
#define FENZHONG (365*24*60)
#define MAX1(A,B) (A>B)?A:B
注意 标识符 最好大写
用typedef命名已有类型
typedef struct student ss;//宏定义变量
#import
//结构体定义
struct student {//定义学生结构体
char name[10];//姓名
double result;//C语言成绩
char sex;//性别
int age;//年龄
};
枚举
枚举 是指将变量的值一一列表出来,变量的值只限于列表出来的值的范围
static
#import
int fac(int n)
{
static int f=1;
f=f*n;
return f;
}
int main(int argc, const char * argv[])
{
@autoreleasepool {
int i;
for (i=1; i<5; i++) {
printf("%d\n",fac(i));
}
//每次调用fac(i),输出一个i!,同时保留这个i!,同时保留这个i!得值以便下次在乘(i+1)
//如果初始化后,变量只被引用而不改变其值,则这时用静态局部变量比较方便,以免每次调用后 重新赋值
}
return 0;
}
const
1 const int *a 指向长整型数的指针 可以改地址 10不能动(内容不能动)
2 int const *a 指向整型数的常指针 可以改内容 不能动地址
随机产生数
c随机产生数
rand()%(y-x+1)+x
strcpy和strcmp
strcpy(a1,a2)是把a2拷贝给a1
strcmp(a1,a2) 比较2字符串的大小
a1>a2 返回值大于0
a1=a2 返回值等于0
a1
开辟空间
int *s;
s=malloc(size of(int )*40)返回地址为开辟空间的首地址
free(s)//释放