C语言初级阶段7——指针4

C语言初级阶段7——指针4

结构体指针

1.概念：所谓的结构体指针就是指向结构体变量的指针，一个结构体变量的起始地址就是这个结构体变量的指针。如果把一个结构体变量的其实地址存放在一个指针变量中，那么这个指针变量就指向此结构体变量。

2.结构体指针的定义

如有以下结构体：

struct student{int id;char *name;char sex[4];}s1,s2,s3;

则可以定义指向struct student类型结构体的指针：

struct student *sp;

sp = &s1;//用结构体指针sp指向struct student类型的结构体变量s1.

#include<stdio.h>
typedef struct nodeDate
{
​
    int a;
    char name[20];
}node;
void main()
{
    node n;//n是结构体变量
    node* p = &n;//p是一个结构体指针
    p->a = 20;//结构体指针通过箭头（->）进行访问。
    printf("%d\n", n.a);
}

#include<stdio.h>
typedef struct nodeDate
{
​
    int a;
    char name[20];
}node;
void main()
{
    node n[5] = {
        {1,"aaa"},
        {2,"bbb"},
        {3,"ccc"},
        {4,"ddd"},
        {5,"eee"}
    };
    node* p[5] = {&n[3],&n[2]};
    printf("%d\t%s\n", p[0]->a,p[1]->name);
}

#include<stdio.h>
typedef struct nodeDate
{
​
    int a;
    char name[20];
}node;
void main()
{
    node n[5] = {
        {1,"aaa"},
        {2,"bbb"},
        {3,"ccc"},
        {4,"ddd"},
        {5,"eee"}
    };
    node* p = n;
    printf("%d\n",p->a);
    printf("%d\n", (p+2)->a);
    printf("%s\n", (p+2)->name);
    printf("%d\t%s\n", (*(p+2)).a,(*(p+4)).name);
}

 

 

 

内存分配

1.动态内存分配：从堆区申请内存，自己使用。

2.通过函数进行申请：malloc、calloc、realloc。

3.从堆区申请的内存是通过指针进行管理的。

4.使用free函数进行释放。

5.优势：栈区的内存比较小，堆区的内存非常大。

6.在释放内存的时候，在free函数中填的指针，必须要指向内存的首地址。

#include<stdio.h>
#include<stdlib.h>
void main()
{
    //赋值的条件：类型相同。
    int* p = (int*)malloc(100);//100个字节  头文件是stdlib.h
    *p = 10;
    *(p + 1) = 20;
    printf("%d\t%d\n", *p, *(p + 1));
    free(p);//头文件是stdlib.h
    int* p1 = (int*)malloc(sizeof(int) * 25);
    
    for (int i = 0; i < 25; i++)
    {
        *(p1 + i) = i + 1;
    }
    for (int i = 0; i < 25; i++)
    {
        printf("%d\t", p1[i]);
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
    //赋值的条件：类型相同。
    int* p = (int*)malloc(100);//100个字节  头文件是stdlib.h
    *p = 10;
    *(p + 1) = 20;
    printf("%d\t%d\n", *p, *(p + 1));
    free(p);//头文件是stdlib.h
    int* p1 = (int*)malloc(sizeof(int) * 25);
    
    for (int i = 0; i < 25; i++)
    {
        *(p1 + i) = i + 1;
    }
    memset(p1, 0, sizeof(int) * 25);//逐字节赋值   头文件是string.h
    for (int i = 0; i < 25; i++)
    {
        printf("%d\t", p1[i]);
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
    
    int* p = (int*)malloc(sizeof(int) * 25);
    for (int i = 0; i < 25; i++)
    {
        *(p + i) = i + 1;
    }
    p = (int*)realloc(p,sizeof(int)*50);//重新分配内存，不会初始化。
    for (int i = 0; i < 50; i++)
    {
        printf("%d\t", p[i]);
    }
    p = (int*)realloc(p, sizeof(int) * 10);
    for (int i = 0; i < 25; i++)
    {
        printf("%d\t", p[i]);
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
    
    int* p = (int*)malloc(sizeof(int) * 25);
    for (int i = 0; i < 25; i++)
    {
        *(p + i) = i + 1;
    }
    p = (int*)realloc(p, sizeof(int) * 10);
    for (int i = 0; i < 25; i++)
    {
        printf("%d\t", p[i]);
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
    int* p = (int*)malloc(sizeof(int) * 25);
    for (int i = 0; i < 25; i++)
    {
        *(p + i) = i + 1;
    }
    p = (int*)realloc(p, sizeof(int) * 10);
    for (int i = 0; i < 25; i++)
    {
        printf("%d\t", p[i]);
    }
    free(p);
    p = NULL;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
	int* p = (int*)calloc(25, sizeof(int) * 25);//会默认初始化为0.
	for (int i = 0; i < 25; i++)
	{
		printf("%d\t", p[i]);
	}
}

#include<stdio.h>
#include<stdlib.h>
int* fun()
{
	//在函数里面申请的堆区内存，不会随着函数的结束而释放，需要手动释放。
	int* p = (int*)malloc(sizeof(int));
	return p;
}
void main()
{
	int* p = fun();
	*p = 123;
	printf("%d\n", *p);
	free(p);
}

#include<stdio.h>
#include<stdlib.h>
int* fun()
{
	//在函数里面申请的堆区内存，不会随着函数的结束而释放，需要手动释放。
	int* p = (int*)malloc(sizeof(int));
	return p;
}
void main()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	for (int i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	int* p1 = (int*)malloc(sizeof(int) * 10 * 2);
	for (int i = 0; i < 10; i++)
	{
		p1[i] = p[i];
	}
	free(p);
	p = p1;
	for(int i = 0; i < 20; i++)
	{
		printf("%d\n",p[i]);
	}
}

#include<stdio.h>
#include<stdlib.h>
int* fun()
{
	//在函数里面申请的堆区内存，不会随着函数的结束而释放，需要手动释放。
	int* p = (int*)malloc(sizeof(int));
	return p;
}
void main()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	for (int i = 0; i < 10; i++)
	{
		p[i] = i + 1;
	}
	int* p1 = (int*)malloc(sizeof(int) * 10 * 2);
	for (int i = 0; i < 10; i++)
	{
		p1[i] = p[i];
	}
	free(p);
	p = p1;
	for (int i = 0; i < 10; i++)
	{
		p[i+10]=11 + i;
	}
	for (int i = 0; i < 20; i++)
	{
		printf("%d\n", p[i]);
	}
	free(p);
}