精华内容
下载资源
问答
  • 结构体指针偏移
    2019-12-05 13:17:25

    笔试题2

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    //笔试题2
    //由于还没学习结构体,这里告知结构体的大小是20个字节
    struct Test
    {
    	int Num;
    	char* pcName;
    	short sDate;
    	char cha[2];
    	short sBa[4];
    }*p;
    //假设p 的值为0x100000。 如下表表达式的值分别为多少?
    int main()
    {
    	printf("%p\n", p + 0x1);  //p + 20 = 0x100014
    	printf("%p\n", (unsigned long)p + 0x1);  //0x100001
    		printf("%p\n", (unsigned int*)p + 0x1);  //0x100004
    	return 0;
    }
    
    • p + 0x1
      p是结构体指针
      十六进制下0x1就是1
      结构指针+1偏移量就是整个结构体的大小
      结构体大小(结构体大小的计算请观看: )是20所以p的地址向后走20个字节 --> p+20
      地址都是用16进制表示的  
      p = 0x100000
      p + 20 = 0x100014

    • (unsigned long)p + 0x1
      将p地址强转成一个宽类型的数,然后加1,指针就往后偏移一个字节于是
      p = 0x100000
      p + 1 = 0x100001

    • (unsigned int*)p + 0x1
      将p地址强转成一个无符号整形指针,然后再加1,指针就往后偏移无符号整形类型字节大小
      p = 0x100000
      p + 4 = 0x100004

    更多相关内容
  • c语言结构体偏移 示例1 我们先来定义一下需求: 已知结构体类型定义如下: struct node_t{ char a; int b; int c; }; 且结构体1Byte对齐 #pragma pack(1) 求: 结构体struct node_t中成员变量c的偏移。 注:...
  • 一、指针运算 与 指针内存操作、 二、结构体偏移量计算





    一、指针运算 与 指针内存操作



    指针变量算术运算 ( 指针可以是任意值 ) : 指针 是一个变量 , 如果对指针进行 算术 / 逻辑 等运算 , 其效果等同于 对 int 整型变量 进行 算术运算 , 编译运行 并不会报错 ;

    char *p = NULL;
    
    // 下面的操作 编译 运行 都可以通过
    p + 1;
    p - 1;
    p * 20;
    

    指针进行内存操作 ( 指针必须合法 ) : 但是注意 , 如果要 对 指针 进行内存操作 , 如使用 * 获取指针指向的数据 , 或者使用 memset 修改指针指向的数据 , 或者 free 释放指针 , 要操作的 指针变量 , 必须是 合法的指针 ;

    char *p = NULL;
    
    // 下面的操作 涉及使用指针进行内存操作 , 编译通过 , 运行时报错
    *p;
    free(p);
    




    二、结构体偏移量计算



    定义结构体 :

    /**
     * @brief The Student struct
     * 定义 结构体 数据类型 , 同时为该结构体类型声明 别名
     * 可以直接使用 别名 结构体变量名 声明结构体类型变量
     * 不需要在前面添加 struct 关键字
     */
    typedef struct Student
    {
        // 声明变量时 , 会自动分配这 5 字节内存
        // 赋值时 , 可以直接使用 = 赋值字符串
        char name[5];	// 0 ~ 4 字节
        int age;		// 5 ~ 8 字节
    
        // 声明变量时 , 只会为 4 字节指针分配内存
        // 具体的 字符串内存 需要额外使用 malloc 申请内存
        // 赋值时 , 必须使用 strcpy 函数 , 向堆内存赋值
        char *address; // 9 ~ 12 字节
    }Student;
    

    求上述 Student 结构体的 age 成员的偏移量 ;

    0 地址 , 按照 Student 结构体 内存 形式进行解释 , 即将 0 地址指针 强转为 Student * 类型 ;

    (Student *)0
    

    然后取上述 Student * 指针类型的 age 成员 ;

    ((Student *)0)->age
    

    获取上述 age 成员的地址 ;

    &(((Student *)0)->age)
    

    age 成员的地址转为 int 类型 ;

    (int)&(((Student *)0)->age)
    

    上述获取的就是 Student 结构体中 , age 成员的偏移量 ;

    展开全文
  • 一、结构体变量的定义与使用 1.先声明结构体类型再定义变量名 #define _CRT_SECURE_NO_WARNINGS #include <string.h> #include <stdio.h> struct student { char name[21]; int age; char address...

    目录

    一、结构体变量的定义与使用

    1.先声明结构体类型再定义变量名

    2.在声明类型的同时定义变量

    3.直接定义结构体类型变量(无类型名)

    二、结构体偏移对齐

    三、结构体指针

    1.普通成员

    2.指针成员

    3.结构体指针

    四、结构体作为函数参数


    一、结构体变量的定义与使用

    1.先声明结构体类型再定义变量名

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    struct student {
        char name[21];
        int age;
        char address[51];
    };
    void main()
    {
        struct student stu;
        //stu.name = "张三";//错误,stu.name是数组名,是个常量
        strcpy(stu.name, "张三");
        stu.age = 18;
        strcpy(stu.address, "北京市朝阳区");
        printf("name:%s\n", stu.name);
        printf("age:%d\n", stu.age);
        printf("address:%s\n", stu.address);
    
        struct student stu1 = { "李四",18,"北京市海淀区" };
        printf("name:%s\n", stu1.name);
        printf("age:%d\n", stu1.age);
        printf("address:%s\n", stu1.address);
    }

    2.在声明类型的同时定义变量

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    
    struct student {
        char name[21];
        int age;
        char address[51];
    } stu;
    
    void main()
    {
        //stu.name = "张三";//错误,stu.name是数组名,是个常量
        strcpy(stu.name, "张三");
        stu.age = 18;
        strcpy(stu.address, "北京市朝阳区");
    
        printf("name:%s\n", stu.name);
        printf("age:%d\n", stu.age);
        printf("address:%s\n", stu.address);
    
    }

    3.直接定义结构体类型变量(无类型名)

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    
    struct {
        char name[21];
        int age;
        char address[51];
    }stu;
    
    void main()
    {
        //stu.name = "张三";//错误,stu.name是数组名,是个常量
        strcpy(stu.name, "张三");
        stu.age = 18;
        strcpy(stu.address, "北京市朝阳区");
    
        printf("name:%s\n", stu.name);
        printf("age:%d\n", stu.age);
        printf("address:%s\n", stu.address);
    }

    二、结构体偏移对齐

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    
    struct student {
        char name[21];
        int age;
        char address[51];
    };
    
    void main()
    {
        struct student stu[3] = {
             {"张三",20,"北京昌平"},
             {"李四",22,"北京朝阳"},
             {"王五",19,"北京海淀"}
        };
        printf("结构体数组字节大小%d\n", sizeof(stu));//240
        printf("结构体字节大小%d\n", sizeof(stu[0]));//80
        printf("结构体字节大小%d\n", sizeof(struct student));//80
        printf("结构体元素个数%d\n", sizeof(stu) / sizeof(struct student));//3
    }

    student 结构体字节大小并不是21+4+51=76,而是21+2+4+51+2=80。

    结构体中元素是按照定义顺序一个一个放到内存中去的,但并不是紧密排列的。从结构体存储的首地址开始,每个元素放置到内存中时,它都会认为内存是按照自己的大小来划分的,因此元素放置的位置一定会在自己宽度的整数倍上开始

    结构体总大小为最大类型所占字节数的整数倍

    name[21]占21个字节;下一个位置为22

    age为int类型,占4字节,但是第22位不是4的整数倍,第24位才是,所以偏移2位后存age;下一个位置为28

    address[51],类型为char,char占1个字节,第28位是char的整数倍,一共占51个字节;此时总大小为78,但78不是最大类型int 所占字节数4的整数倍,所以student 结构体字节大小为80.

    【举个例子】下方student结构体字节大小为76,不需要进行偏移。

    struct student {
        char name[21];
        char address[51];
        int age;
    };

    三、结构体指针

    1.普通成员

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    struct student {
        char name[21];
        int age;
        char address[51];
    };
    void main()
    {
        struct student stu1 = { "张三",20,"北京昌平" };
        struct student stu2 = stu1;
        strcpy(stu2.name, "李四");
        printf("%s\n", stu1.name);//张三
    }

    2.指针成员

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    struct student {
        char* name;
        int age;
        char* address;
    };
    void main()
    {
        struct student stu1 = { "张三",20,"北京昌平" };
        struct student stu2;
        //strcpy(stu2.name, "小三");//报错,使用了未初始化的局部变量stu2
    
        stu2.name = "李四";//正确
    
        stu2.name = (char*)malloc(sizeof(char) * 21);
        strcpy(stu2.name, "李四");//正确
    
        stu2.age = 30;
    
        stu2.address = "北京海淀";//正确
    
        stu2.address = (char*)malloc(sizeof(char) * 51);
        strcpy(stu2.address, "北京海淀");//正确
    
        printf("%s\n", stu2.address);//张三
    }

    3.结构体指针

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    struct student {
        char* name;
        int age;
        char* address;
    };
        struct student stu = { "张三",20,"北京昌平" };
        struct student* p = &stu;
    void main()
    {
        struct student* stu = (struct student*)malloc(sizeof(struct student) * 3);
        for (size_t i = 0; i < 3; i++)
        {
            stu[i].name = (char*)malloc(sizeof(char) * 21);
            stu[i].address = (char*)malloc(sizeof(char) * 51);
            scanf("%s%d%s", stu[i].name, &stu[i].age, stu[i].address);
        }
        for (size_t i = 0; i < 3; i++)
        {
            printf("%s ", stu[i].name);
            printf("%d ", stu[i].age);
            printf("%s\n", stu[i].address);
        }
    }
    void main()
    {
        struct student stu1 = { "张三",20,"北京昌平" };
        struct student* stu2 = &stu1;
        stu2->name= "李四";
        printf("%s\n", stu1.name);//李四
    }

    四、结构体作为函数参数

    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    struct student {
        char* name;
        int age;
        char* address;
    };
    void GetStudent(struct student stu)
    {
        stu.name = "Lisa";
        stu.age = 29;
        stu.address = "another nation";
        printf("%s's age is %d,she is from %s\n", stu.name, stu.age, stu.address);//Lisa's age is 29,she is from another nation
    }
    void main()
    {
        struct student stu = {"Lin",22,"China"};
        printf("%s's age is %d,she is from %s\n", stu.name, stu.age, stu.address);//Lin's age is 22,she is from China
        GetStudent(stu);
        printf("%s's age is %d,she is from %s\n", stu.name, stu.age, stu.address);//Lin's age is 22,she is from China
    }
    #define _CRT_SECURE_NO_WARNINGS
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    struct student {
        char* name;
        int age;
        char* address;
    };
    void GetStudent(struct student* stu)
    {
        //(*stu).name = "Lisa";
        stu->name = "Lisa";
        stu->age = 29;
        stu->address = "another nation";
        printf("%s's age is %d,she is from %s\n", stu->name, stu->age, stu->address);//Lisa's age is 29,she is from another nation
    }
    void main()
    {
        struct student stu = {"Lin",22,"China"};
        printf("%s's age is %d,she is from %s\n", stu.name, stu.age, stu.address);//Lin's age is 22,she is from China
        GetStudent(&stu);
        printf("%s's age is %d,she is from %s\n", stu.name, stu.age, stu.address);//Lisa's age is 29,she is from another nation
    }

     

    展开全文
  • 文章目录1 不同类型指针的步长2 结构体成员偏移量 1 不同类型指针的步长 (1)不同类型的指针 +1 时,内存偏移的字节数不同。 char *类型指针 + 1,内存偏移 1 字节; int *类型指针 + 1,内存偏移 4 字节; ...


    1 不同类型指针的偏移步长

    (1)不同类型的指针 +1 时,内存偏移的字节数不同。

    char *类型指针 + 1,内存偏移 1 字节;
    int *类型指针 + 1,内存偏移 4 字节;
    double *类型指针 + 1,内存偏移 8 字节。

    示例:

    #include <stdio.h>
    
    //1.不同类型的指针+1时,偏移的字节数不同
    void func1() {
    	char* p = NULL;
    	printf("%p\n", p);		//00000000
    	printf("%p\n", p + 1);	//00000001
    
    	int* pp = NULL;
    	printf("%p\n", pp);		//00000000
    	printf("%p\n", pp + 1);	//00000004
    }
    

    (2)对不同类型的指针解引用时,取出的字节数不同

    示例:

    #include <stdio.h>
    #include <string.h>
    
    //2.对不同类型的指针解引用时,取出的字节数不同
    void func2() {
    	char buff[1024] = { 0 };
    	int num = 1234;
    	//memset(buff, 0, sizeof(buff));
    	memcpy(buff, &num, sizeof(num));
    	
    	char* p = buff;
    	//将char*指针强转为int*类型指针后,再解引用
    	printf("%d\n", *(int *)p);	//1234
    }
    
    //3.对不同类型的指针解引用时,取出的字节数不同
    void func3() {
    	char buff[1024] = { 0 };
    	int num = 1234;
    	//memset(buff, 0, sizeof(buff));
    	memcpy(buff + 1, &num, sizeof(num));
    
    	char* p = buff;
    	//将char*指针强转为int*类型指针后,再解引用
    	printf("%d\n", *(int*)(p + 1));	//1234
    }
    

    2 结构体成员的偏移量

    头文件<stddef.h>定义了标准宏
    offsetof()宏可计算结构体成员的偏移量offsetof(结构体类型名 , 结构体成员名)
    例:offsetof(struct Object, field);

    示例:

    #include <stdio.h>
    #include <stddef.h>		//使用标准宏
    
    //结构体内存对齐(按数据类型长度最大的对齐-double 8字节对齐)
    struct Object {
    	char a;			//0 ~ 3
    	int b;			//4 ~ 7
    	char buff[64];	//8 ~ 71
    	double c;		//72 ~ 79
    };
    
    int main() {
    	struct Object obj = { 'a', 1, "hello world", 3.14 };
    	/*
    		offsetof()宏可计算结构体成员的偏移量(需包含<stddef.h>头文件)
    		offsetof(结构体类型名 , 结构体成员名)
    	*/
    	printf("%d\n", offsetof(struct Object, a));		//0
    	printf("%d\n", offsetof(struct Object, b));		//4
    	printf("%d\n", offsetof(struct Object, buff));	//8
    	printf("%d\n", offsetof(struct Object, c));		//72
    
    	/* 
    		通过结构体成员的指针偏移,可访问各个结构体成员
    		将指向结构体的指针强转为(char *)类型,每次指针偏移的步长为1
    	*/
    	struct Object* p = &obj;
    	//char*类型的起始地址,加上结构体成员的偏移量,再强转为指定结构体成员对应的指针类型,解引用获取指定结构体成员的值
    	printf("%c\n", *( (char*)p + offsetof(Object, a) ));			//a (ASCII码 97)
    	printf("%d\n", *(int *)( (char*)p + offsetof(Object, b) ));		//1
    	//打印输出字符串类型时,无需解引用,使用字符串的首地址即可(默认至'\0'结束)
    	printf("%s\n", ( (char*)p + offsetof(Object, buff) ));			//hello world
    	printf("%lf\n", *(double *)( (char*)p + offsetof(Object, c) ));	//3.140000
    
    	//通过结构体成员的偏移地址,解引用并修改对应结构体成员的值
    	*(double *)((char*)p + offsetof(struct Object, c)) = 3.1415926;	//修改结构体成员c的值
    	printf("%lf\n", *(double *)((char*)p + offsetof(Object, c)));	//3.141593
    
    	return 0;
    }
    

    3 嵌套结构体成员的偏移量

    #include <stdio.h>
    #include <stddef.h>
    
    struct Inner {
        char a;
        int b;
    };
    
    struct Outer {
        char c;
        int d;
        struct Inner inner;
    };
    
    int main() {
        struct Outer outer = { 'a', 1, {'b', 2} };
    
        /* 获取Outer结构体中嵌套的Inner结构体成员b */
        //1.通过结构体变量访问
        printf("%d\n", outer.inner.b);  //2
    
        //2.通过2次指针偏移:
        //(1)先获取嵌套结构体成员inner相对outer的偏移
        int offset1 = offsetof(struct Outer, inner);
        //(2)再获取属性b相对结构体inner的偏移
        int offset2 = offsetof(struct Inner, b);
        printf("%d\n", *(int*)((char*)&outer + offset1 + offset2));     //2
    
        //3.通过1次指针偏移,获取指向嵌套结构体inner的指针,通过结构体指针访问成员
        printf("%d\n", ((struct Inner*)((char*)&outer + offset1))->b);  //2
    
        return 0;
    }
    

    4 结构体的内存对齐

    4.1 内存对齐的原因与优点

    内存未对齐的问题:CPU按块读取内存,当CPU访问数据时,若内存未对齐,则可能导致二次访问的情况,即前后两次访问的数据需拼接后才能获取指定数据。

    内存对齐的优点以空间换时间,浪费部分用于对齐的空间,通过一次访问即可获取指定数据。


    4.2 结构体内存对齐的规则

    (1)内置数据类型:数据存储在该类型大小的整数倍上。

    (2)自定义数据类型:依照特定的对齐规则。
    ①从第1个属性开始,从 偏移量0位置 开始存储;
    ②从第2个属性开始,从 该数据类型大小对齐模数较小值的整数倍开始存储。即min {该数据类型大小 , 对齐模数} 的整数倍
    ③整体计算完毕后进行二次对齐,结构体的总大小必须是 该结构体中最大数据类型对齐模数较小值的整数倍不足需补齐。即min {该结构体中最大数据类型 , 对齐模数} 的整数倍

    注:使用#pragma pack(show)生成代码后查看”杂注”即默认对齐模数。默认对齐模数为8。
    例:pragma pack(show) 的值 == 8

    示例1:按默认对齐模数(8)对齐

    #include <stdio.h>
    //#pragma pack(show)	//对齐模数默认为8	//生成后查看
    
    typedef struct {
    	int a;		//0 ~ 3
    	char b;		//4 → 4 ~ 7				//double对齐后,补为4 ~ 7
    	double c;	//8 ~ 15
    	float d;	//16 ~ 19 → 16 ~ 23		//二次对齐,补为16 ~ 23
    } StructA;
    
    int main() {
    	printf("%d\n", sizeof(StructA));	//24
    
    	return 0;
    }
    

    示例2:按指定对齐模数(1)对齐

    #include <stdio.h>
    #pragma pack(1)	//对齐模数为1
    
    typedef struct {
    	int a;		//0 ~ 3
    	char b;		//4			//对齐模数为1,无需补齐
    	double c;	//5 ~ 12
    	float d;	//13 ~ 16	//二次对齐,对齐模数为1,无需补齐
    } StructB;
    
    int main() {
    	printf("%d\n", sizeof(StructB));	//17
    
    	return 0;
    }
    

    4.3 结构体嵌套结构体时的对齐规则

    ①从第1个属性开始,从 偏移量0位置 开始存储;
    ②从第2个属性开始的非嵌套结构体属性,从 该数据类型大小对齐模数较小值的整数倍开始存储。即min {该数据类型大小 , 对齐模数} 的整数倍
    ③从第2个属性开始的嵌套结构体属性,从 该嵌套结构体中最大数据类型对齐模数较小值的整数倍开始存储。即min {该嵌套结构体中最大数据类型 , 对齐模数} 的整数倍
    ④整体计算完毕后进行二次对齐,结构体的总大小必须是 该结构体中最大数据类型对齐模数较小值的整数倍不足需补齐。即min {该结构体中最大数据类型 , 对齐模数} 的整数倍

    示例:结构体嵌套结构体时,按默认对齐模数(8)对齐

    #include <stdio.h>
    #include <stddef.h>
    
    //默认对齐模数为8
    typedef struct {
    	int a;		//0 ~ 3
    	char b;		//4 → 4 ~ 7				//double对齐后,补为4 ~ 7
    	double c;	//8 ~ 15
    	float d;	//16 ~ 19 → 16 ~ 23		//二次对齐,补为16 ~ 23
    } Inner;		//对齐模数为8时,二次对齐后,Inner结构体的大小为24
    
    typedef struct {
    	int x;		 //0 ~ 3
    	char y;		 //4 → 4 ~ 7  //嵌套结构体inner对齐后,补为4 ~ 7
    	Inner inner; //8 ~ 31	  //按嵌套结构体inner的最大数据类型(8)和对齐模数 对齐
    	float z;	 //32 ~ 35 → 32 ~ 39	//二次对齐,补为32 ~ 39
    } Outer;		 //对齐模数为8时,二次对齐后,Outer结构体的大小为40
    
    
    int main() {
    	printf("内层结构体大小:%d\n", sizeof(Inner));	//24
    	printf("外层结构体大小:%d\n", sizeof(Outer));	//40
    
    	printf("属性x的偏移:%d\n", offsetof(Outer , x));			//0
    	printf("属性y的偏移:%d\n", offsetof(Outer , y));			//4
    	printf("属性inner的偏移:%d\n", offsetof(Outer , inner));	//8
    	printf("属性z的偏移:%d\n", offsetof(Outer , z));			//32
    
    	return 0;
    }
    
    展开全文
  • C语言:结构体指针

    2021-03-28 03:10:00
    使用结构体指针注意点: 1.如果用结构体指针,就不能用(点运算符)访问结构体中的变量,要用-> 比如:stu.score = 50;...3.如果结构体指针发生偏移。则是偏移整个结构体的大小。 struct Student...
  • 一、结构体成员偏移量、 二、完整代码示例
  • 结构体指针偏移

    千次阅读 2017-01-04 23:03:47
    刚开始工作,接触到大量的结构体指针代码,指针基础不好,遂写了些测试代码,总算搞明白了刚开始工作,接触到大量的结构体指针代码,指针基础不好,遂写了些测试代码,总算搞明白了 #include #include #include ...
  • 结构体中的结构体指针是使用一、问题背景二、代码三、说明 一、问题背景   日常工作中没有编程的机会,所以只看得懂代码,现在需要重新写一段代码,实现固定格式存储数据,需要使用到结构体和结构体指针。数据...
  • 计算结构体偏移

    2021-09-30 10:24:04
    C 库宏offsetof(type, member-designator)会生成一个类型为size_t的整型常量,它是一个结构成员相对于结构开头的字节偏移量。成员是由 member-designator 给定的,结构的名称是在 type 中给定的。 下面是 offsetof...
  • c语言——结构体偏移

    千次阅读 2020-05-18 17:26:59
    目录c语言——结构体偏移整数类型浮点类型例子结构体成员偏移量test01test02test03参考资料 c语言——结构体偏移 学习结构体偏移前,我们先复习一下c语言的数据类型 整数类型 下表列出了关于标准整数类型的存储大小...
  • Delphi 中的结构体与结构体指针 好多程序都给结构体变量设定了一个结构体指针 例如: PAbc = ^TAbc; TAbc = record a: string[10]; b: string[5]; c: string[1]; end; var Abc: PAbc; New(Abc); … Dispose(Abc); …...
  • 结构体指针赋值

    万次阅读 2017-02-17 15:10:02
    //方法1:可以给p分配一段内存空间,并使其指向此空间: #include main() { struct abc{ int a;}; struct abc *p; p=(struct abc *)malloc(sizeof(struct abc)...//方法2:可以让p指向一个已存在的内存空间:#i
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    c语言中交换两个结构体的值(结构体指针) 1关于语言的结构体: 首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活...
  • 1、结构体偏移量和大小计算: https://www.cnblogs.com/qiumingcheng/p/11370836.html 2、结构体的初始化: https://www.cnblogs.com/lvmf/p/10927446.html 3、memset函数用法: ... ...
  • 在linux下进行C编程,有时候会绵连结构体的大小问题。结构体大小并不等于其内部所有成员大小之和,这个主要是由于结构体需要...所有如果想在程序中基于偏移量来获取结构体成员的值时,靠人工计算该成员相对于结构体首地
  • ↑上面答案改一下,在64位下运行,所以结构体大小是32 初始值一样,都是p=0x...所以一开始的时候,结构体大小是32,所以偏移32个单位,因为结构体也和int ,short等一样,是一种数据类型,即char的时候偏移1个..
  • c语言取结构体偏移
  • C语言结构体指针强转

    千次阅读 2022-02-07 14:25:05
    结构体指针强转2.结构体指针强转在链表中的使用3. 1.结构体指针强转 C语言中结构体无法进行强转,但是结构体指针是可以进行间接强转的 eg: 先定义4个结构体 typedef struct { int array[4]; }Struct_A; typedef...
  • 个人博客 所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。...我在做嵌入式工作时,在已知要获取信息的 flash 地址时,需要取出相对应的信息元素,这个时候时常需要知道结构体相对于已知地址的偏移,方便快.
  • c中结构体指针的强制类型转换

    千次阅读 2021-05-22 09:22:12
    1、结构体到结构体指针之间的转换a、结构体指针的强制类型转换即结构体的数据成员在内存段当中的重新分配,结构体的存储“内存对齐”请参看上篇博客,该论述实例如下:#include #include struct A{int num;...
  • 结构体指针,内容偏移

    千次阅读 2014-10-30 12:22:11
    结构体指针,默认hui'yi
  • 假设有如下一个结构体,要计算成员在结构体中的偏移量。 typedef struct { char a; char b; long c; }TEST_T; 定义一个宏计算结构体的成员偏移量 #define OFFSET(TYPE,MEMBER) ((unsigned long)(&(((TYPE*)0...
  • c语言 得到结构体成员偏移

    千次阅读 2020-03-20 22:14:26
    最直观的想法就是用结构体中成员的地址减去结构体的首地址,需要注意的是要把指 针的类型转换为char *,即单字节长度类型的指针。代码如下: struct stru { char c; int i; }; printf("Offset of stru.i: %ld\n...
  • c\c++:浅论指针偏移量的运用

    千次阅读 2019-03-27 20:47:19
    假设出现一种情况,我们需要从在派生类中需要访问一次基类中的某个私有成员,且该基类中没用任何方法可访问私有成员(如果有那不如直接using为成protected),这个时候就可以使用指针偏移量强制访问. 比如以下代码 ...
  • 文章目录一、结构体基本使用二、结构体常见赋值问题及解决三、结构体与一级指针嵌套四、结构体与二级指针嵌套五、结构体偏移量六、内存对齐问题 一、结构体基本使用 基本规则与使用方法: 1.正常结构体定义时不能赋...
  • 在使用C语言对STM32编程的过程中,经常使用到结构体,本文介绍了一种得到结构体中一个field的偏移量的方法。
  • 利用宏获取结构体成员偏移
  • 结构体与结构体指针

    2022-03-22 15:03:02
    小白快速理解结构体和结构体指针,大神强化

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,609
精华内容 19,043
关键字:

结构体指针偏移