[笔记]指针与结构体

结构体（structure）与数组都是属于派生的数据类型（derived data type）数组的每一个元素都是相同的数据类型，而结构体则是由多个相同或不同数据类型的成员所组成的集合体。

指向结构体变量的指针

我们用一段代码说明指向结构体变量的指针（pointer to structure variable），以及如何访问结构体变量的成员

#include<stdio.h>
#include<stdlib.h>
int main()
{
    struct employee
    {
        char id[7];
        char name[20];
        int salary;
    };
    //声明一个结构体，拥有三个成员变量

    struct employee manager = { "D54321","Peter",35000 };
    //定义一个结构体变量，并为结构体变量依次赋初值

    struct employee* p = &manager;
    //定义一个结构体类型指针，指向结构体变量

    printf("&p=%x\n",&p);
    //十六进制输出指针p的地址

    printf("p=%x\n", p);
    //十六进制输出manager的首地址

    printf("&manager=%x\n", &manager);

    printf("&manager.id=%x\n", &manager.id);

    printf("manager.name=%x\n", manager.name);

    printf("&manager.salary=%x\n\n\n", &manager.salary);

    printf("<<使用.运算符取得结构体内的值>>\n");
    printf("manager.id=%s\n", manager.id);
    printf("manager.name=%s\n", manager.name);
    printf("manager.salary=%d\n\n\n", manager.salary);

    printf("<<使用->运算符取得结构体内的值>>\n");
    printf("p->id=%s\n", p->id);
    printf("p->name=%s\n", p->name);
    printf("p->salary=%d\n\n\n", p->salary);

    printf("<<使用（*）.运算符取到结构体内的值>>\n");
    printf("(*p).id=%s\n", (*p).id);
    printf("(*p).name=%s\n", (*p).name);
    printf("(*p).salary=%d\n\n\n", (*p).salary);

    system("pause");
    return 0;

}

输出结果：

从输出结果得知，ptr指向结构体，manager的地址（30fd30），也是此结构体第一个成员（id）的地址（&manager.id），我们用图来解释下：

同时，也告诉了我们如何打印出结构体中每一成员的数据。假如是一般的变量，则一运算符（.）处理，如：manager.id，假如是指针变量，则使用->处理，如p->id

也可以使用（）.来处理，如（p）.id，但比较麻烦，所以这一种比较少用

容易出错点：

在指针和结构体结合的时候，较易出错的地方，我们来剖析一下，避免做题的时候遇到错误，先看代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
    struct student
    {
        char name[20];
        int score;
    };

    struct student st1, * st2;
    st2 = (struct student*)malloc(sizeof(struct student));
    //为结构体指针分配一段结构体大小的内存空间。
    printf("请输入您的姓名：\n");
    scanf("%s", st1.name);

    printf("请输入您的C语言分数：\n");
    scanf("%d", &st1.score);

    printf("\n请输入您对象对的姓名：\n");
    scanf("%s", st2->name);

    printf("请输入您对象的C语言分数：\n");
    scanf("%d", &st2->score);

    printf("\n您的姓名：%s，您的C语言分数：%d\n", st1.name, st1.score);
    printf("\n您对象的姓名：%s，您对象的C语言分数：%d\n", st2->name, st2->score);

    free(st2);
    //释放st2所管理（指向）的内存

    printf("\n您对象的姓名：%s，您对象的C语言分数：%d\n", st2->name, st2->score);
    printf("\n您的姓名：%s，您的C语言分数：%d\n", st1.name, st1.score);
    system("pause");
    return 0;
}

运行结果：

由于程序便没有将结构体变量指定给结构体指针变量，所以必须用malloc函数，分配内存给结构体指针st2

当给st2分配好该结构体空间的时候，就可以指定数据给该指针。

malloc原型存放于头文件内，其语法如下：

• malloc（bytes数目）;

除了malloc函数可用来动态分配内存外，还有calloc函数，其语法如下：

• calloc（分配次数，每一次的bytes数目）;

使用malloc与calloc函数，分配st2所需要的内存，如下：

• st2=(struct student*)malloc(sizeof(struct student));
• st2=(struct student*)ccalloc(1,sizeof(struct student));

上述表示st2指针指向刚分配的结构体，并将此内存分割给name与score两个成员，如图：

需要注意的是，malloc与calloc函数均须类型转换，让它符合st2的数据类型（struct students*），这样才能正确的分配其内存

