현재 위치

홈 ›› Forums ›› 공부 ›› 프로그래밍 QnA

C언어 파일입출력을 이용할 때, 파일을 한줄씩 읽는 방법이 궁금합니다.

익명 사용자의 이미지
글쓴이: 익명 사용자 / 작성시간: 금, 2020/06/12 - 4:55오후

파일에 있는 문자열과 숫자쌍을 출력하는 프로그램인데요

먼저 파일에 있는 데이터를 알려드리면

Poly1 2 10 4 3
Poly2 3 5 6 3 5 8

이렇게입니다.

최종적인 출력은

문자열: Poly1
숫자쌍: 2 10
숫자쌍: 4 3
문자열: Poly2
숫자쌍: 3 5
숫자쌍: 6 3
숫자쌍: 5 8

이렇게입니다. 제가 짜본 코드는 이건데

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
FILE* fp;
char name[100];
int ch, gy;

fp = fopen("data.txt", "r");

while (!feof(fp))
{
fscanf(fp, "%s", name);
printf("문자열:%s\n", name);
fscanf(fp, "%d %d\n", &ch, &gy);
printf("숫자: %d %d\n", ch, gy);
}
}
지금 코드는 문자열 -> 숫자 -> 숫자 -> 문자열 -> 숫자 -> 숫자 이런식으로 파일에서 입력을 받고있는데 제가 원하는건
문자열 -> 숫자 -> 숫자->숫자->숫자(한줄끝)

문자열 -> 숫자 -> 숫자->숫자->숫자->숫자->숫자(한줄끝)

이런 식으로 입력받는건데 어떻게해야할지를 전혀모르겠네요... fgets함수는 한 변수에만 넣는거라 더 어렵네요...

혹시나 질문에서 뭔가 누락된게있으면 말씀해주세요...프로그래밍 질문은 처음이라 잘모를수있습니다 ㅠㅠ

Forums: 
프로그래밍 QnA
김정균의 이미지

글쓴이: 김정균 / 작성시간: 금, 2020/06/12 - 5:20오후

fgets 로 받은 string 을 tokenizing 하는게 좋을 것 같은데요. tokenizing 은 strsep 사용하시면 되겠고요.

strsep 는 man page 나 google에서 "strsep 예제" 로 찾아 보시면 많이 나옵니다.

뭐 여기 고수분들이 많으니, 다른 간소한 방법을 올려 주실지도..

글쓴이의 이미지

글쓴이: 글쓴이 / 작성시간: 금, 2020/06/12 - 5:50오후

fgets로 받은걸 토큰단위?로 나누어서 하시라는건가용? 한번 찾아보겠습니다! 답변감사드려요

김정균의 이미지

글쓴이: 김정균 / 작성시간: 금, 2020/06/12 - 7:19오후

쉽게 말하면 한 라인을 문자열로 받은 다음, 공백문자를 기준으로 잘라서 새로운 배열변수를 만들라는 것이죠.

익명 사용자의 이미지

글쓴이: 익명 사용자 / 작성시간: 금, 2020/06/12 - 5:29오후

입력 중에 숫자로 시작하는 문자열이 있나요? (e.g., "1string")

이게 있는지 없는지에 따라 난이도가 조금 차이가 있습니다.
대부분의 프로그래밍 언어가 숫자로 시작하는 identifier를 허용하지 않았던 이유이기도 하죠.

글쓴이의 이미지

글쓴이: 글쓴이 / 작성시간: 금, 2020/06/12 - 5:44오후

문자열중에는 숫자로시작하는 문자열은 없고 num1처럼 섞어쓰는경우는 있습니다!!

사기꾼의 이미지

글쓴이: 사기꾼 / 작성시간: 금, 2020/06/12 - 8:33오후

대충 짜봤습니다 ^^

#define _GNU_SOURCE
 
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
union yyalloc {
  int16_t yyss_alloc;
  char *yyvs_alloc;
};
 
enum yytokentype { STRING = 258, NUMBER = 259 };
static const uint8_t yytranslate[] = {
    0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4};
