c - char 和 string 具有相同的变量

Question

首先，这个问题不适合那些自认为是 C++ 警察的人，因为它涉及到一些严重的 C 弯曲以压缩一些内存，所以请戴着你的治安警察帽子阅读这个问题。

我有一个程序，其中有许多用malloc分配的字符串，其中大多数都是1个字符长。包含 1 个字符的字符串大约需要 32 个字节的实内存，包括描述符、 block 大小等。所以我的狡猾计划是使用 char * 指针来存储字符或字符串:

char *sourceStringOrChar;

sourceStringOrChar = malloc(10);
//-- OR
sourceStringOrChar = (char *)'A';    //-- Note that its '' and not ""

if((intptr_t)sourceStringOrChar & (~0xFF))
    TRACE("%s\n", sourceStringOrChar);
else
    TRACE("%c\n", sourceStringOrChar);

我已经知道 malloc 在内存不足时返回 ENOMEM，其中该常量的实际值为 12。这给了我一些希望，malloc 返回的结果中有一个空位。我已经开始阅读malloc的源代码来确定这是否可能，但是如果这里有人对malloc有一些深入的了解，它可能会拯救我很多时间。

编辑:

• 问题当然是这是否可能。

• 有些人担心 free/strlen 等问题，但请注意，这是示例代码，可以使用与上面相同的方式处理

  if((intptr_t)sourceStringOrChar & (~0xFF))
  {
      strlen(sourceStringOrChar);
      free(sourceStringOrChar);
  }
  

• 此外，如果没有大的内存问题，我不会走上这条危险的道路

Answer 1

我一直在研究 CLISP 的代码。那里做了类似的事情，将一些立即值压缩到指针中(而不是从垃圾收集堆中分配对象)。

在 CLISP 的情况下，这是可行的，因为我们知道分配器可以返回的地址范围。然后有一个位永远无法由有效地址设置，如果设置该位，则表明“指针”不是实际的指针，而是数据(在您的情况下为单个或多个字符)。

顺便说一句:使用 char * 不是一个好计划，由于未定义的行为或者只是意外地将这样的“指针”传递给例如 strlen。我想使用 union 是一种更好的方法(尽管我目前没有时间检查标准中关于是否允许以这种方式使用 union 的实际规则)。更安全的是将 uintptr_t 打包到结构中。

[..] but if someone here have some knowledge on the deep-end of malloc it might save me a lot of time.

这不会给你买任何东西。切换操作系统、平台或只是使用的标准库，一切都可能与您当前正在查看的 malloc 实现所了解的有所不同。

一种方法是使用您自己的分配器 - 就像 CLISP 一样 - 它从某个池中获取内存(例如在 Linux/BSD 上使用 mmap 获取)，该内存驻留在某个预定义的地址。

但您也可以使用 malloc (或更合适的函数，如 C11 aligned_alloc 或 posix_memalign)来 allocate aligned memory为了你的琴弦。假设您将每个字符串对齐到偶数地址。这样，当您看到设置了最低有效位的地址时，您可以确定它实际上不是地址，而是立即数据，即字符串本身。

仅使用malloc来分配2字节对齐的内存，这样:您分配2个额外的字节。如果 malloc 返回的地址已经正确对齐，则返回下一个正确对齐的地址 (char_ptr + 2) 并使用某个值标记该地址之前的单元格，该值表示原始地址已对齐 (char_ptr[1] = '1')。另一方面，如果返回的地址未正确对齐，则返回紧随其后的字节(已正确对齐；char_ptr + 1)并标记该地址之前的单元格(因此，第一个；char_ptr[0] = '0')。

释放时，查看传入地址之前的单元格，它包含告诉您需要释放哪个地址的标记。

在代码中:

#define IS_ALIGNED_2BYTE(value) (((uintptr_t)(value) & 0x01) == 0)

/// Allocate a memory region of the specified size at an even (2 byte
/// aligned) address.
///
/// \param[in] size Required size of the memory region.
/// \return Pointer to the memory, or NULL on failure.
inline static void * allocate_2byte_aligned(size_t size) {
#ifdef HAVE_ALIGNED_ALLOC
  return aligned_alloc(2, size);
#elif defined(HAVE_POSIX_MEMALIGN)
  void * ptr;
  if (posix_memalign(&ptr, sizeof(void *), size) == 0) {
    assert(IS_ALIGNED_2BYTE(ptr)); // Paranoia due to uncertainty
                                   // about alignment parameter to
                                   // posix_memalign.
    return ptr;
  } else {
    return NULL;
  }
#else
  char * const memory = malloc(size + 2);
  if (! memory) {
    return NULL;
  }
  if (IS_ALIGNED_2BYTE(memory)) {
    // memory is correctly aligned, but to distinguish from originally
    // not aligned addresses when freeing we need to have at least one
    // byte. Thus we return the next correctly aligned address and
    // leave a note in the byte directly preceeding that address.
    memory[1] = '1';
    return &(memory[2]);
  } else {
    // memory is not correctly aligned. Leave a note in the first byte
    // about this for freeing later and return the next (and correctly
    // aligned) address.
    memory[0] = '0';
    return &(memory[1]);
  }
#endif
}


/// Free memory previously allocated with allocate_2byte_aligned.
///
/// \param[in] ptr Pointer to the 2 byte aligned memory region.
inline static void free_2byte_aligned(void * ptr) {
  assert(IS_ALIGNED_2BYTE(ptr));
#if defined(HAVE_ALIGNED_ALLOC) || defined(HAVE_POSIX_MEMALIGN)
  free(ptr);
#else
  char const * const memory = ptr;
  void const * original_address;
  if (memory[-1] == '0') {
    // malloc returned an address that was not aligned when allocating
    // this memory block. Thus we left one byte unused and returned
    // the address of memory[1]. Now we need to undo this addition.
    original_address = &(memory[-1]);
  } else {
    // malloc returned an address that was aligned. We left two bytes
    // unused and need to undo that now.
    assert(memory[-1] == '1');
    original_address = &(memory[-2]);
  }
  free((void *) original_address);
#endif
}

创建和销毁“指针或立即数据”结构非常简单:

typedef struct its_structure {
  uintptr_t data; ///< Either a pointer to the C string, or the actual
                  ///< string, together with a bit to indicate which
                  ///< of those it is.
} its;

its its_alloc(size_t size) {
  if (size < sizeof(uintptr_t)) {
    its const immediate_string = {.data = 0x01};
    return immediate_string;
  } else {
    void * const memory = allocate_2byte_aligned(size);
    assert(IS_ALIGNED_2BYTE(memory));
    its const allocated_string = {
      .data = memory ? (uintptr_t) memory : (0x01 | 0x02) /* Invalid string */};
    return allocated_string;
  }
}

void its_free(its string) {
  if (IS_ALIGNED_2BYTE(string.data)) {
    free_2byte_aligned((void *) string.data);
  } // else immediate, thus no action neccessary
}

以上代码实际上来自a small library I wrote测试/写这个答案。如果您愿意，请使用/增强它。