古人云，温故而知新，学习的过程中，只有不断复习，才能达到孰能手巧的地步，尤其是复习那些自己或者是那些常人的错误，才能提高自己的学习效率。值此国庆佳节，祝福伟大祖国繁荣昌盛，C站的好友们国庆节快乐。如果你认为这篇博客写的还不错的话，求点赞，求收藏，求评论，您的三连是我制作的最大动力！本片主要讲的是基础入门，进阶版很快就会更新，废话不多说，让我们学起来吧。

二，概念基础

1，数据类型

char        //字符数据类型
short       //短整型
int         //整形
long        //长整型
long long   //更长的整形
float       //单精度浮点数
double      //双精度浮点数

下面哪个不是C语言内置的数据类型：

A.char

B.double

C.struct Stu

D.short

struct关键字是用户用来自定义的结构体类型，不属于C语言的内置类型。

因此：选择C

2，数据类型的大小

#include <stdio.h>
int main()
{
    printf("%d\\n", sizeof(char));
    printf("%d\\n", sizeof(short));
    printf("%d\\n", sizeof(int));
    printf("%d\\n", sizeof(long));
    printf("%d\\n", sizeof(long long));
    printf("%d\\n", sizeof(float));
    printf("%d\\n", sizeof(double));
    printf("%d\\n", sizeof(long double));
    return 0;
}

3，局部变量和全局变量

局部变量：一般将定义在函数中的变量称为局部变量，其只能在函数内部使用。

全局变量：定义在全局作用域中的变量，即函数外的变量，称之为全局变量，全局变量的生命周期随程序启动而生，随程序结束而消亡，在任何函数中都可以使用。

#include <stdio.h>
int global = 2019;//全局变量
int main()
{
    int local = 2018;//局部变量
    int global = 2020;//局部变量
    printf("global = %d\\n", global);
    return 0;
}

局部变量的作用域是：

A.main函数内部

B.整个程序

C.main函数之前

D.局部变量所在的局部范围

注意：全局变量使用起来方便，但为了防止冲突和安全性，尽量避免定义全局变量。

  A：main函数内部定义的局部变量作用域在main函数中，但是其他函数中的局部变量则不在，因此A选项不对。

  B：局部变量作用域在函数内部，全局变量是整个程序，因此B选项不对

  C：main函数之前，是系统做的一些事情，因此也不对

  D：正确，即在函数体内

4，变量的访问规则及变量的作用域和生命周期

作用域

作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的

局部变量的作用域是变量所在的局部范围。

全局变量的作用域是整个工程。

生命周期

变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段

局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

全局变量的生命周期是：整个程序的生命周期。

下面代码输出的结果是：（）

#include <stdio.h>
int num = 10;
int main()
{
    int num = 1;
    printf("num = %d\\n", num);
	return 0;	
}

根据以上描述可知，对于以上代码：

1. 全局作用域中的num和main中的num可以同时存在，不会冲突，因为不是同一个作用域

2. 在main函数中访问num时，采用就近原则，因此访问的是main中的num，相当于将全局作用域中的num屏蔽了

A：错误：因为两个num不在同一个作用域中，可以通过编译

B：正确，main中访问的是main中的num，而main函数中的num是1，因此打印1

C：错误，应该访问main函数中的num，而不是全局作用域中的num

D：错误，凑选择的

5，字符串

"hell0\\n"

这种由双引号（Double Quote）引起来的一串字符称为字符串字面值（String Literal），或者简称字符串。

字符串的结束标志是：（）

A.是'0'

B.是EOF

C. 是'\\0'

D.是空格

C语言规定：以'\\0'作为有效字符串的结尾标记

#include <stdio.h>
int main()
{
    char arr1[] = "abc";
    char arr2[] = { 'a', 'b', 'c' };
    char arr3[] = { 'a', 'b', 'c', '\\0' };
    printf("%s\\n", arr1);
    printf("%s\\n", arr2);
    printf("%s\\n", arr3);
    return 0;
}

6，转义字符