free为释放st2所指向的内存，清空它所指向的内存地址内的数据，但是这篇内存还是属于st2管理，可以实现删数据与改数据

在加了这段代码后，我们来看看运行结果：

我们可以看到，在释放内存后，内存内的数据就为空了，但我们依旧可以指针去添加st2结构体内的数据

我们利用一段代码来说明：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
    struct student
    {
        char firstname[20];
        char* lastname;
        int socre;
    };

    struct student st1, * st2;

    printf("请输入第一位同学的姓：");
    scanf("%s", st1.firstname);//不可以指定一个字符串给它

    st1.lastname = "小轩";     //不可以使用scanf输入函数给它
    printf("%s\n", st1.lastname);

    printf("请输入第一位同学的分数：\n");
    scanf("%d", &st1.socre);

    st2 = (struct student*)malloc(sizeof(struct student));

    printf("请输入第二位同学的姓名：");
    scanf("%s", st2->firstname);

    st2->lastname = "小C";
    printf("%s\n", st2->lastname);

    printf("请输入第二位同学的分数：\n");
    scanf("%d", &st2->socre);

    printf("\n%s%s的C语言分数为：%d\n", st1.firstname, st1.lastname, st1.socre);
    printf("%s%s的C语言分数为：%d\n", st2->firstname, st2->lastname, st2->socre);

    system("pause");
    return 0;

}

输出结果：

这段代码中要注意几点：

• 程序中student结构体的成员fitstname是一个数组，由于它是指针常量，在初定义时并未载入数据，则不可重定义，就不可以将一个字符串指定给它

如果要指定一个字符串给它的话，必须在定义结构体变量时并给其赋值

• 而lastname是一个指针变量，目前也没有指向任何内存，则不可以使用scanf函数来输入数据
• 如果要输入的话需要使用malloc函数为他分配一段内存

结构体指针与自增运算符

结构体指针与自增运算符（++）结合时的用法，要注意的是++的作用段是值还是地址，我们来看一段代码

#include<stdio.h>
#include<stdlib.h>
int main()
{
    struct student
    {
        char* name;
        int score;
    };

    struct student st = { "Axuan",97 };
    struct student* st2;
    st2 = &st;

    printf("st2->name=%s\n", st2->name);
    printf("*st2->name=%c\n", *st2->name);
    printf("*st2->name++=%c\n",*st2->name++);
    printf("*st2->name=%c\n",*st2->name);
    printf("st2->score=%d\n",st2->score);
    printf("st2->score++=%d\n",(st2->score)++);
    printf("st2->score=%d\n",st2->score);

}

运行结果：

结构体的声明与定义我们用图表示出来

st2->name

此语句相当于（*st2）.name，以%s输出结果为Axuan

*st2->name

由于->的运算符优先级高于，所以该表达式等价于（st2->name），得到的结果是字符A

*st2->name++

表示*（st2->name）++，由于*和++的运算优先级相同，而且其结合性是由右向左，所以此处的++作用于st2->name，因此，得到B字符之后，将name的指针移到r的地址，用图表示为：

st2->name

验证上述name的指针是否指向下一字符，就是r

st2->score

取出score结构体变量的值，为97

(st2->score)++

这里的++作用于st2->score，先取值后自增，为97

st2->score

验证上一语句，结果为98

我们再看一段代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
    struct student
    {
        char name[20];
        int score;
    };

    struct student st = { "Xiaoxuan",97 };
    struct student* st2;
    st2 = &st;

    printf("st2->name=%s\n", st2->name);
    printf("*st2->name=%c\n", *(st2->name));
    printf("++*(st2->name)=%c\n",++*(st2->name));

    printf("st2->name=%s\n", st2->name);

    printf("*st2->name=%c\n",*st2->name);
    printf("st2->score=%d\n",st2->score);
    printf("st2->score++=%d\n",(st2->score)++);
    printf("st2->score=%d\n",st2->score);

    system("pause");
    return 0;

}

相比于上一段代码，在student结构体内，将name从指针变量改为了指针常量

在

前置自增++*（st2->name），先将st2指向st结构体内name的首地址，也就是Xiaoxuan字符串首字符X的地址，再结合外面的*符号取到X，在自增，输出的为字符格式的Y

因为指针变量是不可以修改静态数据区的内容的，区别如下：

char *name = "Xiaoxuan"; "Xiaoxuan"保存在文字常量区，该数据不能修改,默认有只读属性. 由指针name指向. 不能通过指针name来修改此值.

