C++复习笔记7

1.C++内存分区

C++内存分区：代码区：存放函数体的二进制代码，由操作系统管理

全局区：存放全局变量静态变量和常量。

栈区：编译器分配，存放函数的参数值和局部变量等。

堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

内存分区的意义：不同区域存放的数据，赋予不同的生命周期，让变成更加灵活。

之前写的代码都存放在代码区。

程序编译后，生成exe可执行程序，未执行该程序前分为两个区域。（未运行前的两个区）

代码区：

存放CPU执行的机器指令

代码区是共享的（对于频繁被执行的程序，在内存中只保存一份即可）

代码区是只读的（防止程序意外地修改了它的指令）

全局区：

全局变量和静态变量存放在此

全局区包含常量：字符串常量和其它常量

该区域的数据在程序结束后由操作系统释放。

const修饰的局部变量作为常量貌似存在了栈区呢?

#include<iostream>
using namespace std;
//创建全局变量
int g_a = 10;
int g_b = 10;

const int c_g_a = 10;

int main()
{
	//创建普通的局部变量
	int a = 10;
	int b = 10;

	cout << "局部变量a的地址为:" << (int)&a << endl;
	cout << "局部变量b的地址为:" << (int)&b << endl;

	cout << "全局变量g_a的地址为:" << (int)&g_a << endl;
	cout << "全局变量g_b的地址为:" << (int)&g_b << endl;
   
	static int s_a = 10;
	static int s_b = 10;
	cout << "静态变量s_a的地址为:" << (int)&s_a << endl;
	cout << "静态变量s_b的地址为:" << (int)&s_b << endl;
	
	//常量分为字符串常量和const修饰的变量，const可以修饰局部变量和全局变量
	cout << "字符串常量的地址为:" << (int)&"Hello World" << endl;

	//const修饰的局部变量
	const int c_s_a = 10;
	cout << "const修饰的局部变量的地址为:" << (int)&c_s_a << endl;

	//const修饰的全局变量
	cout << "const修饰的全局变量的地址为:" << (int)&c_g_a << endl;
	
	system("pause");
	return 0;
}

 c语言利用malloc函数和free函数申请堆区空间：

1.要自己计算大小 2.要把返回的void*强转为其他类型指针 3.要判断返回值是否为NULL。

需要动态申请内存空间的两个场景：

(1).开辟的连续数组空间大小只有运行后才能确定

//栈：局部变量 函数的参数
//堆： malloc new
//静态常量： static 字符串常量
//int* ptr = malloc(); //指针在栈区，申请的空间在堆区

//malloc calloc realloc _alloca
#include<iostream>
using namespace std;

void main()
{
	int n;
	cin >> n;
	int ar[10] = { 0 };

	int* ptr = (int*)malloc(sizeof(int) * n);//动态开辟空间需求1 数组
	{
		if (NULL == ptr)
		{
			cout << "Out of Memory" << endl;
			return;
		}
		free(ptr);
		ptr = NULL;
	}

	if (ptr != NULL)
	{
		*ptr = 10;
	}

}

(2)成员变量的指针开辟空间，存放数据。

class Stu
{
public:
	Stu(const char* name, int age)
	{
		//m_name = name;//指针不能直接赋值
		this->m_name = (char*)malloc(strlen(name) + 1);//动态内存申请需求1 构造函数
		strcpy(m_name, name);
		this->m_age = age;

	}

private:
	char* m_name;
	int m_age;
};