转义字符	释义
\\?	在书写连续多个问号时使用，防止他们被解析成三字母词
\\'	用于表示字符常量'
\\\\	用于表示一个反斜杠，防止它被解释为一个转义序列符。
\\ddd	ddd表示1~3个八进制的数字。如： \\130 X
\\xdd	dd表示2个十六进制数字。如： \\x30 0
\\f	进纸符
\\n	换行
\\r	回车
\\t	水平制表符
\\v	垂直制表符
\\"	用于表示一个字符串内部的双引号

下面那个不是转义字符？

A.'\\n'

B.'\\060'

C.'\\q'

D.'\\b'

A：'\\n' 转义字符，代表换行

B：'\\060' 转义字符，060八进制数据，十进制为48，因此'\\48'表示的就是'0'

C：'\\q' 什么都不是

D：'\\b' 转义字符，表示退格

7，strlen

#include <stdio.h>
#include <string.h>

int main()
{
    char arr[] = {'b', 'i', 't'};
    printf("%d\\n", strlen(arr));
	return 0;
}

strlen是用来获取字符串的有效长度的，结尾标记'\\0'不包含在内。

strlen获取的规则非常简单：从前往后一次检测，直到遇到'\\0'是就终止检测。

而上体中arr是一个字符数组，不是一个有效的字符串，因为后面没有放置'\\0'，因此strlen在求解时，将有效字符检测完之后，还会继续向后检测，直到遇到'\\0'是才终止，因此答案为不确定，就看紧跟在't'之后的第一个'\\0'在什么位置。

#include <stdio.h>
#include <string.h>
int main()
{
    printf("%d\\n", strlen("c:\\test\\121"))
    return 0;
}

strlen：获取字符串的有效长度，不包括'\\0'

"c:\\test\\121": 在该字符串中，\\t是转移字符，水平制表，跳到下一个tab的位置；而\\121表示一个字符，是讲121看做8进制数组，转换为10进制后的81，作业为ASCII码值的字符，即：字符'Q' ，故上述字符串实际为："c: esty",只有7个有效字符.

8，数组创建

C语言中下面那个数组的创建错误的：（）

A.int arr[10] = {0}

B.int n = 10; int arr[n] ={0}

C.int arr[] = {1,2,3,4,5,6,7,8,9,0}

D.char ch[10] = "hello bit"

关于数组描述错误的是：

A.数组是一组相同类型元素的集合

B.数组的下标是从1开始的

C.数组的下标是从0开始

D.数组如果初始化，可以不指定数组的大小

数组的下标是从0开始的。

需要注意的是D：int a[] = {1,2,3},数组可以通过初始化确定大小。

9，关键字

关键字 typedef：typedef 顾名思义是类型定义，这里应该理解为类型重命名。

关键字static：

1. 修饰局部变量-静态局部变量

2. 修饰全局变量-静态全局变量

3. 修饰函数-静态函数

#include <stdio.h>
void test()
{
    //static修饰局部变量
    static int i = 0;
    i++;
    printf("%d ", i);
}
int main()
{
 int i = 0;
    for(i=0; i<10; i++)
   {
        test();
   }
    return 0;
}

static修饰局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。

static int g_val = 2018;
int main()
{
    printf("%d\\n", g_val);
    return 0;
}

一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使用。

static int Add(int x, int y)
{
    return c+y;
}
int main()
{
    printf("%d\\n", Add(2, 3));
    return 0;
}

一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

关于C语言关键字说法正确的是：( )

A.关键字可以自己创建

B.关键字不能自己创建

C.关键字可以做变量名

D.typedef不是关键字

关于static说法不正确的是：（）

A.static可以修饰局部变量

B.static可以修全局变量

C.static修饰的变量不能改变

D.static可以修饰函数

  static修饰变量

   a. 函数中局部变量：

      声明周期延长：该变量不随函数结束而结束

      初始化：只在第一次调用该函数时进行初始化

      记忆性：后序调用时，该变量使用前一次函数调用完成之后保存的值

      存储位置：不会存储在栈上，放在数据段

   b. 全局变量

     改变该变量的链接属性，让该变量具有文件作用域，即只能在当前文件中使用

   c. 修饰变量时，没有被初始化时会被自动初始化为0

static修饰函数

改变该函数的链接属性，让该函数具有文件作用域，即只能在当前文件中使用

