#include<stdio.h> //數據結構之順序表 /*原理：地址連續的存儲單元依此存儲線性表的元素 基本運算：插入 刪除 查找 排序 要點：結構的定義很重要，所有的操作都是建立在數據結構之上的。 */ /*順序表結構體定義:*/ //def數據最大長度 #define Maxsize 100 //定義數據元素類型,可以適應更多類型 typedef int Datatype; //定義順序表類型，只是定義了一個類型，而不是變量 typedef struct SeqList//此處的SeqList可以不要 { Datatype data[Maxsize]; int last; }SeqList; SeqList InitSlist() {//初始化順序表 SeqList L;//通過函數調用來申請空間，創建變量 L.last = -1;//表示表空 return L; } void Creat_Slist(SeqList &L) {//創建順序表，給data初步賦值 int flag;//標示數據規模 scanf("%d",&flag); for(int i=0;i<flag;i++) { scanf("%d",&L.data[i]); L.last++; } } int Getlength(SeqList &L) { return (L.last + 1); } int InsertSlist(SeqList &L,int i,Datatype x) {//在表的第i個位置上插入一個值為 x 的新元素 /*插入位置是否合理? 1 ≤ i ≤ n+1 是否有空間? L->last == MAXSIZE-1 插入流程: 移動 插入 修改長度 */ int j; if(i<1||i>L.last+2) return -1; if(L.last==Maxsize-1) return -2; for(j=L.last;j>=(i-1);j--) { L.data[j+1]=L.data[j]; } L.data[i-1]=x; L.last++; return 1; } int Deletelist(SeqList &L,int i) {//刪除是指在表的第i個位置上刪除一個元素 /* 刪除位置是否合理? 1≤i≤n 表是否為空? L->last==-1 刪除操作 刪除元素 修改長度 */ int j; if(i<1||i>L.last+1) return -1; if(L.last==-1) return -1; for(j=i;j<=L.last;j++) { L.data[j-1]=L.data[j]; } L.last--; return 1; } int Findslist(SeqList &L,int i) {//按序號查找 if(i<1||i>L.last) return -1; else return L.data[i-1]; } int Findslist(SeqList &L,int X) {//在表中找到與x相等的元素，則返回該元素在表中的序號 if(i<1||i>L.last) return -1; else for(int i=0;i<=L.last;i++) { if(L.data[i]==X) return i+1; } if(i==L.last+1) return -1; } void Findwrong(int num) { if(num==1) printf("操作成功"); else printf("操作失敗"); } int main() { SeqList L = InitSlist(); Creat_Slist(L); switch (InsertSlist(L,i,x)) { case 1:printf("插入數據成功"); case -1:printf("位置不合理"); case -2:printf("溢出，不可插"); break; } printf("%d",Getlength(L)); Findwrong(Deletelist(L,i)); Findwrong(Findslist(L,i)); }
順序表的結構體創建：
typedef的查找資料獲得：
來源：http://zjf30366.blog.163.com/blog/static/411164582009817101543293/
有種很方便的寫法。
typedef int *p；
p pointer；
這時直接把pointer帶入原式中，取代p然后去掉typedef，得到的結果就是int * pointer；
哈哈，這樣直接替換就很直觀多了。
C語言語法簡單，但內涵卻博大精深；如果在學習時只是止步於表面，那么往往后期會遇到很多困難。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;
}
[例5]
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)"的結構體聲明。
參考資料：
1、"ISOIEC-98991999(E)--Programming Languages--C"之Page 123;
2、C語言參考手冊(中文版) 之 Page 119
c中typedef函數指針的作用：
類型定義的語法可以歸結為一句話：只要在變量定義前面加上typedef，就成了類型定義。這兒的原本應該是變量的東西，就成為了類型。
int integer; //整型變量
int *pointer; //整型指針變量
int array [5]; //整型數組變量
int *p_array [5]; //整型指針的數組的變量
int (*array_pointer) [5];//整型數組的指針的變量
int function (int param);//函數定義，也可將函數名看作函數的變量
int *function (int param);//仍然是函數，但返回值是整型指針
int (*function) (int param);//現在就是指向函數的指針了
若要定義相應類型，即為類型來起名字，就是下面的形式：
typedef int integer_t; //整型類型
typedef int *pointer_t; //整型指針類型
typedef int array_t [5]; //整型數組類型
typedef int *p_array_t [5]; //整型指針的數組的類型
typedef int (*array_pointer_t) [5]; //整型數組的指針的類型
typedef int function_t (int param); //函數類型
typedef int *function_t (int param); //函數類型
typedef int (*function_t) (int param); //指向函數的指針的類型
注意：上面的函數類型在C中可能會出錯，因為C中並沒有函數類型，它的函數變量會自動退化成函數指針；在C++中好像是可以的。在這里主要說明的是形式上的相似性.
typedef的一般形式為：
typedef 類型 定義名;
在編程中使用typedef目的一般有兩個，一個是給變量一個易記且意義明確的新名字，另一個是簡化一些比較復雜的類型聲明。
其實，在C語言中聲明變量的時候，有個存儲類型指示符（storage-class-specifier），它包括我們熟悉的extern、static、auto、register。在不指定存儲類型指示符的時候，編譯器會根據約定自動取缺省值。另外，存儲類型指示符的位置也是任意的（但要求在變量名和指針*之前），也就是說以下幾行代碼是等價的：
static const int i;
const static int i;
int const static i;
const int static i;
根據C語言規范，在進行句法分析的時候，typedef和存儲類型指示符是等價的！所以，我們把上述使用static的地方替換為typedef：
typedef const int i;
const typedef int i;
int const typedef i;
const int typedef i;
上述代碼的語義是：將i定義為一個類型名，其等價的類型為const int。以后如果我們有i a代碼，就等價於const int a。對於有指針的地方也是一樣的，比如：
int const typedef *t;那么代碼t p。就相當於int const *p。
另外，typedef不能和static等存儲類型指示符同時使用，因為每個變量只能有一種存儲類型，所以代碼：typedef static int i;是非法的。
typedef有兩種用法：
一、一般形式，定義已有類型的別名
typedef 類型 定義名;
二、創建一個新的類型
typedef 返回值類型 新類型名(參數列表);
1）typedef int NUM[10];//聲明整型數組類型
NUM n;//定義n為整型數組變量，其中n[0]--n[9]可用
2）typedef char* STRING;//聲明STRING為字符指針類型
STRING p,s[10];//p為字符指針變量，s為指針數組
3）typedef int (*POINTER)();//聲明POINTER為指向函數的指針類型，該函數返回整型值,沒有參數
POINTER P1,P2;//p1，p2為POINTER類型的指針變量
說明：
1）用typedef可以聲明各種類型名，但不能用來定義變量，用typedef可以聲明數組類型、字符串類型、使用比較方便。
例如：定義數組，原來是用：int a[10],b[10],c[10],d[10];由於都是一維數組，大小也相同，可以先將此數組類型聲明為一個名字：
typedef int ARR[10];
然后用ARR去定義數組變量：
ARR a,b,c,d;//ARR為數組類型，它包含10個元素。因此a,b,c,d都被定義為一維數組，含10個元素。可以看到，用typedef可以將 數組類型 和 數組變量 分離開來，利用數組類型可以定義多個數組變量。同樣可以定義字符串類型、指針類型等。
2）用typedef只是對已經存在的類型增加一個類型名，而沒有創造新的類型。
3）typedef與#define有相似之處，但事實上二者是不同的，#define是在 預編譯 時處理，它只能做簡單的字符串替換，而typedef是在 編譯時 處理的。它並不是做簡單的字符串替換，而是采用如同 定義變量 的方法那樣來 聲明 一個類型。
例如：typedef int COUNT;和#define COUNT int的作用都是用COUNT代表int，單事實上它們二者是不同的。
兩個陷阱：
陷阱一：
記住，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; //不可行
編譯將失敗，會提示“指定了一個以上的存儲類”。
1.typedef 函數指針的使用方法
(1)typedef 首先是用來定義新的類型,i.e typedef struct {.....}mystruct; 在以后引用時，就可以用 mystruct 來定義自己的結構體，mystruct structname1，mystruct structname2.
(2)typedef 常用的地方，就在定義函數指針，行為和宏定義類似，用實際類型替換同義字，但是有區別： typedef 在編譯時被解釋，因此讓編譯器來應付超越預處理器能力的文本替換。
案例一：
通常講，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 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++錯誤。
用法一：
typedef 返回類型(*新類型)(參數表)
typedef int ( * MYFUNCTION )( int,int ); 這種用法一般是在定義函數指針 MYFUNCTION 是一個函數指針類型 有兩個整型的參數，返回一個整型。
在對於這樣的形式，去掉typedef和別名 就剩下了的是原變量的類型 如：int (*)(int ,int); 在函數指針中，抽象得看待函數,函數名其實就是一個地址,函數名指向該函數的代碼在內存的首地址。
用法二： 復雜函數聲明類型
下面是三個變量的聲明 用typedef 如何來做？？？
>1 int *(*a[5])(void *,void *);
>2 void (*b[5])(void (*)());
>3 float (*)()(*pa)[10];
分析如下：
>1 int *(*a[5])(void *,void *);
//pFUN是自己建立的類型別名 typedef int *(* pFUN)(void *,void *); //等價於int *(*a[5])(void *,void *);
pFUN a[5]; a是一個數組，包含五個元素，這些元素都是函數指針,該函數指針所指的函數的返回值是int的指針 輸入參數有兩個都是void *.
>2 void (*b[5])( void (*)() );
// first 為藍色的 聲明一個新的類型 typedef void (*pFUNParam)( );
//整體聲明一個新類型 typedef void (*pFUN)(FUNParam);
//使用定義的新類型聲明對象 等價於void (*b[5])( void (*)() );
pFUN b[5]; b 是一個含有5個元素的數組,每個元素都是一個函數指針，該函數指針所指的函數的返回值是void.輸入參數是另一個函數指針,這個函數指針沒有參數,返回值為空。在這里套用了連續的函數指針。本身就是一個函數指針，而且參數也是一個函數指針。
>3 float (*)()(*pa)[10];
//first 為上面的藍色表達式聲明一個新類型 typedef float (*pFUN)();
//整體聲明一個新類型typedef pFUN (* pFunParam)[10];
//使用定義的新類型來聲明對象 等價與float (*)()(*pa)[10];
pa 是一個指針，指針指向一個含有10個元素的數組,數組的元素是函數指針,函數指針所指的函數沒有輸入參數,返回值為float.
**********************************************
使用typedef簡化復雜的變量聲明
1）、定義一個有10個指針的數組，該指針指向一個函數，該函數有一個整形參數，並返回一個整型？
第一種方法：int (*a[10])(int);
第二種方法：typedef int (*pfunc)(int);
pfunc a[10];
2）、定義一個有10個指針的數組，該指針指向一個函數，該函數有一個函數指針（不帶參數，返回值為空）參數，並返回空。
第一種方法：void (*a[10])(void (*)(void));
第二種方法：typedef void (*pfuncParam)(void);
typedef void (*pfunc)(pfuncParam);
pfunc a[10];
3）、一個指向有10個函數指針（不帶參數，返回值為double）數組的指針
第一種方法：double (*)(void) (*p)[10];
第二種方法：typedef double (*pfunc)(void);
typedef pfunc (*pfuncParam)[10];
pfuncParam p;
從變量名看起，先往右，再往左，碰到一個圓括號就調轉閱讀的方向；括號內分析完就跳出括號，還是按先右后左的順序，如此循環，直到整個聲明分析完。舉例：
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 (*)[]數組指針
**********************************************
finally
typedef 使用最多的地方是創建易於記憶的類型名，用它來歸檔程序員的意圖。類型出現在所聲明的變量名字中，位於 ''typedef'' 關鍵字右邊。例如：
typedef int size;此聲明定義了一個 int 的同義字，名字為 size。注意 typedef 並不創建新的類型。它僅僅為現有類型添加一個同義字。你可以在任何需要 int 的上下文中使用 size：
void measure(size * psz); size array[4];size len = file.getlength();std::vector <size> vs; typedef 還可以掩飾符合類型，如指針和數組。例如，你不用象下面這樣重復定義有 81 個字符元素的數組：
char line[81];char text[81];定義一個 typedef，每當要用到相同類型和大小的數組時，可以這樣：
typedef char Line[81]; Line text, secondline;getline(text);同樣，可以象下面這樣隱藏指針語法：
typedef char * pstr;int mystrcmp(pstr, pstr);這里將帶我們到達第一個 typedef 陷阱。標准函數 strcmp()有兩個‘const char *'類型的參數。因此，它可能會誤導人們象下面這樣聲明 mystrcmp()：
int mystrcmp(const pstr, const pstr); 這是錯誤的，按照順序，‘const pstr'被解釋為‘char * const'（一個指向 char 的常量指針），而不是‘const char *'（指向常量 char 的指針）。這個問題很容易解決：
typedef const char * cpstr; int mystrcmp(cpstr, cpstr); // 現在是正確的記住：不管什么時候，只要為指針聲明 typedef，那么都要在最終的 typedef 名稱中加一個 const，以使得該指針本身是常量，而不是對象。
代碼簡化
上面討論的 typedef 行為有點像 #define 宏，用其實際類型替代同義字。不同點是 typedef 在編譯時被解釋，因此讓編譯器來應付超越預處理器能力的文本替換。例如：
typedef int (*PF) (const char *, const char *);這個聲明引入了 PF 類型作為函數指針的同義字，該函數有兩個 const char * 類型的參數以及一個 int 類型的返回值。如果要使用下列形式的函數聲明，那么上述這個 typedef 是不可或缺的：
PF Register(PF pf);Register() 的參數是一個 PF 類型的回調函數，返回某個函數的地址，其署名與先前注冊的名字相同。做一次深呼吸。下面我展示一下如果不用 typedef，我們是如何實現這個聲明的：
int (*Register (int (*pf)(const char *, const char *))) (const char *, const char *); 很少有程序員理解它是什么意思，更不用說這種費解的代碼所帶來的出錯風險了。顯然，這里使用 typedef 不是一種特權，而是一種必需。持懷疑態度的人可能會問：“OK，有人還會寫這樣的代碼嗎？”，快速瀏覽一下揭示 signal()函數的頭文件 < csinal>，一個有同樣接口的函數。
typedef 和存儲類關鍵字（storage class specifier）
這種說法是不是有點令人驚訝，typedef 就像 auto，extern，mutable，static，和 register 一樣，是一個存儲類關鍵字。這並是說 typedef 會真正影響對象的存儲特性；它只是說在語句構成上，typedef 聲明看起來象 static，extern 等類型的變量聲明。下面將帶到第二個陷阱：
typedef register int FAST_COUNTER; // 錯誤編譯通不過。問題出在你不能在聲明中有多個存儲類關鍵字。因為符號 typedef 已經占據了存儲類關鍵字的位置，在 typedef 聲明中不能用 register（或任何其它存儲類關鍵字）。
促進跨平台開發
typedef 有另外一個重要的用途，那就是定義機器無關的類型，例如，你可以定義一個叫 REAL 的浮點類型，在目標機器上它可以i獲得最高的精度：
typedef long double REAL; 在不支持 long double 的機器上，該 typedef 看起來會是下面這樣：
typedef double REAL; 並且，在連 double 都不支持的機器上，該 typedef 看起來會是這樣： 、
typedef float REAL; 你不用對源代碼做任何修改，便可以在每一種平台上編譯這個使用 REAL 類型的應用程序。唯一要改的是 typedef 本身。在大多數情況下，甚至這個微小的變動完全都可以通過奇妙的條件編譯來自動實現。不是嗎? 標准庫廣泛地使用 typedef 來創建這樣的平台無關類型：size_t，ptrdiff 和 fpos_t 就是其中的例子。此外，象 std::string 和 std::ofstream 這樣的 typedef 還隱藏了長長的，難以理解的模板特化語法，例如：basic_string<char, char_traits<char>，allocator<char>> 和 basic_ofstream<char, char_traits<char>>。