提示：该账号是本人的学习记录，希望同大家一起学习，如有错误希望广大网友帮助我加以改正！如果太久没更新，快找人骂我回来！！哈哈哈！！

---

---

前言

这是第一节，算是一个概述，后期还会每个章节进行精学，希望各位大佬带带我学习！球球！QAQ！

---

一、什么是C语言?

1、C语言是一种机器语言

计算机语言是什么？
答：计算机语言是人和计算机交流的语言。

2、计算机语言的发展

整个过程的变化本质是语言的简便化

2-1、早期阶段（早期语言）

二进制语言（低级语言）
低级语言包括：二进制语言，汇编语言
针对于硬件设备，有了硬件设备加电后就会产生电信号，如何把电信号转化成数字信号？于是把电信号进行分类，1表示正电，0表示负电，于是数字信号开始是以二进制形式进行存储。

2-2、中间阶段

为了简化二进制语言，于是使用助记符，来讲一组二进制语言对应一个助记符，于是产生了汇编语言。
上文提到：汇编语言（低级语言），二进制语言最大的区别就在于使用的助记符！

2-3、现代阶段

使用多个助记符，就产生了B语言，C语言之类的高级语言。

3、C语言的发展

C语言的早期发展具有不统一性。
由于C语言早期的不统一，因此产生了国际标准组织ANSI C89/90标准。
C语言的标准众多，其中C99/11是最不流行，很多情况下不会使用。

4、C代码

.c文件：源文件
.h文件：头文件

---

二、第一个C语言程序

使用的平台是Visual Studio 2019

1、小技巧：设置调试程序弹窗

操作路径：项目名称-右击-属性-链接器-系统-子系统-选择控制台
图示：

2、主函数

主函数main()，程序的入口
一个程序一定有main()函数
一个程序有且仅有一个main()函数
main()函数的基本架构：

int main()
{//代码return 0;
}

上文代码解释：
int表示的是整形；
main函数前面的int表示main函数调用后返回了一个整型；
结尾处return 0，表示返回了一个0（0代表整型），做到了一个首尾呼应的大动作。
void main()替换int main()，可以替换使用，但已经过时了，就不要使用了。

打印函数printf()

printf()的基本语法：

#include <stdio.h>
int main()
{printf("有大佬嘛？\n")；return 0;
}

printf函数是一个库函数
什么是库函数？系统自带的函数
使用库函数需要提前表示标记，于是每一组代码的前文都需要声明#include <头文件>
例如：

#include <stdio.h>
解释：包含一个叫做stdio.h的头文件
std(standard)i(input)o(output)：标准输入输出

---

三、数据类型

1、数据类型分类

char：字符型
int：整型
shot int：短整型
long：长整型
long long：更长整型
float：单精度浮点型
double：双精度浮点型

2、常用不同类型的输出符号

%d：打印整型
%c：打印字符
%f：打印浮点型
%lf：打印双精度浮点型
%p：以地址的形式进行打印
%x：打印十六进制数字
（等等等其他的老师没讲QAQ）

3、为什么划分这么多数据类型？

不同的数据类型，所占内存的空间不同，因为计算机的空间是有限的，所以要合理减少计算机所使用的内存。

3-1、计算不同数据类型所占空间大小

使用sizeof()来计算所占空间

printf("%d\n", sizeof(char));//字符型所占空间1B
printf("%d\n", sizeof(int));//整型所占空间4B
printf("%d\n", sizeof(short int));//短整型所占空间2B
printf("%d\n", sizeof(long));//长整形所占空间4B/8B
//为什么有可能是4B/8B呢？ C语言标准规定，sizeof(long)>=sizeof(int)平台不同，所占字节B不同。
printf("%d\n", sizeof(long long));//更长整形所占空间8B
printf("%d\n", sizeof(float));//单精度浮点型所占空间4B
printf("%d\n", sizeof(double));//双精度浮点型所占空间8B

4、计算机中的单位

• bit 比特位
  计算机中最小的单位。
  计算机是一个硬件，需要通电，电流分为正电和负电，正电被转化为1，负电被转化为0，存储空间为1/0这样的1个二进制位所申请的空间大小，被称作为1个比特。

