今天我們繼續(xù)來學習C語言的入門知識點，第一課：C/C++編程筆記：C語言入門知識點（二），請收藏C語言最全筆記！

21. 輸入 & 輸出

當我們提到輸入時，這意味著要向程序填充一些數(shù)據(jù)。輸入可以是以文件的形式或從命令行中進行。C 語言提供了一系列內(nèi)置的函數(shù)來讀取給定的輸入，并根據(jù)需要填充到程序中。

當我們提到輸出時，這意味著要在屏幕上、打印機上或任意文件中顯示一些數(shù)據(jù)。C 語言提供了一系列內(nèi)置的函數(shù)來輸出數(shù)據(jù)到計算機屏幕上和保存數(shù)據(jù)到文本文件或二進制文件中。

標準輸出

C 語言把所有的設備都當作文件。所以設備（比如顯示器）被處理的方式與文件相同。以下三個文件會在程序執(zhí)行時自動打開，以便訪問鍵盤和屏幕。

文件指針是訪問文件的方式，本節(jié)將講解如何從屏幕讀取值以及如何把結(jié)果輸出到屏幕上。

C 語言中的 I/O (輸入/輸出) 通常使用 printf() 和 scanf() 兩個函數(shù)。

scanf() 函數(shù)用于從標準輸入（鍵盤）讀取并格式化， printf() 函數(shù)發(fā)送格式化輸出到標準輸出（屏幕）。

例子：

void main(){

? ? ? float f;

? ? printf("Enter a float number: \n");

? ? // %f 匹配浮點型數(shù)據(jù)

? ? scanf("%f",&f);

? ? printf("Value = %f", f);

}

輸出：

Enter a float number:

12.3

Value = 12.300000

getchar()&putchar() 函數(shù)

int getchar(void)函數(shù)從屏幕讀取下一個可用的字符，并把它返回為一個整數(shù)。這個函數(shù)在同一個時間內(nèi)只會讀取一個單一的字符。您可以在循環(huán)內(nèi)使用這個方法，以便從屏幕上讀取多個字符。

int putchar(int c)函數(shù)把字符輸出到屏幕上，并返回相同的字符。這個函數(shù)在同一個時間內(nèi)只會輸出一個單一的字符。您可以在循環(huán)內(nèi)使用這個方法，以便在屏幕上輸出多個字符。

void main(){

? ? int c;

? ? printf( "\nEnter a value :");

? ? //函數(shù)從屏幕讀取下一個可用的字符，并把它返回為一個整數(shù)。這個函數(shù)在同一個時間內(nèi)只會讀取一個單一的字符。您可以在循環(huán)內(nèi)使用這個方法，以便從屏幕上讀取多個字符。

? ? c = getchar( );

? ? printf( "\nYou entered: ");

? ? //讀取第一個字符

? ? putchar( c );

}

輸出：

Enter a value :abcdef

You entered: a

gets() & puts() 函數(shù)

char *gets(char *s)函數(shù)從stdin讀取一行到s所指向的緩沖區(qū)，直到一個終止符或 EOF。

int puts(const char *s)函數(shù)把字符串 s 和一個尾隨的換行符寫入到stdout。

void main(){

? ? char str[100];

? ? printf( "\nEnter a value :");

? ? //讀取一行

? ? gets( str );

? ? printf( "\nYou entered: ");

? ? puts( str );

}

輸出：

Enter a value :大家好，才是真的好！

You entered: 大家好，才是真的好！

22. 文件讀寫

上一節(jié)我們講解了 C 語言處理的標準輸入和輸出設備。本章我們將介紹 C 程序員如何創(chuàng)建、打開、關閉文本文件或二進制文件。

一個文件，無論它是文本文件還是二進制文件，都是代表了一系列的字節(jié)。C 語言不僅提供了訪問頂層的函數(shù)，也提供了底層（OS）調(diào)用來處理存儲設備上的文件。本章將講解文件管理的重要調(diào)用。

