检查指针是否已分配内存

Question

我们能否检查传递给函数的指针是否在 C 中分配了内存？

我用 C 语言编写了自己的函数，它接受字符指针 - buf [指向缓冲区的指针] 和大小 - buf_siz [缓冲区大小]。实际上，在调用此函数之前，用户必须创建一个缓冲区并为其分配 buf_siz 的内存。

由于用户可能会忘记进行内存分配而只是将指针传递给我的函数，因此我想检查一下。那么有什么方法可以检查我的函数以查看传递的指针是否真的分配了 buf_siz 内存量.. ??

EDIT1：似乎没有标准库可以检查它..但是有没有什么肮脏的黑客可以检查它.. ??

EDIT2: 我知道我的函数会被优秀的 C 程序员使用……但我想知道我们是否可以检查……如果我们可以我想听听..

结论：因此无法在函数内检查特定指针是否分配了内存

Answer 1

除了一些特定于实现的黑客之外，您无法检查。

指针除了指向的位置之外没有其他信息。你能做的最好的就是说“我知道这个特定的编译器版本是如何分配内存的，所以我将取消引用内存，将指针移回 4 个字节，检查大小，确保它匹配......”等等。您不能以标准方式执行此操作，因为内存分配是实现定义的。更不用说他们可能根本没有动态分配它。

您只需要假设您的客户知道如何用 C 进行编程。我能想到的唯一解决方案是自己分配内存并返回它，但这并不是一个小改变。 （这是一个更大的设计变化。）

Answer 2

您无法检查标准 C 中可用的任何内容。即使您的特定编译器提供了这样做的函数，这仍然是一个坏主意。下面是一个例子：

int YourFunc(char * buf, int buf_size);

char str[COUNT];
result = YourFunc(str, COUNT);

Answer 3

不，你不能。您会注意到标准库或其他任何地方都没有函数这样做。那是因为没有标准的说法。调用代码只需要承担正确管理内存的责任。

Answer 4

不，一般来说没有办法做到这一点。

此外，如果您的界面只是“传递一个指向缓冲区的指针，我将在其中放置东西”，那么调用者可能会选择 not 来分配内存，而是使用固定大小的缓冲区那是静态分配的或自动变量之类的。或者它可能是指向堆上较大对象的一部分的指针。

如果您的界面明确表示“传递一个指向已分配内存的指针（因为我要释放它）”，那么您应该期望调用者会这样做。如果不这样做，您无法可靠地检测到。

Answer 5

对于特定于平台的解决方案，您可能对 Win32 函数IsBadReadPtr（以及其他类似的）感兴趣。此函数将能够（几乎）预测在读取特定内存块时是否会出现分段错误。

但是，在一般情况下，这不会保护您，因为操作系统对 C 运行时堆管理器一无所知，并且如果调用者传入的缓冲区没有如您所料，那么从操作系统的角度来看，堆块的其余部分将继续可读。

Answer 6

我总是将指针初始化为空值。因此，当我分配内存时，它会改变。当我检查是否分配了内存时，我会做pointer != NULL。当我释放内存时，我还将指针设置为空。我想不出任何方法来判断是否分配了足够的内存。

这并不能解决您的问题，但您必须相信，如果有人编写 C 程序，那么他的技能足以将其做好。

Answer 7

正如其他人所说，没有标准的方法。

到目前为止，没有人提到史蒂夫·马奎尔的“Writing Solid Code”。尽管在某些quarters 中受到严厉批评，但这本书有关于内存管理主题的章节，并讨论了如何小心和完全控制程序中的所有内存分配，您可以按照您的要求进行操作并确定是否给您一个指针是指向动态分配内存的有效指针。但是，如果您打算使用第三方库，您会发现其中很少有允许您将内存分配例程更改为您自己的，这使此类分析变得非常复杂。

Answer 8

您可以尝试的一个技巧是检查您的指针是否指向堆栈分配的内存。 这通常对您没有帮助，因为分配的缓冲区可能太小或者指针指向某个全局内存部分（.bss、.const、...）。

要执行此 hack，首先将第一个变量的地址存储在 main() 中。稍后，您可以将此地址与特定例程中的局部变量的地址进行比较。 两个地址之间的所有地址都位于堆栈上。

Answer 9

一般来说，lib 用户负责输入检查和验证。您可能会在 lib 代码中看到 ASSERT 或其他内容，它们仅用于调试目的。这是编写 C/C++ 时的标准方式。而很多编码人员喜欢在他们的 lib 代码中非常仔细地进行此类检查和验证。真是“坏”的习惯。正如 IOP/IOD 中所述，lib 接口应该是合同，并明确 lib 将做什么和不做什么，以及 lib 用户应该做什么和不需要什么。

Answer 10

