해보고나면 별거아니다

//////////////////////////////////////////////////////////////////

#include <iostream>

#include <fstream>

#include <cstring>

#include <string>

#include <stdlib.h>

#pragma warning ( disable : 4996 )

using namespace std;

int hashGetIndex(char key[]);

void makeHash(char buffer[100]);

void searchWord();

//영어 단어 구조체

typedef struct english {

char word[50]; //단어

char mean[100]; //뜻

struct english* chain = NULL; //충돌을 대비한 체인 포인터

}ENGLISH;

//해시 탐색을 위한 포인터 배열 선언

ENGLISH* englishArray[1200] = {'\0'};

void main() {

int i = 0, index = 0;

ifstream file;

char buffer[100];

file.open("english1200.txt");

if (!file.is_open()) {

cout << "파일 열기 실패!" << endl;

}

while (!file.eof()) {

memset(buffer, 0, sizeof(buffer));

file.getline(buffer, 100);

makeHash(buffer);

}

searchWord();

//해당 인덱스에 저장 상태 체크

/*

ENGLISH *tt = englishArray[1069];

while (tt != NULL) {

cout << tt->word << endl;

cout << tt->word[7] << endl;

tt = tt->chain;

}

*/

file.close();

}

//해시 만들기

void makeHash(char buffer[100]) {

char* token = NULL;

char tk[] = "\t\n";

int index = 0;

ENGLISH *tmp = NULL;

ENGLISH *current = NULL;

tmp = (ENGLISH *)malloc(sizeof(ENGLISH));

memset(tmp, 0, sizeof(ENGLISH));

token = strtok(buffer, tk);

strcat(tmp->word, token);

//cout << tmp->word << "\n\n";

token = strtok(NULL, tk);

strcat(tmp->mean, token);

//cout << tmp->mean << endl;

tmp->chain = NULL;

index = hashGetIndex(tmp->word);

if (englishArray[index] == NULL) {

englishArray[index] = tmp;

}

else {

current = englishArray[index];

while (current->chain != NULL) {

current = current->chain;

}

current->chain = tmp;

}

}

//해시 알고리즘

int hashGetIndex(char key[]) {

int hashKey = 0;

int word1 = key[0]; //첫번째 글자의 아스키코드

int word2 = key[strlen(key) - 1]; //끝글자의 아스키코드

int word3 = strlen(key); //문자열의 길이

int word4 = key[strlen(key) / 2]; //가운데 글자의 아스키코드

//hashKey = ((word1 * 107) + (word2 * 31) + word3) % 1200; //556

//hashKey = ((word1*17) + (word2 * 31) + word3) % 1200;   //514

//hashKey = (((word1 + word2) * word3) * 17) % 1199; //312

//hashKey = (word1 + word2 * word3 * word4) % 1199; //695

//hashKey = (word1 * word2 * word3 * word4) % 1199; //537

//hashKey = (word1 * word2 + word3 - word4) % 1199; //628

//hashKey = (word1 * word2 / word3 - word4) % 1200; //698

//hashKey = (word1 * word2 / word3 * word4) % 1200; //540

//hashKey = (word1 * word2 / word3 * word4) % 1199; //648

//hashKey = (word1 * word2 / word3 - word4) % 1199; //693

//hashKey = (word1 * word2 * word3 * word4) % 1200; //275

//hashKey = ((word1 * word4) + word3 + word2) % 1200; //664

//hashKey = ((word1 * word4) / word3 + word2) % 1200; //705

//hashKey = ((word1 * word4) / word3 * word2) % 1200; //538

hashKey = ((word1 * word4) / word3 + word2) % 1200; //705

//해시키 분포도 보기

cout << hashKey << endl;

return hashKey;

}

//단어 검색 함수

