本節目總導演：rampant boy

本節目總編劇：rampant boy

本節目總策劃：rampant boy

本集將初步介紹C語言，讓讀者能快速對C語言有個大致了解，下面進入正文：

什么是C語言

? C語言是一門面向程序的計算機編程語言，與C++、Java等面向物件編程語言有所不同，C語言的設計目標是提供一種能以簡易的方式編譯、處理低級存盤器僅產生少量的機器碼以及不需要任何運行環境支持便能運行的編程語言，C語言描述問題比匯編語言迅速、作業量小、可讀性好、易于除錯、修改和移植，而代碼質量與匯編語言相當，C語言一般只比匯編語言代碼生成的目標程式效率低10%-20%，因此，C語言可以撰寫系統軟體，

? C語言是有國際標準的：C89,C90,C99,C11

? C語言編譯器主要有：Clang，GCC，WIN-TC，SUBLIME，MSVC，Turbo C等等

第一個C語言程式

如何創建環境撰寫代碼

我平時使用VS2019撰寫程式，如果有小伙伴使用VS2013或者VS2015，那就請點開這篇博客

下面，我將用VS2019來演示如何創建環境來撰寫C語言代碼

1.創建一個空專案

首先點擊創建新專案

然后選擇C++語言，再點擊空專案

修改專案名稱，位置，再點擊創建

當顯示為這個界面的時候，就說明空專案已經創建好了

2.創建一個源檔案

什么是源檔案？

以.c為后綴的檔案稱為源檔案

以.h為后綴的檔案稱為頭檔案

創建方法：

右擊源檔案，點擊添加，再點擊新建項

選擇C++檔案，修改檔案名稱，注意：檔案名稱必須以.c結尾

然后點擊添加

當出現這個界面的時候，就代表源檔案已經創建成功了

撰寫C語言程式

1.撰寫代碼

撰寫代碼的第一步，也是最重要的一步，就是寫出主函式（main函式）

int main()
{
    
    return 0;
}

主函式就創建完成了

為什么要創建主函式？

C語言程式是從主函式的第一行開始執行的，所以C語言代碼中得有main函式，主函式相當于程式的入口，

注：一個工程中有且只有一個main函式，

這里先簡要說明一下這個函式的各個結構，至于C語言中函式的詳細講解，我會在之后專門寫一篇博客詳細講解，所以這里不理解的小伙伴不用太擔心，

當主函式創建好了之后，我們就得開始撰寫代碼，假如我們要完成在螢屏上列印hello world，那我們該如何完成呢？

#include<stdio.h>
int main()
{
    printf("hello world");
    return 0;
}

這就是在螢屏上列印hello world的代碼，在螢屏列印資訊，需要使用printf函式，這是C語言里的庫函式，print是列印的意思，f代表function——函式，由于printf是庫函式，那么在使用的時候，需要宣告，所以就要參考頭檔案 stdio.h，剛剛已經強調過，以.h 為后綴的檔案是頭檔案，std是standard的簡寫，i是input，o是output，所以stdio就是標準的輸入輸出，這就是對這段代碼的一個簡要解釋，

2.運行代碼

編譯+鏈接+運行代碼的快捷鍵是：Ctrl+F5

當然，也可以在除錯中點擊開始執行

運行代碼之后，螢屏上就會出現hello world

于此，第一個C語言程式就完成了，

注：這是VS2019執行代碼之后的情況，如果用VS2013或者VS2015，可能在執行代碼以后視窗一閃而過，那么這篇博客或許可以幫到你，

資料型別

C語言中的資料型別：

char——字符資料型別

short——短整型

int——整型

long——長整型

long long——更長整型

float——單精度浮點數

double——雙精度浮點數

那這些字符型別如何使用呢？

比如我們要存盤字符a，那么在C語言中就是這樣存盤的：

int main()
{
    char ch = 'a' ;
    return 0;
}

因為a是一個字符，所以就需要用char型別去存盤，因為char是字符資料型別，char ch意思是在記憶體中開辟一個char型別的空間，將該空間命名為ch，= 在這里不是相等的意思，而是賦值的意思，也就是說把字符a賦值給ch，

