1. c語言異常處理和結構化異常處理有什麼區別
總的來說，結構化異常處理和異常處理之間的區別就是Microsoft對異常處理程序在實現上的不同。所謂的「普通」C++異常處理使用了三條附加的c++語句：try，catch和throw。這些語句的作用是，當正在執行的程序出現異常情況時，允許一個程序(異常處理程序)試著找到該程序的一個安全出口。異常處理程序可以捕獲任何數據類型上的異常情況，包括C++類。這三條語句的實現是以針對異常處理的ISO WG21／ANSI X3J16 C++標准為基礎的，Microsoft C++支持基於這個標準的異常處理。注意，這個標准只適用於C++，而不適用於C。
結構化異常處理是Microsoft c／c++編譯程序的一種功能擴充，它的最大好處就是它對C和C++都適用。Microsoft的結構化異常處理使用了兩種新的結構：try—except和try-finally。這兩種結構既不是ANSI c++標準的子集，也不是它的父集，而是異常處理的另一種實現(Microsoft會繼續在這方面努力的)。try—except結構被稱為異常處理(exception handling)，tryfinally結構被稱為終止處理(termination handling)。try—except語句允許應用程序檢索發生異常情況時的機器狀態，在向用戶顯示出錯信息時，或者在調試程序時，它能帶來很大的方便。在程序的正常執行被中斷時，try—finally語句使應用程序能確保去執行清理程序。盡管結構化異常處理有它的優點，但它也有缺點——它不是一種ANSI標准，因此，與使用ANSI異常處理的程序相比，使用結構化異常處理的程序的可移植性要差一些。如果你想編寫一個真正的C++應用程序，那麼你最好使用ANSI異常處理(即使用try，catch和throw語句)。
2. C語言、雙向鏈表
#include <stdio.h>
#include <string.h>
struct person
{
char name[10];
int number;
person *next;
person *last;
};person *p,*q,*start=NULL,*end;void insert(int num,char nam[10])//插入函數,按姓名的首字母順序插入鏈表中的。
{
q=new person;
if (start==NULL) //判斷start是否為空 若空則新建
{
start=q;
end=q;
p=q;
start->last=NULL;
end->next=NULL;
}
else
{
if(strcmp(nam,start->name)<=0)//插入鏈表頭
{
start->last=q;
q->next=start;
q->last=NULL;
start=q;
}
else if (strcmp(nam,end->name)>0) //插入表尾部
{
end->next=q;
q->last=end;
end=q;
q->next=NULL;
}
else if (strcmp(nam,end->name)<0&&strcmp(nam,start->name)>0)//插入鏈表中
{
for (p=start;strcmp(nam,p->name)>0;p=p->next);
q->next=p;
p->last=q;
for (p=start;p->next!=q->next;p=p->next);
p->next=q;
q->last=p;
}
}
strcpy(q->name,nam);
q->number=num;
}
void find(int num) //按編號查找
{
if(start==NULL)
{
printf("無記錄\n");
}
else
{
for(p=start;p!=NULL&&p->number!=num;p=p->next);
if(p==NULL)
{
printf("不存在的編號!\n");
}
else if (p->number==num)
{
printf("您查找的編號是:%d\n",num);
printf("該生的姓名為:%s",p->name);
}
}
} void del(int num) //按編號刪除
{
for(p=start;p->number!=num;p=p->next);
if (p->number==num)
{
if (p->next==NULL)
{
if(p->last==NULL)
{
start=NULL;
}
else
{
(p->last)->next=NULL;
}
delete p;
}
else if (p->last==NULL)
{
(p->next)->last=NULL;
start = p->next;
delete p;
}
else if(p->last!=NULL&&p->next!=NULL)
{
(p->last)->next=p->next;
(p->next)->last=p->last;
delete p;
}
}
else
{
printf("不存在的編號!\n");
}
}void show()
{
printf("學號\t姓名\n");
for (p=start;;p=p->next)
{
printf("%d\t%s\n",p->number,p->name);
if (p->next==NULL)
break;
}
}void main()
{
int i,num;
char nam[10];
printf("輸入三位學生信息（學號，姓名）:");
for(i=0;i<3;i++)
{
scanf("%d%s",&num,nam);
insert(num,nam);
}
show();
printf("輸入要刪除的學生的學號:");
scanf("%d",&num);
del(num);
show();
printf("輸入要查找的學生的學號:");
scanf("%d",&num);
find(num);
//show();
}
3. c語言偽碼書寫的規范是什麼
偽碼書寫可以參考C代碼規范。
1.
1.1符號命名規則
1.1.1符號名包括模塊名、常量名、標號名、子程序名等。這些名字應該能反映它所代表的實際東西，具有一定的意義，使其能夠見名知義，有助於對程序功能的理解。命名採用匈牙利命名法。規則如下：
(1)所有宏定義、枚舉常數和const變數，用大寫字母命名。在復合詞里用下劃線隔開每個詞。
(2)復合詞中每個單詞的第一個字母大寫。除了規則5.1.1.1以外，避免使用下劃線。
(3)類、類型定義和枚舉型名的第一個字母大寫。
(4)函數名是復合詞的，第一個詞採用全部小寫，隨後每個單詞採用第一個字母大寫，其它字母小寫方式；如果是單個詞的，採用全部小寫方式。
(5)循環變數可採用i,
j,
k等，不受上述規則限制。
(6)
類的成員變數應採用m_開頭。
(7)
全局變數詞頭為g_
。
(8)
臨時變數詞頭為tmp_
。
(9)
對結構體內的變數命名,
遵循變數的具體含義命名原則
(10)用小寫字母的前綴表示變數的類型，前綴的下一個字母用大寫。
表
1
詞頭
類型
詞頭
類型
ch
char
l
long
i
integer
u
unsigned
b
boolean
p
pointer
f
float
lp
long
pointer
d
double
s
string
st
structure
sz
ASCII
string
by
byte
n
short
int
H
handle
x,y
分別為x,y坐標
dw
DWORD
fn
function
表
2
詞頭
變數名
詞頭
變數名
task
task
sig
signal
sb
binary
semaphores
wd
watchdog
sm
mutual
exclusion
tm
timer
sc
counting
semaphores
msg
message
pipe
pipe
例：
#define
ARRAY_SIZE
24
/*規則5.1.1.1*/
int
g_iFlag;
class
MyClass
/*規則5.1.1.3*/
{
};
void
someFunc(
)
/*規則5.1.1.2和5.1.1.4*/
{
int
nArray[ARRAY_SIZE];
unsigned
char
uchByte;
char
szName[
];
char
*pszName
=
szName;
}
(11)有些詞頭（如p和u）可以和其它詞頭組合。
例：WDOG_ID
wdId;
WDOG_ID
g_wdId;
/*全局watchdog
Id，故以g_開頭*/
1.1.2名字的長度一般不要過長或過短。過長的名字會增加工作量，使程序邏輯流程變得模糊；過短的名字無法表達符號的實際意義。約定長度范圍：3-31；
1.2數據和函數說明
1.2.1數據說明次序應當規范化，使數據屬性容易查找，也有利於測試、排錯和維護。說明的先後次序應固定，應按邏輯功能排序，邏輯功能塊內建議採用下列順序：整型說明、實型說明、字元說明、邏輯量說明。
1.2.2如果設計了一個復雜的數據結構，應當通過注釋對其變數的含義、用途進行說明。
1.2.3在函數的聲明中使用異常聲明。
如：void
f()
throw(toobig,
toosmall,
divzero);
在聲明一個函數時，將它所拋出的異常列出，便於函數的使用者了解可能會發生哪些異常。
1.3
程序注釋
1.3.1程序注釋是程序員與日後的程序讀者之間通信的重要手段之一，注釋分為文件注釋、函數注釋和功能注釋。
1.3.2正規程序的注釋應注意：
——注釋行的數量佔到整個源程序的1/3到1/2。
1.3.3文件注釋位於整個源程序的最開始部分，注釋後空兩行開始程序正文。它包括：
——程序標題。
——目的、功能說明。
——文件作者、最後修改日期等說明。
例：
./********************************************************************
（空一行）
標題:
Demo.c
功能:
測試VxWorks的各種系統調用.
說明:
該程序測試各種VxWorks的系統調用函數。包括任務（taks）的創建、掛起及任務間通過信號燈實現同步，通過消息隊列
進行通訊。
程序創建了兩個任務：一個高優先順序的任務和一個低優先順序的任務。兩個任務間通過一個二進制的信號燈進行同步，通過消息隊列進行通訊。
當前版本：
x.x
修改信息：
2000.06.05
John，
Initial
Version
2000.07.05
Tom，
Bug
xxxx
fixed
**************************************************************/
(空2行，開始程序正文)
1.3.4
函數注釋通常置於每函數或過程的開頭部分，它應當給出函數或過程的整體說明對於理解程序本身具有引導作用。一般包括如下條目：
——模塊標題。
——有關本模塊功能和目的的說明。
——調用格式
——介面說明：包括輸入、輸出、返回值、異常。
——演算法。如果模塊中採用了一些復雜的演算法。
例：
file://（/注釋開頭應和上一函數空兩行）
（注釋開頭與上一函數最後一行間隔兩行）
/********************************************************************
標題：assignmentComplete
功能：BSC=>MSC消息生成函數，生成assignment_complete指配完成消息(BSMAP消息)
.
格式：
int
assignmentComplete(int
iCellId,
int
iServiceChannnelNum,
char
*pszMSGData)
throw(exception1,
exception2)
輸入：
int
iCellId:
MS所在的小區識別
iCellId取值：0x00-——0xff
int
iServiceChannnelNum：MS所佔的業務信道號碼
輸出：
char
*
pszMSGData：指配完成消息數據
返回值:
0x00正常
異常：exception1異常情況1,
exception2異常情況2
********************************************************************/
(
注釋後直接開始程序正文，不空行。)
1.3.5功能性注釋嵌在源程序體中，用於描述其後的語句或程序段做什麼工作，也就是解釋下面要做什麼，或是執行了下面的語句會怎麼樣。而不要解釋下面怎麼做，因為解釋怎麼做常常與程序本身是重復的。
例：
/*把
amount
加到
total中*/
total
=
amount
+
total;
這樣的注釋僅僅是重復了下面的程序，對於理解它的工作並沒有什麼作用。而下面的注釋，有助於讀者理解。
/*將每月的銷售額amount加到年銷售額total中*/
total
=
amount
+
total;
1.4
函數編寫應盡可能短小精悍，一般不超過兩屏，以便於調試和理解。
1.5語句結構
為保證語句結構的清晰和程序的可讀性，在編寫軟體程序時應注意以下幾個方面的問題：
——在一行內只寫一條語句，並採用空格、空行和移行保證清楚的視覺效果。
——每一個嵌套的函數塊，使用一個TAB縮進（可以設定為4個空格），大括弧必須放在條件語句的下一行，單獨成一行，便於匹對：
如，有一段程序如下：
for(i=1;i<n-1;i++){
t=1;
for(j=i+1;j<n;j++){
if(a[j]<a[t]
)
t=j;
if(t!=i
){work=a[t];a[t]=a[I];a[I]=work;}}}
應寫為
for(
i=1;
i<n-1;
i++)
{
t=1;
for(j
=
i+1;
j<n;
j++)
{
if(a[i]<a[j])
t=j;
if(t!=1)
{
.5.
Q/ECC/BJ
010—2001
work=a[t];
a[t]=a[i];
a[i]=work;
}
}
}
——文件之中不得存在無規則的空行，比如說連續十個空行。
一般來講函數與函數之間的空行為2-3行；
在函數體內部，在邏輯上獨立的兩個函數塊可適當空行，一般為1-2行。
——程序編寫首先應考慮清晰性，不要刻意追求技巧性而使得程序難以理解。
——每行長度盡量避免超過屏幕寬度，應不超過80個字元。
——除非對效率有特殊要求，編寫程序要作到清晰第一，效率第二。
——盡可能使用函數庫。
——盡量用公共過程或子程序去代替重復的功能代碼段。要注意，這個代碼應具有一個獨立的功能，不要只因代碼形式一樣便將其抽出組成一個公共過程或子程序。
——使用括弧清晰地表達算術表達式和邏輯表達式的運算順序。如將
x=a*b/c*d
寫成
x=(a*b/c)*d可避免閱讀者誤解為x=(a*b)/(c*d)。
——避免不必要的轉移。
——避免採用過於復雜的條件測試。
——避免過多的循環嵌套和條件嵌套。
——建議不要使用
*=，^=,
/=等運算符。
——一個函數不要超過200行。一個文件應避免超過2000行。
——盡量避免使用go
to語句。
——避免採用多賦值語句，如x
=
y
=
z
;
——不鼓勵採用?:操作符，如z
=
(a>b)?a:b;
——不要使用空的if
else
語句。如
if(cMychar
>=
『A』)
if(cMychar
<=
『Z』)
printf(「This
is
a
letter
\n」);
else
printf(「This
is
not
a
letter
\n」);
else到底是否定哪個if容易引起誤解。可通過加{}避免誤解。
——盡量減少使用「否定」條件的條件語句。如：
把
if(
!(
(cMychar<』0』)
||
(cMychar>』9』)
)
)
改為if(
(cMychar>=』0』)
&&
(cMychar<=』9』)
)
4. C語言異常處理
bad_alloc：new分配失敗
bad_cast：dynamic_cast失敗
bad_typeid：typeif參數為空
logic_error：邏輯錯誤
ios_base::failure：IO錯誤
runtime_error：運行時錯誤
bad_exception：未知錯誤
賦值不成功可以用runtime_error，你也可以自己繼承一個異常類過來，自定義異常信息
5. C語言如何用throw在程序中拋出異常 try-catch又怎麼用
不是 catch只是為了捕獲到異常而進行處理 如果你不需要處理異常的話 就不用try-catch了 直接throw就可以了 或者是你覺得可能會有異常 但是這異常是由於程序解決不了的 不如資料庫鏈接不上了 那你就throw異常 然後輸出異常就可以了 ！
6. 在java中拋出異常的時候,throw和throws有什麼區別
JAVA使用.支持.介紹.
一、前言
『Java』從1995年的暑假開始在計算機業界就受到了高度注意，特別是在Internet和多 媒體(Multimedia)相關產品類方面。Java為何有如此這么大的魅力？人作如此的比喻： Java在全球資訊網(World Wide Web, WWW)地位就如同電子表格(Spreadsheet)與個人計 算機(PC)的關系。那Java究竟有那些特色呢？
Java是一種軟體技術
是一種由美國SUN計算機公司(Sun Microsystems, Inc.)所研究而成的語言
是一種為 Internet發展的計算機語言
是一種使網頁(Web Page)產生生動活潑畫面的語言
是一種使網頁(Web Page)由靜態(Static)轉變為動態(Dynamic)的語言
是一種語言，用以產生「小應用程序(Applet(s))」
是一種簡化的C++語言 是一種安全的語言，具有阻絕計算機病毒傳輸的功能
是一種將安全性(Security)列為第一優先考慮的語言
是一種使用者不需花費很多時間學習的語言
是一種突破用戶端機器環境和CPU結構的語言
是一種「寫一次，即可在任何機器上執行(Write OnceRun Anywhere)」的語言是有史以來，第一套允 使用者將應用程序(Applications)通過Internet從遠端的伺服器(Remote Server)傳輸到本地端的機器 上(LocalMachine)並執行
是一種應用程序提供者不需要知道使用者的計算機硬體(如：Sun, Intel, 或MAC等)與軟體(如：SW- UNIX, MAC O/S, Windows, 或NT等)環境的語言(Kestenbaum, 1995)。
下面將依序地介紹Java，首先是Java的發展歷史與Java語言介紹，其次依序是Java Applet和HotJava的簡單介紹。
二、Java FAQ
下面以問答的方式來說明Java的發展歷史與其背景(下列內容整理自 Java FAQ list and Tutorial和The Java Language: A White Paper，讀者若欲深 入了解，請自行參閱原文)：
Java何時開始發展？(When)
最早大概可追溯至1991年四月份，Sun的綠色計劃(Green Project)開始著手於發展消費性電子產品(Consumer Electronics)，所使用的語言是C、C++、及Oak (為Java語 言的前身)，後因語言本身和市場的問題， 使得消費性電子產品的發展無法達到當初 預期的目標，再加上網路的興起， 綠色計劃也因此而改變發展的方向，這已是1994 年了。
為何稱之為Java？(Why) "Java"是美國SUN計算機公司Java發展小組歷經無數次的激烈討論之後才被選擇出。 生動(Liveliness)、動畫(Animation)、速度(Speed)、交互性(Interactivity)為當 初選擇名字時所欲表達出的特色。"Java"是在無數的建議中脫穎而出的，而"Java" 不是由幾個單字的首字所組成， 而是從許多程序設計師鍾愛的熱騰騰、香濃咖啡中 產生靈感的。
誰開發了Java？(Who) Java是美國SUN計算機公司Java發展小組開發的，早期的成員(綠色工程)是Patrick Naughton, James Gosling, & Mike Sheridan，而現在大家較為熟悉的成員是James Gosling。
在那裡開發了Java？(Where)
也就是問Java的出生地？答案是美國。
如何可以找到所需的Java信息？(How to)
在網路上，您可以連到Sun公司的Java WWW網站，URL是http://java.sun.com/，或是 http://www.javasoft.com/。在那裡幾乎可以找到您所需要的所有Java信息，但是語 言多少是一個障礙， 至少對某些人而言；沒關系，目前國內已有很多個網站提供中文 Java信息。在清華和中科院的FTP站點上有不少有關資料。想像以後應會有更多的站點提供相關信息。
如何才能看到Java的效果？(How Do I)
首先您需要有含有Java解釋器的瀏覽器(Browser)，例如：Netscpae公司的Netscape Navigator 2.0以上或是Sun公司的HotJava瀏覽器，對個人計算機使用者而言，操作 系統需是Windows 95或是Windows NT。
Java是因為撰寫C++語言程序時的困難而研製開的，起先，只是一個消費性電子產品 大計劃中的一部份，C++語言是當初被考慮採用的，但從一開始的編譯問題一直到最 後的一連串問題迫使得放棄C++語言，而有Java語言的產生。Sun是要Java成為一個簡 單(Simple)、面向對象的(Object Oriented)、 分布式的(Distributed)、解釋的(Interpreted)、健壯的(Robust)、安全的(Secure)、 結構中立的(Architecture Neutral)、可移植的(Portable)、高效能的(High Performance)、多線程的(Multithreaded)、動態的(Dynamic)的程序語言(摘譯自 TheJava Language: A White Paper, 1995)。
在Sun的Java語言白皮書中明白地說明上述Java語言的技巧。若以木工為比喻，一個面 向對象的木工，他(她)最主要的重點是即將要做的木椅子，其次才是所需要的工具； 反之；一個以非面向對象的木工，他(她)所關心的只是工具。最近的即插即用(Plug and Play)亦是面向對象設計的重點。 分布式的(Distributed)：Java有一個很周全的程薪錄JAVA介紹 。
一、
『Java』從1995年的暑假開始在計算機業界就受到了高度注意，特別是在Internet和 多媒體(Multimedia)相關產品類方面。Java為何有如此這么大的魅力？人作如此的比喻： Java在全球資訊網(World Wide Web, WWW)地位就如同電子表格(Spreadsheet)與個人計 算機TTP和FTP等TCP/IP通訊協定相配合。Java應用程序(Applications) 能在網路上開啟及連結使用物件，就如同透過URLs連結使用一個本地文件系統(Local File System)。 健壯的(Robust)：由Java所編寫出的程序能在多種情況下執行而具有其穩定性。Java與 C/C++最大不同點是Java有一個指針模型(Pointer Model)來排除內存被覆蓋(Overwriting Memory)和毀損數據(Corrupting Data)的可能性。
安全的(Secure)：Java是被設計用於網路及分布式的環境中，安全性自必是一個很 重要的考慮。Java擁有數個階層的互鎖(Interlocking)保護措施，能有效地防止病 毒的侵入和破壞行為的發生。
結構中立的(Architecture Neutral)：一般而言，網路是由很多不同機型的機器所 組合而成的，CPU和作業系統體系結構均有所不同；因此，如何使一個應用程序可以 在每一種機器上執行，是一個難題。所幸，Java的編譯器產生一種結構中立的目標 文件格式(Object File Format)；這使得編解碼得以在很多種處理器中執行。
可移植的(Portable)：原始資料型式的大小是被指定的，例如"float"一直是表示一 個32位元IEEE 754浮點運算數字，因絕大多數的CPU都具有此共同特徵。程序庫屬於 系統的一部份，它定義了一些可移植的程序介面，Java本身具備有很好的可移植性。
解釋的(Interpreted)：Java解釋器能直接地在任何機器上執行Java位元碼(Bytecodes)， 因此在進行程序連結時，時間的節省，這對於縮短程序的開發過程，有極大的幫助。
高效能的(High Performance)：Java位元碼迅速地能被轉換成機器碼(Machine Code)， 從位元碼轉換到機器碼的效能幾乎與C與C++沒有分別。
多線程的(Multi threaded)：Java語言具有多線程的功能，這對於交互回應能力及 即時執行行為是有幫助的。
動態的(Dynamic)：Java比C或C++語言更具有動態性，更能適應時刻在變的環境， Java不會因程序庫的更新，而必須重新編譯程序。
此外，Hank Shiffman (Making Sense of Java)亦針一般對Java的錯誤看法及觀 念提出他的說明，特在此摘譯如下：
"Java是一種編寫Web Pages的一種語言，就如同HTML和VRML一樣" 事實上，Java並不像是HTML此一類的描述語言(Description Language)，而是一種 編程語言(Programming Language)。描述語言標明內容和位置，而編程語言描述一 種產生結果的過程。
2. "Java語言容易學習和使用，不像C、C++和其它程序語言"
Java是一種編程語言。Java容易學嗎？Java或許是比C或C++容易學，但仍是一種編程語言，而不是一種描述語言。
3. "Java碼是可移植的，但C及C++不是"
Java原代碼(Source Code)是比C語言來得可移植一點，差別在於Java的目標碼。 Java碼在一種機器上進行編譯，而能在所有的機器上執行， 只要那部機器上有 Java解釋器。
4. "Java能被拓展而在機器上執行任何事情"
理論上，Java Applet (Java小應用程序)能做任何事情，如模擬3D VRML模型、播放電影、產生音頻....等。但事實上，一個小應用程序(Applet)僅能在那一頁上被執行，而無法在那一頁之外執行。同時，Java亦受限於程序庫的功能。
5. "Java是適合於建立大型的應用程序"
如果Java適合於大型程序，則Java就不適合應用於Web瀏覽器了。第一個商業 性的Java Applets (Applix's Java-Based Spreadsheet) 並不是全然使用Java， 它只使用Java作為用戶介面，而所有的處理工作， 是用CGI碼。
6. "Java是解釋執行的，Basic是解釋執行的，因此Java=Basic"
雖然Java的確是使用解釋器，但事實上，Java則與C或C++等完全編譯語言較為相近，但與Basic或APL等完全解譯語言較不相近。
7. "Java刪除了CGI命令稿(Scripts)和程序的需求"
Java Applets將會取代部份CGI的用途。在有些情況，Java Applets能夠取代一些伺服器端代碼(Server-Side Code)，但大多數的情況，基於安全性理由或是效 能的考慮，Java仍無法全然取代CGI Scripts。
8. "Netscape's JavaScript是與Java有相關"
除了名稱之外，Java和JavaScript是有一點點相關。JavaScript是一種命令稿語 言，是可以在HTML頁中使用。Java碼並未出現在HTML中，而在HTML中通過一個鏈 結來鏈結編解碼組。Java和JavaScript之間的關系就如同C語言和C Shell一般。
7. c語言編程
//計劃做的腳本引擎的一部分
//參考的 C++編程藝術
//總地來說會有一些難度
//我的是C++應該會給你一些啟發
//TypeDef.h
#include "windows.h"
#ifndef B_TYPE_DEF_H
#define B_TYPE_DEF_H
const int MAX_T_LEN = 128;//可以分析的最大符號長度(同時決定了一個字元變數的最大長度為128位元組)
const int MAX_ID_LEN = 31;//允許的最大的標識長度(一個標識符是指一個變數名或函數名)
const int MAX_BUF_LEN = 1024;//解釋緩沖區1024位元組
const int NUM_PARAMS = 32;//最大參數數目
const int MAX_DIM_NUM = 65536//數組最大維數
//需要分析的所有東西
enum Token_Item { UNDEF=1, //未定義
E_TEMP,//當模板使用
E_CHAR,//char關鍵字
E_INT,//int關鍵字
E_FLOAT,//float關鍵字
E_SWITCH,//switch關鍵字
E_CASE,//case關鍵字
E_IF,//if關鍵字
E_ELSE,//else關鍵字
E_FOR,//for關鍵字
E_DO,//do關鍵字
E_WHILE,//while關鍵字
E_BREAK,//break關鍵字
E_RETURN,//return關鍵字
E_COUT,//cout關鍵字
E_CIN,//cin關鍵字
LBLOCK, //{
RBLOCK,//}
DOU,//,
EOS,//;
MAO,//:
SFEN,//'已舍棄,不含'分析
LT,//<
LE,//<=
GT,//>
GE,//>=
EQ,//==
NE,//!=
FF,//.
LK,//(
NOT,//!
INC,//++
DEC,//--
ADD,//+
SUB,//-
RK,//)
LZK,//[
RZK,//]
LS,//<<
RS,//>>
ASS,//=
AND,//&&
OR,//||
MUL,//*
DIV,///
MOD,//%
POW,//^
NUMBER, //數字
IDENTIFIER,//標識
STRING,//字元串
END//文件結束
};//需要分析的全部符號
enum Token_Type{
UNK,//未知類型
KEY,//關鍵字
FJF,//分界符
CMP,//比較運算符
OPE,//運算符
NUM,//數字
IDE,//標識符
STR,//字元串
NON,//結束符號
UDF//未定義
};
typedef struct Token_Table{//符號表
char name[MAX_T_LEN];
Token_Item token;
Token_Type type;
} TOKEN_TABLE,*PTOKEN_TABLE;
enum error_msg //錯誤類型
{ SYNTAX=1000, NO_EXP, NOT_VAR, DUP_VAR, DUP_FUNC,
SEMI_EXPECTED, UNBAL_BRACES, FUNC_UNDEF,
TYPE_EXPECTED, RET_NOCALL, PAREN_EXPECTED,
WHILE_EXPECTED, QUOTE_EXPECTED, DIV_BY_ZERO,
BRACE_EXPECTED, COLON_EXPECTED,FAIL_OPEN,ERROR_SIZE,
NO_MAIN,ERROR_ASSIGN,ERROR_RZK,ERROR_DIM};
class InterpExc { //錯誤類
error_msg err;
public:
InterpExc(error_msg e) { err = e; }
error_msg get_err() { return err; }
};
enum Vars{類型
V_Int,
V_Float,
V_String,
V_pInt,
V_pFloat,
V_pString,
V_Udef
};
#endif
#ifndef V_NULL
#define V_NULL (-1)
#endif
//Cfenxi.h
#include "TypeDef.h"
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <string>
using namespace std;
//Fenxi類說明
//curr_pt始終指向將要分析的地址
//prev_pt為前一個分析的地址
//可以使用函數GotoPt來改變當前分析地址
//分析結果放在變數stoken,item,type
//在Cfenxi.cpp中定義了一個文件級變數TOKEN_TABLE tokentable[];
//在使用的時候必須聲明這個變數
#ifndef B_CFENXI_H
#define B_CFENXI_H
class Fenxi{
public:
char stoken[MAX_T_LEN+1];//分析出來的符號名
char buff[MAX_BUF_LEN+1];//緩沖區
Token_Item item;//分析出來的具體符號
Token_Type type;//符號大類
long curr_pt;//當前分析點
long prev_pt;//前一個分析點
char pFileName[256];//腳本文件名
PTOKEN_TABLE pTokenTable;//符號表
public:
Fenxi(){};
~Fenxi(){};
void Create(char*,PTOKEN_TABLE,int);//創建分析對象
void GetToken();//分析一步
void GotoPt(long);//跳分析點
void PutBack();//回退一個分析點
private:
int nTableItem;//分析表中的分析數目
long iFileLength;//腳本文件長度
int iBlock;//當前所在區塊
int iYouBiao;//當前游標
char cbuff;//當前所指向的字元
char cbuff1;//超前搜索的字元
void MoveNext();//向下移動
void MovePrev();//向前移動
void LoadBlock();//裝入一個塊
long GetPt(int i,int n){return (long)(i*MAX_BUF_LEN+n);};//計算位置
bool KeyLookUp(char*,Token_Item &);//查找是不是關鍵詞
bool isdelim(char);
};
//解釋類
class var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
Vars v_type;
public:
var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
v_type=Udef;
}
var_value(const var_value&);
set_type(Vars type){v_type=type;}
~var_value(){}
friend bool operator == (const var_value& _X, const var_value& _Y);
friend bool operator < (const var_value& _X, const var_value& _Y);
};
class temp_var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
int p_int;
int p_float;
int p_string;
vector<int> dim;
Vars v_type;
public:
temp_var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
p_int=p_float=p_string=V_NULL;
v_type=Udef;
};
temp_var_value(const temp_var_value&);
temp_set_type(Vars type){v_type=type;}
~temp_var_value(){}
friend bool operator == (const temp_var_value& _X, const temp_var_value& _Y);
friend bool operator < (const temp_var_value& _X, const temp_var_value& _Y);
};
struct var_type { //變數類型
char var_name[MAX_ID_LEN+1]; // 變數名
Vars v_type;//數據類型
vector<var_value> value; //變數值
vector<int> v_dim;//變數維數
int v_max;//變數的最大數目
};
struct func_type {
char func_name[MAX_ID_LEN+1]; //函數名
Vars ret_type; //返回值類型
long loc; // 函數入口點,函數的入口點是指分析點指向函數括弧後第一個字元
};
class Script{
public:
Fenxi theFx;//詞法分析對象,負責對腳本文件的操作
char FileName[256];//腳本文件名
var_value ret_value;//返回值
bool breakfound;//中斷
public:
Script(){};
~Script(){};
void Create(char*,PTOKEN_TABLE,int);//創建腳本對象
void ExecuteScript();//開始解釋腳本
private:
void PreScan();//預掃描
void decl_global();//聲明全局變數
long find_func(char*);//返回函數的入口點
void ItemToVar(Token_Item,Vars&);//根據一個項,得到相當的變數類型
void CallFun();//執行一個函數
void get_args();//得到函數的形式參數名
void Interp();//具體解釋
private:
void eval_exp (var_value &value);
void eval_exp0(var_value &value);
void eval_exp1(var_value &value);
void eval_exp2(var_value &value);
void eval_exp3(var_value &value);
void eval_exp4(var_value &value);
void eval_exp5(var_value &value);
void eval_exp6(var_value &value);
void eval_exp7(var_value &value);
void eval_exp8(var_value &value);
bool is_var(char *s);
// 變數名,變數的維數,變數的值,變數的類型
void assign_var(char *var_name,int idx, var_value value);
void find_var_value(char *var_name,int idx,var_value& value);
int find_idx(vector<int>,vector<int>);// 計算[][]
void find_vector(vector<int> &);//讀取[]
int cal_idx(vector<int>);
Vars is_var_type;//使用is_var的時候如果返回值是真那麼這個變數存儲了變數類型
public:
//每執行一個函數的時候就把進入前的局部變數數目
//放到函數結點棧,函數執行完的時候就根據棧里的
//數據改變局部函數表裡的變數,從而實現變數的靈活使用
//同理塊結點棧的原理也一樣
//變數表
vector<var_type> global_vars; //全局變數表
vector<var_type> local_var_stack; //局部變數表(函數參數作為局部變數處理)
vector<func_type> func_table; //函數表
stack<int> func_call_stack;//函數結點棧
stack<int> nest_scope_stack;//塊結點棧
};
#endif
//Fenxi.cpp
#include "CFenxi.h"
#include <cstring>
#include <cctype>
#include <fstream>
#include <cstdio>
#include <cmath>
using namespace std;
///////////////////////////////////////////////////////////////////////
/////////////////////////詞法分析類的函數定義//////////////////////////
///////////////////////////////////////////////////////////////////////
extern TOKEN_TABLE tokentable[]={
"char",E_CHAR,KEY,
"int",E_INT,KEY,
"float",E_FLOAT,KEY,
"switch",E_SWITCH,KEY,
"case",E_CASE,KEY,
"if",E_IF,KEY,
"else",E_ELSE,KEY,
"for",E_FOR,KEY,
"do",E_DO,KEY,
"while",E_WHILE,KEY,
"break",E_BREAK,KEY,
"return",E_RETURN,KEY,
"cout",E_COUT,KEY,
"cin",E_CIN,KEY,
"{",LBLOCK,FJF,
"}",RBLOCK,FJF,
",",DOU,FJF,
";",EOS,FJF,
"<",LT,CMP,
"<=",LE,CMP,
">",GT,CMP,
">=",GE,CMP,
"==",EQ,CMP,
"!=",NE,CMP,
".",FF,OPE,
"(",LK,OPE,
")",RK,OPE,
"[",LZK,OPE,
"]",RZK,OPE,
"++",INC,OPE,
"--",DEC,OPE,
"<<",LS,OPE,
">>",RS,OPE,
"=",ASS,OPE,
"!",NOT,OPE,
"&&",AND,OPE,
"||",OR,OPE,
"+",ADD,OPE,
"-",SUB,OPE,
"*",MUL,OPE,
"/",DIV,OPE,
"%",MOD,OPE,
"^",POW,OPE,
};
var_value::var_value(const var_value& p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
v_type=p.v_type;
}
bool operator == (const var_value& _X, const var_value& _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (abs(_X.float_value - _Y.float_value) < 0.0001);
break;
case V_Int:
return (_X.int_value == _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}
}
bool operator < (const var_value& _X, const var_value& _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (_X.float_value < _Y.float_value);
break;
case V_Int:
return (_X.int_value < _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}
temp_var_value::temp_var_value(const temp_var_value& p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
p_int=p.p_int;
p_float=p.p_float;
p_string=p.p_string;
v_type=p.v_type;
}
void Fenxi::Create(char* p,PTOKEN_TABLE ptt,int n)
{
strcpy(pFileName,p);
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(0,ios::end);
iFileLength=fin.tellg();
fin.close();
if(iFileLength==0)
throw InterpExc(ERROR_SIZE);
iBlock=0;
LoadBlock();
MoveNext();//指向第一個字元
iYouBiao=0;//置游標於文件頭
curr_pt=0;
prev_pt=0;
cbuff=buff[0];//當前應該分析字元
cbuff1=buff[1];//超前搜索字元
pTokenTable=ptt;
nTableItem=n;//分析表設置
}
void Fenxi::MoveNext()
{
if(iYouBiao==MAX_BUF_LEN-1)//如果當前游標在緩沖區尾
{
iBlock++;
LoadBlock();
cbuff=buff[0];
cbuff1=buff[1];//超前搜索
}
else
{
iYouBiao++;
cbuff=buff[iYouBiao];
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}
curr_pt=GetPt(iBlock,iYouBiao);
}
void Fenxi::MovePrev()
{
if(iYouBiao==0)//如果當前游標在緩沖區頭
{
cbuff1=cbuff;//超前搜索
iBlock--;
LoadBlock();
iYouBiao=MAX_BUF_LEN-1;
cbuff=buff[iYouBiao];
}
else
{
cbuff1=cbuff;//超前搜索
iYouBiao--;
cbuff=buff[iYouBiao];
}
curr_pt=GetPt(iBlock,iYouBiao);
}
void Fenxi::PutBack()
{
GotoPt(prev_pt);
}
void Fenxi::LoadBlock()//裝入一個塊
{
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*iBlock);
fin.read(buff,MAX_BUF_LEN);
int i=fin.gcount();
buff[i]=0;
iYouBiao=0;
fin.close();
}
void Fenxi::GotoPt(long pt)
{
if(pt/MAX_BUF_LEN==curr_pt/MAX_BUF_LEN)//如果是在同一個塊內的話
{
curr_pt=pt;
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}
else//否則要重新裝入內存
{
curr_pt=pt;
iBlock=curr_pt/MAX_BUF_LEN;
LoadBlock();
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}
void Fenxi::GetToken()
{
prev_pt=curr_pt;//保存前一個的位置
char *temp; //利用一個指針向字元里寫內容
item=UNDEF;type=UDF;
temp = stoken;
*temp = '\0';
// 如果當前字元是空格且未到文件末
while(isspace(cbuff) && cbuff) MoveNext();
// 跳過行
while(cbuff == '\r') {
MoveNext();
MoveNext();
while(isspace(cbuff) && cbuff) MoveNext();
}
// 是否結尾
if(cbuff == '\0') {
*stoken = '\0';
item = END;
type=NON;
return ;
}
// 檢查{}標識符
if(strchr("{}", cbuff)) {
stoken[0]=cbuff;
stoken[1]='\0';
type=FJF;
if(cbuff=='{')
item=LBLOCK;
else
item=RBLOCK;
MoveNext();//指向下一個字元
return ;
}
// 檢查注釋信息
if(cbuff == '/')
if(cbuff1 == '*') { // /*注釋符
MoveNext();
MoveNext();
do { // 找到結尾
while(cbuff != '*') MoveNext();
MoveNext();
} while (cbuff != '/');
MoveNext();
GetToken();
return;
} else if(cbuff1 == '/') { // is a // CMPment
MoveNext();
MoveNext();
// Find end of CMPment.
while(cbuff != '\r' && cbuff != '\0') MoveNext();
if(cbuff == '\r') {MoveNext();MoveNext();}
GetToken();
return;
}
// 檢查雙操作符
if(strchr("!<>=+-&|", cbuff)) {
switch(cbuff) {
case '|':
if(cbuff1 == '|') {
MoveNext();MoveNext();
*temp = '|';
temp++;
*temp = '|';
temp++;
*temp = '\0';
item=OR;
type=OPE;
}
break;
case '&':
if(cbuff1 == '&') {
MoveNext();MoveNext();
*temp = '&';
temp++;
*temp = '&';
temp++;
*temp = '\0';
item=AND;
type=OPE;
}
break;
case '=':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '=';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=EQ;
type=CMP;
}
break;
case '!':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '!';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=NE;
type=CMP;
}
break;
case '<':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '<';
temp++;
*temp = '=';
item=LE;
type=CMP;
}
else if(cbuff1 == '<') {
MoveNext();MoveNext();
*temp = '<';
temp++;
*temp = '<';
item=LS;
type=OPE;
}
else {
MoveNext();
*temp = '<';
item=LT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '>':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '>';
temp++;
*temp = '=';
item=GE;
type=CMP;
} else if(cbuff1 == '>') {
MoveNext();MoveNext();
*temp = '>';
temp++;
*temp = '>';
item=RS;
type=OPE;
}
else {
MoveNext();
*temp = '>';
item=GT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '+':
if(cbuff1 == '+') {
MoveNext();MoveNext();
*temp = '+';
temp++;
*temp = '+';
temp++;
*temp = '\0';
item=INC;
type=OPE;
}
break;
case '-':
if(cbuff1 == '-') {
MoveNext();MoveNext();
*temp = '-';
temp++;
*temp = '-';
temp++;
*temp = '\0';
item=DEC;
type=OPE;
}
break;
}
if(*stoken) return;
}
// 其它運算符號
if(strchr("+-*^/=().[]|!%", cbuff)) {
type=OPE;
switch(cbuff){
case '+':
item=ADD;break;
case '-':
item=SUB;break;
case '*':
item=MUL;break;
case '/':
item=DIV;break;
case '=':
item=ASS;break;
case '(':
item=LK;break;
case ')':
item=RK;break;
case '[':
item=LZK;break;
case ']':
item=RZK;break;
case '.':
item=FF;break;
case '|':
item=UNDEF;type=UDF;break;
case '!':
item=NOT;break;
case '%':
item=MOD;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}
// 分界符號
if(strchr(";,#:", cbuff)) {
type=FJF;
switch(cbuff){
case ';':
item=EOS;break;
case ',':
item=DOU;break;
case ':':
item=MAO;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}
// 讀取一個字元串
if(cbuff == '"') {
MoveNext();
while(cbuff != '"' && cbuff != '\r' && cbuff) {
// Check for \n escape sequence.
if(cbuff == '\\') {
if(cbuff1 == 'n') {
MoveNext();
*temp++ = '\n';
}
}
else if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
if(cbuff == '\r' || cbuff == 0)
throw InterpExc(SYNTAX);
MoveNext(); *temp = '\0';
item=STRING;
type=STR;
return ;
}
// 讀取一個數字
if(isdigit(cbuff)) {
while((cbuff>='0'&&cbuff<='9')||(cbuff=='.')) {
if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
*temp = '\0';
item=NUMBER;
type=NUM;
return ;
}
// Read identifier or keyword.
if(isalpha(cbuff)) {
while(!isdelim(cbuff)) {
if((temp - stoken) < MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
item=E_TEMP;
}
*temp = '\0';
// Determine if token is a keyword or identifier.
if(item == E_TEMP) { // convert to internal form
if(KeyLookUp(stoken,item)) type=KEY; // is a keyword
else {type = IDE;item=IDENTIFIER;}
}
if(type==UDF)
throw InterpExc(SYNTAX);
}
bool Fenxi::KeyLookUp(char *s,Token_Item &it){
int i;
// char *p;
// 轉為小寫字母
// p = s;
// while(*p) { *p = tolower(*p); p++; }
for(i=0; i<nTableItem; i++) {
if((tokentable[i].type==KEY)&&!strcmp(tokentable[i].name, s))
{
it=tokentable[i].token;
return true;
}
}
return false;
}
// 符號檢查
bool Fenxi::isdelim(char c)
{
if(strchr(" !:;,+-<>/*^=().|&[]\"%", c) || c == 9 ||
c == '\r' || c == 0) return true;
return false;
}
8. C語言中 false是不是關鍵字或函數
C語言中 false不是關鍵字也不是函數,但是在c++中false 是關鍵字。
在計算機語言中，false表示常數0. 一個表示與 true 相反的唯一布爾值。true表示"1",false表示"0".當自動數據類型指定將 false 轉換為數字時，它變為0；將 false 轉換為字元串時，它變為 "false" 。
關鍵字(keyword)又稱保留字，是整個語言范圍內預先保留的標識符。每個C++關鍵字都有特殊的含義。經過預處理後，關鍵字從預處理記號(preprocessing-token)中區出來，剩下的標識符作為記號(token)，用於聲明對象、函數、類型、命名空間等。不能聲明與關鍵字同名的標識符。
C語言關鍵字有：由ANSI標準定義的共32個 :
auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if while static
C++關鍵字有：
ISO C++98/03關鍵字共63個，此處嚴格按標准原文排版：
asm do if return typedef auto double inline short typeid bool dynamic_cast int signed typename break else long sizeof union case enum mutable static unsigned catch explicit namespace static_cast using char export new struct virtual class extern operator switch void const false private template volatile const_cast float protected this wchar_t continue for public throw while default friend register true delete goto reinterpret_cast try
9. C語言如何從數組中刪除一個指定元素
在JAVA中如何從數組中刪除一個元素的程序如下：
package org.usc.action;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Test {
public static void main(String[] args) {
String[] str={"張三","李四","王五","宋六","趙七","朱八","何九","田十"};
List<String> list=Arrays.asList(str);//將數組轉換為list集合
if(list.contains("張三"))
{//加入集合中包含這個元素
///這個時候我們直接移除會報錯，所以我們要轉換為Arraylist
//list.remove("張三");
List<String> arrayList=new ArrayList<String>(list);//轉換為ArrayLsit調用相關的remove方法
arrayList.remove("張三");
for(String str1:arrayList ){
System.out.print(str1+",");}
}}
部分解釋：
1、remove這些method時出現java.lang.UnsupportedOperationException異常。
2、這是由於Arrays.asList() 返回java.util.Arrays$ArrayList， 而不是ArrayList。Arrays$ArrayList和ArrayList都是繼承AbstractList， remove，add等method在AbstractList中是默認throw UnsupportedOperationException而且不作任何操作。
3、ArrayList override這些method來對list進行操作，但是Arrays$ArrayList沒有override remove()，add()等， 所以throw UnsupportedOperationException。
(9)c語言throw擴展閱讀：
因為Java沒有結構，數組和串都是對象，所以不需要指針。Java能夠自動處理對象的引用和間接引用，實現自動的無用單元收集。
Java允許擴展編譯時檢查潛在類型不匹配問題的功能。Java要求顯式的方法聲明，它不支持C風格的隱式聲明。
異常處理是Java中使得程序更穩健的另一個特徵。異常是某種類似於錯誤的異常條件出現的信號。使用try/catch/finally語句，程序員可以找到出錯的處理代碼，這就簡化了出錯處理和恢復的任務。
10. C語言 演算法訓練 Lift and Throw 求答案帶詳細註解
#include<stdio.h>
#include<string.h>
#defineTRUE1
#defineFALSE0
#definemax(a,b)a>b?a:b
//定義數組大小為4，從一開始，空出下標為0，方便計算
intx[4];//三個人的位置
intl[4];//三個人的機動性（可移動距離）
intt[4];//三個人的拋的距離
intans=0;//經過操作後的最遠距離，初始化為0
intw[4];//初始化為0，0表示可以進行操作，非零表示不可以
intp[4];//初始化為0，表示a[i]所舉起的人
inta[4]={3,3,3,3};//初始化為3，表人的狀態，這里a對應的二進制為0011，後三位分別是三個動作：拋出，舉起，移動。0（無意義）0（不可拋出）1（未進行舉起）1（未進行移動）。這道題中，a只有六個可能值：0(0000)、1(0001)、2(0010)、3(0011)、4(0100)、5(0101)，表示人的六種狀態
//bool類型
intnear(ints)
{
inti=1;
for(;i<=3;i++)
{
if(s==x[i]+1||s==x[i]-1)
{
returnTRUE;
}
}
returnFALSE;
}
//dfs深度遍歷
voiddfs(intd)
{
inti=1,j=1,e=0;
//每次都取最遠（大）的位置
for(;i<=3;i++)
{
ans=max(ans,x[i]);
}
for(i=1;i<=3;i++)
{
//是否可以進行操作
if(w[i])
{
continue;
}
//a[i]==1||a[i]==3（未進行移動且不可拋出）
if((a[i]&1)&&!(a[i]&4))
{
for(j=1;j<=l[i];j++)//移動
{
x[i]+=j;//a[i]向前移動j
a[i]^=1;//已移動
if(near(x[i])||j==l[i])//如果a[i]移動後的位置旁邊有人或者移動距離達到上限
{
dfs(d+1);
}
x[i]-=j;//歸位
x[i]-=j;//a[i]向後移動j
if(near(x[i])||j==l[i])//如果a[i]移動後的位置旁邊有人或者移動距離達到上限
{
dfs(d+1);
}
x[i]+=j;//歸位
a[i]^=1;//還原為未移動
}
}
//a[i]==2||a[i]==3||a[i]==5（未進行舉起）
if(a[i]&2)
{
for(j=1;j<=3;j++)//舉起
{
if(i!=j&&!w[j]&&t[i]>0)//是否可以進行操作
{
if(x[i]==x[j]+1||x[j]==x[i]+1)//a[i]附近是否有人
{
w[j]=1;//即將舉起（拋出）j，拋出前將j是否可操作標記變更為否
a[i]^=2;//已舉起
a[i]^=4;//可拋出
p[i]=j;//記錄a[i]舉起（拋出）了j
e=x[j];//記錄a[j]的舉起前位置
x[j]=-j;//a[j]（被舉起）的位置定為負數，只作用於下一層遞歸時的取最遠位置的循環
dfs(d+1);
x[j]=e;//歸位
w[j]=0;//還原為可以進行操作
a[i]^=2;//還原為未舉起
a[i]^=4;//還原為不可拋出
}
}
}
}
//a[i]==4||a[i]==5（可拋出）
if(a[i]&4)
{
for(j=1;j<=t[i];j++)//拋出
{
w[p[i]]=0;//變更a[j]為可操作（以下a[j]指a[i]所舉起的人）
a[i]^=4;//不可拋出
e=x[p[i]];//記錄a[j]被舉起前位置
x[p[i]]=x[i]+j;//拋出a[j]，並更新a[j]位置
if(near(x[p[i]])||j==t[i])//如果a[j]被拋出後的位置旁邊有人或者拋出距離達到上限
{
dfs(d+1);
}
x[p[i]]-=j;//歸位
x[p[i]]-=j;//a[j]向後拋出j
if(near(x[p[i]])||j==t[i])//如果a[j]被拋出後的位置旁邊有人或者拋出距離達到上限
{
dfs(d+1);
}
x[p[i]]=e;//還原a[j]為未舉起前的位置
a[i]^=4;//還原a[j]為可拋出
w[p[i]]=1;//還原a[j]為不可操作
}
}
}
return;
}
intmain()
{
inti=1;
//鍵入每個人的信息
for(;i<=3;i++)
{
scanf("%d%d%d",&x[i],&l[i],&t[i]);
}
//深度優先遍歷
dfs(1);
//輸出最遠距離
printf("%d ",ans);
return0;
}