C/C++(函数)

函数

函数三要素：函数名，参数，返回值

重点研究函数的输入输出

随机数函数

//产生一组随机数
#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\n",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\n",timeinfo->tm_year);
}

自定义函数

最大值函数

#include<stdio.h>
int main() {
    int a = 3;
    int b = 5;
    int iMax = myMax(a,b);
    printf("max value = %d\n",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\n",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\n",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\n",a);
}
void func(int a) {
    a++;
    printf("func a = %d\n",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\n",a);
    return 0;
}
void func(int *pa) {//传进来的地址
    (*pa)++;//对地址取内容再++
    printf("func a %d\n",*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\n",a,b);// 3 5
    mySwap(a,b);
    printf("a = %d,b = %d\n",a,b);//3 5
    mySwap1(&a,&b);//传入要交换的地址
    printf("a = %d,b = %d\n",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\n",sizeof(arr));//40
    disArray(arr);

    return 0;
}
void disArray(int arr[10]) {//大小始终是4
    printf("disArray sizeof(arr) = %d\n",sizeof(arr));//4
}
/*
<=>
void disArray(int *p) {
    printf("disArray sizeof(arr) = %d\n",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\n",sizeof(arr));
    disArray1(&arr[0],sizeof(arr)/sizeof(arr[0]));//传递给数组的首地址和范围大小

    return 0;
}
void disArray1(int *p,int n) {
    printf("disArray1 sizeof(arr) = %d\n",sizeof(p));//大小不变4
    for(int i = 0;i < n;i++) {
        printf("%d\n",*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\n",*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\n",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\n",&factorail);
}
int factorail(int n) {
    if(n == 0)
        return 1;
    else
        return n*factorail(n-1);
        //return n*factorail(--n);前面n参与了运算，不能使用--运算
}