進入正文:
代碼簡化, 促進跨平臺開發的目的.
typedef 行爲有點像 #define 宏,用其實際類型替代同義字。
不同點:typedef 在編譯時被解釋,因此讓編譯器來應付超越預處理器能力的文本替換。
用法一:
typedef int (*MYFUN)(int,
int);
這種用法一般用在給函數定義別名的時候
上面的例子定義MYFUN 是一個函數指針,
函數類型是帶兩個int 參數, 返回一個int
在分析這種形式的定義的時候可以用下面的方法:
先去掉typedef 和別名, 剩下的就是原變量的類型.
去掉typedef和MYFUN以後就剩:
int (*)(int, int)
用法二:
typedef給變量類型定義一個別名.
typedef struct{
int a;
int b;
}MY_TYPE;
這裏把一個未命名結構直接取了一個叫MY_TYPE的別名, 這樣如果你想定義結構的實例的時候就可以這樣:
MY_TYPE tmp;
第二種用法:typedef 原變量類型 別名
簡單的函數指針的用法
//形式1:返回類型(*函數名)(參數表)
char(*pFun)(int);
char glFun(int a){
switch (a)
{
case 1:
return 'A';
default:
return 'E';
}
}
void main()
{
pFun =glFun;
printf("---------- %c \n", (*pFun)(2));
}
第一行定義了一個指針變量pFun.它是一個指向某種函數的指針,這種函數參數是一個int類型,返回值是char類型。只有第一句我們還無法使用這個指針,因爲我們還未對它進行賦值。
第二行定義了一個函數glFun().該函數正好是一個以int爲參數返回char的函數。我們要從指針的層次上理解函數-函數的函數名實際上就是一個指針,函數名指向該函數的代碼在內存中的首地址。
--------------------------------------
typedef:
typedef char(*pFun)(int) //跟上一行功能等同
/*typedef的功能是定義新的類型。第一句就是定義了一種PTRFUN的類型,並定義這種類型爲指向某種函數的指針,這種函數以一個int爲參數並返回char類型。*/
char glFun(int a);
pFun gl_pFun()
{
return glFun;
}
char glFun(int a){
switch (a)
{
case 1:
return 'A';
default:
return 'E';
}
}
void main()
{
pFun pf = gl_pFun();
printf("---------- %c \n", pf(2));
}
----------------------------------------------------------------------------------------------------------
//#include<iostream.h>
#include<stdio.h>
typedef int (*FP_CALC)(int, int);
//注意這裏不是函數聲明而是函數定義,它是一個地址,你可以直接輸出add看看
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;
}
//定義一個函數,參數爲op,返回一個指針。該指針類型爲 擁有兩個int參數、
//返回類型爲int 的函數指針。它的作用是根據操作符返回相應函數的地址
FP_CALC calc_func(char op)
{
switch (op)
{
case '+': return add;//返回函數的地址
case '-': return sub;
case '*': return mul;
case '/': return div;
default:
return NULL;
}
return NULL;
}
//s_calc_func爲函數,它的參數是 op,
//返回值爲一個擁有 兩個int參數、返回類型爲int 的函數指針
int (*s_calc_func(char op)) (int, int)
{
return calc_func(op);
}
//最終用戶直接調用的函數,該函數接收兩個int整數,和一個算術運算符,返回兩數的運算結果
int calc(int a, int b, char op)
{
FP_CALC fp = calc_func(op); //根據預算符得到各種運算的函數的地址
int (*s_fp)(int, int) = s_calc_func(op);//用於測試
// ASSERT(fp == s_fp); // 可以斷言這倆是相等的
if (fp) return fp(a, b);//根據上一步得到的函數的地址調用相應函數,並返回結果
else return -1;
}
void main()
{
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, '/'));
}
------------------------------------------------------------------------------------------------------------------------typedef是C語言中一個很好用的工具,大量存在於已有代碼中,特別值得一提的是:C++標準庫實現中
更是對typedef有着大量的使用。但很 多初學者對其的理解僅侷限於:typedef用來定義一個已有類型
的"別名(alias)"。正是因爲有了這樣的理解,纔有了後來初學者在typedef int myint和typedef
myint int之間的猶豫不決。很多國內大學的C語言課之授課老師也都是如是說的,或者老師講的不夠
透徹,導致學生們都是如是理解的。我這裏想結合C語言標準文檔 以及一些代碼實例,也說說typedef。
int *p;
這樣的代碼是C語言中最最基礎的一個語句了,大家都知道這個語句聲明瞭一個變量p,其類型是指向
整型的指針(pointer to int);如果在這個聲明的前面加上一個typedef後,整個語義(semantics)又會是如何改變的呢?
typedef int *p;
我們先來看看C99標準中關於typedef是如何詮釋的?C99標準中這樣一小段精闢的描 述:
"In a declaration whose storage-class specifier is typedef, each declarator defines
an identifier to be a typedef name that denotes the type specified for the identifier in the way described in xx"。
參照這段描述,並拿typedef int *p作爲例子來理解:在一個聲明中,如果有存儲類說明符
typedef的修飾,標識符p將被定義爲了一個typedef name,這個typedef name表示(denotes)一個類型,
什麼類型呢?就是int *p這個聲明(declarator)中標識符(indentifier)p的類型(int*)。
再比對一下兩個聲明:
int *p;
typedef int *p;
是不是有點"茅舍頓開"的感覺,int *p中, p是一個變量,其類型爲pointer to int;
在int *p前面增加一個typedef後,p變爲一個typedef-name,這個typedef-name所表示
的類型就是int *p聲明式中p的類型(int*)。說句白話,typedef讓p去除了普通變量的身份,
搖身一變,變成了p的類型的一個typedef-name了。
爲了鞏固上面的理解,我們再來看看"C語言參考手冊(C: A Reference Manual)"中的說法:
任何declarator(如typedef int *p)中的indentifier(如p)定義爲typedef-name,
其(指代p)表示的類型是declarator爲正常變量聲明(指代int *p)的那個標識符(指代p)
的類型(int*)。有些繞嘴,不過有例子支撐:
[例1]
typedef double MYDOUBLE;
分析:
去掉typedef ,得到正常變量聲明=> double MYDOUBLE;
變量MYDOUBLE的類型爲double;
=> "typedef double MYDOUBLE"中MYDOUBLE是類型double的一個typedef-name。
MYDOUBLE d; <=> d是一個double類型的變量
[例2]
typedef double *Dp;
分析:
去掉typedef ,得到正常變量聲明=> double *Dp;
變量Dp的類型爲double*,即pointer to double;
=> "typedef double *Dp"中Dp是類型double*的一個typedef-name。
Dp dptr; <=> dptr是一個pointer to double的變量
[例3]
typedef int* Func(int);
分析:
去掉typedef ,得到正常變量聲明=> int* Func(int);
變量Func的類型爲一個函數標識符,該函數返回值類型爲int*,參數類型爲int;
=> "typedef int* Func(int)"中Func是函數類型(函數返回值類型爲int*,參數類型爲int)的一個typedef-name。
Func *fptr; <=> fptr是一個pointer to function with one int parameter, returning a pointer to int
Func f; 這樣的聲明意義就不大了。
[例4]
typedef int (*PFunc)(int);
分析:
去掉typedef ,得到正常變量聲明=> int (*PFunc)(int);
變量PFunc的類型爲一個函數指針,指向的返回值類型爲int,參數類型爲int的函數原型;
=> "typedef int (*PFunc)(int)"中PFunc是函數指針類型(該指針類型指向返回值類型爲int,參數類型爲int的函數)的一個typedef-name。
PFunc fptr; <=> fptr是一個pointer to function with one int parameter, returning int
#include "iostream"
using namespace std;
int add(int a,int b){
return (a+b);
}
typedef int (* func)(int ,int ) ;
void main(){
func f = add;
int n = f(1,2);
cout << n << endl;
}
typedef int A[5];
分析:
去掉typedef ,得到正常變量聲明 => int A[5];
變量A的類型爲一個含有5個元素的整型數組;
=> "typedef int A[5]"中A是含有5個元素的數組類型的一個typedef-name。
A a = {3, 4, 5, 7, 8};
A b = { 3, 4, 5, 7, 8, 9}; /* 會給出Warning: excess elements in array initializer */
[例6]
typedef int (*A)[5]; (注意與typedef int* A[5]; 區分)
分析:
去掉typedef ,得到正常變量聲明 => int (*A)[5];
變量A的類型爲pointer to an array with 5 int elements;
=> "typedef int (*A)[5]"中A是"pointer to an array with 5 int elements"的一個typedef-name。
int c[5] = {3, 4, 5, 7, 8};
A a = &c;
printf("%d\n", (*a)[0]); /* output: 3 */
如果這樣賦值:
int c[6] = {3, 4, 5, 7, 8, 9};
A a = &c; /* 會有Warning: initialization from incompatible pointer type */
[例7]
typedef struct _Foo_t Foo_t;
分析:
去掉typedef ,得到正常變量聲明 => struct _Foo_t Foo_t;
變量Foo_t的類型爲struct _Foo_t;
=> "typedef struct _Foo_t Foo_t"中Foo_t是"struct _Foo_t"的一個typedef-name。
[例8]
typedef struct { ... // } Foo_t;
分析:
去掉typedef ,得到正常變量聲明 => struct { ... // } Foo_t;
變量Foo_t的類型爲struct { ... // } ;
=> "typedef struct { ... // } Foo_t "中Foo_t是"struct { ... // }"的一
個typedef-name。這裏struct {...//}是一個無"標誌名稱(tag name)"的結構體聲明。