【C进阶】之结构体类型（ struct）

最新推荐文章于 2024-06-03 16:57:42 发布
最新推荐文章于 2024-06-03 16:57:42 发布
阅读量1.6k 收藏 15
点赞数 2
分类专栏： C语言 文章标签： c语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/distant_rove666/article/details/127700095
版权

结构体类型（ struct）

1 结构体相关的概念

  1. C语言属于面向过程的一门语言，C语言开发工程师在编写代码时也要具有对象的思想，
    C语言表示对象的方式就是结构体类型。在C语言中通过结构体类型描述一个对象。

  2. 什么是对象？
    事件的万事万物都可以看出一个对象，通过编程语言抽象的描述一个对象。

  3. 如何描述一个对象？
    将一类对象具有共同的属性和行为剥离处理，非共性的东西剥离出去；
    比如人：姓名，年龄，身高，体重，性别，外貌， 吃喝拉撒睡。

    属性：对象的名词，形容词，量词 —> 抽象成代码：使用变量表示
    行为：对象的动词（可以干什么）—> 抽象成代码：使用函数表示

  4. 结构体的概念
    结构体属于C语言中的一个自定义的构造类型，关键字(struct)。
    将很多不同的数据类型封装成一个新的数据类型，这个数据类型就是结构体类型，
    结构体中的成员在内存空间中是连续的，并且每个成员都有其独立的内存空间。

  5. 声明一个结构体类型
    没有结构体的沟通类型，如何描述一个对象：

    char name[20];
int age;
char sex;
int score;   ----> 只能描述一个对象，

    如果描述多个对象，在重新定义多次。

    如果描述多个对象，在重新定义多次。

    有结构体的沟通类型，如何描述一个对象：

    struct student{   // 声明一个结构体类型，此时struct student就表示一个结构体类型名，
					// 使用此类型可以定义结构体类型的变量
	char name[20];
     int age;
     char sex;
     int score; 
};

    // 定义一个对象
    struct student stu1;
    // 定义100个对象
    struct student stu_arr[100];

2 声明结构体类型的语法格式

// 1. 声明一个结构体类型， 声明结构体类型时并没有在内存中分配空间
struct 结构体名{
数据类型 变量名1;
数据类型 变量名2;
数据类型 变量名3;
…
数据类型 变量名n;
};

  1. 此时"struct 结构体名"就是自己构造的新的结构体类型，使用此结构体类型定义结构体类型的变量。

  2. 结构体中的成员的类型可以是：基本的数据类型，数组类型，指针类型，指针数组，数组指针，函数指针，
    函数指针数组，嵌套的结构体类型，枚举类型，联合体类型。

3 定义结构体类型的变量

  1. 定义普通的结构体类型的变量：
    struct 结构体名 结构体变量名;
  2. 定义结构体指针类型的变量：
    struct 结构体名 *结构体指针变量名;

4 结构体中成员的访问

  1. 定义普通的结构体类型的变量：
    结构体变量名.成员变量名;
  2. 定义结构体指针类型的变量：
    结构体指针变量名->成员变量名;

5 定义普通的结构体类型的变量，并访问

5.1 先声明结构体类型，在定义结构体类型的变量

  1. 声明结构体类型

    struct student{  
	char name[20];
     int age;
     char sex;
     int score; 
};

  2. 定义普通结构体类型的变量 : struct 结构体名 结构体变量名;
    struct student stu;

  3. 对结构体中的成员进行初始化
    3.1> 定义结构体类型变量的同时进行初始化
    struct student stu1 = {"yy", 18, 'M', 100};
    // 要求按照结构体中成员的类型依次进行初始化
    3.2> 先定义结构体类型变量，后进行初始化 : 结构体变量名.成员变量名 = 初始值;

    struct student stu2;
strcpy(stu2.name, "yy");
stu2.age = 18;
stu2.sex = 'M';
stu2.score = 100;

    3.3> 定义结构体类型变量的同时进行初始化

    struct student stu1 = {
    .name = "yy", 
    .age = 18, 
    .sex = 'M', 
    .sorce=100
};

    优点：可以只对部分成员初始化，成员初始化的顺序没有要求。

