2021-7-1

栈区的空间是自动进行分配和释放的，由系统进行

int main()
{
	int a;//内存随机分配，随机值
	int* p;//野指针
	int* s = NULL;//0
	int* s = nullptr;//(void*)0
}

失效指针：原来指向这个空间是有效的，随着程序的运行，变成无效的。

int* fun()
{
	int ar[10] = { 12,23,34,45,56,67,78,89,90,100 };
	int* p = &ar[0];
	return p;
}
int main()
{
	int* ip = fun();//p是失效指针
	for (int i = 0; i < 10; ++i)
	{
		printf("%d", *ip);//输出的是乱码
		ip = ip + 1;
	}
	return 0;
}

int* fun()
{
	int ar[10] = { 12,23,34,45,56,67,78,89,90,100 };
	int* p = &ar[0];
	for (int i = 0; i < 10; ++i)
	{
		printf("%d", *p);
		p = p + 1;
	}
	printf("\n");
	return p;
}
int main()
{
	int* ip = fun();
	for (int i = 0; i < 10; ++i)
	{
		printf("%d", *ip);
		ip = ip + 1;
	}
	return 0;
}
//1M=1024*1024,否则ip为失效指针

结构体相当于一个类型，自定义的

结构体变量分配空间，结构体本身不占有资源

struct Date
{
	int year;
	int month;
	int day;
};
int main()
{
	int x;//4
	Date a;//12
}

对结构体赋值用花括号{ }括起来

struct Date
{
	int year;
	int month;
	int day;
};
int main()
{
	int a = 10;
	Date d = { 2000,12,23 };
	printf("%d\n", a);
	printf("%d %d %d\n", d.year, d.month, d.day);//成员变量的赋值是用.
	return 0;
}

只能访问结构体变量，不能访问结构体本身

struct Date
{
	int year;
	int month;
	int day;
};
int main()
{
	int a = 10;
	int* ip = &a;
	*ip = 100;
	Date dx = { 2000,12,23 };
	Date* dp = &dx;
	(*dp).year = 1900;//dp->year = 1900;
	return 0;
}

如何计算结构体的大小？面试中常考

文件

输入，输出流有缓冲区

文件类型

1.文本文件：以字符ASCII编码的形式保存

2.二进制文件：内存中的数据，适用于非字符为主的数据

stdin	标准输入文件	键盘，scanf( ),getchar( )
stdout	标准输出文件	显示器，printf( ),putchar( )
stderr	标准错误文件	显示器，perror( ),无缓冲区
stdprn	标准打印文件	打印机

关键字

const关键字，文件名为.cpp下起作用

可读不可写，修饰变量，指针，数组等

在编译时替换，

int main()
{
	const int a = 10;
	int b = 0;
	int* ip = (int*)&a;
	*ip = 100;
	b = a;
	printf("a = %d\n", a);//10
	printf("b = %d\n", b);//10
	printf("*ip => %d\n", *ip);//100
	return 0;
}

若此程序以.c文件名运行时，运行结果为100,100,100

在.c和.cpp文件名下的运行结果不一样

把内存中的数据拉入到CPU中进行计算，然后再返回给内存，CPU运行速度慢

大块数据交给DMA进行移动，将CPU的资源空出来加大处理速度

mov eax,10---直接访问，把10给eax
mov [eax],10---间接访问，把10给eax所在的地址

int main()
{
	const int a = 10;
	const int* ip = &a;
	int* ip = &a;//error
	int* ip = (int*)&a;//出现强转，则意味着不遵循编程规则 
	return 0;
}

sizeof:字节个数，在编译时计算

int main()
{
	int a = 10;
	int ar[10] = { 12,23,34,45 };
	int size = sizeof(a);//4
	size = sizeof(ar);//40
	return 0;
}

int main()
{
	char stra[] = { "yhping" };
	int len = strlen(stra);//6，长度，遇到\0就结束
	int size = sizeof(stra);//7,有\0，空间大小
	return 0;
}

int main()
{
	const char* s = "yhping";
	int size = sizeof(s);//指针大小，4字节
	size = sizeof("yhping");//字符串的大小
	return 0;
}

int main()
{
	int a = 10;
	int size = sizeof(++a);//4
	size = sizeof(a + 0.8);//8//double类型
	printf("a = %d", a);
	return 0;
}

typedef关键字

把一切合法的变量名转换为类型名，注意作用域

为复杂的声明定义简单的类别

typedef unsigned char u_int8;
typedef unsigned short u_int16;
typedef unsigned int u_int32;
typedef unsigned long long u_int64;
int main()
{
	u_int8 a;//unsigned char a
	u_int64 x;//unsigned long long x
}

struct ListNode
{
	int data;
	ListNode* next;
};
typedef ListNode* LinkList;
int main()
{
	ListNode* p;
	LinkList s;
}

typedef struct ListNode
{
	int data;
	ListNode* next;
}*LinkList;
int main()
{
	ListNode* p;
	LinkList s;
}

struct ListNode
{
	int data;
	ListNode* next;
};
ListNode ListNode;//只要不是关键字即可
int main()
{
	return 0;
}