計算機程式設計 - 快速指南

---

---

計算機程式設計 - 概述

計算機程式介紹

在深入學習計算機程式設計之前，讓我們先了解一下計算機程式及其作用。

計算機程式是用計算機程式語言編寫的一系列指令，用於讓計算機執行指定的任務。

我們在上述定義中使用了兩個重要的術語：

• 指令序列
• 計算機程式語言

為了理解這些術語，假設有人問你如何去附近的肯德基。你究竟會怎麼做才能告訴他去肯德基的路呢？

你會使用人類語言來告訴他去肯德基的路，例如：

先直走，走半公里後，在紅綠燈處左轉，然後繼續行駛一公里，你就會在右邊看到肯德基。

在這裡，你使用了英語來提供到達肯德基的分步指南。如果按照以下順序執行這些步驟，你就能到達肯德基：

1.	Go straight
2.	Drive half kilometer
3.	Take left
4.	Drive around one kilometer
5.	Search for KFC at your right side

現在，嘗試將這種情況與計算機程式進行對映。上述指令序列實際上是一個用**英語**編寫的**人類程式**，它指示如何從給定的起點到達肯德基。同樣的序列可以用西班牙語、印地語、阿拉伯語或任何其他人類語言來表達，前提是尋求方向的人知道其中任何一種語言。

現在，讓我們回到計算機程式，它是一系列用計算機語言編寫的指令，用於讓計算機執行指定的任務。下面是用**Python**程式語言編寫的一個簡單程式：

print "Hello, World!"

上述計算機程式指示計算機在螢幕上列印“Hello, World！”。

• 計算機程式也稱為**計算機軟體**，它可以包含從兩行到數百萬行指令。

• 計算機程式指令也稱為程式原始碼，**計算機程式設計**也稱為**程式編碼**。

• 沒有計算機程式的計算機只是一個空盒子；正是程式使計算機變得活躍。

正如我們開發了許多語言來進行相互交流一樣，計算機科學家也開發了幾種計算機程式語言來向計算機提供指令（即編寫計算機程式）。我們將在後續章節中看到幾種計算機程式語言。

計算機程式設計介紹

如果你理解了什麼是**計算機程式**，那麼我們可以說：*編寫計算機程式的行為稱為計算機程式設計*。

正如我們前面提到的，有數百種程式語言可用於編寫計算機程式，以下是一些例子：

• Java
• C
• C++
• Python
• PHP
• Perl
• Ruby

計算機程式的用途

如今，計算機程式幾乎應用於各個領域，包括家庭、農業、醫療、娛樂、國防、通訊等。以下是計算機程式的一些應用：

• MS Word、MS Excel、Adobe Photoshop、Internet Explorer、Chrome等都是計算機程式的例子。

• 計算機程式被用於開發電影製作中的圖形和特效。

• 計算機程式被用於執行超聲波、X光和其他醫學檢查。

• 計算機程式被用於我們的手機進行簡訊、聊天和語音通訊。

計算機程式設計師

能夠編寫計算機程式的人，或者換句話說，能夠進行計算機程式設計的人，稱為計算機程式設計師。

根據計算機程式語言的專業知識，我們可以將計算機程式設計師命名如下：

• C 程式設計師
• C++ 程式設計師
• Java 程式設計師
• Python 程式設計師
• PHP 程式設計師
• Perl 程式設計師
• Ruby 程式設計師

演算法

從程式設計的角度來看，**演算法**是解決任何問題的逐步過程。演算法是一種用有限的、明確定義的指令表達的有效方法。

因此，計算機程式設計師在編寫實際程式碼之前會列出解決問題所需的所有步驟。下面是一個從給定數字列表中找出最大數字的簡單演算法示例：

1. Get a list of numbers L1, L2, L3....LN
2. Assume L1 is the largest, Largest = L1
3. Take next number Li from the list and do the following
4. If Largest is less than Li
5. Largest = Li
6. If Li is last number from the list then
7. Print value stored in Largest and come out
8. Else repeat same process starting from step 3

上述演算法以一種粗略的方式編寫，以幫助初學者理解這個概念。隨著你進入計算機程式設計的高階階段，你會遇到更多標準化的計算機演算法編寫方式。

計算機程式設計 - 基礎

我們假設你對英語很熟悉，英語是一種眾所周知的**人機互動語言**。英語有預定義的語法，需要遵循這些語法才能正確地編寫英語語句。同樣，大多數人機互動語言（印地語、英語、西班牙語、法語等）都由多種元素組成，例如動詞、名詞、形容詞、副詞、介詞和連詞等。

與人機互動語言類似，計算機程式語言也由多種元素組成。我們將帶你瞭解這些元素的基礎知識，並讓你能夠在各種程式語言中舒適地使用它們。這些基本元素包括：

• 程式設計環境
• 基本語法
• 資料型別
• 變數
• 關鍵字
• 基本運算子
• 決策制定
• 迴圈
• 數字
• 字元
• 陣列
• 字串
• 函式
• 檔案I/O

我們將在後續章節中使用不同的程式語言舉例說明所有這些元素。首先，我們將嘗試理解所有這些術語的一般含義，然後我們將瞭解如何在不同的程式語言中使用這些術語。

本教程旨在讓你瞭解以下最流行的程式語言：

• C 程式設計
• Java 程式設計
• Python 程式設計

教程的大部分內容都是以C作為程式語言進行解釋的，然後我們展示了類似的概念如何在Java和Python中工作。因此，完成本教程後，你將對這些流行的程式語言非常熟悉。

計算機程式設計 - 環境

儘管環境設定不是任何程式語言的元素，但它是開始編寫程式之前要遵循的第一步。

當我們說環境設定時，它僅僅意味著一個基礎，我們可以在其上進行程式設計。因此，我們需要擁有所需的軟體設定，即在我們PC上的安裝，這些軟體將用於編寫計算機程式、編譯和執行它們。例如，如果你需要瀏覽網際網路，那麼你的機器上需要以下設定：

• 連線到網際網路的工作網際網路連線
• 網路瀏覽器，例如Internet Explorer、Chrome、Safari等。

如果你是一位PC使用者，那麼你將識別以下螢幕截圖，我們是在瀏覽tutorialspoint.com時從Internet Explorer中擷取的。

同樣，你需要以下設定才能開始使用任何程式語言進行程式設計。

• 文字編輯器來建立計算機程式。
• 編譯器將程式編譯成二進位制格式。
• 直譯器直接執行程式。

如果你對計算機的瞭解不足，你將無法設定其中任何一個軟體。因此，我們建議你尋求周圍任何技術人員的幫助，以便在你的機器上設定程式設計環境，從那裡開始。但對你來說，重要的是要了解這些專案是什麼。

文字編輯器

文字編輯器是一種用於編寫計算機程式的軟體。你的Windows機器必須有一個記事本，可以用它來鍵入程式。你可以按照以下步驟啟動它：

Start Icon → All Programs → Accessories → Notepad → Mouse Click on Notepad

它將啟動記事本，並顯示以下視窗：

你可以使用此軟體鍵入你的計算機程式並將其儲存在任何位置的檔案中。你可以下載並安裝其他優秀的編輯器，例如**Notepad++**，它是免費提供的。

如果你是一位Mac使用者，那麼你將擁有**TextEdit**，或者你可以安裝一些其他商業編輯器，例如**BBEdit**來開始使用。

編譯器？

你使用你喜歡的程式語言編寫計算機程式，並將其儲存在名為程式檔案的文字檔案中。

現在讓我們嘗試更詳細地瞭解計算機如何理解你使用程式語言編寫的程式。實際上，計算機無法直接理解以文字格式提供的程式，因此我們需要將此程式轉換為計算機可以理解的二進位制格式。

從文字程式到二進位制檔案的轉換由另一個稱為編譯器的軟體完成，而從文字格式程式到二進位制格式檔案的轉換過程稱為程式編譯。最後，你可以執行二進位制檔案來執行已程式設計的任務。

我們不會深入探討編譯器和編譯的不同階段的細節。

以下流程圖說明了該過程：

因此，如果你要使用任何需要編譯的語言（如C、C++、Java和Pascal等）編寫程式，則需要在開始程式設計之前安裝其編譯器。

直譯器

我們剛剛討論了編譯器和編譯過程。如果你要使用需要先編譯成二進位制格式才能執行的程式語言編寫程式，那麼就需要編譯器。

還有一些其他的程式語言，比如 Python、PHP 和 Perl，它們不需要編譯成二進位制格式，而是可以使用直譯器逐行讀取這些程式並直接執行，無需任何進一步的轉換。

所以，如果你打算用 PHP、Python、Perl、Ruby 等語言編寫程式，那麼在開始程式設計之前需要安裝它們的直譯器。

線上編譯

如果你無法在你的機器上設定任何編輯器、編譯器或直譯器，那麼tutorialspoint.com 提供了一個方便的功能，可以輕鬆地一鍵線上編譯和執行幾乎所有程式。

所以不用擔心，讓我們繼續前進，體驗一下成為一名計算機程式設計師的激動過程，我們將以簡單易懂的步驟進行學習。

計算機程式設計 - 基本語法

讓我們從一點程式碼開始，這將真正讓你成為一名計算機程式設計師。我們將編寫一個單行計算機程式，在你的螢幕上輸出Hello, World!。讓我們看看如何使用不同的程式語言編寫它。

C語言中的Hello World程式

嘗試使用我們在 www.compileonline.com 上提供的線上編譯器選項來執行以下示例。

