typedef关键字用法 免费下载
typedef用法总结
typedef⽤法总结原⽂转⾃:引⾔typedef 声明,简称 typedef,为现有类型创建⼀个新的名字。
⽐如⼈们常常使⽤ typedef 来编写更美观和可读的代码。
所谓美观,意指typedef 能隐藏笨拙的语法构造以及平台相关的数据类型,从⽽增强可移植性和以及未来的可维护性。
在编程中使⽤typedef⽬的⼀般有两个,⼀个是给变量⼀个易记且意义明确的新名字,另⼀个是简化⼀些⽐较复杂的类型声明。
typedef的使⽤⽅法如下:typedef existing_type new_type_name ;注意:typedef 并不创建新的类型。
它仅仅为现有类型添加⼀个同义字。
typedef的最简单使⽤typedef int size;typedef unsigned int WORD;第⼀个声明定义了⼀个char的同义词,名字为C,你可以在任何需要int的上下⽂使⽤size。
第⼆个声明定义了⼀个unsigned int的同义词,名字为WORD,你可以在任何需要int的上下⽂使⽤WORD。
typedef和数组,指针我们可以不⽤象下⾯这样重复定义有 81 个字符元素的数组:char line[81];char text[81];定义⼀个 typedef,每当要⽤到相同类型和⼤⼩的数组时,可以这样:typedef char Line[81];Line text, secondline;同样,可以象下⾯这样隐藏指针语法:typedef char * pstr;pstr str = "abc";int mystrcmp(pstr, pstr);typedef和函数函数指针⼀般⽤于回调,例如信号处理,libcurl等会应⽤到回调。
回调是⽐较常⽤的技术,⽽回调就要涉及函数指针。
当我们的程序中有以下函数:void printHello(int i);然后我们要定义⼀个函数指针,指向printHello,并且调⽤这个⽅法,代码如下:void (*pFunc)(int);pFunc = &printHello;(*pFunc)(110);其中void (*pFunc)(int)是声明⼀个函数指针,指向返回值是void,调⽤参数是(int)的函数,变量名是pFunc,pFunc就是函数指针了,以前是函数指针的简单⽤法。
typedef关键字的用法(一)
typedef关键字的用法(一)Typedef关键字的用法在C语言中,typedef是一个非常有用的关键字,用于为已存在的数据类型定义一个新的名称。
通过使用typedef关键字,可以简化复杂数据类型的使用,并提高代码的可读性。
下面是一些typedef关键字的用法。
1. 为基本数据类型定义新名称typedef int myInt;上述代码为int基本数据类型定义了一个新的名称myInt。
现在,我们可以使用myInt来定义变量,就如同使用int一样。
2. 为自定义结构体定义新名称typedef struct {int x;int y;} Point;上述代码为一个无名struct结构体定义了一个新的名称Point。
现在,我们可以使用Point来声明struct类型的变量。
3. 为指针类型定义新名称typedef int* IntPointer;上述代码为int指针类型定义了一个新的名称IntPointer。
现在,我们可以使用IntPointer来声明int类型的指针变量。
4. 为函数指针定义新名称typedef void (*FuncPointer)(int, int);上述代码为接受两个int参数且返回值为void的函数指针类型定义了一个新的名称FuncPointer。
现在,我们可以使用FuncPointer来声明函数指针变量。
5. 为枚举类型定义新名称typedef enum {RED,GREEN,BLUE} Color;上述代码为一个无名enum枚举类型定义了一个新的名称Color。
现在,我们可以使用Color来声明enum类型的变量。
6. 为数组类型定义新名称typedef int IntArray[10];上述代码为一个包含10个int元素的数组类型定义了一个新的名称IntArray。
现在,我们可以使用IntArray来声明数组变量。
通过使用typedef关键字,我们可以方便地为已有的数据类型定义新的名称,提高代码的可读性和可维护性。
typedef使用大全
typedef使用大全初学者在使用或者碰到typedef时往往难以理解其含义,而不知所措,在教科书中有参考价值的很少,在此从网络上把typedef搜索了一些资料并整理给出一个较为完整的typedef 使用方法,供大家参考。
一、数组#include <stdio.h>#include <iostream.h>/* 避免Visual C的for与标准for的不同*/#define for if (0); else for/* dim(a)是用于计算a的维数,不过只能计算数组的维数,不能计算指针的维数*/ #define dim(a) (sizeof(a)/sizeof(a[0]))/* N1到N4是几个常量,以枚举的形式定义*/enum {N1 = 2, N2 = 3, N3 = 4, N4 = 5};/* 这个C程序员都知道,就是将DataType定义为int型,便于扩充*/typedef int DataType;/* 定义一个一维数组,数组的元素维整型值*/typedef DataType ARR1[N4];/* 再定义一个一维数组,数组的元素维ARR1型,不过ARR1又是一个数组,所以 * ARR2 实际上是一个矩阵*/typedef ARR1 ARR2[N3]; /* 此处完全等价为typedef int ARR2[N3][N4];*//* 按照ARR2的解释,ARR3也是一个一维数组,不过数组元素的类型是ARR2的类型* 所有ARR3是一个三维数组*/typedef ARR2 ARR3[N2]; /* 此处完全等价为typedef int ARR3[N2][N3][N4];*//* 分别用定义好的ARR1,ARR2,ARR3定义三个变量a, b, c */ARR1 a; /* 此处完全等价于:int a[N4]; */ARR2 b; /* 此处完全等价于:int b[N3][N4]; */ARR3 c; /* 此处完全等价于:int c[N2][N3][N4]; *//* 下面函数给大家个示例看a,b,c如何使用*/void exam_1(){for (int i=0; i<dim(a); i++) a[i] = i+1;for (int i=0; i<dim(b); i++) for (int j=0; j<dim(b[0]); j++)b[i][j] = (i+1)*10 + (j+1);for (int i=0; i<dim(c); i++) for (int j=0; j<dim(c[0]); j++)for (int k=0; k<dim(c[0][0]); k++) c[i][j][k] = (i+1)*100 + (j+1)*10 + (k+1);printf("\nThe a is :\n");for (int i=0; i<dim(a); i++) printf("%4d ", a[i]);printf("\n");printf("\nThe b is :\n");for (int i=0; i<dim(b); i++){for (int j=0; j<dim(b[0]); j++) printf("%4d ", b[i][j]);printf("\n");}printf("\nthe c is:\n");for (int i=0; i<dim(c); i++){for (int j=0; j<dim(c[0]); j++){for (int k=0; k<dim(c[0][0]); k++) printf("%4d ", c[i][j][k]);printf("\n");}printf("\n");}}/* 下面函数给大家演示数组在内存中的排列*/void exam_2(){int *pn = NULL;pn = (int *)a; /* 等价于pn = &a[0]; */printf("\nThe a is :\n");for (int i=0; i<sizeof(a)/sizeof(DataType); i++) printf("%4d ", pn[i]);printf("\n");pn = (int *)b; /* 等价于pn = &b[0][0]; */printf("\nThe b is :\n");for (int i=0; i<sizeof(b)/sizeof(DataType); i++) printf("%4d ", pn[i]);printf("\n");pn = (int *)c; /* 等价于pn = &c[0][0][0]; */printf("\nThe c is :\n");for (int i=0; i<sizeof(c)/sizeof(DataType); i++) printf("%4d ", pn[i]);printf("\n");}int main(int argc, char* argv[]){exam_1();exam_2();return 0;}#define S(s) printf("%s\n", #s); stypedef struct _TS1{int x, y;} TS1, *PTS1, ***PPPTS1; // TS1是结构体的名称,PTS1是结构体指针的名称// 也就是将结构体struct _TS1 命名为TS1,// 将struct _TS1 * 命名为PTS1// 将struct _TS1 *** 命名为PPPTS1typedef struct { // struct后面的结构体说明也可以去掉int x, y;} TS2, *PTS2;typedef PTS1 *PPTS1; // 定义PPTS1是指向PTS1的指针typedef struct _TTS1{typedef struct ITTS1 {int x, y;} iner;iner i;int x, y;} TTS1;二结构体//结构体内部的结构体也一样可以定义typedef TTS1::ITTS1 ITS1;void test_struct(){// 基本结构体重定义的使用TS1 ts1 = {100, 200};PTS1 pts1 = &ts1; // 完全等价于TS1* pts1 = &ts1;PPTS1 ppts1 = &pts1; // 完全等价于TS1** ppts1 = &pts1;PPPTS1 pppts1 = &ppts1; // 完全等价于TS1*** pppts1 = &ppts1;TS2 ts2 = {99, 88};PTS2 pts2 = &ts2; // 完全等价于TS2* pts2 = &ts2;TTS1 itts1 = {{110, 220}, 10, 20};Its1* rits1 = &itts1.i;ITS1* &its1 = rits1; // 等价于TTS1::ITTS1 *its1 = &(itts1.i);printf("ts1\t = (%d, %d)\n*pts1\t = (%d, %d)\n""**ppts1\t = (%d, %d)\n***pppts1= (%d, %d)\n\n",ts1.x, ts1.y, pts1->x, pts1->y,(**ppts1).x, (**ppts1).y, (***pppts1).x, (***pppts1).y);printf("ts2\t = (%d, %d)\n*pts2\t = (%d, %d)\n\n",ts2.x, ts2.y, pts2->x, pts2->y);printf("itts1\t = [(%d, %d), %d, %d]\n*its1\t = (%d, %d)\n\n", itts1.i.x, itts1.i.y, itts1.x, itts1.y, its1->x, its1->y);S(pts1->x = 119);S(pts2->y = 911);S(its1->x = 999);printf("ts1\t = (%d, %d)\n*pts1\t = (%d, %d)\n""**ppts1\t = (%d, %d)\n***pppts1= (%d, %d)\n\n",ts1.x, ts1.y, pts1->x, pts1->y,(**ppts1).x, (**ppts1).y, (***pppts1).x, (***pppts1).y);printf("ts2\t = (%d, %d)\n*pts2\t = (%d, %d)\n\n",ts2.x, ts2.y, pts2->x, pts2->y);printf("itts1\t = [(%d, %d), %d, %d]\n*its1\t = (%d, %d)\n\n",itts1.i.x, itts1.i.y, itts1.x, itts1.y, its1->x, its1->y);S((*ppts1)->y = -9999);printf("ts1\t = (%d, %d)\n**ppts1\t = (%d, %d)\n\n",ts1.x, ts1.y, (*ppts1)->x, (*ppts1)->y);S((**pppts1)->x = -12345);S((***pppts1).y = -67890);printf("ts1\t = (%d, %d)\n*pts1\t = (%d, %d)\n""**ppts1\t = (%d, %d)\n***pppts1= (%d, %d)\n\n",ts1.x, ts1.y, pts1->x, pts1->y,(**ppts1).x, (**ppts1).y, (***pppts1).x, (***pppts1).y);}三指向函数的指针在typedef的使用中,最麻烦的是指向函数的指针,如果没有下面的函数,你知道下面这个表达式的定义以及如何使用它吗?int (*s_calc_func(char op))(int, int);如果不知道,请看下面的程序,里面有比较详细的说明// 定义四个函数int add(int, int);int sub(int, int);int mul(int, int);int div(int, int);// 定义指向这类函数的指针typedef int (*FP_CALC)(int, int);// 我先不介绍,大家能看懂下一行的内容吗?int (*s_calc_func(char op))(int, int);// 下一行的内容与上一行完全相同,// 定义一个函数calc_func,它根据操作字符op 返回指向相应的计算函数的指针FP_CALC calc_func(char op);// 根据op 返回相应的计算结果值int calc(int a, int b, char op);int add(int a, int b){ return a + b;}int sub(int a, int b){ return a - b;}int mul(int a, int b){ return a * b;}int div(int a, int b){ return b? a/b : -1;}int (*s_calc_func(char op)) (int, int)//这个函数的用途与下一个函数完全相同,参数为op,而不是最后的两个整形{ return calc_func(op);}FP_CALC calc_func(char op)// 这个函数是使用typedef定义了FP_CALC类型后的写法,与一般的函数的写法比较统一,好理解{ switch (op){case '+': return add;case '-': return sub;case '*': return mul;case '/': return div;default:return NULL;}return NULL;}int calc(int a, int b, char op){FP_CALC fp = calc_func(op); // 下面是类似的直接定义指向函数指针变量// 下面这行是不用typedef,来实现指向函数的指针的例子,麻烦!int (*s_fp)(int, int) = s_calc_func(op);// ASSERT(fp == s_fp); // 可以断言这俩是相等的if (fp) return fp(a, b);else return -1;}void test_fun(){int a = 100, b = 20;printf("calc(%d, %d, %c) = %d\n", a, b, '+', calc(a, b, '+'));printf("calc(%d, %d, %c) = %d\n", a, b, '-', calc(a, b, '-'));printf("calc(%d, %d, %c) = %d\n", a, b, '*', calc(a, b, '*'));printf("calc(%d, %d, %c) = %d\n", a, b, '/', calc(a, b, '/'));}运行结果calc(100, 20, +) = 120calc(100, 20, -) = 80calc(100, 20, *) = 2000calc(100, 20, /) = 5。
C语言typedef用法总结
C语言typedef用法总结黄海涛,2012-3-11C语言中的typedef可以让人感觉很清新,但也可以让人感觉神秘。
当你一层层剥开它的时候,神秘的面纱终会摘下……让我们一起来探究其中的秘密吧!一、概述1、类型定义符typedefC语言提供了一个称为typedef的工具,它允许你为各种数据类型定义新的名字。
定义形式:typedef 原类型名新类型名;它的格式与变量声明完全一样,只是把typedef这个关键字放在声明的前面,但typedef并不创建变量,而是为指定类型引入一个新的名字。
2、实质其实质是:为现有类型取个新名字,它并没有引入新的类型。
typedef是一种声明形式,它为一种类型引入新的名字,而不是产生新的类型,也不会为变量分配空间。
3、作用时机在某些方面,typedef类似于宏文本替换,但typedef是类型定义符,在编译时会有相应类型的检查。
typedef是由编译器解释的。
▲typedef与#define的区别A.#define后面没有分号,而typedef后面有分号;B.#define不是关键字,而typedef是关键字;C.宏定义中宏名紧跟着#define,而typedef中的类型名并不紧接其后;D.可以用其他类型说明符对宏名进行扩展,但对typedef定义的类型名却不行;例如:E.在连续几个变量声明中,typedef定义的类型名可以保证声明中所有的变量均为同一种类型,而#define定义的宏名则无法保证。
4、使用原因1)表达方式更简洁,简化编程;2)使程序参数化,提高程序的可移植性;3)为程序提供更好的说明性,可以引入一个易记且意义明确的新名字,提升可维护性。
5、缺点允许一些看上去混乱的语法,可以把几个声明放在一个声明中。
如:二、使用typedef声明定义时的限制1、2、3、存储类关键字:auto、extern、register、static与typedef但在存储类说明符中,typedef是个例外,它不会真正影响对象的存储特性。
c语言中typedef的用法(一)
c语言中typedef的用法(一)C语言中typedef的用法简介在C语言中,typedef是一种特殊的关键字。
它的作用是为已有的数据类型起一个新的名字。
这个新的名字可以让代码更加清晰易懂。
typedef的语法下面是typedef的语法:typedef type newname;其中,type是已有的数据类型,newname是新的名字。
比如,我们可以用typedef为int起一个新的名字叫做myint:typedef int myint;typedef的优点1. 更加清晰易懂使用typedef可以为已有的数据类型起一个更加直观、易懂的名字。
比如我们可以用typedef为int*起一个新的名字叫做IntPtr:typedef int* IntPtr;这样在代码中使用IntPtr就比使用int*更加明确。
2. 更加方便使用typedef可以简化代码的书写。
比如,我们可以用typedef 为结构体起一个新的名字:typedef struct Student {char name[20];int age;} Student;这样,我们就不需要每次都写出完整的结构体定义了。
3. 更加可维护使用typedef可以提高代码的可维护性。
如果我们需要修改某个数据类型的定义,只需要修改一次,然后所有使用该数据类型的地方都会受到影响。
typedef的实际应用1. 简化代码在代码中,我们经常会使用一些比较复杂的数据类型,比如结构体、指针等。
使用typedef可以为这些复杂的数据类型起一个新的名字,使代码更加简洁易懂。
2. 提高代码的可读性使用typedef可以提高代码的可读性。
比如,我们可以为一些常用的数据类型起一个新的名字,使代码更加易懂。
3. 接口设计使用typedef可以用于接口设计。
我们可以将某个复杂的数据类型替换为一个更加简单易懂的名字,从而提高接口的可用性。
总结在C语言中,typedef是一个非常有用的关键字,使用它可以提高代码的可读性、可维护性,简化代码的书写和提高接口的可用性。
typedef的四个用途和两个陷阱
typedef的四个用途和两个陷阱用途一:定义一种类型的别名,而不只是简单的宏替换。
可以用作同时声明指针型的多个对象。
比如:char* pa, pb; // 这多数不符合我们的意图,它只声明了一个指向字符变量的指针,// 和一个字符变量;以下则可行:typedef char* PCHAR; // 一般用大写PCHAR pa, pb; // 可行,同时声明了两个指向字符变量的指针虽然:char *pa, *pb;也可行,但相对来说没有用typedef的形式直观,尤其在需要大量指针的地方,typedef的方式更省事。
用途二:用在旧的C代码中(具体多旧没有查),帮助struct。
以前的代码中,声明struct新对象时,必须要带上struct,即形式为: struct 结构名 对象名,如:struct tagPOINT1{int x;int y;};struct tagPOINT1 p1;而在C++中,则可以直接写:结构名 对象名,即:tagPOINT1 p1;估计某人觉得经常多写一个struct太麻烦了,于是就发明了: typedef struct tagPOINT{int x;int y;}POINT;POINT p1; // 这样就比原来的方式少写了一个struct,比较省事,尤其在大量使用的时候或许,在C++中,typedef的这种用途二不是很大,但是理解了它,对掌握以前的旧代码还是有帮助的,毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。
用途三:用typedef来定义与平台无关的类型。
比如定义一个叫 REAL 的浮点类型,在目标平台一上,让它表示最高精度的类型为:typedef long double REAL;在不支持 long double 的平台二上,改为:typedef double REAL;在连 double 都不支持的平台三上,改为:typedef float REAL;也就是说,当跨平台时,只要改下 typedef 本身就行,不用对其他源码做任何修改。
typedef class用法
一、typedef关键字的作用typedef 是C语言中用来定义新数据类型的关键字,它可以给现有的数据类型起一个新的名字。
通过typedef关键字,我们可以简化复杂数据类型的使用,增强程序的可读性和可维护性。
二、typedef的语法格式typedef 的语法格式如下:typedef 原类型名新类型名;其中,原类型名可以是基本数据类型(int、char、float等)、结构体、联合体或枚举类型,新类型名是我们想要定义的新类型的名称。
三、使用typedef定义基本数据类型1. 定义int类型我们可以使用typedef定义一个新的int类型:typedef int Integer;这样,我们就可以用Integer代表int类型,使用起来更加直观和易读。
2. 定义char类型同样的,我们也可以使用typedef定义一个新的char类型:typedef char Letter;这样,我们就可以用Letter代表char类型,使得代码更加易懂。
3. 定义float类型typedef关键字也可以用来定义新的float类型:typedef float Realnum;这样,我们就可以用Realnum代表float类型,让程序更易读易懂。
四、使用typedef定义结构体类型1. 定义结构体类型通过typedef关键字,我们可以给结构体类型起一个新的名字:typedef struct{int age;char name[20];} Person;这样,我们就可以使用Person代表这个结构体类型,方便我们在程序中使用。
2. 定义结构体类型的指针我们还可以使用typedef定义结构体类型的指针,例如:typedef struct{int age;char name[20];} Person, *PersonPtr;这样,我们可以使用PersonPtr代表指向该结构体类型的指针,使得代码更加清晰易懂。
五、使用typedef定义联合体类型1. 定义联合体类型typedef关键字还可以用来定义联合体类型,例如:typedef union{int i;char c;float f;} Data;这样,我们就可以用Data代表这个联合体类型,方便我们在程序中使用。
ios typedef 用法
iOS typedef 用法一、typedef 的作用在iOS开发中,我们经常会使用 typedef 来定义新的数据类型,它可以为现有的数据类型创建一个新的别名。
通过使用 typedef,我们可以让代码更加易读,同时也可以提高代码的可维护性和可重用性。
二、基本语法typedef 的基本语法如下:typedef old_type new_type;其中 old_type 表示已经存在的数据类型,new_type 表示我们要定义的新的别名。
通过这种方式,我们可以在代码中使用 new_type 作为old_type 的别名。
三、使用场景1. 简化复杂的数据类型有时候我们会遇到一些比较复杂的数据类型,例如一个包含多个字段的结构体,使用 typedef 可以让我们为这个结构体创建一个简单易懂的别名。
例如:typedef struct {int studentID;char name[20];int age;} Student;通过上面的定义,我们可以在代码中直接使用 Student 来代替原先复杂的结构体类型,让代码更加清晰和易读。
2. 提高代码的可移植性在不同的评台上,有时候同一个数据类型可能会有不同的实现方式。
通过使用typedef,我们可以将这些不同评台上的数据类型统一起来,提高代码的可移植性。
例如:#ifdef __APPLE__typedef uint32_t myUInt;#elif defined _WIN32typedef unsigned int myUInt;#endif通过这种方式,不同评台上的 unsigned int 类型都可以统一使用myUInt。
3. 简化复杂的函数指针定义在C和Objective-C中,函数指针的定义有时候会比较复杂,使用typedef 可以让函数指针的定义变得更加简洁清晰。
例如:typedef void (*CompletionBlock)(BOOL success, id responseData);通过上面的定义,我们可以直接使用 CompletionBlock 来代替函数指针类型,让代码更加易读和易维护。
struct和typedefstruct的使用
struct和typedefstruct的使⽤Struct和typedef Struct的使⽤⼀、typedef 关键字1. 简介: typedef⼯具是⼀个⾼级数据特性,利⽤typedef可以为某⼀些类型⾃定义名称。
2. ⼯作原理: 例如我们定义链表的存储结构时,需要定义结点的存储数据元素的类型,如定义⼀个 int 类型的ElemType,我们可以在定义前⾯加上关键字typedef即可:typedef int ElemType; 随后我们便可以⽤ElemType来定义上述数据元素的类型了:ElemType data;⼆、对下述结构指针定义的理解typedef int ElemType;/*****存储结构*****/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList; LNode和*LinkList与关键字typedef配合使⽤,即给声明的结构体起⼀个别名LNode, 与此同时起⼀个指针别名LinkList,然后可以⽤下⾯⽅法声明变量: LNode L; //声明⼀个struct LNode型变量L //等价于 struct LNode L;显然上述⽐较简单 LinkList Ptrl; //声明⼀个struct LNode* 型指针变量Ptrl //等价于写 struct LNode *Ptrl, 同样上述表⽰⽐较简单 另外关于单链表存储结构定义的另⼀表⽰⽅法,⾃⾏与上⾯的定义⽅式⽐较,注意区别:typedef struct LNode *Liststruct LNode{ElemType data;List next;};struct LNode L;List PtrL;节点⽰意图如下:------------------------------------------------------------------------------------------------------------------------------------------------------typedef struct OLNode{ int i,j; int data; OLNode *right,*down;}OLNode,*OLink; //结构的对象OLNode, 指向结构的指针*OLink,可以这样写struct OLNode{};OLNode OLNode, *OLink;分三块来讲述:1 ⾸先://注意在C和C++⾥不同 在C中定义⼀个结构体类型要⽤typedef: typedef struct Student { int a; }Stu; 于是在声明变量的时候就可:Stu stu1;这⾥的Stu实际上就是struct Student的别名,Stu==struct Student(如果没有typedef就必须⽤struct Student stu1;来声明)。
typedef在c语言中的用法
typedef在c语言中的用法嘿,小伙伴们,今天咱们来聊聊C语言里头的一个神奇小工具——typedef,它啊,就像是编程世界里的魔法师,能让复杂的事情变得简单又有趣。
别看它名字听起来高深莫测,其实用起来,嘿,那叫一个顺手!想象一下,你正在厨房里忙碌,准备做一顿大餐。
锅碗瓢盆一大堆,每种工具都有它特定的用途,对吧?但有时候,为了方便,你可能会给某个常用的工具起个昵称,比如那把大铲子,你干脆叫它“翻云覆雨手”,听起来就带劲儿!这就是typedef干的活儿,它给复杂的数据类型起个简单易记的名字,让你的代码读起来像诗一样流畅。
首先,咱们得明白,为啥需要typedef呢?想象一下,如果你在写代码时,经常需要用到一种特别复杂的数据类型,比如一个指向函数的指针,这个函数又返回另一个指向另一个函数的指针,哎呀妈呀,这说起来都绕口。
每次写这么一串长长的类型声明,是不是感觉头都大了?这时候,typedef就像是个贴心的助手,它能帮你把这一大串复杂的东西简化成一个简短的、容易记住的名字。
比如,你可以这么写:```ctypedef int* IntPtr;```看,多简单!以后每当你想用指向int的指针时,直接写IntPtr就行了,再也不用担心记不住那长长的类型声明了。
再比如,咱们定义一个结构体,用来存储学生的信息:```cstruct Student {char name[50];int age;float score;};```每次使用这个结构体时,都得写`struct Student`,挺麻烦的。
有了typedef,咱们可以这么做:```ctypedef struct Student {char name[50];int age;float score;} Student;```注意看,这里有个小技巧,我们把`typedef`和`struct`放在了一起,这样定义之后,直接就可以用`Student`来声明变量了,省去了`struct`这个前缀,代码看起来更清爽。
typedef用法
以上的定义可以分为两步形成
第一步:定义结构体 struct LNode{ ElemType data; struct LNode *next; }; 第二步:利用typedef定义别名 typedef struct LNode LNode; typedef struct LNode *LinkList; //所以明显LinkList 是结构体指针的名称
printf("\nb id a type of ARR2,b= \n"); for(i = 0;i<4;i++) for(j = 0;j<4;j++) b[i][j] = i+j+2; for(i = 0;i<4;i++) {for(j = 0;j<4;j++) printf("%3d",b[i][j]); printf("\n");} return 0; } 输出的就是一个 一维数组和 一个二维数组
为什么定义的名称要相同? 请看下面程序: typedef struct LNode { int *elem; int length; }SqList; 比较: 应改为 LNode La,Lb; struct LNode SqList La,Lb;
La,Lb
即:typedef stuct LNode SqList;
类似的可以做如下推广: typedef ARR2 ARR3[4]; //实际上等价于定义ARR3为一个三元数组 typedef int ARR3[4][4][4];
(1) (2) (3) (4) (5) (6)
(7)
CC++typedef用法详解(真的很详细)
CC++typedef⽤法详解(真的很详细)第⼀、四个⽤途⽤途⼀:定义⼀种类型的别名,⽽不只是简单的宏替换。
可以⽤作同时声明指针型的多个对象。
⽐如:char* pa, pb; // 这多数不符合我们的意图,它只声明了⼀个指向字符变量的指针,// 和⼀个字符变量;以下则可⾏:typedef char* PCHAR; // ⼀般⽤⼤写PCHAR pa, pb; // 可⾏,同时声明了两个指向字符变量的指针虽然:char *pa, *pb;也可⾏,但相对来说没有⽤typedef的形式直观,尤其在需要⼤量指针的地⽅,typedef的⽅式更省事。
⽤途⼆:⽤在旧的C的代码中(具体多旧没有查),帮助struct。
以前的代码中,声明struct新对象时,必须要带上struct,即形式为: struct 结构名对象名,如:struct tagPOINT1{int x;int y;};struct tagPOINT1 p1;⽽在C++中,则可以直接写:结构名对象名,即:tagPOINT1 p1;估计某⼈觉得经常多写⼀个struct太⿇烦了,于是就发明了:typedef struct tagPOINT{int x;int y;}POINT;POINT p1; // 这样就⽐原来的⽅式少写了⼀个struct,⽐较省事,尤其在⼤量使⽤的时候或许,在C++中,typedef的这种⽤途⼆不是很⼤,但是理解了它,对掌握以前的旧代码还是有帮助的,毕竟我们在项⽬中有可能会遇到较早些年代遗留下来的代码。
⽤途三:⽤typedef来定义与平台⽆关的类型。
⽐如定义⼀个叫 REAL 的浮点类型,在⽬标平台⼀上,让它表⽰最⾼精度的类型为:typedef long double REAL;在不⽀持 long double 的平台⼆上,改为:typedef double REAL;在连 double 都不⽀持的平台三上,改为:typedef float REAL;也就是说,当跨平台时,只要改下 typedef 本⾝就⾏,不⽤对其他源码做任何修改。
python typedef用法
Python typedef用法1. 介绍typedef的概念和作用typedef是C语言中的一个关键字,用于定义新的数据类型,是类型定义的缩写。
在C语言中,当我们需要定义一个新的数据类型时,可以使用typedef来简化代码,并增加代码的可读性。
在Python中,虽然没有typedef这个关键字,但是我们可以通过一些方法来实现类似的功能。
2. 在Python中使用自定义类来实现typedef在Python中,我们可以使用自定义类来实现类似C语言中的typedef功能。
我们可以定义一个Point类来表示二维坐标点:```pythonclass Point:def __init__(self, x, y):self.x = xself.y = y```这样,我们就可以使用Point类来表示二维坐标点,增加代码的可读性。
3. 在Python中使用dtuple来实现typedefPython的collections模块中提供了一个namedtuple函数,可以用来创建一个命名元组,即一个带有字段名的元组。
我们可以使用namedtuple来定义新的数据类型,类似于C语言中的typedef功能。
```pythonfrom collections import namedtuplePoint = namedtuple('Point', ['x', 'y'])```这样,我们就可以使用Point来表示二维坐标点,增加代码的可读性。
4. 在Python中使用typehint来实现typedef在Python 3.5及以上版本中,引入了type hint的概念,可以用来标注函数参数和返回值的类型。
我们可以使用type hint来定义新的数据类型,类似于C语言中的typedef功能。
```pythonfrom typing import TuplePoint = Tuple[int, int]```这样,我们就可以使用Point来表示二维坐标点,增加代码的可读性。
C语言typedef用法总结
C语言typedef用法总结黄海涛,2012-3-11C语言中的typedef可以让人感觉很清新,但也可以让人感觉神秘。
当你一层层剥开它的时候,神秘的面纱终会摘下……让我们一起来探究其中的秘密吧!一、概述1、类型定义符typedefC语言提供了一个称为typedef的工具,它允许你为各种数据类型定义新的名字。
定义形式:typedef 原类型名新类型名;它的格式与变量声明完全一样,只是把typedef这个关键字放在声明的前面,但typedef并不创建变量,而是为指定类型引入一个新的名字。
2、实质其实质是:为现有类型取个新名字,它并没有引入新的类型。
typedef是一种声明形式,它为一种类型引入新的名字,而不是产生新的类型,也不会为变量分配空间。
3、作用时机在某些方面,typedef类似于宏文本替换,但typedef是类型定义符,在编译时会有相应类型的检查。
typedef是由编译器解释的。
▲typedef与#define的区别A.#define后面没有分号,而typedef后面有分号;B.#define不是关键字,而typedef是关键字;C.宏定义中宏名紧跟着#define,而typedef中的类型名并不紧接其后;D.可以用其他类型说明符对宏名进行扩展,但对typedef定义的类型名却不行;例如:E.在连续几个变量声明中,typedef定义的类型名可以保证声明中所有的变量均为同一种类型,而#define定义的宏名则无法保证。
4、使用原因1)表达方式更简洁,简化编程;2)使程序参数化,提高程序的可移植性;3)为程序提供更好的说明性,可以引入一个易记且意义明确的新名字,提升可维护性。
5、缺点允许一些看上去混乱的语法,可以把几个声明放在一个声明中。
如:二、使用typedef声明定义时的限制1、2、3、存储类关键字:auto、extern、register、static与typedef但在存储类说明符中,typedef是个例外,它不会真正影响对象的存储特性。
关于typedef的用法
一.基本概念剖析int* (*a[5])(int, char*); //#1void (*b[10]) (void (*)()); //#2double(*)() (*pa)[9]; //#3 1.C语言中函数声明和数组声明。
函数声明一般是这样:int fun(int, double);对应函数指针(pointer to function)的声明是这样:int (*pf)(int, double);可以这样使用:pf = &fun; //赋值(assignment)操作(*pf)(5, 8.9);//函数调用操作也请注意,C语言本身提供了一种简写方式如下:pf = fun; // 赋值(assignment)操作pf(5, 8.9); // 函数调用操作不过我本人不是很喜欢这种简写,它对初学者带来了比较多的迷惑。
数组声明一般是这样:int a[5];对于数组指针(pointer to array)的声明是这样:int (*pa)[5];可以这样使用:pa = &a;// 赋值(assignment)操作int i = (*pa)[2];// 将a[2]赋值给i;(指针数组int *a[10],数组里面的元素是指针)2.有了上面的基础,我们就可以对付开头的三只纸老虎了!:)这个时候你需要复习一下各种运算符的优先顺序和结合顺序了,顺便找本书看看就够了。
#1:int* (*a[5])(int, char*);首先看到标识符名a,“[]”优先级大于“*”,a与“[5]”先结合。
所以a是一个数组,这个数组有5个元素,每一个元素都是一个指针,指针指向“(int, char*)”,对,指向一个函数,函数参数是“int, char*”,返回值是“int*”。
完毕,我们干掉了第一个纸老虎。
:)#2:void (*b[10]) (void (*)());b是一个数组,这个数组有10个元素,每一个元素都是一个指针,指针指向一个函数,函数参数是“void (*)()”【注1】,返回值是“void”。
typedef用法
typedef用法typedef是C/C++的关键字,它可以给现有的类型定义一个别名。
使用typedef后,程序中可以使用别名替换原有类型名,提高代码的可读性,提高维护的便捷性。
它的形式很简单:typedef type alias;它的意思是让编译器根据type来理解alias,相当于alias是一个type类型名的别名,也就是说alias类型完全等同于type类型。
以下将以实例展开typedef的用法:(1)给原有类型定义别名typedef long MY_LONG;//给long类型定义一个别名MY_LONG MY_LONG l1 = -32L;(2)给指针类型定义别名typedef int *pInt;pInt p1, p2;(3)给数组类型定义别名typedef int ARR[3];ARR ar1 = { 1, 2, 3 };(4)给函数类型定义别名typedef void (*pfnFUNC)(int);void func(int n){tprintf(func : %dn);}pfnFUNC pf1 = func;以上就是typedef用法的示例,它可以用来替换一般类型,指针类型,数组类型和函数类型,使代码中更加直观,简单,易读易维护,其中给函数定义别名对使用指针函数特别有用。
由于typedef是C/C++语言内置的关键字,在实际的编程中,经常会需要用它来给特定类型定义一个别名,这种情况可能出现在需要使用复杂类型的时候,可以用一个简洁明了的名字取代长且难以理解的类型,提升代码可读性,减少编程中出错的几率,使维护变得更加便捷。
例如,当我们在某个应用程序中使用多线程时,可能会希望将每个线程的状态都记录下来,在这种情况下,可以使用一个用户自定义的结构定义每个线程的状态,这时候就可以使用typedef给该结构定义一个别名,从而提高代码的可读性。
typedef struct{tint state;tint flag;} thread_state;thread_state my_thread;总之,使用typedef可以给类型定义一个别名,用来替换原先类型名以提高代码的可读性和维护的便捷性,是C/C++很有用的一种语言特性。
typedef关键字用法
typedef用法1、为现有数据类型定义同义词typedef 使用最多的地方是创建易于记忆的类型名,用它来归档程序员的意图。
例如:typedef int size;此声明定义了一个int 的同义字,名字为size。
注意typedef 并不创建新的类型。
它仅仅为现有类型添加一个同义字。
你可以在任何需要int 的上下文中使用size:void measure(size * psz);size array[4];2、t ypedef 还可以掩饰复合类型,如指针和数组●数组例如:typedef char Line[81];表示使用Line代表具有81个元素的char类型数组。
如果要生成类似的数据可以使用如下形式:Line text, secondline;相当于char test[81];char secondline[81];●隐藏指针语法例如:typedef char * pstr;int mystrcmp(pstr, pstr);相当于int mystrcmp(char *,char *);注意:标准函数 strcmp()有两个‘const char *'类型的参数。
因此,它可能会误导人们象下面这样声明 mystrcmp(),int mystrcmp(const pstr, const pstr);这是错误的,‘const pstr'被解释为‘const char* ‘(一个指向char 的常量指针),而不是‘char *'(指向char 的指针)。
修改:添加,typedef const c pstr;记住:不管什么时候,只要为指针声明typedef,那么都要在最终的typedef 名称中加一个const,以使得该指针本身是常量,而不是对象●链表中应用例如:typedef struct node{char name[20];struct node *link;}stu;3、代码简化例如:typedef int (*PF) (const char *, const char *);使用PF 类型作为函数指针的同义字,该函数有两个const char * 类型的参数以及一个int 类型的返回值。
关键字typedef的使用方法
C/C++语言关键字typedef的使用方法typedef,顾名思义,为“类型定义”,可以解释为:将一种数据类型定义为某一个标识符,在程序中使用该标识符来实现相应数据类型变量的定义。
例如:typedef unsigned int UINT;int main (int argc, char *argv[]){unsigned int a; // it’s OKUINT b; // it’s OK, a and b are of the same type (int)// . . . // code references the symbol a and breturn 0;}上面的代码中,a和b属于同一种数据类型(unsigned int型),因为UINT标识符已经标示为unsigned int类型。
上面的代码看似简单,相信很多读者都用过这种方法,但这绝不是typedef的全部,下面介绍使用typedef定义复杂数据类型的几种用法。
1、定义结构体类型结构体是一种较为常见的数据类型,在C/C++程序设计中使用的非常广泛。
下面的代码就是结构体类型的一个应用:#include <iostream.h>int main (int argc, char *argv[]){struct {int x; int y;} point_a, point_b;point_a.x = 10;point_a.y = 10;point_b.x = 0;point_b.y = 0;ios::sync_with_stdio();cout << point_a.x + point_a.y << endl;cout << point_b.x + point_b.y << endl;return 0;}上面的代码包含了两个结构体变量:point_a和point_b,它们的数据类型相同,都是struct {int x; int y;}类型。
typedef
引用typedef的详细用法MFC 2010-08-12 16:12:22 阅读200 评论0 字号:大中小订阅本文引用自thatax《typedef的详细用法》引用thatax的typedef的详细用法typedef是c/c++代码中经常用到的一个关键字. 他的主要做用是给变量类型定义一个别名.从而达到代码简化, 促进跨平台开发的目的.下面是typedef的最经常的用法:typedef struct{int a;int b;}MY_TYPE;这里把一个未命名结构直接取了一个叫MY_TYPE的别名, 这样如果你想定义结构的实例的时候就可以这样:MY_TYPE tmp;这是typedef的第一种用法. 比较简单. 就是typedef 原变量类型别名相似的例子:typedef unsigned long DWORD;typedef void far *LPVOID; //void far *是原变量类型, 表示一个void 型指针(far 在32位系统里面已经没有意义了)等等typedef还有第二种用法. 可能这种用法初学者没有接触过.比如:typedef int (*MYFUN)(int, int);这种用法一般用在给函数定义别名的时候.(其实质还是和上面的用法一样的)上面的例子定义MYFUN 是一个函数指针, 函数类型是带两个int 参数, 返回一个int在分析这种形式的定义的时候可以用下面的方法:先去掉typedef 和别名, 剩下的就是原变量的类型.比如上面的例子:去掉typedef和MYFUN以后就剩:int (*)(int, int)************************************************************************************************************************************************************************************************************************************一.基本概念剖析int* (*a[5])(int, char*); //#1void (*b[10]) (void (*)()); //#2double(*)() (*pa)[9]; //#31.C语言中函数声明和数组声明。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
typedef用法
1、为现有数据类型定义同义词
typedef使用最多的地方是创建易于记忆的类型名,用它来归档程序员的意图。
例如:
typedef int size;
此声明定义了一个int的同义字,名字为size。
注意typedef并不创建新的类型。
它仅仅为现有类型添加一个同义字。
你可以在任何需要int的上下文中使用size:
void measure(size*psz);
size array[4];
2、typedef还可以掩饰复合类型,如指针和数组
z数组
例如:typedef char Line[81];表示使用Line代表具有81个元素的char类型数组。
如果要生成类似的数据可以使用如下形式:Line text,secondline;
相当于char test[81];char secondline[81];
z隐藏指针语法
例如:typedef char*pstr;
int mystrcmp(pstr,pstr);相当于
int mystrcmp(char*,char*);
注意:标准函数strcmp()有两个‘const char*'类型的参数。
因此,它可能会误导人们象下面这样声明mystrcmp(),
int mystrcmp(const pstr,const pstr);
这是错误的,‘const pstr'被解释为‘const char*‘(一个指向char的常量指针),而不是‘char*'(指向char的指针)。
修改:添加,typedef const c pstr;
记住:不管什么时候,只要为指针声明typedef,那么都要在最终的typedef 名称中加一个const,以使得该指针本身是常量,而不是对象
z链表中应用
例如:
typedef struct node
{
char name[20];
struct node*link;
}stu;
3、代码简化
例如:typedef int(*PF)(const char*,const char*);
使用PF类型作为函数指针的同义字,该函数有两个const char*类型的参数以及一个int类型的返回值。
4、促进扩平台开发
typedef有另外一个重要的用途,那就是定义机器无关的类型,例如,你可以定义一个叫REAL的浮点类型,在目标机器上它可以i获得最高的精度:
typedef long double REAL;
在不支持long double的机器上,该typedef看起来会是下面这样:
typedef double REAL;
并且,在连double都不支持的机器上,该typedef看起来会是这样:、
typedef float REAL;
你不用对源代码做任何修改,便可以在每一种平台上编译这个使用REAL类型的应用程序。
唯一要改的是typedef本身。
在大多数情况下,甚至这个微小的变动完全都可以通过奇妙的条件编译来自动实现。
不是吗?标准库广泛地使用typedef来创建这样的平台无关类型:size_t,ptrdiff和fpos_t就是其中的例子。
此外,象std::string和std::ofstream这样的typedef还隐藏了长长的,难以理解的模板特化语法
5、C语言实例
(1)typedef long byte_4;给已知数据类型long起个新名字,叫byte_4。
(2)typedef struct tagMyStruct
{
int iNum;
long lLength;
}MyStruct;
完成两个工作,一是定义了struct tagMyStruct结构,可以用struct tagMyStruct varName来定义变量,但要注意,使用tagMyStruct varName来定义变量是不对的,因为struct和tagMyStruct合在一起才能表示一个结构类型。
二是typedef为这个新的结构起了一个名字,叫MyStruct。
可以使用MyStruct varName来定义变量。
6、typedef与define的区别
(1)例子:typedef char*pStr1;
#define pStr2char*
pStr1s1,s2;
pStr2s3,s4;
在上述的变量定义中,s1、s2、s3都被定义为char*,而s4则定义成了char,不是我们所预期的指针变量,根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。
(2)例子:
#define f(x)x*x
main()
{
int a=6,b=2,c;
c=f(a)/f(b);//被解释为c=a*a/b*b即6*6/2*2=36
printf("%d\\n",c);
}
以下程序的输出结果是:36
注意:使用#define定义时,如果定义中包含表达式,必须使用括号,则上述定义应该如下定义才对:
#define f(x)(x*x)
(3)define宏定义有一个特别的长处:可以使用#ifdef,#ifndef等来进行逻辑判断,还可以使用#undef来取消定义。
(4)typedef也有一个特别的长处:它符合范围规则,使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内(取决于此变量定义的位置),而宏定义则没有这种特性。
(5)对复杂变量建立一个类型别名的方法很简单,你只要在传统的变量声明表达式里用类型名替代变量名,然后把关键字typedef加在该语句的开头就行了。