【C】Structure

🕗 发布于 2024-07-11 23:08 c语言 windows 开发语言

在这里插入图片描述

参考摘抄学习来自：

文章目录

1 定义
2 初始化
3 结构体大小的计算
4 访问结构成员
5 结构作为函数参数
6 指向结构的指针
7 结构体数组
8 动态申请结构体

1 定义

它允许您存储不同类型的数据项。

结构体中的数据成员可以是基本数据类型（如 int、float、char 等），也可以是其他结构体类型、指针类型等。

struct tag { 
    member-list
    member-list 
    member-list  
    ...
} variable-list ;

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f;，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。

在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct 
{
    int a;
    char b;
    double c;
} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
    int a;
    char b;
    double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;

//也可以用typedef创建新类型
typedef struct
{
    int a;
    char b;
    double c; 
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;

结构体嵌套

//此结构体的声明包含了其他的结构体
struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};

//此结构体的声明包含了指向自己类型的指针
struct NODE
{
    char string[100];
    struct NODE *next_node;
};

C 语言提供了 typedef 关键字，您可以使用它来为类型取一个新的名字。下面的实例为单字节数字定义了一个术语 BYTE：

typedef unsigned char BYTE;

在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写，例如：

BYTE  b1, b2;

按照惯例，定义时会大写字母，以便提醒用户类型名称是一个象征性的缩写，但您也可以使用小写字母，如下：

typedef unsigned char byte;

您也可以使用 typedef 来为用户自定义的数据类型取一个新的名字。例如，您可以对结构体使用 typedef 来定义一个新的数据类型名字，然后使用这个新的数据类型来直接定义结构变量

2 初始化

#include <stdio.h>

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 语言", "RUNOOB", "编程语言", 123456};

int main()
{
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

output

title : C 语言
author: RUNOOB
subject: 编程语言
book_id: 123456

3 结构体大小的计算

#include <stdio.h>

struct Person {
    char name[20];
    int age;
    float height;
};

int main() {
    struct Person person;
    printf("name size: %zu\n", sizeof(person.name));
    printf("age size: %zu\n", sizeof(person.age));
    printf("height size: %zu\n", sizeof(person.height));
    printf("结构体 Person 大小为: %zu 字节\n", sizeof(person));
    return 0;
}

output

name size: 20
age size: 4
height size: 4
结构体 Person 大小为: 28 字节

再看看下面这个例子

#include <stdio.h>

int main(void)
{
    struct A
    {
        char a;
        int b;
        char c;

    } a = {'a', 10, 'o'};
    
    printf("size of a = %d\n", sizeof(a.a));
    printf("size of b = %d\n", sizeof(a.b));
    printf("size of c = %d\n", sizeof(a.c));
    printf("size of a = %d\n", sizeof(a));
    
    return 0;
}

output

size of a = 1
size of b = 4
size of c = 1
size of a = 12

#include <stdio.h>

int main(void)
{
    struct A
    {
        char a;
        char c;
        int b;
    } a = {'a', 'o', 10};
    
    printf("size of a = %d\n", sizeof(a.a));
    printf("size of c = %d\n", sizeof(a.c));
    printf("size of b = %d\n", sizeof(a.b));
    printf("size of a = %d\n", sizeof(a));
    
    return 0;
}

output

size of a = 1
size of c = 1
size of b = 4
size of a = 8

存在内存对齐现象

在C语言中，内存对齐（Memory Alignment）是一个重要的概念，它指的是数据在内存中按照一定的规则进行排列，以提高内存的访问效率。不同的硬件平台对内存访问有不同的要求，如果数据没有按照这些要求来对齐，可能会导致性能下降，甚至在某些平台上引发硬件异常。

为什么要内存对齐？

性能优化：现代计算机体系结构通常通过内存对齐来提高内存访问速度。这是因为硬件可能设计为以特定的字节边界（如4字节、8字节等）来高效地访问内存。
平台兼容性：不同的硬件平台对内存对齐的要求可能不同。遵循内存对齐的规则可以确保程序在不同平台上的兼容性。

内存对齐的规则

自然对齐：数据的存储起始地址是数据本身大小的整数倍。例如，int类型（假设为4字节）的变量应该存储在4的倍数地址上。
结构体对齐：结构体中的成员变量和整个结构体本身都会受到对齐规则的影响。结构体成员的对齐通常遵循其自然对齐规则，而结构体本身的对齐则可能由编译器或编译器的特定选项决定。
编译器指令：大多数编译器提供了控制对齐的指令或选项，如GCC的__attribute__((aligned(n)))和MSVC的#pragma pack(n)。

4 访问结构成员

成员访问运算符（.）

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printf( "Book 1 title : %s\n", Book1.title);
   printf( "Book 1 author : %s\n", Book1.author);
   printf( "Book 1 subject : %s\n", Book1.subject);
   printf( "Book 1 book_id : %d\n", Book1.book_id);

   /* 输出 Book2 信息 */
   printf( "Book 2 title : %s\n", Book2.title);
   printf( "Book 2 author : %s\n", Book2.author);
   printf( "Book 2 subject : %s\n", Book2.subject);
   printf( "Book 2 book_id : %d\n", Book2.book_id);

   return 0;
}