• Byte 字节
  计算机中最基本的单位
  1B=8b

• 再往上就KB,MB,GB,TB
  每一级的运算单位都是1024（2¹⁰）
  1KB=1024B

---

四、变量和常量

1、变量

变量就是经常会变化的量

1-1、定义变量的方式

类型+名称=赋值；

1-2、变量的分类

局部变量

定义在代码块{}内部的变量
局部变量只有在当前代码块中生效。
（关系到代码块的嵌套）

全局变量

定义在代码块之外的变量，一般放置在main函数之外/外部文件中
全局变量在代码的任何位置中都可以使用。

局部变量和全局变量的区分

• 全局变量和局部变量的名称可以相同，代码执行的时候，局部变量的优先级更高。
• 但是！不建议全局变量和局部变量的名称相同，容易产生误会，进而生成bug。（NO）

1-3、变量的使用

实例：两数相加

int main()
{//计算2个数之和int num1=0;int num2=0;int sum=0;//输入数据-使用输入函数scanf()//取地址符号scanf("%d%d\n",&num1,&num2);sum=num1+num2;printf("最后结果=%d\n",sum);return 0;
}

方法一： scanf()是不安全的，可以使用scanf_s()来进行替换。由于scanf_s不是标准C语言所提供的函数，是VS编译器说提供的，为了跨平台性，建议不要使用scanf_s()。
方法二：在文件的第一行声明 #define _CRT_SECURE_NO_WARNINGS 就没有问题了！！
推荐使用方法二！
为了方便使用方法二，可以修改配置文件，我的环境下的路径“D:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\VC\VCProjectItems”中找到newc++file.cpp文件，☆重点是找到newc++file.cpp文件，在文件中使用管理员权限输入“#define _CRT_SECURE_NO_WARNINGS”，就没有问题啦！！

库函数还有

scanf、printf、strcpy、strlen、strcat等

1-4、变量的作用域

变量哪里可以使用，哪里就是他的作用域。

• 局部变量的作用域：变量所在的局部范围。
• 全局变量的作用域：是整个工程，全局变量可以跨文件使用，跨文件使用的全局变量需要声明。
• 如何声明？
  声明关键字：extern
  格式：extern 类型 名称；
  如图所示：

1-5、变量的生命周期

生命周期：变量什么时候开始存在，什么时候开始不存在？
局部变量的生命周期是，进入作用域生命周期开始，离开作用域后生命周期结束。
全局变量的生命周期是，整个程序都是它的生命周期。

2、常量

2-1、字面常量

1；
1000；
3.14；

这种直接写出来的常量就是字面常量。

2-2、const修饰常量

格式： const 类型 名称 赋值

• const关键字：

常属性关键字，目的是让变量具有常量的属性，使用后，之后的变量就不能修改了。

const int num =4
printf("%d\n",num);
//num=8；如果加上这一条企图改变num常变量的值，结果必然是会报错，提示不能够修改num。
//printf("%d\n",num);

虽然，变量具有了常量的属性，但本质上来讲依然是属于一个变量，于是产生了常变量的概念。这一观点体现在数值中。

• const修饰的常量在数组：
  数组中，[]中只能是一个常量，而const修饰的常量本质上依然是一个变量。因此不可以使用const修饰常量在数组中。
  错误实例：

const int n = 10;//n是变量，仅具有常量属性
int arrp[n]={0};//数组中[n]，只能是一个常量

2-3、#define定义的标识符常量

例子：

#include <stdio.h>
#define MAX 10
int main()
{int arr[MAX]={0};printf("%d\n",MAX);return 0;
}

2-4、枚举常量

枚举：列举出来的量
例如：星期
枚举的关键字：enum
例子1：

#include <stdio.h>
enum Sex
{MALE,FEMALE,SECRET
};
//MALE,FEMALE,SECRET，指的是枚举常量。
int main()
{enum Sex a = MALE;printf("%d\n", MALE);//0printf("%d\n", FEMALE);//1printf("%d\n", SECRET);//2
}

例子2：

