Какие проблемы переносимости связаны с доступом к указателям на уровне байтов в C?

Вам разрешен доступ к типу данных в виде массива беззнаковых символов, как здесь. Основная проблема с переносимостью, которую я вижу, может возникнуть на платформах, где битовый шаблон, идентифицирующий конкретное местоположение, не уникален - в этом случае вы можете получить указатели, которые сравнивают одинаковое хэширование с разными местоположениями, потому что битовые шаблоны были разными.

Почему они могут быть другими? Ну, во-первых, большинству типов данных C разрешено содержать биты заполнения, которые не участвуют в значении. Платформа, на которой указатели содержат такие биты заполнения, может иметь два указателя, которые отличаются только битами заполнения, указывающими на одно и то же место. (Например, ОС может использовать некоторые биты указателя для указания возможностей указателя, а не только физического адреса.) Другим примером является модель дальней памяти из первых дней DOS, где дальние указатели состояли из сегмента: смещение и соседнего сегменты перекрываются, так что сегмент: смещение может указывать на то же место, что и сегмент + 1: смещение-x.

Все это говорит о том, что на большинстве широко используемых сегодня платформ битовый шаблон, указывающий на данное местоположение, действительно уникален. Таким образом, ваш код будет широко переносимым, даже если он вряд ли будет строго соответствовать.

Выглядит довольно чистым. Если вы можете полагаться на заголовок <inttypes.h> из C99 (он часто доступен в другом месте), рассмотрите возможность использования uintptr_t, но если вы хотите хэшировать значение побайтно, вы в конечном итоге разбиваете все на байты, и нет никакого реального преимущества для Это.

В основном правильно. Однако есть одна потенциальная проблема. вы назначаете

size_t byte = ptrstr.string[i];

*строка определяется как char, а не как unsigned char. На платформе с подписанными символами и беззнаковым size_t это даст вам результат, который вы можете ожидать или не ожидать. Просто измените свой char на unsigned char, это будет чище.

Если вам не нужны значения указателя по какой-либо другой причине, кроме отслеживания выделенной памяти, почему бы вообще не избавиться от хеш-таблицы и просто сохранить магическое число вместе с выделенной памятью, как в примере ниже. Наличие магического числа рядом с выделенной памятью указывает на то, что она все еще «живая». При освобождении памяти вы очищаете сохраненное магическое число перед освобождением памяти.

#pragma pack(1)
struct sMemHdl
{
   int magic;
   byte firstByte;
};
#pragma pack()

#define MAGIC 0xDEADDEAD
#define MAGIC_SIZE sizeof(((struct sMemHdl *)0)->magic)

void *get_memory( size_t request )
{
   struct sMemHdl *pMemHdl = (struct sMemHdl *)malloc(MAGIC_SIZE + request);
   pMemHdl->magic = MAGIC;
   return (void *)&pMemHdl->firstByte;
}

void free_memory ( void *mem )
{
   if ( isgood_memory(mem) != 0 )
   {
      struct sMemHdl *pMemHdl = (struct sMemHdl *)((byte *)mem - MAGIC_SIZE);
      pMemHdl->magic = 0;
      free(pMemHdl);
   }
}

int isgood_memory ( void *Mem )
{
   struct sMemHdl *pMemHdl = (struct sMemHdl *)((byte *)Mem - MAGIC_SIZE);
   if ( pMemHdl->magic == MAGIC )
   {
      return 1; /* mem is good */
   }
   else
   {
      return 0; /* mem already freed */
   }
}

Это может быть немного хакерским, но я думаю, что я в хакерском настроении...

Доступ к переменным, таким как целые числа или указатели, такие как символы или символы без знака, не является проблемой с точки зрения переносимости. Но обратное неверно, потому что это зависит от оборудования. У меня есть один вопрос, почему вы хешируете указатель как строку вместо того, чтобы использовать сам указатель как хеш-значение (используя uintptr_t)?