指针数组和结构体嵌套

指针数组和结构体嵌套

一维数组名

除了两种情况外一维数组的名字都是数组的第一个元素的指针

1 sizeof统计数组长度，返回的是数组长度的大小

2 对数组名取地址，得到的是一个数组指针，步长为整个数组大小

 

数组名是一个指针常量，指向是不可变的

数组索引下标可以为负数

数组指针的定义方式

typedef int(自定义类型)[大小]

是一个数组指针类型

typedef int(*自定义类型)[大小]

定义的是一个数组指针的指针

int (*p)[5]

//数组指针相当于把一个数组当做一个变量，类似于int float之类的来处理
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//第一种通过typedef来定义一个别名来表示数组类型变量
void test01()
{
    int a[5] = { 1,2,3,4,5 };
    typedef int(ARRARY_TYPE)[5];//这里就相当于把ARRARY_TYPE作为一个类型
    //可以和int之类的正常来申明了处理
    ARRARY_TYPE* b = &a;//后面的操作就可以类似的看作int等类型变量来处理
    //这里相当于申请了一个ARRAY_TYPE类型的指针赋值为ARRARY_TYPE类型的a
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*b)[i]);//这里的*b表示对b进行获取内容后得到的其实是a数组的首地址的内容
        //然后可以把*b看成a再用正常数组来处理
    }
}

//通过typedef来定义别名指针来表示数组指针
void test02()
{
    int a[5] = { 1,2,3,4,5 };
    typedef int(*MY_TYPE)[5];//这里表示定义的是一个指针类型的类型
    //类似于 typedef int* aaaa那么aaa就是一个定义的int *的指针类型来处理
    MY_TYPE b = &a;//这里的b已经是一个指针了
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*b)[i]);//这里和前面是一样的
    }
}
//第三种方式直接用指针来处理
void test03()
{
    int a[5] = { 1,2,3,4,5 };
    int(*p)[5] = &a;//这里就相当于一一对应来处理，用同样的指针数组类型
    //来申明p指针对应a的地址来处理
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*p)[i]);
    }
}

void main(void)
{
    //test01();
    //test02();
    test03();
}//数组指针相当于把一个数组当做一个变量，类似于int float之类的来处理
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//第一种通过typedef来定义一个别名来表示数组类型变量
void test01()
{
    int a[5] = { 1,2,3,4,5 };
    typedef int(ARRARY_TYPE)[5];//这里就相当于把ARRARY_TYPE作为一个类型
    //可以和int之类的正常来申明了处理
    ARRARY_TYPE* b = &a;//后面的操作就可以类似的看作int等类型变量来处理
    //这里相当于申请了一个ARRAY_TYPE类型的指针赋值为ARRARY_TYPE类型的a
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*b)[i]);//这里的*b表示对b进行获取内容后得到的其实是a数组的首地址的内容
        //然后可以把*b看成a再用正常数组来处理
    }
}

//通过typedef来定义别名指针来表示数组指针
void test02()
{
    int a[5] = { 1,2,3,4,5 };
    typedef int(*MY_TYPE)[5];//这里表示定义的是一个指针类型的类型
    //类似于 typedef int* aaaa那么aaa就是一个定义的int *的指针类型来处理
    MY_TYPE b = &a;//这里的b已经是一个指针了
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*b)[i]);//这里和前面是一样的
    }
}
//第三种方式直接用指针来处理
void test03()
{
    int a[5] = { 1,2,3,4,5 };
    int(*p)[5] = &a;//这里就相当于一一对应来处理，用同样的指针数组类型
    //来申明p指针对应a的地址来处理
    for (int i = 0; i < 5; i++)
    {
        printf("%d\n", (*p)[i]);
    }
}

void main(void)
{
    //test01();
    //test02();
    test03();
}

 

二维数组名

二维数组名除了两个特殊情况外是指向第一个一维数组的 数组指针

特殊情况：

sizeof()统计的是二维数组的大小

对数组名取地址返回的是一个二维数组指针,步长为整个数组大小

二维数组做函数参数

(int (*p)[])

(int p[][N])

(int array[N][N])　　

//二维数组名做函数参数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//第一种情况来表示二维数组做函数参数
void test01(int (*p)[3],int row,int col)//
{
    for (int i = 0; i < row; i++)
    {
        for (size_t j = 0; j < col; j++)
        {
            printf("%d ", p[i][j]);
        }
        printf("\n");
    }
}
void test02(int p[3][3],int row,int col)
{
    for (int i = 0; i < row; i++)
    {
        for (size_t j = 0; j < col; j++)
        {
            printf("%d ", p[i][j]);
        }
        printf("\n");
    }
}
void test03(int p[][3],int row,int col)
{
    for (int i = 0; i < row; i++)
    {
        for (size_t j = 0; j < col; j++)
        {
            printf("%d ", p[i][j]);
        }
        printf("\n");
    }
}

void main()
{
    int a[3][3] = {
        {1,2,3},
        {4,5,6},
        {7,8,9}
    };
    test01(a, 3, 3);
    test02(a, 3, 3);
    test03(a, 3, 3);

}

结构体基本概念

typedef

加上typedef可以给结构体起别名

typedef struct test{

}TEST;

不在开始加typdef可以直接给结构体初始化一个变量

struct test{

}test1;

匿名结构体

不给结构体命名，可以直接创建一个结构体变量

struct{

}test1;

在栈和堆上创建结构体

 

//在堆区和栈区创建结构体
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//在栈区创建结构体
void test01() 
{
    struct Link {
        int a;
        char b;
    };
    struct Link a = { 1,'c' };
}
//在堆区创建结构体
void test02()
{
    struct Link {
        int a;
        char b;
    };
    struct Link* p = (struct Link*)malloc(sizeof(struct Link));
    p->a = 1;
    p->b = 'a';

    //用完了需要free掉
    free(p);
}

void main()
{
    test01();
    test02();
}

 

结构体深浅拷贝

系统提供一个结构体的直接赋值操作：但是是逐字节操作，连指针地址也会改变

所以当在堆区时如果用直接赋值会导致释放的时候产生问题

 

 

结构体嵌套一级指针

//结构体嵌套指针数组
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
struct Person
{
    char* name;
    int age;
};
struct Person** Space()
{
    struct Person** temp = (struct Person **)malloc(sizeof(struct Person*) * 3);
    for (int i = 0; i < 3; i++)
    {
        //创建结构体内存
        temp[i] = (struct Person *)malloc(sizeof(struct Person));
        //创建结构体的name字符串内存
        temp[i]->name = (char *)malloc(sizeof(char) * 64);
        //给name赋值
        sprintf(temp[i]->name, "name=%d", i + 1);
        temp[i]->age = i + 1;
    }
    return temp;
}
void Print_p(struct Person** p)
{
    for (int i = 0; i < 3; i++)
    {
        printf("this name=%s", p[i]->name);
        printf("this age=%d", p[i]->age);
    }
}
void Delete(struct Person** p)
{
    for (int i = 0; i < 3; i++)
    {
        free(p[i]->name);
        p[i]->name = NULL;
        free(p[i]);
        p[i] = NULL;
    }
}

void main()
{
    struct Person** p = NULL;
    p = Space();
    Print_p(p);
    Delete(p);
    free(p);
}