21-11-23

数组

1、数组认知：
a、静态分配空间（int a[100]；分配了400个字节）空间利用率差（不够用或者浪费空间）

malloc realloc动态分配，不用就释放，优点效率高，空间使用效率高，缺点是开销比较大）
b、所占内存空间特点：连续的（物理连续）——malloc分配空间是否物理连续？（malloc实现原理：链表链接所有空闲的空间，组成最终分配的空间）
2、如何使用数组：
a、定义数组：数组该定义多大？char src[1024];——最佳解决方案：柔性数组
注意事项：
可变长数组c99：定义一个变量，数组可以用这个变量来代替定义数组的长度（不能在使用过程中已修改变量的值，来扩充数组的内存空间）

int n;
int a[n];

局部变量——保存在栈空间——未初始化的变量自动赋值随机值；
c89：定义数组时必须确定它的长度；通常用宏来表示数组的大小，提高代码的移植性

b、数组的使用：
数组名的作用：
（数组名：指针常量，保存的是数组首元素的地址，输入时不用取地址符(a + i)，输出*（a + i）

函数体里定义的数组会退化指针：

printf("&a[0] = %pn",&a[0]);//数组首元素的地址
printf("a = %pn",a);//数组首元素的地址
printf("&a = %pn",&a);//&a:数组的地址

*（&a）= a；对一维数组的地址取值等于数组首元素的地址
二维数组：
定义：不能省略行，可以省略列
二维数组名的作用：
二维数组名：指针常量（一维数组指针），保存首个一维数组的地址
三维数组：
int aaa[2][2][2] = {1,2,3,4},{5,6,7,8}
第一个下标：第几个个二维数组
第二个下标：第几个个二维数组第几行
第三个下标：第几个个二维数组第几行第几列用数组输入字符串：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char str[100];
    char ktr[2][100];
    char ptr[2][2][100];

    printf("please input str:n");
    scanf("%s",str);

    printf("str = %sn",str);

    printf("please input ktr:n");

    for(int i = 0;i < 2;i++)
    {
        //scanf("%s",*(ktr + i));
        scanf("%s",ktr[i]);
    }

    for(int i = 0;i < 2;i++)
    {
        printf("ktr[%d] = %sn",i,*(ktr + i));//ktr[i];
    }

    for(int i = 0;i < 2;i++)
    {
        for(int j = 0;j < 2;j++)
        {
            scanf("%s",*(*(ptr + i)+ j));//ptr[i][j]
        }
    }

        for(int i = 0;i <2;i++)
    {
        for(int j = 0;j < 2;j++)
        {
            printf("ptr = %sn",*(*(ptr + i)+ j));//ptr[i][j]
        }
    }
    return 0;
}

数组指针变量：
保存数组的地址
二维数组指针变量：int (*paa)[2][2] = &aa;指向一个二维数组（保存二维数组地址）
数组指针使用的场景：（函数传参：定义函数）

#include <stdio.h>

void print1(char *str)
{
    printf("str = %sn", str);
}

void print2(char (*ktr)[100])
{
    for (int i = 0; i < 2; i++)
    {
        printf("ktr[%d] = %sn", i, *(ktr + i)); //ktr[i];
    }
}

void print3(char (*ptr)[2][100])
{
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("ptr = %sn", *(*(ptr + i) + j)); //ptr[i][j]
        }
    }
}

int main(int argc, char *argv[])
{
    char str[100];       //"hello1"
    char ktr[2][100];    //"hello1" "hello2"
    char ptr[2][2][100]; //"hello3" "hello4" "hello5" "hello6";

    printf("Please input str:n");
    scanf("%s", str); //首元素地址

    print1(str);

    //

    printf("Please input ktr:n");

    for (int i = 0; i < 2; i++)
    {
        //scanf("%s", *(ktr + i));  //&*(ktr + i);
        scanf("%s", ktr[i]); //*(ktr + i);
    }
    print2(ktr);

    // for (int i = 0; i < 2; i++)
    // {
    //     printf("ktr[%d] = %sn", i, *(ktr + i)); //ktr[i];
    // }

    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            scanf("%s", *(*(ptr + i) + j)); //ptr[i][j]
        }
    }

    print3(ptr);

    // for (int i = 0; i < 2; i++)
    // {
    //     for (int j = 0; j < 2; j++)
    //     {
    //         printf("ptr = %sn", *(*(ptr + i) + j)); //ptr[i][j]
    //     }
    // }

    return 0;
}

指针数组：

int *pi[3];//int (*pa)[3];

使用注意事项：
局部指针数组里元素都是野指针
数组和指针的区别：

数组指针（也称行指针）
定义 int (*p)[n];
()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将二维数组赋给一指针，应这样赋值：
int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

所以数组指针也称指向一维数组的指针，亦称行指针。

指针数组
定义 int p[n];
[]优先级高，先与p结合成为一个数组，再由int说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]…p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 p=a; 这里p表示指针数组第一个元素的值，a的首地址的值。
如要将二维数组赋给一指针数组:
int *p[3];
int a[3][4];
for(i=0;i<3;i++)
p[i]=a[i];
这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。

这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
(p[i]+j)、((p+i)+j)、((p+i))[j]、p[i][j]

优先级：()>[]>*

1、利用递归方法实现一个函数,该函数能够实现n的阶乘,即 n! = n(n-1)…321;*

#include <stdio.h>
#include<stdlib.h>
int fun(int num)
{
    int s = 1;
    if (num == 1)
    {
        return 1;
    }
   else if (num > 1)
    {
        s = num * (fun(num - 1));
        return s;
    }
    else
    {
        printf("input errorn");
        exit(1) ;
    }
}
int main()
{
    int n, result;
    printf("please input mnubern");
    scanf("%d", &n);
    result = fun(n);
    printf("result=%dn", result);
    return 0;
}

2、利用递归函数调用方式,将所输入的n个字符以相反顺序打印出来

#include <stdio.h>

//利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
void fun(int i, char *p)
{
    if (i == 0)
    {
        printf("%c", p[i]);
        return;
    }
    else
    {
        printf("%c", p[i]); 
        fun(i - 1, p);
    }
}

int main()
{

    char str[6];               
    printf("input char:n"); 
    fgets(str, 6, stdin);     
    fun(4, str);
    printf("n");
}