目录

选择语句

循环语句

函数

数组 —— 一组相同类型的元素的集合

操作符

关系操作符                                             

逻辑操作符

条件操作符（三目操作符）

逗号表达式 —— 逗号隔开的一串表达式

下标引用、函数调用和结构成员操作符

常见关键字 

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main(void)
{
	int input = 0;   //输入的值
	printf("今天要好好学习吗(1/0)?:");
	scanf("%d", &input);

	if (input == 1)
	    printf("你真棒n");
	else
		printf("食屎啦你~n");
	
	return 0;
}

或者

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main(void)
{
	int input = 0;   //输入的值
	printf("今天要好好学习吗(1/0)?:");
	scanf("%d", &input);

	if (input == 1)
	{
        printf("你真棒n");
    }
	
    else
	{	
        printf("食屎啦你~n");
	}
	
    return 0;
}

循环语句

#include
int main(void)
{
	int line = 0;   
	
	while(line < 10000)
	{
		printf("写代码:%dn", line);
		line++;

	}

	if (line == 10000)
	{
		printf("你真棒n");
	}

	return 0;
}

函数

非函数举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main(void)
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d%d", &num1, &num2);

	int sum = num1 + num2;
	printf("%dn", sum);
	
	return 0;
}

函数的解决方式：

#define _CRT_SECURE_NO_WARNINGS 1
#include
int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}

int main(void)
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d%d", &num1, &num2);

	int sum = Add(num1, num2);
	printf("%dn", sum);
	
	return 0;
}

数组 —— 一组相同类型的元素的集合

数组是用下标访问的，下标是从 0 开始的

#include

int main(void)
{
	// 10个整型1-10存起来
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int i = 0;
	while (i < 10)
	{
		printf("%dn", arr[i]);
		i++;
	}
	char ch[5] = { 'a','b', 'c' };  //不完全初始化，剩余的默认为0
	
	return 0;
}

操作符

算数操作符： +    -    *    /      %

除号( / ) 两边如果都是整数，则执行的是整数除法，得到的值也是整数。

比如：int  a = 9/2; printf("%dn",a), 得到的是 4，float a = 9/2; printf("%fn",a), 得到的是4.000000。

除号两端( / )两边如果有一个小数，则执行的是小数除法，得到的也是小数。

比如：float a = 9/2.0；printf("%fn",a),得到的是4.500000。

% —— 取模，也叫取余，int  a = 9/2; printf("%dn",a), 得到的是余数 1