void test02()
{
	Stu s("abc", 20);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

C语言_alloca函数在栈区动态开辟空间，不能free释放，比较特殊。

//void* _alloca(size_t size);

void test01()
{
	int* ptr = (int*)_alloca(sizeof(int) * 10);
	//free(ptr);//栈区申请，不用释放
}

c++中的new和delete操作符也是在堆区申请和释放空间的。

1.new delete 开辟或者释放单个对象的空间。new [] 和delete[]申请和释放多个连续的对象空间，相当于搞了一个数组。

2.new操作符不用计算开辟空间大小，不用强转指针，不用判空。

3.malloc free new delete底层实现不一样，不能混用。

4.new 和delete 会调用构造函数，new Test[10]就调用10次，析构也一样。new[]和delete[]必须对应，不然会出现内存泄漏。注意顺序是new开辟空间->调用构造函数->调用析构函数->delete释放空间

5.new对象数组时，类必须有默认构造函数。

6.操作符new和操作符delete即operator new 和operator dalete重载是通过malloc和free实现的，它们的功能仅申请空间，与构造析构无关。

7.打断点可以发现，使用new 和 delete操作符时，会先调用operator new开辟空间，然后调用构造函数进行初始化，接下来调用析构函数销毁数据，最后调用operator delete释放空间。

8.实际在编译器底层也是对new和delete操作符进行了多种重载，执行重载的同时 调用了构造和析构函数。

#include<iostream>
using namespace std;

//c++

//重载new
void* operator new(size_t sz)//无符号类型整形
{
	void* ptr = malloc(sz);
	return ptr;
}

void operator delete(void* ptr)
{
	free(ptr);
}

void* operator new[](size_t sz)//无符号类型整形
{
	void* ptr = malloc(sz);
	return ptr;
}

void operator delete[](void* ptr)
{
	free(ptr);
}

void test00()
{
	int* ptr = (int*)malloc(sizeof(int)*10);
	if (NULL != ptr)
	{
		cout << "Out of mamery" << endl;
		return;
	}
	free(ptr);
}

void test01()
{
	int* ptr = new int;
	*ptr = 10;

	delete ptr;
}

void test02()
{
	int* ptr = new int[10];
	delete[] ptr;
}

void test03()
{
	int* ptr1 = (int*)malloc(sizeof(int));
	*ptr1 = 10;
	free(ptr1);

	int* ptr2 = new int(10);
	delete ptr2;
}

class Test
{
public:
	Test(int d=0)
	{
		this->m_data;
		cout << "Creat Test Obj" <<endl;
	}
     
	~Test()
	{
		cout << "Destory Test Obj" << endl;
	}
private:
	int m_data;
};

void test04()
{
	//Test t;
	Test* pt1 = (Test*)malloc(sizeof(Test));//空间申请和空间释放
	free(pt1);

	Test* pt2 = new Test(10);//1申请空间，2初始化对象（调用构造函数）//new操作符
	delete pt2;              //1调用析构函数 2释放空间
}

void test05()
{
	Test* ptr = new Test[10];//new对象数组时，类必须有默认构造函数
	//delete ptr;//malloc 和free不能混用，底层记录的信息和实现细节不对应
	delete[] ptr;
}

void test06()
{
	Test* ptr = new Test;
	delete ptr;
}

void test07()
{
	Test* ptr = (Test*)operator new(sizeof(Test));//操作符new，不调用构造析构仅申请释放
	operator delete(ptr);
}

int main()
{
	test07();

	system("pause");
	return 0;
}

回调函数来处理申请失败的问题。

void OutOfMemory(void)
{
	cout << "OutOfMemory" << endl;
	exit(1);
}

void test01()
{
	set_new_handler(OutOfMemory);
	int* ptr = new int[536870911];
    
	if (ptr == NULL)
	{
		cout << "aaaaaaaaaaaaa" << endl;
	}
	cout << "bbbbbbbbbbbbbb" << endl;
}

       new和delete也可以在类内重载，类内有优先调用类内的，没有就调全局的，再没有就调底层已经实现的。

class Test
{
public:
	void* operator new(size_t sz)//无符号类型整形
  	{
		void* ptr = malloc(sz);
		return ptr;
	}

	void operator delete(void* ptr)
	{
		free(ptr);
	}

	void* operator new[](size_t sz)//无符号类型整形
	{
		void* ptr = malloc(sz);
		return ptr;
	}

		void operator delete[](void* ptr)
	{
		free(ptr);
	}

	
	Test(int d = 0)
	{
		this->m_data;
		cout << "Creat Test Obj" << endl;
	}

	~Test()
	{
		cout << "Destory Test Obj" << endl;
	}
private:
	int m_data;
};

void test02()
{
	int* ptr = new int;//调全局
	Test* pt = new Test;//调类内
}

 针对内置数据类型进行申请时，malloc和new区别不大。

#include<iostream>
using namespace std;

void test01()
{
	//申请内置数据类型区别不大
	int* ptr = (int*)malloc(sizeof(int));
	int* ptr2 = new int;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

定位new，在原有空间的指定位置放一个对象，这个对象是在堆上new出来的。基本语法如下：

#include<iostream>
using namespace std;

class Test;

void* operator new(size_t sz, void* ptr, int pos)
{
	return &((int*)ptr)[pos];
}

class Test
{
public:

	Test(int d = 0)
	{
		this->m_data=d;
		//cout << "Creat Test Obj" << endl;
	}

	~Test()
	{
		//cout << "Destory Test Obj" << endl;
	}
private:
	int m_data;
};

void test01()
{
	//int* ptr = (int*)malloc(sizeof(int)*10);
    //定位new
	int ptr[10];
	Test t[10];

	//new(ptr,5) int(100);
	 new (t, 5) Test(200);

}

int main()
{
	test01();
	system("pause");
	return 0;
}