/**
    
       C++ 动态内存
       C++ 程序中的内存可分为两个部分
       1： 栈 ：在函数内部声明的所有变量都将占用栈内存
       2：堆：这个是程序中未使用的内存，在程序运行时可用于动态分配内存
       3：在C++中您可以使用特殊的运算符为给定的类型的变量在运行时，分配堆内的内存，它会返回分配的地址空间，
          这种运算符就是 new,如果不需要动态分配的内存空间，可以使用 delete运算符来删除之前通过new运算符申请的内存空间
    */

    std::cout << std::endl;

    // 1:给数组动态分配内存
    // int *foo;  foo = new int[5];  : 系统为 int类型的五个元素动态分配空间，并返回指向序列的第一个元素的指针，该指针被分配给foo (指针)。
    // 因此，foo现在指向一个有效内存块，这个内存块包含五个int类型元素空间

    int *p1 = new int; // 定义一个int类型指针,int类型占四字节，取值范围：-2147483648 - 2147483647
    *p1 = 5; // 给：指针保存的内存地址 对于的值 写入一个5
    *p1 = *p1 + 10000; // 修改刚刚的值
    cout << "输出指针p自身的内存地址：" << p1 <<endl;
    cout << "输出指针P保存内存地址对于的值:" << *p1 << endl;

    // 删除之前指针申请的内存
    delete p1;

    // 重新申请新的内存
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
    p1 = new int[10];
    for (int i = 0; i < 10; i++)
    {
        p1[i] = i + 1;
        cout << "输出p1指针保存的内存地址 对于的值" << p1[i] << endl;
        cout << "输出p1指针保存的内存地址" << &p1[i] << endl;
        std::cout << std::endl;
        
    }
    std::cout << std::endl;
    cout << "输出指针p1自身的内存地址：" << &p1 << endl;
    cout << "输出指针p1保存的内存地址：" << p1 << endl;

    // 释放指针
    delete p1;

为什么要动态内存申请
1．定义数组的时候数组的长度是预先定义好的，在整个程序中固定不变;
2．但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定
3．为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数可以按需要动态的分配内存空间，也可把不再使用的空间回收再次利用.

动态申请常用函数

涉及 malloc , calloc , realloc , free四个函数，

头文件：#include <stdlib.h>

1.malloc函数

函数原型：void *malloc (unsigned int num bytes);

返回值：

1. 分配成功时：返回分配空间的起始地址
2. 分配失败时：返回NULL

特点：

1. 对丁malloc的返回值一般要强制类型转换
2. malloc申请的空间内容不确定一般使用memset函数进行清空（ void *memset(void *str, int c, size_t n) ）
    

2.free函数

函数定义:void free(void *addr)
功能：释放堆区空间
注意addr指向的内存必须是malloc calloc relloc动态申请的内存

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

int main()
{
	int n = 0;
	int *arr = NULL;

	printf("请输入数组元素的个数\n");
	scanf("%d", &n);

	arr = (int *)malloc(n * sizeof(int)); // 申请堆区空间
	memset(arr, 0, n);  //对所申请的空间清零

    //对arr的读写操作
	get_arr(arr, n);
	print_arr(arr, n);

	free(arr);	//释放空间
	printf("\n");
}

int get_arr(int *arr, int n)
{
	printf("请输入%d个数字\n", n);
	for (int i = 0; i < n; i++){
		scanf("%d", arr + i);
	}
}

int print_arr(int *arr, int n)
{
    int i = 0;
	printf("你输入的为:\n");
	for (i = 0; i < n; i++){
		printf("%d ", arr[i]);
	}
}

3.calloc函数

void * calloc(s ize_t  nmemb, size_t  size);

参数:

1. nmemb : 申请的数据块数

2. size :每一块大小

3. 所以申请总大小 == nmemb* size

返回值:

1. 申请成功时：返回申请的内存的首地址
2. 申请失败时：返回 NULL

特点:申请的空间自动清零

4.realloc函数重新申请内存)

void* realloc(void *s，unsigned int newsize);

参数:

1. s:原先开辟内存的首地址
2. newsize:新申请的空间的大小

返回值:新申请的内存的首地址

功能:在原先s指向的内存基础上重新申请内存，新的内存的大小为new_size个字节，如果原先内存后面有足够大的空间，就追加，如果后边的内存不够用，则relloc函数会在堆区找一个newsize个字节大小的内存中请，将原先内存中的内容拷贝过来，然后释放原先的内存，最后返回新内存的地址。

注意:—定要保存realloc的返回值

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int n = 0, new_n = 0;
	int *arr = NULL;
    int i = 0;

	printf("请输入数组元素的个数\n");
	scanf("%d", &n);
	arr = (int *)calloc(sizeof(int), n); // calloc申请的堆区空间,空间自动清零
	
	printf("请输入%d个数字\n", n);
	for (i = 0; i < n; i++){
		scanf("%d", arr + i);
	}

	printf("请输入数组元素新增的个数\n");
	scanf("%d", &new_n);
	arr = (int *)realloc(arr, (n+new_n) * sizeof(int));

	if (new_n > 0){
		printf("请输入数组元素新增的元素\n");
		for (i = n; i < (n + new_n); i++){
			scanf("%d", arr + i);
		}
	}
	printf("你输入的为:\n");
	for (i = 0; i < (n + new_n); i++){
		printf("%d ", arr[i]);
	}

	free(arr);	//释放空间
	printf("\n");
    return 0;
}

在c++中一般使用new和delete在堆区上进行内存的开辟和释放，而c语言中的malloc和free在c++中也可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此c++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。同时对于c和c++中的malloc、free与new、delete来说一般申请数据的类型可以分为内置类型与自定义类型。
1、内置类型：如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

int main()
{
	int* p1 = new int;
	delete p1;
	
	int *p2 = new int[10];
	delete p2;

	int* p3 = (int*)malloc(sizeof(int));
	delete p3;

}

new和delete是用户进行动态内存申请和释放的操作符，它们的实现是调用operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间，同时operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
2、自定义类型：
new的原理
1、.调用operator new函数申请空间
2、在申请的空间使用构造函数进行初始化。
delete的原理
1、在空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数释放对象的空间
new T[N]的原理
1、调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数
delete[]的原理
1、在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间