移位操作符（移动的是二进制位）： >> (右移)     << (左移：左边丢弃，右边补0）

左移举例： 

 位操作符：

& 按位与

|  按位或

^ 按位异或

赋值操作符

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

#include

int main(void)
{
	int a = 2;
	a += 5;     // 这叫复合赋值，也可以写成 a = a + 5

	printf("%dn", a);  //输出 7
	return 0;
}

单目操作符：只有一个操作数的操作符

a + b:    + 有2个操作数，叫双目操作符

！	逻辑反操作
-	负值
+	正值
&	取地址
sizeof	操作数的类型长度（以字节为单位）
~	对一个数的二进制取反。把所有二进制位中的数字，1变0，0变1
--	前置、后置--
++	前置、后置++
*	间接访问操作符（解引用操作符
（类型）	强制类型转换

 ！操作符举例：

#include
int main(void)
{
	//0 表示假，非0表示真
	int a = 10;

	printf("%dn", !a);  //!是取反的意思，a = 10为真， !a为假，输出0
	return 0;
}

#include
int main(void)
{
	//0 表示假，非0表示真
	int a = 0;

	printf("%dn", !a);  //!是取反的意思，a = 0为假， !a为真，输出1
	
	if (a)
	{
		//如果a为真，做事
	}
	if (!a)
	{
		//如果a为假，做事
	}
	
	return 0;
}

sizeof 举例：

sizeof 是一个操作符
计算类型或者变量大小的，也可以计算数组大小
sizeof 求变量的时候后面的括号可以省略，求类型的时候括号不可以省略，通常都不要省略
函数后面跟的括号无论如何是不可以省略的，所以sizeof是操作符不是函数

#include
int main(void)
{
	//sizeof 是一个操作符
	//计算类型或者变量大小的
	//sizeof 求变量的时候后面的括号可以省略，求类型的时候括号不可以省略
	//函数后面跟的括号无论如何是不可以省略的，所以sizeof是操作符不是函数
	int a = 10;

	printf("%dn", sizeof(int));   //输出 4
	printf("%dn", sizeof a);     //输出 4

	return 0;
}

#include
int main(void)
{
	
	int arr[10] = { 0 };   // 10个元素，每个元素都是一个整型int

	printf("%dn", sizeof(arr));  //输出 40 //计算的是数组的总大小，单位是字节，输出的是 10*4 = 40
	
	printf("%dn", sizeof(arr[0]));     //求第一个元素的大小，输出 4
	
	int sz = sizeof(arr) / sizeof(arr[0]);   //计算一个数组的元素个数
	printf("%dn", sz);     //输出 10

	return 0;
}

~  操作符举例： 

#include
int main(void)
{
	int a = 0;
	printf("%dn", ~a);   // 输出-1  // ~ 按（二进制）位取反

	return 0;
}

整数在内存中储存的是 补码

一个整数的二进制表示有3种：原码  反码   补码

正整数的原码、反码、补码相同

负整数：
原码

反码：原码的符号位不变，其余按位取反

补码：反码 + 1

--  ++ 操作符举例：

前置++ —— 运算规则：先++，后使用

#include
int main(void)
{
	int a = 10;
	int b = ++a;    //前置++ 运算规则：先++，后使用
	printf("%dn", b);   // 输出11 
	printf("%dn", a);   // 输出11 因为 b = ++a 是先让 a = 11，再 b = a

	return 0;
}

 后置++  —— 运算规则：先使用，后++

#include
int main(void)
{
	int a = 10;
	int b = a++;    //后置++ 运算规则：先使用，后++
	printf("%dn", b);   // 输出10 
	printf("%dn", a);   // 输出11 因为 b = a++ 是先让 b = 10，再 a = 11

	return 0;
}

#include
int main(void)
{
	int a = 10;
	int b = (++a) + (++a)+ (++a);   //不建议研究这种代码，一般不会这样写
	
	printf("%dn", b);  //输出39

	return 0;
}

int a = 10;
int b = (++a) + (++a)+ (++a);

可以理解为      ++a   第一次   10 +1 =11

                        ++a    第二次   11 + 1 =12

                        ++a    第三次   12 + 1 =13

                         所以运算过后的 a = 13

因为 前置++ 的运算规则是：先++，后使用，所以 int b = (++a) + (++a)+ (++a)= 13 +13 + 13 = 39

（类型）举例：   

对下面代码进行编译的时候，会跳出警告warning C4244: 'initializing': conversion from 'double' to 'int', possible loss of data  提示将double类型转换为int类型可能会丢失数据（丢失精度）

#include
int main(void)
{
	int a = 3.14;

	printf("%dn", a);  

	return 0;
}

   如果不想看到这个警告，可以使用 强制类型转换 如下：                     

#include
int main(void)
{
	int a = (int)3.14;   //强制类型转换

	printf("%dn", a);  
	return 0;
}

关系操作符                                             

>    >=     <      <=     !=  （用于测试“不相等”）     == （用于测试“相等”）   

逻辑操作符

&&    逻辑与

#include
int main(void)
{
	int a = 3;
	int b = 5;
	int c = a && b;

	printf("%dn", c);   //a和b都为真，c为真，输出 1
	return 0;
}

| |      逻辑或

#include
int main(void)
{
	int a = 3;
	int b = 0;
	int c = a || b;

	printf("%dn", c);   //a为真，b为假，c为真，输出 1
	return 0;
}

条件操作符（三目操作符）

exp1 ?  exp2  :  exp3

exp1 成立，exp2计算，整数表达式的结果是：exp2的结果

exp1 不成立，exp3计算，整数表达式的结果是：exp3的结果

比如：

#include
int main(void)
{
	int a = 0;
	int b = 3;
	int max = 0;

	if (a > b)
		max = a;
	else
		max = b;

	printf("%dn", max);   //输出 3
	return 0;
}

用条件操作符表达如下：

#include
int main(void)
{
	int a = 0;
	int b = 3;
	int max = 0;
	max = a > b ? a : b;   //如果a>b，则输出a，否则输出b

	printf("%dn", max);  // 输出3 
	return 0;
}

逗号表达式 —— 逗号隔开的一串表达式

exp1, exp2, exp3, ……expN

逗号表达式是从左向右依次计算的，整个表达式的结果是最后一个表达式的结果

#include
int main(void)
{
	int a = 2;
	int b = 3;
	int c = 5;
    //逗号表达式是从左向右依次计算的
    //整个表达式的结果是最后一个表达式的结果
	
    int d = (a = b + 3, b = a - 2, c = a + b);  //a = 6， b = 4，c = 10

	printf("%dn", d);  // 输出10
	return 0;
}

下标引用、函数调用和结构成员操作符

[ ]     ( )     .     ->

[ ]  和  ( ) 举例：

常见关键字 

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（提现C语言段位的关键字）、while

 auto 自动的 —— 每个局部变量都是auto修饰

#include
int main(void)
{
	int a = 10;   //a进了{}就创建，出了{}就销毁，自动创建自动销毁 —— 自动变量
	//auto int a = 10; 里面的auto省略了
	//auto 新的C语言中也有其他用法，暂时不考虑
 
	printf("%dn", a);
	
	return 0;
}

register 寄存器关键字

计算机中数据可以存储到哪里呢？

可以存到  内存、硬盘、网盘、高速缓存、寄存器

 CPU 中央处理器    ——  早期 数据来源于 内存，后来CPU速度越来越快，内存读取速度跟不上，就有了 高速缓存、寄存器（读取速度非常快）

#include
int main(void)
{
	//大量、频繁被使用的数据，想放在寄存器中，提升效率
	register int a = 10;   //建议将a的值存放在寄存器中
	//现在的编译器已经很聪明，即使没写register，它认为该放进去还是会放进去
	printf("%dn", a);
	return 0;
}

问： define、include 是不是关键字？

答：不是，它们是预处理指令。

typedef（类型定义）：类型重定义，可以把复杂类型简单化

#include
typedef unsigned int u_int;
int main(void)
{
	unsigned int num1 = 100;   //如果不想每次写这么长，可用typedef 把 unsigned int 重新定义为 u_int
	u_int num = 120;   //跟上一行代码意思一样
	printf("%dn", num);
	return 0;
}

 static 静态的

1. 修饰局部变量 
2. 修饰全局变量
3. 修饰函数

 static 修饰局部变量 —— 改变了局部变量的生命周期（本质上是改变了额变量的存储类型）

 举例：

 static 修饰全局变量，使得这个全局变量只能在自己所在的源文件(.c)内部可以使用，其他源文件不能使用！

全局变量，在其他源文件内部可以被使用，是因为全局变量具有外部链接属性，但是被static修饰之后，就变成了内部链接属性，其他源文件就不能链接到这个静态的全局变量了。

 举例：

 static 修饰函数，使得函数只能在自己所在的源文件内部使用，不能在其他源文件内部使用，本质上：static 是将函数的外部链接属性变成了内部链接属性！（和static修饰全局变量一样！）

 举例：