支持自定义数据类型可以用于 python 队列自定义数据类型怎么用

转载

mob64ca141275de 2023-11-24 13:51:07

文章标签 c语言开发语言后端 #include 数据类型 文章分类 Python 后端开发

文章目录

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

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

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

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

类型命名关键字 (typedef)

C语言中可以对类型赋予新名字
语法：typedef Type New TypeName;

注意：typedef 并没有创建新类型，只是创建了类型别名

深入 typedef 应用

typedef 可在函数中定义“局部类型名”
typedef 常用于简化类型名(如: unsigned long long)
typedef 定义类型名，能够以统一的方式创建变量(Type var; )

下面看一段代码：

#include <stdio.h>

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_开发语言

再来看一段代码：

#include <stdio.h>

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_数据类型_02

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

struct

struct 是C语言中的自定义类型关键字
struct 能够定义不同数据类型变量的集合类型

语法：

struct TypeName

{

Type1

Type2

......;

typeN

};

下面看一段代码：

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_开发语言_03

小结

C语言中通过 typedef
typedef
struct 是C语言中的自定义类型关键字
struct 用于创建不同数据类型变量的集合类型

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

深入 struct

struct 结构体变量的本质是变量的集合
struct 结构体变量中的成员占用独立的内存
struct 结构体类型可用 typedef
可定义struct 结构体类型的指针，并指向对应类型的变量
struct
前置类型声明只能用于指针定义
类型完整定义之后才能进行变量定义
struct 结构体类型可以省略类型名

类型名省略时，每次创建变量必须给出完整结构体定义

struct 结构体类型可以省略类型名（无名结构体类型)
类型名省略时，每次创建变量必须给出完整结构体定义
无名结构体类型总是互不相同的类型（互不兼容)

先看第1段代码：

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_后端_04

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

再看第2段代码：

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_后端_05

这里注意两个问题：
1.只要有了类型声明就可以创建对应的指针变量
2.必须先给出类型的完整定义才能创建相应类型的变量

再看第3段代码：

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

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;
}

这段代码编译会出错：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_开发语言_06

无名结构体类型总是互不相同的类型（互不兼容)

位域

现代程序设计中，内存使用的最小单位为字节（约定俗成)
在一些特定场合，可将比特位作为最小单位使用内存
结构体类型能够指定成员变量占用内存的比特位宽度（位域)

深入位域

位域成员必须是整型，默认情况下成员依次排列
位域成员占用的位数不能超过类型宽度（错误示例: char c : 9; )
当存储位不足时，自动启用新存储单元
可以舍弃当前未使用的位，重新启用存储单元

下面看一段代码：

#include <stdio.h>

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_#include_07

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

再看一段代码：

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_数据类型_08

这里注意三点：
1.浮点型成员不能指点位宽度
2.指定的位宽度不能大于声明类型的位宽度
3.unsigned char : 0 重启一个存储单元表示新的成员

小结

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

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

union

union
union 是 struct

语法：

union TypeName

{

Type1 var1;

Type2 var2;

//......

TypeN varn;

};

union 与 struct 的不同

union 类型所有成员共享同一段内存(所有成员起始地址相同)
union
union 类型的变量只能以第一个成员类型的有效值进行初始化

下面看一段代码：

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_后端_09

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

union

小端系统：低位数据存储在低地址内存中
大端系统：低位数据存储在高地址内存中

unsigned

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_#include_10

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

#include <stdio.h>

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_后端_11

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

C语言中的枚举类型( enum

enum 是C语言中的自定义类型关键字
enum 能够定义整型常量的集合类型

语法：

enum TypeName

{

IntConst1,

IntConst2,

//......

IntconstN

};

枚举类型( enum )注意事项

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

例如：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_c语言_12

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

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

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;
}

下面为输出结果：

支持自定义数据类型可以用于 python 队列自定义数据类型怎么用_后端_13