#include <stdio.h>
#include <string.h>
// 1. 声明结构体类型,结构体类型中的成员根据自己的对象添加对应的成员
struct student
{
    char name[20];
    int age;
    char sex;
    int score;
};

// 相同结构体类型的变量，可以进行赋值操作，
// 结构体类型作为函数的形参使用
void print(struct student s)
{
    printf("我的名字叫%s,我的年龄%d,我的性别%c,我的成绩%d\n",
                s.name, s.age, s.sex, s.score);
}

int main(int argc, const char *argv[])
{
    /*your code*/
    // 1. 先定义结构体类型的变量，在对结构体变量中的成员初始化
    struct student stu1;
    strcpy(stu1.name, "yy");
    stu1.age = 18;
    stu1.sex = 'M';
    stu1.score = 100;
    print(stu1);
    
    // 2. 定义结构体类型变量的同时进行初始化
    struct  student stu2 = {"yy", 28,'M',88};
    print(stu2);

    // 3. 定义结构体类型变量的同时进行初始化
    struct student stu3 = {
        .name = "lisi",
        .sex = 'W',
        .age = 24,
        .score = 99
    };
    print(stu3);

    return 0;
}

5.2 声明结构体类型的同时定义结构体类型的变量

  1. 声明结构体类型的同时定义结构体类型的变量

    struct student{  
	char name[20];
    int age;
    char sex;
    int score; 
}stu1, stu2, stu3;

  2. 对结构体类型的变量进行初始化
    2.1> 声明结构体类型的同时定义结构体变量，同时初始化。

    struct student{  
         char name[20];
         int age;
         char sex;
         int score; 
}stu1={"yy",18,'M',100};

    2.2> 声明结构体类型的同时定义结构体变量，同时初始化。

    struct student{  
         char name[20];
         int age;
         char sex;
         int score; 
     }stu2 = {
     	.name = "yy",
     	,age = 18,
     	.sex = 'M',
     	.score = 100};

    2.3> 声明结构体类型的同时定义结构体变量，最后在进行初始化。

    struct student{  
         char name[20];
         int age;
         char sex;
         int score; 
     }stu3;     

strcpy(stu3.name, "yy");
stu3.age = 18;
stu3.sex = 'M';
stu3.score = 100;

没有结构体名字的结构体：

  1. 声明结构体类型的同时定义结构体类型的变量, 省略结构体的名字，
    后续不可以单独使用这个结构体类型在定义新的变量。

    struct  {  
	char name[20];
    int age;
    char sex;
    int score; 
	}stu1, stu2, stu3;

  2. 对结构体类型的变量进行初始化
    2.1> 声明结构体类型的同时定义结构体变量，同时初始化。

    struct {  
    char name[20];
    int age;
    char sex;
    int score; 
}stu1={"yy",18,'M',100};

    2.2> 声明结构体类型的同时定义结构体变量，同时初始化。

    struct {  
         char name[20];
         int age;
         char sex;
         int score; 
     }stu2 = {
     	.name = "yy",
     	,age = 18,
     	.sex = 'M',
     	.score = 100
 };

    2.3> 声明结构体类型的同时定义结构体变量，最后在进行初始化。

    struct {  
    char name[20];
    int age;
    char sex;
    int score; 
}stu3;
strcpy(stu3.name, "yy");
stu3.age = 18;
stu3.sex = 'M';
stu3.score = 100;

练习题：定义教师结构体类型，成员姓名(字符数组name)，年龄(age)，工资(salary)。
并使用类定义结构体变量，对成员进行初始化。

#include <stdio.h>
#include <string.h>
// 声明结构体类型的同时定义结构体变量
struct  teacher
{
    char name[20];
    int age;
    int salary;
}tea1 = {"yy", 18, 30000}, 
tea2 = {
    .name = "yy", 
    .age = 18, 
    .salary = 35000}, 
