300x250
반응형

간단하게 파일에 내용을 가져와서 사용을 해야 할 일이 있어서 테스트겸 만들어 보았다.

C++을 잘 사용 할 줄몰라서 C/C++를 혼용하여 사용 하였으면 최종 데이터 저장 컨테이너는

map으로 사용 하였고, 멀티맵을 하지 않은 이유는 겹치는 key는 발생 할 일이 없을 것으로 판단 하였다.

 

테스트 파일 원본.
//YAS.
DEMO 3

//Tuen.
TONVOLUME 22

//Max T
MAXVOLUME 45

//Reset Timer
RESETTIMER 0

//KEY PATEERN
KEY 2

//USBPLAY
//USBREPEAT ALL
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cstring>
#include <map>
#include <vector>

using namespace std;

typedef struct {
    string key;
    string value;
}USB_DATA;

map<string, string> mapData;

int TrimRight(char *p)
{
    int len = strlen(p);

    if(len <= 0)
    {
        p[0] = 0;
        return 0;
    }
    else
    {
        len--;
        while(len)
        {
            if((unsigned char)p[len] > ' ') break;

            p[len] = 0;
            len--;
        }
    }

    return strlen(p);
}

bool parsingData(char* str)
{
    int cnt = 1;
    char *tok = NULL;

    USB_DATA t_data;

    if(str != NULL)
    {
        if(str[0] == '/' && str[1] == '/')
        {
            return false;
        }
        TrimRight(str);

        tok = strtok(str, " ");
        if(tok == NULL)
        {
            return false;
        }

        t_data.key = tok;

        tok = strtok(NULL, " ");
        if(tok == NULL)
        {
            return false;
        }

        t_data.value = tok;
    }

    //printf("struct data[%s][%s]\n",t_data.key.c_str(), t_data.value.c_str());

    mapData.insert(make_pair(t_data.key, t_data.value));

    return true;
}

bool getDataFile()
{
    FILE    *fp = fopen("demo_mode3.txt","r");
    int     len = 0, total = 0;
    char    buff[64] = {0,};

    if(fp == NULL)
    {
        printf("file open fail\n");
        return false;
    }

    char *p;
    while(!feof(fp))
    {
        p = fgets(buff, sizeof(buff), fp);
        if(p != NULL)
            parsingData(p);
    }

    fclose(fp);

    return true;
}

void print_map()
{
    for(auto itr = mapData.begin(); itr != mapData.end(); ++itr)
    {
        cout << "key : " << itr->first << ", " << "value : " << itr->second << endl;
    }
}

int main(void)
{
    printf("Program parsing\n");

    getDataFile();

    print_map();

    return 1;
}

 

결과 값. 

 

위의 결과에서 주석은 제거, 빈공간 제거등을 하여서 데이터만 가져오도록 하였고,

데이터 구분은. ' '(스페이스)로 처리 되어있다.

728x90
300x250
반응형

간혹 간단한 socket 테스트 할 경우 문자열을 snprint가 아닌 직접 입력하여 보낼 때 공백이 들어가면 해당 공백은 포함 안되고 전체 문자열이 붙혀서 넘어 가는 경우가 발생 할 수 있다.

 

C++를 공부 하면서  C++기준으로. 우리가 입력을 할 때는 cin으로 처리를 하는 cin은 space가 들어가면 해당 문자열을 종료 시킨다고 판단하여 공백이 제거 되버린다.

 

그럴 때 cin.getline(a,10);으로 해주면 공백이 포함 된다.

 

간단한 예제

 

1. cin을 할 경우 

char sbuf[1024];

cin >> sbuf; 했을 경우. 위에 처럼 보내고. 받는 곳에서는 다음과 같은 결과가 나온다.

위의 처럼 결과가 나오는데 입력시 my test라고 공백이 포함되게 보냈지만, 이미 공백이 들어가서 해당 첫 라인은 끝난다고 가정하여 mytest라고 보내게 된 경우다.

 

