linux学习day9

值传递与地址传递

1. 1 值传递

1.1.1 值传递的原理

1.1.2 说明：

值传递过程中，形参与实参操作的是不同的内存空间

当普通变量作为函数参数传递时，是单向的值传递，仅仅只是将实参的值，复制一份给形参使用，形参的改变不会影响到实参的值

#include<myhead.h>

//定义交换函数
void swap_1(int m, int n)
{
    //完成两个数的交换
    int temp = m; 
    m = n; 
    n = temp;

    printf("交换后，swap_1:: m = %d, n = %d\n", m, n);
}


/*********************主程序*********************/
int main(int argc, const char *argv[])
{
    //定义两个变量
    int num = 520;
    int key = 1314;

    //调用交换函数
    swap_1(num, key);
    printf("交换后，main:: num = %d, key = %d\n", num, key);


    return 0;
}

1.2. 地址传递

1.2.1 地址传递原理

 1.2.2 说明

当实参传递的是数组名、指针或变量的地址（&num）时，可以理解成是地址传递

地址传递过程中，形参与实参操作的是同一块内存空间

形参对内存空间进行改变时，实参也跟着一起改变

#include<myhead.h>

//定义冒泡排序函数
void sort_up(int brr[], int n)
{
    printf("sizeof(brr) = %ld\n", sizeof(brr));   //
    //进行冒泡排序
    for(int i=1; i<n; i++)
    {
        for(int j=0; j<n-i; j++)
        {
            if(brr[j] > brr[j+1])
            {
                int temp = brr[j];
                brr[j] = brr[j+1];
                brr[j+1] = temp;
            }
        }
    }
    printf("排序结束\n");
}



/****************主程序********************/
int main(int argc, const char *argv[])
{
    //定义一个一位数组并初始化
    int arr[5] = {2,8,1,6,7};
    printf("sizeof(arr) = %ld\n", sizeof(arr));    //20

    //调用冒泡排序函数，完成升序排序
    sort_up(arr, 5);

    //输出排序后的结果
    printf("排序后：");
    for(int i=0; i<5; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");

    return 0;
}

递归函数

2.1 递归的概念

所谓递归，就是一个函数直接或间接的形式调用自身，这样的函数调用，我们称为递归调用

#include<myhead.h>

//定义一个讲故事函数
void say_story()
{
    printf("从前有座山，山里有个庙，庙里有个老和尚给小和尚讲故事，故事里说：");

    say_story();
}




int main(int argc, const char *argv[])
{
    
    //调用讲故事函数
    say_story();

    return 0;
}

2.2. 递归条件

1> 递归出口：用于终止递归进行进行的条件

2> 递归表达式：能够让递归继续进行的函数调用

2.3 递归思想

当直接解决规模比较大的问题不能进行时，需要先解决规模较小的原理一致的问题后，大的问题得以解决时，可以考虑使用递归逐层分解，逐层合并

2.4 练习

1> 求n！结果

#include<stdio.h>

//递归
int digui(int n){
    if(n==0){
        return 1;
    }else{
        return n*digui(n-1);
    }
}

int main(){
    int n=0;
    printf("请输入阶数");
    scanf("%d",&n);
    printf("阶乘为:%d\n",digui(n));
}

 2> 求斐波那契数列第n项的值

1 1 2 3 5 8 13 21 。。。

#include<stdio.h>

int fei(int n){
    if(n==1||n==2){
        return 1;
    }else{
        return fei(n-1)+fei(n-2);
    }
}

int main(){
    int n=0;
    printf("第几项");
    scanf("%d",&n);
    printf("%d项为:%d\n",n,fei(n));
}

指针

3.1.指针的相关概念

1.引入目的:能够从地址的角度，找到内存中的数据，而不是以变量的角度去找，效率较高

2.指针:就是内存地址编号

3.指针变量:由于指针这个地址编号很难记忆，我们引入指针变量存储指针
                   存储地址的变量称为指针变量

4.指针变量中，指针存储地址，作为一个特殊的数据类型，其大小是固定的8字节

3.2. 指针变量的定义

3.2.1 定义格式:

定义格式:数据类型*指针名;
              例如:int* ptr;

3.2.2 指针变量的初始化

1、使用一个相同数据类型的变量的地址为其进行初始化

                        int num = 520;

                        int * ptr = #         //将num的地址赋值个指针变量 ptr //定义一个指针变量ptr，指向num

2、使用一个已经初始化了的指针变量给一个新的指针变量进行初始化

                        int * qtr = ptr;                 //此时表示两个指针变量同时存储了num的地址 int *qtr = &num

3、使用地址的0 就是 NULL为其初始化

                        int *wtr = NULL;

4、注意：没有初始化的指针变量不能直接使用，因为该指针变量中存储了一个随机地址，如果对其进行更改，可能会导致系统瘫痪

5、野指针：指向非法内存的指针称为野指针

                        产生情况： 1）定义指针时，没有为其进行初始化

                                           2) 指向了一个内存空间，但是随着程序的进行，该内存空间被回收了，那么该指针也是野指针（悬空指针）

                                           3) 数组下标越界时，访问的地址也是野指针