const修饰的变量不能改变

#include <stdio.h>
int sum(int a)
{
    int c = 0;
    static int b = 3;
    c += 1;
    b += 2;
    return (a + b + c);
}
int main()
{
    int i;
    int a = 2;
    for (i = 0; i < 5; i++) 
    { 
        printf("%d,", sum(a)); 
    } 
}

本题主要考察static修饰局部变量的特性，static修饰局部变量，该变量不会随函数的结束而消失，并且只在第一次调用时进行初始化，后序调用该函数时，使用的都是上次结束前该变量的值。

  第一次循环：a=2 b=5 c=1 a+b+c=8

  第二次循环：a=2 b=7 c=1 a+b+c=10

  第二次循环：a=2 b=9 c=1 a+b+c=12

  第二次循环：a=2 b=11 c=1 a+b+c=14

  第二次循环：a=2 b=13 c=1 a+b+c=16

10，指针

内存

内存是电脑上特别重要的存储器，计算机中所有程序的运行都是在内存中进行的。所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

变量都有地址，取出变量地址如下：

int main()
{
 int num = 10;
 &num;//取出num的地址
 printf("%p\\n", &num);//打印地址，%p--以地址的形式打印
 return 0;
}

指针变量的大小

#include <stdio.h>
int main()
{
    printf("%d\\n", sizeof(char *));
    printf("%d\\n", sizeof(short *));
    printf("%d\\n", sizeof(int *));
    printf("%d\\n", sizeof(double *));
    return 0;
}

指针大小在32位平台是4个字节，64位平台是8个字节。

关于指针说法正确的是：（）

A.sizeof(char*)大小一定是1

B.指针是个变量，用来存放地址

C.指针变量的大小都是4个字节

D.指针不是变量

A：错误，指针是一种复合数据类型，指针变量内容是一个地址，因此一个指针可以表示该系统的整个地址集合，故按照32位编译代码，指针占4个字节，按照64位编译代码，指针占8个字节(注意：不是64位系统一定占8个字节，关键是要按照64位方式编译)

B：正确

C：错误，参考A选项解释

D：错误，该条描述比较模糊指针可以认为是一种数据类型，也可以认为是定义出来的指针变量

三，分支语句和循环语句

1，if语句

语法结构：
if(表达式)
    语句;
if(表达式)
    语句1;
else
    语句2;
//多分支    
if(表达式1)
    语句1;
else if(表达式2)
    语句2;
else
    语句3;

如果条件成立，要执行多条语句，怎应该使用代码块。

#include <stdio.h>
int main()
{
    if(表达式)
   {
        语句列表1；
   }
    else
   {
        语句列表2；
   }
    return 0;
}

下面代码执行的结果是：( )

#include <stdio.h>
int main()
{
	int i = 0;
	for (i = 0; i<10; i++)
	{
		if (i = 5)
			printf("%d ", i);
	}
	return 0;
}

上述代码本来的想法应该是：循环10次，每次循环时如果i==5则打印i的结果。

但if语句中表达式的==写成了赋值，相当于每次循环尽量都是将i的值设置成了5，5为真，因此每次都会打印5

i每次修改成5打印后，i的值永远不会等于10，因此造成死循环

故：死循环的打印5

2，switch语句

switch(整型表达式)
{
    语句项；
}

编程好习惯

在switch语句中，我们没法直接实现分支，搭配break使用才能实现真正的分支

在最后一个 case 语句的后面加上一条 break语句。（之所以这么写是可以避免出现在以前的最后一个 case 语句后面忘了添加 break语句）。

在每个 switch 语句中都放一条default子句是个好习惯，甚至可以在后边再加一个 break 。

int func(int a)
{
    int b;
    switch (a)
    {
        case 1: b = 30;
        case 2: b = 20;
        case 3: b = 16;
        default: b = 0;
    }
    return b;
}

则func(1) = （）

switch的每个case之后如果没有加break语句，当前case执行结束后，会继续执行紧跟case中的语句。func(1)可知，在调用func时形参a的值为1，switch(a)<==>switch(1),case 1被命中，因为该switch语句中所有分支下都没有增加break语句，因此会从上往下顺序执行，最后执行default中语句返回。所以答案为0.

