初识C语言（三）

既然是初识，那就只是浅浅的去了解C语言而已，并不深入（怎么感觉有点像渣男，渣不过三！）

---

前言

这一篇笔记主要是初步的了解C语言，所以并不会过多的深入，就像找女朋友一样，先去了解，再去深入。

例如：初识字符串，转义字符，选择语句，选择语句，循环语句，函数&&数组，操作符，常见关键字，常亮和宏，指针等等…

---

一、初识操作符

1.加减乘除和取余

在C语言里，加减乘除和取余是比较常见的操作符。写法如下：
+ - 加
- - 减
* - 乘
/ - 除
% - 取模（余）
他们的代码写法如下：

除和取余的代码

#include<stdio.h>
int main(){
	int a = 9 / 2;
	float b = 9 / 2.0;//float,单精度浮点型,第一篇笔记有写
	int c = 9 % 2;//%取模(余)，求余数
	printf("a = %d b = %lf c = %d\n", a, b, c);
	
	return 0;
}

加减乘除和取余的激情碰撞

#include<stdio.h>
int main(){
	int a = 2;
	a = a + 5;
	a = 6;//这里把6赋值给a，所以上面的运算其实没用
	a += 5;//等价a = a + 5
	a = a - 3;
	a -= 2;//等价a = a - 2
	a = a*2;//经过上面的运算后a此时为6
	a %= 3;//等价a = a % 3，12除以3余0
	
	printf("%d\n", a);//打印结果为0
	return 0;
}

有了上面的基础，此时我们尝试一下用sizeof计算数组大小

利用/操作符来计算数组大小

#include<stdio.h>
int main(){
	int arr[10] = { 0 };//定义数组大小为10，类型int
	printf("%d\n", sizeof(arr));
//计算的是数组的总大小，单位是字节，打印结果为40
	printf("%d\n", sizeof(arr[0]));
//计算的是第一个元素的大小，，一个int占用4个字节，打印结果为4
	int sz = sizeof(arr) / sizeof(arr[0]);
//用数组总大小除以第一个元素的大小得出数组有多少个元素，得出的结果为10
	printf("%d\n", sz);

	return 0;
}

---

2.与或非和移位操作符

逻辑非和移位的写法如下：
! - 逻辑非
&&- 逻辑与
|| -逻辑或
>> - 右移操作符
<< - 左移操作符

逻辑非就是把真变成假，假变成真。非0输出变成0，0输出变成1，
其中0表示“假”，非0表示“真”，而在逻辑非里，假“0”变真是“1”。

真亦假时假亦真

int main(){
	int a = 0;
	printf("%d\n", !a);
	//打印结果为1
	return 0;
}

在C语言中：
&&并且与，两个真就是真，只要有一个数为假，那就是是假
举个例子：你有一个老婆和一个女儿，两个都有的时候，你的人生圆满了。如果少了其中一个，那就是在梦中没睡醒。

