1 指針和引用的區別
1.指針是一個變量，裏面存放的是地址，而引用則是原變量的一個別名；
2.可以由const指針，但是 沒有const引用；
3.指針的值可以爲NULL，但是應用不能爲空，在初始化的時候必須要指定；
4.指針的值在初始化完成之後可以被改變，但是引用在初始化的之後不能被改變；
5.sizeof引用"得到的是所指向的變量(對象)的大小，而"sizeof指針"得到的是指針本身的大小；
6.指針和引用的++的意義不一樣
2 memcpy和strcpy的區別
memcpy是用來內存的拷貝，需要指定長度，可以是任何的數據類型；
strcpy是用來拷貝字符串的，遇到‘/0’就會結束；
3 new，delete和malloc，free的區別
new和delete是C++的運算符，malloc和free是C、c++標準庫的函數，用來申請內存和釋放內存；對於非內部的數據類型對象，使用malloc和free不能滿足要求。
因爲在創建對象的時候，會調用對象的構造函數，在對象滅忙的時候，會調用對象的析構函數。但是由於malloc和free是庫函數，編譯器不能把執行構造函數和
析構函數的任務交給malloc和free；
4 struct和class的區別
1 成員變量的默認訪問權限
struct的默認成員變量的權限是public，但是Class的是private。
2 存儲順序
struct的成員是按聲明的順序來存儲的，但是Class確實不一定。
3 繼承
對於繼承，struct是public，而Class是private
5 union和struct的區別
1 union是所有的變量共用的一個內存區域，長度是由最大長度的那個變量決定；struct的變量時獨立分配的。
2 union的變量時連續分配的，但是struct的變量不一定是連續的。
6 如何引用一個已經定義過的全局變量
可以用引入文件頭的方式，也可以用extern的方式來引入。如果使用文件頭的方式來引進一個在某個文件頭聲明的全局變量，如果全局變量寫錯，則是編譯期間會出現錯誤；
如果是應用extern的方式來引進全局變量，則是在鏈接階段發現錯誤。
7 全局變量可不可以定義在可被多個.C文件包含的頭文件中？爲什麼？
可以。在不同的C文件中可以static的方式來聲明，但是前提是隻有一個C文件複製，否則會出現錯誤。
8 描述內存分配的方式以及區別
1 靜態內存分配，內存在分配的時候就已經分配好了，在整個運行程序運行的期間都存在，如static變量和全局變量。
2 在棧上分配，執行函數的時候會在棧上分配局部變量，當函數執行結束的時候，局部變量就會被釋放。
3 在堆上分配，這一部分可以由程序員決定，可以用malloc，new來分配內存，但是又要使用free和delete來處理釋放。
9 類成員函數的重載，覆蓋和隱藏的區別
1 重載：參數的個數，類型不同；
2 是指派生類覆蓋父類的函數：不同的範圍，基函數必須有virtual，函數名和函數參數都要相同；
3 隱藏是指派生類的函數隱藏了與其同名的基類的函數：如果派生類的函數與基類的函數同名，但是參數不同，無論是否有virtual，基類的函數將被隱藏；
如果派生類的函數與基類的函數同名，參數相同，但是沒有virtual，基類的函數將被隱藏。
10 static的作用
1.設定作用域；
2設置存儲形式。
11 說出const和#define的區別
const常量有數據類型的，但是宏常量是沒有數據類型的。編譯器可以對前者進行類型檢查，但是對後者只是字符串替換，可能會出想不到的錯誤。
12 簡述一下數組和指針的區別？
1數組要麼在靜態存儲區域分配內存，要麼在棧上分配內存。但是指針可以指向任意的內存塊
(1)修改內容上的差別
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發現該錯誤，運行時錯誤
(2) 用運算符sizeof 可以計算出數組的容量（字節數）。sizeof(p),p 爲指針得到的是一個指針變量的字節數，而不是p 所指的內存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作爲函數的參數進行傳遞時，該數組自動退化爲同類型的指針。
13 There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.
( ( a + b ) + abs( a – b ) ) / 2
14 變量在內存中存放的區域
全局變量 全局靜態區
全局靜態變量 全局靜態區
全局常量
有初始化 代碼區
無初始化 全局靜態區
局部變量 堆棧區
局部靜態變量 靜態區
局部常量 堆棧區 v
new和malloc分配空間 堆區
14 進程間的通信方式
管道，共享內存，信號量，socket，消息隊列
15 線程同步方式
臨界區：線程串行化訪問的一段共享區域；
互斥：當一個線程訪問共享資源的時候，其他的進程不能進入臨界區；
信號量：用來控制互斥的一組變量。
16 進程和線程的區別
資源：進程是擁有資源的單位，但是線程沒有用友資源；
調度：線程是調度和分配的基本單位，進程是資源的基本單位；
並行：進程間可以並行運行，線程是在進程內並行運行；
系統開銷：進程創建和銷燬是由系統決定的，進程創建的開銷大，一個進程可以有多個線程。
17 純虛函數和虛函數的區別
虛函數必須有實現，純虛函數沒有實現
虛函數可以不在派生類中重載，但是純虛函數必須在每一個子類中去實現；
動態內存分配的時候，析構函數必須是虛函數，但沒有必要是純虛函數
18 面向對象的四大特性
繼承：子類從父類中獲得的屬性和方法；
封裝：把客觀事物封裝成抽象的類，讓信任的類或者對象可以訪問，不信任的則對信息隱藏引來。
多態：具有不同的數據類型表現出不同的行爲。由繼承產生的相關的不同的類，其對象對同一消息會做出不同的反應。
抽象：抽取共同的，本質的。
19 判斷一個鏈表是否有環？
兩個指針指向頭指針，一個指針每次走一步，另一個指針每次走兩步，如果有一個指針先爲NULL,則沒環；如果重複，則有環。
20 刷新緩衝區的方式？
print("/n")：換行刷新緩衝區。
fflush(stdout):函數刷新緩衝區。
return 0: 結束刷新緩衝區。
21 類和對象的概念
對象就是對客觀事物在計算機上的描述；
類就是對有相似屬性和行爲的一組對象的描述。
22 數據庫範式？
第一範式：沒有重複的列；
第二範式：非主屬的部分依賴於主屬的部分；
第三範式：屬性不依賴於其他非主屬 的部分
23 ASSERT
調試程序中的一個宏，不滿足，報告錯誤，並終止執行；
24 如果只想讓程序有一個實例運行，不能運行兩個。像winamp一樣，只能開一個窗口，怎樣實現
內存映射或全局原子（互斥變量），查找句柄，修改註冊表，共享內存；
25如何截取鍵盤的響應，讓所有的’a’變成’b’？
鍵盤鉤子SetWindowsHookEx
char *strcat(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while (*strDes != ‘\0′)
++ strDes;
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return address;
}
strncat
char *strncat(char *strDes, const char *strSrc, int count)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while (*strDes != ‘\0′)
++ strDes;
while (count — && *strSrc != ‘\0′ )
*strDes ++ = *strSrc ++;
*strDes = ‘\0′;
return address;
}
strcmp
int strcmp(const char *s, const char *t)
{
assert(s != NULL && t != NULL);
while (*s && *t && *s == *t)
{
++ s;
++ t;
}
return (*s – *t);
}
strncmp
int strncmp(const char *s, const char *t, int count)
{
assert((s != NULL) && (t != NULL));
while (*s && *t && *s == *t && count –)
{
++ s;
++ t;
}
return (*s – *t);
}
strcpy
char *strcpy(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return address;
}
strncpy
char *strncpy(char *strDes, const char *strSrc, int count)
{
assert(strDes != NULL && strSrc != NULL);
char *address = strDes;
while (count — && *strSrc != ‘\0′)
*strDes ++ = *strSrc ++;
return address;
}
strlen
int strlen(const char *str)
{
assert(str != NULL);
int len = 0;
while (*str ++ != ‘\0′)
++ len;
return len;
}
strpbrk
char *strpbrk(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
while (*strSrc != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*strSrc == *s)
return (char *) strSrc;
++ s;
}
++ strSrc;
}
return NULL;
}
strstr
char *strstr(const char *strSrc, const char *str)
{
assert(strSrc != NULL && str != NULL);
const char *s = strSrc;
const char *t = str;
for (; *t != ‘\0′; ++ strSrc)
{
for (s = strSrc, t = str; *t != ‘\0′ && *s == *t; ++s, ++t)
NULL;
if (*t == ‘\0′)
return (char *) strSrc;
}
return NULL;
}
strcspn
int strcspn(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*t == *s)
return t – strSrc;
++ s;
}
++ t;
}
return 0;
}
strspn
int strspn(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*t == *s)
break;
++ s;
}
if (*s == ‘\0′)
return t – strSrc;
++ t;
}
return 0;
}
strrchr
char *strrchr(const char *str, int c)
{
assert(str != NULL);
const char *s = str;
while (*s != ‘\0′)
++ s;
for (– s; *s != (char) c; — s)
if (s == str)
return NULL;
return (char *) s;
}
strrev
char* strrev(char *str)
{
assert(str != NULL);
char *s = str, *t = str, c;
while (*t != ‘\0′)
++ t;
for (– t; s < t; ++ s, — t)
{
c = *s;
*s = *t;
*t = c;
}
return str;
}
strnset
char *strnset(char *str, int c, int count)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘\0′ && s – str < count; ++ s)
*s = (char) c;
return str;
}
strset
char *strset(char *str, int c)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘\0′; ++ s)
*s = (char) c;
return str;
}
strtok
char *strtok(char *strToken, const char *str)
{
assert(strToken != NULL && str != NULL);
char *s = strToken;
const char *t = str;
while (*s != ‘\0′)
{
t = str;
while (*t != ‘\0′)
{
if (*s == *t)
{
*(strToken + (s – strToken)) = ‘\0′;
return strToken;
}
++ t;
}
++ s;
}
return NULL;
}
strupr
char *strupr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘\0′)
{
if (*s >= ‘a’ && *s <= ‘z’)
*s -= 0×20;
s ++;
}
return str;
}
strlwr
char *strlwr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘\0′)
{
if (*s >= ‘A’ && *s <= ‘Z’)
*s += 0×20;
s ++;
}
return str;
}
memcpy
void *memcpy(void *dest, const void *src, int count)
{
assert((dest != NULL) && (src != NULL));
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return address;
}
memccpy
void *memccpy(void *dest, const void *src, int c, unsigned int count)
{
assert((dest != NULL) && (src != NULL));
while (count –)
{
*(char *) dest = *(char *) src;
if (* (char *) src == (char) c)
return ((char *)dest + 1);
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return NULL;
}
memchr
void *memchr(const void *buf, int c, int count)
{
assert(buf != NULL);
while (count –)
{
if (*(char *) buf == c)
return (void *) buf;
buf = (char *) buf + 1;
}
return NULL;
}
memcmp
int memcmp(const void *s, const void *t, int count)
{
assert((s != NULL) && (t != NULL));
while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count –)
{
s = (char *) s + 1;
t = (char *) t + 1;
}
return (*(char *) s – *(char *) t);
}
memmove
void *memmove(void *dest, const void *src, int count)
{
assert(dest != NULL && src != NULL);
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (const char *)src + 1;
}
return address;
}
memset
void *memset(void *str, int c, int count)
{
assert(str != NULL);
void *s = str;
while (count –)
{
*(char *) s = (char) c;
s = (char *) s + 1;
}
return str;
}
strdup
char *strdup(const char *strSrc)
{
assert(strSrc != NULL);
int len = 0;
while (*strSrc ++ != ‘\0′)
++ len;
char *strDes = (char *) malloc (len + 1);
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return strDes;
}
strchr_
char *strchr_(char *str, int c)
{
assert(str != NULL);
while ((*str != (char) c) && (*str != ‘\0′))
str ++;
if (*str != ‘\0′)
return str;
return NULL;
}
strchr
char *strchr(const char *str, int c)
{
assert(str != NULL);
for (; *str != (char) c; ++ str)
if (*str == ‘\0′)
return NULL;
return (char *) str;
}
atoi
int atoi(const char* str)
{
int x=0;
const char* p=str;
if(*str==’-’||*str==’+’)
{
str++;
}
while(*str!=0)
{
if((*str>’9′)||(*str<’0′))
{
break;
}
x=x*10+(*str-’0′);
str++;
}
if(*p==’-’)
{
x=-x;
}
return x;
}
itoa
char* itoa(int val,char* buf,unsigned int radix)
{
char *bufptr;
char *firstdig;
char temp;
unsigned int digval;
assert(buf != NULL);
bufptr = buf;
if (val < 0)
{
*bufptr++ = ‘-’; val = (unsigned int)(-(int)val);
}
firstdig = bufptr;
do
{
digval =(unsigned int) val % radix; val /= radix;
if (digval > 9)
{
*bufptr++ = (char)(digval – 10 + ‘a’);
}
else
{
*bufptr++ = (char)(digval + ’0′);
}
} while(val > 0);
*bufptr– = ‘\0′;//設置字符串末尾，並將指針指向最後一個字符
do //反轉字符
{
temp = *bufptr; *bufptr = *firstdig; *firstdig = temp;
–bufptr; ++firstdig;
} while(firstdig < bufptr);
return buf;
}
String實現
已知String原型爲：
class String
{
public:
//普通構造函數
String(const char *str = NULL)
//拷貝構造函數
String(const String &other)
//析構函數
~String(void);
//賦值函數
String & operator=(String &other) //oh,原題目打錯了,string可是一個關鍵字
private:
char* m_str;
unsigned m_uCount;
};
分別實現以上四個函數
//普通構造函數
String::String(const char* str)
{
if(str==NULL) //如果str爲NULL，存空字符串
{
m_str = new char[1]; //分配一個字節
*m_str = ‘\0′; //賦一個’\0′
}else
{
m_str = new char[strlen(str) + 1];//分配空間容納str內容
strcpy(m_str, str); //複製str到私有成員m_str中
}
}
//析構函數
String::~String()
{
if(m_str!=NULL) //如果m_str不爲NULL，釋放堆內存
{
delete [] m_str;
m_str = NULL;
}
}
//拷貝構造函數
String::String(const String &other)
{
m_str = new char[strlen(other.m_str)+1]; //分配空間容納str內容
strcpy(m_str, other.m_str); //複製other.m_str到私有成員m_str中
}
//賦值函數
String & String::operator=(String &other)
{
if(this == &other) //若對象與other是同一個對象，直接返回本身
{
return *this
}
delete [] m_str; //否則，先釋放當前對象堆內存
m_str = new char[strlen(other.m_str)+1]; //分配空間容納str內容
strcpy(m_str, other.m_str); //複製other.m_str到私有成員m_str中
return *this；
}
編寫一個二分查找的功能函數
int BSearch(elemtype a[],elemtype x,int low,int high)
/*在下屆爲low，上界爲high的數組a中折半查找數據元素x*/
{
int mid;
if(low>high)
return -1;
mid=(low+high)/2;
if(x==a[mid])
return mid;
if(x<a[mid])
return(BSearch(a,x,low,mid-1));
else
return(BSearch(a,x,mid+1,high));
}
2) 非遞歸方法實現：
int BSearch(elemtype a[],keytype key,int n)
{
int low,high,mid;
low=0;high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(a[mid].key==key)
return mid;
else if(a[mid].key<key)
low=mid+1;
else
high=mid-1;
}
return -1;
}
字符串逆序
方法一
#include <stdio.h>
#include <string.h>
void main()
{
char str[]=”hello,world”;
int len=strlen(str);
char t;
int i;
for(i=0; i<len/2; i++)
{
t=str[i];
str[i]=str[len-i-1];
str[len-i-1]=t;
}
printf(“%s\n”,str);
return 0;
}
方法二
#include <stdio.h>
int main(){
char* src = “hello,world”;
int len = strlen(src);
char* dest = (char*)malloc(len+1);//要爲\0分配一個空間
char* d = dest;
char* s = &src[len-1];//指向最後一個字符
while( len– != 0 )
*d++=*s–;
*d = 0;//尾部要加\0
printf(“%s\n”,dest);
free(dest);// 使用完，應當釋放空間，以免造成內存匯泄露
return 0;
}
排序
冒泡排序
void bubble_sort(int a[],int n)
{
int i,j;
for(i=0;i<n-1;i++)
{
bool x=ture;
for(j=0;j<n-1-i;j++)
{
int temp;
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
x=false;
}
}
if(x) break;
}
}
時間複雜度O(N^2)
選擇排序
void select_sort(int a[],int n)
{
int i,j;
for(i=0;i<n-1;i++)
{
int min=i;
for(j=i+1;j<n;j++)
{
if(a[j]<a[min])
min=j;
if(min!=i)
{
int temp=a[j];
a[j]=a[min];
a[min]=temp;
}
}
}
}
時間複雜度O(N^2)
插入排序
void insert_sort(int a[],int n)
{
int i,j;
for(i=1;i<n;i++)
{
int x=a[i];
for(j=i;j>0&&x<a[j-1];j–)
a[j]=a[j-1];
a[j]=x;
}
}
時間複雜度O(N^2)
快速排序
void quick_sort(int a[],int ileft,int iright)
{
int iPivot=(left+right)/2;
int nPivot=a[iPivot];
for(int i=ileft,j=iright;i<j;)
{
while(!(i>=iPivot||nPivot<a[i]))
i++;
if(i<iPivot)
{
a[iPivot]=a[i];
iPivot=i;
}
while(!(j<=iPivot||nPivot>a[j]))
j–;
if(j>iPivot)
{
a[iPivot]=a[j];
iPivot=j;
}
}
a[iPivot]=nPivot;
if(iPivot-ileft>1)
quick_sort(a,ileft,iPivot-1);
if(iright-iPivot>1)
quick_sort(a,iPivot+1,iright);
}
時間複雜度O(NlogN)
鏈表
單鏈表
雙鏈表
循環鏈表
單鏈表逆置
void reverse(link *head)
{
link *p, *s, *t;
p = head;
s = p->next;
while(s->next!=NULL)
{
t = s->next;
s->next = p;
p = s;
s = t;
}
s->next = p;
head->next->next = NULL; //尾指針置爲空
head->next = s; //賦值到頭指針後一位
}
鏈表合併
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
遞歸方式：
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}
return head ;
}
寫一個Singleton模式
#include<iostream>
using namespace std;
class Singleton
{
private:
static Singleton* _instance;
protected:
Singleton()
{
cout<<”Singleton”<<endl;
}
public:
static Singleton* Instance()
{
if(NULL==_instance)
{
_instance=new Singleton();
}
return _instance;
}
};
static Singleton* Singleton::_instance=NULL;
int main()
{
Singleton * s =Singleton::Instance();
Singleton * s1=Singleton::Instance();
}
如何對String類型數據的某個字符進行訪問？
#include<iostream>
using namespace std;
int main()
{
string s=”abcdefg”;
const char *c=s.c_str();
while(*c!=’\0′)
{
printf(“%c”,*c++);
}
}
文件加密、解密
1.加密（encryption）：
#include<stdio.h>
void encryption(char *ch)
{
(*ch)^=0xFF; //算法可自行修改調整，使用AES加密算法
}
int main(int argc,char *argv[])
{
if(argc<2)
{
printf(“參數不足”);
return -1;
}
//文件的打開（fopen函數）
/*
r read 只讀
w write 只寫
a append 追加
t text 文本文件，可省略不寫
b banary 二進制文件
+ 讀和寫
*/
a.out a.c b.txt
argv[0] argv[1] argv[2]
FILE* fpr=NULL;
FILE* fpw=NULL;
//文件打開失敗返回一個空指針值NULL
if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
char ch;
while((ch=fgetc(fpr))!=EOF)
{
//putchar(ch);
encryption(&ch);//加密函數
printf(“%c”,ch);//加密後字符顯示
fputc(ch,fpw);//存放進文件
}
printf(“\n文件加密成功！\n”);
//文件的關閉(fclose函數)
fclose(fpr);
fclose(fpw);
}
2.解密（decryption）：
#include<stdio.h>
#include<time.h>
void show()
{
time_t start=time(NULL);
while(start==time(NULL));
}
void decryption(char ch)
{
(*ch)^=0xFF;//算法可自行修改調整
}
int main(int argc,char *argv[])
{
if(argc<2)
{
printf(“參數不足”);
return -1;
}
//文件的打開（fopen函數）
/*
r read 只讀
w write 只寫
a append 追加
t text 文本文件，可省略不寫
b banary 二進制文件
+ 讀和寫
*/
FILE* fpr=NULL;
FILE* fpw=NULL;
//文件打開失敗返回一個空指針值NULL
if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
char ch;
printf(“開始解密！\n”);
while((ch=fgetc(fpr))!=EOF)
{
show();
ch=decryption(ch);//解密函數
printf(“%c”,ch);//解密後字符顯示
fputc(ch,fpw);//存放進文件
fflush(stdout);//刷新顯示
}
printf(“\n文件解密成功！\n”);
//文件的關閉(fclose函數)
fclose(fpr);
fclose(fpw);
}
斐波那契數列（Fibonacci sequence）
int Funct( int n )
{
if( n==0 || n==1 ) return 1;
retrurn Funct(n-1) + Funct(n-2);
}