typedef和define具体的详细区别

本文详细介绍了C语言中的预处理指令#define与类型定义typedef的区别及应用,并通过实例讲解了const修饰符与指针结合时的不同含义。
1) #define是预处理指令,在编译预处理时进行简单的替换,不作正确性检查,不关含义是否正确照样带入,只有在编译已被展开的源程序时才会发现可能的错误并报错。例如:
#define PI 3.1415926
程序中的:area=PI*r*r 会替换为3.1415926*r*r
如果你把#define语句中的数字9 写成字母g 预处理也照样带入。

2)typedef是在编译时处理的。它在自己的作用域内给一个已经存在的类型一个别名,但是You cannot use the typedef specifier inside a function definition。

3)typedef int * int_ptr;

#define int_ptr int *
作用都是用int_ptr代表 int * ,但是二者不同,正如前面所说 ,#define在预处理 时进行简单的替换,而typedef不是简单替换 ,而是采用如同定义变量的方法那样来声明一种类型。也就是说;

//refer to (xzgyb(老达摩))
#define int_ptr int *
int_ptr a, b; //相当于int * a, b; 只是简单的宏替换

typedef int* int_ptr;
int_ptr a, b; //a, b 都为指向int的指针,typedef为int* 引入了一个新的助记符

这也说明了为什么下面观点成立
//QunKangLi(维护成本与程序员的创造力的平方成正比)
typedef int * pint ;
#define PINT int *

那么:
const pint p ;//p不可更改,但p指向的内容可更改
const PINT p ;//p可更改,但是p指向的内容不可更改。

pint是一种指针类型 const pint p 就是把指针给锁住了 p不可更改
而const PINT p 是const int * p 锁的是指针p所指的对象。

3)也许您已经注意到#define 不是语句 不要在行末加分号,否则 会连分号一块置换。
而关于 上面pint 指针锁定,p不可修改。 PINT 是锁定指针p所指的对象。可以用下面的例子:

首先说一下const

const在声明变量时,说明该变量的值在其生存周期里是不可以改变的。

对一般的变量而言。const的位置不同表达的意思是一样的,如:

int const a

const int a

这俩者是一样的,凭你喜好来选择。

但对于指针中却不一样,位置不同所表达的含义却不一样。如:

int const * pci; 

//指向(整形常量)的指针。指针(pci)可改变,指针指向的值(&pci)不能改变

int *const cpi

//指向整形的(常量指针)。指针(cpi)不能变,指针指向的值(&cpi)可以改变

int const * const cpci

//指向(整形常量)的(常量指针)。指针和指针指向的值都不能改变