在本教程中給出的大多數示例中，你都會在網站程式碼部分的右上角找到一個嘗試一下選項，它會將你帶到線上編譯器。

嘗試更改 printf() 內的內容，例如，在Hello World! 的位置輸入任何內容，然後檢查其結果。它只會列印你在兩個雙引號內輸入的內容。

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
}

這將產生以下結果：

Hello, World!

這個小小的 Hello World 程式將幫助我們理解與 C 程式設計相關的各種基本概念。

程式入口點

現在，先不用管#include <stdio.h> 語句，但請記住，你必須將此語句放在 C 程式的頂部。

每個 C 程式都以 main() 開始，它被稱為主函式，然後後面跟著一個左花括號。程式的其餘指令寫在兩個花括號之間，最後用右花括號結束程式。

這兩個花括號內的編碼部分稱為程式體。左花括號可以與 main(){ 在同一行，也可以在新的一行，就像上面程式中提到的那樣。

函式

函式是程式的小單元，用於執行特定的任務。例如，上面的程式使用了兩個函式：main() 和 printf()。這裡，函式 main() 為程式執行提供入口點，另一個函式 printf() 用於在計算機螢幕上列印資訊。

你可以編寫自己的函式，我們將在單獨的章節中介紹，但 C 程式設計本身提供了各種內建函式，如 main()、printf() 等，我們可以根據需要在程式中使用這些函式。

一些程式語言使用子程式代替函式，但它們的功能大體相同。

註釋

C 程式可以包含包含在/*.....*/ 中的語句。這些語句稱為註釋，它們用於使程式更友好、更易於理解。註釋的好處是它們會被編譯器和直譯器完全忽略。所以你可以使用任何你想要的語言來編寫註釋。

空白字元

當我們使用任何程式語言編寫程式時，我們會使用各種可列印字元來準備程式設計語句。這些可列印字元是a, b, c,......z, A, B, C,.....Z, 1, 2, 3,...... 0, !, @, #, $, %, ^, &, *, (, ), -, _, +, =, \, |, {, }, [, ], :, ;, <, >, ?, /, \, ~. `. ", '。希望我沒有遺漏你鍵盤上的任何可列印字元。

除了這些字元之外，還有一些字元我們經常使用，但它們在你的程式中是不可見的，這些字元是空格、製表符(\t)、換行符(\n)。這些字元稱為空白字元。

這三個重要的空白字元在所有程式語言中都很常見，並且在你的文字文件中是不可見的：

僅包含空白字元（可能帶有註釋）的行稱為空行，C 編譯器會完全忽略它。空白字元是 C 中用於描述空格、製表符、換行符和註釋的術語。因此，你可以像下面這樣編寫printf("Hello, World!" );。這裡“Hello, World!”周圍建立的所有空格都是無用的，編譯器在編譯時會忽略它們。

#include <stdio.h>

int main() {

   /* printf() function to write Hello, World! */
   
   printf(    "Hello, World!"      );
   
}

這將產生以下結果：

Hello, World!

如果我們將所有這些空白字元都顯示出來，那麼上面的程式將如下所示，並且你將無法編譯它：

#include <stdio.h>\n
\n
int main()\n
{
   \n
   \t/* printf() function to write Hello, World! */
   \n 
   \tprintf(\t"Hello, World!"\t);\n
   \n
}\n

分號

C 程式中的每個單獨語句都必須以分號 (;) 結尾，例如，如果你想輸出兩次“Hello, World!”，則可以按如下方式編寫：

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!\n" );
   printf( "Hello, World!" );
}

此程式將產生以下結果：

Hello, World! 
Hello, World!

這裡，我們在第一個 printf() 函式中使用換行符\n來建立新行。讓我們看看如果我們不使用此換行符會發生什麼：

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
   printf( "Hello, World!" );
}

此程式將產生以下結果：

Hello, World! Hello, World!

我們將在接下來的幾章中學習識別符號和關鍵字。

程式解釋

讓我們瞭解一下上面 C 程式是如何工作的。首先，上面的程式使用 C 編譯器轉換為二進位制格式。所以讓我們將這段程式碼放在 test.c 檔案中，並按如下方式編譯：

$gcc test.c -o demo

如果有任何語法錯誤（計算機術語中的語法錯誤），那麼我們在將其轉換為二進位制格式之前修復它。如果一切正常，則會生成一個名為demo的二進位制檔案。最後，我們按如下方式執行生成的二進位制檔案 demo：

$./demo

這將產生以下結果：

Hello, World!

這裡，當我們執行二進位制檔案a.out時，計算機從 main() 開始進入程式，並遇到一個 printf() 語句。請注意，/*....*/ 內部的行是註釋，在編譯時會被過濾掉。因此，printf() 函式指示計算機在計算機螢幕上列印給定的行。最後，它遇到一個右花括號，表示 main() 函式的結束，並退出程式。

語法錯誤

如果你沒有遵循程式語言定義的規則，那麼在編譯時，你將遇到語法錯誤，程式將無法編譯。從語法的角度來看，即使是一個點或逗號或一個分號也很重要，你應該注意這些小的語法細節。在下面的示例中，我們省略了一個分號，讓我們嘗試編譯程式：

#include <stdio.h>

main() {
   printf("Hello, World!")
}

此程式將產生以下結果：

main.c: In function 'main':
main.c:7:1: error: expected ';' before '}' token
 }
 ^

所以底線是，如果你沒有在程式中遵循程式語言定義的正確語法，那麼你將遇到語法錯誤。在嘗試另一次編譯之前，你需要修復它們，然後繼續。

Java語言中的Hello World程式

以下是使用 Java 編寫的等效程式。此程式也將產生相同的結果Hello, World!。

public class HelloWorld { 
   public static void main(String []args) {
      /* println() function to write Hello, World! */
      System.out.println("Hello, World!");     
   }
}

這將產生以下結果：

Hello, World!

Python語言中的Hello World程式

以下是使用 Python 編寫的等效程式。此程式也將產生相同的結果Hello, World!。

#  print function to write Hello, World! */
print "Hello, World!"

這將產生以下結果：

Hello, World!

希望你注意到，對於 C 和 Java 示例，我們首先編譯程式，然後執行生成的二進位制檔案，但在 Python 程式中，我們直接執行它。正如我們在上一章中解釋的那樣，Python 是一種解釋型語言，它不需要稱為編譯的中間步驟。

Python 不需要分號 (;) 來終止語句，換行符始終表示語句的終止。

計算機程式設計 - 資料型別

讓我們討論一個非常簡單但非常重要的概念，它幾乎存在於所有程式語言中，稱為資料型別。顧名思義，資料型別表示你可以使用計算機程式處理的資料的型別。它可以是數字、字母數字、小數等。

讓我們暫時擱置計算機程式設計，舉一個簡單的例子，將兩個整數 10 和 20 相加，這可以簡單地按如下方式完成：

10 + 20

讓我們再舉一個例子，我們想將兩個小數 10.50 和 20.50 相加，這將按如下方式編寫：

10.50 + 20.50

這兩個例子都很簡單。現在讓我們再舉一個例子，我們想在一個筆記本上記錄學生資訊。這裡我們想記錄以下資訊：

Name:
Class:
Section:
Age:
Sex:

現在，讓我們根據給定的要求放入一個學生記錄：

Name: Zara Ali
Class: 6th
Section: J
Age: 13
Sex: F

第一個例子處理的是整數，第二個例子加了兩個小數，而第三個例子處理的是不同資料的混合。讓我們將其表示如下：

• 學生姓名“Zara Ali”是一系列字元，也稱為字串。

• 學生班級“6th”由整數和兩個字元的字串混合表示。這種混合稱為字母數字。

• 學生所在班級由單個字元“J”表示。

• 學生年齡由整數 13 表示。

• 學生性別由單個字元“F”表示。

這樣，我們意識到在日常生活中，我們處理不同型別的資料，例如字串、字元、整數和小數（浮點數）。

同樣，當我們編寫計算機程式來處理不同型別的資料時，我們需要明確指定其型別；否則計算機無法理解如何對給定的資料執行不同的操作。不同的程式語言使用不同的關鍵字來指定不同的資料型別。例如，C 和 Java 程式語言使用int來指定整型資料，而char則指定字元型資料型別。

後續章節將向你展示如何在不同情況下使用不同的資料型別。現在，讓我們檢查一下 C、Java 和 Python 中可用的重要資料型別以及我們將用於指定這些資料型別的關鍵字。

C 和 Java 資料型別

C 和 Java 支援幾乎相同的 資料型別集，儘管 Java 支援其他資料型別。現在，我們正在使用這兩種程式語言都支援的一些常用資料型別：

這些資料型別稱為基本資料型別，您可以使用這些資料型別構建更復雜的資料型別，稱為使用者定義資料型別，例如字串將是一系列字元。

Python 資料型別

Python 有五種標準資料型別，但這種程式語言不使用任何關鍵字來指定特定的資料型別，而是 Python 足夠智慧，可以自動理解給定的資料型別。

• 數字
• 字串
• 列表
• 元組
• 字典

這裡，數字指定所有型別的數字，包括十進位制數，字串表示長度為 1 個或多個字元的字元序列。目前，讓我們繼續使用這兩種資料型別，並跳過列表、元組和字典，它們是 Python 中的高階資料型別。

計算機程式設計 - 變數

變數是在計算機程式中用於儲存值的計算機記憶體位置所賦予的名稱。

例如，假設您想在程式中儲存兩個值 10 和 20，並在稍後階段使用這兩個值。讓我們看看您將如何做到這一點。以下是三個簡單的步驟：

