C語言簡介

C 語言是一種通用的高級語言，最初是由丹尼斯·里奇在貝爾實驗室為開發(fā) UNIX 操作系統(tǒng)而設計的。C 語言最開始是于 1972 年在 DEC PDP-11 計算機上被首次實現(xiàn)。

原文鏈接：https://juejin.im/post/5df8c917f265da339772a5d1#heading-10

在 1978 年，布萊恩·柯林漢（Brian Kernighan）和丹尼斯·里奇（Dennis Ritchie）制作了 C 的第一個公開可用的描述，現(xiàn)在被稱為 K&R 標準。

UNIX 操作系統(tǒng)，C編譯器，和幾乎所有的 UNIX 應用程序都是用 C 語言編寫的。由于各種原因，C 語言現(xiàn)在已經成為一種廣泛使用的專業(yè)語言。

易于學習。

結構化語言。

它產生高效率的程序。

它可以處理底層的活動。

它可以在多種計算機平臺上編譯。

環(huán)境設置

這是只說明在 MAC 上怎么使用 C 語言來進行開發(fā)，環(huán)境的話需要用到 GCC 進行編譯，你可以下載并安裝 Xcode 工具，一旦安裝上 Xcode，您就能使用 GNU 編譯器。開發(fā)工具你可以使用 Xcode 或者 CLion 都可以，看個人喜好。我這里用的是 CLion 工具，你可以發(fā)現(xiàn) CLion 頁面跟使用風格包括快捷鍵都跟 AndroidStudio 一樣。上手極其容易。

1. 程序結構

我們先來看一下最簡單的一個 C 程序，先來打印一個 “HelloWorld”。代碼如下:

#include <stdio.h>

/**

* C 語言入口程序

* @return

*/

int main() {//主函數(shù)，程序從這里開始執(zhí)行

? ? printf("C 語言入門第一行代碼 Hello World! \n");

? ? return 0;

}

可以看到 C 語言的入口函數(shù)跟 Java 的類似吧，都是以main來定義的入口，接下來我們講解一下上面這段程序的意思：

（1）程序的第一行#include <stdio.h>是預處理器指令，告訴 C 編譯器在實際編譯之前要包含 stdio.h 文件。

（2）下一行 /.../ 將會被編譯器忽略，這里放置程序的注釋內容。它們被稱為程序的注釋。

（3）下一行int main()是主函數(shù)，程序從這里開始執(zhí)行。

（4）下一行printf(...)是 C 中另一個可用的函數(shù)，會在屏幕上顯示消息 "C 語言入門第一行代碼 Hello World!"。

（5）下一行return 0;終止 main() 函數(shù)，并返回值 0。

當然你可以通過命令來執(zhí)行,如下所示：

1. 使用 gcc xxx.c

2. ./a.out

直接使用上面 2 個步驟就可以進行執(zhí)行 C 代碼了。

2. 基本語法

上一小節(jié)我們知道了一個簡單的小應用由哪些部分組成，這將有助于我們理解 C 語言的其它基本的構建塊。

c 程序由各種令牌組成，令牌可以是關鍵字、標識符、常量、字串符值、或者是一個符號。

下面我們來看一下 C 中的關鍵字，這些關鍵字不能作為常量名，變量名或者其它標識符名稱（跟 Java 類似）。

3. 數(shù)據(jù)類型

在 C 語言中，數(shù)據(jù)類型指的是用于聲明不同類型的變量或函數(shù)的一個廣泛的系統(tǒng)。變量的類型決定了變量存儲占用的空間，以及如何解釋存儲的位模式。

C 中的類型可分為以下幾種：

整數(shù)類型

下表列出了關于標準整數(shù)類型的存儲大小和值范圍的細節(jié)

注意:?各種類型的存儲大小與系統(tǒng)位數(shù)有關，但目前通用的以 64 為系統(tǒng)為主。

浮點類型

他們的字節(jié)，精度，取值范圍都可以通過代碼打印實現(xiàn)，如下：

void main() {

/**

? ? * 整數(shù)類型

? ? */

? ? printf("\n\n 整數(shù)類型 \n");

? ? //char 1 字節(jié)

? ? printf("char 存儲大小: %lu \n", sizeof(char));

? ? printf("unsinged char 存儲大小: %lu \n", sizeof(unsigned char));

? ? //short 2 字節(jié)

? ? printf("short 存儲大小: %lu \n", sizeof(short));

? ? printf("unsinged short 存儲大小: %lu \n", sizeof(unsigned short));

? ? //int 4 字節(jié)

? ? printf("int 存儲大小: %lu \n", sizeof(int));

? ? printf("unsinged int 存儲大小: %lu \n", sizeof(unsigned int));

? ? //long 4/8 字節(jié)

? ? printf("long 存儲大小: %lu \n", sizeof(long));

? ? printf("unsinged long 存儲大小: %lu \n", sizeof(unsigned long));

/**

? ? * 浮點類型

? ? */

? ? printf("\n\n 浮點類型 \n");

? ? //float 4 字節(jié) ，精度 6 位小數(shù)

? ? printf("float 存儲最大字節(jié)數(shù)：%lu \n", sizeof(float));

? ? printf("float 最小值：%e \n", FLT_MIN);

? ? printf("float 最大值：%e \n", FLT_MAX);

? ? printf("float 精度值：%d \n", FLT_DIG);

? ? //double 8 字節(jié)

? ? printf("double 存儲最大字節(jié)數(shù)：%d \n", sizeof(double));

? ? printf("double 最小值：%e \n", DBL_MIN);

? ? printf("double 最大值：%e \n", DBL_MAX);

? ? printf("double 精度值：%d \n", DBL_DIG);

? ? //long double 16 字節(jié)

? ? printf("long double 存儲最大字節(jié)數(shù)：%lu byte \n", sizeof(long double));

? ? printf("long double 最小值：%lg \n", LDBL_MIN);

? ? printf("long double 最大值：%lg \n", LDBL_MAX);

? ? printf("long double 精度值：%d \n", LDBL_DIG);

}

可以通過?sizeof?關鍵字來獲取數(shù)據(jù)類型占用內存的大小。上面代碼可以看到了打印中出現(xiàn)了很多不識的 scanf() 格式控制符，我總結了一個表，可以參考下；

4. 變量

變量其實只不過是程序可操作的存儲區(qū)的名稱。C 中每個變量都有特定的類型，類型決定了變量存儲的大小和布局，該范圍內的值都可以存儲在內存中，運算符可應用于變量上。

變量的名稱可以由字母、數(shù)字和下劃線字符組成。它必須以字母或下劃線開頭。大寫字母和小寫字母是不同的，因為 C 對大小寫敏感的。

C 中的變量定義

變量定義就是告訴編譯器在何處創(chuàng)建變量的存儲，以及如何創(chuàng)建變量的存儲。變量定義指定一個數(shù)據(jù)類型，并包含了該類型的一個或多個變量的列表，如下所示：

type list;

在這里，type必須是一個有效的 C 數(shù)據(jù)類型，可以是 char、w_char、int、float、double 或任何用戶自定義的對象，list可以由一個或多個標識符名稱組成，多個標識符之間用逗號分隔。下面列出幾個有效的聲明：

int a,b,c;

char c1,c2,c3;

float f,f1,f2;

double d1,d2,d3;

這里其實跟 Java 聲明變量差不多，就不再單獨解釋了。

c 中變量聲明

變量聲明向編譯器保證變量以指定的類型和名稱存在，這樣編譯器在不需要知道變量完整細節(jié)的情況下也能繼續(xù)進一步的編譯。變量聲明只在編譯時有它的意義，在程序連接時編譯器需要實際的變量聲明。

變量的聲明有兩種情況：

1、一種是需要建立存儲空間的。例如：int a 在聲明的時候就已經建立了存儲空間。

2、另一種是不需要建立存儲空間的，通過使用 extern 關鍵字聲明變量名而不定義它。 例如：extern int a 其中變量 a 可以在別的文件中定義的。

3、除非有 extern 關鍵字，否則都是變量的定義。

extern int i;//聲明，不是定義

int a;//聲明，也是定義

例子

#include <stdio.h>

//函數(shù)外定義變量? ? ?

//如果需要在一個源文件中引用另外一個源文件中定義的變量，我們只需在引用的文件中將變量加上 extern 關鍵字的聲明即可

int x;

int y;

int sum() {

? ? //函數(shù)內聲明變量 X , Y 為外部變量

? ? x = 10;

? ? y = 15;

? ? return x + y;

}

//入口函數(shù)

void main() {

? ? //打印變量相加

? ? int result;

? ? result = sum();

? ? printf("x + y = %d",result);

}