enum color
{red,yellow,blue
};
int main()
{enum color c=blue;//创建一个变量赋予枚举常量c = yellow;//创造出来的变量可以修改枚举常量blue=7;//报错！但是枚举常量是不可以修改的
}

总结：
枚举常量中创造的变量是可以修改的。
枚举常量（上面大括号中的量）是不可以修改的。

---

五、字符串+转义字符+注释

1、字符串

我们学过的数据类型有字符类型，但是没有字符串类型。

1-1、如何表达字符串？

由双引号引起来的一串字符叫做字符串。

int main()
{"abchdasjdna";"hello yy";"";//空字符串return 0;
}

字符串的结束标志一般隐藏，结束标志是\0。
\0有且仅作为字符串的结束标志，不作为字符串的内容显示。

int main()
{char arr1[]="abc";//arr1中默认存在\0char arr2[]={'a','b','c','d'};//arr2中默认不出现\0printf("1:%s\n",arr1);printf("1:%s\n",arr2);return 0;
}

1-2、使用strlen()函数计算字符串长度

如果没有字符串结束标识符，结果会出现随机数。

int main()
{char arr1[]="abc";char arr2[]={'a','b','c','d'};printf("1:%s\n",strlen(arr1));//strlen()计算字符串长度的函数printf("1:%s\n",strlen(arr2));//因为没有结束标志，所以字符串结果为随机数return 0;
}

数据在计算机上存储的时候，存储形式是二进制的方式，对于每个数据字符做了一个编号，这个编号就是ASCII编码；相关转义字符

2、转义字符

将原来字符的意义发生改变

2-1、常见转义字符

2-1-1、\ ?

用于书写连续多个问号时使用，防止被解析成为三字母词。
早起C语言版本的三字母词：? ? )

int main()
{printf("(are you ok\?\?)\n");return 0;
}

2-1-2、\t

水平制表符（tab）

int main()
{printf("c:\tect\32\test.c");//因为转义字符，所以不能正常显示出来打印的效果//如果想要修改，需要在\t前面加个\，\\构成转移斜杠return 0;
}

2-1-3、\\

可以用来作为转义字符的取消操作。

2-1-4、\ddd

ddd表示3个八进制数。

int main()
{printf("%c\n",'\32');printf("第一个：%d\n",strlen("c:\\tect\\32\\test.c"));printf("第二个：%d\n",strlen("c:\tect\32\test.c"));//\32：32是2个八进制数//32作为八进制代表的那个十进制的数值，是ASCII数值所对应的字符//32八进制数（通过8-10）十进制数26（26作为ASCII的值进行对照转化）ASCII编码表上的对应字符
}

2-1-5、\xdd

dd表示2个十六进制的数。

int main()
{printf("%c\n",'\x61');//16-10:6*16^1+1*16^0=97//97在ASCII中所对应的值return 0;
}

3、注释

两种形式：
//内容：C++的时候开始出现
/* 内容 */：C的时候开始出现，不能嵌

---

六、选择语句

例子1：if语句

int main()
{int input=0;printf("你是否要快点来加入我们学习的大部队？（意思是慢点来也可以o(*￣︶￣*)o）")；printf("你要快点来嘛？请输入(1/0)>:");scanf("%d",&input);if(input==1)printf("omg大佬带我飞！\n");elseprintf("omg晚来的大佬带我飞！")；return 0;
}

---

七、循环语句

例子1：while循环语句

int main()
{int line=0;printf("join byte\n");while(line<20){printf("敲一行代码：%d\n",line);line++;}if (line>=20)printf("give your better offer!\n");elseprintf("you are lower!\n");return 0;
}

---

八、函数

1、如何使用函数和构建函数？

int Add(int x,int y)//Add是函数名，括号里面是函数的接收参数，int是函数的返回类型，可以为空void;
{int z=x+y;return z;
}
//以上函数体是完成函数的内容。
int main()
{int num1=10;int num2=20;int sum1=0;int a=100;int b=200;int sum2=0;sum1=Add(num1,num2);sum2=Add(a,b);printf("sum1=%d\n",sum1);//30printf("sum2=%d\n",sum2);//300
}