#include <stdio.h>  
int main()  
{  
    int a = 1 ,b =2, c = 3;  
    int const *pci = &a;        //指向(整形常量)的指针。指针(pci)可改变,指针指向的值(&pci)不能改变  
    int *const cpi = &b; //指向整形的(常量指针)。指针(cpi)不能变,指针指向的值(&cpi)可以改变  
    int const * const cpci = &c;//指向(整形常量)的(常量指针)。二者都不能变  
  
    printf("原始赋值后(地址):pci=%5x  *cpi = %5x  *cpci = %5x\n",pci,cpi,cpci);  
    printf("原始赋值后(数值):*pci=%d  *cpi = %d  *cpci = %d\n",*pci,*cpi,*cpci);  
  
    pci = &b;   //正确。pci的指针可以改变   地址改变到了b
    //*pci = 8;   //出错。pci的指针指向的变量的值不能改变  
  
    //cpi = &c;  //出错。cpi的指针的不能改变  
    *cpi = 8;    //正确。cpi的指针指向的变量的值不能改变  这里将b的值改成了8 
  
    //cpci = &a; //出错。cpci的指针的不能改变  
    //*cpci = 8;   //出错。cpci指针指向的变量的值不能改变  
    printf("改变赋值后(地址):pci=%5x  *cpi = %5x  *cpci = %5x\n",pci,cpi,cpci);  
    printf("改变赋值后(数值):*pci=%d  *cpi = %d  *cpci = %d\n",*pci,*cpi,*cpci);  
  
    return 0;  
      
}  
<think> 我们被要求解释typedef#define的用法区别。根据引用资料,我们可以总结如下: 核心区别: 1. 本质不同: - typedef是C/C++关键字,用于为已有类型创建别名,发生在编译阶段。 - #define是预处理指令,进行简单的文本替换,发生在预处理阶段。 2. 类型安全性: - typedef有类型检查,更安全。 - #define无类型检查,只是文本替换,容易出错。 3. 作用域: - typedef有作用域限制(如在函数内定义的typedef只在该函数内有效)。 - #define从定义点开始到文件末尾(除非用#undef取消),不受作用域限制。 4. 对指针的处理: - typedef能够正确处理指针类型。 - #define在处理指针时容易出错(如一次定义多个变量时,只有第一个是指针)。 5. 复杂类型的定义能力: - typedef可以定义复杂的类型别名,如结构体、函数指针等。 - #define也可以定义,但容易出错,尤其是有多个语句时需要用括号等。 具体用法对比: 1. 基本类型别名: ```c typedef int Integer; // 定义Integer为int的别名 #define INTEGER int // 预处理时将所有INTEGER替换为int Integer a; // 等同于 int a; INTEGER b; // 预处理后变成 int b; ``` 2. 指针类型别名: ```c typedef int* IntPtr; #define INTPTR int* IntPtr p1, p2; // p1p2都是int指针 INTPTR p3, p4; // 预处理后变成 int* p3, p4; 即p3是指针,p4是int ``` 3. 结构体别名: ```c // 使用typedef typedef struct { int x; int y; } Point; Point p1; // 可以直接用Point声明变量 // 使用#define #define POINT struct point struct point { int x; int y; }; POINT p2; // 等同于struct point p2; ``` 4. 函数指针别名: ```c typedef void (*FuncPtr)(int); #define FUNCPTR void (*)(int) FuncPtr f1; // 定义了一个函数指针 // 用宏定义则无法直接定义变量,需要写成: void (*f2)(int); // 相当于用宏替换需要写全 // 或者重新定义宏为完整类型: #define FUNCPTR_T void (*)(int) FUNCPTR_T f3; // 但这样定义多个变量同样有问题 ``` 5. 作用域示例: ```c void func() { typedef int LocalInt; // 只在func内部有效 LocalInt a = 10; } // 这里LocalInt无效 #define GLOBAL_DEF int // 从定义开始,后面都有效 void func2() { GLOBAL_DEF b = 20; // 有效 } ``` 6. 处理复杂类型(如数组): ```c typedef int ArrayType[10]; #define ARRAY_TYPE int[10] ArrayType arr1; // arr1是10个int的数组 ARRAY_TYPE arr2; // 预处理后变成 int[10] arr2; 但这样写语法错误 // 正确写法应该用宏定义变量为:int arr2[10]; // 所以宏定义数组类型不方便 ``` 注意事项: - 当定义与平台相关的类型时(如int32),通常使用typedef,因为它更安全。 - 宏定义可以定义常量、条件编译等,而typedef只能定义类型别名。 常见错误示例(引用[4]): ```c #define integer int* integer a, b; // 展开后为 int* a, b; 这里b是int类型而不是指针 ``` 而用typedef则不会: ```c typedef int* IntPtr; IntPtr a, b; // ab都是int指针 ``` 总结表格: | 特性 | typedef | #define | |--------------|----------------------------------|----------------------------------| | 本质 | 关键字(编译时处理) | 预处理指令(预处理时替换) | | 类型检查 | 有 | 无 | | 指针定义 | 正确(多个变量均为指针) | 错误(多个变量时只有第一个是指针) | | 作用域 | 遵守作用域规则 | 全局(直到#undef) | | 复杂类型支持 | 支持(结构体、函数指针等) | 支持但易错 | | 其他功能 | 只能定义类型别名 | 可定义常量、代码片段等 | 因此,在定义类型别名时,尤其是复杂类型或需要类型安全时,推荐使用typedef。而#define则更适合定义常量、条件编译等。 相关问题: 1. 在什么情况下必须使用#define而不能用typedef? 2. 如何用typedef定义函数指针类型?请举例说明。 3. 为什么在头文件中使用typedef时需要考虑重定义问题?如何避免? </think> ### typedef 与 #define 用法区别详解 #### 一、本质区别 | 特性 | typedef | #define | |--------------|----------------------------------|----------------------------------| | **本质** | 编译器指令(类型别名声明) | 预处理指令(文本替换) | | **处理阶段** | 编译阶段(有类型检查) | 预处理阶段(无类型检查) | | **作用域** | 遵守块作用域(局部/全局)[^1] | 全局(从定义点到文件结尾) | | **指针处理** | 正确处理指针类型 | 易出错:`#define PTR int*` 导致 `PTR a,b` 中 `b` 非指针[^4] | | **类型安全** | 类型安全(编译器校验) | 不安全(纯文本替换) | #### 二、典型用法对比 1. **基本类型别名** ```c typedef int Distance; // ✓ 类型安全 Distance d1 = 100; // 等同于 int d1 = 100 #define LENGTH int // ! 文本替换 LENGTH len = 50; // 预处理后变为 int len = 50 ``` 2. **结构体别名** ```c // typedef 隐藏实现细节 typedef struct { // 匿名结构体 float x, y; } Point; // Point 可直接使用 Point p = {1.0, 2.0}; // #define 需显式结构体名 #define POINT struct point // 预处理宏 struct point { float x, y; }; POINT q = {3.0, 4.0}; // 等同于 struct point q ``` 3. **函数指针类型** ```c // typedef 清晰定义 typedef void (*Callback)(int); // Callback 为函数指针类型 Callback func = &my_function; // #define 可读性差 #define CALLBACK void (*)(int) CALLBACK func2 = &my_function; // 展开后 void (*func2)(int) ``` 4. **数组类型定义** ```c typedef int Vector[3]; // Vector 是 int[3] 类型 Vector v = {1, 2, 3}; // 等同于 int v[3] #define ARRAY int[3] // 危险:文本替换 ARRAY arr = {4,5,6}; // 预处理后变为 int[3] arr = {...} (语法错误) ``` #### 三、关键差异点 1. **指针陷阱示例** ```c typedef char* String; // ✓ String a,b 都是 char 指针 String s1, s2; #define STRING char* // ! 仅第一个变量为指针 STRING s3, s4; // 展开为 char* s3, s4 → s4 是 char 类型! ``` 2. **作用域限制** ```c void func() { typedef int Counter; // 仅函数内有效 Counter c = 0; } // Counter c2; // 错误!作用域外不可用 #define MAX 100 // 宏全局有效 ``` 3. **调试支持** - `typedef` 定义的别名会被编译器保留,调试时可显示类型名 - `#define` 定义的宏在预处理后消失,调试时只显示原始文本 #### 四、选用原则 | **场景** | 推荐选择 | |-------------------------------|----------| | 创建类型别名(尤其复杂类型) | typedef | | 函数指针类型定义 | typedef | | 跨模块接口封装 | typedef | | 常量定义(如 `#define PI 3.14`) | #define | | 条件编译(`#ifdef DEBUG`) | #define | | 文本替换宏(如 `#define MIN(a,b) ((a)<(b)?(a):(b))`) | #define | > 经验法则:**优先用 `typedef` 定义类型,用 `#define` 定义常量或代码片段**[^2][^3] --- ####
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值