Cday01---内存分区

1.概念

数据类型是为了更好地进行内存管理，让编译器能确定分配多少内存。

2.typedef用法

把定义合在一起时

当要定义两个char*的指针时，可以使用typedef定义


当某个数据类型因为平台编译器或者C++标准的原因，导致无法识别时，可以使用typedef来跨平台，让程序拥有良好的可移植性。

注释

2.void用法

void不能直接定义变量，因为编译器不知道给它分配多少内存。
void无类型指针占四个字节，是所有类型指针的祖宗，都可以不通过强制转换就可以变为void类型。

void test4()
{
	void* p = NULL;

	int* pInt = NULL;
	char* pChar = (char*)pInt;

	void* pVoid = pInt;
}

*void 主要用于数据结构的封装

3.sizeof操作符

struct Person
{
	char a;
	int b;
};

void test1()
{
	cout << "int size:" << sizeof(int) << endl;
	double a = 3.14;
	cout << "a size:" << sizeof a << endl;
	cout << "Person size:" << sizeof(struct Person) << endl;
}

int main()
{
	test1();
	return 0;
}

默认的对齐模式是8，所以结构体Person的内存空间为8，当设置对齐模式为1后，空间占用变为了5

#pragma pack(1)
struct Person
{
	char a;
	int b;
};

void test1()
{
	cout << "int size:" << sizeof(int) << endl;
	double a = 3.14;
	cout << "a size:" << sizeof a << endl;
	cout << "Person size:" << sizeof(struct Person) << endl;
}

int main()
{
	test1();
	return 0;
}

计算数组大小

4.变量的间接赋值

struct Person
{
	char a;
	int b;
	char c;
	int d;
};

void test1()
{
	struct Person p = { 'a',100,'b',200 };
	cout << p.d << endl;
	p.d = 1000;

	/*每次地址+1是跳当前类型所占字节数，比如int+1就是增加4个字节，double+1就是增加8个字节，
	所以这里如果是struct+1就是跳8个字节，加上char *表示每次增加1个字节，精确控制位置*/
	/*这里的d相对于首字节偏移了12个字节单位*/
	printf("%d\n", (char*)&p + 12);
	printf("%d\n", &(p.d));
}

int main()
{
	test1();
	return 0;
}

*此时知道了d的首地址，如何取出d的数据呢？由于d的类型是int，所以要取4个字节，即加上int 表示4个字节

	printf("%d\n", *(int*)((char*)&p + 12));

5.内存分区概念

全局区和静态区的变量生存周期不同，作用域也不同。static int a叫内部链接属性，int a叫外部链接属性。外部链接指某个变量可以在当前程序下的不同文件中可以访问，而内部链接只能在当前文件下可见。常量区存放字符串常量和const修饰的全局变量，例如"Hello World"。常量区的数据一旦初始化则不能修改，即该区域受到保护，为只读内存。

6.栈区

int* myFunc()
{
	int a = 10;
	return &a;
}

void test1()
{
	int* p = myFunc();
	printf("*p=%d\n", *p);
}

int main()
{
	test1();
	return 0;
}

这里无法输出结果，因为局部变量a=10在栈上，此时生存周期已经结束，内存已经回收。

char* myFunc()
{
	char str[] = "hello world!";
	return str;
}

void test1()
{
	char* p = myFunc();
	printf("*p=%s\n", p);
}

int main()
{
	test1();
	return 0;
}

这里也无法输出正确结果，str在栈上，"hello world!"在常量区。

当调用getString函数后，str的内存地址赋给了s后被释放。

7.堆区

堆的内存成员手动申请，手动释放

#define _CRT_SECURE_NO_WARNINGS
//注意这里是C代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* getSpace()
{
	int* p = malloc(sizeof(int) * 5);
	if (p == NULL)
		return NULL;

	//只要是连续的内存空间，就能使用下标的方式访问内存
	for (int i = 0; i < 5; i++)
	{
		p[i] = 100 + i;
	}
	return p;
}

void test1()
{
	int* ret = getSpace();
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", ret[i]);
	}

	//用完堆内存一定要释放
	free(ret);
	ret = NULL;
}

int main()
{
	test1();
	return 0;
}

变量p位于栈上，占用4个字节，p内部存放的地址在堆上。当调用getSpace函数后，将p保存的值赋给ret，位于栈上的变量p释放掉，而堆上的20个字节不会释放。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void allocateSpace(char* p)
{
	/*分配内存
	定义变量时一定要初始化
	*/
	p = malloc(100);//申请内存
	memset(p, 0, 100);//初始化
	strcpy(p, "hello world!");
}

void test1()
{
	char* p = NULL;
	allocateSpace(p);
	printf("p=%s\n", p);
}

int main()
{
	test1();
	return 0;
}

这里allocate的形参p为局部变量，当函数结束时会被释放。同时会失去堆内存的地址，造成内存泄漏，无法释放堆内存。

void allocateSpace(char** p)
{
	/*分配内存
	定义变量时一定要初始化
	*/
	*p = malloc(100);//申请内存
	memset(*p, 0, 100);//初始化
	strcpy(*p, "hello world!");
}

void test1()
{
	char* p = NULL;
	allocateSpace(&p);
	printf("p=%s\n", p);
}

取地址相当于升型，即一级指针p变为二级指针。不管几级指针和属于什么类型，都只占4个字节。

8.extern和static的区别

某个文件中定义的变量，在另一文件中可以先声明然后直接使用，让链接器去找这个变量的定义。

int g_a = 666;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//头文件不参与编译，每一个.c文件叫做一个编译单元
//编译器独立编译每一个.c文件

void test1()
{
	//先声明变量名让编译通过，然后让链接器去寻找变量定义
	extern int g_a;

	printf("g_a = %d\n", g_a);
}

int main()
{
	test1();
	return 0;
}

头文件中只放声明，不放定义。

9.const全局和局部变量区别

局部变量可以通过间接方式修改。

10.字符串常量区

void test1()
{
	char* p = "hello world!";

	printf("%d\n", &"hello world!");
	printf("%d\n", p);
}

void test1()
{
	char* p1 = "hello world!";
	char* p2 = "hello world!";
	printf("%d\n", p1);
	printf("%d\n", p2);
}