2、函数的分类

1. 库函数
2. 自定义函数

---

九、数组

• 数组就是一组相同类型数据的集合
• 数组中的数据集合都是带有下标的，N个数据的有N-1的下标，下标从0开始
• 数组可以通过下标来单个输出
• 数组可以通过变量来进行循环输出

int main()
{//int a = 1;//int b = 2;//int c = 1;//int d = 2;//int e = 1;//int f = 2;以上这样创建对象太拉胯了，所以出现了数组的概念。int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个存放10个整数数字的数组printf("%d\n", arr[5]);//用下标的方式来访问元素 arr[下标];int i = 0;while (i < 10){printf("%d\n", arr[i]);i++;}//数组可以通过变量来进行循环输出return 0;
}

---

十、操作符

1、操作符的分类

• 单目操作符：有1个操作数
• 双目操作符：有2个操作数
• 三目操作符：有3个操作数

例子：
int main()
{int a = 10;int b = 20;a + b;//+属于双目操作符，有两个操作数//举一反三，单目操作符有1个操作数，三目操作符有3个操作数return 0;
}

2、常用的操作符

2-1、算术操作符

符号：+、-、*、/、%

int main()
{int a = 5 / 2;//取商int b = 5 % 2;//取模printf("%d\n", a);//2printf("%d\n", b);//1return 0;
}

2-2、移位操作符

符号：>>右移、<<左移

int main()
{//<< 左移、>> 右移int a = 1; //整型1占4个字节-32bit//00000000.00000000.00000000.0000001这个空间就叫aint b = a << 1;//a空间向左挪动一位，整体向左移动，右边0补位//结果是0000000000000000000000000000010=2printf("%d\n", b);printf("%d\n", a);//左移后，不赋给原对象a，原对象a是不会变得return 0;
}

2-3、位操作符

符号：&、|、^

& 按位与：同为1（真）才为1（真）
| 按位或：同为0（假）才为0（假）
^ 按位异或：相同为0（假），不同为1（真）

int main()
{//位（2进制位）操作//& 按位与 与操作：同为1（真）才为1（真）//| 按位或 或操作：同为0（假）才为0（假）//^ 按位异或  异或操作：相同为0（假），不同为1（真）int a = 3; //011int b = 5; //101int c = a ^ b;printf("%d\n", c); return 0;
}

2-4、赋值操作符

符号：=

int main()
{int a = 10;a = 20;//= 赋值 区分：==判断相等a = a + 10;	//简化版：a+=10；其他运算符也可以用；复合赋值符return 0;
}

2-5、逻辑反操作符

符号：！

//！逻辑反操作
//当我们在C语言中，要表示真假，0表示假，非0表示真
int a = 10;//a就是真
printf("%d\n", a);
printf("%d\n", !a);
//逻辑反操作，真变成假，假变成真。
//（ps:当0变成真的时候，数字规定了一个变为1）

2-6、- 负值 + 正值

符号：- 、+

int a = -2;
int b = -a;
int c = +3;//+正号一般省略
printf("%d\n", b);

2-7、sizeof操作符

符号：sizeof
计算的是，变量/类型所占空间的大小，单位是字节；

例子1：
int a = 10;
int sz = 0;
printf("%d\n", sizeof(a));//4
//语法格式：printf("%d\n", sizeof(变量/类型));
//或者 printf("%d\n", sizeof 变量);
int arr[10] = { 0 };//10个整型元素的数组
printf("%d\n", sizeof(arr));
//计算数组的元素个数：数组总大小/每个元素的大小=个数
sz = sizeof(arr) / sizeof(arr[0]);
printf("sz=%d\n", sz);

