sally0909/Llama3_Dataset huggingface dataset:
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 問109：靜態陣列和動態陣列有何差異？指出其優缺點。  答109：靜態陣列和動態陣列的差別在於記憶體的使用狀況，動態陣列在程式尚未執行到有關該陣列的宣告之前不會配置任何記憶體給該陣列，當程式執行到宣告陣列時，才會要求系統配置記憶體空間給動態陣列使用。而靜態陣列則是程式在載入到記憶體時，同時也要求配置記憶體空間給靜態陣列使用。靜態陣列的優點是找查記憶體十分快速，缺點是對於拓展空間、插入資料很浪費資源，需要移動大量資料。動態陣列的優點是可以動態的新增和刪除元素、可以動態的改變陣列的容量，缺點是當需要插入或刪除元素時，可能需要重新分配記憶體並移動其他元素，以便保持連續的記憶體空間且插入或刪除元素的成本較高，尤其是在陣列的開頭或中間位置。
評論: Good!
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 遞迴的層數過高,可能會導致記憶體區段錯誤,由於記憶體堆疊的空間限制所導致,，每個函式的執行環境都需要佔用一定的記憶體空間，這樣堆疊的空間很快就會耗盡。疊空間耗盡時,會導致記憶體區段錯誤
評論: OK
題目: 作業二採用什麼資料結構儲存讀入資料，須說明原因。
答案: 107. 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？  可以在遞迴函式中用下列簡化的範例完成:  void recursiveFunction(int step) {     try {         // 可能引发异常的代码         throw MyException( error message );  // 抛出异常对象          recursiveFunction(step + 1);     } catch (const MyException& e) {         // 捕获并处理异常         std::cerr <<  捕获到异常：  << e.what() << std::endl;          recursiveFunction(step + 1);     } catch (const std::exception& e) {         // 捕获并处理其他类型的异常         std::cerr <<  捕获到异常：  << e.what() << std::endl;          recursiveFunction(step + 1);     } catch (...) {         // 捕获并处理所有其他类型的异常         std::cerr <<  捕获到未知异常  << std::endl;          recursiveFunction(step + 1);     } }    若在某層捕捉到錯誤，也能通過此類處理異常的語法直接進到下一次遞迴。
評論: 假設遞迴到100層就出現異常，在第99層異常處理後再次進入遞迴，還是會出現異常吧？如何進入第100層繼續執行？
題目: 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？
答案: 方法一:在宣告時直接賦值  int main() {     int arr[5] = {1, 2, 3, 4, 5};  // 使用初始化列表为数组元素设置初始值      // 输出数组元素     for (int i = 0; i < 5; i++) {         cout << arr[i] <<    ;     //輸出賦值結果     }     cout << endl;      return 0; }    其他方法主要是先宣告再用迴圈等方式進行初始值的賦予
評論: 如果不是有規則性的初始值呢？
題目: 作業二靜態陣列和動態陣列有何差異？指出其優缺點。
答案: 問題 : 寫出C++程式碼說明傳值呼叫call by value。  答案 :   #include <iostream>  using namespace std;  // 函式定義，接收一個整數參數 void increment(int num) {     num++; // 將參數增加 1     std::cout <<  Inside the function:   << num << std::endl; }  int main() {     int number = 5;      std::cout <<  Before calling the function:   << number << std::endl;     increment(number); // 傳值呼叫函式     std::cout <<  After calling the function:   << number << std::endl;      return 0; }  在上述程式碼中，我們定義了一個 increment 函式，該函式接收一個整數參數 num。在 increment 函式內部，我們將 num 的值增加 1，並輸出結果。  根據傳值呼叫的方式，increment 函式中的參數 num 是 number 的複製。因此，函式內部對 num 的修改不會影響到 number 的值。這也可以在輸出結果中觀察到：呼叫函式後，num的值變為6，而number 的值仍然是 5。  輸出結果在附件。
評論: 請勿使用附檔，圖片可以插入在本文中。
題目: 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？
答案: 108. 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。  幫陣列寫入非0初始值的方式，就是在設置變數時在變數的後方括號輸入需要的值。    Code:  int X[100]={};//基礎設定為0  int Y[100]={1,2,3, ... ,99,100};  或是利用迴圈定義  int X[100];  for(int i=0;i<100;i++)  {  x[i]=i+1;  }
評論: int Y[100]={1,2,3, ... ,99,100};  可以寫 ... ？
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 靜態陣列的大小在宣告中就被固定了，沒辦法改變。(固定了)  動態陣列則是可以在運行中進行動態調整。(可彈性)  靜態陣列會佔有較大的的記憶體空間不管你有沒有使用到。  動態陣列則會根據需要進行記憶體分配及釋放，只會占用到實際使用的記憶體。  靜態陣列的優點在於存取速度快，資源消耗少，不用額外的記憶體配置和釋放。缺點則是大小已經固定，會浪費記憶體空間可能無法容納所有資料。操作較容易  動態陣列的優點在於節省記憶體空間，比較彈性，缺點則是存取效能較低，操作較複雜，需要記憶體配置及釋放。
評論: 存取速度快慢的差異？須進一步解釋。
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109：靜態陣列和動態陣列有何差異？指出其優缺點。 動態陣列差別在記憶體使用狀況 程式還沒執行到有關陣列宣告時 不會配置任何記憶體而是等到執行後才分配給他 靜態陣列則是程式載入到記憶體同時也配置記憶體空間給他使用  靜態陣列的優點在於存取速度快，不用額外的記憶體配置和釋放。  缺點則是大小已經固定，會浪費記憶體空間。  動態陣列的優點在於節省記憶體空間，彈性度高需要多少配置多少即可  缺點則是存取效率較低，需要記憶體配置及釋放。
評論: 可以提出兩者的優缺點，像是效能之類的差異 動態陣列存取效率較低？
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109 靜態陣列和動態陣列有何差異？指出其優缺點。  靜態陣列的大小在創建已經固定，無法動態擴展或縮小，且連續的記憶體空間被分配給靜態陣列，且其大小不會在執行期間改變。  優點是:1.存取元素的速度快，因為它們在記憶體中佔用連續的空間。2,內存分配簡單且效率高。3.無需管理記憶體的動態分配和釋放。  缺點是:1.大小固定，無法調整。2.在創建時必須指定大小，如果容量過大，可能浪費內存，容量過小則無法儲存足夠的元素。  動態陣列的大小可以根據需要動態調整，具有彈性， 且動態陣列具有較小的容量，但可以隨著元素的添加而自動擴展容量。  優點是:1.具有彈性，可以動態擴展或縮小。2.可根據需要分配更多的內存，以容納更多的元素。3.可以有效地管理記憶體，避免內存的浪費。  缺點是:1.內存分配和重新分配可能需要額外的時間和空間。
評論: Good!
題目: 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？
答案: 108. 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。  本程式是使用迴圈來設定初始值  #include <iostream>  int main() {     int arr[5];  // 建立一個陣列     for (int i = 0; i < 5; i++) {         arr[i] = i + 1;     }      // 輸出陣列元素的值     for (int i = 0; i < 5; i++) {         std::cout << arr[i] <<    ;     }     std::cout << std::endl;      return 0; }
評論: arr[i] = i + 1; 如果不是有規則性的初始值呢？
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 106. 遞迴呼叫為何會造成記憶體區段錯誤？  當呼叫一個函式時，程式會將函式的資訊保存在堆疊（stack）中的一個區段稱為「呼叫框架」（call frame）。呼叫框架包含了呼叫函式所需的所有資訊。當函式完成執行時，它的呼叫框架會被移除。 當堆疊無法容納更多的呼叫框架時，即超過了堆疊的最大限制，就會發生堆疊溢位。這可能導致記憶體區段錯誤，因為程式試圖存取不存在的或被其他變數/資料覆寫的記憶體區域。這種情況可能導致程式崩潰或異常終止。
評論: Good!  Ref. https://en.wikipedia.org/wiki/Call_stack
題目: 作業二採用什麼資料結構儲存讀入資料，須說明原因。
答案: 107.若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？  在遞迴函式中使用條件判斷來檢查是否達到異常終止的條件，如果條件滿足，您可以在該情況下跳過異常終止，繼續執行到下一層。這可以使用 if 條件判斷和 return 陳述式來實現 。  想遞迴進入某層就是造成異常終止的原因，如何跳過異常還同時可以繼續執行到那一層？  可使用 try-catch 塊，在遞迴函式的適當位置使用 try-catch 塊，以捕獲異常。在 try 塊中放置可能引發異常的程式碼，並在 catch 塊中處理異常情況  function recursiveFunction(level) {   try {     // 可能引發異常的程式碼     if (level === 5) {       throw new Error('達到層級 5');     }      // 遞迴調用     recursiveFunction(level + 1);      // 在異常之後的程式碼     console.log('完成異常處理後的操作');   } catch (error) {     // 處理異常     console.log('捕獲到異常:', error.message);      // 可選：進行適當的異常處理操作      // 可選：選擇是否繼續執行到該層     console.log('繼續執行到該層');   } }  recursiveFunction(1);  try 塊中的程式碼可能引發異常。如果異常發生，catch 塊將捕獲到異常並處理它，然後繼續執行到該層的後續程式碼。
評論: 跳過異常終止  vs.  繼續執行到下一層  是對立矛盾的！  想遞迴進入某層就是造成異常終止的原因，如何跳過異常還同時可以繼續執行到那一層？
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 問106：遞迴呼叫為何會造成記憶體區段錯誤？  答106：堆疊溢位，如果遞迴呼叫的層數過多，堆疊可能會超出其容量限制，導致堆疊溢位。這種情況下，程式執行時會發生記憶體區段錯誤，通常會導致程式異常終止。資源耗盡，如果遞迴的次數太多或處理的資料量太大，程式可能耗盡系統可用的記憶體或運算資源，導致記憶體區段錯誤或程式執行速度極慢。
評論: 遞迴的次數太多或處理的資料量太大  這是二種不同的情況，其關係為何？   記憶體區段錯誤或程式執行速度極慢  這是二種不同的情況，題意是問前者，後者是如何發生的？
題目: 作業二採用什麼資料結構儲存讀入資料，須說明原因。
答案: 問107：若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？  答107：若在遞迴的某一層異常終止後，希望強制程式繼續執行到下一層，可以使用例外處理的機制來捕捉異常並進行處理。
評論: 例外處理的機制來捕捉異常   如何實作？   並進行處理   如何進行才可以繼續執行？
題目: 作業二靜態陣列和動態陣列有何差異？指出其優缺點。
答案: #include <iostream> using namespace std ; int sum( int a, int b ) {     a = 7 ;     return a + b ; }  int main() {    int a = 2 ;    int b = 3 ;    cout <<  a =   << a << endl ;    cout << sum( a, b ) << endl ;     cout <<  a =   << a << endl ; }  輸出    可以看到就算sum中更改a的值，執行function後a的值還是不變，因為call by value只傳值進去function  不會動到a記憶體位址裡面的東西
評論: 答問貼文的標題，請附上原本的問題敘述。
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 差別在於記憶體的使用狀況，『動態陣列』在程式尚未執行到有關該陣列的宣告之前，並不會配置任何記憶體給該陣列，當程式執行到宣告陣列時，才會要求系統配置記憶體空間給動態陣列使用。相對地，而『靜態陣列』則是程式在載入到記憶體時，同時也要求配置記憶體空間給靜態陣列使用。因此，動態陣列比較節省記憶體空間的使用率。  靜態陣列優點:使用一段連續的記憶體空間儲存，較節省空間；可以透過索引值對資料進行查詢、更改。  靜態陣列缺點:要一群相同類型的資料才能儲存；必須要明確規劃記憶體空間供資料儲存；刪除或加入資料時，需要移動大量的資料。  動態陣列優點:刪除、加入或合併資料時，只需改變指標。  動態陣列缺點:不可直接存取；不可使用二分法搜索；較量費記憶體空間
評論: 動態陣列也可以直接存取喔！  動態指的是配置時機，既然是陣列，當然也可以直接存取。可參閱程設練習三。
題目: 作業二靜態陣列和動態陣列有何差異？指出其優缺點。
答案: 110. 寫出C++程式碼說明傳值呼叫call by value。  當在 C++ 中使用傳值呼叫（call by value）時，函式的參數會接收實際參數的複本，而不是直接操作實際參數本身。  #include <iostream>  // 傳值呼叫的函式 void increment(int num) {     num++;  // 對傳入的參數進行增加操作 }  int main() {     int number = 10;      std::cout <<  原始數字：   << number << std::endl;      increment(number);  // 傳值呼叫      std::cout <<  呼叫函式後的數字：   << number << std::endl;      return 0; }
評論: You should add some words to explain how it impacts on the output.
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 106. 遞迴呼叫為何會造成記憶體區段錯誤？ 遞迴呼叫可以導致記憶體區段錯誤的原因通常是由於遞迴函式不斷地產生新的函式呼叫，而每次函式呼叫都需要在記憶體中分配一個新的堆疊框架，每當函式被呼叫時，相關的資料（如函式參數、區域變數等）都會被存儲在堆疊框架中。當函式執行完畢後，該函式的堆疊框架會被釋放，以便釋放相應的記憶體。  在遞迴函式中，每次函式呼叫都會導致一個新的堆疊框架被創建並存儲在堆疊中，而且這些堆疊框架的數量可能會非常大。如果遞迴的深度很大，就會在堆疊中產生大量的堆疊框架。  當堆疊空間用盡時，稱為stack overflow。這是因為每個程序都有一個固定大小的堆疊空間，當函式呼叫太多時，堆疊就會超出範圍，導致記憶體區段錯誤。
評論: OK
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 遞迴呼叫為何會造成記憶體區段錯誤?  像是無限遞迴(Infinite Recursion)，當沒有正確的終止條件或是遞迴停止條件不符合，遞迴函式將永遠遞迴下去，不斷地呼叫自己。這將消耗系統的記憶體和資源，最後導致記憶體區段錯誤。
評論: OK.  先細讀先前的貼文，避免太多重複的內容而未得分。
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 遞迴的程式呼叫超過了系統所分配的堆疊空間，導致stack overflow，也就是記憶體區段錯誤
評論: 什麼樣的情況會造成 超過了系統所分配的堆疊空間 ？
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 靜態陣列在宣告時需要指定固定的大小，且在程式運行期間大小不可更改，動態陣列的大小可以在運行時根據需要進行動態調整，大小不固定 靜態陣列優點:存取速度快 靜態陣列缺點:無法應對大小不確定，也可能浪費記憶體空間 動態陣列優點:大小彈性，可以有效利用記憶體，避免浪費 動態陣列缺點:存取速度較慢，需要動態分配和釋放記憶體，可能導致記憶體管理的開銷
評論: 動態陣列缺點:存取速度較慢  WHY?
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109. 靜態陣列和動態陣列有何差異？指出其優缺點。  靜態陣列的記憶體配置發生在堆疊上，通常具有較快的存取速度。相對簡單，不需要額外的記憶體管理或釋放。  缺點是在編譯時期就被確定，無法在執行時期動態改變，這可能限制了彈性和資源使用效率。  動態陣列的大小可以在執行時期動態調整，可以根據需要增加或減少元素的數量,可以根據需求動態分配記憶體，減少不必要的記憶體浪費  缺點是需要額外的記憶體管理操作，例如分配和釋放記憶體，這可能帶來一些開銷和複雜度。記憶體配置發生在堆積上，存取速度相對較慢。
評論: 試解釋為何會造成二者在存取速度的差異。
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109. 靜態陣列和動態陣列有何差異？指出其優缺點。  靜態陣列的優點是存取效能高，可以直接透過索引存取元素，并且佔用固定大小的記憶體，不需要額外的記憶體配置。然而，靜態陣列的缺點是無法動態調整長度，佔用固定大小的記憶體，即使實際使用的元素數量較少，也無法釋放多餘的記憶體。  動態陣列的優點是長度可變，可以在運行時根據需要進行增加或減少，並且在記憶體使用上更靈活，可以釋放多餘的記憶體。然而，動態陣列的缺點是存取效能稍低於靜態陣列，可能需要進行額外的記憶體指標計算，且需要動態分配和釋放記憶體空間。
評論: 存取效能稍低於靜態陣列  WHY？
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 106. 遞迴呼叫為何會造成記憶體區段錯誤？  答: 因為遞迴在每次call function會將所需的參數輸入stack中，等到函數結束時才會釋放該記憶體空間，  所以當使用遞迴呼叫函數次數過多且沒有給其適當條件來結束function時，會造成記憶體被佔用空間不斷增加，導致stack overflow，  覆蓋到其他記憶體所暫存的資料，最終導致記憶體區段錯誤。
評論: Good!
題目: 作業二採用什麼資料結構儲存讀入資料，須說明原因。
答案: 107. 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？  答: 使用try, throw, catch來進行對異常狀態(exception)的處理，例:  在處理除法的遞迴外包上try，並在程式出現異常時，throw出異常狀態 (如: 分母為0)，並且跳到try外面的catch中來對異常狀態進行處理  並回復遞迴狀態(如: depth等參數)，以接續進行遞迴。
評論: 並回復遞迴狀態(如: depth等參數)，以接續進行遞迴。   才是重點，若能詳加解說會更好。
題目: 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？
答案: 108. 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。  答: 這裡使用rand來隨機賦予陣列初始值，其中 array size 和 random 生成亂數的範圍皆可依需求調整  #include <iostream> #include <cstdlib> #include <ctime>  int main() {     std::srand(std::time(nullptr));      const int size = 10;     int arr[size];      // 為陣列元素設定隨機值     for (int i = 0; i < size; i++) {         arr[i] = std::rand() % 100; // 生成0到99之間的隨機數     }      // 輸出陣列元素     for (int i = 0; i < size; i++) {         std::cout << arr[i] <<    ;     }     std::cout << std::endl;      return 0; }
評論: 假設不是隨機數，也沒有規則性，如何給初始值？
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109. 靜態陣列和動態陣列有何差異？指出其優缺點。  答:  靜態陣列:  優點: 存取快、不需要額外記憶體空間存取address、方便宣告  缺點: 大小無法調整  動態陣列:  優點: 可依需求分配空間  缺點: 存取速度較慢、需要額外記憶體空間存取 address、需要手動釋放記憶體以免造成memory leak  靜態陣列是在編譯時就分配好記憶體空間，因此資料會存取在連續的記憶體空間內，不需要通過額外的記憶體來存取 address 並使用 address 間接存取在特定記憶體位置，只需要計算index，但其缺點也很明顯，因為在編譯時就已經分配好記憶體空間，所以可能導致占用不需要的記憶體空間或一開始分配的記憶體空間不足導致超出堆疊大小等問題。  而動態陣列的特性則相反，是在運行時根據需求調整大小，即不會發生靜態陣列的浪費不需要空間或空間不夠存取等問題，但為了達成動態分配記憶體，分配的空間必然無法連續，所以需要通過額外的記憶體空間來存取 address ，並在存取時使用 address 來指定位置。
評論: 動態陣列是配置連續的記憶體空間。
題目: 作業二靜態陣列和動態陣列有何差異？指出其優缺點。
答案: 110. 寫出C++程式碼說明傳值呼叫call by value。  答:   int changeValue(int x) {     x = x / 10; // 將傳入的參數進行遞增操作     return x; }  int main() {     int initial = 100;      std::cout <<  呼叫函數前的initial：   << initial << std::endl;     //輸出: 100          int after = changeValue(initial);      // call by value      std::cout <<  呼叫函數後的initial：   << initial << std::endl;     //輸出: 100      std::cout <<  函數輸出的值：   << after << std::endl;     //輸出:10      return 0; }  輸出為:  呼叫函數前的initial： 100 呼叫函數後的initial： 100 函數輸出的值： 10  有上述舉例可見，函數為傳值呼叫，是將輸入變數複製，並使用複製的值進行運算，並不會改變原來的變數。
評論: Nice.
題目: 作業二靜態陣列和動態陣列有何差異？指出其優缺點。
答案: 110. 寫出C++程式碼說明傳值呼叫call by value。    Call by value 並不會改變它所引用的變數， 因為它引用的只是該變數當時的值，並不是該變數本身，意思是函數把實際參數的值複製到形式參數中， 然後在函數內部使用這個複本，所以不會原本的值  #include <iostream> using namespace std; void swap (int,int); int main() {     int a=100, b=300;     cout <<  before:   << endl;     cout <<  a=  << a <<  , b=  << b << endl;     swap(a,b);     cout <<  after:   << endl;     cout <<  a=  << a <<  , b=  << b << endl;     return 0; } void swap (int x, int y) {     int temp;     temp = x;     x = y;     y = temp; }
評論: 不會原本的值  ?
題目: 作業二採用什麼資料結構儲存讀入資料，須說明原因。
答案: 107. 若遞迴到某層就異常終止，要如何強制它繼續執行到下一層？  可以使用遞迴函式的返回值來實現,當遞迴到指定的異常終止層級時，它會返回特定的值表示異常終止  在每個遞迴呼叫的後續邏輯中，檢查下一層返回的結果是否為異常終止。如果是，則返回另一個特定的值表示強制繼續執行到下一層。否則，正常執行遞迴邏輯。
評論: 似乎有點接近， 返回另一個特定的值表示強制繼續執行到下一層  仍須詳加解說。
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 106. 遞迴呼叫為何會造成記憶體區段錯誤？  遞迴呼叫可能導致記憶體區段錯誤的原因是因為遞迴的深度過大， 導致系統的堆疊空間被被新的函式呼叫用盡或超過了限制。 當使用者沒有將遞回設定停止點，導致遞回函式無限的產生新的函式呼叫，就會造成記憶體區段錯誤
評論: 先詳閱先前的貼文，避免過多重複內容，以免無法得分。
題目: 如何幫陣列元素設定非零的初始值？須寫出C++程式碼。
答案: 109. 靜態陣列和動態陣列有何差異？指出其優缺點。  動態陣列與靜態陣列的差異在於: 1.記憶體的使用狀況 2. 動態陣列 在程式尚未執行到有關該陣列的宣告之前，並不會配置任何記憶體給該陣列， 當程式執行到宣告陣列時，才會要求系統配置記憶體空間給動態陣列使用 3. 靜態陣列 則是程式在載入到記憶體時，同時也要求配置記憶體空間給靜態陣列使用  靜態陣列和動態陣列的優缺點: 1.動態陣列比較節省記憶體空間 2.靜態陣列則由於記憶體不會被釋放，所以可以保留之前的元素數值
評論: 列出的優缺點不盡合理。
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 106. 遞迴呼叫為何會造成記憶體區段錯誤？ 當遞迴呼叫的層數過多，超出了系統或程式所能提供的堆疊大小限制，就會發生記憶體區段錯誤.
評論: 多看看先前的貼文，內容重複並不會得分。
題目: 遞迴呼叫為何會造成記憶體區段錯誤？
答案: 遞迴呼叫在某些情況下可能導致記憶體區段錯誤 主要原因是由於堆疊溢位或無限遞迴  另一個情況是無限遞迴 就是遞迴函數沒有終止條件或終止條件設置不正確  遞迴函數會不斷地呼叫自己 造成無限遞迴
評論: 無限遞迴  是指什麼？電腦不可能無限執行遞迴吧！