以此類推

int main()
{
    int age = 20 ;
    short num = 10;
    float weight = 55.5;
    double d = 0.0;
    reutrn 0;
}

如果大家能理解我舉的char型別的例子，那么以上這些資料型別也應該能看到（當然，如果我哪里寫的不清楚的話，可以在評論區里留言！）

那么我們如何在螢屏上列印這些數字呢？

既然提到列印，那就得用printf函式

int main()
{
    int num = 20;
    printf("%d",num);
    return 0;
}

當運行這段代碼的時候，螢屏上就會顯示出20，

其中%d就是表示列印整型的，

每個型別的大小是多少呢？

既然要求型別大小，就得用到C語言的一個關鍵字——sizeof，它同時也是一個運算子，用來計算型別或者變數的所占空間的大小，

int main()
{
    printf("%d",sizeof(char));//1
    printf("%d",sizeof(short));//2
    printf("%d",sizeof(int));//4
    printf("%d",sizeof(long));//4
    printf("%d",sizeof(long long));//8
    printf("%d",sizeof(float));//4
    printf("%d",sizeof(double));//8
    return 0;
}

sizeof的單位是位元組

計算機中的單位：

bit——位元位——一個位元位用來存放一個二進制位

byte——位元組 = 8bit

kb——1024byte

mb——1024kb

gb——1024mb

tb——1024gb

pb——1024tn

因此，char的大小是1個位元組，short的大小是2個位元組，int的大小是4個位元組，long的大小是4個位元組，long long的大小是8個位元組，float的大小是4個位元組，double的大小是8個位元組，

注：C語言規定，sizeof(long)>=sizeof(int)

為什么出現這么多型別？

因為這樣可以既豐富地表達生活中的各種值，又使空間的利用率更高，

變數，常量

定義變數的方法

第一種：型別 變數的名字 = 值;

第二種：型別 變數的名字;

個人不推薦第二種定義變數的方法

舉例

int main()
{
    int age = 20;
    return 0;
}

這就是定義變數的方法，

變數的分類

變數分為區域變數和全域變數，

{}外部定義的變數是全域變數，{}內部定義的變數是區域變數

例如

int a = 0;
int main()
{
    int b = 0;
    return 0;
}

上述代碼中，a為全域變數，b為區域變數，

當全域變數和區域變數的名字相同時，區域變數優先

int a = 0;
int main()
{
    int a = 10;
    printf("%d",a);
    return 0;
}

這段代碼的運行結果為10，進一步說明了當全域變數和區域變數的名字相同時，區域變數優先，因此，在寫代碼的程序中，不建議把全域變數和區域變數的名字寫成一樣，

下面我們做個小練習：

寫一個代碼，求兩個整數的和

#include<stdio.h>
int main()
{
    int a = 0;
    int b = 0;
    int sum = 0;
    scanf("%d%d",&a,&b);
    sum = a + b;
    printf("sum = %d\n",sum);
    return 0;
}

說明，scanf函式是輸入函式，&是取地址，&a意思是把a的地址取出來，為什么要取a的地址呢？a代表在記憶體中開辟了一個整型空間，這個空間的名稱叫a，而開辟的記憶體是有它的地址的，&a就是把a的地址取出來，因為只有這樣，才能向a中輸入一個整數，如果僅僅是a的話，那么輸入的這個整數就無法存盤到a中，那么&b也是同樣的意思，

注：在VS2013以上的版本中直接運行這段代碼可能會報錯，那么這篇博客或許可以幫大家解決這個問題，

變數的作用域和生命周期

作用域：通常來說，一段程式代碼中所用到的名字并不總是有效/可用的，而限定這個名字的可用性的代碼范圍就是這個名字的作用域，

可以理解為一個變數在哪使用，哪就是它的作用域，

區域變數的作用域：就是變數所在的區域范圍，

全域變數的作用域：整個工程，

比如：

在add.c檔案中命名一個g_val的變數，那么在test.c中也可以呼叫，但需要用extern宣告一下變數，

生命周期：變數的創建到變數的銷毀之間的一個時間段，