輸出：x + y =25

5. 常量

常量是固定值，在程序執(zhí)行期間不會改變。這些固定的值，又叫做字面量。

常量可以是任何的基本數(shù)據(jù)類型，比如整數(shù)常量、浮點常量、字符常量，或字符串字面值，也有枚舉常量。

常量就像是常規(guī)的變量，只不過常量的值在定義后不能進行修改。

在 Java 中聲明一個常量往往是在數(shù)據(jù)類型中定義 final 關鍵字就行了，但是 c 中沒有 final 關鍵字，我們來看看怎么定義，如下所示:

整數(shù)常量

整數(shù)常量可以是十進制、八進制或十六進制的常量。前綴指定基數(shù)：0x 或 0X 表示十六進制，0 表示八進制，不帶前綴則默認表示十進制。

整數(shù)常量也可以帶一個后綴，后綴是 U 和 L 的組合，U 表示無符號整數(shù)（unsigned），L 表示長整數(shù)（long）。后綴可以是大寫，也可以是小寫，U 和 L 的順序任意。

212 /* 合法的 */

215u? ? ? ? /* 合法的 */

0xFeeL? ? ? /* 合法的 */

078? ? ? ? /* 非法的：8 不是八進制的數(shù)字 */

032UU? ? ? /* 非法的：不能重復后綴 */

浮點常量

浮點常量由整數(shù)部分、小數(shù)點、小數(shù)部分和指數(shù)部分組成。您可以使用小數(shù)形式或者指數(shù)形式來表示浮點常量。

當使用小數(shù)形式表示時，必須包含整數(shù)部分、小數(shù)部分，或同時包含兩者。當使用指數(shù)形式表示時， 必須包含小數(shù)點、指數(shù)，或同時包含兩者。帶符號的指數(shù)是用 e 或 E 引入的。

3.14159 /* 合法的 */

314159E-5L? ? /* 合法的 */

510E? ? ? ? ? /* 非法的：不完整的指數(shù) */

210f? ? ? ? ? /* 非法的：沒有小數(shù)或指數(shù) */

.e55? ? ? ? ? /* 非法的：缺少整數(shù)或分數(shù) */

定義常量

在 C 中，有兩種簡單的定義常量的方式：

使用?#define?預處理器。

使用?const?關鍵字。

下面是使用 #define 預處理器定義常量的形式：

#define identifier value

例子：

#define name 10L

#define age 27U

void main() {

? ? int? person;

? ? person = name + age;

? ? printf("values :%d",person);

}

const 關鍵字

您可以使用?const?前綴聲明指定類型的常量，如下所示：

const type variable = value;

例子：

void main() {

? ? const int LEGTH = 10;

? ? const int WIDTH = 5;

? ? const char NEWLINE = '\n';

? ? int area;

? ? area = LEGTH * WIDTH;

? ? printf("value of area: %d", area);

}

6. 存儲類

存儲類定義 C 程序中變量/函數(shù)的范圍（可見性）和生命周期。這些說明符放置在它們所修飾的類型之前。下面列出 C 程序中可用的存儲類：

auto

register

static

extern

auto 存儲類

auto 存儲類時所有局部變量默認的存儲類。

int month;

auto int month;

上面定義了兩個帶有相同存儲類，auto 只能用在函數(shù)內，即 auto 只能修飾局部變量。

register 存儲類

register存儲類用于定義存儲在寄存器中而不是 RAM 中的局部變量。這意味著變量的最大尺寸等于寄存器的大小（通常是一個詞），且不能對它應用一元的 '&' 運算符（因為它沒有內存位置）。

register int miles;

寄存器只用于需要快速訪問的變量，比如計數(shù)器。還應注意的是，定義register并不意味著變量將被存儲在寄存器中，它意味著變量可能存儲在寄存器中，這取決于硬件和實現(xiàn)的限制。

static 存儲類

static存儲類指示編譯器在程序的生命周期內保持局部變量的存在，而不需要在每次它進入和離開作用域時進行創(chuàng)建和銷毀。因此，使用 static 修飾局部變量可以在函數(shù)調用之間保持局部變量的值。static 修飾符也可以應用于全局變量。當 static 修飾全局變量時，會使變量的作用域限制在聲明它的文件內。

全局聲明的一個 static 變量或方法可以被任何函數(shù)或方法調用，只要這些方法出現(xiàn)在跟 static 變量或方法同一個文件中。