`||``逻辑或，其中一个数是真那就是真，两个数都是假就是假（0）
举个例子:皇帝喊他后宫两名爱妃其中一名过来，不然今晚他就不睡觉了！这两名爱妃随便来了一个，就睡觉，如果都没来，不睡了。

计算机的真假只有1和0

int main(){
	int a = 2;
    int b = 3;
    int c = a || b;//如果a和b其中有一个是真即真
    printf("%d\n", c);//打印结果为1
	int r = 1;
    int n = 0;
    int rn = r && n;//如果这两个一个为真一个为假则为假
    printf("%d\n", rn);//打印结果为0
}

在C语言中：

左移操作符和右移动操作符移动的是二进制位

这里简单说一下二进制：
二进制是由1和0组成的。

0 0 1 1
2³ 2² 2¹ 2⁰
右边起的第一个二进制数字1，对应的是2⁰，第二个1对应的是2¹。
此时我们称这个二进制转换成十进制就是2⁰+2¹=3。
由此可知，二进制中第n位为1，对应的十进制转换应该是2^n-1。

左右摇摆的操作符

int main(){
	int a = 2;
	int b = a << 1;
	//这里把a = 2往左移1位
	//因为int a = 2在计算机中占用32个bit位，即4个字节
	//所以这里的a = 2在计算机表示为
	//00000000000000000000000000000010
	//此时我们把a整体往左移1位，然后赋值给b得到的结果为
	//00000000000000000000000000000100
	//左边的0移出去后不要，右边补上一个0，结果得到4
	printf("%d\n", b);//打印结果为4
	return 0;
}

---

3.前置++后置++

++前置在C语言中，是先++后使用的。
通俗的理解是，先拖上心仪女孩的手，再进行爱的告白，最终让她成为你的女朋友后随便拖她的手。

前置++

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

	printf("%d\n", b);//a++后赋值给了b，此时b打印结果为11
	printf("%d\n", a);//a++后为11，此时a的结果为11
	return 0;
}

后置++在C语言中，是先使用后++的。
通俗的理解是，你和你的女朋友培养了很久的关系，最终你求婚成功了，你俩的关系也达成了正果。

后置++

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

	printf("%d\n", b);//a先使用赋值给了b，此时b打印结果为10
	printf("%d\n", a);//a++后为11，此时a的结果为11
	return 0;
}

---

4.各种各样的操作符

C语言中，还有这么一些难以掌握的操作符我们留到日后再细说：

~ - 按位取反操作符
这个比较复杂，日后单独写一篇笔记细说

() - 强制类型转换操作符

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

	printf("%d\n", a);//打印结果为3
	return 0 ;
}

exp1? exp2：exp3 - 三目操作符

max = a > b ? a : b;
exp1成立，exp2计算，整个表达式的结构是：exp2的结果
exp1不成立，exp3计算，整个表达式的结构是：exp3的结果

, - 逗号表达式

int main(){
//例：(2, 4 + 5, 6);整个表达式的结果是最后一个表达式的结果
	int a = 0;
	int b = 3;
	int c = 5;
	//		a=5			c=1			b=3
	int d = (a = b + 2, c = a - 4, b = c + 2);
	//逗号表达式，是从左往右依次计算的。

	printf("%d\n", a);//打印结果为3
	return 0 ;
}

[] - 下标引用操作符

int main(){
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", arr[5]);
	//打印结果为6,arr[5]是数组arr的下标
	return 0 ;
}

() - 函数调用操作符

	//函数调用操作符
int main(){
//调用函数的时候，函数名后边的()就是函数调用操作符。
	printf("hehe\n");
	printf("%d\n", 100);
	return 0 ;
}

还有如:. ->等操作符，我们放到后面再说

---

二、初识常见关键字

1.常见关键字

在C语言中：
关于关键字的语法规则有两条
1、不能自己创建关键字
2、关键字不能做变量名
C语言中常见关键字有：

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; sypedef; union; unsigned; void; volatile; while;

---

2.重点关键字

而C语言中，有一些比较重要的关键字：

tpedef - 类型定义，类型重定义

//typedef

typedef unsigned int u_int
//typedef把unsigned int无符号整型写成了u_int
//把张三 - 喊成小三
#include<stdio.h>
int main(){
	unsigned int num = 100;
	u_int num2 = 100;
	//可以把一个复杂类型简单化
	return 0;
}

static - 在C语言中static是用来修饰变量和函数的

1、修饰局部变量-静态局部变量
2、修饰全局变量-静态全局变量
3、修饰函数-静态函数

#include<stdio.h>
void test(){
	int a = 1;
//a是局部变量，进入这个范围a创建，出了这个范围a销毁,下一次再新建a
	a++;
	printf("%d ", a);//打印2返回到主函数里面
}
int main(){
	int i = 0;
	while(i < 10){
	//判断条件i是否小于10
	test();//小于10的时候，调用test函数
	i++;
	}
//所以这里打印出来是十个2。
	return 0;
}

此时利用static修饰a看看

#include<stdio.h>
void test(){
	static int a = 1;
//static修饰这个局部变量a的时候，第一次进去test函数的a就创建好了
//出了这个局部变量的时候，a并没有销毁，a依然还在。
	a++;
	printf("%d ", a);//打印2返回到主函数里面
}
int main(){
	int i = 0;
	while(i < 10){
	//判断条件i是否小于10
	test();//小于10的时候，调用test函数
	i++;
	}
//所以这里打印出来是2 3 4 5 6 7 8 9 10 11
	return 0;
}

所以其实static修饰局部变量，改变了局部变量的生命周期（本质上是改变了变量的存储类型）

extern- 声明外部符号

全局变量在整个工程中都可以使用,这里假设新建了两个源文件

//全局变量
int g_val = 2333;//static int g_val = 2333;
//假如在这里加上static修饰的话，就会变成内部链接属性。
//其他源文件就不能链接到这个静态的全局变量了。

//extern 声明外部符号的
extern int g_val;

int main(){
	printf("%d\n", g_val);
//打印结果为2333。
	return 0;
}

---

三、常亮和宏

1.define 定义常亮和宏

在C语言中：
define是一个预处理指令:
1、define定义符号
2、define定义宏（宏是完成替换的）

define定义符号

#define MAX 1000
int main(){
	printf("%d\n", MAX);
//打印结果为1000。
	return 0;
}

这就是define定义常量

define定义宏

//define定义宏的语法X,Y是参数
#define ADD(X,Y) X+Y
int main(){
	printf("%d\n", ADD(2, 3));
//打印结果为5。
	return 0;
}

但是这个写法有个缺陷，如果想变成4*(2+3)的话,会因为没有加上括号导致先做乘法后加，完善后的写法应该是

//define定义宏的语法X,Y是参数
#define ADD(X,Y) ((X)+(Y))
//x+y可能不是一个普通的表达式，括起来可以让它优先运算
//同理x和y也可能不是同一个普通表达式，所以我们依旧括起来
int main(){
	printf("%d\n", ADD(2, 3));
//打印结果为5。
	return 0;
}

---

四、初识指针和结构体

1.初识指针

说到指针，就绕不过内存，但因为讲内存这件事太复杂了，我们后面再单独开一篇笔记来描述指针是怎么存放在内存中的。
首先，认识一下C语言中指针的写法

int main(){
	int a = 10;//a在内存中要分配的空间 - 4个字节
	printf("%p\n", &a);
	//这里的%p - 专门用来打印地址的，&a取a的地址
	
	int * pa = &a;
	//pa是用来存放地址的，在C语言中pa叫指针变量，pa是个变量名
	//int 说明pa执行的对象是int类型的

	char ch = 'w';
	char * pc = &ch;
	//char说明执行的对象是char类型的
	//char类型只占用一个字节
	return 0;
}

看到这里，记住一句话，类型 * 指针变量名指向的是一个计算机地址，也就是说，指针就是地址。
接下来再看下面的代码

int main(){
	int a = 10;//a在内存中要分配的空间 - 4个字节
	int * pa = &a;
	*pa = 20;//这里的* - 解引用操作
//所以* pa = 20就是通过pa里面的地址，找到a，并赋值20进去。
	printf("%d\n", a);
	//打印结果为20
	return 0;
}

简单来说：就是美团外卖，别人给了你一个地址门牌号，你在商家那里拿到外卖，并送到指定的地址门牌号处。

值得一提的是，指针的大小取决于指针需要多大空间，指针需要多大空间取决于地址的存储需要多大空间！

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

---

2.初识结构体

结构体使得C语言有能力描述一些复杂对象以及复杂类型。

废话不多说，上码就懂了

struct stu{
	char name[20];//成员变量
	int age;
	double score;
};
struct book{
	char name[20];
	float price;
	char id[30];
};

int main(){
	struct stu s = {"小三", 20, 85.5}//结构体的创建和初始化
	printf("%s %d %lf\n", s.name, s.age, s.score);
	//结构体变量.成员变量
	//打印结果为小三 20 85.500000
	return 0 ;
}

看不懂不要紧，初识初识，看个大概有个印象就可以了。
如果这里利用指针，结果是一样的

struct stu{
    char name[20];//成员变量
    int age;
    double score;
};
struct book{
    char name[20];
    float price;
    char id[30];
};

int main(void){
    struct stu s = {"小三", 20, 85.5};//结构体的创建和初始化
    printf("1:%s %d %lf\n", s.name, s.age, s.score);
    //结构体变量.成员变量
    struct stu * ps = &s;
    printf("2:%s %d %lf\n", (*ps).name, (*ps).age, (*ps).score);
//%lf - 打印双精度浮点型
	printf("3:%s %d %lf\n", ps->name, ps->age, ps->score);
//打印结果为1:小三 20 85.500000
//		  2:小三 20 85.500000
//		  3:小三 20 85.500000
    return 0 ;
}
}

所以我们可以得知，这三条printf语句是等价的。

---

总结

以上的全部仅仅都只初识而已，C语言还有很长一段路要走…加油吧，未来的我。