函数
函数三要素：函数名，参数，返回值
重点研究函数的输入输出
随机数函数
//产生一组随机数
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
srand(time(NULL));//和随机函数一起连用
int randArr[10];
int count = 0;
while(1)
{
int num = rand()%10;//随机函数
randArr[count++] = num;
for(int i = 0;i < count-1;i++) {
if(randArr[i] == randArr[count-1]) {
count--;
break;
}
}
if(count == 10) {
break;
}
}
for(int i = 0;i < 10;i++) {
printf("%d
",randArr[i]);
}
return 0;
}
[100,200]的随机数
rand()%100;//[0,99]
rand()%100+100;//[101,200]
rand()%101+100;//[100,200]
获取当前的时间
#include<stdio.h>
#include<time.h>
int main() {
time_t rawtime;//返回1970.1.1.0:00为起点作为参数
rawtime = time(NULL);
struct tm * timeinfo;//
timeinfo = localtime(&rawtime);
printf("year : %d
",timeinfo->tm_year);
}
自定义函数
最大值函数
#include<stdio.h>
int main() {
int a = 3;
int b = 5;
int iMax = myMax(a,b);
printf("max value = %d
",iMax);
}
int myMax(int i,int j) {
if(i > j)
return i;
else
return j;
//return i > j?i:j;
}
定义和申明的关系
定义在前，调用在后
定义在后，调用在前，此时需要向前申明。函数的特点是先声明，在调用。
#include<stdio.h>
int myMax(int i,int j) {
if(i > j)
return i;
else
return j;
//return i > j?i:j;
}
int main() {
int a = 3;
int b = 5;
int iMax = myMax(a,b);
printf("max value = %d
",iMax);
}
#include<stdio.h>
int myMax(int i,int j);
int main() {
int a = 3;
int b = 5;
int iMax = myMax(a,b);
printf("max value = %d
",iMax);
}
int myMax(int i,int j) {
if(i > j)
return i;
else
return j;
//return i > j?i:j;
}
形参与实参
形参：在函数定义或者是声明的时候的参数，声明中的参数可以省略，但参数类型不能省略。
实参：在函数调用的时候所传入的参数
入参中如果没有参数，可以用void表示，通常省略，如果没有返回值，即返回类型是void,此时void不可省略，若省略系统会默认返回一个类型
传值与传址
使用是有区别，本质上都是传递一个数值。
函数被调用之前，其所有的变量尚未开辟空间，调用时才开辟空间，空间消失结束语函数调用完毕。
#include<stdio.h>
void func(int a);//前向声明
int main() {
int a = 10;
func(a);
printf("main a = %d
",a);
}
void func(int a) {
a++;
printf("func a = %d
",a);
}
//func a = 11
//main a = 10
//传值函数调用参数的传递过程
#include<stdio.h>
void func(int * pa);
int main() {
int a = 10;
func(&a);//传址
printf("main a = %d
",a);
return 0;
}
void func(int *pa) {//传进来的地址
(*pa)++;//对地址取内容再++
printf("func a %d
",*pa);//11
}
两个数的交换
#include<stdio.h>
void mySwap(int a,int b);
void mySwap1(int *pa,int *pb);
int main() {
int a = 3,b = 5;
printf("a = %d,b = %d
",a,b);// 3 5
mySwap(a,b);
printf("a = %d,b = %d
",a,b);//3 5
mySwap1(&a,&b);//传入要交换的地址
printf("a = %d,b = %d
",a,b);// 5 3
return 0;
}
void mySwap(int a,int b) {
int t = a;
a = b;
b = t;
//这里确实改变了
}
//实际并没有交换（传值的方式时间并没有发生交换）
void mySwap1(int *pa,int *pb) {//形参的形式是对传入的实参的地址取内容
int t = *pa;
*pa = *pb;
*pb = t;
}
地址对于不同作用域来说是开放的
传递一维数组
#include<stdio.h>
void disArray(int arr[10]);
int main() {
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
printf("main sizeof(arr) = %d
",sizeof(arr));//40
disArray(arr);
return 0;
}
void disArray(int arr[10]) {//大小始终是4
printf("disArray sizeof(arr) = %d
",sizeof(arr));//4
}
/*
<=>
void disArray(int *p) {
printf("disArray sizeof(arr) = %d
",sizeof(p));
}
*/
数组的传递不可能通过拷贝的方式来传递，c语言基于效率的原因，在传递时，数组名仅当地址使用
数组的三要素：起始地址，步长（刻度），范围
数组名是一个指针，它包含了（起始地址，步长），但数组名没有里面没有包含范围，所以在传递一维数组的时候，要传数组名和范围。
#include<stdio.h>
void disArray1(int *p,int n);
int main() {
int arr[] = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10};
printf("main sizeof(arr) = %d
",sizeof(arr));
disArray1(&arr[0],sizeof(arr)/sizeof(arr[0]));//传递给数组的首地址和范围大小
return 0;
}
void disArray1(int *p,int n) {
printf("disArray1 sizeof(arr) = %d
",sizeof(p));//大小不变4
for(int i = 0;i < n;i++) {
printf("%d
",*p++);
}
}
函数在结构设计或扩及功能设计的应用
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void initArray(int *arr,int n);
void displayArray(int *arr,int n);
void sortArray(int * arr,int n);
void smallIdx(int startIdx,int * arr,int n)
void myswap(int *pa,int *pb);
int main() {
int arr[10];
initArray(arr,10);
displayArray(arr,10);
printf("+++++++++++++++");
sortArray(arr,10);
displayArray(arr,10);
return 0;
}
//随机产生10个数
void initArray(int *arr,int n) {
srand(time(NULL));
for(int i = 0;i < n;i++ ) {
*arr++ = rand()%100;
}
}
//输出数组
void displayArray(int *arr,int n) {
for(int i = 0;i < n;i++) {
printf("%2d
",*arr++);
}
}
//排序
void sortArray(int * arr,int n) {
int idx;
for(int i = 0;i < n-1;i++) {
idx = smallIdx(i,arr,n);
if(idx != i) {
myswap(&arr[i],&arr[idx]);
}
}
}
void smallIdx(int startIdx,int * arr,int n) {
int idx = startIdx;
for(int i = startIdx+1,i < n;i++) {
if(arr[i] < arr[idx]) {
idx = i;
}
}
return idx;
}
void myswap(int *pa,int *pb) {
*pa ^= *pb;
*pb ^= *pb;
*pa ^= *pb;
}
传递二维数组
#include<stdio.h>
void func(int(*p)[4],int n);
int main() {
int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
func(arr,3);
return 0;
}
void func(int (*p)[4],int n) {//二维数组的传递
for(int i = 0;i < n;i++) {
for(int j = 0;j < 4;j++) {
printf("%3d",p[i][j]);
}
putchar(10);
}
}
函数的调用
函数之间是平行的，函数嵌套调用多了会挂掉，栈溢出
递归调用
直接调用或者间接调用自己的情形(recursive),递归是比较接近自然语言特性的调用方式，递归必须要用合理的出口，不然会挂掉
//有 5 个人坐在一起，问第 5 个人多少岁？他说比第 4 个人大 2 岁。问第 4 个人岁数，他说比第 3 个人大 2 岁。问第 3 个人，又说比第 2 个人大 2 岁。问第 2 个人，说比第 1 个人大 2 岁。最后问第 1 个人，他说是 10 岁。请问第 5 个人多大？
#include<stdio.h>
int getAge(int n);
int main() {
int age = getAge(5);
printf("age = %d
",age);
return 0;
}
int getAge(int n) {
if(n == 1) {
return 10;
}else{
return getAge(--n) + 2;
}
}
递归起始条件getAge(n),有使递归趋于结束的语句getAge(--n)递归终止条件n == 1
书写结构：
递归返回 func(递归条件) {
if(递归终止条件)
return 终止处理;
else
return func(趋于递归终结的条件);
}
注意递归条件是否参与计算，如果参与计算，则趋于结束的条件不能++，或着--操作
#include<stdio.h>
int factorail(int n);
int main() {
int factorail = factorial(5);
printf("5! = %d
",&factorail);
}
int factorail(int n) {
if(n == 0)
return 1;
else
return n*factorail(n-1);
//return n*factorail(--n);前面n参与了运算，不能使用--运算
}