一个未初始化的指针就是这样 - 未初始化的。它可能指向任何东西，也可能只是一个无效地址（即未映射到物理或虚拟内存的地址）。

一个实际的解决方案是在指向的对象中具有有效性签名。创建一个 malloc() 包装器，它分配请求的块大小加上签名结构的大小，在块的开头创建一个签名结构，但返回指向签名后位置的指针。然后，您可以创建一个接受指针的验证函数，使用负偏移量来获取有效性结构并对其进行检查。您当然需要相应的 free() 包装器来通过覆盖有效性签名来使块无效，并从分配块的真正开始处执行释放。

作为有效性结构，您可以使用块的大小及其补码。这样，您不仅可以验证块（对两个值进行异或并与零比较），而且还可以获得有关块大小的信息。

Answer 11

计算机中几乎从来没有“从不”。跨平台超出预期。 25 年后，我参与了数百个项目，所有项目都期待跨平台，但从未实现。

显然，堆栈上的变量将指向堆栈上的一个区域，该区域几乎是线性的。跨平台垃圾收集器通过标记堆栈的顶部或（底部）来工作，调用一个小函数来检查堆栈是向上还是向下增长，然后检查堆栈指针以了解堆栈有多大。这是你的范围。我不知道有哪台机器不以这种方式实现堆栈（向上或向下）。

您只需检查我们的对象或指针的地址是否位于堆栈的顶部和底部之间。这样你就可以知道它是否是一个堆栈变量。

太简单了。嘿，它是正确的 c++ 吗？不，正确重要吗？ 25 年来，我看到了更多的正确估计。好吧，让我们这样说吧：如果你在做黑客，你并不是在做真正的编程，你可能只是在重复一些已经完成的事情。

这有多有趣？

Answer 12

有一个简单的方法可以做到这一点。每当您创建指针时，请在其周围编写一个包装器。例如，如果您的程序员使用您的库来创建结构。

struct struct_type struct_var;

确保他使用您的函数分配内存，例如

struct struct_type struct_var = init_struct_type()

如果这个 struct_var 包含动态分配的内存，例如，

如果 struct_type 的定义是

typedef struct struct_type {
 char *string;
}struct_type;

然后在您的 init_struct_type() 函数中，执行此操作，

init_struct_type()
{ 
 struct struct_type *temp = (struct struct_type*)malloc(sizeof(struct_type));
 temp->string = NULL;
 return temp;
}

这样，除非他将 temp-> 字符串分配给一个值，否则它将保持为 NULL。如果字符串是否为 NULL，您可以检查使用此结构的函数。

还有一件事，如果程序员太糟糕了，以至于他无法使用您的函数，而是直接访问未分配的内存，那么他不应该使用您的库。只需确保您的文档说明了所有内容。

Answer 13

我曾经在我的 64 位 Solaris 上使用了一个肮脏的 hack。在 64 位模式下，堆从 0x1 0000 0000 开始。通过比较指针，我可以确定它是数据或代码段中的指针 p < (void*)0x100000000、堆中的指针 p > (void*)0x100000000 还是内存映射区域中的指针 @ 987654323@（mmap 从可寻址区域的顶部返回地址）。 这允许我的程序在同一个映射中保存分配的和内存映射的指针，并让我的映射模块释放正确的指针。

但是这种技巧是高度不可移植的，如果您的代码依赖于类似的东西，那么是时候重新考虑代码的架构了。你可能做错了什么。

Answer 14

下面的代码是我曾经用来检查某个指针是否试图访问非法内存的代码。该机制是诱导 SIGSEGV。 SEGV 信号之前被重定向到一个私有函数，该函数使用 longjmp 返回程序。这是一种 hack，但它确实有效。

代码可以改进（使用'sigaction'而不是'signal'等），但这只是提供一个想法。它还可以移植到其他 Unix 版本，对于 Windows，我不确定。请注意，不应在程序的其他地方使用 SIGSEGV 信号。

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

jmp_buf jump;

void segv (int sig)
{
  longjmp (jump, 1); 
}

int memcheck (void *x) 
{
  volatile char c;
  int illegal = 0;

  signal (SIGSEGV, segv);

  if (!setjmp (jump))
    c = *(char *) (x);
  else
    illegal = 1;

  signal (SIGSEGV, SIG_DFL);

  return (illegal);
}

int main (int argc, char *argv[])
{
  int *i, *j; 

  i = malloc (1);

  if (memcheck (i))
    printf ("i points to illegal memory\n");
  if (memcheck (j))
    printf ("j points to illegal memory\n");

  free (i);

  return (0);
}

Answer 15

我不知道从库调用中执行此操作的方法，但在 Linux 上，您可以查看 /proc/<pid>/numa_maps。它将显示内存的所有部分，第三列将显示“堆”或“堆栈”。您可以查看原始指针值以了解它的排列位置。

例子：