void searchWord() {

char input[50] = {'\0'};

int index = 0;

ENGLISH *tmp = NULL;

while (1) {

cout << "\n\n검색할 단어를 입력해 주세요 (종료: exit) : ";

fflush(stdin);

cin.getline(input, 50);

if (strcmp(input, "exit") != 0) {

index = hashGetIndex(input);

if (englishArray[index] != NULL) {

tmp = englishArray[index];

while ((strcmp(tmp->word, input) != 0) && (tmp->chain != NULL)) {

tmp = tmp->chain;

}

if ((tmp->chain == NULL) && (strcmp(tmp->word, input) != 0)) {

cout << "일치하는 단어가 없습니다" << endl;

} else {

cout << "단어 = " << tmp->word << endl;

cout << "뜻 = " << tmp->mean << endl;

}

} else {

cout << "일치하는 단어가 없습니다" << endl;

}

} else {

cout << "종료합니다..." << endl;

exit(1);

}

}

}

data.txt

report2.cpp

//////////////////////////////////////////////////////////////////////////////////////

#include <iostream>

#include <fstream>

#include<cstdlib>

#include <cstring>

/*

Microsoft visual studio 2015 에서 실행했습니다~~

*/

#pragma warning ( disable : 4996 )

#define MAX_MEMORY 3

using namespace std;

void saveMemory(int data);

bool checkFullMemory();

bool checkFrozen();

void makeRun();

void printMemory();

void Selectminimum();

void writeRunFile();

void lastDataClear();

void printRun();

int memory[MAX_MEMORY];

bool written[MAX_MEMORY];

bool frozen[MAX_MEMORY];

int lastData = 0;

int cnt_partition = 0;

int minIndex;

void main() {

ifstream file;

int i = 0;

int buf = 0;

file.open("data.txt");

if (!file.is_open()) {

cout << "파일 열기 실패!" << endl;

}

memset(memory, 0, MAX_MEMORY);

memset(written, false, MAX_MEMORY);

memset(frozen, false, MAX_MEMORY);

while (!file.eof()) {

file >> buf;

cout << "Input data = " << buf << endl;

saveMemory(buf); //메모리가 비어있으면 data를 메모리에 저장

if (!checkFullMemory()) {

continue;

} 

makeRun();

//printRun();

}

file.close();

for (i = 0; i < MAX_MEMORY - 1; i++) {

lastDataClear();

}

printRun();

}

//비어있는 메모리에 입력값 저장

void saveMemory(int data) {

int i = 0;

for (i = 0; i < MAX_MEMORY; i++) {

if (written[i] == false) {

memory[i] = data;

written[i] = true;

break;

}

}

}

//메모리 상태 체크

bool checkFullMemory() {

//메모리에 데이터가 다 들어가 있으면 true, 없으면 false

int i = 0;

int cnt = 0;

for (i = 0; i < MAX_MEMORY; i++) {

if (written[i] == true) {

cnt++;

}

}

if (cnt != MAX_MEMORY) {

return false;

}

else {

return true;

}

}

//빙결상태 체크

bool checkFrozen() {

// 전체 빙결상태이면 true, 아니면 false

int i = 0;

int cnt = 0;

for (i = 0; i < MAX_MEMORY; i++) {

if (frozen[i] == true) {

cnt++;

}

}

if (cnt != MAX_MEMORY) {

return false;

}

else {

return true;

}

}

//런만들기

void makeRun() {

int i;

Selectminimum();

if (checkFrozen()) {

cout << "!!!!!!!!!!!!!!전체 빙결(분할 완료)!!!!!!!!!!!!!!!!!" << endl;

cnt_partition++;

lastData = 0;

for (i = 0; i < MAX_MEMORY; i++) {

frozen[i] = false;

}

Selectminimum();

}

writeRunFile();

}

//조건에 맞는 미니멈값 찾기

void Selectminimum() {

int i=0;

minIndex = 0;

//프로즌상태가 아니고, 라스트데이터보다 값이 크며, 현재 비교대상 메모리보다 작을 때 mindIndex 교체

for (i = 0; i < MAX_MEMORY; i++) {

if ((memory[i] < lastData)) {

frozen[i] = true;

}

}

//비교 대상 찾기 (프로즌 상태가 아닌 수)

i = 0;

while(i < MAX_MEMORY) {

if (frozen[i] != true) {

minIndex = i;

break;

}

i++;

}

//비교하면서 조건에 맞는 인덱스 찾기

for (i=0; i < MAX_MEMORY; i++) {

if ((frozen[i] == false) && (memory[i] > lastData) && (memory[minIndex] >= memory[i])) {

minIndex = i;

}

}

printMemory();

}