char name[20] = "Xiaoxuan"; "Xiaoxuan"保存在栈空间数组里. 数组名为name, 数组名为数组的首地址. 可以通过name[i]='Y', 或*(name+i)='Y'的形式来修改数组内容.

而st2是指向st的首地址，也就是name的首地址，如果当name为指针变量的时候，st2可以运算但是必须遵从name的规则，如果name存储的值在栈内，即可通过指针走向修改指向地址内的值，但是若name存储的值在静态数据区内，则只有只读属性，具体请移步：指针与内存笔记

结构体与函数：

将一结构体传送给一函数，就像传送数组一般，只要将结构体的地址作为实际参数传送给形式参数即可，因为是传址调用，这该形式参数为实际参数拷贝过来的地址，需要配合*取值符号，换句话来说，形参是指向结构体变量的指针。

我们来看一段代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
void passOrdown(struct student*);//声明函数，返回类型为无类型，参数为student结构体类型指针
void output(struct student*);//声明函数，返回类型为无类型，参数为student结构体类型指针
struct student
{
    //定义全局变量结构体，拥有三个成员变量
    char name[20];
    int score;
    char* passdown;//为char*类型，未分配内存
};
int main()
{
    struct student stu;//定义一结构体变量
    printf("请输入您的姓名：\n");
    scanf("%s", stu.name);//name为数组类型，指针常量，stu空间内已有属于name的空间

    printf("请输入您的C语言分数；\n");
    scanf("%d", &stu.score);

    passOrdown(&stu);//将stu的首地址传入到passOrdown函数内

    output(&stu);//将stu的首地址传入到output函数内

    getchar(NULL);//清空缓冲区
    return 0;
}
void passOrdown(struct student* p)
{
    if (p->score >= 60)
    {
        p->passdown = "PASS";
    }
    else
    {
        p->passdown = "DOWN";
    }
}
void output(struct student* q)
{
    int i;
    printf("\n\n%10s %10s %20s\n", "Name","Score","Pass or Down");
    for (i = 0; i <= 42; i++)
    {
        printf("=");
    }
    printf("\n");
    printf("%10s %10d %20s\n", q->name, q->score, q->passdown);
}

输出结果：

程序将实际参数stu的地址拷贝传给形式参数p和q后，将以这些结构体变量指针取得结构体成员

若要表示一班同学的成绩，则可使用结构体数组（structure array）

我们用一段代码来讲解：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>
void passOrdown(struct student*);
void output(struct student*);
struct student
{
    char name[20];
    int score;
    char* passdown;
};

int main()
{
    struct student stu[3];//定义一个结构体类型的数组，数组内的每一元素都为结构体类型

    int i;

    for (i = 0; i < 3; i++)
    {
        printf("请输入第#%d位同学的姓名：\n",i+1);
        scanf("%s", stu[i].name);

        printf("请输入第#%d位同学的学分：\n",i+1);
        scanf("%d", &stu[i].score);
        printf("\n");
    }

    passOrdown(stu);
    output(stu);

    getchar(NULL);

    return 0;
}
void passOrdown(struct student* p)
{
    for (int i = 0; i < 3; i++)
    {
        if (p[i].score >= 60)
        {
            p[i].passdown="PASS";
        }
        else
        {
            p[i].passdown="DOWN";
        }
    }
}
void output(struct student* q)
{
    int i;
    printf("\n\n%10s %10s %20s\n", "NAME", "SCORE", "PASS or DOWN");
    for (i = 0; i <= 42; i++)
    {
        printf("=");
    }
    printf("\n");

    for (i = 0; i < 3; i++)
    {
        printf("%10s %10d %20s\n", q->name, q->score, q->passdown);
        q++;
    }
}

与上例代码不同的是，程序定义了一个结构体数组stu[3]，里面包含了3个结构体数据类型的变量

利用循环给name和score赋值。注意，passdown为指针变量，且它为被分配内存，只可指定一片内存给它管理，就不能通过scanf 函数输入值

同样也是将实际参数数组名（stu）传入给了实参p，q，这时形参p，q均指向了stu[0]的地址。我们用图来表示一下：

这时p，q自增是跨越了整个结构体字节长度，指向下一个结构体数组元素

输出结果：

自引用结构体

自引用结构体（self*referenced structure）表示在结构体中有结构体成员的数据类型也是此结构体的数据类型，这是重点！

我们先看看容易出错的地方：

这种声明是错误的，因为A也是一个s1类型的结构体变量，这样会形成一个无限嵌套，系统不能计算结构体的长度。

而这种是正确的，声明了一个结构体指针类型的成员，它可以指向同类型的结构体。

而当结构体成员为结构体指针的时候，可让该指针指向同类型的结构体，我们用一段代码来解释：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main()
{
    struct node//声明一个局部结构体
    {
        char *name;
        int score;
        struct node* next;//结构体内声明一个结构体指针
    };

    struct node* p, * q;//定义两个结构体变量，为指针类型

    p = ( struct node* )malloc(sizeof(struct node));//为指针p分配内存，强制转换为结构体指针类型

    p->name = "Axuan";
    p->score = 100;
    p->next = NULL;//将p指向结构体中的next指针，让next指针指向空

    q = (struct node*)malloc(sizeof(struct node));

    q->name = "Bxuan";
    q->score = 70;
    q->next = p;//将q指向结构体中的next指针，将next赋值位p的地址

    printf("%s %10d\n", q->name, q->score);
    printf("%s %10d", q->next->name, q->next->score);

    getchar();
    return 0;

}

这段代码以malloc函数，动态分配内存空间给p与q结构体变量指针，分别指定结构体项目中的值后，将p->next指向NULL，q->指向p，如图所示：

因为程序将q.next指向了p的首地址，所以q->next->name其实就是p->name

我试着解释一下：

一、q是一结构体类型指针，先用malloc动态分配一struct student大小的内存，再将此片内存交给指针q管理，q的值就是这篇内存的首地址

二、与指向结构体变量其实是意义大致相同，可以把结构体变量的首地址看做动态分配的首地址。

三、在struct student类型的结构体中，拥有一个struct student *next，student结构体类型的指针变量，在q管理的这片内存中，next被指向p

四、p也用malloc分配了一片相对应的内存，这时p的值就为这篇内存的首地址，而通过q->next->就可以调用p结构体中的元素，因为next的值等价于p的值

我们可以将上例有关链表节点的输出，以一个循环完成，看代码：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main()
{
    struct  student
    {
        char* name;
        int score;
        struct student* next;//内嵌一个struct student类型的指针
    };//定义一个局部结构体，拥有三个参数

    struct student* q, * p, * r, * current;//定义四个结构体类型的指针变量

    p = (struct student*)malloc(sizeof(struct student));
    p->name = "Axuan";
    p->score = 99;

    q = (struct student*)malloc(sizeof(struct student));
    q->name = "Bxuan";
    q->score = 95;

    r = (struct student*)malloc(sizeof(struct student));
    r->name = "Cxuan";
    r->score = 92;

    p->next = q;
    q->next = r;
    r->next = NULL;

    printf("我的三个同学的班级信息：\n");
    current = p;
    while (current != NULL)
    {
        printf("名字：%10s  学分：%20d\n", current->name, current->score);
        current = current->next;
    }
    getchar();
    return 0;

}

我们来简单解释一下相连关系，p所管理的内存中，成员next存储的是q所管理内存的首地址，以此类推

• current->p
• p.next->q
• q.next->r
• r.next-NULL

那么这时头指针就是current，就像一个火车一样，火车头为current，第一节车厢为p，车厢内存的就是p所管理内存的成员，而p的地址就是车厢的编号。

运行结果：

此程序while循环，将链表数据一一打印出，注意，循环的判断条件是current！=NULL

也就是当current所指向的内存中，成员next指向为空的时候停止循环，若不为空，这将成员next所存储的值赋给current

若表达式为真，则说明链表中还有数据，所以将current移到下一个节点

有了基本概念，我们来看下一段代码：

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main()
{
    struct student
    {
        char* name;
        int score;
        struct student* next;
    };//定义一个局部结构体，拥有三个成员
    //成员三为一个结构体类型的指针变量

    struct student st[] = {
    {"Axuan",97,st + 1},
    {"Bxuan", 95, st + 2},
    {"Cxuan",92,st}
    };//定义一个结构体类型的数组，并赋值

    struct student* p = &st;//定义一个结构体指针变量p，它指向结构体数组的首地址

    printf("st[0].name=%16s\n", st[0].name);
    printf("(*st).name=%16s\n", (*st).name);

    printf("p.name=%20s\n", p->name);

    printf("st[1].next->name=%10s\n", st[1].next->name);
    printf("st[1].next->score=%9d\n", st[1].next->score);

    printf("++(p->name)=%15s\n", ++(p->name));
    printf("++p->name=%17s\n", ++p->name);

    printf("p->next->name=%13s\n", p->next->name);
    printf("p->next->score=%12d\n", p->next->score);

    system("pause");
    return 0;

}