• 建立具有適當名稱的變數。
• 將您的值儲存在這些兩個變數中。
• 檢索並使用變數中儲存的值。

建立變數

在 C 程式設計中，建立變數也稱為**宣告變數**。不同的程式語言在程式內部建立變數的方式不同。例如，C 程式設計有以下建立變數的簡單方法：

#include <stdio.h>

int main() {
   int a;
   int b;
}

以上程式建立了兩個變數，以使用名稱**a**和**b**保留兩個記憶體位置。我們使用**int**關鍵字建立了這些變數來指定變數**資料型別**，這意味著我們希望在這兩個變數中儲存整數值。類似地，您可以建立變數來儲存**long**、**float**、**char**或任何其他資料型別。例如：

/* variable to store long value */
long a;

/* variable to store float value */
float b;

您可以透過將相似型別的變數放在一行中並用逗號分隔來建立它們，如下所示：

#include <stdio.h>

int main() {
   int a, b;
}

以下是關於變數的一些關鍵要點，您需要注意：

• 一個變數名只能儲存一種型別的值。例如，如果變數**a**已定義為**int**型別，則它只能儲存整數。

• C 程式語言要求在程式中使用變數之前建立變數，即宣告。您不能在程式中使用變數名而無需建立它，儘管像 Python 這樣的程式語言允許您在不建立變數名的情況下使用它。

• 您只能在程式中使用一次變數名。例如，如果變數**a**已定義為儲存整數值，則您不能再次定義**a**來儲存任何其他型別的值。

• 有一些程式語言，如 Python、PHP、Perl 等，不需要您在建立變數時指定資料型別。因此，您可以儲存整數、浮點數或長整數，而無需指定其資料型別。

• 您可以為變數賦予任何名稱，例如**age**、**sex**、**salary**、**year1990**或任何您喜歡的名稱，但大多數程式語言只允許在變數名中使用有限的字元。目前，我們建議您僅在變數名中使用**a....z、A....Z、0....9**，並以字母開頭而不是數字。

• 幾乎沒有程式語言允許變數名以數字開頭，因此**1990year**不是有效的變數名，而**year1990**或**ye1990ar**是有效的變數名。

每種程式語言都提供了更多與變數相關的規則，當您深入瞭解該程式語言時，您將學習它們。

在變數中儲存值

您已經瞭解瞭如何在上一節中建立變數。現在，讓我們在這些變數中儲存一些值：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
}

以上程式有兩個額外的語句，我們在其中將 10 儲存在變數**a**中，並將 20 儲存在變數**b**中。幾乎所有程式語言都以類似的方式在變數中儲存值，我們將在等號 = 的左側保留變數名，並且我們將要儲存在變數中的任何值，我們都將其儲存在右側。

現在，我們已經完成了兩個步驟，首先我們建立了兩個變數，然後我們在這些變數中儲存了所需的值。現在變數**a**的值為 10，變數**b**的值為 20。換句話說，我們可以說，當執行上述程式時，名為**a**的記憶體位置將儲存 10，記憶體位置**b**將儲存 20。

訪問變數中儲存的值

如果我們不使用變數中儲存的值，那麼建立變數並在其中儲存值就沒有意義。我們知道以上程式有兩個變數**a**和**b**，它們分別儲存值 10 和 20。所以讓我們嘗試列印儲存在這兩個變數中的值。以下是一個 C 程式，它列印儲存在其變數中的值：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d\n", a );
   printf( "Value of b = %d\n", b );
}

當執行上述程式時，它會產生以下結果：

Value of a = 10
Value of b = 20

您一定在上一章中看到了**printf()**函式，我們之前曾使用它來列印“Hello, World！”。這一次，我們使用它來列印變數的值。我們正在使用**%d**，它將被**printf()**語句中給定變數的值替換。我們可以使用單個**printf()**語句列印這兩個值，如下所示：

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

當執行上述程式時，它會產生以下結果：

Value of a = 10 and value of b = 20

如果要在 C 程式設計中使用**float**變數，則必須使用**%f**而不是**%d**，如果要列印字元值，則必須使用**%c**。類似地，可以使用不同的 % 和字元列印不同的資料型別。

Java 中的變數

以下是使用 Java 程式語言編寫的等效程式。此程式將建立兩個變數**a**和**b**，並且與 C 程式設計非常相似，它將在這些變數中分別賦值 10 和 20，最後以兩種方式列印這兩個變數的值：

public class DemoJava {
   public static void main(String []args) {
      int a;
      int b;
   
      a = 10;
      b = 20;
   
      System.out.println("Value of a = " + a);
      System.out.println("Value of b = " + b);
      System.out.println("Value of a = " + a + " and value of b = " + b);     
   }
}

當執行上述程式時，它會產生以下結果：

Value of a = 10
Value of b = 20
Value of a = 10 and value of b = 20

Python 中的變數

以下是使用 Python 編寫的等效程式。此程式將建立兩個變數**a**和**b**，並在同時將 10 和 20 分配給這些變數。

Python 不需要您在建立變數時指定資料型別，並且無需預先建立變數。

a = 10
b = 20
   
print "Value of a = ", a
print "Value of b = ", b
print "Value of a = ", a, " and value of b = ", b

當執行上述程式時，它會產生以下結果：

Value of a =  10
Value of b =  20
Value of a =  10  and value of b =  20

您可以在 C 和 Java 程式設計中使用以下語法來同時宣告變數和賦值：

#include <stdio.h>

int main() {
   int a = 10;
   int b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

當執行上述程式時，它會產生以下結果：

Value of a = 10 and value of b = 20

計算機程式設計 - 關鍵字

到目前為止，我們已經涵蓋了兩個重要的概念，即變數及其資料型別。我們討論瞭如何使用**int**、**long**和**float**來指定不同的資料型別。我們還學習瞭如何命名變數以儲存不同的值。

雖然本章不需要單獨列出，因為保留關鍵字是基本程式設計語法的組成部分，但我們將其單獨列出以便在資料型別和變數之後立即解釋，以便於理解。

像 int、long 和 float 一樣，C 程式語言支援許多其他關鍵字，我們將用於不同的目的。不同的程式語言提供不同的保留關鍵字集，但所有程式語言中都有一個重要且通用的規則，即我們不能使用保留關鍵字來命名我們的變數，這意味著我們不能將變數命名為**int**或**float**，而這些關鍵字只能用於指定變數資料型別。

例如，如果您嘗試將任何保留關鍵字用於變數名，則會收到語法錯誤。

#include <stdio.h>

int main() {
   int float;
   float = 10;
   
   printf( "Value of float = %d\n", float);
}

當您編譯以上程式時，它會產生以下錯誤：

main.c: In function 'main':
main.c:5:8: error: two or more data types in declaration specifiers
   int float;
......

現在讓我們為我們的整數變數賦予一個合適的名稱，然後以上程式應該可以成功編譯和執行：

#include <stdio.h>

int main() {
   int count;
   count = 10;

   printf( "Value of count = %d\n", count);
}

C 程式設計保留關鍵字

這是一個包含 C 程式語言支援的幾乎所有關鍵字的表格：

Java 程式設計保留關鍵字

這是一個包含 Java 程式語言支援的幾乎所有關鍵字的表格：

Python 程式設計保留關鍵字

這是一個包含 Python 程式語言支援的幾乎所有關鍵字的表格：

我們知道您無法記住所有這些關鍵字，但我們已將其列出以供您參考並解釋**保留關鍵字**的概念。因此，在為變數命名時請小心，您不應為該程式語言使用任何保留關鍵字。

計算機程式設計 - 運算子

程式語言中的運算子是一個符號，它告訴編譯器或直譯器執行特定的數學、關係或邏輯運算併產生最終結果。本章將解釋**運算子**的概念，並帶您瞭解 C、Java 和 Python 中可用的重要算術和關係運算符。

算術運算子

計算機程式廣泛用於數學計算。我們可以編寫一個可以進行簡單計算（如加兩個數 (2 + 3)）的計算機程式，我們還可以編寫一個可以求解複雜方程（如 P(x) = x⁴ + 7x³ - 5x + 9）的程式。即使您是一個差生，您也必須知道在第一個表示式中 2 和 3 是運算元，+ 是運算子。計算機程式設計中也存在類似的概念。

請看以下兩個示例 -

2 + 3

P(x) = x4 + 7x3 - 5x + 9. 

這兩個語句在程式語言中被稱為算術表示式，並且這些表示式中使用的加號、減號被稱為算術運算子，表示式中使用的值，例如 2、3 和 x 等，被稱為運算元。它們最簡單的形式是產生數值結果。

類似地，程式語言提供了各種算術運算子。下表列出了 C 程式語言中一些重要的算術運算子。假設變數 A 包含 10，變數 B 包含 20，則 -

以下是一個簡單的 C 程式設計示例，用於理解上述數學運算子 -

#include <stdio.h>

int main() {
   int a, b, c;
   
   a = 10;
   b = 20;
   
   c = a + b;   
   printf( "Value of c = %d\n", c);
   
   c = a - b;   
   printf( "Value of c = %d\n", c);
   
   c = a * b;   
   printf( "Value of c = %d\n", c);
   
   c = b / a;   
   printf( "Value of c = %d\n", c);
   
   c = b % a;   
   printf( "Value of c = %d\n", c);
}

當執行上述程式時，它會產生以下結果：

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0

關係運算符

考慮這樣一種情況，我們建立兩個變數併為它們分配一些值，如下所示 -

A = 20
B = 10

在這裡，很明顯變數 A 的值大於 B。因此，我們需要一些符號來編寫這樣的表示式，這些表示式稱為關係表示式。如果我們使用 C 程式語言，則將如下編寫 -

(A > B)

這裡，我們使用了符號 >，它被稱為關係運算符，它們最簡單的形式是產生布爾結果，這意味著結果要麼為真，要麼為假。類似地，程式語言提供了各種關係運算符。下表列出了 C 程式語言中一些重要的關係運算符。假設變數A包含 10，變數B包含 20，則 -

在這裡，我們將向您展示一個使用if 條件語句的 C 程式設計示例。儘管此語句將在後面的單獨章節中討論，但簡而言之，我們使用if 語句來檢查條件，如果條件為真，則執行if 語句的主體，否則跳過if 語句的主體。

#include <stdio.h>

int main() {
   int a, b;
   
   a = 10;
   b = 20;
   
   /* Here we check whether a is equal to 10 or not */
   if( a == 10 ) {
	   
      /* if a is equal to 10 then this body will be executed */
      printf( "a is equal to 10\n");
   }
   
   /* Here we check whether b is equal to 10 or not */
   if( b == 10 ) {
	
      /* if b is equal to 10 then this body will be executed */
      printf( "b is equal to 10\n");
   }
   
   /* Here we check if a is less b than or not */
   if( a < b ) {
	
      /* if a is less than b then this body will be executed */
      printf( "a is less than b\n");
   }
   
   /* Here we check whether a and b are not equal */
   if( a != b ) {
	
      /* if a is not equal to b then this body will be executed */
      printf( "a is not equal to b\n");
   }
}

當執行上述程式時，它會產生以下結果：

a is equal to 10
a is less than b
a is not equal to b

邏輯運算子

邏輯運算子在任何程式語言中都非常重要，它們幫助我們根據某些條件做出決策。假設我們想組合兩個條件的結果，那麼邏輯 AND 和 OR 邏輯運算子將幫助我們產生最終結果。

下表顯示了 C 語言支援的所有邏輯運算子。假設變數A包含 1，變數B包含 0，則 -

嘗試以下示例以瞭解 C 程式語言中可用的所有邏輯運算子 -

#include <stdio.h>

int main() {
   int a = 1;
   int b = 0;

   if ( a && b ) {
	
      printf("This will never print because condition is false\n" );
   }
   if ( a || b ) {
	
      printf("This will be printed print because condition is true\n" );
   }
   if ( !(a && b) ) {
	
      printf("This will be printed print because condition is true\n" );
   }
}

編譯並執行上述程式時，將產生以下結果 -

This will be printed print because condition is true
This will be printed print because condition is true

Java 中的運算子

以下是 Java 中編寫的等效程式。C 程式設計和 Java 提供幾乎相同的運算子和條件語句集。此程式將建立兩個變數a和b，與 C 程式設計非常相似，然後我們在這些變數中分別賦值 10 和 20，最後，我們將使用不同的算術和關係運算符 -

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      int a, b, c;
   
      a = 10;
      b = 20;
   
      c = a + b;   
      System.out.println("Value of c = " + c );
   
      c = a - b;
      System.out.println("Value of c = " + c );
   
      c = a * b;   
      System.out.println("Value of c = " + c );
   
      c = b / a;   
      System.out.println("Value of c = " + c );
   
      c = b % a;   
      System.out.println("Value of c = " + c );
      
      if( a == 10 ) {
		
         System.out.println("a is equal to 10" );
      }
   }
}