static const int8_t yypact[] = {-3, -4, -2, 3, -3, -4, -4, -4};
static const uint8_t yydefact[] = {2, 4, 0, 0, 2, 5, 1, 3};
static const int8_t yypgoto[] = {-4, 0, -4};
static const int8_t yydefgoto[] = {-1, 3, 4};
static const uint8_t yytable[] = {1, 2, 5, 6, 7};
static const uint8_t yycheck[] = {3, 4, 4, 0, 4};
static const uint8_t yystos[] = {0, 3, 4, 6, 7, 4, 0, 6};
static const uint8_t yyr1[] = {0, 5, 6, 6, 7, 7};
static const uint8_t yyr2[] = {0, 2, 0, 2, 1, 2};
static const int16_t yy_accept[10] = {0, 0, 0, 5, 2, 3, 1, 2, 1, 0};
static const unsigned char yy_ec[256] = {
    0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
static const unsigned char yy_meta[4] = {0, 1, 2, 1};
static const uint16_t yy_base[11] = {0, 0, 0, 6, 0, 7, 2, 0, 0, 7, 3};
static const int16_t yy_def[11] = {0, 9, 1, 9, 10, 9, 10, 10, 6, 0, 9};
static const uint16_t yy_nxt[11] = {0, 4, 5, 6, 7, 8, 9, 3, 9, 9, 9};
static const int16_t yy_chk[11] = {0, 1, 1, 1, 10, 6, 3, 9, 9, 9, 9};
 
static int yy_init = 0;
static int yy_start = 0;
static FILE *yyin, *yyout;
struct yy_buffer_state {
  FILE *yy_input_file;
  char *yy_ch_buf;
  char *yy_buf_pos;
  size_t yy_buf_size;
  int yy_n_chars;
  int yy_is_our_buffer;
  int yy_is_interactive;
  int yy_at_bol;
  int yy_bs_lineno;
  int yy_bs_column;
  int yy_fill_buffer;
  int yy_buffer_status;
};
static size_t yy_buffer_stack_top = 0;
static size_t yy_buffer_stack_max = 0;
static struct yy_buffer_state **yy_buffer_stack = 0;
static char yy_hold_char;
static int yy_n_chars;
static size_t yyleng;
static char *yy_c_buf_p = (char *)0;
static int yy_did_buffer_switch_on_eof;
static int yynerrs;
static int yychar;
static char *yylval;
static int yy_last_accepting_state;
static char *yy_last_accepting_cpos;
static char *yytext;
 
static int yyparse(void);
static int yylex(void);
static void yyensure_buffer_stack(void);
static struct yy_buffer_state *yy_create_buffer(FILE *file, int size);
static void yy_load_buffer_state(void);
static int yy_get_previous_state(void);
static int yy_try_NUL_trans(int yy_current_state);
static int yy_get_next_buffer(void);
static void yyrestart(FILE *input_file);
static void yy_init_buffer(struct yy_buffer_state *b, FILE *file);
static void yy_flush_buffer(struct yy_buffer_state *b);
__attribute__((__noreturn__)) static void yy_fatal_error(const char *msg);
 
int main() {
  yyparse();
  return EXIT_SUCCESS;
}
 
static int yyparse(void) {
  int yystate;
  int yyerrstatus;
  int16_t yyssa[200];
  int16_t *yyss;
  int16_t *yyssp;
  char *yyvsa[200];
  char **yyvs;
  char **yyvsp;
  long unsigned int yystacksize;
  int yyn;
  int yyresult;
  int yytoken = 0;
  char *yyval;
  int yylen = 0;
  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yystacksize = 200;
  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = (-2);
  goto yysetstate;
yynewstate:
  yyssp++;
yysetstate:
  *yyssp = yystate;
  if (yyss + yystacksize - 1 <= yyssp) {
    long unsigned int yysize = yyssp - yyss + 1;
    if (10000 <= yystacksize) goto yyexhaustedlab;
    yystacksize *= 2;
    if (10000 < yystacksize) yystacksize = 10000;
    {
      int16_t *yyss1 = yyss;
      union yyalloc *yyptr = (union yyalloc *)malloc(
          ((yystacksize) * (sizeof(int16_t) + sizeof(char *)) +
           (sizeof(union yyalloc) - 1)));
      if (!yyptr) goto yyexhaustedlab;
      do {
        long unsigned int yynewbytes;
        __builtin_memcpy(&yyptr->yyss_alloc, yyss, (yysize) * sizeof(*(yyss)));
        yyss = &yyptr->yyss_alloc;
        yynewbytes = yystacksize * sizeof(*yyss) + (sizeof(union yyalloc) - 1);
        yyptr += yynewbytes / sizeof(*yyptr);
      } while (0);
      do {
        long unsigned int yynewbytes;
        __builtin_memcpy(&yyptr->yyvs_alloc, yyvs, (yysize) * sizeof(*(yyvs)));
        yyvs = &yyptr->yyvs_alloc;
        yynewbytes = yystacksize * sizeof(*yyvs) + (sizeof(union yyalloc) - 1);
        yyptr += yynewbytes / sizeof(*yyptr);
      } while (0);
      if (yyss1 != yyssa) free(yyss1);
    }
    yyssp = yyss + yysize - 1;
    yyvsp = yyvs + yysize - 1;
    ;
    if (yyss + yystacksize - 1 <= yyssp) goto yyabortlab;
  };
  if (yystate == 6) goto yyacceptlab;
  goto yybackup;
yybackup:
  yyn = yypact[yystate];
  if ((!!((yyn) == (-4)))) goto yydefault;
  if (yychar == (-2)) {
    ;
    yychar = yylex();
  }
  if (yychar <= 0) {
    yychar = yytoken = 0;
    ;
  } else {
    yytoken = ((unsigned int)(yychar) <= 259 ? yytranslate[yychar] : 2);
    ;
  }
  yyn += yytoken;
  if (yyn < 0 || 4 < yyn || yycheck[yyn] != yytoken) goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0) {
    if (0) goto yyerrlab;
    yyn = -yyn;
    goto yyreduce;
  }
  if (yyerrstatus) yyerrstatus--;
  ;
  yychar = (-2);
  yystate = yyn;
  *++yyvsp = yylval;
  goto yynewstate;
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0) goto yyerrlab;
  goto yyreduce;
