函数类的学习

//从这两个网站可搜索所有的库函数，是一个查询工具

//内存操作函数memory set = memset
memset(void*ptr,int value,size_t num);
//把ptr所指向的空间的前num个字节的内容设置成指定的value这个值

//例
#include<stdio.h>
#include<string.h>
int main()
{
    char arr[]="hello world";
    memset(arr,'6',5);
    printf("%s\n",arr);
    //66666 world
    return 0;
}

//定义函数
#include<stdio.h>
int add(int a,int b)//定义a,b为两个整型
{
    int z = a + b;
    return z;//因为返回时z为整型，所以返回类型也为整型int
}
//函数的使用
int main()
{
    int x = 100;
    int y = 200;
    int sum = 0;
    sum = add(x,y);//自定义"add"的使用需要用一个变量储存
    //而'x'传给了a,'y'传给b,与定义的函数对应
    printf("%d",sum);
    return 0;
}

//例：设计交换函数，按常规思想无法实现
#include<stdio.h>
void Swap1(int x,int y)
{
    int z = 0;
    z = x;
    x = y;
    y = z;
}
int main()
{
    int a = 10;
    int b = 20;
    printf("a=%d b=%d\n",a,b);
    Swap1(a,b);
    printf("a=%d b=%d",a,b);
    return 0;
    //该代码俩打印结果a=10 b=20，无法实现交换
    //原因是定义的'x'和'y'有自己的地址与'a''b'无任何关系
    //因此'a''b'地址的值不变，打印结果也就不变
}

//指针思想
#include<stdio.h>
void Swap2(int* pa, int* pb)
{
    int z = 0;
    z = *pa;//通过指针变量存放的地址，找到该地址存放的内容赋值给z
    *pa = *pb;//同理通过pb存放的地址找到该位置，即b，将改内容赋值给pa存放的地址的位置，即a
    *pb = z;//z变量内容赋值给pb存放的地址的位置，即b
}
int main()
{
    int a = 10;
    int b = 20;
    printf("a=%d b=%d\n",a,b);
    Swap2(&a,&b);
    printf("a=%d b=%d",a,b);
    return 0;
}    

//以该函数为例
#include<stdio.h>
int add(int a,int b)
{
    int z = a + b;
    return z;
}
int main()
{
    int x = 100;
    int y = 200;
    int sum = 0;
    sum = add(x,y);//括号内可以放，常量，变量，表达式，函数
    printf("%d",sum);
    return 0;
}

#include<stdio.h>
int add(int a,int b)//括号内为形参
{
    int z = a + b;
    return z;
}
//当下面不调用add函数时，上方括号内的a，b不存在
int main()
{
    int x = 100;
    int y = 200;
    int sum = 0;
    sum = add(x,y);
    printf("%d",sum);
    return 0;
}

//传址调用，例
//每使用一次自定义函数，num值加1
#include<stdio.h>
void Add(int*p)
{
    (*p)++;//加括号是因为++的优先级比*p大，不加括号结果为p++
}
int main()
{
    int num = 0;
    Add(&num);
    printf("num = %d\n",num);//1
    Add(&num);
    printf("num = %d\n",num);//2
    Add(&num);
    printf("num = %d\n",num);//3
}

//二分查找为例
//先看代码后看注释
#include<stdio.h>
int binary_search(int arr,int k)
{
    int sz = sizeof(arr)/sizeof(arr[0]);
    int left = 0;
    int right = sz - 1;
    int mid = (left+right)/2;
    while(left <= right)
    {
        if(arr[mid]<k)
        {
            left = mid + 1;
        }
        else if(arr[mid]>k)
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int k = 5;
    //            此处arr传递的为指针，即数组arr第一个元素的地址
    int s = binary_search(arr,k);
    // 所以上方arr为指针
    if(s == -1)
    {
        printf("找不到该数字\n");
    }
    else
    {
        printf("找到了，该下标是：%d\n",s);
    }
    return 0;
}
// 该函数无法运行

#include<stdio.h>
int binary_search(int arr[],int k,int sz)
{
    int left = 0;
    int right = sz - 1;
    int mid = (left+right)/2;
    while(left < right)
    {
        if(arr[mid]<k)
        {
            left = mid + 1;
        }
        else if(arr[mid]>k)
        {
            right = mid - 1;
        }
        else
        {
            return mid;
        }
    }
    return -1;
}
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int k = 5;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int s = binary_search(arr,k,sz);
    if(s == -1)
    {
        printf("找不到该数字\n");
    }
    else
    {
        printf("找到了，该下标是：%d\n",s);
    }
    return 0;
}