例子2：
int a = 10;
int arr[] = { 1,2,3,4,5,6 };//不规定数组的大小，设置初始值时；
//在这里，数组的元素类型是整型，所以列出来的元素后面不需要结束字符；字符型需要列出结束字符。
//数组的元素是int类型，数组的类型是int[6]（前期不需要了解）
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(int));//4
printf("%d\n", sizeof a);//4 
//sizeof 求得是变量大小的时候，可以省略括号的，所以sizeof是操作符，不能说是函数，函数是不能去括号的；
//printf("%d\n", sizeof int);//4 这样的写法是错误的；
//sizeof 求的是类型大小的时候，不可用省略括号；
printf("%d\n", sizeof(arr));
//计算数组内部的空间大小，单位是Byte；6个元素，每个元素是一个整型，一个整型是4B，所以输出结果是6*4=24B
printf("计算元素个数=%d\n", sizeof(arr) / sizeof(0));
//总数组的大小/一个元素的大小=元素的个数（0是第一个元素的下标）
return 0;

2-8、~操作符

对一个数的二进制按位取反。

int main()
{//按位取反（~）：1010--取反-->0101int a = 0;//a是4B，32bit，所以a(2)=00000000 00000000 00000000 00000000int b = ~a;//上面a(2)取反的结果：~a(2)=11111111 11111111 11111111 11111111printf("%d\n", b);//结果是-1，为什么？//原码、反码、补码//负数在内存中存储的时候，存储是二进制的补码//最高位是符号位，1是负数，0是正数//我们使用的打印的是这个数的原码，也是我们日常使用的//原码反码补码的计算规则：（原反补）//原码符号位不变，其他位置取反，得到反码，反码加一得到补码//补码减一得到反码，反码符号位不变，其他位置取反得到原码//补码：11111111 11111111 11111111 11111111//反码：11111111 11111111 11111111 11111110//原码：10000000 00000000 00000000 00000001——换算成十进制：-1即为结果return 0;
}//原-反-补（补充）//只要是整数，内存中存储的都是二进制的补码；//正数的原码、反码、补码相同//负数在计算机中存储的是补码，显示出来的是原码，原码是有正负号的二进制序列。通常已知原码得到补码。

2-9、- -操作符和++操作符

int main()
{int a = 10;int b = a++;//++放在变量后面，这种就是后置++//后置++：先使用a（变量）的值，然后a再+1——于是乎现在输出结果：b等于10，a等于11printf("a=%d;b=%d\n", a, b);int c = ++a;//++放在变量前面，这种就是前置++//前置++：a先+1，再把a的值赋给cprintf("a=%d;c=%d\n", a, c);int x = 10;int y = x--;printf("x=%d;y=%d\n", x, y);//分析输出结果为x=9；y=10.int m = 10;int n = --m;printf("m=%d;n=%d\n", m, n);//分析输出结果为m=9；n=9.return 0;
}

2-10、（类型）强制类型转换操作符

int main()
{int a = (int)3.14;//强制将3.14的double浮点型，转换成int整型；//一般不推荐转换return 0;
}

2-11、 *解引用操作符和&取地址操作符（后指针讲解）

2-12、关系操作符

本质就是比较大小的符号
符号：大于>、大于等于>=、小于<、小于等于<=、不等于!=、相等==（注意=是赋值操作符）

2-13、逻辑操作符

符号：逻辑与&&、逻辑或||
(区分&和|，这两个是按2-3位操作，二进制角度)

int main()
{//0表示假，非0表示真；//逻辑与&&全为1才为1，逻辑或||全为0才为0；int a = 3;int b = 5;int c = a && b;//a为真，b并且也为真，则结果也为真，输出结果一般以1来表示；printf("%d\n", c);int x = 5;int y = 0;int z = x || y;//x为真，b为假，逻辑或，全为假才为假，则结果为真；printf("%d\n", z);return 0;
}

2-14、条件操作符(三目操作符)

格式：exp1?exp2:exp3（exp：表达式的意思）

int main()
{//使用if函数表达条件：int a = 10;int b = 20;int max = 0;if (a > b)max = a;elsemax = b;printf("使用if表达式的max值=%d\n", max);//使用条件操作符:exp1？exp2:exp3//exp1为真的话，exp2要执行，exp2的结果是整体表达式的结果//exp1为假的话，exp2不执行，exp3执行结果，exp3的结果即为整个表达式的结果int x = 50;int y = 20;int MAXD = 0;MAXD = x > y ? x : y;printf("使用条件操作符的MAXD值=%d\n", MAXD);return 0;
}

2-15、逗号表达式