yyreduce:
  yylen = yyr2[yyn];
  yyval = yyvsp[1 - yylen];
  ;
  switch (yyn) {
    case 4: {
      printf("문자열: %s\n", (yyvsp[0]));
      free((yyvsp[0]));
    } break;
    case 5: {
      printf("숫자쌍: %s %s\n", (yyvsp[-1]), (yyvsp[0]));
      free((yyvsp[-1]));
      free((yyvsp[0]));
    } break;
    default:
      break;
  };
  (yyvsp -= (yylen), yyssp -= (yylen));
  yylen = 0;
  ;
  *++yyvsp = yyval;
  yyn = yyr1[yyn];
  yystate = yypgoto[yyn - 5] + *yyssp;
  if (0 <= yystate && yystate <= 4 && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - 5];
  goto yynewstate;
yyerrlab:
  yytoken = yychar == (-2)
                ? (-2)
                : ((unsigned int)(yychar) <= 259 ? yytranslate[yychar] : 2);
  if (!yyerrstatus) {
    ++yynerrs;
    yy_fatal_error("syntax error");
  }
  if (yyerrstatus == 3) {
    if (yychar <= 0) {
      if (yychar == 0) goto yyabortlab;
    } else {
      yychar = (-2);
    }
  }
  goto yyerrlab1;
yyerrorlab:
  if (0) goto yyerrorlab;
  (yyvsp -= (yylen), yyssp -= (yylen));
  yylen = 0;
  ;
  yystate = *yyssp;
  goto yyerrlab1;
yyerrlab1:
  yyerrstatus = 3;
  for (;;) {
    yyn = yypact[yystate];
    if (!(!!((yyn) == (-4)))) {
      yyn += 1;
      if (0 <= yyn && yyn <= 4 && yycheck[yyn] == 1) {
        yyn = yytable[yyn];
        if (0 < yyn) break;
      }
    }
    if (yyssp == yyss) goto yyabortlab;
    (yyvsp -= (1), yyssp -= (1));
    yystate = *yyssp;
    ;
  }
  *++yyvsp = yylval;
  ;
  yystate = yyn;
  goto yynewstate;
yyacceptlab:
  yyresult = 0;
  goto yyreturn;
yyabortlab:
  yyresult = 1;
  goto yyreturn;
yyexhaustedlab:
  yy_fatal_error("memory exhausted");
  yyresult = 2;
yyreturn:
  if (yychar != (-2)) {
    yytoken = ((unsigned int)(yychar) <= 259 ? yytranslate[yychar] : 2);
  }
  (yyvsp -= (yylen), yyssp -= (yylen));
  ;
  while (yyssp != yyss) {
    (yyvsp -= (1), yyssp -= (1));
  }
  if (yyss != yyssa) free(yyss);
  return yyresult;
}
 