tea3;

void print(struct teacher t)
{
    printf("姓名：%s, 年龄：%d, 工资：%d\n",
            t.name, t.age, t.salary);
}

int main(int argc, const char *argv[])
{
    /*your code*/
    // 先声明结构体类型，定义结构体变量，后进行初始化
    strcpy( tea3.name, "yy");
    tea3.age = 16;
    tea3.salary = 32000;

    print(tea1);
    print(tea2);
    print(tea3);

    return 0;
}

6 定义结构体指针类型的变量，并访问

  1. 声明结构体类型

    struct student {  
	char name[20];
     int age;
     char sex;
  int score; 
};

  2. 定义结构体指针变量
    struct student *p;

  3. 对结构体指针变量进行初始化
    3.1 结构体指针变量指向栈区的空间：

    struct student stu = {"yy", 18, 'M', 100};  // 定义普通结构体变量
struct student *p = &stu;
struct student *p = NULL;
p = &stu;

    3.2 结构体指针变量指向堆区的空间：

    struct student *p = (struct student *)malloc(sizeof(struct student));
strcpy(p->name, "yy");
p->age = 18;
p->sex = 'M';
p->score = 100;

  4. 如果定义的是结构体指针变量，没有以下初始化的方式，原因是结构体指针变量占8字节空间(64位系统)

struct student *p = {
->name = "yy",
->age = 18,
->sex = 'M',
->score = 100,
};

测试：

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

// 1. 声明结构体类型
struct student
{
    char name[20];
    int age;
    char sex;
    int score;
};

// 函数的形参是一个结构体指针类型
void print(struct student *t)
{
    printf("姓名：%s, 年龄：%d, 性别：%c, 成绩：%d\n",
                t->name, t->age, t->sex, t->score);
}

int main(int argc, const char *argv[])
{
    /*your code*/
    // 2. 定义结构体指针类型的变量，指向一个栈区的结构体变量
    struct student stu = {"yy", 18, 'M', 100};
    print(&stu);
    struct student *p1 = &stu;
    print(p1);

    // 3. 定义结构体指针类型的变量，指向一个堆区的空间。
    struct student *p2 = (struct student *)malloc(sizeof(struct student));
    if (p2 == NULL)
    {
        printf("malloc memory failed!\n");
        return -1;
    }
    strcpy(p2->name, "yy");
    p2->age = 18;
    p2->sex = 'M';
    p2->score = 100;
    print(p2);
    return 0;
}

7 结构体中的成员包含指针类型的成员

1. 声明结构体类型
	struct student {
		char *name;
		int *age;
	};

2. 定义结构体类型的变量并进行初始化
	int m_age = 18;
	struct student stu = {"yy", &m_age};  // char *name指向的是一个字符串常量
	
	char m_name[20]= "yy";
	int m_age = 18;
	struct student stu = {m_name, &m_age};  // char *name指向的是一个字符数组
	
	struct student stu;
	stu.name = (char *)malloc(sizeof(char)*20);  // char *name成员指向堆区空间
	stu.age = (int *)malloc(sizeof(int));  // int *age成员指向堆区空间
	strcpy(stu.name, "yy");
	*stu.age = 18;
	
	struct student *p1 = &stu;
	
	
	struct student *p2 /*定义结构体指针变量，p2在栈区分配8字节空间 */
				= (struct student *)malloc(sizeof(struct student)); 
				/* 让P2指向堆区空间， 给p2->name成员分配8字节空间，存放地址
				给p2->age成员分配8字节空间，存放地址 */
				
	/*对p2中的name成员分配堆区空间并指向堆区的空间 */ 
	p2->name = (char *)malloc(sizeof(char)*20);  // char *name成员指向堆区空间
	/*对p2中的age成员分配堆区空间并指向堆区的空间 */ 
	p2->age = (int *)malloc(sizeof(int));  // int *age成员指向堆区空间
	
	// 对堆区的空间进行初始化。
	strcpy(p2->name, "yy");
	*p2->age = 18;

测试：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct student
{
    char *name;
    int *age;
};

void print(struct student *s)
{
    printf("姓名：%s, 年龄：%d\n", s->name, *s->age);
}

int main(int argc, const char *argv[])
{
    /*your code*/
    int m_age = 18;
    // 定义普通的结构体变量，并进行初始化
    struct student stu1 = {"yy", &m_age}; // char *name指向的是一个字符串常量
                                              // int *age 指向的一个int类型的变量
    print(&stu1);

    char m_name[20] = "yy";
    // 定义普通的结构体变量，并进行初始化
    struct student stu2 = {m_name, &m_age}; // char *name指向的是一个字符数组
                                        // int *age 指向的一个int类型的变量
    print(&stu2);


    // 定义普通结构体变量，让结构体中的指针类型的成员指向堆区空间
    struct student stu3;
    stu3.name = (char *)malloc(sizeof(char) * 20); // char *name成员指向堆区空间
    stu3.age = (int *)malloc(sizeof(int));         // int *age成员指向堆区空间
    // 对堆区的空间进行初始化操作
    strcpy(stu3.name, "ff");
    *stu3.age = 18;
    print(&stu3);

    // 定义结构体指针变量, 指向普通的结构体类型的变量
    struct student *p1 = &stu3;
    print(p1);

    // 定义结构体指针变量，指向堆区空间，结构体中的成员也指向堆区空间
    struct student *p2 /*定义结构体指针变量，p2在栈区分配8字节空间 */
        = (struct student *)malloc(sizeof(struct student));
    /* 让P2指向堆区空间， 给p2->name成员分配8字节空间，存放地址
    给p2->age成员分配8字节空间，存放地址 */

    /*对p2中的name成员分配堆区空间并指向堆区的空间 */
    p2->name = (char *)malloc(sizeof(char) * 20); // char *name成员指向堆区空间
    /*对p2中的age成员分配堆区空间并指向堆区的空间 */
    p2->age = (int *)malloc(sizeof(int)); // int *age成员指向堆区空间

    // 对堆区的空间进行初始化。
    strcpy(p2->name, "ff");
    *p2->age = 18;

    print(p2);
    
    return 0;
}

8 定义结构体数组

  1. 声明结构体类型

    struct student
 {
     char name[20];
     int age;
     char sex;
     int score;
 };

  2. 定义结构体数组变量 : struct student 结构体数组名[数组的长度];
    struct student arr[2];

  3. 对数组的成员进行初始化
    3.1> 定义的同时进行初始化
    struct student arr[2] = {{"yy",18,'M',100},{"yy",18,'M',90}};

    3.2> 定义的同时进行初始化

    struct student  arr[2] = {
		[0] = {
			.name = "yy",
			.age = 18,
			.sex = 'M',
			.score = 100
		},
		[1] = {
			.name = "yy",
			.age = 18,
			.sex = 'M',
			.score = 90
		}
	};

    3.3> 先定义结构体数组，后进行初始化

    struct student  arr[2];
strcpy(arr[0].name, "yy");
arr[0].age = 18;
arr[0].sex = 'M';
arr[0].score = 100;
strcpy(arr[1].name, "yy");
arr[1].age = 18;
arr[1].sex = 'M';
arr[1].score = 90;

  4. 结构体数组中每个元素中的每个结构体成员的访问

    void print(struct student *s, int len)
{
	int i;
	for (i = 0; i < len; i++) 
	{
		printf("%s %d %c %d\n", s[i].name, s[i].age, s[i].sex, s[i].score);
		printf("%s %d %c %d\n", (s + i)->name, (s+i)->age, (s+i)->sex, (s+i)->score);
	}
}

练习题：定义教师结构体类型，成员姓名(字符数组name)，年龄(age)，工资(salary)。
并使用类定义结构体变量，对成员进行初始化

结构体数组实现：

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

