华清远见25072班C语言学习day10

重点内容：

指针：

二级指针：

        数据类型 **指针变量名;        

        二级指针用于保存一级指针的地址

多级指针的偏移量：

        二级指针指向一级指针，偏移量是一级指针的大小8/4（64位操作系统/32位操作系统）

        三级指针指向二级指针，偏移量是二级指针的大小8/4（64位操作系统/32位操作系统）

atoi函数：

        int atoi(字符串的首地址);

        功能： 将字符串转成对应的整形数据，遇到非字符数据就停止

函数：

定义：

        返回值类型 函数名(参数列表) { //函数体 }

        函数的参数列表中可以有多个数据

        返回值：如果函数没有返回值可以写成void 返回值的作用，函数的结果用来返回给主调函数的，如果主调函数处不需要函数的结果，函数可以没有返回值

        参数：如果函数实现功能时，需要外部传递数据过来，那么函数就需要参数

        写在函数定义位置的参数叫做形式参数，没有实际的意义，只起到占位作用        

        函数的定义不能嵌套        

函数的分类：

        是否需要自己定义：库函数、自定义函数

        是否被调用的角度：主调函数、被调函数

        是否有返回值和参数的角度：

                1.有参有返回值

                2.有参无返回值

                3.无参无返回值

                4.无参有返回值

函数的调用：

        函数名(实际参数);

        实际参数的个数需要和形式参数的个数保持一致

        函数调用的过程就是实参初始化形参的过程

        函数定义的代码不会执行，只有函数被调用时才会执行函数体

        不同函数中的同名变量，互不相关

函数的返回值：

        函数的返回值可以理解为函数调用的结果

函数声明：

        函数定义在函数调用下方时，需要函数声明

        格式: 返回值类型 函数名(参数类型);

        作用: 告诉编译器，函数的参数类型和返回值类型，让编译器可以找到该函数

数组作为函数参数传递：

        所有出现在函数形参位置长得像数组定义的代码，实际上都是指针        

        void fun(int *p,int len) //一维整形数组：形参需要使用同类型的指针变量接收一维整形数组的地址,还需要传一维整型数组的长度(因为在功能函数中不能求出数组的长度)

        void fun(char *p)//一维字符数组:只需要接收一维字符数组的首地址即可，不需要接收长度

作业：

1.使用指针实现冒泡排序

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
    int arr[]={1,3,5,7,9,2,4,6,8,10};
    int *p=arr;
    int len=sizeof(arr)/sizeof(arr[0]);
    for(int i=0;i<len-1;i++)
    {
        for(int j=0;j<len-i-1;j++)
        {
            if(p[j]>p[j+1])
            {
                int temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }

    for(int i=0;i<len;i++)
    {
        printf("%d",arr[i]);
    }
    putchar(10);
    return 0;
}
 

2.用指针求一维数组中元素的最大值

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
    int arr[]={1,3,5,7,9,2,4,6,8,10};
    int *p=arr;
    int max_sum=arr[0];
    int len=sizeof(arr)/sizeof(arr[0]);
    for(int i=0;i<len;i++)
    {
        if(p[i]>max_sum)
            max_sum=p[i];
    }
    printf("%d\n",max_sum);
    return 0;
}

3.实现自己的strlen、strcpy、strcat、strcmp函数

strlen函数:

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int my_strlen(char *p)
{
    int i=0,count=0;
    while(p[i])
    {
        count++;
        i++;
    }
    return count;
}
int main(int argc, const char *argv[])
{
    char arr1[100]="hello";
    char arr2[100]="world";
    char *p1=arr1;
    char *p2=arr2;
    int len=my_strlen(p1);
    printf("len=%d\n",len);
    return 0;
}
 

strcpy函数：

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void my_strcpy(char *p1,char *p2)
{
    int i=0;
    while(p2[i])
    {
        p1[i]=p2[i];
        i++;
    }
}
int main(int argc, const char *argv[])
{
    char arr1[100]="hello";
    char arr2[100]="world";
    char *p1=arr1;
    char *p2=arr2;
    my_strcpy(p1,p2);
    puts(arr1);
    return 0;
}
 

strcat函数：

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void my_strcat(char *p1,char *p2)
{
    int i=0,j=0;
    while(p1[i])
    {
        i++;
    }
    while(p2[j])
    {
        p1[i]=p2[j];
        i++;
        j++;
    }
    p1[i]=p2[j];
}
int main(int argc, const char *argv[])
{
    char arr1[100]="hello";
    char arr2[100]="world";
    char *p1=arr1;
    char *p2=arr2;
    my_strcat(p1,p2);
    puts(arr1);
    return 0;
}

strcmp函数：

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void my_strcmp(char *p1,char *p2)
{
    int i=0;
    while(p1[i]&&p1[i]==p2[i])
    {
        i++;
    }
    if(p1[i]-p2[i]>0)
        printf("p1>p2\n");
    else if(p1[i]-p2[i]<0)
        printf("p1<p2\n");
    else
        printf("p1=p2");
}
int main(int argc, const char *argv[])
{
    char arr1[100]="hello";
    char arr2[100]="world";
    char *p1=arr1;
    char *p2=arr2;
    my_strcmp(p1,p2);
    return 0;
}
4.尝试用指针实现求二维数组中，最大值的函数

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int max_sum(int (*p)[3],int n,int m)
{
    int max_num=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(*(p[i]+j)>max_num)
            {
                max_num=*(p[i]+j);
            }
        }
    }
    return max_num;
}
int main(int argc, const char *argv[])
{
    int arr[2][3]={1,3,5,2,4,6};
    int (*p)[3]=arr;
    int max=max_sum(p,2,3);
    printf("max=%d\n",max);
    return 0;
}

5.猴子吃桃问题是一个著名的数学问题，也是中国古代著名的算术题之一。“猴子吃桃”的背景是这样的：一只猴子第一天摘下了一堆桃子，当即吃了一半，还不过瘾，又多吃了一个；第二天早上又将剩下的桃子吃了一半，同样又多吃了一个；以后每天早上都吃了前一天剩下的一半零一个，到第十天早上再想吃时，发现只剩下一个桃子了，问这只猴子第一天共摘了多少个桃子？

递归函数求解：

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int peach(int day)
{
    //day10是递归出口
    if(day==10)return 1;
    return (peach(day+1)+1)*2;
}
int main(int argc, const char *argv[])
{
    printf("%d\n",peach(1));
    return 0;
}
 

循环求解：

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
    int day=10;int peach=1;
    for(int i=day-1;i>0;i--)
    {
        peach=(peach+1)*2;
    }
    printf("peach=%d\n",peach);
    return 0;
}
 

6.自己实现atio函数

程序源码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int my_atoi(const char *p);
int my_atoi(const char *p)
{
    int sum =0;
    while(*p>='0'&&*p<='9')
    {
        sum=sum*10+*p-'0';
        p++;
    }
    return sum;
}
int main(int argc, const char *argv[])
{
    char *p="1234";
    int ret=my_atoi(p);
    printf("%d\n",ret);
    return 0;
}

7.思维导图