C-class Week2.Day9 & test2 summary

指针

指针数组和数组指针：

指针数组：

​ 是由指针组成的数组，里面都是指针，它的成员都是指针变量。

​ 类型 *arr[长度]； int *arr[10];

数组指针：

​ 专门指向数组的指针

​ 类型 （*arr）[长度];

#include<stdio.h>

int main(int argc,const char* argv[])
{
    int arr[10]={0,1,2,3,4,5,6,7,8,9};

    /*int* arrp[10];
    for(int i=0;i<10;i++)
    {
        arrp[i] = &arr[i];
        printf("%d %d\n",arr[i],*arrp[i]);
    }
    return 0;*/
    
    int *p1 =(int*)(&arr+1);
    printf("%d\n",*(p1-1));

    int (*p2)[10]=&arr;
    for(int i=0;i<5;i++)
    {   
        printf("%d\n",(*p2)[i]);
    }   
    //int (*arrp)[10] = &arr;
    //printf("%u %u\n",&arr,&arr+1);
    //printf("%p %p %p %p\n",arrp,&arr,arr,&arr[0]);
    return 0;
}

指针与数组名：

​ 数组名是一种特殊的指针，它是常量，不能修改他的值， 它与数组内存是映射关系，没有自己空间。

​ 数组名 == &数组名 == &数组[0]

​ 指针变量有自己的储存空间，如果它储存的是数组的首地址，指针可以当做数组使用，数组名也可以当做指针使用。

​ 数组名[i] == *(数组名+i)；

​ *(指针名+i) == 指针名[i]；

​ 数组作为函数参数传递时，就会变成指针，所以长度丢失。

int arr[5] = {0,1,2,3,4};
int *p1 =arr;
int *p2 = &arr[0];
for(int i=0;i<5;i++)
{
	printf("%d ",p[i]);
    printf("%d ",*(p2+i));
    printf("%d ",*(arr+i));
}

二级指针：

​ 二级指针就是指向指针的指针。里面储存的指针变量的地址。

定义：

​ 类型** 变量名_pp;

赋值：

​ 变量名_pp = 地址；

​ 变量名_pp = &指针变量；

解引用：

​ *变量名_pp == 一级指针变量 p

​ **变量名_pp == 普通变量的值

注意：

​ 当函数之间需要共享指针变量时，必须传递二级指针

//数组指针就是二级指针
int arr[5]={0,1,2,3,4};
int (*pp)[5] = &arr;
printf("%d\n",**pp);

void swap(int **pp1,int **pp2)
{
    int *temp = NULL;
    temp = *pp1;
    *pp1 = *pp2;
    *pp2 = temp; 
}

int main()
{
	int num1 =1234,num2 = 5678;
    int *p1 = &num1,*p2 = &num2;
    printf("原版---%d %d\n",num1,num2);
    printf("原版指针----%d %d\n",*p1,*p2);

    swap(&p1,&p2);
    printf("交换后---%d %d\n",num1,num2);
    printf("交换后指针----%d %d\n",*p1,*p2);
	//结果为 num1与num2位发生改变、*p1 与 *p2 交换了值
}

函数指针：

​ 函数返回值 （*函数指针名p)(参数列表）；

	int scanf(const char *format,...);

​ 函数名就是个地址（整数），它代表了函数在代码段中的位置。可以通过函数指针，来指向某个函数。

储存的就是函数在代码段中的位置。

​ 可以通过函数指针，把函数作为参数传递给另一个函数，这叫回调。

堆内存

什么是堆内存：

​ 是进程中的一个内存段（text data bss heap stack），由程序员手动管理。

​ 特点是足够大，缺点使用较为麻烦。

为什么要使用堆内存：

​ 1、随着程序的复杂、数据会越来越多。

​ 2、其他的内存段的申请和释放都不受控制，堆内存的申请和释放都受程序员控制

如何使用堆内存：

​ 在C语言中没有控制堆内存的语句，只能使用C标准库中提供的函数来使用堆内存。

#include<stdlib.h> 头文件

void malloc(size_t size);

	void *malloc(size_t size);
	int *p = malloc(4)

功能：从堆内存中申请size个字节的内存，申请的内存中存储的内容是不确定的

size: 表示要申请的字节数大小

返回值：成功时返回成功申请到的内存的首地址，失败时返回NULL

void free(void *ptr);与malloc捆绑使用

    void free(void *ptr);
	free(p);
	p = NULL;

功能：释放一块内存，NULL可以释放，但是不能连续释放和释放非法地址。

ptr： 要释放的堆内存的首地址。

注意：堆内存不要连续释放，释放后及时置空，空指针可以连续释放。

​ 释放的只是使用权、不会专门去清理全部数据

void *calloc(size_t nmemb, size_t size);

	void *calloc(size_t nmemb, size_t size);
	int *p =calloc(10,sizeof(int));

功能：从堆内存中申请nmemb块大小为size字节的内存,申请到的内存块会被初始化为0。

​ 特点 速度慢、

注意：申请到的依然是一块连续内存

void *realloc(void *ptr, size_t size);

	void *realloc(void *ptr, size_t size);

功能：改变已有的内存大小

ptr: 要改变大小的内存的首地址

size：你要想改变之后的大小，会在原有的内存上添加或者删除内存空间。因为后面连续的内存可能会被他人使用，

会拷贝当前空间 到后面未使用空间从新定义一个空间新的首地址来实现你所需要的空间大小。

返回值：返回调整后的内存块的首地址。

考试总结：

1.以后再看到0开头或者0x开头的数字一定要转成 八进制，或者十六进制

2.数组越界的后果

​ 1、可能一切正常

​ 2、可能段错误

​ 3、可能产生脏数据

3.sizeof（ ）只会猜测括号内字节数最多的类型，并不会计算括号内的算式。

4.把float类型数赋值给int类型数组会导致小数点和后面的数据被抹除 ，但是成功运行。

5.无符号和有符号数一起计算 结果为无符号

6.text 代码段中存放二进制文件，常量。

7.const如果修饰 被初始化过的全局变量 会被放在代码段

8.代码阅读题 需要结合代码进行分析，不要脱离代码谈理论。

9.static 延长了生命周期，导致第二次程序运行时，初始化语句失效

10.time（NULL)

	yyyy-mm-dd-hh-mm-ss;

	ss = sec%60;

	mm = sec/60%60;

	hh = sec/3600%24;
	
	bool is_leap(int year)
	{
		return ~
	}
	
	void dtd(day)
	{
		int year = 1970;
		while(day>=365)
		{
			day -= (365+is_leap(year));
			year++;
		}
	
	int month[12]={31,28,30,31,30,31,30,31,31,30,31,30,31};
	
	month[1] +=28 is_leap(year);
	int month = 1;
	for(int i=0;month[i]<day;i++)
	{
		day -= month[i];
		month++;
		}
	}