//파일에 런 쓰기입력

void writeRunFile() {

char file_name[20];

ofstream outfile;

//파일이름 설정

itoa(cnt_partition + 1, file_name, 10);

strcat(file_name, "_partition.txt");

outfile.open(file_name, ios::app);

//outfile << memory[minIndex] << " ";

outfile << " " << memory[minIndex];

lastData = memory[minIndex];

outfile.close();

written[minIndex] = false;

}

//현재 메모리에 들어가있는 값 출력

void printMemory() {

int i;

cout << "\n//////////////////////////////////////////////" << endl;

for (i = 0; i < MAX_MEMORY; i++) {

if (frozen[i] == true) {

cout << "(";

}

cout << memory[i];

if (frozen[i] == true) {

cout << ") ";

} else {

cout << " ";

}

}

cout << "\n//////////////////////////////////////////////" << endl;

}

//런파일들을 화면에 출력

void printRun() {

int i;

ifstream file;

int buf;

char file_name[20];

cout << "\n----------------------------------------------" << endl;

for (i = 0; i <= cnt_partition; i++) {

cout << i + 1 << "번 분할////" << endl;

memset(file_name, 0, sizeof(file_name));

itoa(i + 1, file_name, 10);

strcat(file_name, "_partition.txt");

file.open(file_name);

while (!file.eof()) {

file >> buf;

cout << buf << " ";

}

file.close();

cout << "\n////////////////////////////////////////" << endl;

}

cout << "\n----------------------------------------------" << endl;

}

//마지막 남은 데이터 처리

void lastDataClear() {

int i = 0;

while (i < MAX_MEMORY) {

if (written[i] == true) {

minIndex = i;

break;

}

i++;

}

for (i = 0; i < MAX_MEMORY; i++) {

if ((written[i] == true) && (memory[minIndex] > memory[i])) {

minIndex = i;

}

}

writeRunFile();

}

마스터 파일 내용 보여주기

//////////////////////////////////////////////////////////////////////////

#include <iostream>

#include <fstream>

#include <cstring>

#include <stdlib.h>

#include <vector>

#include <algorithm>

/*

Microsoft visual studio 2015 에서 실행했습니다~~

*/

#pragma warning ( disable : 4996 )

using namespace std;

// 과목 데이터 타입 선언 

typedef struct course_type {

char dept[10]; //부서

char course_name[20];//과목 이름

char prof_id[7]; //교수 id

int credit; //학점

}COURSE;

// 학생 레코드 구조 선언

typedef struct student {

int id; //학번

char name[20]; //이름

char address[50]; //주소

int no_of_courses; //과목의 갯수

course_type course[2]; // 한 학생이 최대 2강좌 수강 가능

}STUDENT;

typedef struct transaction {

STUDENT student;

char mode; // C: 갱신, D: 삭제, I: 추가 

}TRANSACTION;

int print_menu(); //메뉴 출력

void init_file(); //초기 마스터 파일 읽기, 예제 트랜잭션 생성

void run_trans(); //트랜잭션 실행

void trans_insert(STUDENT data); //트랜잭션 삽입 기능

void trans_delete(STUDENT data); //트랜잭션 삭제 기능

void trans_correct(STUDENT data); //트랜잭션 수정 기능

void make_trans(char mode, STUDENT data); //트랜잭션 파일 생성

void write_file(); //마스터 파일에 저장 쓰기

void report(); //마스터 파일 출력

void write_trans(); //생성할 트랜잭션 데이터 입력

void remove_trans(); //기존 생성한 트랜잭션 파일들 삭제 

bool id_compare(STUDENT a, STUDENT b); //정렬을 위한 비교 함수

vector<STUDENT> students;

int trans_cnt = 0;