格式：exp1,exp2,exp3,...,expn

2-16、下标引用、函数调用、结构成员

符号：符号：[]、()、 . 、 ->

int main()
{int arr[10] = { 0 };arr[4];//[]下标引用操作符//()函数调用操作符int a = 10;int b = 20;int sum = add(a, b);//这里的（）就是函数调用的效果printf("两个数值相加等于=%d\n",sum);return 0;
}int add(x, y)
{int z = x + y;return z;
}

---

十一、常见关键字

1、auto 自动变量

int main(){int a = 10;//局部变量，因为自动创建自动销毁，所以也是自动变量；int类型前面基本上都省略了auto关键字；return 0;}

2、register 寄存器关键字

计算机存储数据：寄存器、高速缓存存储器cache、内存、硬盘（从左向右，速度降低，存储升高）

int main(){register int a = 10;//建议定义a是一个寄存器变量；为什么是建议？//寄存器在计算机是有限的，如果所有变量都是寄存器关键字，是不可取的//因此只能编译建议寄存器变量，但是不能最终确定寄存器变量是什么变量，编译器自己会判断出来谁作为return 0;}

3、signed 有符号数

int main(){int a = 10;a = -2;//int 定义的变量是有符号的//完全写法是signed int a = 10,不过一般情况signed是省略的return 0;}

4、unsigned 无符号数

• 正常情况下啊，默认是有符号数，特意指出无符号数之后，只有正数的存在，没有负数的存在。
• 编译器赋值的时候，不论是有符号数还是无符号数，在编译器眼中，只是一个32位的存储空间。
• 给负数就按照补码的形式进行存储，给正数的时候就按照原码的形式进行存储。
• 读数的时候，绝对为有符号数和无符号数就无所谓了，只是存储形式不同。
  无符号数输出符号是：%u

int main(){unsigned int a = -10;//在变量a看来只是“-10”一个整数printf("最后结果a=%u\n", a);//%u是用来输出无符号10进制整数return 0;}

5、static 静态

5-1、修饰函数

声明外部文件的函数，当static修饰函数，改变了函数的作用域。
（static修饰的函数，改变了函数的链接属性，一般函数具有外部链接属性）

前提:在外文件定义了一个函数
外文件：
static int add(int x, int y)//创建函数
{int z = x + y;return z;
}
源文件：
extern int add(int,int);//声明int main(){int a = 10;int b = 20;int sum = add(a, b);//这里使用会报错，因为有了静态属性，函数被赋予了静态属性，不能够跨文件使用。printf("%d\n", sum);return 0;}

5-2、修饰全局变量

前提：在外文件定义了一个全局变量
外文件：
static int g_val = 2020;
//全局变量,在其他文件中需要声明extern
源文件：
int main()
{extern int g_val;//static修饰全局变量，改变了变量的作用域//静态的全局变量，只能在自己所在的源文件内部使用printf("g_val=%d\n", g_val);return 0;
}

5-3、修饰局部变量

void test()
{static int a = 1;//当变量a被加上static后，变量a就是一个静态的局不变量了//static 生命周期取消//static 修饰局部变量，局部变量的生命周期延长了a++;printf("a=%d\n",a);
}//没有加static的局部变量a，在这里生命周期结束int main()
{int i = 0;while (i < 5){test();i++;}return 0;
}

6、typedef 类型定义

int main()
{//可以理解为类型重定义unsigned int num = 20;typedef unsigned int u_int;//就是对于上文的unsigned int 做了一个重命名。u_int num = 20;return 0;
}

0、其他一些关键字概括

1. break 一般用于循环调出
2. continue 继续
3. case
4. char
5. const 常变量：将变量赋有常量的性质，但本质还是变量
6. default 默认
7. do do well循环
8. double
9. else
10. enum 枚举
11. extern 声明引入外部符号
12. float
13. for 循环
14. goto 语句
15. if 语句
16. int
17. long
18. return
19. short
20. sizeof 计算变量/类型大小
21. struct 结构体关键字
22. switch 语句
23. union 联合体
24. void 空
25. volatile 用得少，还难（操作系统再讲）
26. while 循环

---

十二、define 定义常量和宏

1、#define定义标识符常量

注意：在四-2中有讲解

#define MAX 100;
int main()
{int a = MAX;return 0;
}

2、#define定义宏

宏是带参数的

//宏的定义方式：#define MAX(X,Y) X>Y?X:Y
int main()
{int a = 10;int b = 20;int max = MAX(a, b);//使用宏的方式，可以理解成int max=(a>b?a:b);printf("max=%d\n", max);return 0;
}类似理解：
//函数的定义方式
MAX(int x, int y)
{if (x > y)return x;elsereturn y;
}

---

十三、指针

内存是什么概念？
内存被划分成为很多内存单元，每一个内存单元都分配了一个地址。

如何给内存单元分配地址编号？
（如何产生地址？如何分配地址编号？）
一般32位的操作系统，指的是32根地址线/数据线，通电后有了正电1和负电0的区别。
当电信号转化为数字信号，最后出现的二进制数列一共有2³²个；于是就会有2³²个地址编号。
从0开始，对地址进行编号，这个编号被称之为地址。

一共内存单元空间有多大？
一个内存单元就是一个Byte

申请内存？
int a=10;就是为变量a申请4B的内存单元。

例子1：
int main()
{int a = 10;//4B//申请了4B，如何知道地址？//取地址操作符&//&a;//取出变量a的地址printf("%p\n", &a);//打印出来变量a的地址int* p = &a;//有一种变量是用来存放地址的，这种变量被称之为指针变量(int*类型)printf("%p\n", p);*p = 20;//* 解引用操作符，解引用操作通过p变量中存放的地址，找到了变量a，所以*p=aprintf("a=%d\n", a);//修改*p后打印的结果为a的结果，原本a为10，最后a为20；上文证明成功。return 0;
}

例子2：
int main()
{char ch = 'w';char* pc = &ch;*pc = 'a';printf("%c\n", ch);return 0;
}

指针存放地址大小如何定义？
有关于操作系统，在32位的操作系统上，已知规定每个内存单元为1B
内存单元地址，在32位的操作系统上无非就是32个二进制序列，那么存放地址需要32bit，即为4B的空间
（如果是64位的OS，需要的就是8B的内存空间）

int main()
{char ch = 'w';char* pc = &ch;printf("%d\n", sizeof(pc)); //8B——64位的平台return 0;
}

---

十四、结构体

什么是结构体？
也就是复杂对象如何表示？
例如，我们要表示一个人，需要他的姓名+身高+年龄+身份证号码…

例子1：如何描述一本书？
描述结构体关键字：struct(结构)
struct Book
{//描述书的相关属性char name[20];//C语言程序设计short price;//55RMBchar author;//王观棋char press;//朔夜观棋工作室出版社
};//这个分号是必不可少的！用来标志描述属性的结束int main()
{//利用结构体类型，创建一个该类型的结构体变量struct Book b1 = {"C语言程序设计",55,"王观棋","朔夜观棋工作室出版社"};printf("Book name:%s\n",b1.name);// .结构成员操作符printf("Book price:%d\n",b1.price);//修改结构体变量b1中的价格为15b1.price = 15;printf("Book price after:%dRMB\n", b1.price);//修改结构体变量b1中的书名位C++//如果像修改价格一样输入“b1.name="C++";”这样是会报错的//原因是：上文属性描述中，price是变量，name是一个数组//因此我们需要使用strcpy()，（string copy - 字符串拷贝），它是一个库文件，存放在string.h//格式：strcpy(数组变量,"新的数组")strcpy(b1.name,"C++");printf("%s\n",b1.name);struct Book* pb1 = &b1;//指针变量pb1的变量类型，就是一开始定义的struct Book类型//利用pb1打印书名和价格//注意指针打印的格式！！printf("%s\n", (*pb1).name);printf("%d\n", (*pb1).price);//上面的形式太过于啰嗦//注意箭头的操作符形式！printf("%s\n", pb1 -> name);printf("%d\n", pb1 -> price);//.格式：*结构体变量.成员；->格式：结构体变量->成员；return 0;
}

---