static int yylex(void) {
  int yy_current_state;
  char *yy_cp, *yy_bp;
  int yy_act;
  if (!(yy_init)) {
    (yy_init) = 1;
    if (!(yy_start)) (yy_start) = 1;
    if (!yyin) yyin = stdin;
    if (!yyout) yyout = stdout;
    if (!((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)]
                            : NULL)) {
      yyensure_buffer_stack();
      (yy_buffer_stack)[(yy_buffer_stack_top)] = yy_create_buffer(yyin, 16384);
    }
    yy_load_buffer_state();
  }
  {
    while (1) {
      yy_cp = (yy_c_buf_p);
      *yy_cp = (yy_hold_char);
      yy_bp = yy_cp;
      yy_current_state = (yy_start);
    yy_match:
      do {
        unsigned char yy_c = yy_ec[((unsigned int)(unsigned char)*yy_cp)];
        if (yy_accept[yy_current_state]) {
          (yy_last_accepting_state) = yy_current_state;
          (yy_last_accepting_cpos) = yy_cp;
        }
        while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
          yy_current_state = (int)yy_def[yy_current_state];
          if (yy_current_state >= 10) yy_c = yy_meta[(unsigned int)yy_c];
        }
        yy_current_state =
            yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
        ++yy_cp;
      } while (yy_base[yy_current_state] != 7);
    yy_find_action:
      yy_act = yy_accept[yy_current_state];
      if (yy_act == 0) {
        yy_cp = (yy_last_accepting_cpos);
        yy_current_state = (yy_last_accepting_state);
        yy_act = yy_accept[yy_current_state];
      }
      (yytext) = yy_bp;
      yyleng = (size_t)(yy_cp - yy_bp);
      (yy_hold_char) = *yy_cp;
      *yy_cp = '\0';
      (yy_c_buf_p) = yy_cp;
      ;
    do_action:
      switch (yy_act) {
        case 0:
          *yy_cp = (yy_hold_char);
          yy_cp = (yy_last_accepting_cpos);
          yy_current_state = (yy_last_accepting_state);
          goto yy_find_action;
        case 1: {
          yylval = strdup(yytext);
          return NUMBER;
        } break;
        case 2: {
          yylval = strdup(yytext);
          return STRING;
        } break;
        case 3:;
          break;
        case 4:
          do {
            if (fwrite(yytext, yyleng, 1, yyout)) {
            }
          } while (0);
          break;
        case (5 + 0 + 1):
          return 0;
        case 5: {
          int yy_amount_of_matched_text = (int)(yy_cp - (yytext)) - 1;
          *yy_cp = (yy_hold_char);
          if ((yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status == 0) {
            (yy_n_chars) = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars;
            (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_input_file = yyin;
            (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status = 1;
          }
          if ((yy_c_buf_p) <= &(yy_buffer_stack)[(yy_buffer_stack_top)]
                                   ->yy_ch_buf[(yy_n_chars)]) {
            int yy_next_state;
            (yy_c_buf_p) = (yytext) + yy_amount_of_matched_text;
            yy_current_state = yy_get_previous_state();
            yy_next_state = yy_try_NUL_trans(yy_current_state);
            yy_bp = (yytext) + 0;
            if (yy_next_state) {
              yy_cp = ++(yy_c_buf_p);
              yy_current_state = yy_next_state;
              goto yy_match;
            } else {
              yy_cp = (yy_c_buf_p);
              goto yy_find_action;
            }
          } else
            switch (yy_get_next_buffer()) {
              case 1: {
                (yy_did_buffer_switch_on_eof) = 0;
                if ((1)) {
                  (yy_c_buf_p) = (yytext) + 0;
                  yy_act = (5 + (((yy_start)-1) / 2) + 1);
                  goto do_action;
                } else {
                  if (!(yy_did_buffer_switch_on_eof)) yyrestart(yyin);
                }
                break;
              }
              case 0:
                (yy_c_buf_p) = (yytext) + yy_amount_of_matched_text;
                yy_current_state = yy_get_previous_state();
                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext) + 0;
                goto yy_match;
              case 2:
                (yy_c_buf_p) = &(yy_buffer_stack)[(yy_buffer_stack_top)]
                                    ->yy_ch_buf[(yy_n_chars)];
                yy_current_state = yy_get_previous_state();
                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext) + 0;
                goto yy_find_action;
            }
          break;
        }
        default:
          yy_fatal_error("fatal flex scanner internal error--no action found");
      }
    }
  }
}
 
