typedef & #defiine & struct
#define(宏定義)只是簡單的字符串代換(原地擴展)，它自己並不在編譯過程當中進行，而是在這以前(預處理過程)就已經完成了。ios
typedef是爲了增長可讀性而爲標識符另起的新名稱(僅僅只是個別名)，它的新名字具備必定的封裝性，以至於新命名的標識符具備更易定義變量的功能，它是語言編譯過程的一部分，但它並不實際分配內存空間。數組
通常都遵循#define定義「可讀」的常量以及一些宏語句的任務，而typedef則經常使用來定義關鍵字、冗長的類型的別名。安全
typedef是語句（ 以'；'結尾），而#define不是語句（ 不以'；'結尾）ide
用途一：函數
定義一種類型的別名，而不僅是簡單的宏替換。能夠用做同時聲明指針型的多個對象。好比：工具
char* pa, pb; // 這多數不符合咱們的意圖，它只聲明瞭一個指向字符變量的指針 和一個字符變量；flex
如下則可行：spa
typedef char* PCHAR; 指針
PCHAR pa, pb; 調試
這種用法頗有用，特別是char* pa, pb的定義，初學者每每認爲是定義了兩個字符型指針，其實不是，而用typedef char* PCHAR就不會出現這樣的問題，減小了錯誤的發生。
用途二:
用在舊的C代碼中，幫助struct。之前的代碼中，聲明struct新對象時，必需要帶上struct，即形式爲： struct 結構名對象名，如：
struct tagPOINT1
{
int x;
int y;
};
struct tagPOINT1 p1;
而在C++中，則能夠直接寫：結構名對象名，即：tagPOINT1 p1;
typedef struct tagPOINT
{
int x;
int y;
}POINT;
POINT p1; // 這樣就比原來的方式少寫了一個struct，比較省事，尤爲在大量使用的時候,或許，在C++中，typedef的這種用途二不是很大，可是理解了它，對掌握之前的舊代
碼仍是有幫助的，畢竟咱們在項目中有可能會遇到較早些年代遺留下來的代碼。
有關struct的用法 在後面
用途三：
用typedef來定義與平臺無關的類型。
好比定義一個叫 REAL 的浮點類型，在目標平臺一上，讓它表示最高精度的類型爲：
typedef long double REAL;
在不支持 long double 的平臺二上，改成：
typedef double REAL;
在連 double 都不支持的平臺三上，改成：
typedef float REAL;
也就是說，當跨平臺時，只要改下 typedef 自己就行，不用對其餘源碼作任何修改。
標準庫就普遍使用了這個技巧，好比size_t。另外，由於typedef是定義了一種類型的新別名，不是簡單的字符串替換，因此它比宏來得穩健。
這個優勢在咱們寫代碼的過程當中能夠減小很多代碼量哦！
用途四： (這個不太懂，之後解決)
爲複雜的聲明定義一個新的簡單的別名。方法是：在原來的聲明裏逐步用別名替換一部
分複雜聲明，如此循環，把帶變量名的部分留到最後替換，獲得的就是原聲明的最簡化
版。舉例：
原聲明：void (*b[10]) (void (*)());
變量名爲b，先替換右邊部分括號裏的，pFunParam爲別名一：
typedef void (*pFunParam)();
再替換左邊的變量b，pFunx爲別名二：
typedef void (*pFunx)(pFunParam);
原聲明的最簡化版：
pFunx b[10];
原聲明：doube(*)() (*e)[9];
變量名爲e，先替換左邊部分，pFuny爲別名一：
typedef double(*pFuny)();
再替換右邊的變量e，pFunParamy爲別名二
typedef pFuny (*pFunParamy)[9];
原聲明的最簡化版：
pFunParamy e;
理解複雜聲明可用的「右左法則」：從變量名看起，先往右，再往左，碰到一個圓括號
就調轉閱讀的方向；括號內分析完就跳出括號，仍是按先右後左的順序，如此循環，直
到整個聲明分析完。舉例：
int (*func)(int *p);
首先找到變量名func，外面有一對圓括號，並且左邊是一個*號，這說明func是一個指針
；而後跳出這個圓括號，先看右邊，又遇到圓括號，這說明(*func)是一個函數，因此
func是一個指向這類函數的指針，即函數指針，這類函數具備int*類型的形參，返回值
類型是int。
int (*func[5])(int *);
func右邊是一個[]運算符，說明func是具備5個元素的數組；func的左邊有一個*，說明
func的元素是指針（注意這裏的*不是修飾func，而是修飾func[5]的，緣由是[]運算符
優先級比*高，func先跟[]結合）。跳出這個括號，看右邊，又遇到圓括號，說明func數
組的元素是函數類型的指針，它指向的函數具備int*類型的形參，返回值類型爲int。
這種用法是比較複雜的，出現的頻率也很多，每每在看到這樣的用法卻不能理解，相信以上的解釋能有所幫助。
*****以上爲參考部分，如下爲本人領悟部分*****
使用示例：
1.比較一：
#include <iostream>
using namespace std;
typedef int (*A) (char, char);
int ss(char a, char b)
{
cout<<"功能1"<<endl;
cout<<a<<endl;
cout<<b<<endl;
return 0;
}
int bb(char a, char b)
{
cout<<"功能2"<<endl;
cout<<b<<endl;
cout<<a<<endl;
return 0;
}
void main()
{
A a;
a = ss;
a('a','b');
a = bb;
a('a', 'b');
}
2.比較二：
typedef int (A) (char, char);
void main()
{
A *a;
a = ss;
a('a','b');
a = bb;
a('a','b');
}
兩個程序的結果都同樣：
功能1
a
b
功能2
b
a
#define與const區別（定義常量）：
1. const常量有數據類型，而#define（宏）常量沒有數據類型。編譯器能夠對前者進行類型安全檢查。而對後者只進行字符替換，沒有類型安全檢查，而且在字符替換可能會產生意料不到的錯誤（邊際效應）。
2. const常量在堆棧分配了空間，而#define（宏）常量只是把具體數值直接傳遞到目標變量罷了。或者說，const的常量是一個Run-Time的概念，他在程序中確確實實的存在並能夠被調用、傳遞。而#define常量則是一個Compile-Time概念，它的生命週期止於編譯期：在實際程序中他只是一個常數、一個命令中的參數，沒有實際的存在。
3. const常量存在於程序的數據段，#define常量存在於程序的代碼段。
4. 有些集成化的調試工具能夠對const常量進行調試，可是不能對宏常量進行調試。
typedef 與 #define的區別：
案例一：
一般講，typedef要比#define要好，特別是在有指針的場合。請看例子：
typedef char *pStr1;
#define pStr2 char *;
pStr1 s1, s2;
pStr2 s3, s4;
在上述的變量定義中，s一、s二、s3都被定義爲char *，而s4則定義成了char，不是咱們所預期的指針變量，根本緣由就在於#define只是簡單的字符串替換而typedef則是爲一個類型起新名字。
案例二：
下面的代碼中編譯器會報一個錯誤，你知道是哪一個語句錯了嗎？
typedef char * pStr;
char string[4] = "abc";
const char *p1 = string;
const pStr p2 = string;
p1++;
p2++;
是p2++出錯了。這個問題再一次提醒咱們：typedef和#define不一樣，它不是簡單的
文本替換。上述代碼中const pStr p2並不等於const char * p2。const pStr p2和
const long x本質上沒有區別，都是對變量進行只讀限制，只不過此處變量p2的數據類
型是咱們本身定義的而不是系統固有類型而已。所以，const pStr p2的含義是：限定數
據類型爲char *的變量p2爲只讀，所以p2++錯誤。雖然做者在這裏已經解釋得很清楚了，可我在這個地方仍然仍是糊塗的，真的但願哪位高手能幫忙指點一下，特別是這一句「只不過此處變量p2的數據類型是咱們本身定義的而不是系統固有類型而已」，難道本身定義的類型前面用const修飾後，就不能執行更改運算，而系統定義的類型卻能夠？
#define的用法：
一、簡單的宏定義
#define MAXTIME 1000
一個簡單的MAXTIME就定義好了，它表明1000，若是在程序裏面寫：
if(i<MAXTIME){
}
編譯器在處理這個代碼以前會對MAXTIME進行處理替換爲1000。
這樣的定義看起來相似於普通的常量定義const，但也有着不一樣，由於define的定義只是簡單的替換，而不是做爲一個量來使用，這個問題在下面反映的尤其突出。
二、帶參數的宏
define能夠像函數那樣接受一些參數，以下：
#define max(x,y) (x)>(y)?(x):(y);
它將返回兩個數中較大的那個，這個「函數」沒有類型檢查，就好像一個函數模板似的，固然，不難看出它絕對沒有模板那麼安全。
由於這樣作的話存在隱患，例子以下：
#define Add(a,b) a+b;
通常的單獨使用是沒有問題的，可是若是遇到如：c * Add(a,b) * d的時候就會出現問題，代數式的本意是a+b而後和c，d相乘，可是由於使用了define（它只是一個簡單的替換），因此式子實際上變成了c*a + b*d 。
再看看這個例子：
#define int_ptr int *;
int_ptr a,b;
本意是a和b都是int型指針，可是實際上變成
int* a,b;
a是int型指針，而b是int型變量。這時應該使用typedef定義：
typedef int* int_ptr;
int_ptr a,b;
這樣a和b就都是int型指針了。
三、define的多行定義
define能夠替代多行的代碼，例如MFC中的宏定義（很是的經典，雖然讓人看了噁心）
#define MACRO(arg1, arg2) do { /
/* declarations */ /
stmt1; /
stmt2; /
/*
*/ /
} while(0) /* (no trailing ; ) */
關鍵是要在每個換行的時候加上一個"/"。
四、在大規模的開發過程當中，特別是跨平臺和系統的軟件裏，define最重要的功能是條件編譯。
#ifdef WINDOWS
#endif
#ifdef LINUX
#endif
能夠在編譯的時候經過#define設置編譯環境
五、如何定義宏、取消宏
//定義宏
#define [MacroName] [MacroValue]
//取消宏
#undef [MacroName]
//普通宏
#define PI (3.1415926)
//帶參數的宏
#define max(a,b) ((a)>(b)? (a),(b))
關鍵是十分容易產生錯誤，包括機器和人理解上的差別等等。
六、條件編譯
#ifdef XXX…(#else) …#endif
例如：
#ifdef DV22_AUX_INPUT
#define AUX_MODE 3
#else
#define AUY_MODE 3
＃endif
#define和typedef的區別：
一、 #define是預處理指令，在編譯預處理時進行簡單的替換，不做正確性檢查，無論含義是否正確照樣帶入，只有在編譯已被展開的源程序時纔會發現可能的錯誤並報錯。例如：
#define PI 3.1415926
程序中的：area=PI*r*r 會替換爲3.1415926*r*r
若是你把#define語句中的數字9 寫成字母g 預處理也照樣帶入。
二、typedef是在編譯時處理的。它在本身的做用域內給一個已經存在的類型一個別名，可是You cannot use the typedef specifier inside a function definition。
三、
typedef int * int_ptr;
與
#define int_ptr int *
做用都是用int_ptr表明 int * ，可是兩者不一樣，正如前面所說，#define在預處理時只是進行簡單的替換，而typedef不是簡單替換 ，而是採用如同定義變量的方法那樣來聲明一種類型。重複前面的例子：
#define int_ptr int *
int_ptr a,b; //至關於int * a, b; 只是簡單的宏替換，a是整型指針，而b之是整型變量
typedef int * int_ptr;
int_ptr a,b; //a, b 都爲指向int的指針,typedef爲int* 引入了一個新的助記符
四、也許您已經注意到#define不是語句，不要在行末加分號，不然會連分號一塊置換；可是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 自己就行，不用對其餘源碼作任何修改。
標準庫就普遍使用了這個技巧，好比size_t。
另外，由於typedef是定義了一種類型的新別名，不是簡單的字符串替換，因此它比宏來得穩健（雖然用宏有時也能夠完成以上的用途）。
用途四：
爲複雜的聲明定義一個新的簡單的別名。方法是：在原來的聲明裏逐步用別名替換一部分複雜聲明，如此循環，把帶變量名的部分留到最後替換，獲得的就是原聲明的最簡化版。舉例：
1. 原聲明：int *(*a[5])(int, char*);
變量名爲a，直接用一個新別名pFun替換a就能夠了：
typedef int *(*pFun)(int, char*);
原聲明的最簡化版：
pFun a[5];
2. 原聲明：void (*b[10]) (void (*)());
變量名爲b，先替換右邊部分括號裏的，pFunParam爲別名一：
typedef void (*pFunParam)();
再替換左邊的變量b，pFunx爲別名二：
typedef void (*pFunx)(pFunParam);
原聲明的最簡化版：
pFunx b[10];
3. 原聲明：doube(*)() (*e)[9];
變量名爲e，先替換左邊部分，pFuny爲別名一：
typedef double(*pFuny)();
再替換右邊的變量e，pFunParamy爲別名二
typedef pFuny (*pFunParamy)[9];
原聲明的最簡化版：
pFunParamy e;
理解複雜聲明可用的「右左法則」：從變量名看起，先往右，再往左，碰到一個圓括號就調轉閱讀的方向；括號內分析完就跳出括號，仍是按先右後左的順序，如此循環，直到整個聲明分析完。舉例：
int (*func)(int *p);
首先找到變量名func，外面有一對圓括號，並且左邊是一個*號，這說明func是一個指針；而後跳出這個圓括號，先看右邊，又遇到圓括號，這說明 (*func)是一個函數，因此func是一個指向這類函數的指針，即函數指針，這類函數具備int*類型的形參，返回值類型是int。
int (*func[5])(int *);
func右邊是一個[]運算符，說明func是具備5個元素的數組；func的左邊有一個*，說明func的元素是指針（注意這裏的*不是修飾func， 而是修飾func[5]的，緣由是[]運算符優先級比*高，func先跟[]結合）。跳出這個括號，看右邊，又遇到圓括號，說明func數組的元素是函數 類型的指針，它指向的函數具備int*類型的形參，返回值類型爲int。
也能夠記住2個模式：
type (*)(....)函數指針
type (*)[]數組指針
陷阱一：
記住，typedef是定義了一種類型的新別名，不一樣於宏，它不是簡單的字符串替換。好比：
先定義：
typedef char* PSTR;
而後：
int mystrcmp(const PSTR, const PSTR);
const PSTR實際上至關於const char*嗎？不是的，它實際上至關於char* const。
緣由在於const給予了整個指針自己以常量性，也就是造成了常量指針char* const。
簡單來講，記住當const和typedef一塊兒出現時，typedef不會是簡單的字符串替換就行。
陷阱二：
typedef在語法上是一個存儲類的關鍵字（如auto、extern、mutable、static、register等同樣），雖然它並不真正影響對象的存儲特性，如：
typedef static int INT2; //不可行
編譯將失敗，會提示「指定了一個以上的存儲類」。
struct用法
基本定義：結構體，通俗講就像是打包封裝，把一些變量有共同特徵（好比同屬於某一類事物的屬性）的變量封裝在內部，經過必定方法訪問修改內部變量。
結構體定義：
第一種：只有結構體定義
struct stuff{
char job[20];
int age;
float height;
};
第二種：附加變量初始化的結構體定義
//直接帶變量名Huqinwei
struct stuff{
char job[20];
int age;
float height;
}Huqinwei;
也許初期看不習慣容易困惑，其實這就至關於：
struct stuff{
char job[20];
int age;
float height;
};
struct stuff Huqinwei;
第三種：若是該結構體你只用一個變量Huqinwei，而再也不須要用「struct stuff yourname;」去定義第二個變量。
那麼，附加變量初始化的結構體定義還可進一步簡化出第三種：
struct{
char job[20];
int age;
float height;
}Huqinwei;
把結構體名稱去掉，這樣更簡潔，不過也不能定義其餘同結構體變量了。
結構體變量及其內部成員變量的定義及訪問：
繞口吧？要分清結構體變量和結構體內部成員變量的概念。
就像剛纔的第二種提到的，結構體變量的聲明能夠用：
struct stuff yourname;
其成員變量的定義能夠隨聲明進行：
struct stuff Huqinwei = {"manager",30,185};
也能夠考慮結構體之間的賦值：
struct stuff faker = Huqinwei; //或 struct stuff faker2; // faker2 = faker; 打印，可見結構體的每個成員變量如出一轍
若是不使用上邊兩種方法，那麼成員數組的操做會稍微麻煩（用for循環可能好點）
Huqinwei.job[0] = 'M';
Huqinwei.job[1] = 'a';
Huqinwei.age = 27;
Huqinwei.height = 185;
結構體成員變量的訪問除了能夠藉助符號"."，還能夠用"->"訪問（下邊會提）。
指針和數組：
這是永遠繞不開的話題，首先是引用：
struct stuff *ref = &Huqinwei;
ref->age = 100;
printf("age is:%d\n",Huqinwei.age);
結構體也不能免俗，必須有數組：
struct test{
int a[3];
int b;
};
//對於數組和變量同時存在的狀況，有以下定義方法：
struct test student[3] = {{{66,77,55},0},
{{44,65,33},0},
{{46,99,77},0}};
//特別的，能夠簡化成：
struct test student[3] = {{66,77,55,0},
{44,65,33,0},
{46,99,77,0}};
結構體嵌套：
結構體嵌套其實沒有太意外的東西，只要遵循必定規律便可：
//對於「一錘子買賣」，其中A、B可刪，不過最好帶着
struct A{
struct B{
int c;
}
b;
}
a;
//使用以下方式訪問：
a.b.c = 10;
特別的,能夠一邊定義結構體B，一邊就使用上：
struct A{
struct B{
int c;
}b;
struct B sb;
}a;
傳遞副本和指針了 ：
//struct A定義同上
//設立了兩個函數，分別傳遞struct A結構體和其指針。
void func1(struct A a){
printf("%d\n",a.b.c);
}
void func2(struct A* a){
printf("%d\n",a->b.c);
}
main(){
a.b.c = 112;
struct A * pa;
pa = &a;
func1(a);
func2(&a);
func2(pa);
}
佔用內存空間：
struct結構體，在結構體定義的時候不能申請內存空間，不過若是是結構體變量，聲明的時候就能夠分配——二者關係就像C++的類與對象，對象才分配內存（不過嚴格講，做爲代碼段，結構體定義部分「.text」真的就不佔空間了麼？）。
結構體的大小是結構體所含變量大小的總和，而且不能用"char a[]"這種彈性（flexible）變量，必須明確大小，下面打印輸出上述結構體的size：
printf("size of struct man:%d\n",sizeof(struct man));
printf("size:%d\n",sizeof(Huqinwei));
結果毫無懸念，都是28：分別是char數組20，int變量4，浮點變量4.
和C++的類不同，結構體不能夠給結構體內部變量初始化，。
以下，爲錯誤示範：
#include<stdio.h>
//直接帶變量名Huqinwei
struct stuff{
// char job[20] = "Programmer";
// char job[];
// int age = 27;
// float height = 185;
}Huqinwei;
- 1. struct和typedef struct
- 2. typedef struct
- 3. C++ typedef struct v.s. struct
- 4. typedef struct bit0 : 1
- 5. typedef struct用法
- 6. typedef struct和struct比較
- 7. 細說 struct和typedef struct
- 8. struct 和typedef struct的區別
- 9. struct和typedef struct的區別
- 10. C語言 typedef struct
- 更多相關文章...
- • C# 結構體（Struct） - C#教程
- • Rust 結構體 - RUST 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。