【C语言基础入门】9.C语言中的自定义数据类型

文章目录

一、自定义数据类型（上）

二、自定义数据类型（中）​​​​​

三、自定义数据类型（下）​​​​​

---

一、自定义数据类型（上）

• 类型命名关键字 (typedef) 
  • C语言中可以对类型赋予新名字
  • 语法：typedef Type New TypeName;
    • 注意：typedef 并没有创建新类型，只是创建了类型别名
• 深入 typedef 应用
  • typedef 可在函数中定义“局部类型名”
  • typedef 常用于简化类型名(如: unsigned long long)
  • typedef 定义类型名，能够以统一的方式创建变量(Type var; )

        下面看一段代码：

#include 

typedef  unsigned char  byte;

void func()
{
    typedef  byte  uint8;

    uint8 var = 200;
    byte  b   = var;   // 本质为相同类型变量之间的初始化

    printf("sizeof(uint8) = %d\n", sizeof(uint8));
    printf("var = %d\n", var);
    printf("b = %d\n", b);
}

int main()
{
    // uint8 var = 1;   // ERROR
    byte b = 128;

    func();

    printf("sizeof(byte) = %d\n", sizeof(byte));
    printf("b = %d\n", b);

    return 0;
}

​​​​​​        下面为输出结果：

​​​​        需要注意：本代码中的 byte 和 uint8 为同一个自定义类型，所以它们之间可以相互赋值。

         再来看一段代码：

#include 

typedef  float(FArr5)[5];        // 定义数组类型名
typedef  int(IFuncII)(int, int); // 定义函数类型名

typedef  FArr5*    PFArr5;
typedef  IFuncII*  PIFuncII;

float g_arr[5] = {0.1, 0.2, 0.3};

int add(int a, int b)
{
    return a + b;
}

int main()
{
    FArr5* pa = &g_arr;  // float(*)[5]
    IFuncII* pf = add;   // int(*)(int,int)

    PFArr5   npa = pa;
    PIFuncII npf = pf;

    int i = 0;

    for(i=0; i<5; i++)
    {
        printf("%f\n", (*pa)[i]);
        printf("%f\n", (*npa)[i]);
    }


    printf("%d\n", pf(2, 3));
    printf("%d\n", npf(2, 3));

    return 0;
}

        下面为输出结果：

         这里要特别注意函数指针的用法，可以通过 typedef 使得函数指针的定义简化。

•  C语言中的结构体（ struct )
  • ​​​​​​​struct 是C语言中的自定义类型关键字
  • struct 能够定义不同数据类型变量的集合类型

        语法：

        struct TypeName

        {

                Type1 var1;

                Type2 var2;

                ......;

                typeN varn;

        };

        下面看一段代码：

#include 
#include 

struct Student
{
    char name[20];
    int id;
    short major;
};

int main()
{
    struct Student s1 = {"Autumn", 908, 1};
    struct Student s2 = s1;

    printf("s1.name = %s\n", s1.name);
    printf("s1.id = %d\n", s1.id);
    printf("s1.major = %d\n", s1.major);

    strcpy(s2.name, "Hu");
    s2.id = 909;
    s2.major = 2;

    printf("s2.name = %s\n", s2.name);
    printf("s2.id = %d\n", s2.id);
    printf("s2.major = %d\n", s2.major);

    return 0;
}

        下面为输出结果：

•  小结
  • C语言中通过 typedef 关键字对数据类型赋予新名字
  • typedef 并不会创建一个全新的数据类型
  • struct 是C语言中的自定义类型关键字
  • struct 用于创建不同数据类型变量的集合类型

二、自定义数据类型（中）​​​​​

•  深入 struct  结构体类型
  • ​​​​​​​struct 结构体变量的本质是变量的集合
  • struct 结构体变量中的成员占用独立的内存
  • struct 结构体类型可用 typedef 赋予新类型名
  • 可定义struct 结构体类型的指针，并指向对应类型的变量
  • struct 结构体类型可先前置声明，再具体定义
  • 前置类型声明只能用于指针定义
  • 类型完整定义之后才能进行变量定义
  • struct 结构体类型可以省略类型名
    • ​​​​​​​类型名省略时，每次创建变量必须给出完整结构体定义
  • ​​​​​​​struct 结构体类型可以省略类型名（无名结构体类型)
  • 类型名省略时，每次创建变量必须给出完整结构体定义
  • 无名结构体类型总是互不相同的类型（互不兼容)

        先看第1段代码：

#include 
#include 

typedef  struct Student  Stu;

struct Student
{
    char name[20];
    int id;
    short major;
};

int main()
{
    Stu s;
    Stu* ps = &s;

    strcpy(ps->name, "Autumn");

    ps->id = 1;
    ps->major = 908;

    (*ps).major = 910;   // ==> s.major = 910

    printf("s.name = %s\n", s.name);
    printf("s.id = %d\n", s.id);
    printf("s.major = %d\n", s.major);

    return 0;
}

        下面为输出结果：
 

         这里注意结构体变量指针通过 -> 操作符访问成员变量。

        再看第2段代码：

#include 
#include 

struct Test;
struct Test* g_pt;    // 只要有了类型声明就可以创建对应的指针变量

// 必须先给出类型的完整定义才能创建相应类型的变量
struct Test
{
    int a;
    int b;
};

int main()
{
    struct Test t;

    t.a = 1;
    t.b = 2;

    g_pt = &t;

    printf("g_pt = %p\n", g_pt);
    printf("g_pt->a = %d\n", g_pt->a);
    printf("g_pt->b = %d\n", g_pt->b);

    return 0;
}

         下面为输出结果：

 

 这里注意两个问题：

1.只要有了类型声明就可以创建对应的指针变量

2.必须先给出类型的完整定义才能创建相应类型的变量

         再看第3段代码：

#include 
#include 

int main()
{
    struct { int a, b; } v1;
    struct { int a, b; } v2;
    struct { int a, b; }*pv;

    v1.a = 1;
    v1.b = 2;

    v2 = v1;

    pv = &v2;

    return 0;
}

        这段代码编译会出错：

 这段代码充分说明无名结构体类型总是互不相同的类型（互不兼容)

• 位域 
  • ​​​​​​​现代程序设计中，内存使用的最小单位为字节（约定俗成)
  • 在一些特定场合，可将比特位作为最小单位使用内存
  • 结构体类型能够指定成员变量占用内存的比特位宽度（位域)
• 深入位域
  • ​​​​​​​位域成员必须是整型，默认情况下成员依次排列
  • 位域成员占用的位数不能超过类型宽度（错误示例: char c : 9; )
  • 当存储位不足时，自动启用新存储单元
  • 可以舍弃当前未使用的位，重新启用存储单元

         下面看一段代码：

#include 

struct BW
{
    unsigned char a : 4;
    unsigned char b : 2;
    unsigned char c : 2;
};

int main()
{
    struct BW bw = {0};

    bw.a = 10;
    bw.b = 4;   // 4 大于 b 能表示的最大值，因此赋值后 b 回转到 0
    bw.c = 3;

    printf("sizeof(struct BW) = %d\n", sizeof(struct BW));
    printf("bw.a = %d\n", bw.a);
    printf("bw.b = %d\n", bw.b);
    printf("bw.c = %d\n", bw.c);

    return 0;
}

        下面为输出结果：

         这里注意 a : 4 ，所以 a 的取值范围是 0000 ~ 1111 之间，即 0 ~ 15 之间。

        再看一段代码：

#include 
#include 

struct Bits1
{

    int a   : 16;
    short b : 8;
    char c  : 8;
    float f;     // float f : 32;   ==> 浮点型成员不能指点位宽度
};

struct Bits2
{
    unsigned char a : 6;
    unsigned char b : 6;
    unsigned char c : 6;
    // unsigned char d : 9;    ==> 指定的位宽度不能大于声明类型的位宽度
};

struct Bits3
{
    unsigned char a : 4;
    unsigned char   : 0;  // 重启一个存储单元表示新的成员
    unsigned char b : 4;
};

int main()
{
    printf("sizeof(Bits1) = %d\n", sizeof(struct Bits1));
    printf("sizeof(Bits2) = %d\n", sizeof(struct Bits2));
    printf("sizeof(Bits3) = %d\n", sizeof(struct Bits3));

    return 0;
}

         下面为输出结果：

         这里注意三点：

1.浮点型成员不能指点位宽度

2.指定的位宽度不能大于声明类型的位宽度

3.unsigned char  : 0 重启一个存储单元表示新的成员

• 小结 
  • ​​​​​​​struct 结构体变量中的成员占用独立的内存
  • struct 结构体类型可用 typedef 赋予新类型名
  • 结构体类型能够指定成员变量占用内存的比特位宽度
  • 位域成员必须是整型，占用的位数不能超过类型宽度
  • 当存储位不足时，自动启用新存储单元

三、自定义数据类型（下）​​​​​

•  C语言中的联合体( union )
  • union 是C语言中的自定义类型关键字
  • union 是 struct 的兄弟关键字，用法上非常相似

        语法：

        union TypeName

        {

                Type1 var1;

                Type2 var2;

                //......

                TypeN varn;

        };

• union 与 struct 的不同
  • union 类型所有成员共享同一段内存(所有成员起始地址相同)
  • union 类型的大小取决于成员的最大类型
  • union 类型的变量只能以第一个 成员类型的有效值进行初始化

        下面看一段代码：

 

#include 
#include 

union UTest
{
    int a;
    float f;
};

struct STest
{
    int a;
    float f;
};

int main()
{
    union UTest ut = {987654321};
    struct STest st = {987654321, 0.1f};

    printf("union UTest size = %d\n", sizeof(union UTest));
    printf("&ut.a = %p\n", &ut.a);
    printf("&ut.f = %p\n", &ut.f);

    printf("struct STest size = %d\n", sizeof(struct STest));
    printf("&st.a = %p\n", &st.a);
    printf("&st.f = %p\n", &st.f);

    printf("ut.a = %d\n", ut.a);
    printf("ut.f = %f\n", ut.f);

    ut.f = 987654321.0f;

    printf("ut.a = %d\n", ut.a);
    printf("ut.f = %f\n", ut.f);

    return 0;
}

        下面为输出结果：

         这里注意整型数据和浮点类型数据在内存中的表示方式不一样，所以在同一段内存，同是4个字节，按照整型的方式解释这4个字节的数据时是一种结果，按照浮点数类型解释这4个字节时就是另一种结果。

•  union 类型的应用-判断系统大小端
  • ​​​​​​​小端系统：低位数据存储在低地址内存中
  • 大端系统：低位数据存储在高地址内存中

        例如，对于 unsigned ui = 1;

         下面看一段判断大小端的代码：

#include 

int isLittleEndian()
{
    union
    {
        int i;
        char a[4];
    } test = {0};

    test.i = 1;

    return (test.a[0] == 1);
}

int main()
{
    printf("System Endian: %d\n", isLittleEndian());

    return 0;
}

        下面为输出结果：

         由代码可知，1 存在低位，所以我的电脑为小端系统。

•  C语言中的枚举类型( enum )
  • ​​​​​​​enum 是C语言中的自定义类型关键字
  • enum 能够定义整型常量的集合类型

​​​​​​​        语法：

        enum TypeName

        {

                IntConst1,

                IntConst2,

                //......

                IntconstN

        };

• 枚举类型( enum )注意事项
  • 第一个枚举常量的默认值为0
  • 后续常量的值在前一一个常量值的基础上加1
  • 可以任意对枚举常量指定整型值(只能指定整型值)

        例如：

         下面看一段代码，感受一下：

#include 
#include 

enum Day { MON = 1, TUE, WED, THU, FRI, SAT, SUN };
enum Season { Spring, Summer = 3, Autumn, Winter = -1 };

enum { CONSTANT = 12345 };

int main()
{
    enum Day d = TUE;
    enum Season s = Winter;

    int i = SUN;
    int j = Autumn;

    printf("d = %d\n", d);   // 2
    printf("s = %d\n", s);   // -1
    printf("i = %d\n", i);   // 7
    printf("j = %d\n", j);   // 4

    d = 0;
    s = -2;

    printf("d = %d\n", d);
    printf("s = %d\n", s);

    printf("sizeof(enum Day) = %d\n", sizeof(enum Day));
    printf("sizeof(enum Season) = %d\n", sizeof(enum Season));

    printf("CONSTANT = %d\n", CONSTANT);

    // CONSTANT = 54321;

    return 0;
}

        下面为输出结果：

         这段代码也说明了 enum 枚举类型的本质就是整型。

• 小结
  • union 是 struct 的兄弟关键字，用法上非常相似
  • union 类型所有成员共享同一段内存
  • enum 能够定义整型常量的集合类型
  • enum 的本质是 int 类型，常用于整型常量定义