下面代码的执行结果是什么（）

#include <stdio.h>
int main() 
{
	int x = 3;
	int y = 3;
	switch (x % 2) 
{
	case 1:
		switch (y)
		{
		case 0:
			printf("first");
		case 1:
			printf("second");
			break;
		default: printf("hello");
		}
	case 2:
		printf("third");
	}
	return 0;
}

  #include <stdio.h>
  int main()
{
  	int x = 3;
  	int y = 3;
  	switch (x % 2) 
{  // x%2的结果为1，因此执行case1
  	case 1:
  		switch (y)   // y是3，因此会执行case3，而case3不存在，那只能执行default
  		{
  		case 0:
  			printf("first");
  		case 1:
  			printf("second");
  			break;
  		default: printf("hello"); // 打印hello，打印完之后，内部switch结束，此时外部case1结束
  		}             // 因为外部case1之后没有添加break语句，所以继续执行case2
  	case 2:             // 打印third
  		printf("third");      // 外部switch结束
  	}
  	return 0;
  }

3，循环语句

if(条件)
     语句；

while(表达式)
 循环语句；

while语句中的break和continue

#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (i == 5)
			break;
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

break在while循环中的作用：

其实在循环中只要遇到break，就停止后期的所有的循环，直接终止循环。所以：while中的 break是用于永久终止循环的。

#include <stdio.h>
int main()
{
	int i = 1;
	while (i <= 10)
	{
		if (i == 5)
			continue;
		printf("%d ", i);
		i = i + 1;
	}
	return 0;
}

continue在while循环中的作用就是：

continue是用于终止本次循环的，也就是本次循环中continue后边的代码不会再执行，而是直接跳转到while语句的判断部分。进行下一次循环的入口判断。

#include <stdio.h>
int main()
{
	int a = 0, b = 0;
	for (a = 1, b = 1; a <= 100; a++)
	{
		if (b >= 20) break;
		if (b % 3 == 1)
		{
			b = b + 3;
			continue;
		}
		b = b-5;
	}
	printf("%d\\n", a);
	return 0;
}

第一次循环：a = 1，b=1--->b小于20，if不成立，b%3==1%3==1成立，b=b+3, 此时b的值为4

第一次循环：a = 2，b=4--->b小于20，if不成立，b%3==4%3==1成立，b=b+3, 此时b的值为7

第一次循环：a = 3，b=7--->b小于20，if不成立，b%3==7%3==1成立，b=b+3, 此时b的值为10

第一次循环：a = 4，b=10--->b小于20，if不成立，b%3==10%3==1成立，b=b+3, 此时b的值为13

第一次循环：a = 5，b=13--->b小于20，if不成立，b%3==13%3==1成立，b=b+3, 此时b的值为16

第一次循环：a = 6，b=16--->b小于20，if不成立，b%3==16%3==1成立，b=b+3, 此时b的值为19

第一次循环：a = 7，b=19--->b小于20，if不成立，b%3==19%3==1成立，b=b+3, 此时b的值为22

第一次循环：a = 8，b=22--->b大于20，if成立，循环break提出

最后打印a：8

四，函数

1，库函数

我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。

在编程的过程中我们会频繁的做一些字符串的拷贝（strcpy）。

在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。

2，自定义函数

函数的组成：

