关于内存溢出

xyj1

#include"dynaicArray.h"

//初始化数组   参数  初始化数组容量 返回值 数组指针
struct dynamicArray* init_dynamicArray(int capacity)
{
        if (capacity <= 0)
        {
                return NULL;
        }
        //给数组分配内存
        struct dynamicArray* arr = malloc(sizeof(struct dynamicArray));
        if (arr == NULL)
        {
                return NULL;
        }
        //给属性初始化
        arr->pAddr = malloc(sizeof(void *)* capacity);
        if (arr->pAddr == NULL)
        {
                return NULL;
        }
        //容量初始化
        arr->m_Capacity = capacity;
        //大小初始化
        arr->m_Size = 0;

        return arr;
}

//插入数组
void insert_dynaminArray(struct dynamicArray* arr, void* data, int pos)
{
        if (arr == NULL)
        {
                return;
        }
        if (data == NULL)
        {
                return;
        }
        if (pos < 0 || pos > arr->m_Size)
        {
                //尾插
                pos = arr->m_Size;
        }
        //判断数组是否满了
        if (arr->m_Size == arr->m_Capacity)
        {
                //计算新内存的大小
                int newCapacity = arr->m_Capacity * 2;
                //开辟新空间
                void** newSpace = malloc(sizeof(void* ) * newCapacity);
                if (newSpace == NULL)
                {
                        return;
                }
                //将原空间下数据拷贝到新空间下
                memcpy(newSpace, arr->pAddr, sizeof(void*)* arr->m_Capacity);
                //释放原有空间
                free(arr->pAddr);
                //更改指针指向
                arr->pAddr = newSpace;
                //更改新的容量
                arr->m_Capacity = newCapacity;
        }
        //将新元素插入到数组中指定位置
        for (int i = arr->m_Size - 1; i >= pos; i--)
        {
                //数据往后移动
                arr->pAddr[i + 1] = arr->pAddr[i];
        }
        //将数据插入到指定位置
        arr->pAddr[pos] = data;
        //更新数组大小
        arr->m_Size++;
}

//遍历
void foreach_dynamicArray(struct dynamicArray* arr, void(*myPrint)(void*))
{
        if (arr == NULL)
        {
                return;
        }
        for (int i = 0; i < arr->m_Size; i++)
        {
                myPrint(arr->pAddr[i]);
        }

}
--------------------------------------------------------------------------------------------------------------------------------------------------------

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

//容量和大小的区别：一个是能装多少，一个是装了多少。
struct dynamicArray
{
        //维护真实在堆区开辟数组指针
        void** pAddr;
        //数组的容量
        int m_Capacity;
        //数组的大小
        int m_Size;
};

struct PERSON
{
        char name[64];
        int age;
};

//初始化数组
struct dynamicArray* init_dynamicArray(int capacity);

//插入数组
void insert_dynaminArray(struct dynamicArray* arr, void* data, int pos);

//遍历动态数组
void foreach_dynamicArray(struct dynamicArray* arr, void(*myprint)(void*));
---------------------------------------------------------------------------------------------------------------------------------------------------------
严重性        代码        说明        项目        文件        行        禁止显示状态
警告        C6386        写入到“arr->pAddr”时缓冲区溢出: 可写大小为“sizeof(void *)*newCapacity”个字节，但可能写入了“8”个字节。        动态数组的实现        C:\Users\x\source\repos\数据结构\动态数组的实现.c        70       

xyj1

void** newSpace = malloc(sizeof(void* ) * (newCapacity + 2));
我扩充了newSpace的大小，消除了 C6386  警告
但是(newCapacity + 1))依旧会报这个警告
+2之后就不会报
有大佬解释一下吗

人造人

xyj1 发表于 2022-2-28 14:53
void** newSpace = malloc(sizeof(void* ) * (newCapacity + 2));
我扩充了newSpace的大小，消除了 C6386  ...

把代码发完整

xyj1

人造人 发表于 2022-2-28 15:11
把代码发完整

不完整吗？我贴了封装函数的所有程序啊。

人造人

xyj1 发表于 2022-3-3 08:47
不完整吗？我贴了封装函数的所有程序啊。

1. $ cat main.c
   
2. //#include"dynaicArray.h"
   
3. 
   
4. //#pragma once
   
5. //#define _CRT_SECURE_NO_WARNINGS
   
6. #include<stdio.h>
   
7. #include<string.h>
   
8. #include<stdlib.h>
   
