typedef與#define的區別

一、typedef

typedef並非定義一個新的類型而是給已有的類型起一個別名，在這一點上與引用的含義相似，引用是變量或對象的別名，而typedef定義的是類型的別名。

它是語言編譯過程的一部分，但它並不實際分配內存空間。typedef能夠加強程序的可讀性，以及標識符的靈活性，但它也有「非直觀性」等缺點。

typedef的做用包括：

（1）簡化複雜的類型聲明

簡化複雜的類型聲明，或給已有類型起一含義明確的別名。如：

typedef bool (*FuncPointer)(int, double);	
//聲明瞭一個返回 bool 類型並帶有兩個(int和double)形參的函數的指針類型FuncPointer
FuncPointer pFunc;	
//聲明瞭一個FuncPointer類型的函數指針對象pFunc

（2）定義與平臺無關的類型

用typedef來定義與平臺無關的類型，屏蔽不一樣平臺的類型差別化。如：

//好比定義一個叫 REAL的浮點類型，在目標平臺一上，讓它表示最高精度的類型爲：
typedef long double REAL;
//在不支持 long double 的平臺二上，改成：
typedef double REAL;
//在連 double 都不支持的平臺三上，改成：
typedef float REAL;
//也就是說，當跨平臺時，只要改下 typedef 自己就行，不用對其餘源碼作任何修改。

標準庫就普遍使用了這個技巧，好比size_t。另外，由於typedef是定義了一種類型的新別名，不是簡單的字符串替換，因此它比宏來得穩健。

（3）與struct的結合使用

在C++中，struct與class的做用相同，就是默認的訪問權限不一樣，struct默認爲public，而class默認爲private的。

在C++中能夠採用以下兩種方式定義結構體：

struct Person
{
	string name;
	int age;
	float height;
};
Person person;
//定義一個Struct的類型Person，定義一個Person的對象person。

struct Person
{
	string name;
	int age;
	float height;
}person;
//定義一個Struct的類型Person，在定義的同時還聲明瞭一個Person的對象person。

可是在C語言中，struct的定義和聲明要用typedef。

typedef struct __Person
{
	string name;
	int age;
	float height;
}Person;	
//這是Person是結構體的一個別名
Person person;

若是沒有typedef就必須用struct Person person；來聲明，如：

struct Person
{
	string name;
	int age;
	float height;
};
struct Person person;

或

struct Person
{
	string name;
	int age;
	float height;
}person;	
//person是Person的對象

二、#define

#define爲宏定義語句，一般用它來定義常量(包括無參量與帶參量)，以及用來實現那些「表面似和藹、背後一長串」的宏，它自己並不在編譯過程當中進行，而是在這以前(預處理過程)就已經完成了，但也所以難以發現潛在的錯誤及其它代碼維護問題。

示例如：

#define   INT             int
#define   TRUE         1
#define   Add(a,b)     ((a)+(b));
#define   Loop_10    for (int i=0; i<10; i++)

三、typedef與#define的區別

‍（1）執行時間不一樣‍

關鍵字typedef在編譯階段有效，因爲是在編譯階段，所以typedef有類型檢查的功能。

#define則是宏定義，發生在預處理階段，也就是編譯以前，它只進行簡單而機械的字符串替換，而不進行任何檢查。

示例：

typedef會作相應的類型檢查：

typedef unsigned int UINT;

void func()
{
	UINT value = "abc";	// error C2440: 'initializing' : cannot convert from 'const char [4]' to 'UINT'
	cout << value << endl;
}

#define不作類型檢查：

//#define用法例子：
#define f(x) x*x
int main()
{
	int a=6, b=2, c;
	c=f(a) / f(b);
	printf("%d\n", c);
	return 0;
}

程序的輸出結果是：36，根本緣由就在於#define只是簡單的字符串替換。

（2）功能有差別

typedef用來定義類型的別名，定義與平臺無關的數據類型，與struct的結合使用等。

#define不僅是能夠爲類型取別名，還能夠定義常量、變量、編譯開關等。

（3）做用域不一樣

#define沒有做用域的限制，只要是以前預約義過的宏，在之後的程序中均可以使用。

而typedef有本身的做用域。

示例1：

沒有做用域的限制，只要是以前預約義過就能夠。

void func1()
{
	#define HW "HelloWorld";
}

void func2()
{
	string str = HW;
	cout << str << endl;
}

示例2：

而typedef有本身的做用域。

void func1()
{
	typedef unsigned int UINT;
}

void func2()
{
	UINT uValue = 5;
	//error C2065: 'UINT' : undeclared identifier
}

示例3：

class A
{
	typedef unsigned int UINT;
	UINT valueA;
	A() : valueA(0){}
};

class B
{
	UINT valueB;
	//error C2146: syntax error : missing ';' before identifier 'valueB'
	//error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
};

上面例子在B類中使用UINT會出錯，由於UINT只在類A的做用域中。此外，在類中用typedef定義的類型別名還具備相應的訪問權限。

示例4：

class A
{
	typedef unsigned int UINT;
	UINT valueA;
	A() : valueA(0){}
};

void func3()
{
	A::UINT i = 1;
	// error C2248: 'A::UINT' : cannot access private typedef declared in class 'A'
	//class默認是private訪問權限，若是是sruct則不會有問題
}

而給UINT加上public訪問權限後，則可編譯經過。

示例5：

class A
{
public:
	typedef unsigned int UINT;
	UINT valueA;
	A() : valueA(0){}
};

void func3()
{
	A::UINT i = 1;
	cout << i << endl;
}

（4）對指針的操做

兩者修飾指針類型時，做用不一樣。

typedef int * pint;
#define PINT int *

int i1 = 1, i2 = 2;

const pint p1 = &i1;	//p不可更改，p指向的內容能夠更改，至關於 int * const p;
const PINT p2 = &i2;	//p能夠更改，p指向的內容不能更改，至關於 const int *p；或 int const *p；

pint s1, s2;	//s1和s2都是int型指針
PINT s3, s4;	//至關於int * s3，s4；只有一個是指針。

void TestPointer()
{
	cout << "p1:" << p1 << "  *p1:" << *p1 << endl;
	//p1 = &i2;	//error C3892: 'p1' : you cannot assign to a variable that is const
	*p1 = 5;
	cout << "p1:" << p1 << "  *p1:" << *p1 << endl;

	cout << "p2:" << p2 << "  *p2:" << *p2 << endl;
	//*p2 = 10;	//error C3892: 'p2' : you cannot assign to a variable that is const
	p2 = &i1;
	cout << "p2:" << p2 << "  *p2:" << *p2 << endl;
}

結果：

p1:00EFD094  *p1:1

p1:00EFD094  *p1:5

p2:00EFD098  *p2:2

p2:00EFD094  *p2:5

四、typedef易錯點

（1）陷阱一 

記住，typedef是定義了一種類型的新別名，不一樣於宏，它不是簡單的字符串替換。好比： 

先定義： 

typedef   char*   PSTR;

而後： 

int   mystrcmp(const   PSTR,   const   PSTR);

const   PSTR實際上至關於const   char*嗎？不是的，它實際上至關於char*   const。 

緣由在於const給予了整個指針自己以常量性，也就是造成了常量指針char*   const。 

簡單來講，記住當const和typedef一塊兒出現時，typedef不會是簡單的字符串替換就行。

（2）陷阱二 

typedef在語法上是一個存儲類的關鍵字（如auto、extern、mutable、static、register等同樣），雖然它並不真正影響對象的存儲特性，如： 

typedef   static   int   INT2;   //不可行

編譯將失敗，會提示「指定了一個以上的存儲類」。