ret_type fun_name(para1, * )
{
 statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1    函数参数

#include <stdio.h>
//get_max函数的设计
int get_max(int x, int y)
{
 return (x>y)?(x):(y);
}
int main()
{
 int num1 = 10;
 int num2 = 20;
 int max = get_max(num1, num2);
 printf("max = %d\\n", max);
 return 0;
}

关于函数的声明和定义说法正确的是：（）

A.函数的定义必须放在函数的使用之前

B.函数必须保证先声明后使用

C.函数定义在使用之后，也可以不声明

D.函数的声明就是说明函数是怎么实现的

A：错误，函数的定义可以放在任意位置，函数的声明必须放在函数的使用之前

B：正确

C：错误，函数定义在使用之后，使用之前没有声明时，编译器编译时识别不了该函数

D：错误，函数的声明只是告诉编译器函数返回值类型、函数名字以及函数所需要的参数，函数定义才是说明函数是怎么实现的

3，函数的调用

传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。这种传参方式可以让函数和函数外边的变量建立起正真的联系，也就是函数内部可以直接操作函数外部的变量。

能把函数处理结果的二个数据返回给主调函数，在下面的方法中不正确的是：（）

A.return 这二个数

B.形参用数组

C.形参用二个指针

D.用二个全局变量

A：错误，一个函数只能返回一个结果

B：正确，将形参存在数组中，修改数组中内容，可以通过数组将修改结果带出去

C：正确，形参如果用指针，最终指向的是外部的实参，在函数中对指向指向内容进行修改，改变的就是外部的实参

D：正确，全局变量不受函数的结束而结束，在函数中改变全局变量，主调函数中可以看到改变之后的结果

关于函数调用说法不正确的是：（）

A.函数可以传值调用，传值调用的时候形参是实参的一份临时拷贝

B.函数可以传址调用，传址调用的时候，可以通过形参操作实参

C.函数可以嵌套定义，但是不能嵌套调用

D.函数可以嵌套调用，但是不能嵌套定义

A：正确，形参按照值的方式传递，将来形参就是实参的一份临时拷贝，修改形参不会影响外部的实参

B：正确，形参按照指针方式传递，将来形参就是实参地址的一份拷贝，形参指向的是实参，修改形参指针指向的内容，就是在操作实参

C：错误，C语言中，函数不能嵌套定义

D：正确，函数可以嵌套调用，即：A()中调用B()，B()中调用A()，但是要控制好，否则就成为无限递归

在函数调用时，以下说法正确的是：（）

A.函数调用必须带回返回值

B.实际参数和形式参数可以同名

C.函数间的数据传递不可以使用全局变量

D.主调函数和被调函数总是在同一个文件里

4，函数的参数

实际参数（实参）：

真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

关于实参和形参描述错误的是：（）

A.形参是实参的一份临时拷贝

B.形参是在函数调用的时候才实例化，才开辟内存空间

C.改变形参就是改变实参

D.函数调用如果采用传值调用，改变形参不影响实参

A：正确，传参时不论是按照值还是指针方式传递，形参拿到的都是实参的一份拷贝

B：正确，函数没有调用时，新参没有空间

C：错误，如果是按照值的方式传递，形参和实参各自有各自的空间，改变形参不能改变外部的实参

D：正确，因为形参和实参是两个不同的变量

函数调用exec((vl，v2)，(v3，v4)，v5，v6);中，实参的个数是：（）

exec((vl，v2)，(v3，v4)，v5，v6) 总共有四个参数

(v1, v2)属于第一个实参，逗号表达式，真实的参数时v2

(v3，v4)属于第二个实参，逗号表达式，真实的参数是v4

v5属于第三个实参

v6属于第四个实参

五，数组

1，一维数组的创建和初始化。

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

定义了一维 int 型数组 a[10] 后，下面错误的引用是：（）

A.a[0] = 1;

B.a[0] = 5*2;

C.a[10] = 2;

D.a[1] = a[2] * a[0];

数组是相同类型的一段连续的空间，下标是从0开始的，比如：int array[N]

下标的范围为[0,N),其中N位置不能存储有效元素

A：正确，将0号位置设置为1

B：正确，将0号位置设置为10

C：错误，越界

D：正确，1号位置初始化为a[2]*a[0]之后的结果

2，一维数组的使用

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };//数组的不完全初始化
       //计算数组的元素个数
    int sz = sizeof(arr) / sizeof(arr[0]);
    //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
    int i = 0;//做下标
    for (i = 0; i < 10; i++)//这里写10，好不好？
    {
        arr[i] = i;
    }
    //输出数组的内容
    for (i = 0; i < 10; ++i)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

下面代码的结果是：( )

#include <stdio.h>
int main()
{
    int arr[] = {1,2,(3,4),5};
    printf("%d\\n", sizeof(arr));
    return 0;
}

对于int arr[] = {1,2,(3,4),5}数组，里面总共有4个元素，(3,4)为逗号表达式，取后者，因此数组中元素分别为：1,2,4,5。而sizeof(arr)求的是整个数组所占空间的大小，即：4*sizeof(int)=4*4=16