區域變數的生命周期：進入作用域，生命周期開始；出作用域，生命周期結束，

全域變數的生命周期是：整個程式的生命周期，

常量

C語言中的常量分為以下幾種：

• 字面常量
• const修飾的常變數
• #define定義的識別符號常量
• 列舉常量

字面常量

例如：

3.14;
10;
'a';
"abcd";

以上就是字面常量，

const修飾的常變數

例如：

此時num就是常變數，常變數就說明具有常屬性（不能被改變的屬性）

那為什么說它是變數？

例如這段代碼：

**如果此時n為常量的話，那么這段代碼就不會報錯，**根據這段代碼報錯，我們可以知道，n其實是個變數，因此，上面那段代碼中的num本質上是個變數，只不過它具有常屬性，

#define定義的識別符號常量

例如：

MAX就是#define定義的識別符號常量，它也是無法被修改的，

列舉常量

列舉常量——可以一一列舉的常量，

例如：

enum Sex
{
    //列舉常量
    MALE，
    FEMALE，
    SECRET
}；

int main()
{
    enum Sex s = MALE;
    return 0;
}

這就是列舉常量，列舉常量默認是從0開始，

當然，列舉常量可以賦初值，

以上就是對C語言中四種常量的簡單解釋，

字串+轉義字符+注釋

字串

字串：由雙引號引起來的一串字串稱為字串字面值，簡稱字串，

例如：

"hello world";

這就是字串，

注：字串的結束標志是一個==\0的轉義字符，在計算字串長度的時候\0==是

結束的標志，不算做字串的內容，

arr[]是陣列，后文會有簡介，

轉義字符

引例：

int main()
{
    printf("c:\test\test.c");//猜猜這個代碼運行的結果是多少
    return 0;
}

我們用VS2019來運行一下

為什么出現這種情況呢？

因為代碼中出現了轉義字符（\t），轉義字符——轉變了它原來的意思，

\+部分字符，就是轉義字符，那么C語言中有哪些轉義字符呢？

轉義字符	釋義
\’	用于表示字符常量’
\’’	用于表示一個字串內部的雙引號
\\	用于表示一個反斜杠，防止它被釋義為一個轉義序列符
\a	警告字符，蜂鳴
\b	退格符
\f	進紙符（換頁）
\n	換行
\r	回車
\t	水平制表符
\v	垂直制表符
\ddd	ddd表示1-3個八進制的數字，如：\130——88
\xdd	dd表示2個十六進制的數字，如：\x30——48

以上是部分轉義字符，例如\t，就是代表一個水平制表符，相當于鍵盤上的tab鍵，其他的之后在使用的程序中再作詳細的介紹，

這里就介紹一下\ddd和\xdd：

\130=0*8^0+3*8^1+1*8^2=88，根據ASCII碼值，88就是’X’，

\x30=0*16^0+3*16^3=48，根據ASCII碼值，48就是’0’，

如果咱就是需要列印c:\test\test.c，那么就得使用\\

int main()
{
    printf("c:\\test\\test.c");
    return 0;
}

轉義字符的內容就先介紹到這里，

注釋

VS中如何注釋？

或者

推薦使用//注釋，不建議使用/*內容*/注釋，因為這種注釋無法實作嵌套注釋，例如：

/*只能和第一個*/匹配，無法跟第二個*/匹配，

為什么要注釋？

1.代碼中有不需要的代碼可以直接洗掉，也可以注釋掉

2.代碼中有些代碼比較難懂，可以加一下注釋文字，

第二點是注釋的主要作用，

選擇陳述句

這里只是對選擇陳述句進行一個簡單的介紹，后續會詳細的進行介紹

我們先來看一段代碼

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    if(a>b)
    {
        printf("%d",a);
    }
    else
    {
        printf("%d",b);
    }
    return 0;
}

這段代碼就用到了選擇陳述句——if，else，先輸入兩個數，a，b，如果a>b，那么就在螢屏上列印a，否則，就在螢屏上列印b，這就是選擇陳述句，

回圈陳述句

C語言中的回圈有while回圈，for回圈，do…while回圈，本次只是初步講解while回圈，其他兩個回圈之后會詳細講解，

