作业：
#include<stdio.h>
#include<string.h>
int main()
{
char a[20]={"lilinhua "};
char b[20]={"LILINHUA "};
char c[40]={""};
strcpy(c,b);
strcat(c,a);
printf("%s\n",c);
}
--函数：就是为了避免代码重复写，进行单独封装
基本概念：把代码中功能相似并且独立的代码单独封装成一个独立的整体
(1)优 点：提高开发效率 提高代码的重用 有利于程序的维护
(2)函数的分类
系统函数:由c系统提供的函数：如：printf(),scanf(),gets(),puts();
用系统函数时，只需将其对应的头文件包含进来，即可
例子：
#include<stdio.h>---------->printf("hello");
1 #include<stdio.h>
#include<math.h>------编译的时候gcc 要加-lm 才能运行
int main()
{
int i=9;
//平方根函数
int sum=sqrt(i);
printf("%d\n",sum);
//幂函数
//计算2的16次方
int a=pow(2,16);
printf("2^16=%d\n",a);
int j,b;
for(j=0;j<=16;j++)
{
b=pow(2,j);
printf("2^%d=%d\n",j,b);
}
}
//产生随机数
2 #include<stdio.h>
#include<stdlib.h>
#include<math.h>
int main()
{
srand(time(0));//随机数种子 srand(time(NULL));
int i=0;
int sum=0;
//随机产生10个：0～100之间的数
for(i=0;i<10;i++)
{
sum=rand()%100;
printf("%d\n",sum);
}
return 0;
}
//字母大小写转换
3 #include<stdio.h>
#include<math.h>
int main()
{
char ch='q';
char ch1='T';
char cd=toupper('q');
printf("q的大写字母是：%c\n",toupper(ch));
char ce=tolower('T');
printf("T的小写字母是：%c\n",tolower(ch1));
}
自定义函数:用户根据需要自己定义的函数；
分类二；
有返回值函数:
函数调用后，会返回一个数值给主调函数；
无返回值函数:
函数结束后，无返回值，一般定义为viod类型，即空类型
分类三:
有参函数:参数可以有多个
无参函数:
函数基本定义:
1.无参函数的定义
DataType FunctionName()
{
//函数体;
//可执行语句；
}
注意:函数名后的括号不能省略！！！
#include<stdio.h>
//自定义函数
void test() //括号里面没有内容叫无参函数
{
printf("hello,world\n");
return;
}
//自定义函数
void test1()
{
int i=4;
i+=19;
printf("i=%d\n",i);
return;
}
void test2(int a)//有参函数
{
int b=a;
printf("a=%d\n",a);
return;
}
int main()
{
//main函数里面只要调用就可以了
test();
test1();
test2(5); // 传一个5给test2
return 0;
}
2.有参函数的定义
DataType FunctionName(Type arg1,Type arg2)//参数列表可以有多个
{
//函数体；
}
注：参数列表可以有多个，参数的类型可以任意（相对）！！
3.函数的定义、声明和调用
函数的定义
DataType FunctionName(参数列表)
{
//函数体；
}
函数的声明：
//少了函数体 多了分号
DataType FunctionName(参数列表);
注：声明时，参数列表一定要和定义时的参数列表一致！！1
后面分号不能省！！
放在函数被调用之前
函数的调用
FunctionName(value);
value：数值
注：函数调用实参的值类型，一定要和函数定义的形参列表一致！！
若想要调用的函数体在此函数体之后 就必须要声明
注：函数名也是函数的入口地址
实参:实际参数，即具体的数值
形参:形式参数，形参的定义和普通变量的定义无区别！
#include<stdio.h>
//自定义函数
void test() //void 可以定义为int char 等
{
int i=3;
i+=5;
printf("i=%d\n",i);
scanf("%d",&i);
printf("scanf:%d\n",i);
return;
}
int main()
{
test();
return 0;
}
//若想要调用的函数体在此函数体之后 就必须要声明
//声明格式如下
#include<stdio.h>
//自定义函数
void test();//为了告诉编译器已经声明了
//调用函数放在main函数之后才需这样声明
int main()
{
test();
return 0;//函数的调用
}
void test() //void 可以定义为int char 等
{
int i=3;
i+=5;
printf("i=%d\n",i);
scanf("%d",&i);
printf("scanf:%d\n",i);
return;
}
无参函数
#include<stdio.h>
//自定义函数
void test() //void 可以定义为int char 等
{
//实现累加和问题
int i=1;
int sum=0;
for(i=1;i<10;i++)
sum+=i;
printf("sum=%d\n",sum);
return;
}
int main()
{
int i=0;
//for(i=0;i<5;i++)
test();
}
有参函数
#include<stdio.h>
//自定义函数
void test(int a) //void 可以定义为int char 等
{
int j=0;
int sum=0;
for(j=0;i<=a;j++)
sum+=j;
printf("sum=%d\n",sum);
return;
}
//形参在发生调用时 系统会默认把实参赋给形参
//发生调用时形参才会分配空间
int main()
{
int i=10;
//for(i=0;i<5;i++)
test(5); //默认a=5
test(i); //默认a=10
return 0;
综合用法：
#include<stdio.h>
//自定义函数
void jiecheng()
{
int i;
int mul=1;
int num=1;
printf("input num:\n");
scanf("%d",&num);
for(i=1;i<=num;i++)
mul *=i;
printf("mul=%d\n",mul);
return;
}
void jiech(int a)
{
int j=1;
int sum=1;
for(j=1;j<=a;j++)
sum *=j;
printf("sum=%d\n",sum);
return;
}
int main()
{
jiecheng();
int num;
printf("input num:\n");
scanf("%d",&num);
jiech(num); //默认a=5
return 0;
}
4.函数的返回值
无返回值的类型为:void
DataType FuncName(参数列表)
{
//函数体;
}
DataType:决定了函数的返回值
如果函数的返回值能够在后面的程序中使用，则需要相同类型的变量接收返回值
若是void类型的函数，则无返回值，return可有可无！！！
若函数不是void类型，则必须要有return！！！
5.return的作用
a.函数遇到return,则函数结束，后面代码不再执行
b.用于返回函数的即执行结果
#include<stdio.h>
//自定义函数
int test() //有返回值 int 型函数体
{
int i=0;
int sum=0;
for(i=0;i<10;i++)
sum+=i;
printf("sum=%d\n",sum);
return 100; //返回的是什么值ret就接受什么值
}
int main()
{
//若test()的返回值对后面的代码有用，需要用相同类型的变量接收
//test()的返回值，若没用，则无需接收
这里省略了一个auto全局变量
int ret=test();//返回的值用ret来接收
printf("ret=%d\n",ret);
return 0;
}
6.关键字
变量分为全局变量和局部变量
全局变量：在函数体之外定义的变量
其作用域是从变量定义处开始，一直到本文件结束！！
在全局变量定义之前函数体不可以使用（百度）
局部变量:在函数中定义的变量，其作用域是整个函数!
函数结束，局部变量会自动释放，因此不同的
函数中可以使用相同的变量名
auto: 可有可无 声明变量是动态变量
作用域从定义处到文件末
生命周期:整个程序运行期间
动态全局变量
动态局部变量
#include<stdio.h>
int main()
{
auto int a=5; //auto 可以省略 来修饰
是静态还是动态 我们一般用的都是动态
int b=4;
printf("%d %d\n",a,b);
}
#include<stdio.h>
int c=123;//动态全局变量
static int sum=45;//静态全局变量
int main()
{
auto int a=5;
int b=4;
printf("%d %d\n",a,b);
static int num=4;//静态局部变量
}
static:若定义时没有初始化则系统默认初始化为0
作用域：
从定义开始到文件结束
生命周期：
整个程序运行期间
声明变量为静态变量
静态变量只初始化一次
静态全局变量
静态局部变量
静态函数：static修饰的函数只用于本文件使用
#include<stdio.h>
int sum=4; //全局变量
void test()
{
sum+=5;
printf("test():sum=%d\n",sum);
return;
}
int main()
{ test();
printf("main():sum=%d\n",sum);
return 0;
}
extern:
声明为外部变量:extern,int,sum;
修饰函数:extern int test()
声明变量或函数在外部已经定义（百度再深刻了解）
#include<stdio.h>
extern int num;//告诉编译器，此变量已在外部文件中定义过
//调用这个外部文件 在当前的开头要声明extern
int test()
{
sum+=8;
printf("sum=%d\n",sum);
return 3;
}
register:
寄存器变量:变量直接存放在寄存器中
cpu的寄存器个数有限，不可以定义多个寄存器变量
速度快
const:
常量，不可更改其值
const int num=5;值不可更改
const int *p; 指针变量的值不可更改
int const *p;指针变量的值不可更改
int* const p;地址不可更改
const int* const p;值和地址都不可更改
#include<stdio.h>
int main()
{
const int a=5;
int const b=4;
b+=5;//error 有错 值不可更改
return 0;
}
7.函数的传参 值传递 地址传递
#include<stdio.h>
//这里只传了值，没有传地址 所以只是值交换了
//并没有改变变量地址里的内容
void swap(int a,int b)
{
int temp=a;
a=b;
b=temp;
return;
}
//传地址
void swap_addr(int *pa,int *pb)
{
int temp=*pa;
*pa=*pb;
*pb=temp;
return;
}
int main()
{
int x=0;
int y=0;
printf("input x,y:");
scanf("%d,%d",&x,&y);
printf("before:%d,%d\n",x,y);
swap(x,y);
printf("behind:%d,%d\n",x,y);
swap_addr(&x,&y);
printf("behind:%d,%d\n",x,y);
}
二、指针函数 和函数值针
1.指针函数；
int *test;
返回一个局部地址是不允许的，没有意义
注意返回值问题，返回的是一个地址！！
#include<stdio.h>
//可以正确执行，但不允许
int *test()
{
int num=6;
int *p=#
return p;
}
//不返回局部地址
//局部变量在函数结束后自动消亡，其地址被系统收回
int *test1()
{
int num=66;
int *p=#
return # //不能返回局部变量的地址
}
int main()
{
int *pa=test();
printf("*pa=%d\n",*pa);
return 0;
}
2.函数值针:
#include<stdio.h>
int test()
{
int a=5;
a+=6;
printf("%d\n",a);
return 1;
}
int main()
{
//指针指向了这个函数
//int *pa的指针类型：int (*)() pa;==int (*pa)();
int (*pa)()=test;//test后面不用加括号()函数名是一个地址
//两种调用方式
pa();
//(*pa)();
return 0;
}