00400000 prefer:0 file=/usr/bin/bash mapped=163 mapmax=9 N0=3 N1=160
006dc000 prefer:0 file=/usr/bin/bash anon=1 dirty=1 N0=1
006dd000 prefer:0 file=/usr/bin/bash anon=9 dirty=9 N0=3 N1=6
006e6000 prefer:0 anon=6 dirty=6 N0=2 N1=4
01167000 prefer:0 heap anon=122 dirty=122 N0=25 N1=97
7f39904d2000 prefer:0 anon=1 dirty=1 N0=1
7f39904d3000 prefer:0 file=/usr/lib64/ld-2.17.so anon=1 dirty=1 N0=1
7f39904d4000 prefer:0 file=/usr/lib64/ld-2.17.so anon=1 dirty=1 N1=1
7f39904d5000 prefer:0 anon=1 dirty=1 N0=1
7fffc2d6a000 prefer:0 stack anon=6 dirty=6 N0=3 N1=3
7fffc2dfe000 prefer:0

因此高于 0x01167000 但低于 0x7f39904d2000 的指针位于堆中。

Answer 16

我知道这是一个老问题，但在 C 语言中几乎一切皆有可能。这里已经有一些骇人听闻的解决方案，但确定内存是否已正确分配的有效方法是使用 oracle 代替malloc、calloc、realloc 和 free。这与测试框架（例如 cmocka）可以检测内存问题（段错误、未释放内存等）的方式相同。您可以维护分配的内存地址列表，并在用户想要使用您的功能时简单地检查此列表。我为自己的测试框架实现了一些非常相似的东西。一些示例代码：

typedef struct memory_ref {
    void       *ptr;
    int        bytes;
    memory_ref *next;
}

memory_ref *HEAD = NULL;

void *__wrap_malloc(size_t bytes) {
    if(HEAD == NULL) {
        HEAD = __real_malloc(sizeof(memory_ref));
    }

    void *tmpPtr = __real_malloc(bytes);

    memory_ref *previousRef = HEAD;
    memory_ref *currentRef = HEAD->next;
    while(current != NULL) {
        previousRef = currentRef;
        currentRef = currentRef->next;
    }

    memory_ref *newRef = (memory_ref *)__real_malloc(sizeof(memory_ref));
    *newRef = (memory_ref){
        .ptr   = tmpPtr,
        .bytes = bytes,
        .next  = NULL
    };

    previousRef->next = newRef;

    return tmpPtr;
}

calloc、realloc 和 free 具有类似的功能，每个包装器都以 __wrap_ 为前缀。真正的malloc 可通过使用__real_malloc 获得（与您包装的其他功能类似）。每当您想检查是否实际分配了内存时，只需遍历链接的memory_ref 列表并查找内存地址。如果你找到它并且它足够大，你肯定知道这个内存地址不会让你的程序崩溃；否则，返回错误。在您的程序使用的头文件中，您将添加以下几行：

extern void *__real_malloc  (size_t);
extern void *__wrap_malloc  (size_t);
extern void *__real_realloc (size_t);
extern void *__wrap_realloc (size_t);
// Declare all the other functions that will be wrapped...

我的需求相当简单，所以我实现了一个非常基本的实现，但您可以想象如何扩展它以拥有更好的跟踪系统（例如，创建一个struct 来跟踪内存位置以及大小)。然后你只需用

编译代码

gcc src_files -o dest_file -Wl,-wrap,malloc -Wl,-wrap,calloc -Wl,-wrap,realloc -Wl,-wrap,free

缺点是用户必须使用上述指令编译他们的源代码；然而，这远非我所见过的最糟糕的。分配和释放内存有一些开销，但在添加安全性时总会有一些开销。

Answer 17

指针跟踪器，跟踪并检查指针的有效性

用法：

创建内存 int * ptr = malloc(sizeof(int) * 10);

将指针地址添加到tracker Ptr(&ptr);

检查失败的指针 PtrCheck();

并在代码末尾释放所有跟踪器

PtrFree();

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

struct my_ptr_t { void ** ptr; size_t mem; struct my_ptr_t *next, *previous; };

static struct my_ptr_t * ptr = NULL;

void Ptr(void * p){ 
                struct my_ptr_t * tmp = (struct my_ptr_t*) malloc(sizeof(struct my_ptr_t));
                printf("\t\tcreating Ptr tracker:");    
                if(ptr){ ptr->next = tmp; }
                tmp->previous = ptr;
                ptr = tmp;
                ptr->ptr = p;
                ptr->mem = **(size_t**) ptr->ptr;
                ptr->next = NULL;
                printf("%I64x\n", ptr); 
};
void PtrFree(void){
                    if(!ptr){ return; }
                    /* if ptr->previous == NULL */
                    if(!ptr->previous){ 
                                    if(*ptr->ptr){
                                                free(ptr->ptr);
                                                ptr->ptr = NULL;
                                    }
                                    free(ptr);
                                    ptr = NULL; 
                            return;                 
                    }

                    struct my_ptr_t * tmp = ptr;    
                    for(;tmp != NULL; tmp = tmp->previous ){
                                            if(*tmp->ptr){
                                                        if(**(size_t**)tmp->ptr == tmp->mem){
                                                                                                                                                    free(*tmp->ptr);
                                                                        *tmp->ptr = NULL;
                                                        }
                                            }
                                        free(tmp);
                    } 
            return; 
};