對while回圈的講解這次只是通過一段代碼來說明，

int main()
{
    int a = 0;
    while(a<10)
    {
        printf("rampant boy");
        a++;
    }
    return 0;
}

這段代碼的意思是，如果a小于10，那么就列印rampant boy，然后a+1，如果a大于或等于10，那么就跳出回圈，回圈結束，

這就是對while回圈的一個簡單介紹，

函式

什么是函式呢？

舉個例子：假如需要計算兩個數的和

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    int sum = a + b;
    printf("sum=%d\n",sum);
    return 0;
}

這段代碼就是用來計算兩個數的和，這也是常規寫法，那么下面我們就用函式來求兩個數的和，

int ADD(int x,int y)
{
    int z = 0;
    z = x + y;
    return z;
}

int main()
{
    int num1 = 0;
    int num2 = 0;
    scanf("%d%d",&num1,&num2);
    int sum = ADD(num1,num2);
    return 0;
}

這就是用函式實作兩個數的和，ADD就是函式名，ADD（num1，num2）的意思是把num1和num2傳給ADD函式，而ADD（int x，int y）中的x和y就是用來接收num1，num2，由于num1和num2是整型，所以x，y也是整型，而ADD函式是求兩個整數的和，所以它的回傳值也應該是整型，因此ADD（int x，int y）前面有個int，這就是創建ADD函式的程序，當ADD函式定義之后，那么在這個工程中如果需要再次求兩數之和，就可以直接呼叫ADD函式來實作，

函式的特點就是簡化代碼，代碼復用，

陣列

陣列：一組相同型別的元素的集合，

為什么需要陣列？

如果不選擇使用陣列的話，那么當我們需要存盤十個整數的時候，就得創建十個變數，而如果使用陣列，那么只需創建一個陣列即可，

例如：存盤1——10

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

這就是陣列的創建，arr是陣列名，10代表該陣列儲存十個元素，int代表儲存元素的型別是整型，

我們再看下面這個陣列

char ch[5] = {'a','b','c'};

這個陣列稱為不完全初始化，因為這個陣列原本可以儲存五個字符，但現在只儲存三個字符，那么剩余的就默認為0，

陣列是用下標訪問的，陣列的下標是從0開始的，

例如上面這個陣列，儲存十個整型元素，那么下標就是從0開始，一直到9，

即：

arr[0] = 1;
arr[1] = 2;

以此類推，

所以，要想列印這個陣列，就得使用下面這段代碼，

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    while(i<10)
    {
        printf("%d ",arr[i]);
        i++;
    }
    return 0;
}

對于陣列的講解，咱就先講解到這，之后會對陣列進行詳細的講解，

運算子

目前先簡單介紹

算數運算子

+ - * / %

注：*代表稱號，/代表除號，但是在C語言中，整數a，b，a/b得到的是商，例如9/2=4，而不是4.5，如果想得到4.5，就得寫出9/2.0，或者9.0/2，%代表取模，可以理解為取余數，例如9%2=1，

移位運算子

>> <<

位運算子

& ^ |

&——按位與，|——按位或，^——按位異或，

賦值運算子

= += -= *= /= &= ^= |= >>= <<=

a = a+1等價于a += 1，在C語言中，=不是代表相等，而是賦值，

單目運算子

！	邏輯反操作
-	負值
+	正值
&	取地址
sizeof	運算元的型別長度（以位元組為單位）
~	對一個數的二進制按位取反
–	前置，后置–
++	前置，后置++
*	間接訪問運算子（解參考運算子）
(型別)	強制型別轉換

什么是單目運算子？

例如：a+b，+有兩個運算元，所以+是雙目運算子，因此單目運算子就是只有一個運算元，

這里先簡單解釋一下！，~，++，–和(型別)的用法吧，

！

C語言規定，0表示假，非零表示真，例如：

int a = 5;

那么a就是真，則!a=0，

那么如果：

int a = 0;

則!a=1，這是規定，

~

~——按（二進制）位取反——把所有二進制位中的數字，1變成0，變成1,

例如：

int main()
{
    int a = 0;
    printf("%d\n", ~a);
    return 0;
}