//函數(shù)聲明

void func1(void);

static int count = 10; //全局變量 - static 默認的

void main() {

? ? while (count--) {

? ? ? ? func1();

? ? }

}

void func1(void) {

//? 'thingy' 是 'func1' 的局部變量 - 只初始化一次

// * 每次調用函數(shù) 'func1' 'thingy' 值不會被重置。

? ? static int thingy = 5;

? ? thingy++;

? ? printf("thingy 為 %d, count 為 %d \n", thingy, count);

}

輸出：

thingy 為 6, count 為 9

thingy 為 7, count 為 8

thingy 為 8, count 為 7

thingy 為 9, count 為 6

thingy 為 10, count 為 5

thingy 為 11, count 為 4

thingy 為 12, count 為 3

thingy 為 13, count 為 2

thingy 為 14, count 為 1

thingy 為 15, count 為 0

實例中 count 作為全局變量可以在函數(shù)內使用，thingy 在局部使用 static 修飾后，不會在每次調用時重置。

extern 存儲類

extern存儲類用于提供一個全局變量的引用，全局變量對所有的程序文件都是可見的。當您使用extern時，對于無法初始化的變量，會把變量名指向一個之前定義過的存儲位置。

當您有多個文件且定義了一個可以在其他文件中使用的全局變量或函數(shù)時，可以在其他文件中使用extern來得到已定義的變量或函數(shù)的引用?？梢赃@么理解，extern是用來在另一個文件中聲明一個全局變量或函數(shù)。

extern 修飾符通常用于當有兩個或多個文件共享相同的全局變量或函數(shù)的時候，如下所示：

第一個文件 ndk_day1.c

#include <stdio.h> //stdio.h 是一個頭文件（標準輸入輸出頭文件）,#include 是一個預處理命令，用來引入頭文件。

#include "support.h" //引入自己的頭文件

int main() {

? ? int sum = add(2, 5);

? ? printf("extern 使用 :%d", sum);

}

聲明 support.h 頭文件

int add(int num1,int num2){

? ? return num1 * num2;

}

輸出：

extern 使用 :10

7. 運算符

運算符是一種告訴編譯器執(zhí)行特定的數(shù)學或邏輯操作的符號。C 語言內置了豐富的運算符，并提供了以下類型的運算符：

算術運算符

關系運算符

邏輯運算符

位運算符

賦值運算符

雜項運算符

算術運算符

下表顯示了 C 語言支持的所有算術運算符。假設變量A的值為 10，變量B的值為 20，則：

例子：

void main(){

? ? int a = 21;

? ? int b = 10;

? ? int c;

? ? c = a + b;

? ? printf("a + b = %d \n", c);

? ? c = a - b;

? ? printf("a - b = %d \n", c);

? ? c = a * b;

? ? printf("a * b = %d \n", c);

? ? c = a / b;

? ? printf("a / b = %d \n", c);

? ? c = a % b;

? ? printf("a % b = %d \n", c);

? ? c = ++a;

? ? printf("++a = %d , %d \n", c, a);

? ? c = b++;

? ? printf("b++ = %d , %d \n", c, b);

? ? c = b--;

? ? printf("b-- = %d \n", c);

}

輸出：

a + b = 31

a - b = 11

a * b = 210

a / b = 2

a b = 1

++a = 22 , 22

b++ = 10 , 11

b-- = 11

關系運算符

下表顯示了 C 語言支持的所有關系運算符。假設變量?A?的值為 10，變量?B?的值為 20，則：

邏輯運算符

下表顯示了 C 語言支持的所有關系邏輯運算符。假設變量?A?的值為 1，變量?B?的值為 0，則：

例子：
void main(){

? int a1 = 5;

? ? int b1 = 5;

? ? int c1;

? ? //如果兩個操作數(shù)都非零，則條件為真。

? ? if (a1 && b1) {

? ? ? ? printf("a1 && b1? %d \n", true);

? ? } else {

? ? ? ? printf("a1 && b1? %d \n", false);

? ? }

? ? //如果兩個操作數(shù)中有任意一個非零，則條件為真。

? ? if (a1 || b1) {

? ? ? ? printf("a1 || b1? %d \n", true);

? ? } else {

? ? ? ? printf("a1 || b1? %d \n", false);

? ? }

? ? //改變 a1 b1 的值

? ? a1 = 0;

? ? b1 = 10;

? ? //如果兩個操作數(shù)都非零，則條件為真。

? ? if (a1 && b1) {

? ? ? ? printf("a1 && b1? %d \n", true);

? ? } else {

? ? ? ? printf("a1 && b1? %d \n", false);

? ? }

? ? if (!(a1 && b1)) {

? ? ? ? printf("!(a1 && b1)? %d \n", true);

? ? } else {

? ? ? ? printf("a1 || b1? %d \n", false);

? ? }

}