void PtrCheck(void){
                if(!ptr){ return; }
                if(!ptr->previous){
                        if(*(size_t*)ptr->ptr){
                                    if(*ptr->ptr){
                                                if(**(size_t**) ptr->ptr != ptr->mem){
                                                                printf("\tpointer %I64x points not to a valid memory address", ptr->mem);
                                                                printf(" did you freed the memory and not NULL'ed the pointer or used arthmetric's on pointer %I64x?\n", *ptr->ptr);
                                                                return; 
                                                        }   
                                    }
                                    return;
                                }
                        return;
                }
                struct my_ptr_t * tmp = ptr;
                for(;tmp->previous != NULL; tmp = tmp->previous){   
                                if(*(size_t*)tmp->ptr){         
                                                   if(*tmp->ptr){
                                                            if(**(size_t**) tmp->ptr != tmp->mem){
                                                                        printf("\tpointer %I64x points not to a valid memory address", tmp->mem);
                                                                        printf(" did you freed the memory and not NULL'ed the pointer or used arthmetric's on pointer %I64x?\n", *tmp->ptr);                            continue;
                                                            } 
                                                    }
                                                    continue;
                                }

                } 
            return;
       };

 int main(void){
        printf("\n\n\t *************** Test ******************** \n\n");
        size_t i = 0;
        printf("\t *************** create tracker ********************\n");
        int * ptr = malloc(sizeof(int) * 10);
        Ptr(&ptr);
        printf("\t *************** check tracker ********************\n");
        PtrCheck();
        printf("\t *************** free pointer ********************\n");
        free(ptr);
        printf("\t *************** check tracker ********************\n");
        PtrCheck();
        printf("\t *************** set pointer NULL *******************\n");
        ptr = NULL;
        printf("\t *************** check tracker ********************\n");
                PtrCheck();
        printf("\t *************** free tracker ********************\n");
        PtrFree();
        printf("\n\n\t *************** single check done *********** \n\n");
        printf("\n\n\t *************** start multiple test *********** \n");
        int * ptrs[10];
        printf("\t *************** create trackers ********************\n");
        for(; i < 10; i++){
                        ptrs[i] = malloc(sizeof(int) * 10 * i);
                        Ptr(&ptrs[i]);
                 }
        printf("\t *************** check trackers ********************\n");
        PtrCheck();
        printf("\t *************** free pointers but set not NULL *****\n");
        for(i--; i > 0; i-- ){ free(ptrs[i]); }
        printf("\t *************** check trackers ********************\n");
        PtrCheck(); 
        printf("\t *************** set pointers NULL *****************\n");
        for(i=0; i < 10; i++){ ptrs[i] = NULL; }
        printf("\t *************** check trackers ********************\n");
        PtrCheck(); 
        printf("\t *************** free trackers ********************\n");
        PtrFree();
        printf("\tdone");
    return 0;
 }

Answer 18

嗯，我不知道是否有人没有把它放在这里，或者它是否会在你的程序中出现。我在大学项目中遇到过类似的事情。

我很简单地解决了它 - 在 main() 的初始化部分，在我声明 LIST *ptr 之后，我只是输入了 ptr=NULL。像这样-

int main(int argc, char **argv) {

LIST *ptr;
ptr=NULL;

所以当分配失败或你的指针根本没有被分配时，它将为 NULL。所以你可以简单地用 if 测试它。

if (ptr==NULL) {
  "THE LIST DOESN'T EXIST" 
} else {
  "THE LIST MUST EXIST --> SO IT HAS BEEN ALLOCATED"
}

我不知道你的程序是怎么写的，但你肯定明白我想指出什么。如果可以像这样检查您的分配，然后将您的参数传递给您的函数，您可以有一个简单的解决方案。

当然，你必须小心让你的函数在分配和创建结构时做得很好，但在 C 语言中你不必小心。

Answer 19

我不确定 msync 有多快，但这是一个仅限 linux 的解决方案：

// Returns 1 if the ponter is mapped
int pointer_valid (void *p)
{
  size_t pg_size = sysconf (_SC_PAGESIZE);
  void *pg_start = (void *) ((((size_t)p) / pg_size) * pg_size);
  return msync (pg_start, pg_size, MS_ASYNC) == 0;
}