那么這個代碼的結果是-1，

為什么是-1？

整數0

二進制：00000000000000000000000000000000（因為0為整數，所以是4個位元組，32個位元位）

~a：11111111111111111111111111111111

那為什么~a列印出來的是-1？

整數在記憶體中存盤的是補碼

一個整數的二進制表示有三種：原碼，反碼，補碼

例如：-1

10000000000000000000000000000001（原碼）（最高位是符號位，1代表負數，0代表整數）

11111111111111111111111111111110（反碼）（除符號位以外，按位取反，1變成0,0變成1）

11111111111111111111111111111111（補碼）（反碼+1即為補碼）

注：正整數的原碼，反碼，補碼相同，

因此，~a列印出來的值為-1，

++

前置++：先++，后使用

例如這段代碼，a的值在賦給b之前，自身以及加1了，相當于a=a+1，b=a，所以最后列印出來的就是a=2，b=2.

后置++：先使用，后++

例如這段代碼，a的值先賦給b，然后a再加1，所以列印出來的是a=2，b=1，

(型別)

如果我們輸入這樣一段代碼：

那么運行的時候，就會顯示這樣一句話：

因為3.14是浮點型，所以如果要將3.14轉為整型，則

int a = (int)3.14;

這就是強制型別轉換，

關系運算子

>

>=

<

<=

!= 用于測驗“不相等”

== 用于測驗“相等”

邏輯運算子

&& 邏輯與

|| 邏輯或

&&

&&可以理解為并且

int c = a && b;

如果a，b均是非零，那么c的值為1，如果a，b中至少有一個為0，那么c的值為0，

||

||可以理解為或

int c = a || b;

如果a，b中至少有一個為非零，那么c的值為1，如果a，b均為0，那么c的值為0，

條件運算子

exp1 ? exp2 : exp3

這個運算子的意思是：
如果exp1成立，那么計算exp2，整個運算式的結果是exp2的結果；

如果exp1不成立，那么計算exp3，整個運算式的結果是exp3的結果，

例如：

int a = 0;
int b = 1;
int max = a>b?a:b; 

所以max的值為1，

逗號運算式

exp1，exp2，exp3，… ，expN

逗號運算式：逗號隔開的一串運算式，

在逗號運算式中，從左到右依次計算，整個運算式的結果是最后一個運算式的結果，

例如：

下標參考、函式呼叫和結構成員

[] () . ->

[]

[]——下標參考運算子

()

呼叫函式的時候，函式名后面的()就是函式呼叫運算子，

至于.和->，后面會講到的，

常見關鍵字

關鍵字：

1.C語言提供的，不能自己創建關鍵字，

2.變數名不能是關鍵字，

常見關鍵字：

auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

這里先簡要介紹幾個

auto

auto——每個區域變數都是auto修飾的，一般省略掉了，區域變數是自動創建，自動銷毀，所以也是自動變數，

register

register是暫存器關鍵字，

例如：

register int num = 100;//建議num的值存放到暫存器中

為什么要存到暫存器中？

計算機中資料可以存盤到暫存器，高速快取，記憶體，硬碟，網盤，

從暫存器到網盤，空間越來越大，但造價越來越低，傳輸速度越來越慢，

所以大量頻繁被使用的資料，放在暫存器中，可以提升效率，

typedef

typedef：型別重定義

例如：

typedef unsigned int uint_32;//將unsigned int重命名為uint_32

int main()
{
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    //num1和num2，這兩個變數的型別是一樣的
    return 0;
}

static

C語言中，static是用來修飾變數和函式，

static修飾區域變數

例如：

在不加static的情況下：

上述這段代碼最終列印結果是十個2，因為每次回圈進入test函式后，a的值都為1，然后a++，所以當列印的時候，a的值為2，回圈十次，就列印十個2，

加上static：

為什么會出現這個結果？

***因為static修飾區域變數，改變了區域變數的生命周期，致使a在出函式范圍之后不會被銷毀，***本質上是改變了變數的存盤型別，（這個后期會講到）

static修飾全域變數

例如：

在沒有static的情況下：

extern是宣告外部符號的，全域變數在整個工程中都可以使用，