當執行上述程式時，它會產生以下結果：

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0
a is equal to 10

Python 中的運算子

以下是 Python 中編寫的等效程式。此程式將建立兩個變數a和b，並同時在這些變數中賦值 10 和 20。幸運的是，C 程式設計和 Python 程式語言提供了幾乎相同的運算子集。此程式將建立兩個變數a和b，與 C 程式設計非常相似，然後我們在這些變數中分別賦值 10 和 20，最後，我們將使用不同的算術和關係運算符。

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述示例生成的輸出相同。

a = 10
b = 20
   
c = a + b   
print "Value of c = ", c

c = a - b   
print "Value of c = ", c

c = a * b   
print "Value of c = ", c

c = a / b   
print "Value of c = ", c

c = a % b   
print "Value of c = ", c

if( a == 10 ):
   print "a is equal to 10"

當執行上述程式時，它會產生以下結果：

Value of c =  30
Value of c =  -10
Value of c =  200
Value of c =  0
Value of c =  10
a is equal to 10

決策語句

決策制定對於計算機程式設計至關重要。在許多情況下，您將獲得兩個或多個選項，並且您必須根據給定的條件選擇一個選項。例如，我們希望根據學生獲得的分數列印關於學生的評語。以下是這種情況 -

Assume given marks are x for a student:

If given marks are more than 95, then
Student is brilliant

If given marks are less than 30, then
Student is poor

If given marks are less than 95 and more than 30, then
Student is average

現在，問題是如何編寫程式設計程式碼來處理這種情況。幾乎所有程式語言都提供條件語句，這些語句的工作原理基於以下流程圖 -

讓我們使用if 條件語句編寫一個 C 程式，將上述給定情況轉換為程式設計程式碼 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   }
   if( x < 30) {
	
      printf( "Student is poor\n");
   }
   if( x < 95 && x > 30 ) {
	
      printf( "Student is average\n");
   }
}

當執行上述程式時，它會產生以下結果：

Student is average

上述程式使用了if 條件語句。這裡，第一個if 語句檢查給定條件，即變數 x 是否大於 95，如果發現條件為真，則進入條件體執行給定的語句。這裡我們只有一個printf()語句來列印關於學生的評語。

類似地，第二個if 語句工作。最後，執行第三個if 語句，這裡我們有兩個條件 -

• 第一個條件是x > 95

• 第二個條件是x < 30

計算機評估這兩個給定的條件，然後，使用二元運算子&&組合最終結果。如果最終結果為真，則執行條件語句，否則不執行任何語句。

本教程將為您提供有關各種形式的if 語句以及 C 程式語言中switch語句的介紹的基本概念。不同的程式語言提供不同型別的決策語句，但基本概念與本教程中解釋的相同。

if...else 語句

一個if語句後面可以跟一個可選的else語句，當布林表示式為假時執行該語句。C 程式語言中if...else語句的語法如下 -

if(boolean_expression) {
   
   /* Statement(s) will execute if the boolean expression is true */
} else {
  
  /* Statement(s) will execute if the boolean expression is false */
}

上述語法可以表示為如下所示的流程圖 -

當我們必須從兩個選項中做出決策時，if...else語句非常有用。例如，如果學生的分數超過 95 分，則該學生很優秀，否則無法編碼這種情況，如下所示 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   } else {
      printf( "Student is not brilliant\n");
   }
}

當執行上述程式時，它會產生以下結果：

Student is not brilliant

if...elseif...else 語句

一個if語句後面可以跟一個可選的else if...else語句，這對於測試各種條件非常有用。

使用if、else if、else語句時，需要注意以下幾點 -

• 一個if可以有零個或一個else，並且它必須出現在else if之後。

• 一個if可以有零到多個else…if，並且它們必須出現在else之前。

• 一旦else…if成功，就不會測試任何剩餘的else…if或else。

C 程式語言中if...else if...else語句的語法如下 -

if(boolean_expression 1) {

   /* Executes when the boolean expression 1 is true */
}
else if( boolean_expression 2) {

   /* Executes when the boolean expression 2 is true */
}
else if( boolean_expression 3) {

   /* Executes when the boolean expression 3 is true */
} else {
   
   /* Executes when the none of the above condition is true */
}

現在，藉助if...elseif...else語句，第一個程式可以編碼如下 -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
      printf( "Student is brilliant\n");
   } 
   else if( x < 30) {
      printf( "Student is poor\n");
   } 
   else if( x < 95 && x > 30 ) {
      printf( "Student is average\n");
   }
}

當執行上述程式時，它會產生以下結果：

Student is average

Switch 語句

switch語句是if 語句的替代方案，它允許將變數與值列表進行相等性測試。每個值稱為一個case，並且正在切換的變數將針對每個 switch case 進行檢查。它具有以下語法 -

switch(expression){
   case ONE :
      statement(s);
      break;
   case TWO:
      statement(s);
      break;
   ......
   
   default :
      statement(s);
}

switch語句中使用的表示式必須給出整數值，該值將與給定的不同 case 進行相等性比較。在表示式的值與某個 case 的值匹配的地方，將執行該 case 的主體，最後，將使用break語句終止 switch。如果沒有提供 break 語句，則計算機將繼續執行下面可用的其他語句，直到匹配的 case。如果沒有任何 case 匹配，則執行 default case 的主體。

上述語法可以表示為如下所示的流程圖 -

現在，讓我們考慮另一個示例，我們希望為給定的數字編寫等效的英文單詞。然後，可以將其編碼如下 -

#include <stdio.h>

int main() {
   int x = 2;
   
   switch( x ){
      case 1 :
         printf( "One\n");
         break;
      case 2 :
         printf( "Two\n");
         break;
      case 3 :
         printf( "Three\n");
         break;
      case 4 :
         printf( "Four\n");
         break;
      default :
         printf( "None of the above...\n");
   }
}

當執行上述程式時，它會產生以下結果：

Two

Java 中的決策