輸出：

a1 && b1 1

a1 || b1? 1

a1 && b1? 0

!(a1 && b1)? 1

位運算符

例子：

void main(){

? //位運算符 & | ^ ~

? ? int wA = 60; //0011 1100

? ? int wB = 13; //0000 1101

? ? int wC = 10;

? ? //都為真，才是真 0000 1100

? ? printf("wA & wB=？%d\n", wA & wB);

? ? //其中一個為真，就為真 0011 1101

? ? printf("wA | wB=？%d\n", wA | wB);

? ? //一個為真則為真，2個為真這為假 00110001

? ? printf("wA ^ wB=？%d\n", wA ^ wB);

? ? printf("~wB=？%d\n", ~wB);

? ? //二進制左移運算符 左 * 4 = 40

? ? printf("wC<<2=？%d\n", wC << 2);

? ? //二進制右移運算符 右 / 4

? ? printf("wC>>2=？%d\n", wC >> 2);

}

輸出：

wA & wB=？12

wA | wB=？61

wA ^ wB=？49

~wB=？-14

wC<<2=？40

wC>>2=？2

下表顯示了 C 語言支持的位運算符。假設變量?A?的值為 60，變量?B?的值為 13，則：

賦值運算符

下表列出了 C 語言支持的賦值運算符：

例子：

void main(){

int wAA = 21;

? ? int wBB;

? ? wBB = wAA;

? ? printf("= %d\n", wBB);

? ? wBB += wAA;

? ? printf("+= %d\n", wBB);

? ? wBB -= wAA;

? ? printf("-= %d\n", wBB);

? ? wBB *= wAA;

? ? printf("*= %d\n", wBB);

? ? wBB /= wAA;

? ? printf("/= %d\n", wBB);

? ? wBB %= wAA;

? ? printf("%= %d\n", wBB);

? ? wBB <<= wAA;

? ? printf("<<= %d\n", wBB);

? ? wBB <<= wAA;

? ? printf(">>= %d\n", wBB);

? ? wBB &= wAA;

? ? printf("&= %d\n", wBB);

? ? wBB ^= wAA;

? ? printf("^= %d\n", wBB);

? ? wBB |= wAA;

? ? printf("|= %d\n", wBB);

}

輸出：

= 21

+= 42

-= 21

*= 441

/= 21

= 0

<<= 0

>>= 0

&= 0

^= 21

|= 21

雜項運算符 sizeof、&、三元

下表列出了 C 語言支持的其他一些重要的運算符，包括?sizeof?和?? :。

例子：

void main(){

? int zxA = 4;

? ? short zxB;

? ? double zxC;

? ? int *ptr;

? ? //sizeOf 運算符實例 ,lu 32位無符號整數(shù)

? ? printf("zxA sizeOf = %lu \n", sizeof(zxA));

? ? printf("zxB sizeOf = %lu \n", sizeof(zxB));

? ? printf("zxC sizeOf = %lu \n", sizeof(zxC));

? ? //& 和 * 運算符實例

? ? ptr = &zxA; //將 zxA 的地址值復制給 ptr 指針

? ? printf("zxA 的值為：%d \n", zxA);

? ? printf("*ptr 的值為：%d \n", *ptr);

? //三元運算符

? ? zxA = 10;

? ? zxB = (zxA == 1) ? 20 : 30;

? ? printf("zxb 的值為：%d \n", zxB);

? ? zxB = (zxA == 10) ? 20 : 30;

? ? printf("zxb 的值為：%d \n", zxB);

}

輸出：

zxA sizeOf = 4

zxB sizeOf = 2

zxC sizeOf = 8

zxA 的值為：4

*ptr 的值為：4

zxb 的值為：30

zxb 的值為：20

8. 判斷

C 語言把任何非零和非空的值假定為?true，把零或?null?假定為?false。

