C语言1. 指针+二级指针 + 知识点杂

1. 接收多行输入：
   while(scanf()!=EOF)
   {}
2. 两个char加
   内部用ascall加，再转char
3. sizeof()返回无符号整型
4. 整型提升：
   截断：
   char a = -1
   给char32位存不下，只存低8位
   char a = 0xb6;
5. C的整型运算至少以缺省整型类型精度进行，为获取精度，先转为普通整形，对short（两个字节）和char先做整型提升，高位补充符号位。
   最后运算比如做+, 结果取低8位
   char c = a+b
   char c存a+b中先各自做整型提升后的和的低8位
   如果最后输出 “%d” c，把char转了int，又作提升，高位补符号位，
   此时是补码（之前一系列操作也都用补码计算）最后输出又计算为源码对应int值, char归类也为整型，只要是整形在内存中都以补码存
   char c= 1;
   sizeof© = 1
   sizeof(+c)=4 这里整型提升后参与sizeof 所以长度是4
   两个操作符属于不同类型，会向上转换，int->unsigned int -long int->float …
6. 调试：
   第一种F10调试，单步执行，不进入调用的其它函数
   第二种F11调试，单步执行,进入调用的其它函数
7. 表达式计算路径
   如果通过优先级不能确定表达式的唯一计算路径，那么这个表达式是存在问题的

指针

1. 指针实际意义是地址（唯一标识一块空间），但口语中指针是变量 初始化可以直接给NULL
   int* pa = &a
   &a是一个地址
   一个内存单元是一个字节,
   2^32个地址是4GB内存
   64位机器，有64个地址线，一个指针变量为8字节，32位平台是4字节
   x86是32位环境
   x64是64位
   sizeof返回无符号整型 unsigned int printf(zu)
2. 指针类型
   所有类型指针大小固定，但区分有必要
   可以通过类型转换
   如果把int类型指针给了char，且通过强制转换不会报警告，在使用该char指针解引用修改值时只会对1个内存单元的地址存值做改变因为char大小为1，指针类型决定指针被解引用时访问几个字节。
   int类型指针+1，地址增加4个字节，char类型指针+1地址增加1个字节

指针类型决定指针+1或-1的步长，就像整型数组指针+1时，会到下一个int类型的值位置-

int类型和float类型指针+1都走4个字节，但是内存解读方式有差异，比如存100和100.0，在内存中值不一样，不同类型指针不能混用
double类型指针大小为4，但+1会向后访问8
它的变量大小是4字节，变量里存着首地址，但double类型权限能存8个字节。

因为用char类型指针接收int类型，解引用只修改了1个字节内容，而不会把内存a中全部数据改变。
int a = 0x11223344;
char* pc = (char*)&a;
*pc = 0;
================================
这里的p是short类型接收arr,
后面for中+1每次只会走2个字节，所以它能修改的值只有int arr中的前2个。
int arr[] = {1,2,3,4,5};
  short *p = (short*)arr;
  int i = 0;
  for(i=0; i<4; i++)
  {
    *(p+i) = 0;
  }

总之，指针类型决定解引用访问权限(即可修改的大小)，所以char类型指针接收int类型数据，修改只能修改低8位数字。且决定+1，-1挪动多少，上面例子中的short之所以只能改变arr中两个数字，就是因为它挪动两次才是一个int类型的长度。

3. 野指针
   指针指向位置不可知（随机，没有明确限制）
   由于未初始化，所以给的是随机值，*p可能会出错

int* p;
*p = 10;

①这里p没有初始化，指针必须初始化：给一个地址，即=&a，上面方式：p的地址是一个随便找的地址，可能会被其他值覆盖，是非法地址。p就是野指针
②指针越界访问，也会变成野指针，比如a[10], 而使用*(p+10)就会越界
③ 当

 int* test()  { int a = 10; retunr &a;}
   int main( int* p = test();)
   这里输出*p可以有结果，但是不一定永远能是10，因为可能被别的变量占用

这里p能找到之前a的地址，但是不能访问，因为函数调用完空间就销毁了，这里的p也是野指针。
注意：创建指针就给 = &的习惯避免野指针。如果不知道给啥值，可以初始化为NULL，等后续再给&地址。
针对初始化=NULL的指针，习惯上防止出错经常写：

int* p = NULL;
if(p3!=NULL){ *p3 = a;}
if(p3) // 也可以，但是建议(p3!=NULL)
这里把p初始为NULL，相当于在标记注意是野指针，因没初始化，所以使用时注意先初始化

总结避免使用野指针：

1. 指针需要&给地址初始化： int* p = &
2. 小心指针越界
3. 指针指向空间释放即使置为NULL
4. 避免局部变量的地址（不能在调用函数的内部返回局部变量地址）
5. 使用之前检查有效性 if(p!=NULL)

4. 指针运算
   如果有a[5]，，如果val = &a[0], 可访问的只有val < &a[5]。且可以用val++ = 0;赋值， 虽然val++中有++，但是*靠着val，所以先执行解引用，赋值完才移地址。而只是挪动地址，直接对p++即可。
   循环遍历：

int arr[10] = {0};
int sz = sizeof()/sizeof();
int* p = arr;
// 范围是从0到小于sz
for(int i =0; i<sz;i++) {}

指针（必须指向同一片空间）减法：
指针-指针得到的绝对值是两者之间元素的数量
string 字符串的结束： ‘\0’
c语言用“”标记string

数组的本质 arr[i] 编译器会自动转为： *(arr+i)

之前求字符串长度：用1.递归、
2. 自定义函数 strlen(char str*)
{利用 while(*str!='\0'), str++, count++}
两种方式求string长度，
3. 利用指针减法，和2区别是不需要count++，直接str++到最后减去起始指针位置

二级指针：存放一级指针变量的地址

int a = 10;
int* pa = &a;
int** paa = &pa; // 存的是pa指针的地址
**paa的值是10

int *p[10]; 是创建指针的数组，数组内存存的是指针
int (*p)[10]是数组的指针，p指向存放整型数据的数组.

指针数组
多个元素的地址可以放在指针数组中：这个pa中存了多个地址
int *p[10]是一个指针数组，是存放指针的数组。

*(par[i])直接*加数组元素访问指针数组中指向的数字

二级指针存储二维数组

这里的parr[i][j]已经解引用了, 对于一级指针，par[i] ==(par+i) *