以下是 Java 中編寫的等效程式，它也支援if、if...else、if...elseif...else和switch語句。

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述 C 示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      int x = 45;
   
      if( x > 95) {
         System.out.println( "Student is brilliant");
      } 
      else if( x < 30) {
         System.out.println( "Student is poor");
      } 
      else if( x < 95 && x > 30 ) {
         System.out.println( "Student is average");
      }
   }
}

當執行上述程式時，它會產生以下結果：

Student is average

Python 中的決策

以下是 Python 中編寫的等效程式。Python 提供if、if...else、if...elif...else和switch語句。在這裡，您必須注意 Python 不使用花括號作為條件體，而是簡單地使用語句的縮排來識別塊的主體。

您可以嘗試執行以下程式以檢視輸出 -

x = 45

if x > 95:
   print "Student is brilliant"
elif x < 30:
   print "Student is poor"
elif x < 95 and x > 30:
   print "Student is average"

print "The end"

當執行上述程式時，它會產生以下結果：

Student is average
The end

計算機程式設計 - 迴圈

讓我們考慮這樣一種情況，您希望列印Hello, World!五次。這是一個簡單的 C 程式來完成同樣的操作 -

#include <stdio.h>

int main() {
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
}

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

這很簡單，但再次，讓我們考慮另一種情況，您希望寫入Hello, World!一千次。我們當然不能將 printf() 語句寫一千次。幾乎所有程式語言都提供了一個稱為迴圈的概念，它有助於將一個或多個語句執行到所需的次數。所有高階程式語言都提供各種形式的迴圈，這些迴圈可用於重複執行一個或多個語句。

讓我們使用while 迴圈編寫上述 C 程式，稍後我們將討論此迴圈的工作原理

#include <stdio.h>

int main() {
   int i = 0;
   
   while ( i < 5 ) {
      printf( "Hello, World!\n");
      i = i + 1;
   }
}

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

上述程式使用了while 迴圈，該迴圈用於執行包含在 {....} 中的一組程式設計語句。在這裡，計算機首先檢查給定條件，即變數“a”是否小於 5，如果發現條件為真，則進入迴圈體執行給定的語句。這裡，我們在迴圈體中有以下兩個語句 -

• 第一個語句是printf()函式，它列印 Hello World!

• 第二個語句是i = i + 1，用於增加變數i的值。

執行完迴圈體中所有語句後，計算機將返回到while( i < 5)，並再次檢查給定的條件(i < 5)，如果條件成立，則再次執行迴圈。這個過程會重複，直到給定的條件保持為真，這意味著變數“a”的值小於5。

總之，迴圈語句允許我們多次執行一個語句或一組語句。下面是在大多數程式語言中迴圈語句的一般形式：

本教程旨在向非程式設計師介紹程式設計的基本概念，因此讓我們討論一下C程式語言中提供的兩個最重要的迴圈。一旦您瞭解了這兩個迴圈，您就可以選擇C程式設計教程或參考書，並檢查C中提供的其他迴圈及其工作方式。

while迴圈

C程式語言中提供的while迴圈具有以下語法：

while ( condition ) {
   /*....while loop body ....*/
}

以上程式碼可以用流程圖表示，如下所示：

關於while迴圈，需要注意以下幾點：

• while迴圈以關鍵字while開頭，後跟用( )括起來的條件。

• 在while()語句之後，您將擁有用花括號{...}括起來的迴圈體。

• while迴圈體可以有一行或多行要重複執行的原始碼。

• 如果while迴圈體只有一行，則可以使用花括號{...}，也可以不使用。

• while迴圈會一直執行其迴圈體，直到給定的條件為真。一旦條件變為假，while迴圈就會退出，並繼續從while迴圈體之後的下一條語句開始執行。

• 條件通常是一個關係語句，其結果要麼為真，要麼為假。值為零被視為假，任何非零值都被視為真。

do...while迴圈

while迴圈會在執行迴圈體中任何語句之前檢查給定的條件。C程式設計提供另一種形式的迴圈，稱為do...while，它允許在檢查給定條件之前執行迴圈體。它具有以下語法：

do {
   /*....do...while loop body ....*/
} 
while ( condition );

以上程式碼可以用流程圖表示，如下所示：

如果您使用do...while迴圈編寫上述示例，則Hello, World將產生相同的結果：

#include <stdio.h>

int main() {
   int i = 0;
   
   do {
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

break語句

當在迴圈內遇到break語句時，迴圈會立即終止，程式控制權會恢復到迴圈之後的下一條語句。C中break語句的語法如下：

break;

break語句可以用流程圖表示，如下所示：

以下是上述程式的一個變體，但它只打印三次Hello World!後就會退出：

#include <stdio.h>

int main() {
   int i = 0;
   do {
      printf( "Hello, World!\n");
      i = i + 1;
      
      if( i == 3 ) {
         break;
      }
   }
   while ( i < 5 );
}

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!

continue語句

C程式語言中的continue語句在某種程度上類似於break語句。continue不是強制終止，而是強制執行迴圈的下一輪迭代，跳過中間的任何程式碼。C中continue語句的語法如下：

continue;

continue語句可以用流程圖表示，如下所示：

以下是上述程式的一個變體，但當變數的值等於3時，它將跳過列印：

#include <stdio.h>

int main() {
   int i = 0;
   do {
      if( i == 3 ) {
         i = i + 1;
         continue;
      }
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!

Java中的迴圈

以下是使用Java編寫的等效程式，它也支援while和do...while迴圈。以下程式列印Hello, World!五次，就像我們在C程式設計中所做的那樣：

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      int i = 0;
   
      while ( i < 5 ) {
         System.out.println("Hello, World!");
         i = i + 1;
      }
   }
}

Java程式設計中的break和continue語句的工作方式與C程式設計中的工作方式完全相同。

Python中的迴圈

以下是使用Python編寫的等效程式。Python也支援while和do...while迴圈。以下程式列印Hello, World!五次，就像我們在C程式設計中所做的那樣。在這裡，您必須注意，Python不使用花括號來表示迴圈體，而是簡單地使用語句的縮排識別迴圈體。

您可以嘗試執行以下程式以檢視輸出。為了顯示差異，我們使用了另一個print語句，該語句將在迴圈結束後執行。

i = 0

while (i < 5):
   print "Hello, World!"
   i = i + 1
print "Loop ends"

當執行上述程式時，它會產生以下結果：

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Loop ends

Python中的break和continue語句的工作方式與C程式設計中的工作方式完全相同。

計算機程式設計 - 數字

每種程式語言都提供對操作不同型別數字的支援，例如簡單的整數和浮點數。C、Java和Python根據數字的性質將這些數字分為幾類。

讓我們回到並檢查資料型別章節，我們在其中列出了與數字相關的核心資料型別：

這些資料型別稱為基本資料型別，您可以使用這些資料型別來構建更多資料型別，這些資料型別稱為使用者定義資料型別。

在討論運算子時，我們已經看到了對數字的各種數學和邏輯運算。所以我們知道如何加數字、減數字、除數字等等。

首先讓我們看看如何在C程式語言中列印各種型別的數字：

#include <stdio.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   s = 10;
   i = 1000;
   l = 1000000;
   f = 230.47;
   d = 30949.374;

   printf( "s: %d\n", s);
   printf( "i: %d\n", i);
   printf( "l: %ld\n", l);
   printf( "f: %.3f\n", f);
   printf( "d: %.3f\n", d);
}

其餘的編碼非常明顯，但我們使用了%.3f來列印float和double，這表示要列印小數點後的位數。當執行上述程式時，它會產生以下結果：

s: 10
i: 1000
l: 1000000
f: 230.470
d: 30949.374

數字的數學運算

下表列出了C程式語言中可用於各種重要數學計算的各種有用的內建數學函式。

例如，如果您想計算一個數字的平方根，例如2304，那麼您有一個內建函式可以計算平方根。

以下是一個簡單的示例，用於顯示一些數學運算。要利用這些函式，您需要在程式中包含數學標頭檔案<math.h>，就像您包含stdio.h一樣：

#include <stdio.h>
#include <math.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   printf( "sin(s): %f\n", sin(10));
   printf( "abs(i): %f\n", abs(1000));
   printf( "floor(f): %f\n", floor(230.47));
   printf( "sqrt(l): %f\n", sqrt(1000000));
   printf( "pow(d, 2): %f\n", pow(2.374, 2));
}

當執行上述程式時，它會產生以下結果：

sin(s): -0.544021
abs(i): -0.544021
floor(f): 230.000000
sqrt(l): 1000.000000
pow(d, 2): 5.635876

除了以上用法外，您還將在迴圈計數、標誌表示、C程式設計中的真假值中使用數字。

Java中的數字

以下是使用Java編寫的等效程式。Java提供了幾乎所有在C程式設計中提供的數字資料型別。

您可以嘗試執行以下程式以檢視輸出，該輸出與上述C示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      short  s;
      int    i;
      long   l;
      float  f;
      double d;

      s = 10;
      i = 1000;
      l = 1000000L;
      f = 230.47f;
      d = 30949.374;

      System.out.format( "s: %d\n", s);
      System.out.format( "i: %d\n", i);
      System.out.format( "l: %d\n", l);
      System.out.format( "f: %f\n", f);
      System.out.format( "d: %f\n", d);
   }
}

當執行上述程式時，它會產生以下結果：

s: 10
i: 1000
l: 1000000
f: 230.470001
d: 30949.374000

Java還提供了一系列用於數學計算的內建函式，您可以像在C程式設計中一樣使用它們。

Python中的數字

Python與C和Java略有不同；它將數字分為int、long、float和complex。以下是一些Python中數字的示例：