void main() {

int menu = 0;

init_file();

while (1) {

menu = print_menu();

switch (menu)

{

case 1 :

report();

break;

case 2 :

write_trans();

break;

case 3:

run_trans();

break;

case 4:

remove_trans();

break;

default:

cout << "종료합니다...." << endl;

return;

break;

}

}

}

//메뉴 출력

int print_menu() {

int num = 0;

while (1) {

cout << "/////////////////////////////////////////////////////////////////" << endl;

cout << "-------------------------------------------------------------------" << endl;

cout << "|  1. 마스터 파일 보기   2. 새로운 트랜잭션 생성   3.트랜잭션 실행|" << endl;

cout << "|  4.기존 트랜잭션 삭제   5.종료                                  |" << endl;

cout << "-------------------------------------------------------------------" << endl;

cout << "/////////////////////////////////////////////////////////////////" << endl;

cout << "메뉴를 입력해 주세요 : ";

cin >> num;

if (num == 1 || num == 2 || num == 3 || num == 4 || num == 5) {

break;

}

else {

cout << "다시 입력해주세요." << endl;

}

}

return num;

}

//마스터파일 내용 출력

void report() {

int i = 0;

for (i = 0; i < students.size(); i++) {

cout << i + 1 << "번째 학생//////////////////" << endl;

cout << "학번: " << students[i].id << endl;

cout << "이름: " << students[i].name << endl;

cout << "주소: " << students[i].address << endl;

cout << "수강 강좌 수: " << students[i].no_of_courses << endl;

cout << "--------------------------------------" << endl;

if (students[i].no_of_courses >= 1) {

cout << "1번과목 종류: " << students[i].course[0].dept << endl;

cout << "1번과목 이름: " << students[i].course[0].course_name << endl;

cout << "1번과목 교수번호: " << students[i].course[0].prof_id << endl;

cout << "1번과목 학점: " << students[i].course[0].credit << endl;

}

if (students[i].no_of_courses == 2) {

cout << "--------------------------------------" << endl;

cout << "2번과목 종류: " << students[i].course[1].dept << endl;

cout << "2번과목 이름: " << students[i].course[1].course_name << endl;

cout << "2번과목 교수번호: " << students[i].course[1].prof_id << endl;

cout << "2번과목 학점: " << students[i].course[1].credit << endl;

}

cout << "/////////////////////////////////////////\n\n" << endl;

}

}

//파일 준비, 생성

void init_file() {

int i = 0, j=0;

ifstream file;

file.open("student_list.txt");

if (!file.is_open()) {

cout << "파일 열기 실패!" << endl;

}

//마스터 파일 읽기

while (!file.eof()) {

STUDENT tmp_data;

memset(&tmp_data, 0, sizeof(tmp_data));

file >> tmp_data.id;

file >> tmp_data.name;

file >> tmp_data.address;

file >> tmp_data.no_of_courses;

if (tmp_data.no_of_courses >= 1) {

file >> tmp_data.course[0].dept;

file >> tmp_data.course[0].course_name;

file >> tmp_data.course[0].prof_id;

file >> tmp_data.course[0].credit;

}

if (tmp_data.no_of_courses == 2) {

file >> tmp_data.course[1].dept;

file >> tmp_data.course[1].course_name;

file >> tmp_data.course[1].prof_id;

file >> tmp_data.course[1].credit;

}

students.push_back(tmp_data);

i++;

}

file.close();

////////////////////////트랜잭션 작성 (임시 6개 생성)

STUDENT temp_data_1;

memset(&temp_data_1, 0, sizeof(temp_data_1));

temp_data_1.id = 35;

strcpy(temp_data_1.name, "김영희");

strcpy(temp_data_1.address, "전라남도_전라시_중앙동");

temp_data_1.no_of_courses = 1;

strcpy(temp_data_1.course[0].dept, "교양");

strcpy(temp_data_1.course[0].course_name, "성문화와심리");

strcpy(temp_data_1.course[0].prof_id, "7777");

temp_data_1.course[0].credit = 2;

make_trans('I', temp_data_1);

make_trans('C', temp_data_1);

make_trans('D', temp_data_1);

/////////////////////////////////////

STUDENT temp_data_2;

memset(&temp_data_2, 0, sizeof(temp_data_2));

temp_data_2.id = 20;

strcpy(temp_data_2.name, "장수왕");

strcpy(temp_data_2.address, "경상남도_고성시_고룡동");

temp_data_2.no_of_courses = 2;

strcpy(temp_data_2.course[0].dept, "교양");

strcpy(temp_data_2.course[0].course_name, "성문화와심리");

strcpy(temp_data_2.course[0].prof_id, "7777");

temp_data_2.course[0].credit = 2;

strcpy(temp_data_2.course[1].dept, "전공");

strcpy(temp_data_2.course[1].course_name, "경영학개론");

strcpy(temp_data_2.course[1].prof_id, "121212");

temp_data_2.course[1].credit = 3;

make_trans('I', temp_data_2);

make_trans('C', temp_data_2);

make_trans('D', temp_data_2);

}