struct teacher
{
    char name[20];
    int age;
    int salary;
};

int main(int argc, const char *argv[])
{
    struct teacher tea[10];
    int n=0;//教师人数
    printf("请输入教师人数>");
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        printf("教师%d的姓名:",i);
        scanf("%s",tea[i].name);   
        printf("年龄:");
        scanf("%d",&(tea[i].age));
        printf("工资:");
        scanf("%d",&(tea[i].salary));
    }
    printf("打印教师工资表>\n");
    for (int i=1; i<=n;i++)
    {
        printf("教师%d的姓名:%s  年龄:%d   工资:%d\n",i,tea[i].name,tea[i].age,tea[i].salary);
    }
    return 0;
}

结构体指针实现：

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

struct teacher
{
    char name[20];
    int age;
    int salary;
};

int main(int argc, const char *argv[])
{
    int n=0;//教师人数
    printf("请输入教师人数>");
    scanf("%d",&n);
    // struct teacher tea[10];
    struct teacher *tea=(struct teacher *)malloc(sizeof(struct teacher)*n);
    if(NULL==tea) printf("malloc memory filed!\n");
    for(int i=0;i<n;i++){
        printf("教师%d的姓名:",i+1);
        // scanf("%s",(*(tea+i)).name); 
        scanf("%s",(tea+i)->name); 
        printf("年龄:");
        // scanf("%d",&((*(tea+i)).age));
        scanf("%d",&(tea+i)->age);
        printf("工资:");
        // scanf("%d",&((*(tea+i)).salary));
        scanf("%d",&(tea+i)->salary);
    }
    printf("打印教师工资表>\n");
    for (int i=0; i<n;i++)
    {
        // printf("教师%d的姓名:%s  年龄:%d   工资:%d\n",i+1,(*(tea+i)).name,(*(tea+i)).age,(*(tea+i)).salary);
        printf("教师%d的姓名:%s  年龄:%d   工资:%d\n",i+1,(tea+i)->name,(tea+i)->age,(tea+i)->salary);
    }
    return 0;
}

9 定义结构指针数组

  1. 结构指针数组:本质是一个数组，数组中的成员都是结构体的指针。

  2. 格式：
    struct 结构体名 *结构体指针数组名[元素个数];

  3. 初始化：
    struct 结构体名 结构体变量0;
    struct 结构体名 结构体变量1;
    …

    定义结构体指针数组的同时进行初始化：
    struct 结构体名 *结构体指针数组名[元素个数] = {&结构体变量0, &结构体变量1};

    先定义结构体指针数组，后进行初始化：
    struct 结构体名 *结构体指针数组名[元素个数];
    结构体指针数组名[下标] = &结构体变量0;
    结构体指针数组名[下标] = &结构体变量1;

  4. 访问结构体指针数组的每个元素，每个元素都是一个结构体指针类型，并访问结构体中的每个成员。
    结构体指针数组名[下标]->结构体成员名;

10 定义结构体数组指针

  1. 结构体数组指针 ： 本质是一个指针，指向的是一个结构体二维数组

  2. 格式：
    struct 结构体名 (*结构体数组指针名)[元素个数];

  3. 初始化
    定义的同时进行初始化：
    struct 结构体名 结构体数组名[元素个数] = {{},{},…};
    struct 结构体名 (*结构体数组指针名)[元素个数] = &结构体数组名;

    先定义后进行初始化：
    struct 结构体名 (*结构体数组指针名)[元素个数];
    结构体数组指针名 = &结构体数组名;

  4. 成员的访问
    (*结构体数组指针名)[下标].结构体成员名;

    或者
    ((*结构体数组指针名)+下标)->结构体成员名;

11 相同结构体类型变量可以进行赋值操作

相同结构体类型的变量可以进行赋值操作。
struct student
{
    char name[20];
    int age;
    char sex;
    int score;
};
struct student stu1 = {"yy", 18, 'M', 100};
struct student stu2 = stu1;   // 普通结构体变量进行赋值

struct student *p = NULL;   // 结构体指针变量进行赋值
*p = &stu1;

struct student *p2 = p;  // 结构体指针变量进行赋值

12 小结

声明一个结构体类型：

struct teacher{
	char *name;
	int age;
	char sex;
	int salary;
};

// 1. 定义普通的结构体变量，并初始化，完成成员的访问（3种）
// 2. 定义结构体指针， 并初始化，指向堆区的空间或者栈区空间，并访问成员(堆区、栈区)
// 3. 定义结构体数组，并初始化，已经完成数组的每个元素及元素中的每个成员的访问(3种)
// 4. 定义结构体指针数组， 并初始化，访问成员(2种)
// 5. 定义结构体数组指针，并初始化，以及成员的访问

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

typedef struct teacher{
    char *name;
    int age;
    char sex;
    int salary;
}tea;

int main(int argc, const char *argv[])
{
    //1. 定义普通的结构体变量，并初始化，完成成员的访问（3种）
    tea t1={"y1",18,'M',10000};//方法一
    tea t2={.name="y2",.age=19,.sex='M',.salary=100};//方法二
    //方法三
    tea t3;
    t3.name="y3";
    t3.age=20;
    t3.sex='M';
    t3.salary=10000;

    // 2. 定义结构体指针， 并初始化，指向堆区的空间或者栈区空间，并访问成员
    //在栈区
    tea t4={"y4",18,'M',10000};
    tea *p1_t4=&t4;

    //在堆区
    tea *p2=(tea *)malloc(sizeof(tea));
    if(NULL==p2)printf("malloc memory filed!\n");
    // 给结构体中的指针赋值的方式（3种）
    //结构体中name指针直接指向常量区
    p2->name="p2";
    //结构体中name指针指向栈区
    char name[20]="yy";
    p2->name=name;
    //结构体中name指针指向堆区
    p2->name=(char *)malloc(sizeof(20));
    strcpy(p2->name,"yy");

    p2->age=20;
    p2->sex='M';
    p2->salary=1000;
    free(p2);
    p2=NULL;
// #define DEBUG
#ifdef DEBUG1

    //error初始化,原因：指针的大小只有8字节（64位系统），不能存储那么多数据
    int *p3={
            ->name="p3",
            ->age=20,
            ->sex='M',
            ->salary=200}

#endif

    // 3. 定义结构体数组，并初始化，已经完成数组的每个元素及元素中的每个成员的访问(3种)
    tea t5[2]={{"y5",18,'M',10000},{"y6",18,'M',10000}};//方法一

    tea t6[2]={
            [0]={"y5",18,'M',10000},
            [1]={"y6",18,'M',10000}
            };//方法二
    //方法三
    tea t7[2];
    t7[0].name="y7";
    t7[0].age=20;
    t7[0].sex='M';
    t7[0].salary=2000;
    t7[1].name="y8";
    t7[1].age=20;
    t7[1].sex='M';
    t7[1].salary=2000;
    //访问
    for(int i=0;i<2;i++){
        printf("%s   %d   %c   %d\n",t7[i].name,t7[i].age,t7[i].sex,t7[i].salary);
        printf("%s   %d   %c   %d\n",(*(t7+i)).name,(*(t7+i)).age,(*(t7+i)).sex,(*(t7+i)).salary);
        printf("%s   %d   %c   %d\n",(t7+i)->name,(t7+i)->age,(t7+i)->sex,(t7+i)->salary);
    }


    // 4. 定义结构体指针数组， 并初始化，访问成员(2种)
    tea t9={"y9",18,'M',10000};
    tea t10={"y10",18,'M',10000};
    tea *t8[2]={&t9,&t10};//方法一，定义结构体指针数组的同时进行初始化
    //访问
    for(int i=0;i<2;i++){
        printf("%s   %d   %c   %d\n",(*t8[i]).name,(*t8[i]).age,(*t8[i]).sex,(*t8[i]).salary);
    }

    //方法二，先定义结构体指针数组，后进行初始化
    tea *t11[2];
    t11[0]=&t9;
    t11[1]=&t10;
    //访问
    for(int i=0;i<2;i++){
        printf("%s   %d   %c   %d\n",t11[i]->name,t11[i]->age,t11[i]->sex,t11[i]->salary);
    }

    // 5. 定义结构体数组指针，并初始化，以及成员的访问(2种)
    //方法一：定义的同时进行初始化
    tea t13[2]={{"y13",18,'M',10000},{"y13",19,'M',10000}};
    tea (*t12)[2]=&t13;
    //访问：
    for(int i=0;i<2;i++){
        printf("%s   %d   %c   %d\n",(*t12)[i].name,(*t12)[i].age,(*t12)[i].sex,(*t12)[i].salary);
        printf("%s   %d   %c   %d\n",(*((*t12)+i)).name,(*((*t12)+i)).age,(*((*t12)+i)).sex,(*((*t12)+i)).salary);
        printf("%s   %d   %c   %d\n",((*t12)+i)->name,((*t12)+i)->age,((*t12)+i)->sex,((*t12)+i)->salary);
    }
    //方法二：先定义后进行初始化
    tea (*t14)[2];
    t14=&t13;
    //访问：
    for(int i=0;i<2;i++){
        printf("%s   %d   %c   %d\n",(*t14)[i].name,(*t14)[i].age,(*t14)[i].sex,(*t14)[i].salary);
        printf("%s   %d   %c   %d\n",(*((*t14)+i)).name,(*((*t14)+i)).age,(*((*t14)+i)).sex,(*((*t14)+i)).salary);
        printf("%s   %d   %c   %d\n",((*t14)+i)->name,((*t14)+i)->age,((*t14)+i)->sex,((*t14)+i)->salary);
    }
    return 0;
}
编程远泊
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言进阶学习，复习资料
10-09
在C语言进阶学习中，了解各种数据类型是至关重要的。数据类型决定了变量在内存中占用的空间大小以及如何解读这些空间。C语言的数据类型主要包括基本类型、构造类型和指针类型。 1. 基本类型： - `char`：用于存储...
【C语言】1. 结构体struct（结构体概念、结构体指针、结构体作为函数参数、传值与传地址、内存对齐（struct与union））
瞌睡的博客
11-27 1万+
/创建结构体模板 struct Student {int _age;//使用该模板创建3个变量stu1,stu2,stu3 struct Student stu1 , stu2 , stu3;缺点就是定义变量时必须带上struct可以使用typedef进行简写，这样在定义变量时比较简洁//结构体模板struct Student重新命名为Stu typedef struct Student {int _age;} Stu;
【C语言】struct结构体
m0_51064412的博客
04-29 1万+
在C中，结构体内只能存放各种类型的变量，不能存函数：像上面这样就是声明了一个结构体，此时的相当于一个类型名。补充：C 和 C++ 中定义结构体变量的区别在 C 中使用结构体去定义变量时，需要在结构体名称前加上 struct 关键字。在 C++ 中使用结构体去定义变量时，可以不加 struct 关键字在 c99 中有明确的规定允许结构体中最后一个数组大小是未知的。char b;//或者int arr[0];struct T t;
【C语言】结构体（struct）最全的讲解（万字干货）以及枚举类型
最新发布
C4840的博客
06-03 3472
结构体实现位段的方式；结构体的声明；结构体的传参；位段的应用；枚举类型的讲解细节
结构体类型
m0_66908026的博客
04-11 5162
一：结构体定义 1.C语言允许用户自己建立由不同类型的数据组成的组合型数据结构，它称为结构体 2.一般形式： struct结构体名 {成员列表}； （1）struct是声明结构体类型时所必须使用的关键字 （2）大括号内是结构体所包含的子项，称为结构体成员，对各成员都应进行类型声明，即类型名成员名； 3.先声明结构体类型，再定义该类型的变量 例：struct student（结构体类型名）student1 student2（结构体变量名） 这种方式是声明类型和定义变量分离，在声明类型后可..
【C语言进阶】结构体类型
Henry的博客
05-09 4520
目录 1. 结构体类型 2. 匿名结构体类型 3. 结构体的自引用 4. 结构体的 typedef 5. 结构体类型的初始化 6. 结构体的内存对齐 7. 内存对齐的原因 8. 修改默认对齐数 9. offset 取偏移量 10. 结构体传参 1. 结构体类型 内置类型：char、int、short、float 自定义类型：结构体类型、枚举类型、联合体类型 结构体类型： 创建结构体类型： 2. 匿名结构体类型 省略了结构体标签（名字），那么需要在后面创.
【结构体类型——详细讲解】
qq_73900397的博客
09-18 1212
一篇就会让你学懂结构体类型！！！
C语言进阶训练包
01-19
C语言是一种基础且强大的编程语言，它以其简洁的语法、高效性能和广泛的应用范围而闻名。这个"C语言进阶训练包"是专为已经初步了解C语言基础的新手准备的，旨在通过一...所以，不要犹豫，立即开始你的C语言进阶之旅吧！
结构体C语言高级进阶篇PPT课件.pptx
10-09
1. 使用`struct`关键字定义结构体类型，并指定其成员变量，例如： ```c struct student_tag { char ID[7]; char name[20]; char gender; int age; char phone[9]; char addr[30]; }; ``` 在这个例子中，`...
C语言进阶语法与编程技巧.md
08-12
### C语言进阶语法与编程技巧 #### 一、结构体与联合体 **1.1 定义与声明** 在C语言中，结构体（`struct`）是一种复合数据类型，它允许开发者创建包含不同数据类型成员的自定义类型。这种特性非常有用，特别是在...
C语言进阶（含代码）
05-05
- **特定用途的数据类型**：除了基本数据类型，C语言还支持如枚举类型（`enum`）、结构体（`struct`）、联合体（`union`）等，这些类型用于解决更复杂的数据表示问题，例如结构体可以用来组合不同类型的数据成为一个...
详解C语言自定义类型——结构体struct
weixin_74837727的博客
03-19 3109
详解C语言自定义类型——结构体struct
自定义类型--结构体详解
zhaocx111222333的博客
11-21 556
#pragma pack(4)/*编译选项，表示4字节对齐 平台：VS2013。语言：C语言*/ int main(int argc, char* argv[]) { struct Test1 { short a; char d; long b; long c; }; struct Test2 { long b; short c; char d; long a; ...
C语言——结构体（Struct）详解+运用举例
脑壳有点痒，好像要长脑子了！
07-27 3667
结构体（Struct）是一种数据类型，用于将不同类型的变量组合在一起形成一个新的数据结构。它允许我们在单个实体中存储和操作多个相关的变量。结构体可以包含不同类型的成员变量。那么具体可以包含哪些类型呢？在实际运用中该怎么用呢？
结构体类型struct
qq_45613195的博客
08-16 1119
结构体类型是一种可以用户自定义的数据类型
结构体（struct）
热门推荐
愿万事胜意
03-09 2万+
结构体 1.概念 结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合。 2. C语言中的结构体 在C语言中，结构体(struct)是复合数据类型的一种。同时也是一些元素的集合，这些元素称为结构体的成员，且这些成员可以为不同的类型，成员一般用名字访问。结构体可以被声明为变量、指针或数组等，用以实现较复杂的数据结构。 注意：在C语言中，结构体不能包含函数。 示例...
C语言结构体总结(详细，直观，全面)
weixin_73233099的博客
01-24 6587
新年必看的一篇结构体文章
自定义类型之结构体详解——struct
月亮有痕迹诶的博客
09-30 1523
结构体是一种自定义数据类型，可以将不同数据类型的变量组合成一个结构体，方便进行管理和操作。本文详细介绍了结构体的各种使用，并对结构体在内存中的存储进行了深入的探讨。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程远泊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值