글
정말 긴연산... 다들 비슷한거 내서 한개는 특별하게
후위연산 + 토큰 +기본 옵션 까지 ~! 주석달기...
쫌길다.. 25페이지... ㅋㅋ
// 사칙연산
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BOOL int
#define TRUE 1
#define FALSE 0
#define STACKSIZE 20 // 입력할 문자를 20개 까지 받는다
#define BUFFER 256
// 아스키 코드를 사용해서 사칙연산 및 괄호를 입력 받는다
#define ASCII_ADD 43 // + 를 지정
#define ASCII_SUB 45 // - 를 지정
#define ASCII_MUL 42 // * 를 지정
#define ASCII_DIV 47 // / 를 지정
#define ASCII_MOD 37 // % 를 지정
#define ASCII_BRACKET_START 40 // ( 를 지정
#define ASCII_BRACKET_STOP 41 // ) 를 지정
// push, pop, del을 지정 한다
#define FLAG_NONE 0
#define FLAG_PUSH 1
#define FLAG_POP 2
#define FLAG_DEL 3
// 각 리턴을 지정해준다
#define RETURN_NONE 0
#define RETURN_NUM 1
#define RETURN_OPER 2
#define RETURN_START 3
#define RETURN_STOP 4
typedef struct _NODE
{
char nData;
_NODE *pPrev;
_NODE *pNext;
} NODE, *PNODE;
typedef struct _LINKEDLIST
{
NODE *pTop;
NODE *pBottom;
int nSize;
} LINKEDLIST, *PLINKEDLIST;
// 함수의 원형을 나열한다
PLINKEDLIST Create();
BOOL Input(PLINKEDLIST pLinkedList, char *szInfix, char* szPostfix);
BOOL PushLinkedList(PLINKEDLIST pLinkedList, char *cOperator);
char PopLinkedList(PLINKEDLIST pLinkedList);
BOOL PrintLinkedList(char *pToken, char *pValue, PLINKEDLIST pLinkedList, char *szResult, int nFlag);
int Process(char *szPostfix);
BOOL PushArray(int *pStack, int nValue, int *nTop);
int PopArray(int *pStack, int *nTop);
BOOL PrintArray(int *pStack, char *pToken, int nValue, int nTop, int nFlag);
char* AddResult(char *pResult, char *pToken, int nSize);
char* NextTokenIn(char *pCurrent, char *pToken, int *nFlag);
char* NextTokenPost(char *pCurrent, char *pToken, int *nFlag);
BOOL ParseInfix(char *pCurrent);
BOOL GetKey(char *szTemp);
// 프로그램 시작점
int main()
{
PLINKEDLIST pLL;
char szInfix[BUFFER];
char szPostfix[BUFFER];
int nResult;
// 행렬리스트 링크드 리스트를 생성한다
pLL = Create();
// 화면 출력
printf("===============================================================================\n");
printf(" 스택 구현 프로그램\n");
printf("===============================================================================\n\n");
// 수식 입력 함수 호출
Input(pLL, szInfix, szPostfix);
printf("===============================================================================\n");
printf(" 후위 계산 과정 출력\n");
printf("===============================================================================\n\n");
// 수식 계산 함수 호출
nResult = Process(szPostfix);
printf("===============================================================================\n");
printf(" 결과값 출력\n");
printf("===============================================================================\n\n");
// 결과 출력
printf("INFIX : %s\n", szInfix);
printf("POSTFIX : %s\n", szPostfix);
printf("RESULT : %d\n", nResult);
printf("\n===============================================================================");
// 링크드리스트 헤더노드 메모리 소거
free(pLL);
getchar();
return 0;
}
// 새로운 링크리스트를 만드는 부분
PLINKEDLIST Create()
{
// 노드의 시작을 가리키는 포인터를 생성한다
PLINKEDLIST pLinkedList;
// 말록 함수를 이용해서 LINKEDLIST의 사이즈만큼 pLinkedList로 삽입한다
pLinkedList = (PLINKEDLIST)malloc(sizeof(LINKEDLIST));
// 노드의 TOP, BOTTOM을 NULL(공백)로 지정한다
pLinkedList->pTop = NULL;
pLinkedList->pBottom = NULL;
//스택의 크기를 0으로 초기화 한다
pLinkedList->nSize = 0;
return pLinkedList;
}
//값을 삽입 해주는 부분
BOOL Input(PLINKEDLIST pLinkedList, char *szInfix, char* szPostfix)
{
char szTemp[BUFFER];
char szResult[BUFFER];
char szToken[BUFFER];
char *pCurrent;
char *pResult;
char cTemp;
int nFlag;
if(pLinkedList == NULL) //pLinkedList가 공백이면
{
// 초기화 되지 않았다고 알림이 나온뒤
printf("Input(): LinkedList가 초기화 될수없다\n");
// 리턴해준다
return FALSE;
}
//배열을 NULL로 초기화 한다(다른것과 겹쳐서 오류가 나지않기위해서)
//memset=포인터가 가리키는 주소에서부터 바이트수만큼의 길이를 값으로 초기화 시킨다
memset(szResult, '\0', sizeof(szResult));
printf("[?] 수식을 입력. ");
printf("예) 1+2*(3+4)/5%6+(7*8)\n");
while(TRUE)
{
printf(">> ");
// 값 입력
GetKey(szTemp);
// 입력된 수식이 올바른 형식인지 원하는 모양인지 확인한다(파싱)
if(ParseInfix(szTemp) == TRUE)
{
break;
}
else
{
printf("[!] 잘못된 수식이 입력\n");
}
}
// 순환을 돌 토큰 지정 하는 부분
pCurrent = szTemp;
pResult = szResult;
// 중위입력값 보관하는 부분
strcpy(szInfix, szTemp);
while(*pCurrent != NULL)// 널이 아닐경우
{
memset(szToken, '\0', sizeof(szToken));
// Infix형 수식의 토큰을 나눈다
pCurrent = NextTokenIn(pCurrent, szToken, &nFlag);
if(nFlag == RETURN_NONE)
{
continue;
}
// 숫자일때
else if(nFlag == RETURN_NUM)
{
pResult = AddResult(pResult, szToken, strlen(szToken));
PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_NONE);
}
else if(nFlag == RETURN_OPER)
{
if(szToken[0] == ASCII_ADD || szToken[0] == ASCII_SUB)
{
// 스택의 최상위가 NULL이 아닐때
if(pLinkedList->pTop != NULL)
{
while(TRUE)
{
// 스택이 비어있을때 멈춘다
if(pLinkedList->pTop == NULL)
{
break;
}
// 스택위 최상위에 같은 우선순위 (*, /, %, +, -) 연산자가 있을경우 스택에서 꺼내주는 부분
if(pLinkedList->pTop->nData == ASCII_MUL || pLinkedList->pTop->nData == ASCII_DIV || pLinkedList->pTop->nData == ASCII_MOD
|| pLinkedList->pTop->nData == ASCII_ADD || pLinkedList->pTop->nData == ASCII_SUB)
{
// 스택 POP
cTemp = PopLinkedList(pLinkedList);
pResult = AddResult(pResult, &cTemp, 1);
PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);
}
else
{
break;
}
}
}
PushLinkedList(pLinkedList, szToken);
PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);
}
else if(szToken[0] == ASCII_MUL || szToken[0] == ASCII_DIV || szToken[0] == ASCII_MOD)
{
// 스택의 최상위가 NULL이 아닐때
if(pLinkedList->pTop != NULL)
{
while(TRUE)
{
// 스택이 비어있을때
if(pLinkedList->pTop == NULL)
{
break;
}
// 스택의 최상위에 같은 우선순위의 (*, /, %) 연산자가 있을경우 스택에서 꺼낸다
if(pLinkedList->pTop->nData == ASCII_MUL || pLinkedList->pTop->nData == ASCII_DIV || pLinkedList->pTop->nData == ASCII_MOD)
{
// 스택 POP
cTemp = PopLinkedList(pLinkedList);
pResult = AddResult(pResult, &cTemp, 1);
PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);
}
else
{
break;
}
}
}
// 스택에 넣는다
PushLinkedList(pLinkedList, szToken);
PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);
}
}
// 괄호 시작일때
else if(nFlag == RETURN_START)
{
// 스택에 넣는다
PushLinkedList(pLinkedList, szToken);
PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);
}
// 괄호가 닫힐때
else if(nFlag == RETURN_STOP)
{
// TOP이 NULL이 아니면서 열린 괄호가 나올때까지 스택의 값들을 꺼낸다
while(pLinkedList->pTop != NULL && pLinkedList->pTop->nData != ASCII_BRACKET_START)
{
// 스택 POP
cTemp = PopLinkedList(pLinkedList);
pResult = AddResult(pResult, &cTemp, 1);
PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);
}
// 열린괄호를 삭제한다
cTemp = PopLinkedList(pLinkedList);
PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_DEL);
}
// 그 이외의 값이 입력되었을때
else
{
// 잘못된 값이라 출력하고 리턴해준다
printf("[!] 잘못된 값이 입력되었다");
return FALSE;
}
}
// 모든 토큰을 돌았을때
strcpy(szToken, "end");
// 스택안에 들어있는 데이터를 모두 꺼낸다
while(pLinkedList->nSize > 0)
{
// 스택 POP
cTemp = PopLinkedList(pLinkedList);
pResult = AddResult(pResult, &cTemp, 1);
PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);
}
// 후위 변환 완료후 결과값 복사
strcpy(szPostfix, szResult);
return TRUE;
}
// Push LinkedList Stack 부분
BOOL PushLinkedList(PLINKEDLIST pLinkedList, char *cOperator)
{
PNODE pNewNode;
// 스택이 풀인지 체크 한다
if(pLinkedList->nSize == STACKSIZE)
{
printf("[!] 링크드리스트 스택이 가득차 있다");
return FALSE;
}
// 링크드 리스트가 정상적으로 생성되있지 않을경우
if(pLinkedList == NULL)
{
printf("PushLinkedList(): LinkedList가 초기화 될수없다\n");
return FALSE;
}
// 포인터 구조체에 값을 입력하기 위해 메모리 영역을 할당한다
pNewNode = (PNODE)malloc(sizeof(NODE));
// 위의 과정을 거쳐 메모리에 영역을 할당하는데 실패하였을 경우
if(pNewNode == NULL)
{
printf("PushLinkedList(): LinkedList 노드를 생성 할 수가없다\n");
return FALSE;
}
// 입력된 연산자를 스택에 입력한다
pNewNode->nData = (char)*cOperator;
// 이전 노드의 포인터를 NULL로 한다
pNewNode->pPrev = NULL;
// 처음으로 입력되는 스택일경우
if(pLinkedList->pTop == NULL)
{
pNewNode->pNext = NULL;
pLinkedList->pTop = pNewNode;
pLinkedList->pBottom = pNewNode;
}
// 두번째 이상으로 입력되는 스택일경우
else
{
pLinkedList->pTop->pPrev = pNewNode;
pNewNode->pNext = pLinkedList->pTop;
pLinkedList->pTop = pNewNode;
}
// 스택의 사이즈를 하나더 증가시킨다
pLinkedList->nSize++;
return TRUE;
}
// Pop LinkedList Stack 부분
char PopLinkedList(PLINKEDLIST pLinkedList)
{
char cTemp;
PNODE pCurrent;
// 스택이 비어있는지 검사한다
if(pLinkedList->nSize == 0)
{
printf("[!] 링크드리스트 스택이 비어 있다");
return FALSE;
}
// 링크드 리스트가 정상적으로 생성되어있지 않을경우
if(pLinkedList == NULL)
{
printf("PopLinkedList(): LinkedList가 초기화 될수 없다\n");
return FALSE;
}
// 메모리에서 삭제하기 위한 링크를 남겨둔다
pCurrent = pLinkedList->pTop;
// 링크드 리스트 스택 사이즈를 1줄인다
pLinkedList->nSize--;
// 스택이 비었을때
if(pLinkedList->nSize == 0)
{
pLinkedList->pTop = NULL;
pLinkedList->pBottom = NULL;
}
// 스택이 비어있지 않을때 Top을 조정한다
else
{
pLinkedList->pTop = pLinkedList->pTop->pNext;
pLinkedList->pTop->pPrev = NULL;
}
// 삭제될 최상의 스택의 값을 받는다.
cTemp = pCurrent->nData;
// 메모리 소거
free(pCurrent);
// 값 리턴
return cTemp;
}
// Print LinkedList Stack부분
BOOL PrintLinkedList(char *pToken, char *pValue, PLINKEDLIST pLinkedList, char *szResult, int nFlag)
{
PNODE pCurrent;
char *pResult;
char szTemp[BUFFER];
int nReturn;
//pLinkedList가 공백일때
if(pLinkedList == NULL)
{
printf("PrintLinkedList(): LinkedList가 초기화 될수없다\n");
return FALSE;
}
// 현재 토큰 값 출력
printf("TOKEN : %s\n", pToken);
// 플래그 출력, PUSH인지 POP인지 DELETE인지 구별한다
switch(nFlag)
{
case FLAG_NONE :
// 스택을 거치지 않을때
printf("COPY(-)\n");
break;
case FLAG_PUSH :
// PUSH일때
printf("PUSH(%s)\n", pToken);
break;
case FLAG_POP :
// POP일때
printf("POP(%c)\n", pValue[0]);
break;
case FLAG_DEL :
// DELETE일때
printf("DELETE(%c)\n", pValue[0]);
break;
}
// 스택안에 들어있는 값 출력
printf("STACK : ");
pCurrent = pLinkedList->pBottom;
while(pCurrent != NULL)
{
// 링크드 리스트를 돌며 값을 출력한다
printf("%c ", pCurrent->nData);
pCurrent = pCurrent->pPrev;
}
// 결과 출력
printf("\nOUTPUT : ");
pResult = szResult;
// 토큰을 돌며 출력한다
while(*pResult != '\0')
{
memset(szTemp, '\0', sizeof(szTemp));
// 토큰을 돌며 출력한다
pResult = NextTokenPost(pResult, szTemp, &nReturn);
// 숫자나 연산자만 출력한다
if(nReturn == RETURN_NUM || nReturn == RETURN_OPER)
{
printf("%s ", szTemp);
}
}
getchar();
printf("\n");
return TRUE;
}
int Process(char *szPostfix)
{
char *pCurrent;
char szTemp[BUFFER];
int aStack[STACKSIZE];
int nReturn;
int nTop;
int nTemp[2];
// 스택의 탑위치를 가리키는 nTop초기화(0부터 시작하므로-1으로 초기화)
nTop = -1;
// 후위변경된 수식의 시작을 포인터 지정
pCurrent = szPostfix;
// 토큰을 돌며 출력한다
while(*pCurrent != '\0')
{
memset(szTemp, '\0', sizeof(szTemp));
// 토큰을 돌며 출력한다
pCurrent = NextTokenPost(pCurrent, szTemp, &nReturn);
// 숫자는 무조건 push한다
if(nReturn == RETURN_NUM)
{
PushArray(aStack, atoi(szTemp), &nTop);
PrintArray(aStack, szTemp, atoi(szTemp), nTop, FLAG_PUSH);
}
// 연산자가 나오면 이전의 스택 값 두개를 연산하여 결과를 다시 push한다
else if(nReturn == RETURN_OPER)
{
nTemp[1] = PopArray(aStack, &nTop);
PrintArray(aStack, szTemp, nTemp[1], nTop, FLAG_POP);
nTemp[0] = PopArray(aStack, &nTop);
PrintArray(aStack, szTemp, nTemp[0], nTop, FLAG_POP);
switch(szTemp[0])
{
case '+' :
// 덧셈 연산자 일때
PushArray(aStack, (int)(nTemp[0] + nTemp[1]), &nTop);
break;
case '-' :
// 뺄셈 연산자 일때
PushArray(aStack, (int)(nTemp[0] - nTemp[1]), &nTop);
break;
case '*' :
// 곱셈 연산자 일때
PushArray(aStack, (int)(nTemp[0] * nTemp[1]), &nTop);
break;
case '/' :
// 나눗셈 연산자 일때
PushArray(aStack, (int)(nTemp[0] / nTemp[1]), &nTop);
break;
case '%' :
// 나머지 연산자 일때
PushArray(aStack, (int)(nTemp[0] % nTemp[1]), &nTop);
break;
}
PrintArray(aStack, szTemp, aStack[nTop], nTop, FLAG_PUSH);
}
}
// 최종 결과 값 리턴
return aStack[0];
}
// Push Stack
BOOL PushArray(int *pStack, int nValue, int *nTop)
{
// 스택사이즈만큼 가득차 있을경우
if(*nTop == STACKSIZE)
{
printf("[!] 배열 스택이 가득차 있다\n");
return FALSE;
}
// TOP 위치 상승
(*nTop)++;
// 푸쉬할 값 입력
*(pStack + *nTop) = nValue;
return TRUE;
}
// Pop Stack
int PopArray(int *pStack, int *nTop)
{
int nTemp;
// 스택이 비어있을 경우
if(*nTop == -1)
{
printf("[!] 배열 스택이 비어 있다\n");
return FALSE;
}
// 팝을 하기 위한 값 복사
nTemp = *(pStack + *nTop);
// TOP위치 감소
(*nTop)--;
return nTemp;
}
// Print Stack
BOOL PrintArray(int *pStack, char *pToken, int nValue, int nTop, int nFlag)
{
int nCount;
printf("TOKEN : %s\n", pToken); //pToken 값을 출력
if(nFlag == FLAG_PUSH)//FLAG_PUSH와 같으면
{
printf("PUSH(%d)\n", nValue);//nValue(push) 값을 출력
}
else if(nFlag == FLAG_POP)//또는 FLAG_POP와 같을때
{
printf("POP(%d)\n", nValue);//nValue(pop)를 출력
}
printf("STACK : ");
for(nCount = 0 ; nCount <= nTop ; nCount++)//nCount를 nTop보다 같으나 클때까지 출력
{
printf("%d ", *(pStack + nCount));
}
// 사용자가 엔터를 입력할때까지 기다린다
getchar();
printf("\n");
return TRUE;
}
// Add Character Array
char* AddResult(char *pResult, char *pToken, int nSize)
{
int nCount;
// 토큰을 결과 배열에 입력한다
for(nCount = 0; nCount < nSize ; nCount++)
{
*pResult = *pToken;
// 결과 배열 포인터를 증가시킨다
pResult++;
pToken++;
}
// 널문자 삽입
*pResult = '\0';
return pResult;
}
// Next Token Pointer
char* NextTokenIn(char *pCurrent, char *pToken, int *nFlag)
{
// 숫자인지 오퍼레이터인지 검사하는 플래그 초기화
*nFlag = 0;
// 숫자일때
if(*pCurrent < 58 && *pCurrent > 47)
{
// 이전 토큰의 값이 -이면서 그 이전토큰의 값이 숫자가 아닐때
if(*(pCurrent - 1) == ASCII_SUB && (*(pCurrent - 2) > 57 || *(pCurrent - 2) < 48))
{
*pToken = ASCII_SUB;
pToken++;
}
else
{
*pToken = ASCII_ADD;
pToken++;
}
// 이어 나오는 토큰이 숫자일경우 계속 출력한다
while(*pCurrent < 58 && *pCurrent > 47)
{
*pToken = *pCurrent;
pToken++;
pCurrent++;
}
// 숫자일경우
*nFlag = RETURN_NUM;
}
else if(*pCurrent == ASCII_BRACKET_START || *pCurrent == ASCII_BRACKET_STOP)
{
if(*pCurrent == ASCII_BRACKET_START)
{
*nFlag = RETURN_START;
}
else
{
*nFlag = RETURN_STOP;
}
*pToken = *pCurrent;
pToken++;
pCurrent++;
}
else
{
// 앞의 토큰이 숫자일 경우
if(*(pCurrent - 1) < 58 && *(pCurrent - 1) > 47 || *(pCurrent - 1) == ASCII_BRACKET_STOP)
{
*pToken = *pCurrent;
pToken++;
// 연산식일 경우
*nFlag = RETURN_OPER;
}
pCurrent++;
}
return pCurrent;
}
// Next Token Pointer
char* NextTokenPost(char *pCurrent, char *pToken, int *nFlag)
{
// 숫자인지 오퍼레이터인지 검사하는 플래그 초기화
*nFlag = RETURN_NONE;
// 숫자일때
if(*pCurrent < 58 && *pCurrent > 47)
{
// 이전 토큰의 값이 -일때
if(*(pCurrent - 1) == ASCII_SUB)
{
*pToken = ASCII_SUB;
pToken++;
}
// 이어 나오는 토큰이 숫자일경우 계속 출력한다
while(*pCurrent < 58 && *pCurrent > 47)
{
*pToken = *pCurrent;
pToken++;
pCurrent++;
}
// 숫자일경우
*nFlag = RETURN_NUM;
}
// 연산식일때
else
{
// 뒤의 토큰이 숫자일 경우
if(*(pCurrent + 1) > 57 || *(pCurrent + 1) < 48)
{
*pToken = *pCurrent;
pToken++;
*nFlag = RETURN_OPER;
}
pCurrent++;
}
return pCurrent;
}
// Get Key 키입력 처리
BOOL GetKey(char *szTemp)
{
int nCount;
// fgets로 값을 입력받는다. BUFFER이상 길이의 값이 입력될 경우 짤린다
fgets(szTemp, BUFFER, stdin);
// 반복문, 값이 입력되지 않은 부분에 널문자를 채운다
for(nCount = 0 ; nCount < BUFFER ; nCount++)
{
if(szTemp[nCount] < 0 || szTemp[nCount] == '\n')
{
// 아스키코드 0번 이하이거나 엔터문자일경우 널문자로 교체
szTemp[nCount] = '\0';
}
}
return TRUE;
}
// Parserinfix
BOOL ParseInfix(char *pCurrent)
{
int nCountNum;
int nCountOper;
int nCountBracket_Start;
int nCountBracket_Stop;
// 각각의 정보를 기록하는 카운터를 초기화 한다
nCountNum = 0;
nCountOper = 0;
nCountBracket_Start = 0;
nCountBracket_Stop = 0;
while(*pCurrent != '\0')
{
// 현재 토큰이 숫자일때
if(*pCurrent < 58 && *pCurrent > 47)
{
// 이전 토큰이 숫자가 아닐때
if(*(pCurrent - 1) > 57 || *(pCurrent - 1) < 48)
{
nCountNum++;
}
}
// 현재 토큰이 연산자일때
else
{
// 여는 괄호일때, 이전 토큰이 숫자이면 안된다
if(*pCurrent == ASCII_BRACKET_START && (*(pCurrent - 1) > 57 || *(pCurrent - 1) < 48))
{
// 닫는 괄호가 여는 괄호보다 많을수 없음
nCountBracket_Start++;
}
// 닫는 괄호일때
else if(*pCurrent == ASCII_BRACKET_STOP)
{
if(nCountBracket_Stop > nCountBracket_Start)
{
return FALSE;
}
nCountBracket_Stop++;
}
// 연산자 일때
else if(*pCurrent == ASCII_ADD || *pCurrent == ASCII_SUB || *pCurrent == ASCII_MUL || *pCurrent == ASCII_DIV || *pCurrent == ASCII_MOD)
{
// 이전 토큰이 숫자일때 연산자임
if(*(pCurrent - 1) < 58 && *(pCurrent - 1) > 47 || *(pCurrent - 1) == ASCII_BRACKET_STOP)
{
nCountOper++;
}
// 이전 토큰이 시작하는 괄호일때
else if(*(pCurrent - 1) == ASCII_BRACKET_START)
{
// 현재 토큰이 *, /, %이라면 잘못된 수식
if(*pCurrent == ASCII_MUL || *pCurrent == ASCII_DIV || *pCurrent == ASCII_MOD)
{
return FALSE;
}
}
}
else
{
// 위에 있지 않는 문자가 입력되었을 경우
return FALSE;
}
}
pCurrent++;
}
// 여는 괄호와 닫는 괄호의 수가 다를 경우 잘못된 형식
if(nCountBracket_Start != nCountBracket_Stop)
{
return FALSE;
}
// 숫자와 연산자+1의 수가 다를 경우 잘못된 형식
if(nCountNum != (nCountOper + 1))
{
return FALSE;
}
return TRUE;
}
'컴퓨터 > c관련 숙제' 카테고리의 다른 글
C++ 윈도우 프로그래밍 숙제 (0) | 2013.12.29 |
---|---|
윈도우 프로그래밍 숙제 2탄~! (0) | 2013.12.29 |
c언어 자료구조 숙제 ~! 2부 (0) | 2013.12.29 |
자료구조) (큐+스택) 이중연결리스트를 이용한 덱프로그램 (0) | 2013.12.29 |
c로 배우는 자료구조 연습문제 (0) | 2013.12.29 |
RECENT COMMENT