void remove_trans() {

char file_name[20];

//기존 트랜잭션파일 삭제

for (int i = 0; i < trans_cnt; i++) {

memset(file_name, 0, sizeof(file_name));

itoa(i + 1, file_name, 10);

strcat(file_name, "_trans.txt");

remove(file_name);

}

trans_cnt = 0;

}

//트랜잭션 데이터 입력.

void write_trans() {

TRANSACTION trs;

memset(&trs, 0, sizeof(trs));

cout << "//////////////////////////////////////////" << endl;

cout << "트랜잭션을 추가합니다..." << endl;

cout << "모드를 입력해주세요 (I : 삽입, C : 수정, D : 삭제) = ";

cin >> trs.mode;

cout << "학번을 입력하세요 = ";

cin >> trs.student.id;

fflush(stdin);

if (trs.mode == 'D') {

make_trans(trs.mode, trs.student);

return;

}

cout << "이름을 입력하세요 = ";

cin >> trs.student.name;

cout << "주소를 입력하세요(띄어쓰기는 _언더바로 해주세요) = ";

cin >> trs.student.address;

cout << "수강 갯수를 입력하세요(최대 2개) = ";

cin >> trs.student.no_of_courses;

if (trs.student.no_of_courses >= 1) {

cout << "과목1의 종류를 입력하세요 = ";

cin >> trs.student.course[0].dept;

cout << "과목1의 이름을 입력하세요 = ";

cin >> trs.student.course[0].course_name;

cout << "과목1의 교수id를 입력하세요 = ";

cin >> trs.student.course[0].prof_id;

cout << "과목1의 학점을 입력하세요 = ";

cin >> trs.student.course[0].credit;

} 

if (trs.student.no_of_courses == 2) {

cout << "과목2의 종류를 입력하세요 = ";

cin >> trs.student.course[1].dept;

cout << "과목2의 이름을 입력하세요 = ";

cin >> trs.student.course[1].course_name;

cout << "과목2의 교수id를 입력하세요 = ";

cin >> trs.student.course[1].prof_id;

cout << "과목2의 학점을 입력하세요 = ";

cin >> trs.student.course[1].credit;

}

make_trans(trs.mode, trs.student);

}

//트랜잭션 파일 생성

void make_trans(char mode, STUDENT data) {

char file_name[20];

ofstream outfile;

//파일이름 설정

itoa(trans_cnt+1, file_name, 10);

strcat(file_name, "_trans.txt");

//파일 생성

outfile.open(file_name, ios::trunc);

outfile << mode << '\t';

outfile << data.id << '\t';

outfile << data.name << '\t';

outfile << data.address << '\t';

outfile << data.no_of_courses;

if (data.no_of_courses >= 1) {

outfile << '\t' << data.course[0].dept << '\t';

outfile << data.course[0].course_name << '\t';

outfile << data.course[0].prof_id << '\t';

outfile << data.course[0].credit;

}

if (data.no_of_courses == 2) {

outfile << '\t' << data.course[1].dept << '\t';

outfile << data.course[1].course_name << '\t';

outfile << data.course[1].prof_id << '\t';

outfile << data.course[1].credit;

}

outfile.close();

trans_cnt++;

}

//트랜잭션 실행

void run_trans() {

int i = 0;

char file_name[20];

while (i < trans_cnt) {

ifstream file;

memset(file_name, 0, sizeof(file_name));

itoa(i + 1, file_name, 10);

strcat(file_name, "_trans.txt");

file.open(file_name);

if (!file.is_open()) {

cout << "트랜잭션 파일 열기 실패!" << endl;

}

cout << "트랜잭션 파일 : " << file_name;

while (!file.eof()) {

TRANSACTION tmp_data;

file >> tmp_data.mode;

file >> tmp_data.student.id;

file >> tmp_data.student.name;

file >> tmp_data.student.address;

file >> tmp_data.student.no_of_courses;

if (tmp_data.student.no_of_courses >= 1) {

file >> tmp_data.student.course[0].dept;

file >> tmp_data.student.course[0].course_name;

file >> tmp_data.student.course[0].prof_id;

file >> tmp_data.student.course[0].credit;

}

if (tmp_data.student.no_of_courses == 2) {

file >> tmp_data.student.course[1].dept;

file >> tmp_data.student.course[1].course_name;

file >> tmp_data.student.course[1].prof_id;

file >> tmp_data.student.course[1].credit;

}

if (tmp_data.mode == 'I') {

trans_insert(tmp_data.student);

}

else if (tmp_data.mode == 'D') {

trans_delete(tmp_data.student);

}

else if (tmp_data.mode == 'C') {

trans_correct(tmp_data.student);

}

}

file.close();

i++;

}

sort(students.begin(), students.end(), id_compare);

write_file();

}

//트랜잭션 추가

void trans_insert(STUDENT data) {

int i = 0;

int cnt = 0;

for (i = 0; i < students.size(); i++) {

if (students[i].id == data.id) {

cnt++;

}

}

if (cnt == 0) {

students.push_back(data);

cout << "[INSERT SUCCESS]" << endl;

} else {

cout << "[INSERT FAIL] 이미존재하는 학생입니다." << endl;

}

}

//트랜잭션 삭제

void trans_delete(STUDENT data) {

int i = 0;

int flag = 0;

for (i = 0; i < students.size(); i++) {

if (students[i].id == data.id) {

students.erase(students.begin() + i);

flag = 1;

break;

}

}

if (flag == 1) {

cout << "[DELETE SUCCESS]" << endl;

} else {

cout << "[DELETE FAIL] 존재하지 않는 학생입니다." << endl;

}

}

//트랜잭션 수정

void trans_correct(STUDENT data) {

int i = 0;

int flag = 0;

for (i = 0; i < students.size(); i++) {

if (students[i].id == data.id) {

students.erase(students.begin() + i);

students.push_back(data);

flag = 1;

break;

}

}

if (flag == 1) {

cout << "[CORRECT SUCCESS]" << endl;

}

else {

cout << "[CORRECT FAIL] 존재하지 않는 학생입니다." << endl;

}

}

//마스터파일에 저장

void write_file() {

ofstream outfile;

int i;

outfile.open("student_list.txt", ios::trunc);

for (i = 0; i < students.size(); i++) {

outfile << students[i].id << '\t';

outfile << students[i].name << '\t';

outfile << students[i].address << '\t';

outfile << students[i].no_of_courses;

if (students[i].no_of_courses >= 1) {

outfile << '\t' << students[i].course[0].dept << '\t';

outfile << students[i].course[0].course_name << '\t';

outfile << students[i].course[0].prof_id << '\t';

outfile << students[i].course[0].credit;

}

if (students[i].no_of_courses == 2) {

outfile << '\t' << students[i].course[1].dept << '\t';

outfile << students[i].course[1].course_name << '\t';

outfile << students[i].course[1].prof_id << '\t';

outfile << students[i].course[1].credit;

}

if (i != students.size() - 1) {

outfile << '\n';

}

}

outfile.close();

cout << "마스터 파일에 저장 완료!" << endl;

}

//정렬을 위한 비교 함수

bool id_compare(STUDENT a, STUDENT b)

{

return a.id < b.id;

}

C에서는 변수를 무조껀 상위에 선언해야하지만

(ex)

int a=0;

int b=1;

int c=2;

a = b+c;

C++에서는 중간에 선언하여도 사용할 수있다고 하여 (물론 해당 변수를 사용하기 이전)

(ex)

int a=0;

int b=1;

a = b;

int c = 2;

a = a + c;

//////////////////////////////////////////////////

for문에서 

for (i = 0; i < N; i++) {

for (int j = 0; j < N; j++) {

cout << "hahah";

}

}

이런식으로 자주 썼었는데 문득 for문안의 저 'int j'가 

for문 밖에서도 선언된 상태인지 궁금하여

for (i = 0; i < N; i++) {

for (int j = 0; j < N; j++) {

cout << "hahah";

}

cout <<  j;

}

이렇게 j를 출력해보았는데 안되었다. ( 'j'가 선언되지 않은 식별자라고 에러표시된다 )

선언된 변수는 {    } 안에서만 사용가능하고 {   } 를 빠져나오게 되면

없어지는 것 같다.

char input[100][100] = {0};

cout << "N을 입력 : ";

cin >> N;

while (i < N) {

cin.getline(input[i], 100);

i++;

}

이런식으로 N번의 문자열을 받는 프로그램을 짜고 실행하였는데

N = 3 이라면 3번을 입력받아야 하는데

2번밖에 입력안받는 현상이 생겼다.

버퍼에 남아있는 문자때문에 그렇다고 생각되어

C언어를 할때 쓰던

fflush(stdin);

을 사용하여 버퍼를 비워 보았는데 비워지지 않았다ㅠ

그래서 찾아본 결과

cin.ignore() 로 입력버퍼를 비울 수 있다는 것을 알게되었다.

//////////////////////////////////////////////////////////

char input[100][100] = {0};

cout << "N을 입력 : ";

cin >> N;

cin.ignore();

while (i < N) {

cin.getline(input[i], 100);

i++;

}

///////////////////////////////////////////////////////////

이런식으로 버퍼를 지워주니 getline에서 잘 입력받아 주었다.

typedef struct english {

char word[50]; //단어

char mean[100]; //뜻

struct english* chain = NULL;

}ENGLISH;

ENGLISH* tmp = (ENGLISH *)malloc(sizeof(ENGLISH));

이런식으로 동적할당을 받아서 char배열에 값을 넣고 쓸 때

쓰레기 값들이 한번씩 나왔던것 같다.

물론 구조체 안에서 각 멤버들을 초기화 해주어도 되지만

나는 할당을 받고나서 memset을 이용하여 초기화를 해준다.

///////////////////////////////////////////////////////////

ENGLISH* tmp = (ENGLISH *)malloc(sizeof(ENGLISH));

memset(tmp, 0, sizeof(ENGLISH));

///////////////////////////////////////////////////////////

이렇게 해주면 한번에 해당 메모리를 원하는 문자로 초기화 할 수 있다.

=================================================

원형 : void * memset(void *ptr, int value, size_t num);

ptr은 시작 주소

value 해당 공간을 채울 값

num은 시작 주소부터 얼마만큼 value로 채울지 (size)

accumulate 모으다; 축적하다

accustomed 익숙한

achieve 이루다, 성취하다

이런식으로 들어가 있는 txt 파일을 읽으려고 하니 

char buffer[100];

while (!file.eof()) {

file >> buffer;

}

이런식으로 읽게되면 공백단위로 읽게되어 (모으다; 축적하다) 가 한번에 들어가야되는데

(모으다;) 따로 (축적하다) 따로 들어가게 된다.

영어단어와 뜻 사이에 있는 탭( '\t' ) 으로 구분하여 잘라서 사용하고 싶다면

strtok을 사용하면 된다!

////////////////////////////////////////////////////////

char* token = NULL;

