#include
#include
#include
#include
using namespace std;


void test_c()//c语言的方法
{
    int *pc=(int *)malloc(sizeof(int));
  assert(pc);//不为空，则执行下面语句
    memset(pc,0,sizeof(int));//初始化内存
    *pc=123;
    printf("%d",*pc)
    free(pc);
    pc=nullptr;
}
void test_cpp()//c++的方法
{
    int*pc=new int;
      assert(pc);//不为空，则执行下面语句
    pc=2233;
    cout<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36

2-申请连续空间内存

#include 
#include 
#include 
#include 
using namespace std;

void test_c() //c语言的方法，分配一块内存
{

    int *pc = (int *)malloc(10 * sizeof(int)); //申请一段空间，一维数组
                                               //可以使用calloc,能省去memset() // int *pc=(int *)calloc(10,sizeof(int));
                                               //注意含有两个参数，第一个参数是代表分配多少个int大小的连续内存
    assert(pc);                                //不为空，则执行下面语句
    memset(pc, 0, 10 * sizeof(int));           //初始化内存
    pc[0] = 1122;
    pc[9] = 3232;
    cout << "p[0]为:" << pc[0] << "\t"
         << "p[9]为:" << pc[9] << endl;
    // printf("%p", pc);
    // printf("%c")

    cout << pc << endl; //打印地址

    //对于realloc函数，是扩容函数realloc函数和上面两个有本质的区别，其原型void realloc(void *ptr, size_t new_Size)
    //用于对动态内存进行扩容(及已申请的动态空间不够使用，需要进行空间扩容操作)，ptr为指向原来空间基址的指针， new_size为接下来需要扩充容量的大小。

    int *pcPlus = (int *)realloc(pc, 5 * sizeof(int)); //重新分配一块小于之前大小的内存
    cout << "分配一块小于或者等于之前大小空间的内存，地址将保持原状" << endl;
    cout << pcPlus;//打印地址
    // int *pcPlus = (int *)realloc(pc, 10 * sizeof(int));//重新分配一块等于之前大小的内存，地址将保持原状
    // cout << pcPlus;

    // 其中，指针p必须为指向堆内存空间的指针，即由malloc函数、calloc函数或realloc函数分配空间的指针。realloc函数将指针p指向的内存块的大小改变为n字节。
    // 如果n小于或等于p之前指向的空间大小，那么。保持原有状态不变。如果n大于原来p之前指向的空间大小，那么，系统将重新为p从堆上分配一块大小为n的内存空间，
    // 同时，将原来指向空间的内容依次复制到新的内存空间上，p之前指向的空间被释放。relloc函数分配的空间也是未初始化的。

    // cout << "分配一块大于之前大小空间的内存，地址将改变";
    // int *pcPlus = (int *)realloc(pc, 20 * sizeof(int));

    // cout << "扩容后的大小为         " << sizeof(pcPlus) << endl; //注意我们无法通过sizeof计算出指针指向的空间大小，这是由于动态分配的性质造成的，动态分配是在运行时分配内存的
    // sizeof是一个关键字，一个操作符，不是一个函数，它的计算结果在编译时就已经确定了的，不是在运行时，如果你要在运行时分配一个空间，显然大小在运行时应该也是可知的。
    //  你不能要求sizeof在编译时知道运行时的东西，这是不可能的。
    //除非，该指针指向数组这类，编译时就分配好指定内存，才能使用sizeof计算指针所指向的空间大小。

    // cout << pcPlus;//打印地址
    free(pcPlus);
    pcPlus = nullptr;
}
void test_cpp() //c++的方法申请一块内存 
{
    int *pc = new int[5];
    assert(pc); //不为空，则执行下面语句
    pc[5] = 2233;
    cout << pc;
    delete pc;
    pc = nullptr;

}
int main()
{
    test_c();
    test_cpp();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

3-申请空间并初始化

#include
using namespace std;
#include
void test_cpp ()
{
  //  单个数据使用（）
  int *Pnum=new int (100);
    cout<<*pnum;
    delete pnum;
    pnum=nullptr;
    //多个数据用{}
    int *PPnum=new int[5]{1,2,3,4,5};
    for(int i=0;i<5;i++)
    {
        cout<<PPnum[i]<<"\t"
    }
    cout<<endl;
    
}
int main()
{
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4——c++y允许我们重新管理申请堆内存

#include 
using namespace std;
#include 
void test_cpp()
{
    char *number = new char[100];
    int *point_f = new (number + 0) int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    //前40个字节存放10个整数,从number数组下标为0处开始
    // cout<

    cout <<"number指针所指向处          "<< number + 40 << endl; //结果为空

    cout << "point_f指针所指向处        "<<*(point_f+3) << endl;  //结果为第4个数
    

    char *ptr = new (point_f + 10) char[20];
//从point数组结尾又申请20个字节

    strcpy(ptr, "hello linux");

    cout <<"ptr指针所指向处：    " << ptr << endl;//打印整个字符串
}
int main()
{
    test_cpp();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26