加上static：

出現報錯的原因是***static修飾全域變數，使得這個全域變數只能在自己所在的源檔案（.c）內部可以使用，其他源檔案不能使用！***

全域變數之所以能在其他源檔案內部可以被使用，是因為全域變數具有外部鏈接屬性，但是被static修飾之后，就變成了內部鏈接屬性，其他源檔案就不能鏈接到這個靜態的全域變數了，

static修飾函式

例如：

在不加static的情況下：

加上static：

static修飾函式，使得函式只能在自己所在的源檔案內部使用，不能在其他源檔案內部使用，本質上static是將函式的外部鏈接屬性變成了內部鏈接屬性，

#define定義常量和宏

***define是一個預處理指令，******不是關鍵字***，

define定義符號

例如：

#define MAX 100

這就是define定義的符號，我們可以將這個列印一下

define定義宏

例如：

#define ADD(x,y) ((x)+(y))

這就是define定義宏（后期還會詳細講解），

注：如果是想實作兩個數相加，那么就不要這樣寫：

#define ADD(x,y) x+y

因為這段代碼會這樣計算：4*ADD（2,3）= 4*2+3 = 11，

指標

在講解指標之前，我們先來講解記憶體

記憶體是電腦上特別重要的存盤器，計算機中所有程式的運行都是在記憶體中運行的，所有為了有效的使用記憶體，就把記憶體劃分為一個個小的記憶體單元，每個記憶體單元的大小是1個位元組，為了能夠有效的訪問到記憶體的每個單元，就給記憶體單元進行了編號，這些編號被稱為該記憶體單元的地址，

那么記憶體是如何編號的呢？

我們拿32位機器舉例，32位機器有32根地址線，這些地址線是物理線，可以通電的，正電記為1，負電記為0，計算機將電信號轉換為數字信號——1和0組成的二進制序列，32根地址線產生的二進制序列就是：、

00000000000000000000000000000000

00000000000000000000000000000001

…

01111111111111111111111111111111

10000000000000000000000000000000

…

11111111111111111111111111111111

一共產生2^32個二進制序列，每一個序列就是一個編號，

我們可以通過代碼來觀察

0x006ffbfc就是a的地址，a是整型，整型是四個位元組，***&a是取出a的四個位元組中第一個位元組的地址，***

那么我們如何來存放地址呢？

這里就涉及到了指標

int a = 10;
int* pa = &a;

pa就是用來存放地址的，在C語言中pa稱為指標變數，*說明pa是指標變數，int說明pa執行的物件是int型別，

舉一反三：

char ch = 'w';
char* pc = &ch;

那么我們如何通過指標變數存盤的地址找到原來的變數呢？

這里就要涉及到前面沒有講到的一個運算子——*

int a = 10;
int* pa = &a;
*pa = 20;

*——解參考操作，*pa就是通過pa里的地址，找到a，那么*pa=20，就是將20賦值給a，我們可以將這段代碼列印一下，

指標變數的大小是多少呢？

指標的大小是相同的，指標是用來存盤地址的，指標需要多大空間，取決于地址的存盤需要多大空間，32位機器上，以32個位元位為一個序列，所以地址為4個位元組，64位機器上，以64個位元位為一個序列，所以地址為8個位元組，

我們可以來驗證一下：

x86就是32位

x64就是64位

指標暫時先就講解到這，

結構體

結構體可以使得C語言有能力描述復雜型別，

比如描述一個學生，需要姓名，年齡，成績，

struct Stu
{
    char name[20];//成員變數
    int age;
    double score;
};

int main()
{
    struct Stu s = {"張三",20,90.0};//結構體的創建和初始化
    return 0;
}

這就是結構體的創建和初始化，

那么我們如何列印結構體呢?

這就需要用到前面提到的一個運算子——.

.的使用——結構體變數.成員變數

當然，也可以用->來列印結構體

->的使用——結構體指標->成員變數

關于結構體，先就講解這么多，

于此，本集節目到此為止，之后將會詳細講解C語言各個部分，敬請期待！！！

下期預告：當if姑娘碰上三位回圈兄弟，