以下是使用Python編寫的等效程式：

s = 10
i = 1000
l = 1000000
f = 230.47
d = 30949.374

print "s: ", s
print "i: ", i
print "l: ", l
print "f: ", f
print "d: ", d

當執行上述程式時，它會產生以下結果：

s:  10
i:  1000
l:  1000000
f:  230.47
d:  30949.374

Python還提供了一系列用於數學計算的內建函式，您可以像在C程式設計中一樣使用它們。

計算機程式設計 - 字元

如果在計算機程式設計中使用數字很容易，那麼使用字元就更容易了。字元是簡單的字母，如a、b、c、d……、A、B、C、D……，但有一個例外。在計算機程式設計中，任何一位數字，如0、1、2……以及特殊字元，如$、%、+、-……等，也被視為字元，要在字元型別變數中分配它們，您只需將它們放在單引號中。例如，以下語句定義了一個字元型別變數ch，我們為其賦值'a'：

char ch = 'a';

這裡，ch是字元型別的變數，可以容納實現的字元集中的一個字元，而'a'稱為字元字面量或字元常量。不僅是a、b、c……，當任何數字，如1、2、3……或任何特殊字元，如!、@、#、#、$……放在單引號中時，它們將被視為字元字面量，並且可以分配給字元型別的變數，因此以下是一個有效的語句：

char ch = '1';

字元資料型別佔用8位記憶體，這意味著您可以在字元中儲存任何內容，其ASCII值介於-127到127之間，因此它可以容納256個不同的值中的任何一個。字元資料型別可以儲存鍵盤上提供的任何字元，包括特殊字元，如!、@、#、#、$、%、^、&、*、(、)、_、+、{、}等。

請注意，您只能在單引號中保留一個字母或一個數字，並且不允許在單引號中使用多個字母或數字。因此，以下語句在C程式設計中無效：

char ch1 = 'ab';
char ch2 = '10';

下面是一個簡單的示例，它展示瞭如何在C程式語言中定義、賦值和列印字元：

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = 'a';      
   ch2 = '1';
   ch3 = '$';
   ch4 = '+';  

   printf( "ch1: %c\n", ch1);
   printf( "ch2: %c\n", ch2);
   printf( "ch3: %c\n", ch3);
   printf( "ch4: %c\n", ch4);
}

這裡，我們使用%c來列印字元資料型別。當執行上述程式時，它會產生以下結果：

ch1: a
ch2: 1
ch3: $
ch4: +

轉義序列

許多程式語言都支援稱為轉義序列的概念。當字元字首為反斜槓(\)時，它稱為轉義序列，並且對編譯器具有特殊含義。例如，以下語句中的\n是一個有效字元，它被稱為換行符：

char ch = '\n';

這裡，字元n字首為反斜槓(\)，它具有特殊的含義，即換行，但請記住，反斜槓(\)僅對少數字符具有特殊含義。以下語句在C程式設計中不會傳達任何含義，它將被視為無效語句：

char ch = '\1';

下表列出了C程式語言中提供的轉義序列：

以下示例演示了編譯器如何在 print 語句中解釋轉義序列：

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = '\t';      
   ch2 = '\n';

   printf( "Test for tabspace %c and a newline %c will start here", ch1, ch2);
}

當執行上述程式時，它會產生以下結果：

Test for tabspace     and a newline 
will start here

Java 中的字元

以下是使用 Java 編寫的等效程式。Java 處理字元資料型別的方式與我們在 C 程式設計中看到的方式非常相似。但是，Java 為字元操作提供了額外的支援。

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述 C 示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      char  ch1;
      char  ch2;
      char  ch3;
      char  ch4;
   
      ch1 = 'a';      
      ch2 = '1';
      ch3 = '$';
      ch4 = '+';  

      System.out.format( "ch1: %c\n", ch1);
      System.out.format( "ch2: %c\n", ch2);
      System.out.format( "ch3: %c\n", ch3);
      System.out.format( "ch4: %c\n", ch4);
   }
}

當執行上述程式時，它會產生以下結果：

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Java 也以與你在 C 程式設計中使用相同的方式支援轉義序列。

Python 中的字元

Python 不支援任何字元資料型別，但所有字元都被視為字串，字串是字元序列。我們將在單獨的章節中學習字串。在 Python 中使用單個字元時，無需進行任何特殊安排。

以下是使用Python編寫的等效程式：

ch1 = 'a';      
ch2 = '1';
ch3 = '$';
ch4 = '+'; 

print "ch1: ", ch1
print "ch2: ", ch2
print "ch3: ", ch3
print "ch4: ", ch4

當執行上述程式時，它會產生以下結果：

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Python 以與你在 C 程式設計中使用相同的方式支援轉義序列。

計算機程式設計 - 陣列

假設我們需要儲存五個整數。如果我們使用程式設計的簡單變數和資料型別概念，那麼我們需要五個 int 資料型別的變數，程式將如下所示：

#include <stdio.h>

int main() {
   int number1;
   int number2;
   int number3;
   int number4;
   int number5;
   
   number1 = 10;      
   number2 = 20;   
   number3 = 30;   
   number4 = 40; 
   number5 = 50;     

   printf( "number1: %d\n", number1);
   printf( "number2: %d\n", number2);
   printf( "number3: %d\n", number3);
   printf( "number4: %d\n", number4);
   printf( "number5: %d\n", number5);
}

這很簡單，因為我們只需要儲存五個整數。現在假設我們必須儲存 5000 個整數。我們要使用 5000 個變數嗎？

為了處理這種情況，幾乎所有程式語言都提供了一個稱為 陣列的概念。陣列是一種資料結構，可以儲存相同資料型別的固定大小的元素集合。陣列用於儲存資料集合，但通常將其視為相同型別變數的集合更有用。

與其宣告單獨的變數，例如 number1、number2、...、number99，不如宣告一個整數型別的陣列變數 number，並使用 number1[0]、number1[1] 和 ...、number1[99] 來表示各個變數。這裡，0、1、2、.....99 是與 var 變數關聯的索引，它們用於表示陣列中可用的各個元素。

所有陣列都由連續的記憶體位置組成。最低地址對應於第一個元素，最高地址對應於最後一個元素。

建立陣列

要在 C 中建立陣列變數，程式設計師需要指定元素的型別以及要儲存在該陣列中的元素數量。下面是 C 程式設計中建立陣列的簡單語法：

type arrayName [ arraySize ];

這稱為一維陣列。arraySize 必須是大於零的整數常量，type 可以是任何有效的 C 資料型別。例如，現在要宣告一個名為 number 的 10 元素陣列，其型別為 int，請使用以下語句：

int number[10];

這裡，number 是一個數組變數，足以容納最多 10 個整數。

初始化陣列

你可以在 C 中逐個初始化陣列，也可以使用以下單個語句進行初始化：

int number[5] = {10, 20, 30, 40, 50};

花括號 { } 中的值的數量不能大於我們在方括號 [ ] 中為陣列宣告的元素的數量。

如果你省略陣列的大小，則會建立一個足夠大的陣列來容納初始化。因此，如果你編寫：

int number[] = {10, 20, 30, 40, 50};

你將建立與前面示例中完全相同的陣列。以下是如何為陣列分配單個元素的示例：

number[4] = 50;

上述語句將陣列中的第 5 個元素賦值為 50。所有陣列的第一個元素的索引都為 0，也稱為基索引，陣列的最後一個索引將是陣列的總大小減 1。下圖顯示了我們上面討論的陣列的圖形表示：

訪問陣列元素

透過索引陣列名稱來訪問元素。這是透過在陣列名稱後面方括號中放置元素的索引來完成的。例如：

int var = number[9];

上述語句將從陣列中獲取第 10 個元素並將該值賦給 var 變數。以下示例使用了上述所有三個概念，即建立、賦值和訪問陣列：

#include <stdio.h>
 