打開文件

您可以使用fopen( )函數(shù)來創(chuàng)建一個新的文件或者打開一個已有的文件，這個調(diào)用會初始化類型FILE的一個對象，類型FILE包含了所有用來控制流的必要的信息。下面是這個函數(shù)調(diào)用的原型：

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

在這里，filename?是字符串，用來命名文件，訪問模式?mode?的值可以是下列值中的一個：

如果處理的是二進制文件，則需要使用下面的訪問模式來取代上面的訪問模式：

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

關閉文件

為了關閉文件，請使用 fclose( ) 函數(shù)。函數(shù)的原型如下：

int fclose( FILE *fp );

如果成功關閉文件，fclose( )函數(shù)返回零，如果關閉文件時發(fā)生錯誤，函數(shù)返回EOF。這個函數(shù)實際上，會清空緩沖區(qū)中的數(shù)據(jù)，關閉文件，并釋放用于該文件的所有內(nèi)存。EOF 是一個定義在頭文件stdio.h中的常量。

C 標準庫提供了各種函數(shù)來按字符或者以固定長度字符串的形式讀寫文件。

寫入文件

下面是把字符串寫入到流中的最簡單的函數(shù)：

int fputc(int c,FILE *fp);

函數(shù)?fputc()?把參數(shù) c 的字符值寫入到 fp 所指向的輸出流中。如果寫入成功，它會返回寫入的字符，如果發(fā)生錯誤，則會返回?EOF。您可以使用下面的函數(shù)來把一個以 null 結(jié)尾的字符串寫入到流中：

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

函數(shù)fputs()把字符串s寫入到 fp 所指向的輸出流中。如果寫入成功，它會返回一個非負值，如果發(fā)生錯誤，則會返回EOF。您也可以使用int fprintf(FILE *fp,const char *format, ...)函數(shù)來寫把一個字符串寫入到文件中。嘗試下面的實例：

void main(){

? ? ? //定義一個空指針文件

? ? FILE *fp = NULL;

? ? //打開文件，打開一個文本文件，允許讀寫文件。

? ? // 如果文件不存在，則會創(chuàng)建一個新文件。

? ? // 讀取會從文件的開頭開始，寫入則只能是追加模式。

? ? fp = fopen("/Users/devyk/Data/ClionProjects/NDK_Sample/README.md","a+");

? ? fprintf(fp, " fprintf 我是添加進來的1\n");

? ? fprintf(fp, "fprintf 我是添加進來的2\n");

? ? fputs("fputs 我是添加進來的1\n", fp);

? ? fputs("fputs 我是添加進來的2\n", fp);

? ? fclose(fp);

}

讀取文件

下面是從文件讀取單個字符的最簡單的函數(shù)：

int fgetc( FILE * fp );

fgetc()?函數(shù)從 fp 所指向的輸入文件中讀取一個字符。返回值是讀取的字符，如果發(fā)生錯誤則返回?EOF。下面的函數(shù)允許您從流中讀取一個字符串：

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

函數(shù)fgets()從 fp 所指向的輸入流中讀取 n - 1 個字符。它會把讀取的字符串復制到緩沖區(qū)buf，并在最后追加一個null字符來終止字符串。

如果這個函數(shù)在讀取最后一個字符之前就遇到一個換行符 '\n' 或文件的末尾 EOF，則只會返回讀取到的字符，包括換行符。您也可以使用int fscanf(FILE *fp, const char *format, ...)函數(shù)來從文件中讀取字符串，但是在遇到第一個空格和換行符時，它會停止讀取。

