Как удалить новую строку из динамических строк

В опубликованном фрагменте кода много проблем:

• вы не проверяете возвращаемое значение fgets(), вызывая неопределенное поведение при доступе к содержимому буфера в случае сбоя fgets().
• вызов fgets(sentinel,4,stdin); будет читать только до 3 байтов в sentinel, чтобы оставить место для конечного нулевого терминатора. Следовательно, перевод строки, введенный пользователем после yes, останется во входном потоке и приведет к немедленному возврату следующего вызова fgets() с содержимым буфера "\n".
• len = strlen(recipe.ingredients[j]) + 1; слишком велик: смещение новой строки будет strlen(recipe.ingredients[j]) - 1, если он присутствует и если recipe.ingredients[j] не является пустой строкой.
• recipe.ingredients[len] == "\0"; полностью подделка: это просто сравнение, а не назначение, и он сравнивает яблоки и апельсины: char и const char *.

Более простой способ удалить новую строку, если она есть:

char *p = recipe.ingredients[j];
p[strcspn(p, "\n")] = '\0';   // overwrite the newline, if present

Вот модифицированная версия:

for (;;) {
    char sentinel[100];
    char *p;

    printf("Put the ingredient: ");
    if (!fgets(recipe.ingredients[j], 30, stdin))
        break;
    p = recipe.ingredients[j];
    p[strcspn(p, "\n")] = '\0';   // overwrite the newline, if present
    fprintf(fbr, "%s,", recipe.ingredients[j]);
    j++;
    counter++;
    printf("Do you want to continue? (yes/no): ");
    if (!fgets(sentinel, sizeof sentinel, stdin))
        break;
    if (strcmp(sentinel, "yes") != 0)
        break;
}

Обратите внимание, что вы также должны убедиться, что j не увеличивается сверх размера массива recipe.ingredient.

Это всего лишь расширенный комментарий, который может быть кому-то полезен.

ответ от chqrlie соответствует заданному вопросу.

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

Основная логика проста. Мы используем два индекса в строке: i и o. i - это индекс следующего проверяемого символа, а o - это индекс, в котором мы сохраняем следующий символ, который хотим сохранить.

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

Функция, удаляющая все начальные пробелы из строки, часто называется ltrim(). Вот как это можно реализовать. Этот также удаляет все управляющие символы:

#include <stdlib.h>
#include <ctype.h>

char *ltrim(char *s)
{
    if (s != NULL) {
        char *in = s;
        char *out = s;

        /* Skip leading whitespace and control characters. */
        while (isspace(*in) || iscntrl(*in))
            in++;

        /* If there was no leading whitespace,
           we can simply return the original string. */
        if (in == out)
            return s;

        /* Move the rest of the string to start at s. */
        while (*in)
            *(in++) = *(out++);

        /* Terminate the string. */
        *out = '\0';
    }

    /* The function always returns the argument. */
    return s;
}

Обратите внимание, как in указывает на следующий символ в строке, который нужно исследовать, а out указывает на следующую позицию для сохранения сохраненного символа. У нас всегда есть in >= out, то есть мы не будем пытаться прочитать позицию, которую мы уже перезаписали, потому что всякий раз, когда мы увеличиваем out, мы также увеличиваем in.

Есть несколько способов реализовать rtrim(), функцию, которая удаляет все конечные пробелы, включая новую строку. Вот один из подходов. Он удаляет как завершающие пробелы, так и управляющие символы.

char *rtrim(char *s)
{
    if (s) {
        char *oug = s;

        /* This just implements out = s + strlen(s). */
        while (*out != '\0')
            out++;

        /* Back over trailing whitespace and controls. */
        while (out > s && (isspace(out[-1]) || iscntrl(out[-1])))
            out--;

        /* Terminate the string here. */
        *out = '\0';
    }

    /* This function also always returns the argument. */
    return s;
}

На этот раз, после того как мы скопировали (или проверили) все символы, мы «делаем резервную копию» завершающих символов, которые хотим удалить. Поскольку out указывает на позицию следующий, предыдущий символ - out[-1] (эквивалент *(out-1) в C). Однако мы должны быть осторожны, чтобы не перевернуть начало строки.

Вместо того, чтобы просто реализовать trim() как вызов обеих вышеуказанных функций, более эффективно объединить их в одну функцию:

char *trim(char *s)
{
    if (s != NULL) {
        char *in = s;
        char *out = s;

        /* Skip leading whitespace and control characters. */
        while (isspace(*in) || iscntrl(*in))
            in++;

        /* Move the rest of the string to start at s. */
        while (*in)
            *(in++) = *(out++);

        /* Back up over trailing whitespace and control characters. */
        while (out > s && (isspace(out[-1]) || iscntrl(out[-1])))
            out--;

        /* Terminate the string. */
        *out = '\0';
    }

    /* Always return the argument. */
    return s;
}

Я обычно использую только trim().

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

char *clean(char *s)
{
    if (s != NULL) {
        char *in = s;
        char *out = s;

        /* Skip leading whitespace and control characters. */
        while (isspace(*in) || iscntrl(*in))
            in++;

        /* Move the rest of the string to start at s,
           combining consecutive whitespaces and control
           characters to a single space. */
        while (*in)
            if (isspace(*in) || iscntrl(*in)) {
                /* Skip all consecutive whitespaces and
                   control characters first. */
                while (isspace(*in) || iscntrl(*in));
                    in++;
                /* "Replace" them with a single space. */
                *(out++) = ' ';
            } else
                *(in++) = *(out++);

        /* Back up over the one trailing space we might have copied. */
        if (out > s && out[-1] == ' ')
            out--;

        /* Terminate the string. */
        *out = '\0';
    }

    /* Always return the argument. */
    return s;
}

По сути, единственное отличие от trim() состоит в том, что в цикле копирования, если мы встречаем пробел или управляющий символ, мы пропускаем их все (то есть последовательные), а затем сохраняем только один пробел, чтобы «заменить» их этим единственным космос.

Поскольку указанные выше функции изменяют данную строку, вы не можете использовать их в строковых литералах. То есть что-то вроде

char *mystring = clean(" This Will Not Work ");

или же

char *oldstring = " Thiss Will Not Work Either ";
char *mystring = clean(oldstring);

не будет работать, потому что вы не должны пытаться изменять строковые литералы. Помните, что в приведенных выше формах oldstring и mystring являются указателями на строковые литералы.

Вместо этого создайте массив символов, который инициализируется строковым литералом. Впоследствии вы можете изменить массив символов:

char  mybuffer[] = " This will work just Fine.\n";
clean(mybuffer);

или же

char  line[256] = "This will work, too.\n";
printf("Read '%s'.\n", trim(line));

Обратите внимание на то, что возвращаемое значение (указатель на строку) не используется в первом примере, а предоставляется как строка для печати во втором примере. Если вы используете форму, использованную в последнем примере, помните, что она изменяет line[]; строка все еще "обрезана" после вызова printf. Проще говоря, последнее в точности эквивалентно

char  line[256] = "This will work, too.\n";
trim(line);
printf("Read '%s'.\n", line);

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