2. cin.getline() 을 할경우

 

char sbuf[1024];

cin.getline(sbuf, 1024);

 

위 코드로 처리 할 경우 위의 결과 값으로 나온다.

공백도 문자열로 처리가 된다.

728x90
300x250
반응형

대학생때 이후로는 C++를 접할 일이 없었습니다.

그래서 공부를 해볼 겸 간단한 로또 프로그램을 만들어 보았습니다.

목표는. 간단한 class 및 STL를 사용 하는 거고 추 후에 서버 프로그램을 c++로 제작 해볼 예정입니다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
#include <iostream>
#include <vector>
#include <random>
 
#define LOTTO_MAX 7
 
using namespace std;
 
class Lottery {
private:
    int lotto_num;
    int lotto_idx;
    int* check_list;
    vector<int> user_vec;
    vector<int> machine_vec;
 
public:
    Lottery() {
        lotto_num = 0;
        lotto_idx = 0;
 
        check_list = new int[LOTTO_MAX];
        for (int i = 0; i < LOTTO_MAX; i++) {
            check_list[i] = 0;
        }
 
        user_vec.reserve(LOTTO_MAX - 1);
        machine_vec.reserve(LOTTO_MAX);
    }
 
    bool duplicate_check(int num, vector<int>& user_vec);
    void printLottoNumber(vector<int>& user_vec);
    void Lotto_Input(vector<int>& user_vec);
    void UserInterFace_Init();
 
    //로또 번호 생성, 본번호 + 보너스 번호
    void CreateLotteryNumber(/*vector<int>& machine*/);
    int BonusLotteryNumber(vector<int>& machine);
 
    //입력한 번호와 생성된 번호를 비교하여 순위를 매긴다.
    int ret_ranking(vector<int>& machine, vector<int>& user_vec);
 
    ~Lottery() {
        if (check_list)
            delete[] check_list;
    }
};
 
int Lottery::ret_ranking(vector<int>& machine, vector<int>& user_vec) {
    int rank = 0;
    int match = 0;
    int bonus = 0;
 
    for (int i = 0; i < machine.size(); i++) {
        for (int j = 0; j < user_vec.size(); j++) {
            if (machine[i] == user_vec[j]) {
                if (i == (machine.size() - 1)) {
                    bonus = 1;
                }
                match++;            
            }                
        }        
    }
 
    cout << "math = " << match << endl;
    cout << "bonus = " << bonus << endl;
 
    switch (match) {
    case 3: rank = 5break;
    case 4: rank = 4break;
    case 5: rank = 3break;
    case 6
        if (bonus == 0)    rank = 1;         
        else rank = 2
        
        break;
    default: rank = 0break;
    }
 
    return rank;
}
 
int Lottery::BonusLotteryNumber(vector<int>& vec)
{
    int rand_number;
    int chk_flg = 0;
 
    random_device rand;        //시드 값을 얻기 위한 random_device 생성.
    mt19937_64 gen(rand());    //random_device를 통해 난수 생성 엔진을 초기화.    (메르센 트위스터 알고리즘 사용)
 
    uniform_int_distribution<int> dis(145); //1 ~ 45까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의 
 
    rand_number = dis(gen);
 
    //새롭게 발생된 보너스번호를 생성된 1등 번호와 충첩되는지 체크 한다.
    //1등번호와 충첩되면 다시 보너스 번호를 생성 한다.
    for (int i = 0; i < vec.size(); i++) {
        if (rand_number == vec[i])
            BonusLotteryNumber(vec);    
    }
 
    return rand_number; // 생성된 보너스번호 리턴.
}
 
