Удалите конечные пробелы внутри [] с помощью sscanf

Используйте "%n", чтобы определить смещение частей сканирования.

Используйте " ", чтобы просмотреть необязательные пробелы.

*scanf() не любит сканировать/формировать строки нулевой длины, поэтому при сканировании столбца рассматривайте [ как часть строки, чтобы гарантировать наличие хотя бы 1 символа в строке. Позже начните поле, которое прошло '['.

#include <stdio.h>
#define FN 8

char *cut_up_line(char *offset[FN], char * line) {
  for (int i = 0; i < FN; i++) {
    int field_end;
    int column_end = 0;
    // If possible for the line to include unusually white-spaces,
    // adjust format to include them: "%*[^] \t\r\v\f]%n ] %n"
    sscanf(line, "%*[^] \t]%n ] %n", &field_end, &column_end);
    if (column_end == 0) {
      // debug: printf("-%d <%s>\n", i, line);
      return NULL;
    }
    // Maybe add test here that *line is a '['.
    offset[i] = line + 1;
    line[field_end] = '\0';
    line += column_end;
    // debug: printf("+%d <%s>\n", i, offset[i]);
  }
  return line;
}


void test(char *line) {
  printf("<%s>\n", line);
  char *field[FN];
  if (cut_up_line(field, line) == NULL) {
    printf("** Failed **\n");
  } else {
    for (int i = 0; i < FN; i++) {
      printf("  %d:<%s>\n", i, field[i]);
    }
  }
}


int main() {
  char s1[] = "[8] [13420] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:18:29,836564+00:00]";
  char s2[] = "[7] [13611] [ts/3] [john    ] [pts/3       ] [192.168.1.38        ] [192.168.1.38   ] [2024-07-22T11:21:30,065856+00:00]";
  char s3[] = "[8] [13611] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:21:41,814051+00:00]";

  test(s1);
  test(s2);
  test(s3);
}

Выход

<[8] [13420] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:18:29,836564+00:00]>
  0:<8>
  1:<13420>
  2:<>
  3:<>
  4:<pts/3>
  5:<>
  6:<0.0.0.0>
  7:<2024-07-22T11:18:29,836564+00:00>
<[7] [13611] [ts/3] [john    ] [pts/3       ] [192.168.1.38        ] [192.168.1.38   ] [2024-07-22T11:21:30,065856+00:00]>
  0:<7>
  1:<13611>
  2:<ts/3>
  3:<john>
  4:<pts/3>
  5:<192.168.1.38>
  6:<192.168.1.38>
  7:<2024-07-22T11:21:30,065856+00:00>
<[8] [13611] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:21:41,814051+00:00]>
  0:<8>
  1:<13611>
  2:<>
  3:<>
  4:<pts/3>
  5:<>
  6:<0.0.0.0>
  7:<2024-07-22T11:21:41,814051+00:00>

• Некоторые форматы заслуживают разделения для ясности.

#define FMT_ALL_BUT_RBRACKET_WSPACE "%*[^] \t\r\n\f\v]"
...
sscanf(line, FMT_ALL_BUT_RBRACKET_WSPACE "%n ] %n", &field_end, &column_end);

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

Вот простой пользовательский парсер для этого формата:

#include <stdio.h>

// split the line and populate `fields` with pointers to trimmed contents.
int split_log(char *fields[], int n, char *line) {
    char *p = line;
    char *tail;
    int i;
    for (i = 0; i < n; i++) {
        while (*p == ' ')
            p++;
        if (*p != '[')
            break;
        p++;
        fields[i] = p;
        for (tail = p; *p && *p != ']'; p++) {
            if (*p != ' ')
                tail = p + 1;
        }
        if (*p != ']')
            break;
        *tail = '\0';
        p++;
    }
    return i;
}

void print_log(char *fields[], int n) {
    for (int i = 0; i < n; i++)
        printf("field%d = '%s'\n", i + 1, fields[i]);
    printf("\n");
}

int test_split(char *line, int n) {
    char *fields[8];
    int n1 = split_log(fields, n, line);
    printf("split_log found %d fields:\n", n1);
    print_log(fields, n1);
    return n == n1;
}

int main(void) {
    char line1[] = "[8] [13420] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:18:29,836564+00:00]\n";
    char line2[] = "[7] [13611] [ts/3] [john    ] [pts/3       ] [192.168.1.38        ] [192.168.1.38   ] [2024-07-22T11:21:30,065856+00:00]\n";
    char line3[] = "[8] [13611] [    ] [        ] [pts/3       ] [                    ] [0.0.0.0        ] [2024-07-22T11:21:41,814051+00:00]\n";

    test_split(line1, 8);
    test_split(line2, 8);
    test_split(line3, 8);
    return 0;
}

Выход:

split_log found 8 fields:
field1 = '8'
field2 = '13420'
field3 = ''
field4 = ''
field5 = 'pts/3'
field6 = ''
field7 = '0.0.0.0'
field8 = '2024-07-22T11:18:29,836564+00:00'

split_log found 8 fields:
field1 = '7'
field2 = '13611'
field3 = 'ts/3'
field4 = 'john'
field5 = 'pts/3'
field6 = '192.168.1.38'
field7 = '192.168.1.38'
field8 = '2024-07-22T11:21:30,065856+00:00'

split_log found 8 fields:
field1 = '8'
field2 = '13611'
field3 = ''
field4 = ''
field5 = 'pts/3'
field6 = ''
field7 = '0.0.0.0'
field8 = '2024-07-22T11:21:41,814051+00:00'

Как разобрать такую ​​строку на 8 переменных char * с помощью sscanf конкретно?

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

// split the line and populate `fields` with pointers to trimmed contents.
int split_log(char *fields[], int n, char *line) {
    char *p = line;
    char open[2], close[2];
    int i, begin, end;
    for (i = 0; i < n; i++) {
        if (sscanf(p, " %1[[]%n%*[^]]%n%1[]]", open, &begin, &end, close) != 2)
            break;
        fields[i] = p + begin;
        while (p[end - 1] == ' ')
            end--;
        p[end] = '\0';
        p += end + 1;
    }
    return i;
}

Проблема, которую я не могу решить, заключается в том, как обрезать конечные пробелы и в то же время позволить промежуточной строке [] изменять длину. Возможно ли это вообще с sscanf?

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

        // while (p[end - 1] == ' ')
        //    end--;
        while (sscanf(p + end - 1, "%1[ ]", open))
            end--;

Однако если содержимое поля содержит не более одного слова, вы можете использовать sscanf для вычисления длины этого слова:

int split_log(char *fields[], int n, char *line) {
    char *p = line;
    char open[2], close[2];
    int i, begin, end, len;
    for (i = 0; i < n; i++) {
        if (sscanf(p, " %1[[]%n%*[^]]%n%1[]]", open, &begin, &end, close) != 2)
            break;
        fields[i] = p + begin;
        p[end] = '\0';
        len = 0;
        sscanf(p + begin, "%*s%n", &len);
        p[begin + len] = '\0';
        p += end + 1;
    }
    return i;
}

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