void main(){

? ? FILE *fp = NULL;

? ? //讀取文件

? ? char buff[255];

? ? fp = fopen("/Users/devyk/Data/ClionProjects/NDK_Sample/README.md","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);

}

23. 預處理器

C 預處理器不是編譯器的組成部分，但是它是編譯過程中一個單獨的步驟。簡言之，C 預處理器只不過是一個文本替換工具而已，它們會指示編譯器在實際編譯之前完成所需的預處理。我們將把 C 預處理器（C Preprocessor）簡寫為 CPP。

所有的預處理器命令都是以井號（#）開頭。它必須是第一個非空字符，為了增強可讀性，預處理器指令應從第一列開始。下面列出了所有重要的預處理器指令：

例子:

分析下面的實例來理解不同的指令。

#define MAX_ARRAY_LENGTH 20

（1）這個指令告訴 CPP 把所有的 MAX_ARRAY_LENGTH 替換為 20。使用?#define?定義常量來增強可讀性。

#include <stdio.h>

#include "utils.h"

（2）這些指令告訴 CPP 從系統(tǒng)庫中獲取 stdio.h，并添加文本到當前的源文件中。下一行告訴 CPP 從本地目錄中獲取?utils.h，并添加內(nèi)容到當前的源文件中。

#undef FILE_SIZE

#define FILE_SIZE 42

（3）這個指令告訴 CPP 取消已定義的 FILE_SIZE，并定義它為 42。

#ifndef MESSAGE

? #define MESSAGE "You wish!"

#endif

這個指令告訴 CPP 只有當 MESSAGE 未定義時，才定義 MESSAGE。

#ifdef DEBUG

? /* Your debugging statements here */

#endif

這個指令告訴 CPP 如果定義了 DEBUG，則執(zhí)行處理語句。在編譯時，如果您向 gcc 編譯器傳遞了-DDEBUG開關量，這個指令就非常有用。它定義了 DEBUG，您可以在編譯期間隨時開啟或關閉調(diào)試。

預定義宏

ANSI C 定義了許多宏。在編程中您可以使用這些宏，但是不能直接修改這些預定義的宏。

預處理器運算符

C 預處理器提供了下列的運算符來幫助您創(chuàng)建宏：

宏延續(xù)運算符()

一個宏通常寫在一個單行上。但是如果宏太長，一個單行容納不下，則使用宏延續(xù)運算符（\）。例如：

#define message_for(a, b) \

? ? printf(#a " and " #b ": We love you!\n")

字符串常量化運算符(#)

在宏定義中，當需要把一個宏的參數(shù)轉(zhuǎn)換為字符串常量時，則使用字符串常量化運算符（#）。在宏中使用的該運算符有一個特定的參數(shù)或參數(shù)列表。例如：

#include <stdio.h>

#define? message_for(a, b)? \

? ? printf(#a " and " #b ": We love you!\n")

int main(void)

{

? message_for(Carole, Debra);

? return 0;

}

當上面的代碼被編譯和執(zhí)行時，它會產(chǎn)生下列結(jié)果：

Carole and Debra: We love you!

標記粘貼運算符(##)

宏定義內(nèi)的標記粘貼運算符（##）會合并兩個參數(shù)。它允許在宏定義中兩個獨立的標記被合并為一個標記。例如：

#include <stdio.h>

#define tokenpaster(n) printf ("token" #n " = %d", token##n)

int main(void)

{

? int token34 = 40;

? tokenpaster(34);

? return 0;

}

當上面的代碼被編譯和執(zhí)行時，它會產(chǎn)生下列結(jié)果：

token34 = 40

這是怎么發(fā)生的，因為這個實例會從編譯器產(chǎn)生下列的實際輸出：

printf ("token34 = %d", token34);

這個實例演示了 token##n 會連接到 token34 中，在這里，我們使用了字符串常量化運算符（#）和標記粘貼運算符（##）。

defined() 運算符

預處理器defined運算符是用在常量表達式中的，用來確定一個標識符是否已經(jīng)使用 #define 定義過。如果指定的標識符已定義，則值為真（非零）。如果指定的標識符未定義，則值為假（零）。下面的實例演示了 defined() 運算符的用法：

#include <stdio.h>

#if !defined (MESSAGE)

? #define MESSAGE "You wish!"

#endif

int main(void)

{

? printf("Here is the message: %s\n", MESSAGE);?

? return 0;

}

當上面的代碼被編譯和執(zhí)行時，它會產(chǎn)生下列結(jié)果：

Here is the message: You wish!

參數(shù)化的宏

CPP 一個強大的功能是可以使用參數(shù)化的宏來模擬函數(shù)。例如，下面的代碼是計算一個數(shù)的平方：

int square(int x) {

? return x * x;

}

我們可以使用宏重寫上面的代碼，如下：

#define square(x) ((x) * (x))

在使用帶有參數(shù)的宏之前，必須使用?#define?指令定義。參數(shù)列表是括在圓括號內(nèi)，且必須緊跟在宏名稱的后邊。宏名稱和左圓括號之間不允許有空格。例如：

#include <stdio.h>

#define MAX(x,y) ((x) > (y) ? (x) : (y))

int main(void)

{

? printf("Max between 20 and 10 is %d\n", MAX(10, 20));?

? return 0;

}

當上面的代碼被編譯和執(zhí)行時，它會產(chǎn)生下列結(jié)果：

Max between 20 and 10 is 20

24. 頭文件

頭文件是擴展名為.h的文件，包含了 C 函數(shù)聲明和宏定義，被多個源文件中引用共享。有兩種類型的頭文件：程序員編寫的頭文件和編譯器自帶的頭文件。

在程序中要使用頭文件，需要使用 C 預處理指令#include來引用它。前面我們已經(jīng)看過stdio.h頭文件，它是編譯器自帶的頭文件。

引用頭文件相當于復制頭文件的內(nèi)容，但是我們不會直接在源文件中復制頭文件的內(nèi)容，因為這么做很容易出錯，特別在程序是由多個源文件組成的時候。

A simple practice in C 或 C++ 程序中，建議把所有的常量、宏、系統(tǒng)全局變量和函數(shù)原型寫在頭文件中，在需要的時候隨時引用這些頭文件。

引用頭文件的語法

使用預處理指令#include可以引用用戶和系統(tǒng)頭文件。它的形式有以下兩種：

#include <file>

這種形式用于引用系統(tǒng)頭文件。它在系統(tǒng)目錄的標準列表中搜索名為 file 的文件。在編譯源代碼時，您可以通過 -I 選項把目錄前置在該列表前。

#include "file"

這種形式用于引用用戶頭文件。它在包含當前文件的目錄中搜索名為 file 的文件。在編譯源代碼時，您可以通過 -I 選項把目錄前置在該列表前。

引用頭文件的操作

#include指令會指示 C 預處理器瀏覽指定的文件作為輸入。預處理器的輸出包含了已經(jīng)生成的輸出，被引用文件生成的輸出以及#include指令之后的文本輸出。例如，如果您有一個頭文件 char_manger.h，如下：

char *test(void);

和一個使用了頭文件的主程序 char_manager.c,如下:

#include "char_manger.h"

int x;

int main (void)

{

? puts (test ());

}

編輯器會看到如下的代碼信息：

char *test (void);

int x;

int main (void)

{

? puts (test ());

}

只引用一次頭文件

如果一個頭文件被引用兩次，編譯器會處理兩次頭文件的內(nèi)容，這將產(chǎn)生錯誤。為了防止這種情況，標準的做法是把文件的整個內(nèi)容放在條件編譯語句中，如下：

#ifndef HEADER_FILE

#define HEADER_FILE

the entire header file file

#endif

這種結(jié)構(gòu)就是通常所說的包裝器#ifndef。當再次引用頭文件時，條件為假，因為 HEADER_FILE 已定義。此時，預處理器會跳過文件的整個內(nèi)容，編譯器會忽略它。

有條件引用

有時需要從多個不同的頭文件中選擇一個引用到程序中。例如，需要指定在不同的操作系統(tǒng)上使用的配置參數(shù)。您可以通過一系列條件來實現(xiàn)這點，如下：

#if SYSTEM_1

? # include "system_1.h"

#elif SYSTEM_2

? # include "system_2.h"

#elif SYSTEM_3

? ...

#endif

但是如果頭文件比較多的時候，這么做是很不妥當?shù)?，預處理器使用宏來定義頭文件的名稱。這就是所謂的有條件引用。它不是用頭文件的名稱作為?#include?的直接參數(shù)，您只需要使用宏名稱代替即可：

#define SYSTEM_H "system_1.h"

...

#include SYSTEM_H

25. 強制類型轉(zhuǎn)換

強制類型轉(zhuǎn)換是把變量從一種類型轉(zhuǎn)換為另一種數(shù)據(jù)類型。例如，如果您想存儲一個 long 類型的值到一個簡單的整型中，您需要把 long 類型強制轉(zhuǎn)換為 int 類型。您可以使用強制類型轉(zhuǎn)換運算符來把值顯式地從一種類型轉(zhuǎn)換為另一種類型，如下所示：

(type_name) expression

請看下面的實例，使用強制類型轉(zhuǎn)換運算符把一個整數(shù)變量除以另一個整數(shù)變量，得到一個浮點數(shù)：

void main(){

? void main(){

? ? int sum = 20,count = 3;

? ? double? value,value2;

? ? value = (double)sum / count;

? ? value2 = sum / count;

? ? printf("Value 強轉(zhuǎn) : %f Value2 wei強轉(zhuǎn) : %f\n ", value ,value2);

}

}

輸出：

Value 強轉(zhuǎn) : 6.666667 Value2 wei強轉(zhuǎn) : 6.000000

整數(shù)提升

整數(shù)提升是指把小于?int?或?unsigned int?的整數(shù)類型轉(zhuǎn)換為?int?或?unsigned int?的過程。請看下面的實例，在 int 中添加一個字符：

void main(){

? ? //整數(shù)提升

? ? int i= 17;

? ? char c = 'c'; //在 ascii 中的值表示 99

? ? int sum2;

? ? sum2 = i + c;

? ? printf("Value of sum : %d\n", sum2 );

}

輸出：

Value of sum : 116

在這里，sum 的值為 116，因為編譯器進行了整數(shù)提升，在執(zhí)行實際加法運算時，把 'c' 的值轉(zhuǎn)換為對應的 ascii 值。

26. 錯誤處理

C 語言不提供對錯誤處理的直接支持，但是作為一種系統(tǒng)編程語言，它以返回值的形式允許您訪問底層數(shù)據(jù)。在發(fā)生錯誤時，大多數(shù)的 C 或 UNIX 函數(shù)調(diào)用返回 1 或 NULL，同時會設置一個錯誤代碼errno，該錯誤代碼是全局變量，表示在函數(shù)調(diào)用期間發(fā)生了錯誤。您可以在 errno.h 頭文件中找到各種各樣的錯誤代碼。

所以，C 程序員可以通過檢查返回值，然后根據(jù)返回值決定采取哪種適當?shù)膭幼?。開發(fā)人員應該在程序初始化時，把 errno 設置為 0，這是一種良好的編程習慣。0 值表示程序中沒有錯誤。

errno、perror() 和 strerror()

C 語言提供了perror()和strerror()函數(shù)來顯示與errno相關的文本消息。

（1）perror()函數(shù)顯示您傳給它的字符串，后跟一個冒號、一個空格和當前 errno 值的文本表示形式。

（2）strerror()函數(shù)，返回一個指針，指針指向當前 errno 值的文本表示形式。

讓我們來模擬一種錯誤情況，嘗試打開一個不存在的文件。您可以使用多種方式來輸出錯誤消息，在這里我們使用函數(shù)來演示用法。另外有一點需要注意，您應該使用stderr文件流來輸出所有的錯誤。

例子：

void main(){

? ? int dividend = 20;

? ? int divsor = 0;

? ? int quotient;

? ? if (divsor == 0){

? ? ? ? fprintf(stderr,"除數(shù)為 0 退出運行。。。\n");

? ? ? ? exit(EXIT_FAILURE);

? ? }

? ? quotient = dividend / divsor;

? ? fprintf(stderr,"quotient 變量的值為 : %d\n", quotient);

? ? exit(EXIT_SUCCESS);

}

輸出：除數(shù)為 0 退出運行。。。

27. 遞歸

遞歸指的是在函數(shù)的定義中使用函數(shù)自身的方法。

語法格式如下：

void recursion()

{

? statements;

? ... ... ...

? recursion(); /* 函數(shù)調(diào)用自身 */

? ... ... ...

}

int main()

{

? recursion();

}

數(shù)的階乘

double factorial(unsigned int i){

? ? if (i <= 1){

? ? ? ? return 1;

? ? }

? return i * factorial(i - 1);

}

void main(){

? ? int i = 15;

? ? printf("%d 的階乘 %ld \n",i ,factorial(i));

}

輸出：15 的階乘 140732727129776

斐波拉契數(shù)列

//斐波拉契數(shù)列

int fibonaci(int i){

? ? if (i == 0){

? ? ? ? return 0;

? ? }

? ? if (i == 1){

? ? ? ? return 1;

? ? }

? ? return fibonaci(i - 1) + fibonaci( i -2);

}

void main(){

? ? for (int j = 0; j < 10; j++) {

? ? ? ? printf("%d\t\n", fibonaci(j));

? ? }

}

輸出：

0

1

1

2

3

5

8

13

21

34

28. 可變參數(shù)

有時，您可能會碰到這樣的情況，您希望函數(shù)帶有可變數(shù)量的參數(shù)，而不是預定義數(shù)量的參數(shù)。C 語言為這種情況提供了一個解決方案，它允許您定義一個函數(shù)，能根據(jù)具體的需求接受可變數(shù)量的參數(shù)。下面的實例演示了這種函數(shù)的定義。

int func(int, ... )

{

? .

? .

? .

}

int main()

{

? func(2, 2, 3);

? func(3, 2, 3, 4);

}

請注意，函數(shù)func()最后一個參數(shù)寫成省略號，即三個點號（...），省略號之前的那個參數(shù)是int，代表了要傳遞的可變參數(shù)的總數(shù)。為了使用這個功能，您需要使用stdarg.h頭文件，該文件提供了實現(xiàn)可變參數(shù)功能的函數(shù)和宏。具體步驟如下：

（1）定義一個函數(shù)，最后一個參數(shù)為省略號，省略號前面可以設置自定義參數(shù)。

（2）在函數(shù)定義中創(chuàng)建一個va_list類型變量，該類型是在 stdarg.h 頭文件中定義的。

（3）使用int參數(shù)和va_start宏來初始化va_list變量為一個參數(shù)列表。宏 va_start 是在 stdarg.h 頭文件中定義的。

（4）使用va_arg宏和va_list變量來訪問參數(shù)列表中的每個項。

（5）使用宏va_end來清理賦予va_list變量的內(nèi)存。

現(xiàn)在讓我們按照上面的步驟，來編寫一個帶有可變數(shù)量參數(shù)的函數(shù)，并返回它們的平均值：

double average(int num,...){

? ? va_list? vaList;

? ? double? sum = 0.0;

? ? int i ;

? ? //為 num 個參數(shù)初始化 valist

? ? va_start(vaList,num);

? ? //訪問所有賦給 vaList 的參數(shù)

? ? for (int j = 0; j < num; j++) {

? ? ? ? sum += va_arg(vaList, int);

? ? }

? ? //清理為valist 保留的內(nèi)存

? ? va_end(vaList);

? ? return sum/num;

}

void main(){

? ? printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));

? ? printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));

}