9. 
   
10. //容量和大小的区别：一个是能装多少，一个是装了多少。
    
11. struct dynamicArray
    
12. {
    
13.         //维护真实在堆区开辟数组指针
    
14.         void** pAddr;
    
15.         //数组的容量
    
16.         int m_Capacity;
    
17.         //数组的大小
    
18.         int m_Size;
    
19. };
    
20. 
    
21. struct PERSON
    
22. {
    
23.         char name[64];
    
24.         int age;
    
25. };
    
26. 
    
27. //初始化数组
    
28. struct dynamicArray* init_dynamicArray(int capacity);
    
29. 
    
30. //插入数组
    
31. void insert_dynaminArray(struct dynamicArray* arr, void* data, int pos);
    
32. 
    
33. //遍历动态数组
    
34. void foreach_dynamicArray(struct dynamicArray* arr, void(*myprint)(void*));
    
35. 
    
36. //初始化数组   参数  初始化数组容量 返回值 数组指针
    
37. struct dynamicArray* init_dynamicArray(int capacity)
    
38. {
    
39.         if (capacity <= 0)
    
40.         {
    
41.                 return NULL;
    
42.         }
    
43.         //给数组分配内存
    
44.         struct dynamicArray* arr = malloc(sizeof(struct dynamicArray));
    
45.         if (arr == NULL)
    
46.         {
    
47.                 return NULL;
    
48.         }
    
49.         //给属性初始化
    
50.         arr->pAddr = malloc(sizeof(void *)* capacity);
    
51.         if (arr->pAddr == NULL)
    
52.         {
    
53.                 return NULL;
    
54.         }
    
55.         //容量初始化
    
56.         arr->m_Capacity = capacity;
    
57.         //大小初始化
    
58.         arr->m_Size = 0;
    
59. 
    
60.         return arr;
    
61. }
    
62. 
    
63. //插入数组
    
64. void insert_dynaminArray(struct dynamicArray* arr, void* data, int pos)
    
65. {
    
66.         if (arr == NULL)
    
67.         {
    
68.                 return;
    
69.         }
    
70.         if (data == NULL)
    
71.         {
    
72.                 return;
    
73.         }
    
74.         if (pos < 0 || pos > arr->m_Size)
    
75.         {
    
76.                 //尾插
    
77.                 pos = arr->m_Size;
    
78.         }
    
79.         //判断数组是否满了
    
80.         if (arr->m_Size == arr->m_Capacity)
    
81.         {
    
82.                 //计算新内存的大小
    
83.                 int newCapacity = arr->m_Capacity * 2;
    
84.                 //开辟新空间
    
85.                 void** newSpace = malloc(sizeof(void* ) * newCapacity);
    
86.                 if (newSpace == NULL)
    
87.                 {
    
88.                         return;
    
89.                 }
    
90.                 //将原空间下数据拷贝到新空间下
    
91.                 memcpy(newSpace, arr->pAddr, sizeof(void*)* arr->m_Capacity);
    
92.                 //释放原有空间
    
93.                 free(arr->pAddr);
    
94.                 //更改指针指向
    
95.                 arr->pAddr = newSpace;
    
96.                 //更改新的容量
    
97.                 arr->m_Capacity = newCapacity;
    
98.         }
    
99.         //将新元素插入到数组中指定位置
    
100.         for (int i = arr->m_Size - 1; i >= pos; i--)
     
101.         {
     
102.                 //数据往后移动
     
103.                 arr->pAddr[i + 1] = arr->pAddr[i];
     
104.         }
     
105.         //将数据插入到指定位置
     
106.         arr->pAddr[pos] = data;
     
107.         //更新数组大小
     
108.         arr->m_Size++;
     
109. }
     
110. 
     
111. //遍历
     
112. void foreach_dynamicArray(struct dynamicArray* arr, void(*myPrint)(void*))
     
113. {
     
114.         if (arr == NULL)
     
115.         {
     
116.                 return;
     
117.         }
     
118.         for (int i = 0; i < arr->m_Size; i++)
     
119.         {
     
120.                 myPrint(arr->pAddr[i]);
     
121.         }
     
122. 
     
123. }
     
124. $ gcc-debug -o main main.c
     
125. /usr/bin/ld: /usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/../../../../lib/Scrt1.o: in function `_start':
     
126. (.text+0x1b): undefined reference to `main'
     
127. collect2: error: ld returned 1 exit status
     
128. $

复制代码