C++?typedef常見用法有哪些

本篇內容主要講解“C++ typedef常見用法有哪些”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C++ typedef常見用法有哪些”吧!

typedef的4種常見用法：

• 給已定義的變量類型起個別名

• 定義函數指針類型

• 定義數組指針類型

• 為復雜的聲明定義一個新的簡單的別名

總結一句話：“加不加typedef，類型是一樣的"，這句話可以這樣理解：

沒加typedef之前如果是個數組，那么加typedef之后就是數組類型；

沒加typedef之前如果是個函數指針，那么加typedef之后就是函數指針類型；

沒加typedef之前如果是個指針數組，那么加typedef之后就是指針數組類型。

typedef char TA[5];//定義數組類型
typedef char *TB[5];//定義指針數組類型,TB定義的變量為含5個char*指針元素的數組(指針數組類型)
typedef char *(TC[5]);//指針數組類型，因為[]的結合優先級最高，所以加不加()沒啥區別，TC等價于TB
typedef char (*TD)[5];//數組指針類型，TD指向一個5容量的char數組

后文簡單介紹下指針數組和數組指針

typedef的4種用法詳解

1、給已定義的變量類型起個別名

（1）typedef unsigned char uin8_t; //uint8_t就是unsigned char的別名，這是最基礎的用法；

（2）結構體用法——作用是給struct __person起了個別名person_t，這種這種用法也很基礎；

struct __person
{
    char    name[20];
    uint8_t age;
    uint8_t height;
}
typedef __person person_t;
 
//以上兩段代碼也可合并為一段，如下：
typedef struct __person
{
    char    name[20];
    uint8_t age;
    uint8_t height;
}person_t;

2、定義函數指針類型

首先來看一下如何定義函數指針變量，然后再看如何定義函數指針類型。

（1）定義函數指針變量

定義了一個函數指針變量pFunc，它可以指向這樣的函數：返回值為int，形參為char*、int：

int (*pFunc)(char *frame, int len);

定義了5個函數指針變量：pFunc[0]、pFunc[1]···，它們都可以指向這樣的函數：返回值為int*，形參為int：

int *(*pFunc[5])(int len);

（2）定義函數指針類型

定義函數指針類型，必須使用typedef，方法就是，在“定義函數指針變量”前加上typedef。

typedef int (*pFunc_t)(char *frame, int len);//定義了一個類型pFunc_t

舉例：

typedef  int (*pFunc_t)(char *frame, int len);//定義了一個類型pFunc_t
int read_voltage(char *data, int len)
{
    int voltage = 0;
    ···//其他功能代碼
    return voltage;
}
int main(void)
{
    pFunc_t   pHandler = read_voltage;//使用類型pFunc_t來定義函數指針變量
    ···//其他功能代碼
}

3、定義數組指針類型

這個問題還是分兩步，先看如何定義數組指針變量，再看如何定義數組指針類型。

（1）定義數組指針變量

• int(*pArr)[5];//定義了一個數組指針變量pArr，pArr可以指向一個int [5]的一維數組

• char(*pArr)[4][5];///定義了一個數組指針變量pArr，pArr可以指向一個char[4][5]的二維數組

char(*pArr)[4][5];///定義了一個數組指針變量pArr，pArr可以指向一個char[4][5]的二維數組

int(*pArr)[5];//pArr是一個指向含5個int元素的一維數組的指針變量
int a[5] = {1,2,3,4,5};
int b[6] = {1,2,3,4,5,6};
pArr = &a;//完全合法，無警告
pArr = a;//發生編譯警告，賦值時類型不匹配：a的類型為int(*)，而pArr的類型為int(*)[5]
pArr = &a[0];//發生編譯警告，賦值時類型不匹配：a的類型為int(*)，而pArr的類型為int(*)[5]
pArr = &b;//發生編譯警告，賦值時類型不匹配：&b的類型為int(*)[6]，而pArr的類型為int(*)[5]
pArr = (int(*)[5])&b;//類型強制轉換為int(*)[5]，完全合法，無警告

上面這個例子中，使用類型轉換時，代碼的樣式略顯復雜，試想，我們如果強轉為一個結構體數組的指針，那這個強轉的括號里的內容得多長！這就直接影響了代碼的可讀性，因此，強轉后的類型應該定義出來。

（2）定義數組指針類型

如同上面定義函數指針類型的方法，直接在前面加typedef即可，例如：

