Question

P|20131120|20131120
C|F|350.0|50.0|350.0|16.67|50.0|16.67|1400.0|Y|15.0|
C|H|610.3|87.19|610.3|29.06|87.19|29.06|2441.2|Y|15.0|
C|L|1386.0|198.0|1386.0|66.0|198.0|66.0|5544.0|Y|15.0|
C|Z|1286.0|183.71|1286.0|61.24|183.71|61.24|5144.0|Y|15.0|

P|20131121|20131121
C|A|323.65|46.24|323.65|15.41|46.24|15.41|1294.6|Y|15.0|
C|B|323.65|46.24|323.65|15.41|46.24|15.41|1294.6|Y|15.0|
C|D|365.65|52.24|365.65|17.41|52.24|17.41|1462.6|Y|15.0|
C|E|365.65|52.24|365.65|17.41|52.24|17.41|1462.6|Y|15.0|

以上是来自一个服务器的消息作为单个字符串。现在我想解析它并存储在用C语言处理的结构中。

这里对于一个P（Period）行，可以有许多C（Class）行。 '|'是字段分隔符，在存储到结构中时应该忽略。对于P，这里C（类）行的数量不固定。

有人可以在C中建议我，我应该如何声明结构并解析并将这些字段存储到其中。根据我的猜测，我必须在运行时为类（C）行声明结构数组，因为它不是固定的。有一件事是固定的：P（Period）行大小总是17字节（或charector）不包括管道（|）和C（Class）行大小是61字符，不包括管道（|。亲爱的所有，可以请任何人帮我C逻辑或代码。

Answer 1

此字符串有多个解析级别

使用令牌作为P / C进行第一级过滤
使用令牌作为|作为第二级过滤（在其中你有H / Y等，你需要将其复制到结构成员时）。

因此，您可以进行结构声明。

您可以访问此文章strtok usage

Answer 2

你去吧 -

struct node{
    char startChar, endChar;
    float numArr[8];
    struct node *next;
}

struct headerNode{
   int num1, num2;
   struct node *first;
}

之后你可以使用

createList() //create a blank list with header node.
createNode() //a C node everytime you need it.

Rest只是解析字符串。

我希望这会有所帮助。

Answer 3

#include <stdio.h>
#include <string.h>

#define MAX_CLASSES 100
#define MAX_PERIODS 100

struct Class{
  char a, i;
  float b,c,d,e,f,g,h,j;
};

struct Period{
  char date1[10], date2[10];
  struct Class classes[MAX_CLASSES];
};

struct Period periods[MAX_PERIODS];

int main(void){
  //use sscanf to parse the data
  //for example, (assuming data is in char *s),
  //sscanf(s, "P|%s|%s\n", periods[0].date1, periods[0].date2);
  return 0;
}

Answer 4

struct c_struct
{
    char c_content[61];
    struct c_strcut *next_c_strcut; //pointer to next class
};

struct PC_struct
{
    char p_content[17];
    struct c_struct *c_head; // pointer to first node
    struct PC_struct *PC_struct; // pointer to next pc 
};

Answer 5

最关键的部分是安全地解析输入，之后，解释，验证和组织预结构化数据是轻而易举的，我只做了下面的困难部分（输入处理）

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char *data =
  "P|20131120|20131120\n"
  "C|F|350.0|50.0|350.0|16.67|50.0|16.67|1400.0|Y|15.0|\n"
  "C|H|610.3|87.19|610.3|29.06|87.19|29.06|2441.2|Y|15.0|\n"
  "C|L|1386.0|198.0|1386.0|66.0|198.0|66.0|5544.0|Y|15.0|\n"
  "C|Z|1286.0|183.71|1286.0|61.24|183.71|61.24|5144.0|Y|15.0|\n"
  "\n"
  "P|20131121|20131121\n"
  "C|A|323.65|46.24|323.65|15.41|46.24|15.41|1294.6|Y|15.0|\n"
  "C|B|323.65|46.24|323.65|15.41|46.24|15.41|1294.6|Y|15.0|\n"
  "C|D|365.65|52.24|365.65|17.41|52.24|17.41|1462.6|Y|15.0|\n"
  "C|E|365.65|52.24|365.65|17.41|52.24|17.41|1462.6|Y|15.0|\n"
  ;

struct columns
{
  char *cols[12]; /* 16 pointers */
} rows[100];  /* bss, all zero */

#define N_COLS (sizeof(struct columns)/sizeof(char*))
#define N_ROWS (sizeof(rows)/sizeof(struct columns))

int main(void)
{
  char *rowsdata, *s;
  char **curcol  = rows->cols;
  char **lastcol = rows->cols + N_COLS;
  int row, i;

  rowsdata = s = strdup(data);
  if (rowsdata == 0) {
    perror("strdup");
    exit(1);
  }

  for (row=0; row < N_ROWS; s++) {
    if (*s == '|') {
      *s = 0;
      if (++curcol == lastcol) {
        puts("error: too much columns");
        exit(1);
      }
    } else if (*s == '\n') {
      *s = 0;
      row++;
      curcol  = (rows + row)->cols;
      lastcol = (rows + row)->cols + N_COLS;
    } else if (*curcol == 0) {
      *curcol = s;
    } else if (*s == 0) break;
  }

  /* do your logic here
   */

  for (i=0; i<row; i++) {
    curcol = (rows + i)->cols;
    lastcol = (rows + i)->cols + N_COLS;
    while (*curcol && curcol < lastcol) {
      printf("[%s]", *curcol);
      curcol++;
    }
    printf("\n");
  }

  /* free rowsdata only when done with rows
   */
  free(rowsdata); rowsdata = 0;

  return 0;
}

上面的代码很大程度上依赖于指针算法

*编辑：从'cols'重命名为'rows'，'cells'重命名为'cols'，更有意义

如何将给定的字符串解析为结构变量数组

5 个答案: