【C语言】【unix c】为类型命名别名（使用typedef关键字）

小灰灰 2022-06-10 07:50 232阅读 0赞

一、为类型命名别名（使用typedef关键字）
        1、首先举个例子：结构体    
            struct node{
                int num;
                struct node *next;//不带星是不可以的，因为如果不带的话无法确认需要多大空间，但是带的话就确定了是指针类型，占4个字节，结构体共8个字节大小；
            }
            为结构体起名字应该都比较清楚，定义好别名后就可使用这个别名来定义所要的变量，如下
                在没有定义别名的时候我们要定义一个结构体的变量比较麻烦：
                    struct node (前面这两个是结构体的类型名) node1 (这是一个变量名) = {
       0};
                定义别名后就可以直接用别名来定义变量：
                    node node1 = {
       0}; //在这里node就是struct node这个类型，这里变量是node，类型是node，访问方式是结构体里取某个成员变量时的方式
    
        2、使用typedef为类型定义别名
    
        3、使用typedef定义别名有三个步骤：
            a、定义一个类型的变量   eg: int count_p
            b、在第一步的基础之上，在最前面加上typedef关键字，这时候，新定义的变量或常量就是类型的别名（新类型）  eg:typedef int count_t;
            c、使用新类型定义变量或常量 eg：count_t c;
    
        4、举例：
            1、为int类型定义别名
                typedef int count_t;
                count_t c;//这里的c也就是int类型的
    
            2、在系统中经常会出现下边情况：（_t也就是表示这是一个用typedef定义的，不是一个新类型，为了方便会用别名定义一些类型）
    
                typedef signed char int8_t;
                typedef unsigned char uint8_t
                typedef unsigned short uint16_t;
                typedef unsigned long uint32_t; 
                    .....
                使用：uint32_t a; //实际这是一个unsigned long类型的
    
            3、为指针类型定义别名：
                char *str_t;//变量名是 str_t 类型是 * 取值方式是char
                typedef char *str_t;
                str_t s,r; 等价于 char *s,*r;//这里的str_t 就是一个类型，是char *
    
            4、为一个结构体类型定义别名：
                struct node{
                    int num;
                    struct node *next;//不带星是不可以的，因为如果不带的话无法确认需要多大空间，但是带的话就确定了是指针类型，占4个字节，结构体共8个字节大小；
                };
                typedef struct node node_t;//这里将note_t就是struct node
                typedef node_t *list_t;//继续进行包装
                list_t h;//h是一个指针类型的变量，访问方式是结构体的访问方式
                list_t *n; //n是一个二级指针 实现了降维
    
            *5、为函数类型定义别名：
                int (*fun_t)(int, int);//fun_t是变量，*是类型，访问方式是函数类型 int (int, int)是访问方式，即函数访问方式
                typedef int (*fun_t)(int, int)//fun_t是类型那个的别名，是指针类型，访问方式是 int (int, int);
                typedef int t_add(int, int);//函数的名字是常量，加上typedef后t_add成为类型的别名，
                t_add *f
    
                演示类型的别名(以day23做的实验)
                    point.c文件：//回调函数的定义
                        #include "t_math.h"
                        int process(fun_t f, int x, int y) {
                            return f(x, y);
                        }
                    t_math.h文件： 
                        #ifndef T_MATH_H_
                        #define T_MATH_H_
    
                        typedef int(*fun_t)(int, int);
                        int t_add(int, int);
                        int t_sub(int, int);
                        int t_div(int, int);
                        int t_mul(int, int);
                        int process(fun_t, int, int );
                        #endif //T_MATH_H_
                    point.c文件
                        #include <stdio.h>
                        #include "t_math.h"
    
                        int main(void) {
                            int a= 6,b = 3;
                            fun_t f[4] = {t_add, t_sub, t_mul, t_div};// fun_t 在这里代表了一个函数类型，在头文件中已经为该函数定义了别名，所以这里不用写传入参数的类型，这里就相当于int (*f[4])(int,int)?????为什么要加 *
                            //f=t_add;
                            printf("%d+%d=%d\n", a, b, f[0](a, b));
                            printf("%d-%d=%d\n", a, b, f[1](a, b));
                            printf("%d*%d=%d\n", a, b, f[2](a, b));
                            printf("%d/%d=%d\n", a, b, f[3](a, b));
    
                            printf("%d*%d=%d\n", a, b, f[2](a, b));
    
                            printf("%d/%d=%d\n", a, b, process(t_div, a, b));
                            printf("%d+%d=%d\n", a, b, process(f[0], a, b));//回调函数的演示，该回调函数已经在头文件声明，第一个参数为一个函数的地址，后面为传入的两个参数
    
                            return 0;
                        }
                    （其他文件省略）
    
            6、为数组类型命名别名
                int arr_t[3];//arr_t是常量 int[3]是类型 
                typedef int arr_t[3]; //arr_t是类型的别名，这里的类型是int[3]的别名（typedef int [3] arr_t）
                arr_t a;//a是一个一维数组
                arr_t b[2];//b是一个一维数组,有2个元素，每个元素是一个一维数组，有3个元素，访问方式是int方式 （b[2][3]）
                验证数组的别名 （代码见arr_alias.c）
    
                代码： #include <stdio.h>
                    typedef int arr_t[3];
                    int main(void) {
                        arr_t a = {
       1,2,3};
                        arr_t b[2] = {
       1,2,3,4,5,6};//用别名来定义，b在这里相当于是一个一维数组了
                        int i = 0;
                        for( ; i < 3; i++) {
                        printf("a[%d]=%d\n", i, a[i]);
                        }
                        printf("b[1][1]=%d\n", b[1][1]);
                        return 0;
                    }
                运行：tarena@ubuntu:~/day/day24$ ./a.out 
                    a[0]=1
                    a[1]=2
                    a[2]=3
                    b[1][1]=5
    
        回调函数：（演示同为函数类型定义别名）