static void yyensure_buffer_stack(void) {
  size_t num_to_alloc;
  if (!(yy_buffer_stack)) {
    num_to_alloc = 1;
    (yy_buffer_stack) = (struct yy_buffer_state **)malloc(
        num_to_alloc * sizeof(struct yy_buffer_state *));
    if (!(yy_buffer_stack))
      yy_fatal_error("out of dynamic memory in yyensure_buffer_stack()");
    memset((yy_buffer_stack), 0,
           num_to_alloc * sizeof(struct yy_buffer_state *));
    (yy_buffer_stack_max) = num_to_alloc;
    (yy_buffer_stack_top) = 0;
    return;
  }
  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1) {
    size_t grow_size = 8;
    num_to_alloc = (yy_buffer_stack_max) + grow_size;
    (yy_buffer_stack) = (struct yy_buffer_state **)realloc(
        (yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state *));
    if (!(yy_buffer_stack))
      yy_fatal_error("out of dynamic memory in yyensure_buffer_stack()");
    memset((yy_buffer_stack) + (yy_buffer_stack_max), 0,
           grow_size * sizeof(struct yy_buffer_state *));
    (yy_buffer_stack_max) = num_to_alloc;
  }
}
 
static struct yy_buffer_state *yy_create_buffer(FILE *file, int size) {
  struct yy_buffer_state *b;
  b = (struct yy_buffer_state *)malloc(sizeof(struct yy_buffer_state));
  if (!b) yy_fatal_error("out of dynamic memory in yy_create_buffer()");
  b->yy_buf_size = (size_t)size;
  b->yy_ch_buf = (char *)malloc(b->yy_buf_size + 2);
  if (!b->yy_ch_buf)
    yy_fatal_error("out of dynamic memory in yy_create_buffer()");
  b->yy_is_our_buffer = 1;
  yy_init_buffer(b, file);
  return b;
}
 
static void yy_load_buffer_state(void) {
  (yy_n_chars) = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars;
  (yytext) = (yy_c_buf_p) =
      (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_pos;
  yyin = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_input_file;
  (yy_hold_char) = *(yy_c_buf_p);
}
 
static int yy_get_previous_state(void) {
  int yy_current_state;
  char *yy_cp;
  yy_current_state = (yy_start);
  for (yy_cp = (yytext) + 0; yy_cp < (yy_c_buf_p); ++yy_cp) {
    unsigned char yy_c =
        (*yy_cp ? yy_ec[((unsigned int)(unsigned char)*yy_cp)] : 1);
    if (yy_accept[yy_current_state]) {
      (yy_last_accepting_state) = yy_current_state;
      (yy_last_accepting_cpos) = yy_cp;
    }
    while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
      yy_current_state = (int)yy_def[yy_current_state];
      if (yy_current_state >= 10) yy_c = yy_meta[(unsigned int)yy_c];
    }
    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
  }
  return yy_current_state;
}
 
static int yy_try_NUL_trans(int yy_current_state) {
  int yy_is_jam;
  char *yy_cp = (yy_c_buf_p);
  unsigned char yy_c = 1;
  if (yy_accept[yy_current_state]) {
    (yy_last_accepting_state) = yy_current_state;
    (yy_last_accepting_cpos) = yy_cp;
  }
  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
    yy_current_state = (int)yy_def[yy_current_state];
    if (yy_current_state >= 10) yy_c = yy_meta[(unsigned int)yy_c];
  }
  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];
  yy_is_jam = (yy_current_state == 9);
  return yy_is_jam ? 0 : yy_current_state;
}
 
