C学习01

1.计算机体系结构

CPU，内存，磁盘（冯诺依曼体系）。

2.程序运行过程

（1）程序存在硬盘中。
（2）操作系统将程序加载到内存中。
（3）CPU读取内存，读取指令，加载指令，解析指令，执行指令。

3.windows下命令行手工编译.c文件

cl.exe  first.c（编译）
link.exe   first.obj （链接）

4.C语言基本数据类型

32位下：
char 1字节 -127——128；
unsigned char 1字节 0——255；
int 4字节 -2147483648——2147483647；
unsigned int 4字节 0——4294967295；
short 2字节 -32767——32768；
unsigned short 2字节 0——65535；
long 4字节 -2147483648——2147483647；
unsigned long 4字节 0——4294967295；

IEEE标准下：
float 1符号位 8指数位 23尾数位——精度为2^23为7位（即6~7位有效数字）
double 1符号位 11指数位 52尾数位——精度为2^52为16位（即15~16位有效数字）

5.循环和switch

switch：
1.switch只能判断int和char类型的数据（C++中多了bool）；
2.当有多个case语句时，在内部会生成一个跳转表（如果只有一个语句可能就不会）；VS可以在debug调试环境下按alt+8进入反汇编环境查看。
3.switch中不能使用continue，可以使用break退出循环。因为switch不是循环，很容易理解。

for循环：
1.执行顺序：for（int i= 0；i < 20; i ++）先执行初始化语句i = 0,然后执行条件判断语句，如果满足条件，执行循环体，执行完循环体后，再执行i++，然后再执行循环体，直到i = 20退出循环。
2.for循环题目陷阱，当for循环语句的条件判断语句，如for（…；…=0；…）时，不会执行for循环，因为条件为假，应该为==。

while循环：
当条件判断为非0时，执行循环。

do while循环：
至少执行一次，条件为假时退出。while后的分号不能丢。

continue和break：
continue进入下一次循环，break则为结束循环，当跳出多重循环时，使用goto。

6.内存的分区及函数调用过程

内存分区：
1.栈区 存放参数和局部变量
2.全局区 存放字符串常量，代码，全局变量。
3.堆区 动态申请，手工释放。
栈的生长方向，由高到低
堆的生长方向，由低到高

函数调用过程：
1.按照调用约定传参
2.保存返回地址
3.跳到被调用函数的流程
4.保存上一层的栈帧地址（栈帧指的是特定函数在运行过程中对应的栈的一块空间）
5.分配局部变量空间
6.保存寄存器信息

传参约定：
1.标准约定：
（1）通过内存传参
（2）从右往左传参
（3）被调用方平衡栈

2.C约定：
（1）通过内存传参
（2）从右往左传参
（3）调用方平衡栈

变参函数参数可变，有两种方法决定参数是否已经读完：
1.约定一个结束值
2.提前告之参数个数

扩展之一：printf函数可变参数的实现机制（自行查询）

7.数组和指针

1.数组的批量赋值只能在初始化的时候。
2.数组的大小定义必须是常量，不可以是变量。（宏定义可以，直接替换）
3.二维数组初始化赋值时可以省略行值，但必须保留列值。
4.C语言的结构体中支持变长数组，如data[0]，可以重新分配地址空间实现变长。

1.两个指针相减，是地址的相减。
2.两个指针不能相加，没有意义。
3.空指针类型void* 只存地址，没有解释方式，指针如果有解释方式，变为void* 类型，可以直接转换，不需要强转。
4.对于二维数组，如int Value[3][3],可以定义int （*pValue）[3] = Value;（指针后的数值与数组的第二维值相等），然后可以直接使用指针来执行和这个数组有关的操作。
5.函数指针，注意其typedef定义后的使用情况。

#include <stdio.h>
        

typedef int(*func_max)(int ,int);

int max(int x, int y)
{
    if (x > y) return x;
    else return y;
}

int main(int argc, char* argv[])
{

        func_max func1;

    　　 func1 = &max;

        int x = (*func1)(10,15);

        printf("%d", x);
}