下面代码的结果是：( )

#include <stdio.h>
int main()
{
    char str[] = "hello bit";
    printf("%d %d\\n", sizeof(str), strlen(str));
	return 0;
}

str字符数组使用"hello bit"初始化，最终也会将'\\0'放置到数组中，因此数组中总共有10个元素

sizeof(str)：获取数组的总大小，10个元素，每个元素占1个字节，因此总共是10个字节

strlen(str): 获取字符串中有效字符的个数，不算'\\0'，因此总共9个有效字符

故上述printf会分别打印：10 9

关于一维数组描述不正确的是：( )

A.数组的下标是从0开始的

B.数组在内存中是连续存放的

C.数组名表示首元素的地址

D.随着数组下标的由小到大，地址由高到低

A：正确，C语言规定，数组的下标是从0开始的

B：正确，数组的空间是一段连续的内存空间

C：正确，数组名既可以表示数组的地址，也可以表示数组首元素的地址，两个在数值上是一样的，但是含义不一样。

注意：数组名只有在sizeof和&后才代表整个数组，其它都表示首元素的地址

D：错误，这个要是系统而定，一般都是下标由小到大，地址由低到高

3，二维数组初始化

二维数组的创建

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

以下能对二维数组a进行正确初始化的语句是：（）

A.int a[2][]={{0,1,2},{3,4,5}};

B.int a[][3]={{0,1,2},{3,4,5}};

C.int a[2][4]={{0,1,2},{3,4},{5}};

D.int a[][3]={{0,,2},{},{3,4,5}};

对于二维数组int array[M][N], 说明如下：

1. M和N都必须为常数，

2. M代表数组有M行，N代表每行中有N个元素

3. 其中M可以省略，省略后必须给出初始化表达式，编译器从初始化结果中推断数组有多少行

4. N一定不能省略，因为N省略了就不能确定一行有多少个元素，也不能确定数组有多少行

A：错误，参数上述说明

B：正确，参考上述说明

C：错误，数组有两行，但是初始化给了三行

D：错误，初始化不允许{0,,2}该种情况存在

六，操作符

1，算术操作符

+    -   *   /   %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

2，移位操作符

<< 左移操作符
>> 右移操作符

左移操作符移位规则：

左边抛弃、右边补0

右移操作符移位规则：

1. 逻辑移位左边用0填充，右边丢弃

2. 算术移位左边用原该值的符号位填充，右边丢弃

3，位操作符

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数

#include <stdio.h>
int main()
{
 int num1 = 1;
 int num2 = 2;
 num1 & num2;
 num1 | num2;
 num1 ^ num2;
 return 0;
}

4，单目操作符

!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换

以上四个内容我在之前的博客专门有讲解，欢迎大家考古。

5，sizeof和数组

#include <stdio.h>
 int main()
 {
 int a = 10;
 int x = ++a;
 //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
 int y = --a;
 //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
 return 0;
 }
 
 //后置++和--
 #include <stdio.h>
 int main()
 {
 int a = 10;
 int x = a++;
 //先对a先使用，再增加，这样x的值是10；之后a变成11；
 int y = a--;
 //先对a先使用，再自减，这样y的值是11；之后a变成10；
 return 0;
 }

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

#include <stdio.h>
int main()
{
	int a, b, c;
	a = 5;
	c = ++a;// ++a：加给a+1，结果为6，用加完之后的结果给c赋值，因此：a = 6  c = 6
	b = ++c, c++, ++a, a++;
   // 逗号表达式的优先级，最低，这里先算b=++c, b得到的是++c后的结果，b是7
   // b=++c 和后边的构成逗号表达式，依次从左向右计算的。
   // 表达式结束时，c++和，++a,a++会给a+2，给c加1，此时c：8，a：8，b:7
	b += a++ + c; // a先和c加，结果为16，在加上b的值7，比的结果为23，最后给a加1，a的值为9
	printf("a = %d b = %d c = %d\\n:", a, b, c); // a:9, b:23, c:8
	return 0;
}

6，逗号表达式

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式。逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);
	printf("%d", c);
	return 0;
}