static int yy_get_next_buffer(void) {
  char *dest = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf;
  char *source = (yytext);
  size_t number_to_move, i;
  int ret_val;
  if ((yy_c_buf_p) >
      &(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars) + 1])
    yy_fatal_error("fatal flex scanner internal error--end of buffer missed");
  if ((yy_buffer_stack)[(yy_buffer_stack_top)]->yy_fill_buffer == 0) {
    if ((yy_c_buf_p) - (yytext)-0 == 1) {
      return 1;
    } else {
      return 2;
    }
  }
  number_to_move = (size_t)((yy_c_buf_p) - (yytext)) - 1;
  for (i = 0; i < number_to_move; ++i) *(dest++) = *(source++);
  if ((yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status == 2)
    (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars) = 0;
  else {
    size_t num_to_read = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size -
                         number_to_move - 1;
    while (num_to_read <= 0) {
      struct yy_buffer_state *b = (yy_buffer_stack)[(yy_buffer_stack_top)];
      int yy_c_buf_p_offset = (int)((yy_c_buf_p)-b->yy_ch_buf);
      if (b->yy_is_our_buffer) {
        size_t new_size = b->yy_buf_size * 2;
        if (new_size <= 0)
          b->yy_buf_size += b->yy_buf_size / 8;
        else
          b->yy_buf_size *= 2;
        b->yy_ch_buf =
            (char *)realloc((void *)b->yy_ch_buf, b->yy_buf_size + 2);
      } else
        b->yy_ch_buf = 0;
      if (!b->yy_ch_buf)
        yy_fatal_error("fatal error - scanner input buffer overflow");
      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
      num_to_read = (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size -
                    number_to_move - 1;
    }
    if (num_to_read > 8192) num_to_read = 8192;
    if ((yy_buffer_stack)[(yy_buffer_stack_top)]->yy_is_interactive) {
      int c = '*';
      size_t n;
      for (n = 0; n < num_to_read && (c = getc(yyin)) != EOF && c != '\n'; ++n)
        (&(yy_buffer_stack)[(yy_buffer_stack_top)]
              ->yy_ch_buf[number_to_move])[n] = (char)c;
      if (c == '\n')
        (&(yy_buffer_stack)[(yy_buffer_stack_top)]
              ->yy_ch_buf[number_to_move])[n++] = (char)c;
      if (c == EOF && ferror(yyin))
        yy_fatal_error("input in flex scanner failed");
      (yy_n_chars) = n;
    } else {
      errno = 0;
      while (((yy_n_chars) = fread((&(yy_buffer_stack)[(yy_buffer_stack_top)]
                                         ->yy_ch_buf[number_to_move]),
                                   1, num_to_read, yyin)) == 0 &&
             ferror(yyin)) {
        if (errno != EINTR) {
          yy_fatal_error("input in flex scanner failed");
          break;
        }
        errno = 0;
        clearerr(yyin);
      }
    };
    (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_n_chars = (yy_n_chars);
  }
  if ((yy_n_chars) == 0) {
    if (number_to_move == 0) {
      ret_val = 1;
      yyrestart(yyin);
    } else {
      ret_val = 2;
      (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buffer_status = 2;
    }
  } else
    ret_val = 0;
  if ((int)((yy_n_chars) + number_to_move) >
      (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_buf_size) {
    int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
    (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf = (char *)realloc(
        (void *)(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf, new_size);
    if (!(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf)
      yy_fatal_error("out of dynamic memory in yy_get_next_buffer()");
  }
  (yy_n_chars) += number_to_move;
  (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars)] = 0;
  (yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[(yy_n_chars) + 1] = 0;
  (yytext) = &(yy_buffer_stack)[(yy_buffer_stack_top)]->yy_ch_buf[0];
  return ret_val;
}
 
static void yyrestart(FILE *input_file) {
  if (!((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL)) {
    yyensure_buffer_stack();
    (yy_buffer_stack)[(yy_buffer_stack_top)] = yy_create_buffer(yyin, 16384);
  }
  yy_init_buffer(
      ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL),
      input_file);
  yy_load_buffer_state();
}
 
static void yy_init_buffer(struct yy_buffer_state *b, FILE *file) {
  int oerrno = errno;
  yy_flush_buffer(b);
  b->yy_input_file = file;
  b->yy_fill_buffer = 1;
  if (b !=
      ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL)) {
    b->yy_bs_lineno = 1;
    b->yy_bs_column = 0;
  }
  b->yy_is_interactive = file ? (isatty(fileno(file)) > 0) : 0;
  errno = oerrno;
}
 
static void yy_flush_buffer(struct yy_buffer_state *b) {
  if (!b) return;
  b->yy_n_chars = 0;
  b->yy_ch_buf[0] = 0;
  b->yy_ch_buf[1] = 0;
  b->yy_buf_pos = &b->yy_ch_buf[0];
  b->yy_at_bol = 1;
  b->yy_buffer_status = 0;
  if (b ==
      ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL))
    yy_load_buffer_state();
}
 
static void yy_fatal_error(const char *msg) {
  fprintf(stderr, "%s\n", msg);
  exit(EXIT_FAILURE);
}
글쓴이의 이미지

글쓴이: 글쓴이 / 작성시간: 금, 2020/06/12 - 8:44오후

아직 프로그래밍을 잘 몰라서... 굉장히 복잡하네요 @_@ 짜주신코드를 이해하는건 엄청오래걸릴것같지만 감사합니다!

jick의 이미지

글쓴이: jick / 작성시간: 토, 2020/06/13 - 2:37오전

이거 flex나 유사품 써서 자동생성된 코드죠? -.-

초보자한테 이런 장난을 치시다니, 나빠요!

파이썬3의 이미지

글쓴이: 파이썬3 / 작성시간: 일, 2020/06/14 - 12:57오후

전 왤케 사기꾼님의 코드가 아름답게 보일까요?
페이스북이라면 좋아요를 막 눈지르고 싶네요^^^

[우분투 18.04 파여폭스 나비에서 적었어요~]

라스코니의 이미지

글쓴이: 라스코니 / 작성시간: 금, 2020/06/12 - 9:12오후

파일로부터 값을 읽을 필요가 있을 때 fgets() + sscanf() 조합이 좋더군요.

글쓴이의 이미지

글쓴이: 글쓴이 / 작성시간: 금, 2020/06/12 - 9:19오후

fgets은 char형밖에 받을 수 밖에 없어서 어쩌지 고민하고있었는데 sscanf가 있었네요!! 답변감사드려요! 한번 해결해보겠습니다

글쓴이의 이미지

글쓴이: 글쓴이 / 작성시간: 금, 2020/06/12 - 10:52오후 

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
 
int main()
{
	FILE* fp;
	char length[100];
	char name[100];
	int ch, gy;
 
	fp = fopen("data.txt", "r");
 
	while (!feof(fp))
	{
		fscanf(fp, "%s", name);
		printf("문자열:%s\n", name);
		fgets(length, 100, fp);
		printf("%d", strlen(length));
		for (int i = 1; i < strlen(length)-1; i=i+4)
		{
			sscanf(length+i, "%d %d", &ch,&gy);
			if (ch >= 10 || ch <= -1)
				i++;
			if (gy >= 10 || gy <= -1)
				i++;
			printf("숫자쌍: %d %d\n", ch, gy);
		}
	}
}

sscanf+fgets로 해결했네요...제가 보기에도 코드가 좀 더럽긴해도...해결했다는거에 의의를 두겠습니다 ㅋㅋ

김정균의 이미지

글쓴이: 김정균 / 작성시간: 토, 2020/06/13 - 2:13오전

scanf 류는 신경쓰지 않으면 bof (Boffer overflow) 의 위험이 많기 때문에 잘 쓰셔야 합니다.
https://blog.naver.com/PostView.nhn?blogId=mdstec_auto&logNo=220896135830 또는 검색에서 "scanf 버퍼 오버플로우" 로 검색해 보시면 fscanf 또는 vfscanf 를 사용하라는 글들이 꽤 나옵니다. sscanf 의 경우에는 fsscanf 를 사용하시면 됩니다.

저는 scanf 에 된통 당한 적이 있어, strsep 또는 strtok_r 같은 토큰 함수로 파싱을 해서 많이 사용 합니다.

Stephen Kyoungwon Kim@Google의 이미지

글쓴이: Stephen Kyoungw... / 작성시간: 토, 2020/06/13 - 6:00오전

라인을 읽었으면 ' '를 delimiter로 라인을 tokenize 하신 다음, 첫 토큰 외의 모든 토큰은 정수/실수로 변환하면 됩니다.
https://www.tutorialspoint.com/c_standard_library/c_function_strtok.htm

그리고 atoi, atof를 찾아보세요.

라인 읽고 (버퍼 마지막에 남을 수도 있는 newline을 주의하시고), strtok로 토크나이징 하면서, 첫 토큰이 아니면 atoi로 변환하면 됩니다.

댓글 달기

텍스트 포맷에 대한 자세한 정보

Filtered HTML

  • 텍스트에 BBCode 태그를 사용할 수 있습니다. URL은 자동으로 링크 됩니다.
  • 사용할 수 있는 HTML 태그: <p><div><span><br><a><em><strong><del><ins><b><i><u><s><pre><code><cite><blockquote><ul><ol><li><dl><dt><dd><table><tr><td><th><thead><tbody><h1><h2><h3><h4><h5><h6><img><embed><object><param><hr>
  • 다음 태그를 이용하여 소스 코드 구문 강조를 할 수 있습니다: <code>, <blockcode>, <apache>, <applescript>, <autoconf>, <awk>, <bash>, <c>, <cpp>, <css>, <diff>, <drupal5>, <drupal6>, <gdb>, <html>, <html5>, <java>, <javascript>, <ldif>, <lua>, <make>, <mysql>, <perl>, <perl6>, <php>, <pgsql>, <proftpd>, <python>, <reg>, <spec>, <ruby>. 지원하는 태그 형식: <foo>, [foo].
  • web 주소와/이메일 주소를 클릭할 수 있는 링크로 자동으로 바꿉니다.

BBCode

  • 텍스트에 BBCode 태그를 사용할 수 있습니다. URL은 자동으로 링크 됩니다.
  • 다음 태그를 이용하여 소스 코드 구문 강조를 할 수 있습니다: <code>, <blockcode>, <apache>, <applescript>, <autoconf>, <awk>, <bash>, <c>, <cpp>, <css>, <diff>, <drupal5>, <drupal6>, <gdb>, <html>, <html5>, <java>, <javascript>, <ldif>, <lua>, <make>, <mysql>, <perl>, <perl6>, <php>, <pgsql>, <proftpd>, <python>, <reg>, <spec>, <ruby>. 지원하는 태그 형식: <foo>, [foo].
  • 사용할 수 있는 HTML 태그: <p><div><span><br><a><em><strong><del><ins><b><i><u><s><pre><code><cite><blockquote><ul><ol><li><dl><dt><dd><table><tr><td><th><thead><tbody><h1><h2><h3><h4><h5><h6><img><embed><object><param>
  • web 주소와/이메일 주소를 클릭할 수 있는 링크로 자동으로 바꿉니다.

Textile

  • 다음 태그를 이용하여 소스 코드 구문 강조를 할 수 있습니다: <code>, <blockcode>, <apache>, <applescript>, <autoconf>, <awk>, <bash>, <c>, <cpp>, <css>, <diff>, <drupal5>, <drupal6>, <gdb>, <html>, <html5>, <java>, <javascript>, <ldif>, <lua>, <make>, <mysql>, <perl>, <perl6>, <php>, <pgsql>, <proftpd>, <python>, <reg>, <spec>, <ruby>. 지원하는 태그 형식: <foo>, [foo].
  • You can use Textile markup to format text.
  • 사용할 수 있는 HTML 태그: <p><div><span><br><a><em><strong><del><ins><b><i><u><s><pre><code><cite><blockquote><ul><ol><li><dl><dt><dd><table><tr><td><th><thead><tbody><h1><h2><h3><h4><h5><h6><img><embed><object><param><hr>

Markdown

  • 다음 태그를 이용하여 소스 코드 구문 강조를 할 수 있습니다: <code>, <blockcode>, <apache>, <applescript>, <autoconf>, <awk>, <bash>, <c>, <cpp>, <css>, <diff>, <drupal5>, <drupal6>, <gdb>, <html>, <html5>, <java>, <javascript>, <ldif>, <lua>, <make>, <mysql>, <perl>, <perl6>, <php>, <pgsql>, <proftpd>, <python>, <reg>, <spec>, <ruby>. 지원하는 태그 형식: <foo>, [foo].
  • Quick Tips:
    • Two or more spaces at a line's end = Line break
    • Double returns = Paragraph
    • *Single asterisks* or _single underscores_ = Emphasis
    • **Double** or __double__ = Strong
    • This is [a link](http://the.link.example.com "The optional title text")
    For complete details on the Markdown syntax, see the Markdown documentation and Markdown Extra documentation for tables, footnotes, and more.
  • web 주소와/이메일 주소를 클릭할 수 있는 링크로 자동으로 바꿉니다.
  • 사용할 수 있는 HTML 태그: <p><div><span><br><a><em><strong><del><ins><b><i><u><s><pre><code><cite><blockquote><ul><ol><li><dl><dt><dd><table><tr><td><th><thead><tbody><h1><h2><h3><h4><h5><h6><img><embed><object><param><hr>

Plain text

  • HTML 태그를 사용할 수 없습니다.
  • web 주소와/이메일 주소를 클릭할 수 있는 링크로 자동으로 바꿉니다.
  • 줄과 단락은 자동으로 분리됩니다.
댓글 첨부 파일
이 댓글에 이미지나 파일을 업로드 합니다.
파일 크기는 8 MB보다 작아야 합니다.
허용할 파일 형식: txt pdf doc xls gif jpg jpeg mp3 png rar zip.
CAPTCHA
이것은 자동으로 스팸을 올리는 것을 막기 위해서 제공됩니다.