輸出：

Average of 2, 3, 4, 5 = 3.500000

Average of 5, 10, 15 = 10.000000

29. 內(nèi)存管理

本章將講解 C 中的動態(tài)內(nèi)存管理。C 語言為內(nèi)存的分配和管理提供了幾個函數(shù)。這些函數(shù)可以在?<stdlib.h>?頭文件中找到。

**注意: ** void * 類型表示未確定類型的指針。C、C++ 規(guī)定 void * 類型可以通過類型轉(zhuǎn)換強制轉(zhuǎn)換為任何其它類型的指針。

動態(tài)分配內(nèi)存

編程時，如果您預先知道數(shù)組的大小，那么定義數(shù)組時就比較容易。例如，一個存儲人名的數(shù)組，它最多容納 100 個字符，所以您可以定義數(shù)組，如下所示：

char name[100];

但是，如果您預先不知道需要存儲的文本長度，例如您向存儲有關一個主題的詳細描述。在這里，我們需要定義一個指針，該指針指向未定義所需內(nèi)存大小的字符，后續(xù)再根據(jù)需求來分配內(nèi)存，如下所示：

void main() {

? ? char name[100];

? ? char *description;

? ? //將字符串 copy 到 name 中

? ? strcpy(name, "迎娶白富美！");

? ? //開始動態(tài)分配內(nèi)存

? ? description = (char *) malloc(200 * sizeof(char));

? ? if (description == NULL) {

? ? ? ? fprintf(stderr, "Error - unable to allocate required memory\n");

? ? } else {

? ? ? ? strcpy(description, "開始添加數(shù)據(jù)到 description 中");

? ? }

? ? printf("Name = %s\n", name );

? ? printf("Description: %s sizeOf 大小 ：%d\n", description , sizeof(description));

//? ? 使用 free() 函數(shù)釋放內(nèi)存

? ? free(description);

}