#include<stdio.h>
void new_line()
{
    printf("hollow\n");
}
void three_time()
{
    int i = 0;
    for(i=0;i<3;i++)
    {
        new_line();
    }
}
int main()
{
    three_time():
    return 0;
}
//打印三次"hollow".

#include<stdio.h>
int main()
{
    int len = 0;
    //1
    len = strlen("abc");
    printf("%d\n",len);
    //2
    printf("%d\n",strlen("abc"));
}
//将strlen("abc")的结果作为printf函数的参数，即方式2
//两种方式都可以运行，方式2为链式访问，更为简洁

//函数声明
#include<stdio.h>
int Add(int x, int y);
 
int main()
{
    int a = 10;
    int b = 20;
    int sum = 0;
    //函数调用
    sum = Add(a,b);
    printf("%d\n",sum);
    return 0;
}
//函数定义
int Add(int x,int y)
{
    int z=x+y;
    return z;
}
//这种写法比较啰嗦，浪费时间

//创建一个( ).h的头文件,将函数声明放进去
int Add(int x,int y)

//再创建一个( ).c的源文件，将函数定义放进去
int Add(int x,int y)
{
    int z=x+y;
    return z;
}

//最后在要写代码的源文件(test.c)中使用自定义的函数
#include<stdio.h>
#include"Add.h"//用""引自己定义的函数
int main()
{
    int a = 10;
    int b = 20;
    int sum = 0;
    sum = Add(a,b);
    printf("%d\n",sum);
    return 0;
}

//例
#include<stdio.h>
int main()
{
    printf("hehe\n");
    main();
    return 0;
}
//最终结果导致栈溢出,即栈区空间耗尽"stack overflow",因为递归无条件

#include<stdio.h>
void print(int n)
{
    if(n>9)
    {
        print(n/10);
    }
    printf("%d ",n%10);
}
// 这就是递归思想。假设输入的是123，在第一次调用print时，"123"进入if语句，n变为12，再调用print进入if语句，n变为1，此时代码往下走，打印数为1，随后回到第二次调用print时刻，此时n=12，打印数位2，再回到第一次调用print时刻，此时n=123，打印数为3。这就是"递"和"归"
int main()
{
    int num = 0;//123
    scanf("%d",&num);
    print(num);
    return 0;
}
//这不会无线循环，因为有定义条件

//依照上方代码思考
#include<stdio.h>
int my_strlen(char*str)
{
    if (*str!='\0')
        return 1+my_strlen(str+1);
    else
        return 0;
}
int main()
{
    char arr[]="bit";
    int len = my_strlen(arr);//传上去的为第一个元素的地址
    printf("len = %d\n",len);
    return 0;
}

//n的阶乘，这里只打自定义函数
int Fac(int n)
{
    if(n <= 1)
        return 1;
    else
        return n*Fac(n-1);
}

//求第n个斐波那契数  即 1 1 2 3 5 8 13 21 34 55
//使用递归运算效率低下
int count = 0;
int Fib(int n)
{
    if(n=3)
    {
        count++;//看一下n=3是被重复计算多少次
    }
    if(n<=2)
        return 1;
    else
        return Fib(n-1)+Fib(n-2);
}
int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d",&n);
    ret = Fib(n);
    printf("ret = %d\n",ret);
    printf("count = %d",count);//count=39088169
    return 0;
}

//迭代思想，跟循环挺像
#include<stdio.h>
int Fib(int n)
{
    int a = 1;
    int b = 1;
    int c = 1;
    while(n>2)
    {
        c = a+b;
        a = b;
        b = c;
        n--;
    }
    return c;
}
int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d",&n);
    ret = Fib(n);
    printf("ret = %d\n",ret);
    return 0;
}