int main () {
   int number[10]; /* number is an array of 10 integers */
   int i = 0;
 
   /* Initialize elements of array n to 0 */         
   while( i < 10 ) {
	
      /* Set element at location i to i + 100 */
      number[ i ] = i + 100;
      i = i + 1;
   }
   
   /* Output each array element's value */
   i = 0;
   while( i < 10 ) {
	
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
   
   return 0;
}

當以上程式碼編譯並執行時，會產生以下結果：

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

Java 中的陣列

以下是使用 Java 編寫的等效程式。Java 支援陣列，但它們在 Java 中使用 new 運算子建立的方式略有不同。

您可以嘗試執行以下程式以檢視輸出，該輸出必須與上述 C 示例生成的輸出相同。

public class DemoJava {
   public static void main(String []args) {
      int[] number = new int[10];
      int i = 0;
      
      while( i < 10 ) {
		
         number[ i ] = i + 100;
         i = i + 1;
      }

      i = 0;
      while( i < 10 ) {
         System.out.format( "number[%d] = %d\n", i, number[i] );
         i = i + 1;
      }
   }
}

當執行上述程式時，它會產生以下結果：

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

Python 中的陣列（列表）

Python 沒有陣列的概念，而是提供了另一種稱為 列表的資料結構，它提供了與任何其他語言中的陣列類似的功能。

以下是使用Python編寫的等效程式：

# Following defines an empty list.
number = []
i = 0

while i < 10:
   # Appending elements in the list
   number.append(i + 100)
   i = i + 1

i = 0
while i < 10:
   # Accessing elements from the list
   print "number[", i,  "] = ", number[ i ]
   i = i + 1

當執行上述程式時，它會產生以下結果：

number[ 0 ] =  100
number[ 1 ] =  101
number[ 2 ] =  102
number[ 3 ] =  103
number[ 4 ] =  104
number[ 5 ] =  105
number[ 6 ] =  106
number[ 7 ] =  107
number[ 8 ] =  108
number[ 9 ] =  109

計算機程式設計 - 字串

在我們關於字元的討論中，我們瞭解到字元資料型別處理單個字元，你可以將鍵盤上的任何字元賦給字元型別變數。

現在，讓我們稍微深入一點，考慮一種需要在變數中儲存多個字元的情況。我們已經看到 C 程式設計不允許在字元型別變數中儲存多個字元。因此，以下語句在 C 程式設計中無效，並且會產生語法錯誤：

char ch1 = 'ab';
char ch2 = '10';

我們還了解了如何使用陣列的概念在變數中儲存多個相同資料型別的值。以下是儲存和列印 int 型別陣列中的五個數字的語法：

#include <stdio.h>

main() {
   int number[5] = {10, 20, 30, 40, 50};
   int i = 0;
        
   while( i < 5 ) {
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
}

當以上程式碼編譯並執行時，會產生以下結果：

number[0] = 10
number[1] = 20
number[2] = 30
number[3] = 40
number[4] = 50

現在，讓我們以與數字相同的方式定義一個包含五個字元的陣列，並嘗試列印它們：

#include <stdio.h>

main() {
   char ch[5] = {'H', 'e', 'l', 'l', 'o'};
   int i = 0;
        
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

這裡，我們使用 %c 列印字元值。當以上程式碼編譯並執行時，會產生以下結果：

ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

如果你完成了以上示例，那麼我認為你已經理解了 C 程式設計中字串的工作原理，因為C 中的字串表示為字元陣列。C 程式設計簡化了字串的賦值和列印。讓我們再次檢查同一個示例，使用簡化的語法：

#include <stdio.h>

main() {
   char ch[5] = "Hello";
   int i = 0;
    
   /* Print as a complete string */
   printf("String = %s\n", ch);  

   /* Print character by character */
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

這裡，我們使用 %s 使用陣列名稱 ch 列印完整的字串值，ch 實際上是儲存 ch 變數的記憶體地址的開頭，如下所示：

儘管從以上示例中看不出來，但 C 程式在內部將空字元 '\0' 作為每個字串的最後一個字元。它表示字串的結尾，這意味著如果你想在陣列中儲存一個 5 個字元的字串，那麼最好將陣列大小定義為 6，儘管 C 不會對此報錯。

如果以上程式碼編譯並執行，會產生以下結果：

String = Hello
ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

基本字串概念

根據以上討論，我們可以得出關於 C 程式語言中字串的一些重要結論：

• C 中的字串表示為字元陣列。

• 我們可以透過將字元逐個分配到字元陣列中來構成 C 程式設計中的字串。

• 我們可以透過分配用雙引號括起來的完整字串來構成 C 程式設計中的字串。

• 我們可以使用陣列下標逐個列印字串字元，或者使用不帶下標的陣列名稱列印完整字串。

• 每個字串的最後一個字元都是空字元，即 ‘\0’。

• 大多數程式語言都提供內建函式來操作字串，即你可以連線字串、搜尋字串、從字串中提取子字串等。更多資訊，你可以檢視我們關於 C 程式設計或任何其他程式語言的詳細教程。

Java 中的字串

雖然你可以使用字元陣列來儲存字串，但 Java 是一種高階程式語言，其設計者試圖提供額外的功能。Java 將字串作為與其他資料型別相同的內建資料型別提供。這意味著你可以直接定義字串，而不是將其定義為字元陣列。

以下是使用 Java 編寫的等效程式。Java 使用 new 運算子建立字串變數，如以下程式所示。

您可以嘗試執行以下程式以檢視輸出 -

public class DemoJava {
   public static void main(String []args) {
      String str = new String("Hello");  
      System.out.println( "String = " + str );
   }
}

當執行上述程式時，它會產生以下結果：

String = Hello

Python 中的字串

在 Python 中建立字串就像使用單引號或雙引號將字串分配給 Python 變數一樣簡單。

下面是一個簡單的程式，它建立兩個字串並使用 print() 函式列印它們：

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1 = ", var1
print "var2 = ", var2

當執行上述程式時，它會產生以下結果：

var1 =  Hello World!
var2 =  Python Programming

Python 不支援字元型別；這些被視為長度為一的字串，因此也被視為子字串。

要訪問子字串，請使用方括號進行切片，以及索引或索引來獲取子字串。請檢視以下程式碼段：

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

當以上程式碼執行時，會產生以下結果：

var1[0]:  H
var2[1:5]:  ytho

計算機程式設計 - 函式

函式是一塊組織良好的、可重用的程式碼，用於執行單個相關的操作。函式為你的應用程式提供了更好的模組化和高度的程式碼重用。你已經看到了各種函式，例如 printf() 和 main()。這些是語言本身提供的內建函式，但我們也可以編寫自己的函式，本教程將教你如何在 C 程式語言中編寫和使用這些函式。

函式的好處在於它們有很多名稱。不同的程式語言對它們的稱呼不同，例如函式、方法、子例程、過程等。如果你遇到任何此類術語，只需想象一下我們在本教程中將要討論的相同概念即可。

讓我們從一個程式開始，在這個程式中我們將定義兩個數字陣列，然後從每個陣列中找到最大的數字。以下是找出給定數字集中最大數字的步驟：

1. Get a list of numbers L1, L2, L3....LN
2. Assume L1 is the largest, Set max = L1
3. Take next number Li from the list and do the following
4.    If max is less than Li
5.       Set max = Li
6.    If Li is last number from the list then
7.       Print value stored in max and come out
8. Else prepeat same process starting from step 3

讓我們將以上程式翻譯成 C 程式語言：

#include <stdio.h>

int main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int i, max;
   
   /* Process first set of numbers available in set1[] */
   max = set1[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set1[i] ) {
         max = set1[i];
      }
      i = i + 1;
   }
   
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = set2[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set2[i] ) {
         max = set2[i];
      }
      i = i + 1;
   }
   printf("Max in second set = %d\n", max );
}

當以上程式碼編譯並執行時，會產生以下結果：

Max in first set = 50
Max in second set = 501

如果您理解了上面的例子，那麼理解為什麼我們需要函式就會變得很容易。在上面的例子中，只有兩組數字，set1 和 set2，但是考慮這樣一種情況，我們有 10 組或更多類似的數字集需要找出每組中的最大數字。在這種情況下，我們將不得不重複處理 10 次或更多次，最終程式將變得太大，並且程式碼重複。為了處理這種情況，我們編寫函式，在函式中，我們嘗試保留將在我們的程式設計中反覆使用的原始碼。

現在，讓我們看看如何在 C 程式語言中定義一個函式，然後在後續章節中，我們將解釋如何使用它們。

定義函式

C 程式語言中函式定義的一般形式如下所示：

return_type function_name( parameter list ) {
   body of the function
   
   return [expression];
}

C 程式語言中的函式定義由一個函式頭和一個函式體組成。以下是函式的所有部分：

• 返回型別 - 函式可能會返回值。return_type 是函式返回值的資料型別。有些函式執行所需的運算而不返回值。在這種情況下，return_type 是關鍵字void。

• 函式名稱 - 這是函式的實際名稱。函式名稱和引數列表共同構成函式簽名。

• 引數列表 - 引數就像一個佔位符。當呼叫函式時，您將值作為引數傳遞。此值稱為實際引數或實參。引數列表指的是函式的引數的型別、順序和數量。引數是可選的；也就是說，函式可能不包含任何引數。

• 函式體 - 函式體包含定義函式作用的一組語句。

呼叫函式

在建立 C 函式時，您會給出函式必須執行的操作的定義。要使用函式，您必須呼叫該函式以執行定義的任務。

現在，讓我們使用函式編寫上面的例子：

#include <stdio.h>

int getMax( int set[] ) {
   int i, max;
   
   max = set[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set[i] ) {
         max = set[i];
      }
      i = i + 1;
   }
   return max;
}
main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int max;

   /* Process first set of numbers available in set1[] */
   max = getMax(set1);
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = getMax(set2);
   printf("Max in second set = %d\n", max );
}

當以上程式碼編譯並執行時，會產生以下結果：

Max in first set = 50
Max in second set = 501

Java 中的函式

如果您瞭解 C 程式設計中的函式，那麼在 Java 中理解它們也很容易。Java 程式設計將它們命名為方法，但其餘的概念或多或少保持不變。

以下是 Java 中編寫的等效程式。您可以嘗試執行它以檢視輸出：

public class DemoJava {
   public static void main(String []args) {
      int[] set1 = {10, 20, 30, 40, 50};
      int[] set2 = {101, 201, 301, 401, 501};
      int max;

      /* Process first set of numbers available in set1[] */
      max = getMax(set1);
      System.out.format("Max in first set = %d\n", max );

      /* Now process second set of numbers available in set2[] */
      max = getMax(set2);
      System.out.format("Max in second set = %d\n", max );
   }
   public static int getMax( int set[] ) {
      int i, max;
      max = set[0];
      i = 1;    
      
      while( i < 5 ) {
         if( max <  set[i] ) {
            max = set[i];
         }
         i = i + 1;
      }
      return max;
   }
}

當執行上述程式時，它會產生以下結果：

Max in first set = 50
Max in second set = 501

Python 中的函式

