Question

我一直在思考这个问题，但我不确定它是否“安全”且可能。

想象一下这样的事情：

void genLeaks(void)
{
 char* charLeakAddr;
 charLeakAddr = (char*)malloc(sizeof(char) * 10);
 strcpy(charLeakAddr, "Hello World");
}

据我所知，这会造成内存泄漏，因为charLeakAddr未发布（free (charLeakAddr);）。

现在主要：

int main(void)
{
 genLeaks();

 ??????? 

 return 0;
}

在标有???????的地方有没有办法创建某种函数来释放charLeakAddr分配的内存？

感谢您的时间。

很抱歉，但我怎样才能使代码在帖子中看起来很好看？S？

感谢您的回答。

不知怎的，我生成了这个代码，它似乎工作（我在GCC中使用Code :: Blocks在Linux和Windows中测试过它）请看一下。这是对的吗？或尝试类似的东西真是太疯狂了？

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

#define LEAKS_PATH_FILE               "leaks.txt"
#define WIN_ERASE_LEAKS_FILE_COMMAND  "erase leaks.txt"
#define UNIX_ERASE_LEAKS_FILE_COMMAND "rm leaks.txt"

#define __ASM__LEAK__DELETER__DEBUG

#define __UNIX__DEBUG__

unsigned int LEAKS = 0;

void regLeakAddr(void* memPtr, const char* fileName)
{
 FILE* arch;

 #ifdef __ASM__LEAK__DELETER__DEBUG
  printf("\nMemory Leak : 0x%x\n", (void*)memPtr);
 #endif

 arch = fopen(fileName, "a");

 if(arch)
 {
  fprintf(arch, "%d", (void*)memPtr);
  fprintf(arch, "%c", '\n');
  fclose(arch);
  LEAKS++;
 }
 else
  printf("ERROR IN FILE leaks.txt\n");
}

void assemblyDeleter(int numAddr)
{
 #ifdef __ASM__LEAK__DELETER__DEBUG
  printf("\nOnassemblyDeleter : 0x%x\n\n", numAddr);

  #ifdef __UNIX__DEBUG__
   getchar();
  #else
   system("pause");
  #endif
 #endif

 char* deleter;
 int*  ptr = &numAddr;

 printf("\n======> 0x%x\n\n", *ptr);
 printf("\n======> 0x%x\n\n", deleter);

 if((char*)*ptr > deleter)
 {
  printf("(ptr > deleter) : Offset : 0x%x\n", ((char*)*ptr - deleter));
  deleter += ((char*)*ptr - deleter);
 }
 else
 {
  printf("(ptr < deleter) : Offset : 0x%x\n", (deleter - (char*)*ptr));
  deleter += ((char*)*ptr - deleter);
 }

 printf("deleter =========> 0x%x\n", deleter);

 #ifdef __ASM__LEAK__DELETER__DEBUG
  puts(deleter);
 #endif

 free(deleter);

 #ifdef __ASM__LEAK__DELETER__DEBUG
  puts(deleter);
 #endif

 deleter = NULL;
 ptr     = NULL;
}

void freeMemory(void)
{
 if(LEAKS == 0)
 {
  #ifdef __ASM__LEAK__DELETER__DEBUG
   printf("NO LEAKS\n");
  #endif
  return;
 }

 FILE* arch;
 int   addr;
 int i;

 arch = fopen(LEAKS_PATH_FILE, "r");

 if(arch == NULL)
 {
  #ifdef __ASM__LEAK__DELETER__DEBUG
   printf("Error on file...\n");
  #endif
  return;
 }

 for(i = 0; i<LEAKS; i++)
 {
  fscanf(arch, "%d", &addr);
  assemblyDeleter(addr);
 }

 fclose(arch);

 #ifdef __UNIX__DEBUG__
  system(UNIX_ERASE_LEAKS_FILE_COMMAND); 
 #else
  system(WIN_ERASE_LEAKS_FILE_COMMAND); 
 #endif
}

void genLeakTrick(char** msg)
{
 *msg = (char*)malloc(sizeof(char) * 17);
 strcpy(*msg, "Hello World again");
 printf("\n%s\n", *msg);
}

void genLeaks(void)
{
 char* charLeakAddr;
 charLeakAddr = (char*)malloc(sizeof(char) * 10);
 strcpy(charLeakAddr, "Hello World");
 printf("\n%s\n", charLeakAddr);
 //free(charLeakAddr);
 regLeakAddr(charLeakAddr, LEAKS_PATH_FILE);

 char* charLeakAddr2;
 genLeakTrick(&charLeakAddr2);
 //free(charLeakAddr2);
 regLeakAddr(charLeakAddr2, LEAKS_PATH_FILE);
}

int main(void)
{
 genLeaks();

 freeMemory();

 return 0;
}

Answer 1

不，没有办法释放那段记忆。它永久丢失（除非你能以某种方式找到最初由malloc返回的指针）。

你总是可以在genLeak中释放它，因为它之后没有用于任何事情。如果您返回指针，则其他人将在使用后将其释放。

这就是为什么在C库文档中，无论何时返回指针，它们都会告诉您指针所属的对象以及是否必须释放指针。

Answer 2

没有办法，直到genleak()返回类型为void。修改返回类型，如果函数返回引用charLeakAddr，则可能。

char* genleak()
{
    char* charLeakAddr;
    charLeakAddr = (char*)malloc(sizeof(char) * 10);
    strcpy(charLeakAddr, "Hello World");

    return charLeakAddr ;
}

int main()
{
     genleak(); // Now also not possible, since the return value is not collected.
     char* temp = genleak();

     free temp;  // Deallocating the resources acquired using malloc
     return 0;
}

修改：

在发布的代码段中，charLeakAddr在函数调用genleak()返回时超出范围。因此，使资源保持在免费的方式，没有进程来访问泄漏的来源。如何添加全局变量？

char* globalVar = NULL ;
void genleak()
{
    char* charLeakAddr;
    charLeakAddr = (char*)malloc(sizeof(char) * 10);
    // ....
    globalVar = charLeakAddr ;
}

int main()
{
    // .....
    genleak();
    free globalVar ;
}

在genleak()中，指定charLeakAddr指向的值。然后，程序可以对其执行自由操作。

Answer 3

是的，有一种方法，就是所谓的垃圾收集器。有些人可以阅读this和this。基本上，如果您的所有程序都是使用垃圾收集器编译/链接的，那么您可以执行

之类的操作

GC.Collect的（）

要求所有泄露的记忆。

释放可能的内存泄漏

3 个答案: