我们可以检查传递给函数的指针是否在C中分配了内存吗？
我在C中编写了自己的函数，该函数接受字符指针-buf [指向缓冲区的指针]和大小-buf_siz [缓冲区大小]。实际上，在调用此函数之前，用户必须创建一个缓冲区并为其分配buf_siz的内存。
由于用户可能会忘记做内存分配，而只是将指针传递给我的函数，因此我想检查一下。所以有什么办法可以检查我的函数，以查看传递的指针是否确实分配了buf_siz的内存量。
EDIT1：似乎没有标准库可以检查它..但是有没有脏东西可以检查它.. ??
EDIT2：我确实知道我的函数将由优秀的C程序员使用...但是我想知道是否可以检查..如果我们愿意听..
结论：因此，无法检查某个指针是否在函数中分配了内存
Answers:
除了某些特定于实现的黑客措施外，您无法检查。
指针除了指向之外，没有其他信息。最好的办法是说“我知道这个特定的编译器版本是如何分配内存的，所以我将取消对内存的引用，将指针移回4个字节，检查大小，确保它匹配...”等等。您不能以标准方式执行此操作，因为内存分配是由实现定义的。更不用说他们可能根本没有动态分配它。
您只需要假设您的客户知道如何使用C进行编程即可。我能想到的唯一解决方案是自己分配内存并返回它，但这并不是一个小小的改变。（这是一个较大的设计更改。）
malloc返回一个NULL指针。那么...malloc我们信任吗？
下面的代码是我曾经用来检查某些指针是否试图访问非法内存的代码。该机制是诱导SIGSEGV。SEGV信号之前已重定向到私有函数，该函数使用longjmp返回程序。这是一种破解，但可以。
可以改进代码（使用“签名”而不是“信号”等），但这只是一个想法。我不确定它是否可以移植到其他Unix版本。注意，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);
}
i = malloc(1);是有效的C代码，并且优于i = (int*) malloc(1);。也许您在想另一种语言。
setjmp()和longjmp()也许应该被替换成sigsetjmp()和siglongjmp()。见stackoverflow.com/questions/20755260/...
c = *(char *)(x);即使x未指向分配的区域，您也可以通过。SEGV仅在指针指向不可访问的内存段内（但该段的大小为几kB）时才触发，因此，如果在处分配4个字节10，则20尽管内存地址不在分配的区域内，但mem地址仍在同一段中作为address 10，因此尽管未分配，但您仍可以在20没有SEGV的情况下访问地址。
NULL原因，因为如果尝试取消引用它，则可以保证此值会导致SEGV。
对于特定于平台的解决方案，您可能对Win32函数IsBadReadPtr（以及其他类似的函数）感兴趣。此功能将能够（几乎）预测从特定内存块读取时是否会遇到分段错误。
但是，这在一般情况下并不能保护您，因为操作系统对C运行时堆管理器一无所知，并且如果调用者传入的缓冲区不如您期望的那么大，则其余堆块从操作系统的角度来看，它将继续保持可读性。
不，通常没有办法。
此外，如果您的接口只是“将指针传递到我将要放入东西的缓冲区”，则调用方可能会选择根本不分配内存，而是使用静态分配的固定大小的缓冲区或自动变量或其他东西。也许它是指向堆中较大对象一部分的指针。
如果您的接口专门说“传递一个指向已分配内存的指针（因为我要对其进行分配）”，那么您应该期望调用者会这样做。失败不是您可以可靠地检测到的东西。
valgrind;）
您可以尝试的一种方法是检查指针是否指向堆栈分配的内存。通常，这对您没有帮助，因为分配的缓冲区可能很小，或者指针指向某些全局内存部分（.bss，.const，...）。
要执行此破解，首先要在main（）中存储第一个变量的地址。以后，您可以在特定例程中将此地址与局部变量的地址进行比较。两个地址之间的所有地址都位于堆栈上。
char copy[255] = {0}; snprintf(copy, sizeof(copy), "%n: %s\n", error_code, error_msg); copy[sizeof(copy) -1] = 0; write(log_fd, copy, strnlen(copy) + 1); copy[0] = 0; 如果snprintf执行像您建议的那样奇怪的检查，snprintf又会错误地认为copy是无效的指针呢？
我知道这是一个老问题，但是在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
缺点是用户必须使用上述指令编译其源代码。但是，这与我见过的最糟糕的情况相去甚远。分配和释放内存会有一些开销，但是在增加安全性时总会有一些开销。
我不知道从库调用中执行此操作的方法，但是在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的指针位于堆中。
您无法检查标准C中提供的任何内容。即使您的特定编译器提供了执行此功能的功能，也仍然不是一个好主意。这是为什么的示例：
int YourFunc(char * buf, int buf_size);
char str[COUNT];
result = YourFunc(str, COUNT);
有一个简单的方法可以做到这一点。每当创建指针时，都要在其周围编写包装器。例如，如果您的程序员使用您的库来创建结构。
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-> string分配给一个值，否则它将保持为NULL。您可以检入使用此结构的函数（字符串是否为NULL）。
还有一件事，如果程序员非常糟糕，以至于他无法使用您的函数，而是直接访问未分配的内存，那么他就不应该使用您的库。只要确保您的文档中指定了所有内容即可。
好吧，我不知道是否有人没有把它放在这里，或者这是否有可能出现在您的程序中。我在大学项目中正为类似的事情而苦苦挣扎。
我非常简单地解决了它-在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语言中您不必特别小心。
未初始化的指针正是未初始化的指针。它可能指向任何内容，或者仅仅是一个无效的地址（即未映射到物理或虚拟内存的地址）。
一个实际的解决方案是在所指向的对象中具有有效性签名。创建一个malloc（）包装器，该包装器分配请求的块大小加上签名结构的大小，在块的开头创建一个签名结构，但将指针返回到签名之后的位置。然后，您可以创建一个接受指针的验证函数，使用负偏移量获取有效性结构并对其进行检查。当然，您将需要一个相应的free（）包装器，以通过覆盖有效性签名来使该块无效，并从分配的块的真正开始处执行释放。
作为有效性结构，您可以使用块的大小及其补码。这样，您不仅可以验证块（将两个值进行异或并与零进行比较），而且还可以获得有关块大小的信息。
指针跟踪器，跟踪并检查指针的有效性
用法：
创建内存int * ptr = malloc（sizeof（int）* 10）;
将指针地址添加到跟踪器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;
}
计算机几乎从来没有“从来没有”。跨平台超出了预期。25年后，我参与了数百个预期跨平台的项目，但从未实现。
显然，堆栈上的变量将指向堆栈上几乎是线性的区域。跨平台垃圾收集器的工作方式是：标记堆栈的顶部或底部（底部），调用一个小函数来检查堆栈是向上还是向下生长，然后检查堆栈指针以知道堆栈有多大。这是你的范围。我不知道没有这样实现堆栈的机器（向上或向下生长）。
您只需检查我们的对象或指针的地址是否位于堆栈的顶部和底部之间。这是您如何知道它是否是堆栈变量。
太简单。嘿，正确的C ++吗？否。正确重要吗？在25年中，我看到了更多关于正确性的估计。好吧，让我们这样说：如果您是黑客，则不是在进行真正的编程，您可能只是在修改已完成的内容。
那有多有趣？
malloc类似功能不一定执行将导致堆扩展的操作。C ++具有一种全新的分配内存的方式，每个人都知道使用C的预定义函数不是一个好主意。