output

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

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

struct Person {
    int age;
    float height;
};

struct Birthday{
    char name[20];
    struct Person person;
};

int main() {
    struct Birthday birthday;
    strcpy(birthday.name, "Bryant");
    birthday.person.age = 18;
    birthday.person.height = 171;
    printf("name:%s, age:%d, height:%f\n", birthday.name, birthday.person.age, birthday.person.height);
  
    return 0;
}

output

name:Bryant, age:18, height:171.000000

5 结构作为函数参数

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printBook( Book1 );

   /* 输出 Book2 信息 */
   printBook( Book2 );

   return 0;
}
void printBook( struct Books book )
{
   printf( "Book title : %s\n", book.title);
   printf( "Book author : %s\n", book.author);
   printf( "Book subject : %s\n", book.subject);
   printf( "Book book_id : %d\n", book.book_id);
}

output

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

#include <stdio.h>

struct Student{
    int age;
};

void test(struct Student stu){
    printf("test 修改前的值:%d\n", stu.age);
    stu.age = 10;
    printf("test 修改后的值:%d\n", stu.age);
}

int main()
{
    struct Student student;
    student.age = 30;
    printf("main 修改前的值:%d\n", student.age);
    test(student);
    printf("main 修改后的值:%d\n", student.age);
    return 0;
}

output

main 修改前的值:30
test 修改前的值:30
test 修改后的值:10
main 修改后的值:30

可以看到仅改变了形参，实际值没有改变，传结构体指针就没问题（见下节）

#include <stdio.h>

struct Student{
    int age;
};

void test(struct Student* stu){
    printf("test 修改前的值:%d\n", stu->age);
    stu->age = 10;
    printf("test 修改后的值:%d\n", stu->age);
}

int main()
{
    struct Student student;
    student.age = 30;
    printf("main 修改前的值:%d\n", student.age);
    test(&student);
    printf("main 修改后的值:%d\n", student.age);
    return 0;
}

output

main 修改前的值:30
test 修改前的值:30
test 修改后的值:10
main 修改后的值:10

6 指向结构的指针

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

struct Student{
    char name[20];
    int age;
};


int main()
{
    struct Student student;
    
    student.age = 20;
    strcpy(student.name, "Bryant");
    
    printf("name: %s, age: %d\n", student.name, student.age);

    struct Student *p = &student;
    printf("name: %s, age: %d\n", p->name, p->age);
    printf("name: %s, age: %d\n", (*p).name, (*p).age);
   
    return 0;
}

output

name: Bryant, age: 20
name: Bryant, age: 20
name: Bryant, age: 20

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );

   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );

   return 0;
}
void printBook( struct Books *book )
{
   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

output

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

7 结构体数组

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

struct Person {
    char name[20];
    int age;
    float height;
}person[3]={{"Bryant", 19, 178}, {"Chole", 18, 167}};


int main() {
    for(int i=0; i<2; i++)
        printf("name:%s, age:%d, height:%f\n", person[i].name, 
        person[i].age, person[i].height);
    return 0;
}

output

name:Bryant, age:19, height:178.000000
name:Chole, age:18, height:167.000000

8 动态申请结构体

结构体也可以在堆里面动态申请

#include <stdio.h>
...
int main(void)
{
    struct Info *i1;
    struct Info *i2;
    
    i1 = (struct Info *)malloc(sizeof(struct Info));
    i2 = (struct Info *)malloc(sizeof(struct Info));
    if (i1 == NULL || i2 == NULL)
    {
        printf("内存分配失败！\n");
        exit(1);
    }
    
    printf("请录入第一个同学的信息...\n");
    getInput(i1);
    putchar('\n');
    printf("请录入第二个学生的信息...\n");
    getInput(i2);

    printf("\n录入完毕，现在开始打印...\n\n");
    printf("打印第一个学生的信息...\n");
    printInfo(i1);
    putchar('\n');
    printf("打印第二个学生的信息...\n");
    printInfo(i2);
    
    free(i1);
    free(i2);
    
    return 0;
}

原文地址：https://blog.csdn.net/bryant_meng/article/details/140202728

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 找单词(200分) - 三语言AC题解(Python/Java/Cpp)
下一篇：实施团队人员配备计划

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

【C】Structure

文章目录

1 定义

2 初始化

3 结构体大小的计算

4 访问结构成员

5 结构作为函数参数

6 指向结构的指针

7 结构体数组

8 动态申请结构体

相关文章