char tk[] = "\t\n";

char buffer[100];

ENGLISH *tmp = NULL;

while (!file.eof()) {

memset(buffer, 0, sizeof(buffer));

file.getline(buffer, 100);

token = strtok(buffer, tk);

strcat(tmp->word, token);

token = strtok(NULL, tk);

strcat(tmp->mean, token);

}

이런식으로 getline으로 한줄을 받은 후

strtok 을 사용하여 특정 token단위로 잘라서 사용해주면 될 거 같다.

//////////////////////////////////////////////////////

원형

char* strtok(char* str, const char* delimiters);

str은 대상 문자열

delimiters는 구분자, 무엇으로 구분할 것인가를 문자열 형태로 지정

분리한 결과의 첫번째 주소값을 리턴

///////////////////////////////////////////////////////////////

중요!!!!!!!!!!!!!!!!!

token = strtok(NULL, tk);    을 쓰는 이유

첫번째 인자로 문자열의 주소값이 들어오면 거기서부터 분리를 시도하는데

만약 NULL이 들어오면 이전에 자기가 기억한 곳으로부터 분리 시도!!!!!!!

visual studio 2015로 C++과제를 하고있었는데

'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead. 

이런 에러가 막 발생했다.

검색해보니 에러가 아니라 해당 함수가 보안적인 면에서 취약하다고 말해주는 경고메세지라고 한다.

str~~~ 종류의 함수들이 이런 경고를 다 표시하는 것 같다.

//////////////////////////////////////////////////////////////

strcpy_s 같이 뒤에 _s를 붙여 보안적인면이 추가된 함수를 사용해도 좋고

그냥 그대로 사용하고 싶다면

#pragma warning ( disable : 4996 )

이 코드를 이용해 경고를 무시해줘도 된다.

c 프로그램을 작성하고 실행시키면

출력결과를 지켜보고싶은데

확인하기도 전에 바로 콘솔창이 꺼지는 경우가 있다.

멈추고 싶은 곳에

system("pause");  을 넣으면 멈추게된다

헤더파일은 #include <windows.h>   이다

그런데 귀찮을 때, 그냥 결과를 확인하고싶으면

getch();  이렇게 쓰기도 한다. 나는ㅎ

3
2
4
92

2
19
4841817

소스

////////////////////////////////////////////////////////////

#include <stdio.h>

#include <string.h>

#define MOD 10000000

int n;

int cache[101][101];

int poly(int ,int);

int main(){

    int c;

    int i = 0;

    scanf("%d", &c);

    while(c-- > 0){

        memset(cache, -1, sizeof(cache));

        scanf("%d",&n);

        int start = 0;

        int ans = 0;

        for(i = 1; i< n; i++){

            ans = ans + poly(n, i);

            ans %= MOD;

        }

        printf("%d\n", ans+1);          

    }

    return 0;

}

int poly(int n, int first){

    if(n == first) return 1;

    int ret = cache[n][first];

    int second = 0;

    if(ret != -1) return ret;

    ret = 0;

    for(second = 1; second <= n - first; second++){

          int add = second + first -1;

          int sum = poly(n-first, second);

          int temp = n - first;

          cache[temp][second] = sum;

          add = add * sum;

          add %= MOD;

          ret += add;

          ret %= MOD;

    }

    return ret;   

}

0000011111
3
0 5
4 2
5 9

No
Yes
Yes

소스

/////////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>

int main(){

     char input[1000001];

     int grpIn[1000001];

     int i=0;

     int j=0;

     int N=0;

     int A=0;

     int num=0;

     scanf("%s", input);

     scanf("%d", &N);

     for(A=0; A<1000001; A++){

         if(input[A] == '\0') break;

         grpIn[A] = num;  

         if(input[A] != input[A+1]){

              num++;            

         }              

     }

     while(N){

         scanf("%d %d", &i, &j);

         if(grpIn[i] == grpIn[j]) printf("Yes\n");

         else printf("No\n");

         N--;                          

     }

}

/////////////////////////////////////////////////////////////////////////////////////