void Lottery::CreateLotteryNumber(/*vector<int>& vec*/)
{
    //랜덤으로 1 ~ 45의 중복되지 않는 숫자를 생성 한다.
    //보너스 번호는 별도로 생성. 1 ~ 45에서 중복되지 않는 값으로 생성 한다. 
 
    int bonus_number = 0;
    int create_lottery_num = 0;
    random_device rand;        //시드 값을 얻기 위한 random_device 생성.
    mt19937_64 gen(rand());    //random_device를 통해 난수 생성 엔진을 초기화.    (메르센 트위스터 알고리즘 사용)
    
    uniform_int_distribution<int> dis(145); //1 ~ 45까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의 
    
    for (int i = 0; i < LOTTO_MAX - 1; i++) {
        create_lottery_num = dis(gen);
        
        //중복 검사.
        for (int j = 0; j < machine_vec.size(); j++) {
            if (create_lottery_num == machine_vec[j])
                CreateLotteryNumber();
        }
        machine_vec.push_back(create_lottery_num);
    }
 
    bonus_number = BonusLotteryNumber(machine_vec);
 
    machine_vec.push_back(bonus_number);
 
    cout << "생성된 1등번호 + 보너스번호 : ";
    for (int i = 0; i < machine_vec.size(); i++) {
        cout << "[" << machine_vec[i] << "] ";
    }
 
    cout << endl;
 
    int rank;
    rank = ret_ranking(machine_vec, user_vec);
 
    cout << "당신은 " << rank << "입니다." << endl;
}
 
bool check_number(int num)
{
    if (num > 45 || num < 1) {
        cout << "잘못된 숫자를 입력 하셨습니다. 다시 입력 하세요." << endl;
 
        return false;
    }
    else
        return true;
}
 
//중복 체크. 처음에 체크되는 부분은 true 이후 중복이 발견되면 fail
bool Lottery::duplicate_check(int input, vector<int>& vec)
{
    int check_cnt = 0;
 
    cout << "input : " << input << endl;
    cout << "vector size : " << vec.size() << endl;
 
    for (int i = 0; i < vec.size(); i++){
        cout << "vec : " << vec[i] << endl;
        if (input == vec[i]) {            
            cout << "데이터 중복." << endl;
            return false;            
        }
    }
 
    return true;
}
 
void Lottery::Lotto_Input(vector<int>& vec)
{
    cout << "번호를 입력하세요." << endl;    
 
    while (1) {        
        cout << lotto_idx +1 << "번째 번호 입력 : ";
        cin >> lotto_num;
 
        if (check_number(lotto_num)){
            if (duplicate_check(lotto_num, vec)) {
                check_list[lotto_idx] = 1;
                vec.push_back(lotto_num);
                lotto_idx++;
            }
        }
        else Lotto_Input(vec);        
        
        if (lotto_idx > 5break;
    }
}
 
void Lottery::UserInterFace_Init()
{
    cout << "안녕하세요. 로또 테스트 프로그램에 오신 것을 환영 합니다." << endl;
    cout << "총 6개의 번호를 입력하세요 1 ~ 45 입니다." << endl;
    cout << "총 6개를 맞추면 1등입니다." << endl;
    cout << "총 5개를 맞추고 보너스번호 1개를 맞추면 2등입니다. ( 억울 하겠네요... ㅎㅎ ) " << endl;
    cout << "총 5개를 맞추면 3등 입니다. " << endl;
    cout << "총 4개를 맞추면 4등 입니다. " << endl;
    cout << "총 3개를 맞추면 3등 입니다. " << endl;
    cout << endl;
 
    Lotto_Input(user_vec);
 
    printLottoNumber(user_vec);
 
    CreateLotteryNumber();
}
 
void Lottery::printLottoNumber(vector<int>& vec)
{
    cout << "Lotto Number :";
 
    for (int i = 0; i < vec.size(); i++) {
        cout <<  "[" << vec[i] << "] ";
    }    
    
    cout << endl;
}
 
int main(int agrc, char** argv)
{
    Lottery lot;
 
    lot.UserInterFace_Init();
    
    return 0;
}
cs
728x90

+ Recent posts