C语言入门教程-指向结构体的指针
[c语言结构体数组赋值]C语言给结构体指针赋值
![[c语言结构体数组赋值]C语言给结构体指针赋值](https://img.taocdn.com/s3/m/9412480ab6360b4c2e3f5727a5e9856a561226ac.png)
[c语言结构体数组赋值]C语言给结构体指针赋值篇一: C语言给结构体指针赋值指向结构体的指针在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。
创建结构体指针是极常见的。
下面是一个例子：r是一个指向结构体的指针。
请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。
而malloc语句会从堆上分配45字节的内存。
*r是一个结构体，像任何其他Rec类型的结构体一样。
下面的代码显示了这个指针变量的典型用法：您可以像对待一个普通结构体变量那样对待*r，但在遇到C的操作符优先级问题时要小心。
如果去掉*r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。
使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：r->这种写法和.是完全等效的，但是省去了两个字符。
指向数组的指针还可以创建指向数组的指针，如下所示：或：可见要创建指向整数数组的指针，只需创建一个普通的整数指针即可。
调用malloc分配合适的数组空间，然后将指针指向数组的第一个元素。
访问数组元素既可以用普通的数组下标也可以用指针运算。
C将两种方法视为是等效的。
指向数组的指针这一技巧尤其适用于字符串。
您可以为某个特定大小的字符串分配刚好合适的内存。
指针数组有时声明一个指针数组可以节省大量内存，或者使得某些内存消耗较大的问题得以解决。
下面例子中的代码，声明了一个由10个结构体指针组成的数组，而不是一个结构体数组。
否则这个结构体数组将占用243 * 10=2,430字节的内存。
使用指针数组可以最大限度减小内存消耗，直到用malloc语句为记录实际分配内存空间。
作为此过程的演示，下面的代码只为一个记录分配空间，保存某个值后又将空间释放：包含指针的结构体结构体可以包含指针，如下所示：typedef struct{char name[21];char city[21];char phone[21];char *comment;} Addr;Addr s;char comm[100];gets;gets;gets;gets;ment=malloc+1])); strcpy;typedef struct { char s1[81];char s2[81];char s3[81];} Rec;Rec *a[10];a[0]=malloc);strcpy;free;int *p;int i;p=malloc);for*=0;free;int *p;int i;p=malloc);forp[i]=0;free;strcpy;, “Leigh”); strcpy.city, “Raleigh”);strcpy.state, “NC”);printf.city);free;typedef struct{char name[21];char city[21];char state[3];} Rec;typedef Rec *RecPointer;RecPointer r;r=malloc);结构体指针变量的概念当一个指针变量用来指向一个结构体变量时，称之为结构体指针变量。
c语言结构体指针的用法
c语言结构体指针的用法
结构体指针可以指向结构体变量，通过指针操作结构体的成员变量，可以实现对结构体的灵活操作。
下面是使用结构体指针的一些常见方法：
- 定义结构体指针：使用`struct`关键字定义一个结构体，然后使用`*`表示定义一个指向该结构体的指针变量。
例如：
```c
struct Person {
char name[20];
int age;
float height;
};
struct Person *p_ptr;
```
- 访问结构体成员：使用`->`操作符来访问指针所指向的结构体成员。
例如：
```c
p_ptr->name = "John";
p_ptr->age = 25;
p_ptr->height = 1.75;
```
- 动态分配结构体内存：使用`malloc()`函数动态分配内存，然后将指针指向这块内存。
使用完后，使用`free()`函数释放内存。
例如：
```c
p_ptr = (struct Person*)malloc(sizeof(struct Person));
```
总的来说，结构体指针可以提供更灵活、高效的操作方式，通过指针对结构体对象进行动态操作和内存管理，可以编写出更复杂、更优雅的C语言程序。
在使用指针时，需要注意指针的指向是否有效，避免出现野指针等问题。
C语言的指针和结构体
– 如果分配成功，原存储块的内容就可能改变了，因此不
允许再通过ptr去使用它精选。课件ppt
17
结构体
精选课件ppt
18
结构体的定义
• 结构体类型定义的一般形式为：
struct 结构名 {
//关键字struct和它后
类型名
结构成员名1；
面的结构名一起组成 一个新的数据类型名
类型名 结构成员名2；
所需要的存储空间。 （3）使指针指向获得的内存空间，以便用指
针在该空间内实施运算或操作。 （4）当使用完毕内存后，释放这一空间。
精选课件ppt
13
动态存储分配函数malloc()
void *malloc(unsigned size)
在内存的动态存储区中分配一连续空间，其长度为 size
– 若申请成功，则返回一个指向所分配内存空间的起 始地址的指针
& ： 取地址运算符，给出变量的地址。
int *p, a = 3;
p = &a; 把 a 的地址赋给 p，即 p 指向 a
p
a
&a
3
*p
//指针变量的类型和它所指向变量的类型相同
* ：间接访问运算符，访问指针所指向的变量。
*p：指针变量 p 所指精向选课的件p变pt 量。
4
p
a
说明 int a = 3, *p;
};
name ↓
Zhang
age ↓
26
telephone ↓
精选课件ppt
23
结构体变量成员的使用
结构体变量名 .成员名
friend1.age = 26; strcpy(, "Zhang San"); strcpy(friend1.addr.zip, " 210044 ");
typedef 结构体指针
typedef 结构体指针
typedef结构体指针是C语言中的一种数据类型，它可以用来定义结构体类型的指针变量。
在C语言中，结构体是由多个不同数据类型的变量组成的复合数据类型。
而结构体指针是指向结构体变量的指针。
通过使用typedef，我们可以为结构体指针定义一个简洁的别名，方便在程序中进行使用。
例如，下面的代码定义了一个名为student 的结构体，并为其定义了一个指向该结构体的指针类型student_ptr： typedef struct
{
char name[20];
int age;
float score;
} student;
typedef student *student_ptr;
通过以上代码，我们就可以使用student_ptr来代替student *，从而方便地定义和使用结构体指针变量。
例如，可以按照以下方式定义一个指向student类型变量的指针变量：
student_ptr p;
接下来，我们就可以通过该指针变量对结构体变量中的成员进行访问和操作。
例如，可以使用以下代码为结构体变量中的成员赋值： p->age = 20;
p->score = 85.5;
总之，typedef 结构体指针可以让我们更加方便地定义和使用结构体类型的指针变量，是C语言中非常实用的特性之一。
结构体指针的定义,使用,赋值方法.
结构体指针的定义,使用,赋值方法.1. 定义结构体指针：使用"struct"关键字和指针符号(*)来定义一个结构体指针变量。
2. 声明结构体指针变量：在定义时，需要指定结构体的类型。
3. 初始化结构体指针：通过使用malloc函数来为结构体指针分配内存空间，然后使用指针操作符（->）来访问结构体成员。
4. 通过结构体指针访问成员变量：使用指针操作符（->）来访问结构体的成员变量。
5. 结构体指针作为参数传递：可以将结构体指针作为参数传递到函数中，以便在函数内部对结构体进行修改。
6. 结构体指针作为返回值：函数可以返回结构体指针，以便在调用函数后可以通过指针访问结构体的成员。
7. 结构体指针赋值给另一个指针：可以将一个结构体指针赋值给另一个结构体指针，使它们指向同一个结构体。
8. 结构体指针赋值给另一个结构体：可以将一个结构体指针赋值给另一个结构体变量，使它们的值相等。
9. 使用结构体指针数组：可以定义一个结构体指针的数组，并通过遍历数组来访问每个结构体指针。
10. 使用结构体指针的嵌套：结构体指针可以指向另一个结构体指针，形成结构体指针的嵌套关系。
11. 结构体指针作为动态数组：可以使用结构体指针来创建动态数组，通过指针索引来访问数组元素。
12. 使用结构体指针的动态分配：可以使用结构体指针和malloc函数来动态分配一个结构体。
13. 结构体指针的指针：可以定义一个结构体指针的指针，用两个星号（**）表示，用于指向一个结构体指针的地址。
14. 结构体指针的传址：可以通过将结构体指针的地址传递给另一个指针来进行传址操作。
15. 使用结构体指针的链表：可以使用结构体指针来构建链表，通过指针链接不同的结构体节点。
16. 结构体指针的动态释放：在不再需要使用结构体指针时，应该使用free函数来释放掉分配的内存空间。
17. 结构体指针的静态数组：可以定义一个静态数组，并将每个元素定义为结构体指针来存储不同的结构体。
c语言 sizeof 结构体指针
c语言 sizeof 结构体指针
在C语言中，sizeof操作符用于获取数据类型或变量的大小，
而结构体指针是指向结构体变量的指针。
当我们使用sizeof操作符
来获取结构体指针的大小时，实际上是获取指针变量的大小，而不
是指向的结构体的大小。
在C语言中，结构体指针的大小与指针变量的大小相同，通常
是与系统的位数相关的固定大小。
例如，在32位系统中，指针的大
小通常是4个字节，在64位系统中，指针的大小通常是8个字节。
这意味着无论结构体的大小是多少，结构体指针的大小都是固定的。
结构体指针的大小并不取决于结构体本身的大小，而是取决于
系统架构和编译器的实现。
因此，无论结构体的大小如何，结构体
指针的大小都是固定的。
需要注意的是，结构体指针的大小与结构体本身的大小是不同
的概念。
结构体的大小取决于其成员变量的大小和对齐方式，而结
构体指针的大小只取决于系统架构和编译器的实现。
总之，当你使用sizeof操作符来获取结构体指针的大小时，你
实际上获取的是指针变量的大小，而不是指向的结构体的大小。
这一点在内存分配和指针运算时需要特别注意。
结构体数组指针定义与使用
结构体数组指针定义与使用结构体数组指针定义与使用结构体是C语言中用于组织数据的一种数据类型，它由多个不同数据类型的数据成员组成。
在很多场景下，我们需要使用多个结构体来保存不同的数据，而结构体数组指针便是用于管理这种数据的一种重要工具。
本文将详细介绍结构体数组指针的定义、初始化和使用方式。
一、结构体数组指针的定义结构体数组指针是指针类型的结构体数组，在C语言中，使用struct关键字来定义结构体类型，常常需要使用typedef来实现类型定义简化。
结构体数组指针的定义方式如下：typedef struct struct_name { member_type member_name; ... }struct_type;struct_type *ptr_array_name[N];其中，struct_name为结构体的名称，member_type为结构体成员变量的数据类型，member_name为结构体成员变量的名称，struct_type为结构体类型，*ptr_array_name 为结构体数组指针类型，N为数组的长度。
例如，假设我们要创建一个结构体数组指针来保存多个学生的信息，可以使用以下代码：typedef struct student { char name[20]; int age; float score; }Stu;Stu *stu_list[5];这个定义方式意味着我们创建了一个包含5个元素的Stu类型结构体指针数组。
二、结构体数组指针的初始化结构体数组指针的初始化方式有两种：静态初始化和动态初始化。
静态初始化：在编译时即提前给数组元素赋初值。
Stu stu_1={"小明",18,98.5}; Stu stu_2={"小红",17,89.5}; Stu stu_3={"小东",19,76.5}; Stustu_4={"小兰",16,70.2}; Stu stu_5={"小华",20,85.5};Stu*stu_list[5]={&stu_1,&stu_2,&stu_3,&stu_4,&stu_5};动态初始化：在程序运行时，动态地分配内存给数组元素，并赋于初值。
指向结构体数组的指针
指向结构体数组的指针首先，我们来了解一下结构体和结构体数组的概念。
结构体是一种自定义的数据类型，它可以包含多个不同类型的变量，这些变量可以是基本数据类型也可以是其他结构体类型。
结构体数组是一种特殊的数组，它的元素是结构体类型，并且每个元素都可以有不同的值。
在C语言中，我们可以通过定义指向结构体数组的指针来访问和操作结构体数组的元素。
指针是一种特殊的变量，可以存储内存地址。
通过将指针指向结构体数组的首地址，我们可以使用指针来操作结构体数组的元素。
下面是指向结构体数组的指针的定义和初始化的方法：```c#include <stdio.h>//定义结构体类型typedef structint id;char name[100];float score;} Student;int mai//定义结构体数组Student students[3] ={1, "Alice", 90.5},{2, "Bob", 88.0},{3, "Cathy", 92.5}};Student *p;//将指针指向结构体数组的首地址p = students;//使用指针访问结构体数组的元素printf("第一个学生的姓名：%s\n", p->name);printf("第二个学生的姓名：%s\n", (p + 1)->name);printf("第三个学生的姓名：%s\n", (p + 2)->name);return 0;```在上面的示例中，我们首先定义了一个结构体类型`Student`，它包含一个int类型的学生ID、一个char类型的学生姓名、以及一个float 类型的学生成绩。
然后，我们定义了一个包含3个元素的结构体数组`students`，并初始化了它的每个元素的值。
c语言初始化结构体指针
c语言初始化结构体指针在C语言中，可以使用结构体来表示一组相关的数据。
结构体可以包含不同类型的数据成员，并且还可以声明指向结构体的指针。
结构体指针可以通过动态分配内存，从而在程序运行时申请所需的内存空间。
初始化结构体指针的方法有多种，可以通过直接赋值、使用构造函数、使用memset函数等。
下面将详细介绍这些方法。
1.直接赋值直接赋值是最常见的一种方法，可以通过在初始化结构体指针时，为其成员变量赋予具体的值。
例如：```c#include <stdio.h>//定义结构体struct Student {char name[20];int age;float score;};int main() {//初始化结构体指针struct Student *p = NULL;//动态分配内存p = (struct Student *)malloc(sizeof(struct Student)); //直接赋值strcpy(p->name, "Tom");p->age = 18;p->score = 90.5;//输出结果printf("Name: %s\n", p->name);printf("Age: %d\n", p->age);printf("Score: %.2f\n", p->score);//释放内存free(p);return 0;}```在上述代码中，首先定义了一个结构体Student，包含name、age 和score三个成员变量。
然后在main函数中，申请了一个Student类型的指针p，并动态分配了内存空间。
之后，通过直接赋值的方式，为p指向的结构体成员变量赋予具体的值。
最后，使用printf函数输出p指向的结构体成员变量的值，并通过free函数释放内存。
2.使用构造函数在C语言中，可以通过构造函数来初始化结构体指针。
c语言结构体指针作为函数参数
c语言结构体指针作为函数参数一、概述在C语言中，结构体是一种非常有用的数据类型。
结构体可以包含多个不同类型的变量，这些变量可以按照自己的需求进行组合。
而结构体指针则是指向结构体的指针变量，它可以更加方便地操作结构体中的成员变量。
在函数中使用结构体指针作为参数，可以使得函数能够直接修改结构体中的成员变量，从而实现更加灵活和高效的操作。
二、定义结构体在使用结构体指针作为函数参数之前，首先需要定义一个包含多个成员变量的结构体。
例如：```struct Student {char name[20];int age;float score;};```这个结构体包含了三个成员变量：姓名、年龄和分数。
三、传递结构体指针作为参数在函数中使用结构体指针作为参数时，需要注意以下几点：1. 函数声明时需要将参数声明为一个指向该结构体类型的指针。
例如：```void printStudent(struct Student *s);```这个函数接受一个指向Student类型的指针作为参数。
2. 在调用函数时需要传递一个该类型的指针作为实参。
例如：```struct Student stu = {"Tom", 18, 90.5};printStudent(&stu);```这里将stu的地址传递给了printStudent函数。
3. 在函数内部可以通过指针访问结构体中的成员变量。
例如：```void printStudent(struct Student *s) {printf("Name: %s\n", s->name);printf("Age: %d\n", s->age);printf("Score: %.2f\n", s->score);}```这个函数使用指针访问了结构体中的三个成员变量，并将它们打印出来。
C语言学习入门笔记之结构体与共用体
结构体与共用体笔记定义结构体C语言允许用户自己建立由不同类型数据组成的组合型的数据结构，它称为结构体(structre)。
在其他一些高级语言中称为“记录”.定义后的结构体类型和系统提供的标准类型(如int, char, float, double 等)具有相似的作用，都可以用来定义变量，只不过int等类型是系统已声明的，而结构体类型是由用户根据需要在程序中指定的。
定义一个结构体类型的一般形式为：struct 结构体名{ 成员表列}；注意：1.结构体类型的名字是由一个关键字struct和结构体名组合而成的(例如struct Student) ，结构体名是由用户指定的，又称“结构体标记”，以区别于其他结构体类型。
上面的结构体声明中Student就是结构体名(结构体标记)。
2.花括号内是该结构体所包括的子项，称为结构体的成员。
“成员表列"(member list)也称为“域表”(field list),成员表列由若干个成员组成,每一个成员是结构体中的一个域。
对每个成员也必须作类型说明，其形式为：类型说明符成员名;成员名的命名应符合标识符的书写规定。
例如：struct stu{int num;char name[20];char sex;float score;};3.一个结构体的成员可以属于另一个结构体类型（嵌套）。
例如：struct Date //声明一个结构体类型struct Date{ int month;//月int day;//日int year；//年}struct Student//声明一个结构体类型struct Student{ int num；char name[20]；char sex；int age;struct Date birthday;//成员birthday属于struct Date 类型char addr[30]；};结构体类型变量1.定义结构体类型变量说明结构变量有以下三种方法。
c语言 结构体指针操作
在C语言中，结构体指针是一种指向结构体的指针。
通过结构体指针，我们可以对结构体进行操作，例如访问结构体的成员、修改结构体的内容等。
下面是一些关于结构体指针的基本操作：
定义结构体指针：
c
struct MyStruct {
int x;
float y;
};
struct MyStruct *ptr;
初始化结构体指针：
c
ptr = malloc(sizeof(struct MyStruct)); // 为结构体分配内存通过结构体指针访问结构体的成员：
c
ptr->x = 10; // 访问结构体的成员x，并赋值为10
ptr->y = 20.5; // 访问结构体的成员y，并赋值为20.5
释放内存：
c
free(ptr); // 释放结构体所占用的内存空间
指向另一个结构体：
c
struct MyStruct anotherStruct;
ptr = &anotherStruct; // 将结构体指针指向另一个结构体
创建指向数组的结构体指针：
c
struct MyStruct arr[10];
struct MyStruct *arrPtr = arr; // 创建一个指向数组的指针
需要注意的是，在使用结构体指针时，我们需要确保指针指向的内存空间是有效的，并且在使用完毕后及时释放内存，避免内存泄漏。
同时，还需要注意指针的类型和所指向的结构体的类型是否匹配，避免出现类型不匹配的错误。
C语言定义指向固定地址的结构体的指针
C语言定义指向固定地址的结构体的指针在C语言中，可以通过指针来操作和访问结构体。
定义指向固定地址的结构体指针意味着指针将指向一个特定的内存地址，该地址中存储了结构体的数据。
下面是一个具体的示例：```c#include <stdio.h>//定义一个结构体struct Studentchar name[50];int age;float score;};int mai//分配内存struct Student *ptr = (struct Student *)0x1000;//使用指针访问结构体字段，并修改其值sprintf(ptr->name, "John");ptr->age = 20;ptr->score = 85.5;//输出结构体字段值printf("Name: %s\n", ptr->name);printf("Age: %d\n", ptr->age);printf("Score: %.1f\n", ptr->score);return 0;```在上述示例中，我们首先声明了一个结构体 `Student`，它包含了姓名、年龄和分数等字段。
然后，在 `main` 函数中，我们定义了一个指针`ptr`，将其初始化为一个固定地址（0x1000）。
注意，强制类型转换`(struct Student *)` 是必需的，将地址转换为结构体指针。
接下来，我们通过指针 `ptr` 来访问结构体字段，并修改其值。
使用 `->` 运算符来访问结构体指针成员。
在本示例中，我们通过`sprintf` 将字符串 "John" 复制到 `name` 字段中，将 `age` 字段设置为 20，将 `score` 字段设置为 85.5最后，使用 `printf` 函数输出结构体字段的值。
C语言给结构体赋数据值和带有结构体指针变量的赋值方法
C语言给结构体赋数据值和带有结构体指针变量的赋值方法在C语言中，结构体是一种自定义的数据类型，用于存储不同类型的相关数据。
当我们定义完结构体后，可以使用各种方式为结构体赋值。
下面将介绍C语言中给结构体赋值的几种方法，以及带有结构体指针变量的赋值方法。
一、给结构体赋值的方法：1.使用"."操作符进行成员赋值：结构体中的成员变量可以通过"."操作符来赋值。
例如，假设我们定义了一个名为Student的结构体，其中包含姓名和年龄两个成员变量：```cstruct Studentchar name[20];int age;};```使用"."操作符给结构体成员赋值如下：```cstruct Student stu;strcpy(, "Tom");stu.age = 20;```2.使用初始化列表进行赋值：在定义结构体变量时，可以使用初始化列表直接为其成员变量赋值。
这种方式比较简洁，例如：```cstruct Studentchar name[20];int age;} stu = {"Tom", 20};```这样就将结构体的成员变量name赋值为"Tom"，age赋值为20。
3. 使用memcpy函数进行复制赋值：可以使用C标准库中的memcpy函数将已有的结构体数据复制到另一个结构体中，实现赋值的效果。
例如：```cstruct Studentchar name[20];int age;};struct Student stu1;struct Student stu2;strcpy(, "Tom");stu1.age = 20;memcpy(&stu2, &stu1, sizeof(struct Student));```上述代码将stu1中的数据复制到stu2中，达到了结构体赋值的效果。
c语言结构体指针 typedef
C语言中的结构体指针与typedef一、结构体指针的概念结构体是C语言中一种复合类型，它由若干数据成员组成，我们可以通过定义结构体变量的方式来使用结构体类型。
当我们需要在函数间传递结构体变量或在函数中动态创建结构体变量时，就需要使用结构体指针来进行操作。
二、结构体指针的定义和使用1. 定义结构体指针在C语言中，我们可以通过在结构体类型名称前加上"*"来定义结构体指针。
如果我们有一个名为Student的结构体类型，我们可以定义一个指向Student类型的指针变量ptr_stu如下所示：```struct Student {char name[20];int age;};struct Student *ptr_stu;```2. 结构体指针的初始化和使用我们可以通过使用取位置区域符""将结构体变量的位置区域赋给结构体指针，然后可以通过指针来访问结构体的成员变量。
假设我们有一个名为stu的结构体变量：```struct Student stu = {"John", 20};struct Student *ptr_stu = stu;printf("Name: s\n", ptr_stu->name);printf("Age: d\n", ptr_stu->age);```而在实际开发中，如果结构体类型名称较长或者需要频繁使用结构体指针，我们可以通过使用typedef来定义结构体指针类型，从而简化代码并提高可读性。
三、typedef关键字的介绍typedef是C语言中的关键字之一，它可以用来为一个已有的数据类型定义一个新的名称。
通过使用typedef，我们可以为复杂的数据类型定义更简洁、更易读的别名，从而提高代码的可维护性和可读性。
四、结构体指针的typedef用法1. 定义结构体指针类型我们可以通过使用typedef来定义结构体指针类型，从而可以直接使用新的类型名称来声明结构体指针变量。
精品-清华大学C语言课件 第13章01 结构体指针
【例13.2】 使用指向运算符引用结构体对象成员。 在本实例中，定义结构体变量但不为其进行初始化操作，使用指针指向结构体变量并为其成员进行赋值操作。
#include<stdio.h> #include<string.h>
struct Student/*学生结构*/ { char cName[20];/*姓名*/ int iNumber;/*学号*/ char cSex[3];/*性别*/ int iGrade;/*年级*/ }student;/*定义变量*/
pStruct ->成员名;
这种方法使用的是指向运算符，例如使用指向运算符引用一个变量的成员：
pStruct->iNumber=12061212;
假如student为结构体变量，pStruct为指向结构体变量的指针，可以看出以下三种形式的效果是等价的：
student.成员名 (*pStruct).成员名 pStruct->成员名
Display(student.fScore[0]);
C语言结构体指针引用详解
C语⾔结构体指针引⽤详解⽬录指向结构体变量的指针指向结构体数组的指针结构体指针，可细分为指向结构体变量的指针和指向结构体数组的指针。
指向结构体变量的指针前⾯我们通过“结构体变量名.成员名”的⽅式引⽤结构体变量中的成员，除了这种⽅法之外还可以使⽤指针。
前⾯讲过，&student1 表⽰结构体变量 student1 的⾸地址，即 student1 第⼀个项的地址。
如果定义⼀个指针变量 p 指向这个地址的话，p 就可以指向结构体变量 student1 中的任意⼀个成员。
那么，这个指针变量定义成什么类型呢？只能定义成结构体类型，且指向什么结构体类型的结构体变量，就要定义成什么样的结构体类型。
⽐如指向 struct STUDENT 类型的结构体变量，那么指针变量就⼀定要定义成 struct STUDENT* 类型。
下⾯将前⾯的程序⽤指针的⽅式修改⼀下：# include <stdio.h># include <string.h>struct AGE{int year;int month;int day;};struct STUDENT{char name[20]; //姓名int num; //学号struct AGE birthday; //⽣⽇float score; //分数};int main(void){struct STUDENT student1; /*⽤struct STUDENT结构体类型定义结构体变量student1*/struct STUDENT *p = NULL; /*定义⼀个指向struct STUDENT结构体类型的指针变量p*/p = &student1; /*p指向结构体变量student1的⾸地址, 即第⼀个成员的地址*/strcpy((*p).name, "⼩明"); //(*p).name等价于(*p).birthday.year = 1989;(*p).birthday.month = 3;(*p).birthday.day = 29;(*p).num = 1207041;(*p).score = 100;printf("name : %s\n", (*p).name); //(*p).name不能写成pprintf("birthday : %d-%d-%d\n", (*p).birthday.year, (*p).birthday.month, (*p).birthday.day);printf("num : %d\n", (*p).num);printf("score : %.1f\n", (*p).score);return 0;}输出结果是：name : ⼩明birthday : 1989-3-29num : 1207041score : 100.0我们看到，⽤指针引⽤结构体变量成员的⽅式是：(*指针变量名).成员名注意，*p 两边的括号不可省略，因为成员运算符“.”的优先级⾼于指针运算符“*”，所以如果 *p 两边的括号省略的话，那么*p.num 就等价于 *(p.num) 了。
指向结构体数组的指针定义
指向结构体数组的指针定义在C语言中，结构体是一种自定义的数据类型，它可以包含多个不同类型的数据成员，可以根据需要定义多个同种类型的结构体变量。
而结构体数组是一种数据结构，它是由相同类型的结构体变量组成的数组。
指向结构体数组的指针是一种指针类型，它可以指向一个结构体数组的首地址。
定义指向结构体数组的指针需要使用以下语法：struct student {char name[20];int age;float score;};struct student stu_array[5];struct student *p = stu_array;在上面的代码中，我们首先定义了一个结构体 student，包含三个数据成员：姓名、年龄和分数。
然后定义了一个长度为 5 的结构体数组 stu_array，其中每个元素都是一个 struct student 类型的结构体变量。
接着我们定义了一个指向结构体数组的指针 p，使用 stu_array 的首地址初始化了它。
这样，p 就指向了 stu_array 数组的第一个元素，也就是第一个 struct student 类型的结构体变量。
通过指向结构体数组的指针，我们可以方便地访问结构体数组中的各个元素。
例如，可以使用以下语法访问数组中的第 i 个元素： (p + i)->name(p + i)->age(p + i)->score上面的代码中，(p + i) 表示 p 指针所指向的位置加上 i 的偏移量，即指向 stu_array 数组中的第 i 个元素。
然后使用箭头运算符 -> 访问该元素的数据成员。
指向结构体数组的指针在 C 语言中非常常用，特别是在涉及到动态内存分配和结构体数组参数传递等情况下。
掌握其定义和使用方法对于 C 语言编程非常重要。
c语言传结构体指针
在C语言中，可以使用结构体指针来传递结构体数据。
下面是一个示例代码，演示了如何传递结构体指针：
```c
#include <stdio.h>
struct Student {
char name[20];
int age;
};
void printStudent(struct Student *s) {
printf("Name: %s\n", s->name);
printf("Age: %d\n", s->age);
}
int main() {
struct Student stu = {"Tom", 18};
printStudent(&stu); // 传递结构体指针
return 0;
}
```
在这个示例中，我们定义了一个名为`Student`的结构体，其中包含`name`和`age`两个成员变量。
我们还定义了一个名为`printStudent`的函数，该函数接受一个指向`Student`结构体的指针作为参数，并打印出该结构体的内容。
在`main`函数中，我们创建了一个名为`stu`的`Student`结构体实例，并将其传递给`printStudent`函数。
由于`printStudent`函数需要一个指向`Student`结构体的指针作为参数，因此我们使用`&`运算符获取了`stu`的地址，并将其传递给函数。
运行这个程序，将会输出以下内容：
```
Name: Tom
Age: 18
```
这表明我们成功地通过结构体指针传递了结构体数据，并打印出了其内容。
函数返回结构体指针
函数返回结构体指针在C语言中，可以使用结构体来表示复杂的数据结构，并且可以创建函数返回结构体指针。
本文将介绍如何在函数中返回结构体指针。
在开始之前，让我们先了解一下结构体和指针的概念：结构体是一种用户自定义的数据类型，它可以包含多个不同类型的变量。
通过结构体，我们可以将多个相关的变量组合成一个单一的实体。
在C语言中，可以使用以下方式定义一个结构体：```cstruct Personchar name[20];int age;float height;};```上述代码定义了一个名为`Person`的结构体，它包含了一个字符数组`name`、一个整型变量`age`和一个浮点型变量`height`。
指针是一个存储了内存地址的变量。
它可以指向任何类型的数据，包括结构体。
通过指针，我们可以间接访问和操作内存中的数据。
在C语言中，可以使用以下方式定义一个指向结构体的指针：```cstruct Person *ptr;```上述代码定义了一个名为`ptr`的指向`Person`结构体的指针。
现在我们来看一下如何在函数中返回结构体指针。
首先，我们需要在函数内部创建一个结构体，并为其分配内存空间。
可以使用`malloc(`函数来动态分配内存。
在分配内存之后，我们可以为结构体的成员变量赋值。
```c#include <stdio.h>#include <stdlib.h>struct Personchar name[20];int age;float height;};struct Person* createPerso//创建结构体并为其分配内存空间struct Person *ptr = (struct Person*)malloc(sizeof(struct Person));//为结构体的成员变量赋值strcpy(ptr->name, "John");ptr->age = 25;ptr->height = 1.75;return ptr;int maistruct Person *person = createPerson(;printf("Name: %s\n", person->name);printf("Age: %d\n", person->age);printf("Height: %.2f\n", person->height);free(person); // 释放内存return 0;```上述代码中，`createPerson(`函数动态地创建了一个`Person`结构体，并为其分配了内存空间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言入门教程-指向结构体的指针
2009年07月29日12:04
[导读] 指向结构体的指针
在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。
创建结构体指针是极常见的。
下面是一个例子：
typedef struct{
关键词：c语言入门
指向结构体的指针
在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。
创建结构体指针是极常见的。
下面是一个例子：
typedef struct
{char name[21];char city[21];char state[3];} Rec;
typedef Rec *RecPointer;
RecPointer r;
r=(RecPointer)malloc(sizeof(Rec));
r是一个指向结构体的指针。
请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。
而malloc语句会从堆上分配45字节的内存。
*r是一个结构体，像任何其他Rec类型的结构体一样。
下面的代码显示了这个指针变量的典型用法：
strcpy((*r).city, "Raleigh");
strcpy((*r).state, "NC");
printf("%sn", (*r).city);
free(r);
您可以像对待一个普通结构体变量那样对待*r，但在遇到C的操作符优先级问题时要小心。
如果去掉*r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。
使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：
r->这种写法和(*r).是完全等效的，但是省去了两个字符。
指向数组的指针
还可以创建指向数组的指针，如下所示：
int i;
p=(int *)malloc(sizeof(int[10])); for (i=0; i<10; i++)
p[i]=0;
free(p);
或：
int *p;
p=(int *)malloc(sizeof(int[10]));
for (i=0; i<10; i++)
*(p+i)=0;
free(p);
可见要创建指向整数数组的指针，只需创建一个普通的整数指针即可。
调用malloc分配合适的数组空间，然后将指针指向数组的第一个元素。
访问数组元素既可以用普通的数组下标也可以用指针运算。
C将两种方法视为是等效的。
指向数组的指针这一技巧尤其适用于字符串。
您可以为某个特定大小的字符串分配刚好合适的内存。
指针数组
有时声明一个指针数组可以节省大量内存，或者使得某些内存消耗较大的问题得以解决。
下面例子中的代码，声明了一个由10个结构体指针组成的数组，而不是一个结构体数组。
否则这个结构体数组将占用243 * 10=2,430字节的内存。
使用指针数组可以最大限度减小内存消耗，直到用malloc语句为记录实际分配内存空间。
作为此过程的演示，下面的代码只为一个记录分配空间，保存某个值后又将空间释放：
typedef struct
{char s1[81];char s2[81];char s3[81];} Rec; Rec *a[10];
a[0]=(Rec *)malloc(sizeof(Rec));
strcpy(a[0]->s1, "hello");
free(a[0]);
包含指针的结构体
结构体可以包含指针，如下所示：
typedef struct
{char name[21];char city[21];char phone[21];char *comment;} Addr; Addr s;
char comm[100];
gets(, 20);
gets(s.city, 20);
gets(s.phone, 20);
gets(comm, 100);
ment=
(char *)malloc(sizeof(char[strlen(comm)+1]));
strcpy(ment, comm);
只有当评论框里包含有评论的记录时，这一技巧才是有用的。
如果没有评论记录，评论框里只包含一个指针（4个字节）。
包含评论的记录会分配恰到好处的空间，保存评论的的字符串，
这取决于用户输入的字符串的长度。
10
外链代发。