七，指针

1，指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

指针是个变量，存放内存单元的地址（编号）。

#include <stdio.h>
int main()
{
 int a = 10;//在内存中开辟一块空间
 int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
   //将a的地址存放在p变量中，p就是一个之指针变量。
 return 0;
}

关于指针的概念，错误的是：( )

A.指针是变量，用来存放地址

B.指针变量中存的有效地址可以唯一指向内存中的一块区域

C.野指针也可以正常使用

D.局部指针变量不初始化就是野指针

A：正确，指针变量中存储的是一个地址，指向同类型的一块内存空间

B：正确，地址是唯一的，一个指针变量中只能存储一个地址，因此可以唯一指向内存中的一块区域

C：野指针指向的空间时非法的，或者说该指针指向的空间已经不存在了，因此野指针不能使用

D：局部指针变量没有初始化时里面就是随机值，因此指向那个位置不一定，故将其看成是野指针

以下系统中，int类型占几个字节，指针占几个字节，操作系统可以使用的最大内存空间是多大：( )

A.32位下：4,4,2^32 64位下：8,8,2^64

B.32位下：4,4,不限制 64位下：4,8,不限制

C.32位下：4,4,2^32 64位下：4,8,2^64

D.32位下：4,4,2^32 64位下：4,4,2^64

32位系统下：

int占4个字节，指针表示地址空间个数，总共有2^32个，故占4个字节

64位系统下：

int占4个字节，指针表示地址空间个数，总共有2^64个，故占8个字节

指针的大小在32位平台是4个字节，在64位平台是8个字节。

2，指针的解引用

int main()
{
 int n = 0x11223344;
 char *pc = (char *)&n;
 int *pi = &n;
 *pc = 0;   //重点在调试的过程中观察内存的变化。
 *pi = 0;   //重点在调试的过程中观察内存的变化。
 return 0;
}

总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

下面代码的结果是：（）

#include <stdio.h>
int main()
{
  int arr[] = {1,2,3,4,5};
  short *p = (short*)arr;
  int i = 0;
  for(i=0; i<4; i++)
  {
    *(p+i) = 0;
  }
   
  for(i=0; i<5; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

arr数组在内存中的存储格式为：
0x00ECFBF4:  01 00 00 00
0x00ECFBF8:  02 00 00 00
0x00ECFBFC:  03 00 00 00
0x00ECFC00:  04 00 00 00
0x00ECFC04:  05 00 00 00
指针p的类型为short*类型的，因此p每次只能所有两个字节，for循环对数组中内容进行修改时，一次访问的是：
arr[0]的低两个字节，arr[0]的高两个字节，arr[1]的低两个字节，arr[1]的高两个字节，故改变之后，数组中内容如下：
0x00ECFBF4:  00 00 00 00
0x00ECFBF8:  00 00 00 00
0x00ECFBFC:  03 00 00 00
0x00ECFC00:  04 00 00 00
0x00ECFC04:  05 00 00 00
故最后打印：0   0   3   4   5

下面代码输出的结果是：（）

#include <stdio.h>
int main()
{
	int a = 0x11223344;
    char *pc = (char*)&a;
    *pc = 0;
    printf("%x\\n", a);
    return 0;
}

答案解析：
 
假设，a变量的地址为0x64，则a变量在内存中的模型为：
0x64| 44 |
0x65| 33 |
0x66| 22 |
0x67| 11 |
 
char*类型的指针变量pc指向只能指向字符类型的空间，如果是非char类型的空间，必须要将该空间的地址强转为char*类型。
char *pc = (char*)&a; pc实际指向的是整形变量a的空间，即pc的内容为0x64，即44，
*pc=0，即将44位置中内容改为0，修改完成之后，a中内容为：0x11223300

以上是关于❤️万字总结，C语言的这些万年坑你还在踩吗（基础篇）❤️的主要内容，如果未能解决你的问题，请参考以下文章

一篇万字博文带你入坑爬虫这条不归路（你还在犹豫什么&抓紧上车） ❤️熬夜整理&建议收藏❤️

必知必会面试10多家中大厂后的两万字总结——❤️JVM篇❤️（建议收藏）