注：
1.如int a[5]，数组名a就是数组首元素的地址，加一后指向下一个元素，但是数组名的地址&a是整个数组的地址，&a+1是指向整个数组之外的下一个地址的元素，是未知的。
2.数组指针，指针数组和函数指针数组：
指针数组本质上是数组：char *Array[2]，其中每一个元素是指针。
数组指针本质上是指针，是指向数组的指针，char （*Array）[2]。
函数指针数组，就是一个数组，其中的每一个元素都是一个函数指针。
下面感受一下来自函数指针数组深深的恶意吧，哈哈：

#include <iostream>


using  namespace std;

int MyFunc1(int p,int q){return p%q;}
int MyFunc2(int p,int q){return p/q;}
int MyFunc3(int p,int q){return p-q;}

int (*ArrPMF[])(int,int)={MyFunc1,MyFunc2,MyFunc3};


int main()
{
    int nRes;
    nRes=1[ArrPMF](7,2);
    cout<<nRes<<endl;

    return 0;
}

1ArrPMF这种神奇而且玄幻的写法，真的让人一脸懵逼。
但是其实它和下面这种写法等价：

#include <iostream>

using  namespace std;

int MyFunc1(int p,int q){return p%q;}
int MyFunc2(int p,int q){return p/q;}
int MyFunc3(int p,int q){return p-q;}

typedef int (*PMF[])(int,int);

int main()
{
    PMF ArrPMF={MyFunc1,MyFunc2,MyFunc3};

    int nRes;
    nRes=ArrPMF[1](7,2);            cout<<nRes<<endl;
    return 0;
}

其本质：ArrPMF[1]>*(ArrPMF+1)<>*(1+ArrPMF)==>1[ArrPMF]；
3.const修饰指针：
const int *p = &a;

const修饰*p， *p不可变，p是指针，*p是指针p指向的内存单元里的内容，*p不可变也就是p指向的内存单元里的内容是不可变的。

int* const p = &a;

const修饰p，指针p是不可变的，也就是p指向的内存单元不可变。即p的指向不可变，p指向的内存单元的内容可以变。

8.宏，内联函数，和C++中模板

这三个放在一起讲，是因为这三个在程序代码里面的作用都有简化代码的作用。

宏：就是直接的替换，没有类型检查。
宏里面一个井号用于字符串化，两个井号用于连接token，配合使用用于复杂性模板编程。

#include <iostream>  
void quit_command(){  
    printf("I am quit command\n");  
}     
void help_command(){  
    printf("I am help command\n");  
}     
struct command  
{  
    char * name;  
    void (*function) (void);  
};    
#define COMMAND(NAME) {#NAME,NAME##_command}  
#define PRINT(NAME) printf("token"#NAME"=%d\n", token##NAME)  
main(){  
    int token9=9;  
    PRINT(9);  
    struct command commands[] = {  
        COMMAND(quit),  
        COMMAND(help),  
    };    
    commands[0].function();  
}  

得到的结果就是
token9=9
I am quit command

内联函数：
inline修饰的函数在编译时期，会尝试将函数内联
类似于宏，直接展开，但是有类型检查。
注！！：
1.内联涉及到优化，Debug版本不体现。
2.内联函数的实现必须在头文件中（方便编译器查找替换）
3.不是所有的函数都可以内联，具体是否会内联，由傲娇且聪明的编译器决定。
4.适合内联的函数是功能简单，代码较少，十几行且不带循环，但是使用非常频繁的函数。
5.内联虽然提高了效率，但是是以空间的消耗为代价的。
6.C++类里面的成员函数，都默认为内联函数，可以显式加inline修饰，不显式添加，也默认为内联函数。

模板：
适应所有类型的泛型编程，还带有类型检查。
模板的原理是：编译前替换，但是模板引用了各种关键字和语法，所以它更像一种编译前的语言（宏的升级）。

