realloc не может перераспределить ранее распределенный указатель

Есть несколько проблем с вашим кодом:

• Вы тестируете while (c != 10), но c не инициализируется в первый раз, и вы не позволяете файлу закончиться до следующего '\n'. Вы также предполагаете ASCII, некоторые системы до сих пор используют EBCDIC, где '\n' не 10.
• Вы перераспределяете, используя sizeof(cmdline) вместо counter. sizeof(cmdline) - это размер указателя, а не текущий размер выделенного массива.
• Вы сохраняете getchar() в переменной char, EOF не является значением, которое может туда поместиться, и, возможно, значениями между 128 и UCHAR_MAX, если char подписано на вашей платформе. Используйте для этого int.
• Вы не завершаете выделенную строку нулем. Ни malloc, ни realloc не инициализируют выделенную память.
• Вы никогда не проверяете malloc или realloc сбой.
• Вероятно, вам следует вернуть NULL в конце файла, иначе невозможно определить конец файла по последовательностям пустых строк.
• Вы перераспределяете буфер для каждого символа, это неэффективно, но может быть оптимизировано на более позднем этапе, сначала исправьте код.

Вот исправленная версия:

#include <stdlib.h>

char *readCMDLine(void) {
    char *cmdline = malloc(1);
    size_t counter = 0, size = 1;
    int c;

    if (cmdline == NULL)
        return NULL;

    while ((c = getchar()) != EOF && c != '\n') {
        char *p = realloc(cmdline, counter + 2);
        if (p == NULL) {
            free(cmdline);
            return NULL;
        }
        cmdline = p;
        cmdline[counter++] = c;
    }
    cmdline[counter] = '\0';
    if (c == EOF && counter == 0) {
        free(cmdline);
        cmdline = NULL;
    }
    return cmdline;
}

Вот оптимизированная версия, которая гораздо реже вызывает realloc:

#include <stdlib.h>

#define ALLOCATE_INCREMENT  100
char *readCMDLine(void) {
    char *p, *cmdline = NULL;
    size_t counter = 0, size = 0;
    int c;

    while ((c = getchar()) != EOF && c != '\n') {
        if (counter > size - 2) {
            p = realloc(cmdline, size += ALLOCATE_INCREMENT);
            if (p == NULL) {
                free(cmdline);
                return NULL;
            }
            cmdline = p;
        }
        cmdline[counter++] = c;
    }
    if (counter == 0) {
        if (c == EOF || (cmdline = malloc(1)) == NULL)
            return NULL;
    } else {
        p = realloc(cmdline, counter + 1);
        if (p != NULL)
            cmdline = p;
    }
    cmdline[counter] = '\0';
    return cmdline;
} 

Использование sizeof(cmdline) не делает того, что вы ожидаете. При использовании с указателями он возвращает размер указателя, а не выделенную память. Это отличается для массивов, определенных во время компиляции.

Вы можете использовать переменную counter, чтобы отслеживать, сколько байтов уже выделено.

Также одна вещь стиля: sizeof(char) всегда 1, поэтому это не нужно.

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

Проблема здесь в том,

 sizeof(cmdline)

не работает так, как вы думаете. Вы не можете получить размер выделенной памяти, используя sizeof для указателя. Вы должны сами следить за размером.

Теперь, чтобы добавить немного об ошибке,

realloc(): неверный следующий размер: 0x00000000007ca010

в основном то, что происходит,

cmdline = realloc(cmdline, sizeof(cmdline) + sizeof(char));

на самом деле не изменяет размер выделенной памяти, как вы могли бы подумать. Таким образом, когда значение counter достаточно велико, чтобы указать на лишнюю память в случае cmdline[counter], вы, по сути, вызываете неопределенное поведение. Таким образом, из-за UB (и последующего повреждения памяти) realloc() выдает ошибку и выдает ошибку сегментации в качестве побочного эффекта.

Кроме того, чтобы добавить

• Пункт 1:

   pointer = realloc(pointer....)
  

  это очень плохой синтаксис для использования. В случае сбоя realloc() вы также потеряете фактическую память, поскольку она будет заменена NULL.

• Пункт 2:

  getchar() возвращает int, и все возвращаемые значения могут не соответствовать char (например, EOF ). Измените тип c на int.

• Пункт 3:

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

• Пункт 4:

  Вы должны проверить успешность malloc() и realloc() перед использованием возвращенного указателя.

Объединяем все предложения:

#define BYTES_TO_ADD 80     /* a rather arbitrary number */

char * readCMDLine ( void ) {
    char * cmdline = NULL;
    size_t cmdSize = 0;
    size_t cmdLen = 0;
    int    c;

    while ((c = getchar()) != EOF) {
        if (cmdLen == cmdSize) {
            char * tmp = realloc(cmdline, (cmdSize += BYTES_TO_ADD));  
            if (tmp == NULL) { free(cmdline); return NULL; } 
            cmdline = tmp;
        }
        cmdline[cmdLen++] = (c == '\n') ? '\0' : c;
        if (c == '\n') return cmdline;
    }
    return NULL;   /* no newline */
}