❶ c語言 對文件進行操作的三個主要過程是
C語言對文件進行操作的三個主要過程是：打開文件、操作文件、關閉文件。
C語言的文件處理功能依據系統是否設置「緩沖區」分為兩種：一種是設置緩沖區，另一種是不設置緩沖區。
由於不設置緩沖區的文件處理方式，必須使用較低級的I/O函數(包含在頭文件io.h和fcntl.h中)來直接對磁碟存取，這種方式的存取速度慢，並且由於不是C的標准函數，跨平台操作時容易出問題。
(1)c語言文件使用的順序擴展閱讀
C語言文件有不同的類型，在程序設計中，主要用到兩種文件：
（1）程序文件：包括源程序文件(後綴為.c)、目標文件(後綴為.obj)、可執行文件(後綴為.exe)等。這種文件的內容是程序代碼。
（2）數據文件：文件的內容不是程序，而是供程序運行時讀寫的數據，如在程序運行過程中輸出到磁碟(或其他外部設備)的數據，或在程序運行過程中供讀入的數據。如一批學生的成績數據、貨物交易的數據等。
為了簡化用戶對輸入輸出設備的操作，使用戶不必去區分各種輸入輸出設備之間的區別，操作系統把各種設備都統一作為文件來處理。從操作系統的角度看，每一個與主機相連的輸入輸出設備都看作一個文件。例如，終端鍵盤是輸入文件，顯示屏和列印機是輸出文件。
輸入輸出是數據傳送的過程，數據如流水一樣從一處流向另一處，因此常將輸入輸出形象地稱為流(stream)，即數據流。流表示了信息從源到目的端的流動。在輸入操作時，數據從文件流向計算機內存，在輸出操作時，數據從計算機流向文件(如列印機、磁碟文件)。
C的數據文件由一連串的字元（或位元組）組成，而不考慮行的界限，兩行數據間不會自動加分隔符，對文件的存取是以字元（位元組）為單位的。輸入輸出數據流的開始和結束僅受程序控制而不受物理符號（如回車換行符）控制，這就增加了處理的靈活性。
❷ 關於C語言程序的執行順序
1.
最開始a=0.000000；
2.
C語言從main()函數開始執行，如果在main()函數中不調用test()，那麼test()就不執行。
3.
假設調用了test()函數，那麼要等timer函數執行完之後才開始執行a
=
k
+
i
。
4.
假設調用了timer()函數，只是要循環100次，並不是100個時鍾周期。
❸ C語言實現文件排序
常見排序演算法（冒泡，選擇，快速）的C語言實現
要實現這幾種演算法的關鍵是要熟悉演算法的思想。簡單的說，冒泡排序，就如名字說的，每經過一輪排序，將最大的數沉到最底部。選擇排序的思想是將整個數列，分為有序區和無序區。每輪排序，將無序區里的最小數移入到有序區。快速排序的思想是以一個數為中心，通常這個數是該數列第一個數，將整個數列分為兩個部分，一個部分是大於這個數的區域，一個部分是小於這個數的區域。然後再對這兩個部分的數列分別排序。如果將數列分為兩個部分是通過，一方面從後向前的搜索，另一方面從前向後的搜索來實現的。具體的參考後面的來自網路的文檔。
從這幾個簡單的排序演算法上看，有幾個特點：
冒泡排序是最簡單的，也是最穩定的演算法。
選擇排序不太穩定，但是效率上較冒泡還是有較大的提升。其實在分析的過程中就能發現，選擇排序和冒泡排序相比，中間少了很多的交換過程，和比較的次數，這個應該是時間較少的原因。選擇排序能夠滿足一般的使用。當比較的數超過以萬為單位時，選擇排序也還是要一點時間的。
快速排序據說是最快的。這個可以從思想上看的出來。，當記錄較多的時候，快速排序的比較循環次數比上面2個都要少。但是在具體的實現過程中，並不見得如此。這是因為遞歸效率的低下導致的。當然，估計在實際使用過的過程，快速排序估計都會使用非遞歸操作棧的方式來實現。那樣應該會效率高傷不少。估計我會在後期出一個快速排序的非遞歸實現來真正比較它們3個性能。在下面的程序中，可以通過調高N的數字就能看的出來冒泡排序和選擇排序性能的差異。在N較小，大概幾百的時候，是看不出來的。N較大的的時候，比如N=1000或者N=10000的時候，快速排序的遞歸實現就會卡死在那裡了，出不了結果。
以下是具體的代碼：
/*
** 常見排序演算法比較
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define N 10
#define Demo 1
void BubbleSort(int arr[], int n);
void SelectSort(int arr[], int n);
void QuickSort(int arr[], int n);
void PrintArray(int arr[], int n);
void GenerateArray(int arr[], int n);
int main(int argc, char *argv[])
{
int arr[N];
GenerateArray(arr, N);
#if Demo
printf("Before the bubble sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start Bubble sort----------------------\n");
clock_t start_time1=clock(); //開始計時
BubbleSort(arr, N);
clock_t end_time1=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time1-start_time1)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the bubble sort------------------------\n");
PrintArray(arr, N);
#endif
printf("-----------------------------------------------------------\n");
sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf("Before the selection sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start selection sort----------------------\n");
clock_t start_time2=clock(); //開始計時
SelectSort(arr, N);
clock_t end_time2=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time2-start_time2)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the selection sort------------------------\n");
PrintArray(arr, N);
#endif
printf("-----------------------------------------------------------\n");
sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf("Before the quick sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start quick sort----------------------\n");
clock_t start_time3=clock(); //開始計時
QuickSort(arr, N);
clock_t end_time3=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time3-start_time3)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the quick sort------------------------\n");
PrintArray(arr, N);
#endif
system("PAUSE");
return 0;
}
// 產生隨機列表
void GenerateArray(int arr[], int n)
{
int i;
srand((unsigned)time(0));
for(i = 0; i <N; i++)
{
arr[i] = rand(); // 生成隨機數 范圍在0-32767之間
}
}
// 列印列表
void PrintArray(int arr[], int n)
{
int i = 0;
for(i = 0; i < n; i++)
printf("%6d", arr[i]);
printf("\n");
}
// 經典冒泡排序
void BubbleSort(int arr[], int n)
{
int i = 0, j =0;
for(i = 0; i < n; i++)
for(j = 0; j < n - 1 - i; j++)
{
if(arr[j] > arr[j + 1])
{
arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[j] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j+1];
}
}
}
// 快速排序的遞歸實現
void QuickSort(int arr[], int n)
{
if(n <= 1)
return;
int i =0 , j = n - 1;
int key = arr[0];
int index = 0;
while(i < j)
{
// 從後向前搜索
while(j > i && arr[j] > key)
j--;
if(j == i)
break;
else
{
//交換 a[j] a[i]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = j;
}
// 從前向後搜索
while(i < j && arr[i] <key)
i++;
if(i == j)
break;
else
{
// 交換 a[i] a[j]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = i;
}
}
QuickSort(arr, index);
QuickSort(arr + index + 1, n - 1 - index);
}
// 選擇排序
void SelectSort(int arr[], int n)
{
int i, j;
int min;
for(i = 0; i < n - 1; i++)
{
int index = 0;
min = arr[i];
for(j = i + 1; j < n; j++) //找出 i+1 - n 無序區的最小者與arr[i]交換
{
if(arr[j] < min)
{
min = arr[j];
index = j;
}
}
if(index != 0) //表明無序區有比arr[i]小的元素
{
arr[i] = arr[i]^arr[index];
arr[index] = arr[i]^arr[index];
arr[i] = arr[i]^arr[index];
}
}
}
程序里有幾點注意的地方：
一，在程序里，交換2個數，我使用了異或來處理。這個可以根據個人喜好。為了避免產生臨時變數，可以使用如下幾種方式來交換2個數：
a=a^b;
b=a^b;
a=a^b;
或者
a=a+b;
b=a-b;
a=a-b;
使用第二種也挺好的。第一種異或的方式，只適用於，2個數都為int型的，a,b可以正可以負，這個沒有關系，但是必須是int類型。
二， sleep()函數是包含在windows.h裡面的，要加入 #include <window.h>
三， 關於隨機數生成的2個函數 srand()種子發生器函數，還有rand()隨機數生成器函數，自己可以參考相關文檔。
四， Demo宏來控制是演示還是比較性能用的。當把N調整的很小，比如10的時候，可以設置Demo為1，那樣就能列印數組了，可以看到比較前後的情況。當把N調整到很大比如10000的時候，就把Demo設置為0，那樣就不列印數組，直接比較性能。
具體的演算法文檔參考下面的：
冒泡排序
基本概念
冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。
用二重循環實現，外循環變數設為i，內循環變數設為j。外循環重復9次，內循環依次重復9，8，...，1次。每次進行比較的兩個元素都是與內循環j有關的，它們可以分別用a[j]和a[j+1]標識，i的值依次為1,2,...,9，對於每一個i, j的值依次為1,2,...10-i。
產生
在許多程序設計中，我們需要將一個數列進行排序，以方便統計，而冒泡排序一直由於其簡潔的思想方法而倍受青睞。
排序過程
設想被排序的數組R［1..N］垂直豎立，將每個數據元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R，凡掃描到違反本原則的輕氣泡，就使其向上"漂浮"，如此反復進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
演算法示例
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟冒泡排序過程
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 76 97 13 27
38 49 65 76 13 97 27
38 49 65 76 13 27 97 – 這是第一趟冒泡排序完的結果
第二趟也是重復上面的過程，只不過不需要比較最後那個數97，因為它已經是最大的
38 49 65 13 27 76 97 – 這是結果
第三趟繼續重復，但是不需要比較倒數2個數了
38 49 13 27 65 76 97
….
選擇排序
基本思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1趟排序
在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n-1)。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。
常見的選擇排序細分為簡單選擇排序、樹形選擇排序（錦標賽排序）、堆排序。上述演算法僅是簡單選擇排序的步驟。
排序過程
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟排序後 13 ［38 65 97 76 49 27]
第二趟排序後 13 27 ［65 97 76 49 38]
第三趟排序後 13 27 38 [97 76 49 65]
第四趟排序後 13 27 38 49 [76 97 65]
第五趟排序後 13 27 38 49 65 [97 76]
第六趟排序後 13 27 38 49 65 76 [97]
最後排序結果 13 27 38 49 49 65 76 97
快速排序演算法
演算法過程
設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。一趟快速排序的演算法是：
1）設置兩個變數I、J，排序開始的時候：I=0，J=N-1；
2）以第一個數組元素作為關鍵數據，賦值給key，即 key=A[0]；
3）從J開始向前搜索，即由後開始向前搜索（J=J-1），找到第一個小於key的值A[J]，並與A[I]交換；
4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於key的A[I]，與A[J]交換；
5）重復第3、4、5步，直到 I=J； (3,4步是在程序中沒找到時候j=j-1，i=i+1，直至找到為止。找到並交換的時候i， j指針位置不變。另外當i=j這過程一定正好是i+或j+完成的最後另循環結束)
例如：待排序的數組A的值分別是：（初始關鍵數據：X=49） 注意關鍵X永遠不變，永遠是和X進行比較，無論在什麼位子，最後的目的就是把X放在中間，小的放前面大的放後面。
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
進行第一次交換後： 27 38 65 97 76 13 49
( 按照演算法的第三步從後面開始找)
進行第二次交換後： 27 38 49 97 76 13 65
( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時：I=3 )
進行第三次交換後： 27 38 13 97 76 49 65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找
進行第四次交換後： 27 38 13 49 76 97 65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時：I=4,J=6 )
此時再執行第三步的時候就發現I=J，從而結束一趟快速排序，那麼經過一趟快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。
快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：
初始狀態 {49 38 65 97 76 13 27}
進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}
分別對前後兩部分進行快速排序 {27 38 13} 經第三步和第四步交換後變成 {13 27 38} 完成排序。
{76 97 65} 經第三步和第四步交換後變成 {65 76 97} 完成排序。
❹ C語言文件的編譯與執行的四個階段並分別描述
開發C程序有四個步驟：編輯、編譯、連接和運行。
任何一個體系結構處理器上都可以使用C語言程序，只要該體系結構處理器有相應的C語言編譯器和庫，那麼C源代碼就可以編譯並連接到目標二進制文件上運行。
1、預處理：導入源程序並保存（C文件）。
2、編譯：將源程序轉換為目標文件（Obj文件）。
3、鏈接：將目標文件生成為可執行文件（EXE文件）。
4、運行：執行，獲取運行結果的EXE文件。
(4)c語言文件使用的順序擴展閱讀：
將C語言代碼分為程序的幾個階段：
1、首先，源代碼文件測試。以及相關的頭文件，比如stdio。H、由預處理器CPP預處理為．I文件。預編譯的。文件不包含任何宏定義，因為所有宏都已展開，並且包含的文件已插入。我歸檔。
2、編譯過程是對預處理文件進行詞法分析、語法分析、語義分析和優化，生成相應的匯編代碼文件。這個過程往往是整個程序的核心部分，也是最復雜的部分之一。
3、匯編程序不直接輸出可執行文件，而是輸出目標文件。匯編程序可以調用LD來生成可以運行的可執行程序。也就是說，您需要鏈接大量的文件才能獲得「a.out」，即最終的可執行文件。
4、在鏈接過程中，需要重新調整其他目標文件中定義的函數調用指令，而其他目標文件中定義的變數也存在同樣的問題。