本节目总导演：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姑娘碰上三位循环兄弟。