輸出：

Name = 迎娶白富美！

Description: 開始添加數(shù)據(jù)到 description 中 sizeOf 大小 ：8

30. 命令行參數(shù)

執(zhí)行程序時，可以從命令行傳值給 C 程序。這些值被稱為命令行參數(shù)，它們對程序很重要，特別是當您想從外部控制程序，而不是在代碼內(nèi)對這些值進行硬編碼時，就顯得尤為重要了。

命令行參數(shù)是使用 main() 函數(shù)參數(shù)來處理的，其中，argc是指傳入?yún)?shù)的個數(shù)，argv[]是一個指針數(shù)組，指向傳遞給程序的每個參數(shù)。下面是一個簡單的實例，檢查命令行是否有提供參數(shù)，并根據(jù)參數(shù)執(zhí)行相應的動作：

void main(int argc , char *argv[]){

? ? if (argc ==1){

? ? ? ? printf("argv[%d] == %d",0,*argv[0]);

? ? }

? ? else if (argc ==2){

? ? ? ? printf("argv[%d] == %d",1,*argv[1]);

? ? } else{

? ? ? ? printf("匹配失敗...");

? ? }

}

輸出：argv[0] == 47

總結(jié)

到了這里，我們連續(xù)三天的C語言入門知識點分享，到這里就結(jié)束了，你們收獲了多少呢？筆者也知道你們?nèi)绻鯇W的話肯定一時間也記不住什么，所以還是要記得收藏哈！這個很重要的。

不知道大家在看完 C 基礎內(nèi)容之后在對比下 Java 語法，是不是大部分都差不多，之前有的人說學了 C 在學其它語言都是小菜一碟，現(xiàn)在看來好像是這么回事。個人覺得其實只要會編程語言中的任何一門在學其它語言都會比較容易上手。

另外，UP在主頁上傳了一些學習C/C++編程的視頻教程，有興趣或者正在學習的小伙伴一定要去看一看哦！會對你有幫助的~