（1）->是指針指向其成員的運算符
（2）.是結構體的成員運算符
先看幾個例子
(1) struct{ int x; int y; }test1; 好，定義了 結構 test1， test1.x 和 test1.y 可以在語句里用了。 (2) struct test {int x; int y; }test1; 好，定義了 結構 test1， test1.x 和 test1.y 可以在語句里用了。 與 1 比，省寫 了 test (3) typedef struct test {int x; int y; }text1,text2; 只說了 這種結構 的（類型）別名 叫 text1 或叫 text2 真正要使用它，還要寫： text1 test1; 然后好用 test1.x test1.y 或寫 text2 test1; 然后好用 test1.x test1.y （4）type struct {int x; int y; }test1; 這個不可以。 改 typedef ... 就可以了。 但也同 （3）一樣，還要 寫： test1 my_st; 才能用 my_st.x 和 my_st.y
typedef和define具體的詳細區別
一、typedef的用法
在C/C++語言中，typedef常用來定義一個標識符及關鍵字的別名，它是語言編譯過程的一部分，但它並不實際分配內存空間，實例像：
typedef int INT; typedef int ARRAY[10]; typedef (int*) pINT;
typedef可以增強程序的可讀性，以及標識符的靈活性，但它也有“非直觀性”等缺點。
二、#define的用法
#define為一宏定義語句，通常用它來定義常量(包括無參量與帶參量)，以及用來實現那些“表面似和善、背后一長串”的宏，它本身並不在編譯過程中進行，而是在這之前(預處理過程)就已經完成了，但也因此難以發現潛在的錯誤及其它代碼維護問題，它的實例像：
#define INT int #define TRUE 1 #define Add(a,b) ((a)+(b)); #define Loop_10 for (int i=0; i<10; i++)
在Scott Meyer的Effective C++一書的條款1中有關於#define語句弊端的分析，以及好的替代方法，大家可參看。
三、typedef與#define的區別
從以上的概念便也能基本清楚，typedef只是為了增加可讀性而為標識符另起的新名稱(僅僅只是個別名)，而#define原本在C中是為了定義常量
，到了C++，const、enum、inline的出現使它也漸漸成為了起別名的工具。有時很容易搞不清楚與typedef兩者到底該用哪個好，如#define INT int這樣的語句，用typedef一樣可以完成，用哪個好呢？我主張用typedef，因為在早期的許多C編譯器中這條語句是非法的，只是現今的編譯器又做了擴充。為了盡可能地兼容，一般都遵循#define定義“可讀”的常量以及一些宏語句的任務，而typedef則常用來定義關鍵字、冗長的類型的別名。
宏定義只是簡單的字符串代換(原地擴展)，而typedef則不是原地擴展，它的新名字具有一定的封裝性，以致於新命名的標識符具有更易定義變量的功能。例如
typedef (int*) pINT; 以及下面這行: #define pINT2 int*
效果相同？實則不同！實踐中見差別：pINT a,b;的效果同int *a; int *b;表示定義了兩個整型指針變量。而pINT2 a,b;的效果同int *a, b;表示定義了一個整型指針變量a和整型變量b。
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所指的對象。
四.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; //不可行 編譯將失敗，會提示“指定了一個以上的存儲類”。
一 const基礎
如果const關鍵字不涉及到指針，我們很好理解，下面是涉及到指針的情況：
int b = 500; const int* a = &b; [1] int const *a = &b; [2] int* const a = &b; [3] const int* const a = &b; [4]
如果你能區分出上述四種情況，那么，恭喜你，你已經邁出了可喜的一步。不知道，也沒關系，我們可以參考《Effective c++》Item21上的做法，如果const位於星號的左側，則const就是用來修飾指針所指向的變量，即指針指向為常量；如果const位於星號的右側，const就是修飾指針本身，即指針本身是常量。因此，[1]和[2]的情況相同，都是指針所指向的內容為常量（const放在變量聲明符的位置無關），這種情況下不允許對內容進行更改操作，如不能*a = 3 ；[3]為指針本身是常量，而指針所指向的內容不是常量，這種情況下不能對指針本身進行更改操作，如a++是錯誤的；[4]為指針本身和指向的內容均為常量。 另外const 的一些強大的功能在於它在函數聲明中的應用。在一個函數聲明中，const 可以修飾函數的返回值，或某個參數；對於成員函數，還可以修飾是整個函數。有如下幾種情況，以下會逐漸的說明用法：
A& operator=(const A& a); void fun0(const A* a ); void fun1( ) const; // fun1( ) 為類成員函數 const A fun2( );
二 const的初始化
先看一下const變量初始化的情況 1) 非指針const常量初始化的情況：
A b; const A a = b;
2) 指針(引用)const常量初始化的情況：
A* d = new A(); const A* c = d; 或者：const A* c = new A(); 引用： A f; const A& e = f; // 這樣作e只能訪問聲明為const的函數，而不能訪問一般的成員函數；
[思考1]： 以下的這種賦值方法正確嗎？ const A* c=new A(); A* e = c; [思考2]： 以下的這種賦值方法正確嗎？ A* const c = new A(); A* b = c; 三 作為參數和返回值的const修飾符 其實，不論是參數還是返回值，道理都是一樣的，參數傳入時候和函數返回的時候，初始化const變量 1 修飾參數的const，如 void fun0(const A* a ); void fun1(const A& a); 調用函數的時候，用相應的變量初始化const常量，則在函數體中，按照const所修飾的部分進行常量化，如形參為const A* a，則不能對傳遞進來的指針的內容進行改變，保護了原指針所指向的內容；如形參為const A& a，則不能對傳遞進來的引用對象進行改變，保護了原對象的屬性。 [注意]：參數const通常用於參數為指針或引用的情況; 2 修飾返回值的const，如const A fun2( ); const A* fun3( ); 這樣聲明了返回值后，const按照"修飾原則"進行修飾，起到相應的保護作用。
const Rational operator*(const Rational& lhs, const Rational& rhs) { return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator()); }
返回值用const修飾可以防止允許這樣的操作發生:
Rational a,b; Radional c; (a*b) = c;
一般用const修飾返回值為對象本身（非引用和指針）的情況多用於二目操作符重載函數並產生新對象的時候。 [總結] 一般情況下，函數的返回值為某個對象時，如果將其聲明為const時，多用於操作符的重載。通常，不建議用const修飾函數的返回值類型為某個對象或對某個對象引用的情況。 原因如下： 如果返回值為某個對象為const（const A test = A 實例）或某個對象的引用為const（const A& test = A實例） ，則返回值具有const屬性，則返回實例只能訪問類A中的公有（保護）數據成員和const成員函數，並且不允許對其進行賦值操作，這在一般情況下很少用到。
[思考3]： 這樣定義賦值操作符重載函數可以嗎？ const A& operator=(const A& a); 四 類成員函數中const的使用
一般放在函數體后，形如：void fun() const; 如果一個成員函數的不會修改數據成員，那么最好將其聲明為const，因為const成員函數中不允許對數據成員進行修改，如果修改，編譯器將報錯，這大大提高了程序的健壯性。
五 使用const的一些建議
1 要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委； 2 要避免最一般的賦值操作錯誤，如將const變量賦值，具體可見思考題； 3 在參數中使用const應該使用引用或指針，而不是一般的對象實例，原因同上； 4 const在成員函數中的三種用法（參數、返回值、函數）要很好的使用； 5 不要輕易的將函數的返回值類型定為const; 6除了重載操作符外一般不要將返回值類型定為對某個對象的const引用;
第一篇：typedef struct與struct的區別
1. 基本解釋
typedef為C語言的關鍵字，作用是為一種數據類型定義一個新名字。這里的數據類型包括內部數據類型（int,char等）和自定義的數據類型（struct等）。
在編程中使用typedef目的一般有兩個，一個是給變量一個易記且意義明確的新名字，另一個是簡化一些比較復雜的類型聲明。
至於typedef有什么微妙之處，請你接着看下面對幾個問題的具體闡述。
2. typedef & 結構的問題
當用下面的代碼定義一個結構時，編譯器報了一個錯誤，為什么呢？莫非C語言不允許在結構中包含指向它自己的指針嗎？請你先猜想一下，然后看下文說明：
typedef struct tagNode { char *pItem; pNode pNext; } *pNode;
答案與分析：
1、typedef的最簡單使用
typedef long byte_4;
給已知數據類型long起個新名字，叫byte_4。
2、 typedef與結構結合使用
typedef struct tagMyStruct { int iNum; long lLength; } MyStruct;
這語句實際上完成兩個操作：
1) 定義一個新的結構類型
struct tagMyStruct { int iNum; long lLength; };
分析：tagMyStruct稱為“tag”，即“標簽”，實際上是一個臨時名字，struct 關鍵字和tagMyStruct一起，構成了這個結構類型，不論是否有typedef，這個結構都存在。
我們可以用struct tagMyStruct varName來定義變量，但要注意，使用tagMyStruct varName來定義變量是不對的，因為struct 和tagMyStruct合在一起才能表示一個結構類型。
2) typedef為這個新的結構起了一個名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
因此，MyStruct實際上相當於struct tagMyStruct，我們可以使用MyStruct varName來定義變量。
答案與分析
C語言當然允許在結構中包含指向它自己的指針，我們可以在建立鏈表等數據結構的實現上看到無數這樣的例子，上述代碼的根本問題在於typedef的應用。
根據我們上面的闡述可以知道：新結構建立的過程中遇到了pNext域的聲明，類型是pNode，要知道pNode表示的是類型的新名字，那么在類型本身還沒有建立完成的時候，這個類型的新名字也還不存在，也就是說這個時候編譯器根本不認識pNode。
解決這個問題的方法有多種：
1)、
typedef struct tagNode { char *pItem; struct tagNode *pNext; } *pNode;
2)、
typedef struct tagNode *pNode; struct tagNode { char *pItem; pNode pNext; };
注意：在這個例子中，你用typedef給一個還未完全聲明的類型起新名字。C語言編譯器支持這種做法。
3)、規范做法：
typedef uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );
這個以前沒有看到過,個人認為是宇定義一個uint32的指針函數,uint16*, uint32 為函數里的兩個參數; 應該相當於#define uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );
struct在代碼中常見兩種形式： struct A { //... };
struct { //... } A; 這其實是兩個完全不同的用法： 前者叫做“結構體類型定義”，意思是：定義{}中的結構為一個名稱是“A”的結構體。 這種用法在typedef中一般是： typedef struct tagA //故意給一個不同的名字，作為結構體的實名 { //... } A; //結構體的別名。
后者是結構體變量定義，意思是：以{}中的結構，定義一個名稱為"A"的變量。這里的結構體稱為匿名結構體，是無法被直接引用的。 也可以通過typedef為匿名結構體創建一個別名，從而使得它可以被引用： typedef struct { //... } A; //定義匿名結構體的別名為A
第二篇：在C和C++中struct和typedef struct的區別
在C和C++有三種定義結構的方法。
typedef struct {
int data;
int text;
} S1;
//這種方法可以在c或者c++中定義一個S1結構
struct S2 {
int data;
int text;
};
// 這種定義方式只能在C++中使用，而如果用在C中，那么編譯器會報錯
struct {
int data;
int text;
} S3;
這種方法並沒有定義一個結構，而是定義了一個s3的結構變量，編譯器會為s3內存。
void main()
{
S1 mine1;// OK ,S1 是一個類型
S2 mine2;// OK,S2 是一個類型
S3 mine3;// OK,S3 不是一個類型
S1.data = 5;// ERRORS1 是一個類型
S2.data = 5;// ERRORS2 是一個類型
S3.data = 5;// OKS3是一個變量
}
另外，對與在結構中定義結構本身的變量也有幾種寫法
struct S6 {
S6* ptr;
};
// 這種寫法只能在C++中使用
typedef struct {
S7* ptr;
} S7;
// 這是一種在C和C++中都是錯誤的定義
如果在C中，我們可以使用這樣一個“曲線救國的方法“
typedef struct tagS8{
tagS8 * ptr;
} S8;
第三篇：struct和typedef struct
分三塊來講述： 1 首先： 在C中定義一個結構體類型要用typedef: typedef struct Student { int a; }Stu; 於是在聲明變量的時候就可：Stu stu1; 如果沒有typedef就必須用struct Student stu1;來聲明 這里的Stu實際上就是struct Student的別名。
另外這里也可以不寫Student（於是也不能struct Student stu1;了） typedef struct { int a; }Stu; 但在c++里很簡單，直接 struct Student { int a; }; 於是就定義了結構體類型Student，聲明變量時直接Student stu2； =========================================== 2其次： 在c++中如果用typedef的話，又會造成區別： struct Student { int a; }stu1;//stu1是一個變量 typedef struct Student2 { int a; }stu2;//stu2是一個結構體類型 使用時可以直接訪問stu1.a 但是stu2則必須先 stu2 s2; 然后 s2.a=10; =========================================== 3 掌握上面兩條就可以了，不過最后我們探討個沒多大關系的問題 如果在c程序中我們寫： typedef struct { int num; int age; }aaa,bbb,ccc; 這算什么呢？ 我個人觀察編譯器（VC6）的理解，這相當於 typedef struct { int num; int age; }aaa； typedef aaa bbb; typedef aaa ccc; 也就是說aaa,bbb,ccc三者都是結構體類型。聲明變量時用任何一個都可以,在c++中也是如此。但是你要注意的是這個在c++中如果寫掉了typedef關鍵字，那么aaa，bbb，ccc將是截然不同的三個對象。
第四篇：C/C++中typedef struct和struct的用法
struct _x1 { ...}x1; 和 typedef struct _x2{ ...} x2; 有什么不同？
其實, 前者是定義了類_x1和_x1的對象實例x1, 后者是定義了類_x2和_x2的類別名x2 ,
所以它們在使用過程中是有取別的.請看實例1.
[知識點]
結構也是一種數據類型, 可以使用結構變量, 因此, 象其它 類型的變量一樣, 在使用結構變量時要先對其定義。
定義結構變量的一般格式為:
struct 結構名
{
類型 變量名;
類型 變量名;
...
} 結構變量; //結構體的變量
結構名是結構的標識符，不是變量名。
另一種常用格式為:
typedef struct 結構名
{
類型 變量名;
類型 變量名;
...
} 結構別名; //結構別名:只是結構的標示符——結構體類型
另外注意: 在C中，struct不能包含函數。在C++中，對struct進行了擴展，可以包含函數。
======================================================================
實例1: struct.cpp
#include <iostream>
using namespace std;
typedef struct _point{
int x;
int y;
}point; //定義類，給類一個別名 ,需要聲明使用
struct _hello{
int x,y;
} hello; //同時定義類和對象 ，可以直接使用
int main()
{
point pt1;
pt1.x = 2;
pt1.y = 5;
cout<< "ptpt1.x=" << pt1.x << "pt.y=" <<pt1.y <<endl; // C++編程語言互換流中的標准輸出流
//hello pt2;
//pt2.x = 8;
//pt2.y =10;
//cout<<"pt2pt2.x="<< pt2.x <<"pt2.y="<<pt2.y <<endl;
//上面的hello pt2;這一行編譯將不能通過. 為什么?
//因為hello是被定義了的對象實例了.
//正確做法如下: 用hello.x和hello.y
hello.x = 8;
hello.y = 10;
cout<< "hellohello.x=" << hello.x << "hello.y=" <<hello.y <<endl;
return 0;
}
第五篇：問答
Q：用struct和typedef struct 定義一個結構體有什么區別？為什么會有兩種方式呢？
struct Student { int a; } stu; typedef struct Student2 { int a; }stu2;
A：
事實上，這個東西是從C語言中遺留過來的，typedef可以定義新的復合類型或給現有類型起一個別名，在C語言中，如果你使用 struct xxx { }; 的方法，使用時就必須用 struct xxx var 來聲明變量，而使用 typedef struct { }的方法 就可以寫為 xxx var; 不過在C++中已經沒有這回事了，無論你用哪一種寫法都可以使用第二種方式聲明變量，這個應該算是C語言的糟粕。
參考http://www.cnblogs.com/kerwinshaw/archive/2009/02/02/1382428.html 作者 沉浮
參考http://blog.csdn.net/haiou0/article/details/6877718 作者 haiou0
也可以學習這篇 http://www.cnblogs.com/qyaizs/articles/2039101.html 比較簡潔