ошибка чтения/записи двоичного файла, содержащая указатель char* в структуре

Не называйте свои функции read и write (эти имена предназначены для функций Posix). И не ожидайте, что сможете снова прочитать указатель, написанный другим процессом. Это неопределенное поведение.

Итак, в вашем write вы (при условии, что 64-битная система x86, например, Linux) пишете 12 байтов (4, т.е. sizeof(int) + 8, т.е. sizeof(char*)); последние 8 байтов являются числовым значением некоторого malloc-указателя.

В вашем read вы читаете эти 12 байтов. Таким образом, вы устанавливаете в поле name числовой указатель, который оказался действительным в процессе, выполнившем write. Обычно это не работает (например, из-за ASLR).

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

То, что вы хотите сделать, называется сериализацией. По разработке программного обеспечения я рекомендую использовать текстовый формат для сериализации (например, JSON, возможно, используя Jansson библиотека). Текстовые форматы менее хрупкие и их легче отлаживать.

Предполагая, что вы закодируете студента в формате JSON, например

{ "id":123, "name":"John Doe" }

вот возможная процедура кодирования JSON с использованием Jansson:

int encode_student (FILE*fil, const Student*stu) {
   json_t* js = json_pack ("{siss}", 
                           "id", stu->id, 
                           "name", stu->name);
   int fail = json_dumpf (js, fil, JSON_INDENT(1));
   if (!fail) putc('\n', fil);
   json_decref (js); // will free the JSON
   return fail;  
}

Обратите внимание, что вам нужна функция для освобождения зоны malloc-ed Student, вот она:

void destroy_student(Student*st) {
   if (!st) return;
   free (st->name);
   free (st);
}

и вам может понадобиться макрос

#define DESTROY_CLEAR_STUDENT(st) do \
  { destroy_student(st); st = NULL; } while(0)

Теперь вот процедура декодирования JSON с использованием Jansson; он дает указатель Student в куче (который позже будет уничтожен вызывающей стороной с DESTROY_CLEAR_STUDENT).

Student* decode_student(FILE* fil) { 
   json_error_t jerr;
   memset (&jerr, 0, sizeof(jerr));
   json_t *js = json_loadf(fil, JSON_DISABLE_EOF_CHECK, &err);
   if (!js) {
      fprintf(stderr, "failed to decode student: %s\n", err.text);
      return NULL;
   }
   char* namestr=NULL;
   int idnum=0;
   if (json_unpack(js, "{siss}",  
                       "id", &idnum,
                       "name", &namestr)) {
       fprintf(stderr, "failed to unpack student\n");
       return NULL;
   };
   Student* res = malloc (sizeof(Student));
   if (!res) { perror("malloc student"); return NULL; };
   char *name = strdup(namestr);
   if (!name) { perror("strdup name"); free (res); return NULL; };
   memset(res, 9, sizeof(Student));
   res->id = id;
   res->name = name;
   json_decref(js);
   return res;
}

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

Вы также можете (в C99) решить, что name учащегося является элемент гибкого массива, который объявляется

typedef struct _student {
   int id;
   char name[]; // flexible member array, conventionally \0 terminated
} Student;

Вы действительно хотите, чтобы имена учеников были разной длины. Тогда вы не сможете просто поместить записи разной длины в простой файл FILE. Вы можете использовать некоторую библиотеку индексированных файлов, например GDBM (каждая запись может быть в формате JSON). И вы, вероятно, захотите использовать Sqlite или настоящую базу данных, такую ​​как MariaDb или MongoDB.

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

Либо поместите всю строку в свою структуру (не указатель на символ, а массив символов), либо вы должны отдельно записать строки в файл.

В read() вы никогда не выделяете память для name в своей структуре Student. (Ваша функция write() ведет себя в этом отношении гораздо лучше.)

Когда вы ссылаетесь на него в своем операторе printf, вы вызываете неопределенное поведение.