精华内容
下载资源
问答
  • C语言自定义类型

    2020-08-01 09:15:42
    C语言自定义类型 结构体 结构体类型的声明 结构是一些值的集合,这些值称为成员变量,结构的每个成员可以是不同类型的变量。 struct tag { member-list; }variable-list; struct tag x; 也可以通过typedef对类型...

    C语言自定义类型

    结构体

    结构体类型的声明

    结构是一些值的集合,这些值称为成员变量,结构的每个成员可以是不同类型的变量。

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

    也可以通过typedef对类型重命名

    typedef struct Student
    {
    	char name[20];
    	int age;
    	char sex[6];
    } Student;
    // 这里的Student不是变量名,而是类型名
    
    Student x;
    

    对结构体类型的变量进行初始化

    Student x = {"zhangsan", 20, "male"};
    printf("%s %d %s", x.name, x.age, x.sex);
    // 结构体成员的访问使用 . 
    
    // 匿名结构体类型
    struct
    {
    	char name[20];
    	int age;
    	char sex[6];
    } Student;
    

    关于匿名结构体类型,有一个需要注意的点

    struct
    {
    	char name[20];
    	int age;
    	char sex[6];
    } Student;
    
    struct
    {
    	char name[20];
    	int age;
    	char sex[6];
    } *p;
    
    p = &Student;
    

    虽然两个结构体内容一样,等号两边都是指针类型,但是编译器编译时会将两个结构体当成不同的类型处理,所以尽量不要出现这样的写法。

    结构体传参

    struct S
    {
    	char data[1000];
    	int n;
    };
    
    void Print1(struct S ss)
    {
    	printf("%s %d\n", ss.data, ss.n);
    }
    
    void Print1(struct S* ps)
    {
    	printf("%s %d\n", ss->data, ss->n);
    }
    
    int main()
    {
    	struct S s = {"xxxxxxxxxxx", 10};
    	Print1(s);
    	Print2(&s);
    	return 0;
    }
    

    上述代码中,Print1 函数传参时传入的是结构体变量,而 Print2 函数传参时传递的是结构体变量的地址,二者除了成员变量的访问方式不同外,还要注意一点,实参传递给形参时,形参相当于实参的一份临时拷贝,如果某结构体类型变量占用的内存空间很大,在传参时需要临时开辟同样大小的内存空间,消耗内存,效率会低一些,而使用指针传递参数时,会降低内存消耗和拷贝内容耗费的时间。所以结构体传参时,要传结构体的地址。 (函数传参的时候,参数是需要压栈的,如果传递一个结构体对象的时候,结构体过大,参数压栈的系统开销比较大,所以会导致性能的下降)。

    结构体自引用

    在结构体中包含一个类型为该结构体本身的成员,这样可以么?

    struct Node
    {
    	int data;
    	struct Node next;
    };
    

    上述的写法是错误的,因为当使用struct Node创建一个变量时需要开辟相应大小的内存空间,其中包含的结构体类型成员变量同样需要开辟空间,这就无法计算最初的结构体变量开辟的实际内存空间大小,从而导致错误。
    所以如果想在结构体中包含有关自身的信息,需要正确的使用结构体自引用,如下:

    struct Node
    {
    	int data;
    	struct Node* next;
    };
    

    以上代码是可行的,但对于重命名的结构体如何进行自引用呢?

    typedef struct Node
    {
    	int data;
    	Node* next;
    }Node;
    // 错误,在类型重命名的过程中使用了将要重新定义的名字
    // 必须写成以下形式
    typedef struct Node
    {
    	int data;
    	struct Node* next;
    }Node;
    

    结构体内存对齐

    计算结构体大小。

    struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };
    
    printf("%d\n", sizeof(struct S1));
    // 12
    
    struct S2
    {
    	char c1;
    	char c2;
    	int i;
    };
    
    printf("%d\n", sizeof(struct S2));
    // 8
    

    结构体对齐规则:
    1、第一个成员放在结构体起始位置偏移量为0的地址处;
    2、其他成员变量要对齐到对齐数的整数倍的地址处,对齐数 = 编译器默认的一个对齐数与该成员大小的较小值;
    3、结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍;
    4、如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小为所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

    为什么存在内存对齐?
    1、平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。
    2、性能原因:数据结构(尤其是栈)应该尽可能的在自然边界上对齐,原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。

    结构体的内存对齐是拿空间来换取时间的做法。如果想在设计结构体时,既要满足对齐,又要节省空间,可以让占用空间小的成员变量尽量集中在一起。

    在结构体对齐规则中提到了成员变量相对于结构体起始位置的偏移量,偏移量可以通过C库宏offsetof来查看,其原型为size_t offsetof(structName, memberName);包含在stddef.h头文件中,该宏返回的是一个成员变量相对其结构开始位置的偏移量。

    #define offsetof(s,m) (size_t)&(((s*)0)->m)
    

    分析一下该语句,当在程序中使用offsetof时,例如offsetof(struct S, c),其中 struct S 是一个结构体,c 是该结构体中的一个成员变量,此时会被替换为(size_t)&(((struct S*)0)->c)(struct S*)00强制类型转换为结构体指针,对应该结构体的起始位置,->c指向成员变量c&(((struct S*)0)->c)此时得到的就是c变量相对于结构体起始位置地址0的地址(偏移量),将该地址(size_t)强制类型转换就可以得到该变量的偏移量。

    修改默认对齐数

    通过#pragma这个预处理指令,可以改变默认对齐数。

    #pragma pack(8)  // 设置默认对齐数为8
    struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };
    #pragma pack()  // 取消设置的默认对齐数,还原为默认,此时只有该结构体的对齐数被修改
    

    位段

    1、位段的成员必须是 int、unsigned int、signed int
    2、位段的成员名后边有一个冒号和一个数字。

    struct A
    {
    	int _a:2;  // _a 变量仅占2个bit
    	int _b:5;
    	int _c:10;
    	int _d:30;
    };
    

    此时printf("%d\n", sizeof(struct A));打印的结果为8,这是因为使用位段时,先开辟4个字节进行使用,当4个字节内容空间填满后,再申请下一个4字节空间,以此类推。

    位段的内存分配:
    1、位段的成员可以是 int、unsigned int、signed int 或者是 char (属于整型家族)类型;
    2、位段的空间上是按照需要以4个字节(int)或者1个字节(char)的方式来开辟的;
    3、位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。
    在这里插入图片描述
    位段的跨平台问题:
    1、int 位段被当成有符号数还是无符号数是不确定的;
    2、位段中最大位的数目不能确定(16位机器最大16,32位机器最大32,写成27在16位机上会出错);
    3、位段中的成员在内存中从左到右分配还是从右到左分配标准尚未定义;
    4、当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确定的。

    枚举

    枚举顾名思义就是一一列举,将可能的取值一一列举出来。

    enum Weekday
    {
    	Mon, // 默认为0
    	Tue,  // 1
    	Wed,  // 2
    	Thur,  // 3
    	Fri  // 4
    };
    
    enum Day day = Mon;  // 给变量赋值时,只能选择枚举类型中可能的取值
    // 枚举类型创建了,就尽量使用枚举类型的可能取值进行赋值,不建议直接使用数字进行赋值
    
    // 定义的时候也可以赋初值
    enum Weekday
    {
    	Mon = 1, 
    	Tue = 2,
    	Wed = 3,
    	Thur = 4,
    	Fri = 5
    };
    

    枚举的优点:
    1、增加代码的可读性和可维护性;
    2、和#define定义的标识符比较枚举有类型检查,更加严谨;
    3、防止了命名污染;
    4、便于调试;
    5、使用方便,一次可以定义多个变量。

    联合(共用体)

    联合也是一种特殊的自定义类型,这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块儿空间。

    union Un
    {
    	char c;
    	int i;
    };
    
    int main()
    {
    	union Un u = {0};
    	u.i = 0x11223344;
    	u.c = 0x55;
    	return 0;
    }
    
    // 面试题
    // 判断当前计算机的大小端存储
    
    // 方法1
    int check_sys()
    {
    	int a = 1;
    	return *(char*)&a;
    	//if(1 == *(char*)&a)
    	//	return 1;
    	//else
    	//	return 0;
    }	
    
    // 方法2
    int check_sys()
    {
    	union Un
    	{
    		int i;
    		char c;
    	}u;
    	u.i = 1;
    	return u.c;
    }
    
    int main()
    {
    	int ret = check_sys();
    	if(ret == 1)
    		printf("xiaoduan\n");
    	else
    		printf("daduan\n");
    	return 0;
    }
    

    联合大小的计算

    联合的大小至少是最大成员的大小,当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍。例如:

    union Un
    {
    	char c[5];
    	int i;
    };
    // 该联合的大小为8
    
    展开全文
  • c语言自定义类型知识总结 1.结构体类型创建 在创建结构体时根据实际情况在结构体中添加应有的元素。结构体在声明的时候,前面必须添加struct关键字。 例如: struct PersonInfo{ char name[1024]; char sex[1024]; ...

    c语言自定义类型知识总结

    1.结构体类型创建
    在创建结构体时根据实际情况在结构体中添加应有的元素。结构体在声明的时候,前面必须添加struct关键字。
    例如:
    struct PersonInfo{
    char name[1024];
    char sex[1024];
    int age;
    char phone[1024];
    char address[1024];
    };
    定义变量: struct PersonInfo person;
    也可以直接在结构体后面定义:
    struct PersonInfo{
    char name[1024];
    char sex[1024];
    int age;
    char phone[1024];
    char address[1024];
    }person;
    如果程序中多次使用到结构体,且其名字比较长,可以使用下述做法:
    typedef struct PersonInfo{
    char name[1024];
    char sex[1024];
    int age;
    char phone[1024];
    //char company[1024];
    char address[1024];
    }PersonInfo;
    使用PersonInfo代替结构体的名字,在定义变量时,变量的类型直接写PersonInfo就可以了。
    2.结构体的初始化
    结构体的初始化是在定义变量的同时初始化,比如:
    struct Stu //类型声明
    {
    char name[15];//名字
    int age; //年龄
    };
    struct Stu s = {“zhangsan”, 20};//初始化
    3.结构体内存对齐
    结构体内存对齐规则:
    首先得掌握结构体的对齐规则:
    (1)第一个成员在与结构体变量偏移量为0的地址处。
    (2)其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8
    Linux中的默认值为4
    (3)结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
    (4) 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是
    所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
    4.位段
    位段的声明和结构是类似的,有两个不同:
    (1)位段的成员必须是 int、unsigned int 或signed int 。
    (2)位段的成员名后边有一个冒号和一个数字。
    例如:
    struct A
    {
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
    };
    A就是一个位段
    位段的内存分配:
    (1)位段的成员可以是 int unsigned int signed int 或者是 char (属于整形家族)类型
    (2) 位段的空间上是按照需要以4个字节( int )或者1个字节( char )的方式来开辟的。
    (3) 位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。
    5.枚举和联合
    (1)枚举类型的定义
    enum Sex//性别
    {
    MALE,
    FEMALE,
    SECRET
    };
    枚举类型的变量默认从0开始,依次递增1,即MALE=0;FEMALE=1,SECRET=2.当然在定义的时候也可以赋初值。例如:
    enum Sex//性别
    {
    MALE=3,
    FEMALE,
    SECRET
    };
    则FEMALE=4,SECRET=5。
    (2)枚举类型的使用
    enum Color//颜色
    {
    RED=1,
    GREEN=2,
    BLUE=4
    };
    enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值,才不会出现类型的差异。
    (3)联合
    联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员,特征是这些成员公用同一块空间(所以
    联合也叫共用体)。
    例如:
    union Un
    {
    char c;
    int i;
    };
    Un就是一个联合体
    (3)联合大小的计算
    (1)联合的大小至少是最大成员的大小。
    (2)当最大成员大小不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍。
    例如:
    union Un1
    {
    char c[5];
    int i;
    };
    printf("%d\n", sizeof(union Un1));
    上述输出的结果是8;

    展开全文
  • C语言自定义类型详解——结构体 1.结构体类型的声明 下面请看2段代码: struct Book { char name[20]; int price; }b4,b5,b6; int main() { struct Book b1; struct Book b2; struct Book b3; } 注意此处b4,...

    C语言自定义类型详解——结构体

    1.结构体类型的声明

    下面请看2段代码:

    struct Book
    {
    	char name[20];
    	int price;
    }b4,b5,b6;
    
    int main()
    {
    	struct Book b1;
    	struct Book b2;
    	struct Book b3;
    }
    

    注意此处b4,b5,b6与b1,b2,b3的区别在于:b4,b5,b6是全局变量而b1,b2,b3是局部变量

    2.匿名结构体类型

    struct//此处省略结构体的标签
    {
    	char c;
    	int i;
    	char ch;
    }s;
    

    此处的s是匿名结构体类型创建的变量,直接使用匿名结构体类型创建对象

    struct//此处省略结构体的标签
    {
    	char c;
    	int i;
    	char ch;
    }*ps;
    

    此处ps是匿名结构体类型的指针变量
    而下面这一段代码编译器是不支持的:

    int main()
    {
    	ps = &s;
    	return 0;
    }
    

    编译器认为即使上述2个的成员变量相同,仍是2个不同的类型,在编译器看来这种写法是不合理的

    3.结构体自引用

    struct A
    {
    	int i;
    	char c;
    };
    struct B
    {
    	int s;
    	struct A a;
    };
    

    上面这段代码是在结构体B中对结构体A进行了引用
    请问下面这段代码引用方式是正确的吗?

    struct Node
    {
    	int d = 0;
    	struct Node n;
    };
    

    不正确!因为结构体自引用不是包含自身结构体变量,而是包含自身结构体的指针,正确的自引用方式如下所示:

    struct Node
    {
    	int data;
    	struct Node* next;
    };//正确的自引用
    

    请问下面这段代码可行吗?

    typedef struct
    {
    	int data;
    	Node* next;
    }Node;
    

    不可行!
    正确引用方式如下所示:

    typedef struct Node
    {
    	int data;
    	struct Node* next;
    }Node;
    

    4.结构体初始化及成员变量的访问

    struct s
    {
    	char c;
    	int i;
    }s1,s2;
    
    struct B
    {
    	double d;
    	struct s s;
    	char c;
    };
    int main()
    {
    	struct s s3 = { 'a', 3 };//结构体初始化
    	struct B sb = { 3.14, { 'w', 100},'q' };
    	printf("%lf %c %d %c\n", sb.d, sb.s.c, sb.s.i, sb.c);
    }
    

    5.结构体内存大小的计算

    struct S
    {
    	int i;//4
    	char c;//1
    };
    int main()
    {
    	struct S s = { 0 };
    	printf("%d\n", sizeof(s));//输出8而不是5
    }
    

    为什么上述代码输出8而不是内部2个变量大小之和5呢?这与结构体内存对齐有关。

    展开全文
  • c语言 自定义类型

    2019-04-22 22:05:54
    结构体是一些值的集合,这些值称为成员变量,成员变量可以是不同的类型. //结构体的声明 struct Stu { chsr name[1024]; int age; char[sex]; char[id]; }; 在声明结构体时,可以不完全声明 //匿名...

    1,结构体
    结构体是一些值的集合,这些值称为成员变量,成员变量可以是不同的类型.

    //结构体的声明
    struct Stu
    {
     chsr name[1024];
     int age;
     char[sex];
     char[id];
    };
    
    

    在声明结构体时,可以不完全声明

    //匿名结构体类型(省略了结构体标签tag)
    struct
    {
     int a;
     char b;
     float c;
    }x;
    

    结构体的自引用

    struct Node
    {
     int date;
     struct Node* next;
    };
    

    结构体变量的定义和初始化

    struct point
    {
     int x;
     int y;
    }p1;         //声明类型的同时定义变量
    struct point p2;     //定义结构体变量p2
    struct Node
    {
     int  a;
     char arr[];
     struct Node* next;
    }n1 = { 1,{2,3},NULL };   //结构体嵌套初始化
    

    结构体内存对齐
    对齐规则:1.第一个成员在与结构体变量偏移量为0的地址处
    2.其他成员变量要对齐到对齐数的整数倍的地址处
    (对齐数=对齐数与该成员大小的较小值vs为8,Linux为4)
    3.结构体总大小为最大对齐数的整数倍
    4.如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍

    总体来说,结构体的内存对齐是拿空间来换取时间的做法

    struct s1
    {
     char a;     
     short b;   
     int c;      
     double d;   
     short e;    
     float f;
     int i;
    }x;          //sizeof  x=32
    

    修改默认对齐数 #pragma

    #pragma pack(4)   //设置默认对齐数为4
    struct s1
    {
     char a;     
     short b;   
     int c;      
     double d;   
     short e;    
     float f;
     int i;
    }x;                    //sizeof=28
    #pragma pack()//取消设置的默认对齐数,还原为默认
    
    

    位段
    位段的成员和结构体是类似的,有两个不同:
    1.位段的成员必须是int,unsigned int ,signed int.char(整型家族)类型
    2.位段的成员名后边有一个冒号和数字

    比如:

    struct A
    {
     int _a : 2;
     int _b: 4;
     int _h: 9;
    };
    

    枚举

    enum Sex
    {
     MALE,
        FEMALE,
     SECRET
    };
    
    //枚举的使用
    enum Color
    {
     RED=1,
     GREEN=2,
     BIUE=3
    };
    //只能拿枚举常量给枚举变量赋值
    //才不会出现类型的差异
    enum Color clr = GREEN; 
    clr = 5;//理论上不成立,但是c语言是一门弱类型语言,可隐式转化为int
    

    联合
    联合这种类型定义的变量也包含一系列成员,特征是这些成员
    公用同一块空间

    //声明
    union Un
    {
     char c;
     int d;
    };
    

    因此,联合变量的大小,最少是最大成员的大小

    联合大小的计算
    1.联合变量的大小,最少是最大成员的大小
    2.但最大成员大小不是最大对其数的整数倍的时候,
    就要对齐到最大对其数的整数倍

    #include<stdio.h>
    #include<stdlib.h>
    union Un1
    {
     char c[5];
     int i;
    };
    union Un2
    {
     short c[7];
     int i;
    };
    int main() {
     printf("%d\n", sizeof(union Un1));       //8
     printf("%d\n", sizeof(union Un2));       //16
     system("pause");
     return 0;
    }
    
    展开全文
  • C语言自定义类型浅析

    2018-05-13 20:34:16
    C语言自定义类型有三种:结构体、枚举、联合 一、结构体 1.定义:结构体是一些称为成员变量的值的集合,结构里的每个成员可以是不同类型的变量。 2.声明 struct tag { member-list; //成员列表 }variable-...
  • C语言自定义类型小结

    2019-08-26 16:26:32
    C语言自定义类型的学习主要有以下3个重点: 1. 结构体 2. 枚举 3. 联合 下面就分条总结这三个重点: 1.结构体 结构体的定义:结构体是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。 ...
  • 结构体类型结构体的声明与调用将结构体作为另一个结构体的成员结构体的内存对齐与位段联合体的内存存储枚举的定义 结构体的声明与调用 一 . 结构体类型声明 代码如下: struct S1 { int a; char name[20]; double s...
  • C语言自定义类型详解

    2020-06-23 19:20:39
    目录结构体结构体类型声明结构的自引用结构体变量的定义和初始化结构体内存对齐结构体传参枚举枚举类型的定义枚举的优点枚举的使用联合(共用体)联合类型的定义联合的特点联合大小的计算 结构体 结构体类型声明...
  • C语言自定义类型解析

    2019-06-25 12:13:39
    结构体类型声明 结构的自引用 结构体变量的定义和初始化 结构体内存对齐 结构体传参 结构体实现位段(位段的填充&可移植性) 枚举: 枚举类型的定义 枚举的优点 枚举的使用 联合 : 联合类型的定义 联合的特点...
  • C语言自定义类型:结构体、枚举、联合 结构体 首先,我们来讲一下,什么是数组?什么是结构体? 简单的说就是: 数组:具有相同类型元素的集合。 结构体:具有不同类型元素的集合。 结构体的声明: struct tag { ...
  • 保姆级讲解!C语言自定义类型

    千次阅读 多人点赞 2021-03-07 22:47:49
    文章目录C语言中的各种结构体详解及练习前言一、结构体的声明二、使用步骤1.引入库2.读入数据总结 前言 在我们日常写代码时,经常会遇到结构体类型的使用,今天带读者了解结构体类型的使用。 一、结构体的声明 ...
  • 结构体类型创建 struct Stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 };//分号不能丢 特殊声明 可以不完全声明 //匿名结构体类型 struct { int a; char b; ...
  • 结构的每个成员可以是不同类型的变量 例如描述一个学生: struct Stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 };//分号不能丢 2. 特殊的声明声明结构的时候,...
  • C语言当中有一部分类型是自定义类型,比如结构体、数组、枚举、联合,其实指针也是自定义类型,我们可以定义各种各样类型的指针,这在我之前的文章中有指针的解析。本文着重于讲解结构体类型,以及它的一个重要特征-...
  • C语言自定义数据类型

    2021-03-28 11:26:22
    结构体 ...大纲: 结构体的声明 结构体的自引用 ...char short int long short float double -这些都叫做内置类型,是C语言...复杂类型(自定义类型)-结构体、枚举、联合体。 1.结构体的声明 结构体的基础知识:结构
  • 这里我们声明了一个位段类型A,与结构体不同的是,每个成员后面都有一个冒号且都跟一个数字,其含义是该成员占用几个比特位。 位段的内存分配 位段的成员可以是int 、unsigned int、signed int、或者是char(属于...
  • 结构体类型的创建(声明) struct student{ char name[1024]; int age; }; //分号必须有 结构体是否可以自引用了? 这样对么? struct student{ char name[1024]; int age; struct student node; }; 答:这样是不对的,...
  • 1.1结构体类型声明 struct 结构体名称 { 成员类型 成员变量1; 成员类型 成员变量2; … }(定义当前结构体变量); 例: struct student { char name[1024];//名字 int age;//年龄 char sex[1024];//性别 char id[....
  • 结构是一些值的集合,这些值称为它的成员,一个结构的各个成员可能具有不同的类型。每个结构成员都有自己的名字,它们是通过名字访问的。 结构的声明声明结构时,必须列出它包含的所有成员。这个列表包括每个...
  • C语言中函数原型(声明)和自定义数据类型声明顺序。 代码A #include <stdio.h> struct student *del(struct student *head, int num); typedef struct student { int num; float score; struct ...
  • C语言自定义数据类型中的结构体,枚举,联合详解

    千次阅读 多人点赞 2021-04-02 23:16:54
    首先结构体的出现是因为我们使用C语言的基本类型无法满足我们的需求,比如我们要描述一本书,就需要书名,作者,价格,出版社等等一系列的属性,无疑C语言的基本数据类型无法解决,所以就出现了最重要的自定义数据...
  • 这里我们声明了一个位段类型A,与结构体不同的是,每个成员后面都有一个冒号且都跟一个数字,其含义是该成员占用几个比特位。 位段的内存分配 位段的成员可以是int 、unsigned int、signed int、或者是char(属于...
  • C语言自定义数据类型第7章 自定义数据类型7.1 结构体类型 7.2 共用体 7.3 枚举类型 7.4 用typedef声明类型C+提供了许多种基本的数据类型(如int、float、 double、char等)供用户使用。但是由于程序需要处 理的问题...
  • c语言自定义类型

    2018-05-17 17:50:48
    c语言自定义类型分为:结构体 枚举 联合,下面分别介绍一下他们的特点. 结构体: 1. 结构体的类型声明 struct tag { member__list; }variable__list; 例如描述一个学生: struct stu{ char name[20]; ...
  • C语言自定义类型

    2021-06-20 15:22:23
    自定义类型(九) 自定义类型:结构体,枚举,联合 结构体 结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。 结构体成员可以是标量,数组,指针,其他结构体。 结构的声明 形式1: ...
  • 1、关于数据类型的关键字(1) char :声明字符型变量或函数(2) double :声明双精度变量或函数(3) enum :声明枚举类型enum类型可以增加可读性,可移植性;在enum中定义的每个对象,默认都是从0开始,当然也可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 686
精华内容 274
关键字:

c语言自定义类型声明

c语言 订阅