故事要從前兩天交流群中一位同學提到的這個問題開始：

這個問題看起來十分刁鉆，不過稍有常識的人都知道，制定 C 標準的那幫語言律師也不是吃白飯的，對這種奇奇怪怪的問題一定會有定義。翻閱C17 標準 草案 N2176，在 7.22.3 節里，有如下說法：

/*
  malloc(size_t n)
  Returns a pointer to a newly allocated chunk of at least n bytes, or null
  if no space is available. Additionally, on failure, errno is
  set to ENOMEM on ANSI C systems.


  If n is zero, malloc returns a minumum-sized chunk. (The minimum
  size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
  systems.)  On most systems, size_t is an unsigned type, so calls
  with negative arguments are interpreted as requests for huge amounts
  of space, which will often fail. The maximum supported value of n
  differs across systems, but is in all cases less than the maximum
  representable value of a size_t.
*/

細讀代碼，可以發現，將讀入的內存大小進行轉換是由宏 checked_request2size 實現的。

/* pad request bytes into a usable size -- internal version */
#define request2size(req)                                         
  (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE)  ?             
   MINSIZE :                                                      
   ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)


/* Same, except also perform an argument and result check.  First, we check
   that the padding done by request2size didn't result in an integer
   overflow.  Then we check (using REQUEST_OUT_OF_RANGE) that the resulting
   size isn't so large that a later alignment would lead to another integer
   overflow.  */


#define checked_request2size(req, sz) 
({        
  (sz) = request2size (req);     
  if (((sz) < (req))      
      || REQUEST_OUT_OF_RANGE (sz)) 
    {        
      __set_errno (ENOMEM);     
      return 0;       
    }        
})

/* The smallest possible chunk */
#define MIN_CHUNK_SIZE        (offsetof(struct malloc_chunk, fd_nextsize))
/* The smallest size we can malloc is an aligned minimal chunk */
#define MINSIZE  
  (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))/* The corresponding bit mask value.  */
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
/* MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.  It
   must be a power of two at least 2 * SIZE_SZ, even on machines for
   which smaller alignments would suffice. It may be defined as larger
   than this though. Note however that code and data structures are
   optimized for the case of 8-byte alignment.  */
#define MALLOC_ALIGNMENT (2 * SIZE_SZ < __alignof__ (long double) 
     ? __alignof__ (long double) : 2 * SIZE_SZ)


#ifndef INTERNAL_SIZE_T
# define INTERNAL_SIZE_T size_t
#endif


/* The corresponding word size.  */
#define SIZE_SZ (sizeof (INTERNAL_SIZE_T))


/*
  This struct declaration is misleading (but accurate and necessary).
  It declares a "view" into memory allowing access to necessary
  fields at known offsets from a given base. See explanation below.
*/


struct malloc_chunk {


  INTERNAL_SIZE_T      mchunk_prev_size;  /* Size of previous chunk (if free).  */
  INTERNAL_SIZE_T      mchunk_size;       /* Size in bytes, including overhead. */


  struct malloc_chunk* fd;         /* double links -- used only if free. */
  struct malloc_chunk* bk;


  /* Only used for large blocks: pointer to next larger size.  */
  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
  struct malloc_chunk* bk_nextsize;
};


// GCC 提供
/* Offset of member MEMBER in a struct of type TYPE. */
#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)

#include 
#include 
int main(void) {
    char *p = malloc(0);
    printf("Address: 0x%x.
Length: %ld.
",p,malloc_usable_size(p));
    return 0;
}

該樣例在我電腦內輸出的結果為 24。

因此，我們知道了，在 glibc 下，執行 malloc 會得到一個指向分配給我們的大小為 24 字節的內存空間的指針。

但這只是在 glibc 下的結果，在其他 C 標準庫實現內，可能你會得到一個空指針。因為標準中提到了，對于 malloc(0) 這種故意挑事的代碼，實現時可以返回一個空指針作為回禮。