3.2.3指针变量的使用：

使用运算符 ‘ * ’来取得指针变量中的值，我们也称该运算为 取值运算

1、指针变量在定义时，*号只是身份的象征，表示该语句定义的是指针变量

2、指针变量使用是，*号表示一个运算，取值运算，就是取得该指针变量指向的内存空间中的值

3、总结一下 * 号在C语言中的用途

                        1) 表示乘号，是一个双目运算符

                        2) 定义指针时，是身份的象征，表示定义的是指针变量

                        3) 使用指针时，是取值运算符，表示取得指针变量指向的内存空间中的值

4、总结一下 & 在C语言中的用途

                        1) 一个&表示双目运算符 按位 与运算

                        2) 两个&&表示双目运算符 逻辑 与运算

                        3) 一个&表示单目运算符 取址运算

5、&与*在指针的方面，互为逆运算

                        int num = 520;

                        int *ptr = &num

                1)         *&num ==> *（&num） ==> *(ptr) ==> num

                2) &*ptr ==> &(*ptr) ==> &(num) ==> ptr

                3) *&ptr ==>*(&ptr) ==> *(ptr的二级地址) ==> ptr

                4) &*num ==>报错

#include<myhead.h>

int main(int argc, const char *argv[])
{
    int num = 520;

    printf("num = %d\n", num);    //num的值
    printf("&num = %p\n", &num);   //输出变量的地址

    //定义指针变量指向num
    int *ptr = &num;        //该语句执行后：num <==> *ptr

    printf("ptr = %p\n", ptr);    //得到的是num的地址
    
    //通过ptr获取num的值
    printf("*ptr = %d\n", *ptr);         //输出的是num的值

    //解释解释什么叫等价
    num = 1314;
    printf("*ptr = %d\n", *ptr);         //输出的是num的值

    *ptr = 999;
    printf("num = %d\n", num);    //num的值



    return 0;
}

3.2.4指针的大小与指针的类型之间的关系

1）不同数据类型的指针所占内存空间都是一样的，都是指针的大小，32位系统下为4字节，64位系统下为 8字节

2）指针的数据类型存在的意义，不是为了给指针分配内存空间的，而是为了指针偏移使用的

3）不同类型的指针，在进行指针偏移时，偏移的大小跟指针的数据类型有关

4）指针每偏移一个单位，内存空间就会偏移一个数据类型大小的字节数

5）指针指向普通变量时，指针的偏移是没有意义的，但是，指针指向数组时，指针的偏移就有了现实的意义，表示指向上一个元素或者下一个元素的地址

#include<myhead.h>