运行结果：

我们先用图解释一下结构体中的迭代关系

我们来剖析下这段代码中的表达式：

st[0]的name，先取到st数组中的首地址，进入首地址后取到成员name的首地址，以%s输出，结果为Axuan

(*st).name，进入st的地址，取到成员name的值，等价于st[0]，结果为Axuan

p.name， 由于p指向的是st的，p内存储的也是st的首地址，那么通过p也能访问st，输出的值也为Axuan

st[1].next->name，取到st+1地址内的成员next，next指向的是r，这段语句等价于q.name，输出的值为Cxuan

st[1].next->score，等同于上句，取到的也是指针r所管理内存中成员score的值，为92

++（p->name）先结合括号内，取到p所指向st中成员name的值，为字符串Axuan的首地址，自增得到x的地址，%s输出为xuan

++p->name，由于->优先级最大，等同于上一语句，也是p指向st中name的值，这时name的值已自增为x的地址，再自增得到u的地址，则输出为uan

p->next->name，p指向st所管理内存中成员next，next存储的是st[1]的首地址，访问到st[1]后取到成员name的值，为Bxuan首字符B的地址，以字符串格式输出，为Bxuan

p->next->name，等同于上一句，访问到st[1]后，取到成员score的值为95

我们再来个扩展性：看代码

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
int main()
{
    struct student
    {
        char* name;
        int score;
        struct student* next;
    };//定义一个局部结构体，拥有三个成员
    //成员三为一个结构体类型的指针变量

    struct student st[] = {
    {"Axuan",97,st + 1},
    {"Bxuan", 95, st + 2},
    {"Cxuan",92,st}
    };//定义一个结构体类型的数组，并赋值

    struct student* p[] = { st,st + 1,st + 2 };

    printf("(*p)->name=%s\n", (*p)->name);
    printf("(**p).name=%s\n\n", (**p).name);

    printf("(*p)->score=%d\n", (*p)->score);
    printf("p[0]->score=%d\n\n", p[0]->score);

    printf("(*p)->next->name=%s\n", (*p)->next->name);
    printf("(*p)->next->next->name=%s\n\n", (*p)->next->next->name);

    printf("(++(*p)->next)->name=%s\n", (++(*p)->next)->name);
    printf("(*p)->next->score=%d\n", (*p)->next->score);

    system("pause");
    return 0;
}

多了啥？多了个指针数组，里面存的是每一个st结构体的首地址

我们先来看看输出结果：

再看看它的剖析图

再来看看它的表达式：

（*p）->name

访问p指向的结构体st，取到成员name，字符串Auan的首地址，以%s输出为Axuan

（**p）.name

同上，这是另外一种表达方式，因为p为以指针数组，需要两个*才能访问到指向的结构体内

（*p）->score

取到p中首元素为st的首地址，再取到score的值，为90

p[0]->score

同上，结果也为90

（*p）->next->name

先取到p访问的st结构体中取到next的值为st[1]的首地址，再取到name的值为Bxuan的首地址，以%s输出为Bxuan

（*p）->next->next->name

先取到p访问的st结构体中取到next的值为st[1]的首地址，再取到st[1]中next的值为st[2]的首地址，再取到st[2]中name的值，为Cxuan

（++（*p）->next）->name

此处++作用于（*p）->next，则next的值为st+1，再自增则为st+2的地址，取到st+2中的name值为Cxuan

(*p)->next->score，这时p还是指向st，但st中的next经过自增后指向st[2]，取到st[2]中的score值为92

总结

到这里，结构体与指针就学习完毕了，结构体与指针的关系有：

• 结构体类型的指针变量，它可以指向同类型的结构体变量
• 内嵌结构体指针，可以实现结构体嵌套与自引用
• 结构体成员有指针类型，可以指向同类型的变量
• 指向一个结构体变量的指针,也可以指向结构体变量的任何一个成员
• 当结构体变量类型为指针时，需要使用->做指向成员运算
• 若结构体指针未指向任何一个变量，则需要为其动态分配同类型的内存
• 当结构体做函数参数时候，需要使用指针进行传址调用

具体的疑问将会在问题演练中浮出，摸透结构体与指针的关系对于数据结构链表类型是一个铺垫。

本文链接：

https://nullcode.fun/111.html