C 語言提供了以下類型的判斷語句。

?:運算符

跟 Java 一樣

void main(){

int pdNumber;

? ? printf("輸入一個數(shù)字：");

? ? scanf("%d", &pdNumber);

? ? (pdNumber % 2 == 0) ? printf("偶數(shù)") : printf("基數(shù)");

}

9. 循環(huán)

C 語言提供了以下幾種循環(huán)類型。

循環(huán)控制語句

循環(huán)控制語句改變你代碼的執(zhí)行順序。通過它你可以實現(xiàn)代碼的跳轉。

C 提供了下列的循環(huán)控制語句。

使用方法可以參考 Java ，下面給出循環(huán)的例子:

void main(){

? ? ? //限制

? ? for (int i = 0; i < 6; i++) {

? ? ? ? printf("限制循環(huán),%d \n",i);

? ? }

? ? //無限循環(huán)

? ? for (;;) {

? ? ? ? printf("該循環(huán)會一直執(zhí)行下去！\n");

? ? }

}

10. 函數(shù)

函數(shù)定義

C 語言中的函數(shù)定義的一般形式如下：

return_type function_name( parameter list )

{

? body of the function

}

在 C 語言中，函數(shù)由一個函數(shù)頭和一個函數(shù)主體組成。下面列出一個函數(shù)的所有組成部分：

**返回類型：**一個函數(shù)可以返回一個值。return_type是函數(shù)返回的值的數(shù)據(jù)類型。有些函數(shù)執(zhí)行所需的操作而不返回值，在這種情況下，return_type 是關鍵字void。

**函數(shù)名稱：**這是函數(shù)的實際名稱。函數(shù)名和參數(shù)列表一起構成了函數(shù)簽名。

**參數(shù)：**參數(shù)就像是占位符。當函數(shù)被調用時，您向參數(shù)傳遞一個值，這個值被稱為實際參數(shù)。參數(shù)列表包括函數(shù)參數(shù)的類型、順序、數(shù)量。參數(shù)是可選的，也就是說，函數(shù)可能不包含參數(shù)。

**函數(shù)主體：**函數(shù)主體包含一組定義函數(shù)執(zhí)行任務的語句。

例子：

/* 函數(shù)返回兩個數(shù)中較大的那個數(shù) */

int max(int num1, int num2)

{

? /* 局部變量聲明 */

? int result;

? if (num1 > num2)

? ? ? result = num1;

? else

? ? ? result = num2;

? return result;

}

函數(shù)聲明

函數(shù)聲明會告訴編譯器函數(shù)名稱及如何調用函數(shù)。函數(shù)的實際主體可以單獨定義。

函數(shù)聲明包括以下幾個部分：

return_type function_name( parameter list );

針對上面定義的函數(shù) max()，以下是函數(shù)聲明：

int max(int num1, int num2);

在函數(shù)聲明中，參數(shù)的名稱并不重要，只有參數(shù)的類型是必需的，因此下面也是有效的聲明：

int max(int, int);

當您在一個源文件中定義函數(shù)且在另一個文件中調用函數(shù)時，函數(shù)聲明是必需的。在這種情況下，您應該在調用函數(shù)的文件頂部聲明函數(shù)。

調用函數(shù)

//函數(shù)聲明

int max(int num1, int num2);

/**

*C 函數(shù)

*/

void main() {

? ? //找出函數(shù)中最大值

? ? printf("找出函數(shù)中最大值，%d \n",max(66,88));

}

int max(int num1, int num2) {

? ? return (num1 > num2) ? num1 : num2;

}

輸出：找出函數(shù)中最大值，88

函數(shù)參數(shù)

如果函數(shù)要使用參數(shù)，則必須聲明接受參數(shù)值的變量。這些變量稱為函數(shù)的形式參數(shù)。

形式參數(shù)就像函數(shù)內的其他局部變量，在進入函數(shù)時被創(chuàng)建，退出函數(shù)時被銷毀。

本節(jié)知識將會以分節(jié)的形式向大家展示，又想要學習C語言的小伙伴可以關注筆者！一起來加油呀~

微信公眾號：C語言編程學習基地

學習C/C++編程知識，提升C/C++編程能力，歡迎關注UP一起來成長！
另外，UP在主頁上傳了一些學習C/C++編程的視頻教程，有興趣或者正在學習的小伙伴一定要去看一看哦！會對你有幫助的~