int main(int argc, const char *argv[])
{
    char value_1 = 'H';      //定义字符数据
    short value_2 = 520;     //定义短整形数据
    int value_3 = 1314;       //定义整形数据
    double value_4 = 3.14;    //定义双精度浮点型数据

    //定义指针指向普通变量
    char *ptr1 = &value_1;
    short *ptr2 = &value_2;
    int * ptr3 = &value_3;
    double *ptr4 = &value_4;

    printf("ptr1 = %p\n", ptr1);
    printf("ptr2 = %p\n", ptr2);
    printf("ptr3 = %p\n", ptr3);
    printf("ptr4 = %p\n", ptr4);

    printf("*************************************\n");
    printf("ptr1+1 = %p\n", ptr1+1);
    printf("ptr2+1 = %p\n", ptr2+1);
    printf("ptr3+1 = %p\n", ptr3+1);
    printf("ptr4+1 = %p\n", ptr4+1);
    return 0;
}

3.2.5 指针可以使用的运算

关系运算： == 判断两个指针是否指向同一个内存地址，ptr==NULL，判空指针

数加运算：表示对指针进行偏移

取值运算（*）、取址运算（&）

作业

1> 使用递归实现 求 n 的 k 次方

#include<stdio.h>

//
int digui(int n,int m){
    if(m==0){
        return 1;//最后一位时返回1
    }else{
        return n*digui(n,m-1);//不是最后一位时返回n*递归
    }
}

int main(){
    int n=0,m=0;
    printf("请输入底数和阶数");
    scanf("%d%d",&n,&m);
    printf("为:%d\n",digui(n,m));
}

 

 2> 使用递归实现 strlen 的功能

#include<stdio.h>

//strlen
int strl(char str[],int n){
    if(str[n]=='\0'){//当前位置为空
        return 0;
    }else{
        return 1+strl(str,n+1);//不为空时返回 1+递归
    }
}

int main(){
    char str[20]={'\0'};
    printf("请输入字符串");
    scanf("%s",str);
    printf("%s长度为%d:\n",str,strl(str,0));
}

 

 3> 使用递归实现汉诺塔问题

4> 定义一个函数将一个字符串从大到小排序 

#include<stdio.h>
#include<string.h>

void maxx(char str[]){  
    for(int i=1;i<strlen(str);i++){
        for(int j=1;j<strlen(str)-i;j++){
            if(str[j]>str[j+1]){
                char temp=str[j];
                str[j]=str[j+1];
                str[j+1]=temp;
            }
        }
    }
}

int main(){
    char str[20]={'\0'};
    printf("请输入字符串");
    scanf("%s",str);
    maxx(str);
    printf("%s",str);
}

 5> 实现一个函数，用于检查一个字符串是否是回文字符串（正序和反序都相同）

#include <stdio.h>
#include <string.h>
void hui_wz(char arr[],int n)
{
    for(int i = 0;i<n/2;i++)
    {
        if(arr[i]!=arr[n-1-i])
        {
            printf("不是回文字\n");
            return 0;
        }
    }
    printf("是回文字\n");
}


int main()
{
    char arr[1000]="";
    int n = 0;
    printf("输入一个字符串:\n");
   
    gets(arr);   //gets  允许输入空格

    n = strlen(arr);

    hui_wz(arr,n);
}

 

6> 使用指针完成判断自己的主机存储多字节整数时，是大端存储还是小端存储 

int check_sys()
{
	int a = 1;
	return *(char*)&a;
}
int main()
{
	int ret = check_sys();
	if( ret == 1 )
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

 

7>有一段文本，写一段程序统计其中的单词数。

        例如:Do one thing at a time, and do well.

        注意:单词间的间隔不一定是一个空格。

#include<stdio.h>

//
int strl(char str[],int n){
    if(n==strlen(str)){
        return 1;
    }else //if((str[n+1]==' '||str[n+1]==',')&&((str[n]>'a'&&str[n]<'z')||(str[n]>'A'&&str[n]<'Z')))
    if ((str[n]>'a'&&str[n]<'z'||str[n]>'A'&&str[n]<'Z')&&(!(str[n+1]>'a'&&str[n+1]<'z'||str[n+1]>'A'&&str[n+1]<'Z')))
    {
        return 1+strl(str,n+1);
    }else{
        return strl(str,n+1);
    }
}

int main(){
    char str[100]={'\0'};
    printf("请输入字符串");
    gets(str);
    printf("%s单词数为:%d\n",str,strl(str,0));
}