特点：
1.只有在模板实例化时，才做类型检查。
2.为了实现泛型编程，模板的实现代码，必须放在头文件中，且声明和实现必须写在一起，STL中的各种类，方法，几乎全是以模板的方式提供的。
3.有函数模板，也有类模板。

9.static

1.全局变量在各个源文件中都有效，加上static后，只在定义该变量的源文件中有效，在同一源程序的其它源文件中不可用，可以对其它源文件隐藏。
2.静态局部变量只会被初始化一次，即调用函数时，会在上次的值的基础上做操作。
3.静态变量与全局变量都会被自动初始化为0。

10.枚举

方便且又有类型检查，宏在预处理阶段替换，枚举在编译阶段替换。
枚举的第一个元素默认为0，后面的每一个元素依次加1。也可以自定义数值，后面的每一个元素仍然依次加1。

11.共用体

1.共用体内部的所有成员的内存空间是共享的，共用体的大小，由其内部的最大成员决定。因为内存是共用的，所以不能同时解析两种不同类型的成员。
2.共用体变量的地址和它各成员的地址都是同一地址。
3.共用体变量中起作用的成员是最后一次存放的成员，存入一个新成员后，原有成员失去作用。

12.结构体

1.结构体可以批量初始化，但是只有在声明变量的时候可以。
2.结构体的内存布局连续且内存对齐。
3.在传结构体参数时，一般传结构体指针，而不直接传结构体。
4.结构体通过“.”读取成员，结构体指针通过“->”读取成员。
5.不能通过memcpy的方法来比较两个结构体大小是否相等，因为虽然两个结构体相同，但是可能内存对齐方式不同。
6.有时候不能通过网络直接传输结构体给别人使用，因为不同的电脑可能设置的内存对齐方式不同。
7.可以通过预编译指令来设置对齐值：#pragma pack（1）。

13.堆

1.堆是一种树结构，是操作系统内存管理所划分的一块区域。
2.C中使用malloc和free来申请堆，初始化的内存初始化为cd，申请的堆设置上溢标志和下溢标志fd。
3.申请的资源如果不释放，就容易造成内存泄露。
4.释放资源后，将之前指向的指针指向NULL无效值，防止野指针。

14.C语言文件操作

1.主要函数有fopen，fclose，fread，fwrite，fgetc，fputc，fgets，fputs，fprintf，fscanf，feof，ftell，rewind 和fseek。
2.fopen的属性：
w：写打开，如果文件不存在，会创建一个新的文件，如果文件已经存在，原内容会被摧毁重置。
r：读打开，文件必须存在。
r+：可读可写，文件必须存在。
b：binary，二进制形式打开。不用二进制形式打开，会默认使用文本模式打开，文本模式会将换行进行转换成符号。

文件读写的缓存机制：
fwrite后的数据不一定马上被写入到文件中。
缓冲机制：会积攒了一定的数据后，再一口气写入。
缓冲区没满，也会被写入文件的情况由：1.fclose。2.fflush。

15.位运算，逻辑运算

位运算：&，^，|，~
从改变标志上来看：
&是用于关闭标志的运算。
|是用来开启标志的运算。
^是用来切换标志的运算。
异或的可逆性：
Value^key==>newValue；
newValue^key==>Value；

逻辑运算：&&，||，！
注意在程序代码里面，当||左边的条件满足为真时，不会执行||右边的代码，只有当左边的条件为假时，才会去执行右边的代码。
&&时，当左边的为假时，将不会执行右边的代码，只有当&&左边的代码为真时，才会执行右边的代码。

16.运算符优先级

1.结合方向只有三个是从右往左，其余都是从左往右。
2.所有双目运算符中只有赋值运算符的结合方向是从右往左。
3.另外两个从右往左结合的运算符也很好记，因为它们很特殊：一个是单目运算符，一个是三目运算符。
4.C语言中有且只有一个三目运算符。
5.逗号运算符的优先级最低，要记住。
6.此外要记住，对于优先级：算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符。逻辑运算符中“逻辑非 !”除外。