typedef int (*pArr_t)[5];//定義了一個指針類型pArr_t，該類型的指針可以指向含5個int元素的數組

typedef int(*pArr_t)[5];//定義一個指針類型，該類型的指針可以指向含5個int元素的一維數組
 
int main(void)
{
    int a[5] = {1,2,3,4,5};
    int b[6] = {1,2,3,4,5,6};
    pArr_t pA;//定義數組指針變量pA
    pA= &a;//完全合法，無警告    
    pA= (pArr_t)&b;//類型強制轉換為pArr_t，完全合法，無警告
}

（3）定義數組類型

如果我們想聲明一個含5個int元素的一維數組，一般會這么寫：int a[5];

如果我們想聲明多個含5個int元素的一維數組，一般會這么寫：int a1[5], a2[5], a3[5]···，或者 a[N][5]

可見，對于定義多個一維數組，寫起來略顯復雜，這時，我們就應該把數組定義為一個類型，例如：

typedef int arr_t[5];//定義了一個數組類型arr_t，該類型的變量是個數組。

typedef int arr_t[5];
int main(void)
{
    arr_t d;        //d是個數組，這一行等價于:  int d[5];
    arr_t b1, b2, b3;//b1, b2, b3都是數組
    
    d[0] = 1;
    d[1] = 2;
    d[4] = 134;
    d[5] = 253;//編譯警告：下標越界
}

4、為復雜的聲明定義一個新的簡單的別名

為復雜的聲明定義一個新的簡單的別名。方法是：在原來的聲明里逐步用別名替換一部分復雜聲明，如此循環，把帶變量名的部分留到最后替換，得到的就是原聲明的最簡化版。舉例：

int *(*a[5])(int, char*);//原聲明
 
typedef int *(*pFun)(int, char*); //變量名為a，直接用一個新別名pFun替換a就可以了
pFun a[5];//原聲明的最簡化版

void (*b[10]) (void (*)());//原聲明
 
typedef void (*pFunParam)();//變量名為b，先替換右邊部分括號里的，pFunParam為別名一
typedef void (*pFunx)(pFunParam);//再替換左邊的變量b，pFunx為別名二
 
pFunx b[10];//原聲明的最簡化版

兩大陷阱

陷阱一：記住，typedef是定義了一種類型的新別名，不同于宏，它不是簡單的字符串替換。

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

typedef 與 #define的區別

案例一：

通常講，typedef要比#define要好，特別是在有指針的場合。請看例子：

typedef char *pStr1;  
#define pStr2 char *;  
pStr1 s1, s2;  
pStr2 s3, s4;

在上述的變量定義中，s1、s2、s3都被定義為char *，而s4則定義成了char，不是我們所預期的指針變量，根本原因就在于#define只是簡單的字符串替換而typedef則是為一個類型起新名字。

案例二：

下面的代碼中編譯器會報一個錯誤，你知道是哪個語句錯了嗎？

typedef char * pStr;  
char str[4] = "abc";  
const char *p1 = str;  
const pStr p2 = str;  
p1++;  
p2++;

是p2++出錯了。這個問題再一次提醒我們：typedef和#define不同，它不是簡單的文本替換。上述代碼中const pStr p2并不等于const char * p2。const pStr p2和const long x本質上沒有區別，都是對變量進行只讀限制，只不過此處變量p2的數據類型是我們自己定義的而不是系統固有類型而已。因此，const pStr p2的含義是：限定數據類型為pStr 的變量p2為只讀，因此p2++錯誤。

對于指針數組和數組指針的概念，相信很多人經常會感到迷惑，見到二者一時不能分辨究竟對應哪一個才是對的。接下來我們來分析一下二者區別。

我們來看一下這個示例代碼：

int *ptr1[10];
int (*ptr2)[10];

對于上述代碼語句，你是否能分清哪一句代碼聲明的是指針數組，而哪一句代碼聲明的又是數組指針呢？

答案是第一行代碼聲明的ptr1是一個指針數組，數組名為 ptr1，而“int*”修飾的是數組的內容，該數組包含 5 個 指向 int 類型 數據的指針。第二行代碼聲明的ptr2則是一個 數組的指針 ，指針變量名為 ptr2，而 int 修飾的是數組的內容，即數組的每個元素。即ptr2 是一個指針，它指向一個包含 5 個 int 類型數據的數組。

到此，相信大家對“C++ typedef常見用法有哪些”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！