再次，如果您瞭解 C 和 Java 程式設計中的函式概念，那麼 Python 並沒有太大區別。下面是 Python 中定義函式的基本語法：

def function_name( parameter list ):
   body of the function
   
   return [expression]

使用 Python 中的此函式語法，上面的示例可以寫成如下：

def getMax( set ):
   max = set[0]
   i = 1   
   
   while( i < 5 ):
      if( max <  set[i] ):
         max = set[i]
      
      i = i + 1
   return max

set1 = [10, 20, 30, 40, 50]
set2 = [101, 201, 301, 401, 501]

# Process first set of numbers available in set1[]
max = getMax(set1)
print "Max in first set = ", max
    
# Now process second set of numbers available in set2[]
max = getMax(set2)
print "Max in second set = ", max

當以上程式碼執行時，會產生以下結果：

Max in first set =  50
Max in second set =  501

計算機程式設計 - 檔案I/O

計算機檔案

計算機檔案用於以數字格式儲存資料，例如純文字、影像資料或任何其他內容。計算機檔案可以組織在不同的目錄中。檔案用於儲存數字資料，而目錄用於儲存檔案。

計算機檔案可以被視為紙質文件的數字對應物。在程式設計時，您將原始碼儲存在具有不同副檔名的文字檔案中，例如，C 程式設計檔案以副檔名.c結尾，Java 程式設計檔案以.java結尾，Python 檔案以.py結尾。

檔案輸入/輸出

通常，您使用文字編輯器（如記事本、MS Word、MS Excel 或 MS Powerpoint 等）建立檔案。但是，很多時候，我們也需要使用計算機程式建立檔案。我們可以使用計算機程式修改現有檔案。

檔案輸入是指寫入檔案的資料，檔案輸出是指從檔案讀取的資料。實際上，輸入和輸出術語更多地與螢幕輸入和輸出相關。當我們在螢幕上顯示結果時，稱為輸出。類似地，如果我們從命令提示符向程式提供一些輸入，則稱為輸入。

現在，記住寫入檔案是檔案輸入，從檔案讀取是檔案輸出就足夠了。

檔案操作模式

在我們使用計算機程式處理任何檔案之前，我們需要建立一個新檔案（如果它不存在）或開啟一個已經存在的檔案。在這兩種情況下，我們都可以以下列模式開啟檔案：

• 只讀模式 - 如果您只想讀取現有檔案並且不想在檔案中寫入任何其他內容，則將以只讀模式開啟檔案。幾乎所有程式語言都提供以只讀模式開啟檔案的語法。

• 只寫模式 - 如果您要寫入現有檔案或新建立的檔案，但不想從該檔案讀取任何寫入的內容，則將以只寫模式開啟檔案。所有程式語言都提供以只寫模式開啟檔案的語法。

• 讀寫模式 - 如果您要讀取和寫入同一檔案，則將以讀寫模式開啟檔案。

• 追加模式 - 當您開啟檔案進行寫入時，它允許您從檔案開頭開始寫入；但是，它會覆蓋任何現有內容（如果有）。假設我們不想覆蓋任何現有內容，那麼我們將以追加模式開啟檔案。追加模式最終是一種寫入模式，它允許在檔案末尾追加內容。幾乎所有程式語言都提供以追加模式開啟檔案的語法。

在以下章節中，我們將學習如何開啟一個新的檔案、如何向其中寫入內容，以及隨後如何讀取和追加更多內容到同一檔案中。

開啟檔案

您可以使用fopen()函式建立新檔案或開啟現有檔案。此呼叫將初始化型別為FILE的物件，其中包含控制流所需的所有資訊。以下是此函式呼叫的原型，即簽名：

FILE *fopen( const char * filename, const char * mode );

這裡，filename 是字串文字，您將使用它來命名您的檔案，並且access mode 可以具有以下值之一：

關閉檔案

要關閉檔案，請使用fclose( )函式。此函式的原型為：

 int fclose( FILE *fp );

fclose( )函式在成功時返回零，或者如果關閉檔案時出錯，則返回EOF特殊字元。此函式實際上將緩衝區中仍掛起的所有資料重新整理到檔案，關閉檔案，並釋放用於檔案的任何記憶體。EOF 是在標頭檔案stdio.h中定義的常量。

C 標準庫提供了各種函式來逐個字元或以固定長度字串的形式讀取和寫入檔案。讓我們在下一節中瞭解其中的一些函式。

寫入檔案

以下是將單個字元寫入流的最簡單函式：

int fputc( int c, FILE *fp );

fputc()函式將引數 c 的字元值寫入fp引用的輸出流。如果成功，它將返回寫入的字元，否則如果出錯，則返回EOF。您可以使用以下函式將以 null 結尾的字串寫入流：

int fputs( const char *s, FILE *fp );

fputs()函式將字串s寫入fp引用的檔案。如果成功，它將返回一個非負值，否則如果發生任何錯誤，則返回EOF。您還可以使用函式int fprintf(FILE *fp,const char *format, ...)將字串寫入檔案。嘗試以下示例：

#include <stdio.h>

int main() {
   FILE *fp;

   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}

當編譯並執行上述程式碼時，它將在/tmp目錄中建立一個名為test.txt的新檔案，並使用兩個不同的函式寫入兩行。讓我們在下一節中讀取此檔案。

讀取檔案

以下是逐個字元讀取文字檔案的最簡單函式：

int fgetc( FILE * fp );

fgetc()函式從fp引用的輸入檔案讀取一個字元。返回值是讀取的字元；或者如果發生任何錯誤，則返回EOF。以下函式允許您從流中讀取字串：

char *fgets( char *buf, int n, FILE *fp );

fgets()函式從fp引用的輸入流中讀取最多 n - 1 個字元。它將讀取的字串複製到緩衝區buf中，並附加一個null字元以終止字串。

如果此函式在讀取最大字元數之前遇到換行符'\n'或 EOF，則它只返回讀取到該點的字元，包括換行符。您還可以使用int fscanf(FILE *fp, const char *format, ...)從檔案讀取字串，但它會在遇到第一個空格字元後停止讀取。

#include <stdio.h>

main() {

   FILE *fp;
   char buff[255];

   fp = fopen("/tmp/test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1 : %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("2: %s\n", buff );
   
   fgets(buff, 255, (FILE*)fp);
   printf("3: %s\n", buff );
   fclose(fp);
}

當編譯並執行上述程式碼時，它會讀取上一節中建立的檔案併產生以下結果：

1 : This
2 : is testing for fprintf...

3 : This is testing for fputs...

讓我們分析一下這裡發生了什麼。首先，fscanf()方法讀取This，因為之後它遇到了一個空格。第二個呼叫用於fgets()，它讀取剩餘的行直到遇到行尾。最後，最後一個呼叫fgets()完全讀取第二行。

Java 中的檔案 I/O

Java 提供了更豐富的函式集來處理檔案 I/O。有關此主題的更多資訊，我們建議您檢視我們的 Java 教程。

在這裡，我們將看到一個簡單的 Java 程式，它等效於上面解釋的 C 程式。此程式將開啟一個文字檔案，向其中寫入幾行文字，然後關閉檔案。最後，開啟同一個檔案，然後從已建立的檔案中讀取。您可以嘗試執行以下程式以檢視輸出：

import java.io.*;

public class DemoJava {
   public static void main(String []args) throws IOException {
      File file = new File("/tmp/java.txt");
      
      // Create a File
      file.createNewFile();
      
      //  Creates a FileWriter Object using file object
      FileWriter writer = new FileWriter(file); 
      
      // Writes the content to the file
      writer.write("This is testing for Java write...\n");
      writer.write("This is second line...\n");
      
      // Flush the memory and close the file
      writer.flush();
      writer.close();
      
      // Creates a FileReader Object
      FileReader reader = new FileReader(file); 
      char [] a = new char[100];
      
      // Read file content in the array
      reader.read(a);
      System.out.println( a );
      
      // Close the file
      reader.close();
   }
}

當執行上述程式時，它會產生以下結果：

This is testing for Java write...
This is second line...

Python 中的檔案 I/O

以下程式顯示了相同的功能，用於開啟一個新檔案，向其中寫入一些內容，最後讀取同一個檔案：

# Create a new file
fo = open("/tmp/python.txt", "w")

# Writes the content to the file
fo.write( "This is testing for Python write...\n");
fo.write( "This is second line...\n");

# Close the file
fo.close()

# Open existing file
fo = open("/tmp/python.txt", "r")

# Read file content in a variable
str = fo.read(100);
print str

# Close opened file
fo.close()

當以上程式碼執行時，會產生以下結果：

This is testing for Python write...
This is second line...

計算機程式設計 - 總結

感謝您耐心閱讀本教程。我們試圖保持簡潔，但由於本主題包含多個主題，因此我們詳細展示了一些示例。

如果您沒有理解任何概念，那麼我們建議您再次閱讀本教程，並且一旦您對本教程中解釋的概念感到滿意，您就可以繼續學習。

還有許多其他與計算機程式設計相關的主題，我們有意沒有涵蓋，以避免任何混淆，但我們相信只要您對本教程中解釋的概念感到滿意，這些概念就不會難以理解。

在 tutorialspoint，我們投入了大量精力來準備關於 C、Java 和 Python 程式語言的全面教程，我們強烈建議您在完成本教程後開始學習其中任何一種。

請與我們分享您對本教程的看法，在主題行中提及教程名稱，傳送至webmaster@tutorialspoint.com。如果您有任何建議可以進一步改進本教程，我們非常樂意收到您的反饋。