1000 자리까지 계산되는 계산기

1000 자리 계산기를 입력받아서 계산하는 계산기입니다

전부다 1초 미만으로 계산 됩니다

나누기는 1000 자리 나누기 1000 자리하면 무한 계산합니다

처음부터 끝까지 만들고 

버그가많아서 처음부터 다시시작해서

다시코딩해서 3일정도 걸렷네욤 코드 실행파일 추가합니다

Calculator1000Debug.exe

#include <stdio.h>
#include <uchar.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <math.h>
#include <time.h>
 
//윈도우용 헤더
#if defined(_WIN32) || defined(_WIN64)
#include <Windows.h>
#include <crtdbg.h>
#define CLEAR "cls"
#else
#deifne CLEAR "clear"
#endif
 
#define SAFE_FREE(p) if (p) {free(p); p = NULL;}    //메모리해제 매크로    
 
//배열의 최대크기
#define MAX_SIZE 1001
//배열의 마지막 인덱스
#define END_INDEX MAX_SIZE - 1
//문자열의 최대 길이
#define STR_MAX_LEN MAX_SIZE - 1
//최대 문자열 길이의 인덱스
#define STR_MAX_LEN_INDEX STR_MAX_LEN - 1
 
enum ARITHMETIC
{
    A_NONE,
    A_PLUS,
    A_MINUS,
    A_MULTIPLY,
    A_DIVIDE,
    A_TEST,
    A_EXIT
};
 
bool Init(void** _pResult, void** _pInput);
void Run(char* _pResult, char* _pInput);    //실행 함수
int32_t Menu();    //메뉴 함수
void Input(char* _pInput);    //사용자에게서 입력받는 함수
void OutputResult(char* _pResult, char* _pInput);    //결과 출력해주는 함수
void Output(char* _cArr);    //문자열 출력
void Button(char* _pResult, char* _pInput, bool(*lpfnCalculate)(char*, char*));    //버튼
bool Plus(char* _pResult, char* _pInput);            //사칙연산
bool Minus(char* _pResult, char* _pInput);
bool Multiply(char* _pResult, char* _pInput);
bool Divide(char* _pResult, char* _pInput);
void Test();
 
int32_t ctoi(char _cChar);    //문자 정수로 변환
char itoc(int32_t _iInt);    //정수 문자로 바꿈
int32_t FindKey(char* _pSet);    //키값의 시작 인덱스를 반환함
int32_t MinKey(char* _pSet1, char* _pSet2);    //더작은 키값을 반환함
int32_t iInput();    //정수인풋함수
char* strInput();    //문자열 인풋함수
void ClearBuffer();    //버퍼지우기
 
//------ 전역변수 끝
//1000자리 까지 계산하는 계산기
int main()
{
#if defined(_WIN32) || defined(_WIN64)
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    //_CrtSetBreakAlloc();
#endif
 
    srand((unsigned int)time(NULL));
 
    //지역설정
    setlocale(LC_ALL, "");
 
    //결과값과 입력값
    char* pResult = NULL;
    char* pInput = NULL;
 
    if (!Init((void*)&pResult, (void*)&pInput))
    {
        wprintf(u"초기화에 실패했습니다.\n");
        goto exit;
    }
 
    //실행
    Run(pResult, pInput);
 
exit:
    //메모리 해제
    SAFE_FREE(pResult);
    SAFE_FREE(pInput);
 
    return 0;
}
 
bool Init(void ** _pResult, void ** _pInput)
{
    void** pResult = _pResult;
    void** pInput = _pInput;
 
    *pResult = calloc(MAX_SIZE, 1);
    *pInput = calloc(MAX_SIZE, 1);
 
    //아무값도 할당이 안됬으면 초기화 실패
    if ((*pResult == NULL) || (*pInput == NULL))
        return false;
 
    memset(*pResult, '0', STR_MAX_LEN);
    memset(*pInput, '0', STR_MAX_LEN);
 
    return true;
}
 
void Run(char* _pResult, char* _pInput)
{
    char* pResult = _pResult;
    char* pInput = _pInput;
 
    while (true)
    {
        //화면 지우기
        system(CLEAR);
        //출력하기
        OutputResult(pResult, pInput);
        switch (Menu())
        {
        case A_PLUS:
            Button(pResult, pInput, Plus);
            break;
        case A_MINUS:
            Button(pResult, pInput, Minus);
            break;
        case A_MULTIPLY:
            Button(pResult, pInput, Multiply);
            break;
        case A_DIVIDE:
            Button(pResult, pInput, Divide);
            break;
        case A_TEST:
            Test();
            break;
        case A_EXIT:
            return;
        }
    }
}
 
int32_t Menu()
{
    wprintf(u"%d. 더하기\n", A_PLUS);
    wprintf(u"%d. 빼기\n", A_MINUS);
    wprintf(u"%d. 곱하기\n", A_MULTIPLY);
    wprintf(u"%d. 나누기\n", A_DIVIDE);
    wprintf(u"%d. 시범관\n", A_TEST);
    wprintf(u"%d. 종료\n", A_EXIT);
    wprintf(u"메뉴를 선택하세요 :: ");
    int32_t iMenu = iInput();
 
    if (iMenu <= A_NONE || A_EXIT < iMenu)
        return 0;
 
    return iMenu;
}
 
void Input(char* _pInput)
{
    char* pInput = _pInput;
 
    wprintf(u"숫자를 입력해주세요.\n");
    char* str = NULL;
    while (str == NULL)
    {
        SAFE_FREE(str);
        str = strInput();
    }
    //입력받은 문자열의 길이를 저장
    int32_t cch = strlen(str);
    //NULL 값을 포함한 문자열의 길이
    int32_t cchz = cch + 1;
    //문자열 길이와 종 배열 크기의 차
    int32_t cchDif = MAX_SIZE - cchz;
 
    //만약 cchDif의 값이 0보다 크다면
    if (0 < cchDif)
    {
        //문자열의 가장 뒤쪽으로 옮긴뒤
        memmove(str + cchDif, str, cchz);
        //빈공간을 0으로 채웁니다
        memset(str, '0', cchDif);
    }
    //마무리로 pInput에 복사
    strcpy(pInput, str);
    //메모리해제
    SAFE_FREE(str);
}
 
void OutputResult(char* _pResult, char* _pInput)
{
    //지역변수
    char* pResult = _pResult;
    //char* pInput = _pInput;
 
    wprintf(u"== 1000자리 까지 계산되는 계산기  =\n");
    wprintf(u"결과값 :: "); Output(pResult);
    //wprintf(u"입력값 :: "); Output(pInput);
    wprintf(u"===================================\n");
}
 
void Output(char * _cArr)
{
    //지역변수로 바꿔주고
    char* cArr = _cArr;
    int32_t n = FindKey(cArr);
    //배열 출력기
    for (int32_t i = n; i < STR_MAX_LEN; ++i)
    {
        printf("%c", cArr[i]);
    }
    if (n == STR_MAX_LEN)
        printf("%c", '0');
    printf("\n");
}
 
void Button(char * _pResult, char * _pInput, bool(*lpfnCalculate)(char *, char *))
{
    char* pResult = _pResult, *pInput = _pInput;
 
    Input(pInput);                    //입력값 받고
    lpfnCalculate(pResult, pInput);    //배열들을 넘겨주면 끝
}
 
bool Plus(char* _pResult, char* _pInput)
{
    char* pResult = _pResult, *pInput = _pInput;
 
    //szSet1 는 첫번째 값
    //szSet2 는 두번째 값
    char szSet1[MAX_SIZE] = { '\0' };
    char szSet2[MAX_SIZE] = { '\0' };
 
    //원본 복사
    strcpy(szSet1, pResult);
    strcpy(szSet2, pInput);
 
    //두 문자열중 더긴 문자열의 시작 인덱스를 반환함
    int32_t Key = MinKey(szSet1, szSet2);
 
    //    문자를 정수형으로 바꾼값으 저장할 변수
    int32_t iSet1 = 0;
    int32_t iSet2 = 0;
 
    //    iSet1 + iSet2 의 합
    int32_t iSum = 0;
 
    //    앞의 인덱스를 가르킴
    int32_t iFrontIndex = 0;
 
    //문자열 가장 뒤부터 시작해서 Key를 만나면 종료
    for (int32_t i = STR_MAX_LEN_INDEX; Key <= i; --i)
    {
        //각각의 문자를 정수형으로 변환
        iSet1 = ctoi(szSet1[i]);
        iSet2 = ctoi(szSet2[i]);
 
        //두 정수를 더함
        iSum = iSet1 + iSet2;
 
        //만약 두수의 합이 9보다 클경우
        if (9 < iSum)
        {
            iFrontIndex = i - 1;
            //만약 앞의 인덱스가 음수 라면
            if (iFrontIndex < 0)
                return false;    //함수종료        
            do {
                //만약 앞의 인덱스가 '9'보다 커졌다면
                if ('9' < szSet1[iFrontIndex])
                {
                    szSet1[iFrontIndex] -= 10;    //10 감소
                    --iFrontIndex;    // 앞으로 전진
                }
                //만약 앞의 인덱스가 음수 라면
                if (iFrontIndex < 0)
                    return false;    //함수종료        
 
                //앞의 인덱스값에 + 1 해주고
                ++szSet1[iFrontIndex];
            } while ('9' < szSet1[iFrontIndex]);    //값이 '9' 보다 크면반복
 
            //iSum 에 - 10 해준뒤
            iSum -= 10;
        }    // if (9 < iSum) 끝
            //현재 인덱스에 그값을 저장
        szSet1[i] = itoc(iSum);
    }    // for (int32_t i = STR_MAX_LEN_INDEX; Key <= i; --i) 종료
 
    //값복사후 종료
    strcpy(pResult, szSet1);
 
    return true;
}
 
bool Minus(char* _pResult, char* _pInput)
{
    char* pResult = _pResult, *pInput = _pInput;
 
    //szSet1 는 첫번째 값
    //szSet2 는 두번째 값
    char szSet1[MAX_SIZE] = { '\0' };
    char szSet2[MAX_SIZE] = { '\0' };
 
    //원본 복사
    strcpy(szSet1, pResult);
    strcpy(szSet2, pInput);
 
    //두 문자열중 더긴 문자열의 시작 인덱스를 반환함
    int32_t Key = MinKey(szSet1, szSet2);
 
    //    문자를 정수형으로 바꾼값으 저장할 변수
    int32_t iSet1 = 0;
    int32_t iSet2 = 0;
 
    //    iSet1 - iSet2 의 차
    int32_t iDifference = 0;
 
    //    앞의 인덱스를 가르킴
    int32_t iFrontIndex = 0;
 
    //문자열 가장 뒤부터 시작해서 Key를 만나면 종료
    for (int32_t i = STR_MAX_LEN_INDEX; Key <= i; --i)
    {
        //각각의 문자를 정수형으로 변환
        iSet1 = ctoi(szSet1[i]);
        iSet2 = ctoi(szSet2[i]);
 
        //두 정수를 더함
        iDifference = iSet1 - iSet2;
 
        //만약 두수의 차가 0보다 작을경우
        if (iDifference < 0)
        {
            //앞의 인덱스를 할당
            iFrontIndex = i - 1;
            //만약 앞의 인덱스가 - 라면
            if (iFrontIndex < 0)
                return false;    //함수종료        
            do {
                //만약 앞의 인덱스가 '0'보다 작아졌다면
                if (szSet1[iFrontIndex] < '0')
                {
                    szSet1[iFrontIndex] += 10;    //10 증가시킨후
                    --iFrontIndex;    // 앞으로 전진
                }
                //만약 앞의 인덱스가 - 라면
                if (iFrontIndex < 0)
                    return false;    //함수종료        
 
                //앞의 인덱스값에 - 1 해주고
                --szSet1[iFrontIndex];
            } while (szSet1[iFrontIndex] < '0');    //감소된값이 '0' 보다 작으면반복
 
            //iSum 에 - 10 해준뒤
            iDifference += 10;
        }    // if (9 < iSum) 끝
            //현재 인덱스에 그값을 저장
        szSet1[i] = itoc(iDifference);
    }    // for (int32_t i = STR_MAX_LEN_INDEX; Key <= i; --i) 종료
 
    //값복사후 종료
    strcpy(pResult, szSet1);
    return true;
}
 
bool Multiply(char* _pResult, char* _pInput)
{
    char* pResult = _pResult, *pInput = _pInput;
 
    //szSet1 는 첫번째 값
    //szSet2 는 두번째 값
    char szSet1[MAX_SIZE] = { '\0' };
    char szSet2[MAX_SIZE] = { '\0' };
 
    //원본 복사
    strcpy(szSet1, pResult);
    strcpy(szSet2, pInput);
 
    //각자리수의 곱을 임시로 저장해둘 변수
    char szTemp[MAX_SIZE] = { '\0' };
 
    //szAnswer 은 szTemp 계산값을 누적할 배열
    char szAnswer[MAX_SIZE] = { '\0' };
 
    //szTemp & zAnswer 초기화
    memset(szTemp, '0', STR_MAX_LEN);
    memset(szAnswer, '0', STR_MAX_LEN);
 
    //두 문자열 Key의 시작값을 구함
    int32_t Key1 = FindKey(szSet1);
    int32_t Key2 = FindKey(szSet2);
 
    //    문자를 정수형으로 바꾼값을 저장할 변수
    int32_t iSet1 = 0;
    int32_t iSet2 = 0;
 
    //    iSet1 * iSet2 의 곱
    int32_t iProduct = 0;
 
    //    앞의 인덱스를 가리킴
    int32_t iFrontIndex = 0;
 
    //문자가 저장될 배열의 위치를 가리킴
    int32_t iCurrentPosition = 0;
 
    //임시 배열의 자릿수의 정수를 저장할 변수
    int32_t iTemp = 0;
 
    //10의 배수를 저장함
    int32_t iFactor = 0;
    //Set1과 Set2 을 돌아주는 2중 for문
    for (int32_t i = STR_MAX_LEN_INDEX, k = 0; Key1 <= i; --i, ++k)
    {
        for (int32_t j = STR_MAX_LEN_INDEX; Key2 <= j; --j)
        {
            //저장될 배열의 위치를 정해줌
            iCurrentPosition = j - k;
            //음수라면 함수 종료
            if (iCurrentPosition < 0)
                return false;
 
            //각각 자리의 수를 정수로 변환한후
            iSet1 = ctoi(szSet1[i]);
            iSet2 = ctoi(szSet2[j]);
 
            //두수를 곱함
            iProduct = iSet1 * iSet2;
 
            //현재자리수의 정수를 구함
            iTemp = ctoi(szTemp[iCurrentPosition]);
 
            //곱에다가 더함
            iProduct += iTemp;
 
            //곱한 값이 10의 몃배수인지 구함
            iFactor = iProduct / 10;
 
            //만약 iProduct의 값이 9보다 크다면
            if (9 < iProduct)
            {
                //앞의 인덱스를 가리킴
                iFrontIndex = j - k - 1;
                //앞의 인덱스가 음수면 함수 종료
                if (iFrontIndex < 0)
                    return false;
                //iFactor 만큼 더해줌
                szTemp[iFrontIndex] += iFactor;
                //만약 더한값이 9보다 커졌다면
                while ('9' < szTemp[iFrontIndex])
                {
                    //10빼준뒤
                    szTemp[iFrontIndex] -= 10;
                    //감소시키고
                    --iFrontIndex;
                    //앞의 인덱스가 음수면 함수 종료
                    if (iFrontIndex < 0)
                        return false;
 
                    // 1 증가
                    ++szTemp[iFrontIndex];
                }
 
                //1의 자리수를 구해준뒤 뺌
                iProduct -= 10 * iFactor;
            }    // if (9 < iProduct) 끝    
            //문자로 변환후 넣어줌
            szTemp[iCurrentPosition] = itoc(iProduct);
        }    // for (int32_t j = STR_MAX_LEN_INDEX; Key2 <= j; --j)
        //곱한 결과를 szAnswer에 축적함
        //만약 더하기가 불가능하다면
        if (!Plus(szAnswer, szTemp))
            return false;    //함수종료
        //szTemp 초기화
        memset(szTemp, '0', STR_MAX_LEN);
    } // for (int32_t i = STR_MAX_LEN_INDEX; Key1 <= i; --i)
 
    //값전달
    strcpy(pResult, szAnswer);
 
    return true;
}
 
bool Divide(char* _pResult, char* _pInput)
{
    char* pResult = _pResult, *pInput = _pInput;
 
    //szSet1 는 첫번째 값
    //szSet2 는 두번째 값
    char szSet1[MAX_SIZE] = { '\0' };
    char szSet2[MAX_SIZE] = { '\0' };
 
    //원본 복사
    strcpy(szSet1, pResult);
    strcpy(szSet2, pInput);
 
    //나눠진값을 임시로 저장할 변수
    char szTemp[MAX_SIZE] = { '\0' };
 
    //szAnswer 은 나누기 몫을 저장할 배열
    char szAnswer[MAX_SIZE] = { '\0' };
 
    //초기화
    memset(szTemp, '0', STR_MAX_LEN);
    memset(szAnswer, '0', STR_MAX_LEN);
 
    //문자열 Key의 시작값을 구함
    int32_t Key1 = FindKey(szSet1);
 
    //1~9 의 문자열 pSet1에 곱할용도로 쓰임
    char** pFactor = NULL;
    char *szFactor[9] = { NULL };
    char Factor[9 * MAX_SIZE] = { '\0' };
 
    //2중배열 직렬화
    pFactor = &szFactor;
    pFactor[0] = Factor;
    for (int32_t i = 1; i < 9; ++i)
        pFactor[i] = pFactor[i - 1] + MAX_SIZE;
 
    //초기화
    for (int32_t i = 0; i < 9; ++i)
    {
        memset(pFactor[i], '0', STR_MAX_LEN);
        pFactor[i][STR_MAX_LEN_INDEX] = itoc(i + 1);
    }
 
    //나눠지는 제수를 저장할 변수
    int32_t iDivisor = 0;
 
    //pSet1 의 첫번째 문자열부터 마지막까지 순회함
    for (int32_t i = Key1, j = 1; i < STR_MAX_LEN; ++i, ++j)
    {
        //첫번째 자리부터 차례대로 증가시키면서
        //szTemp에 적용시킴
        strncpy(szTemp + STR_MAX_LEN - j, szSet1 + Key1, j);
 
        for (int32_t n = 8; 0 <= n; --n)
        {
            //곱해지나봄 안되면 넘어감
            if (!Multiply(szSet2, pFactor[n]))
                continue;
            //곱해졌으면 빼지나 봄
            if (!Minus(szTemp, szSet2))
            {
                //안빼지면 szSet2 초기화
                strcpy(szSet2, pInput);
                continue;
            }
            else
            {
                //인덱스 수를 저장하고
                iDivisor = n + 1;
                //그 값을 저장
                szAnswer[j - 1] = itoc(iDivisor);
                break;
            }
        }
        //Set2 초기화
        strcpy(szSet2, pInput);
        //빼진값을 저장함
        strncpy(szSet1 + Key1, szTemp + STR_MAX_LEN - j, j);
    }
    //나머지
    szTemp;
    //정답의 길이
    int32_t length = STR_MAX_LEN - Key1;
    //정답 복사
    strncpy(pResult + Key1, szAnswer, length);
    return true;
}
 
void Test()
{
    system(CLEAR);
 
    LARGE_INTEGER start, end, f;
    float fDeltaTime = 0.f;
    QueryPerformanceFrequency(&f);
 
    char szResult[MAX_SIZE] = { '\0' };
    char szInput[MAX_SIZE] = { '\0' };
    char szInput2[MAX_SIZE] = { '\0' };
 
    memset(szResult, '0', STR_MAX_LEN);
    memset(szInput, '0', STR_MAX_LEN);
    memset(szInput2, '0', STR_MAX_LEN);
 
    for (int32_t i = STR_MAX_LEN_INDEX; 1 < i; --i)
    {
        szResult[i] = itoc(rand() % 10);
        /*if (i == STR_MAX_LEN_INDEX)*/
            szInput[i] = itoc(rand() % 10);
    }
 
    strcpy(szInput2, szResult);
    QueryPerformanceCounter(&start);
    Output(szInput2);
    printf(" + ");
    Output(szInput);
    printf(" = ");
    if (!Plus(szResult, szInput))
        printf("Out of Bounds\n");
    else
        Output(szResult);
    QueryPerformanceCounter(&end);
    fDeltaTime = (end.QuadPart - start.QuadPart)*1000.f / f.QuadPart;
    wprintf(u"걸린시간 :: %f m/s\n", fDeltaTime);
 
    strcpy(szResult, szInput2);
    QueryPerformanceCounter(&start);
    Output(szInput2);
    printf(" - ");
    Output(szInput);
    printf(" = ");
    if (!Minus(szResult, szInput))
        printf("Out of Bounds\n");
    else
        Output(szResult);
    QueryPerformanceCounter(&end);
    fDeltaTime = (end.QuadPart - start.QuadPart)*1000.f / f.QuadPart;
    wprintf(u"걸린시간 :: %f m/s\n", fDeltaTime);
 
    strcpy(szResult, szInput2);
    QueryPerformanceCounter(&start);
    Output(szInput2);
    printf(" * ");
    Output(szInput);
    printf(" = ");
    if (!Multiply(szResult, szInput))
        printf("Out of Bounds\n");
    else
        Output(szResult);
    QueryPerformanceCounter(&end);
    fDeltaTime = (end.QuadPart - start.QuadPart)*1000.f / f.QuadPart;
    wprintf(u"걸린시간 :: %f m/s\n", fDeltaTime);
 
    strcpy(szResult, szInput2);
    QueryPerformanceCounter(&start);
    Output(szInput2);
    printf(" / ");
    Output(szInput);
    printf(" = ");
    if (!Divide(szResult, szInput))
        printf("Out of Bounds\n");
    else
        Output(szResult);
    QueryPerformanceCounter(&end);
    fDeltaTime = (end.QuadPart - start.QuadPart)*1000.f / f.QuadPart;
    wprintf(u"걸린시간 :: %f m/s\n", fDeltaTime);
 
    system("pause");
}
 
int32_t ctoi(char _cChar)
{
    char cChar = _cChar;
    int32_t i = 0;
 
    if ('0' <= cChar && cChar <= '9')
        i = cChar - '0';
 
    return i;
}
 
char itoc(int32_t _iInt)
{
    int32_t iInt = _iInt;
    char cChar = '\0';
 
    if (0 <= iInt && iInt <= 9)
        cChar = iInt + '0';
 
    return cChar;
}
 
int32_t FindKey(char * _pSet)
{
    char* pSet = _pSet;
    int32_t cch = strlen(pSet);
    if (cch == 0)
        return STR_MAX_LEN;
    char Key[] = "123456789";
    int32_t iKeyOccur = strcspn(pSet, Key);
    return iKeyOccur;
}
 
int32_t MinKey(char * _pSet1, char * _pSet2)
{
    char* pSet1 = _pSet1, *pSet2 = _pSet2;
 
    int32_t Key1 = FindKey(pSet1);
    int32_t Key2 = FindKey(pSet2);
    int32_t keyDif = Key2 - Key1;
    if (keyDif <= 0)
        return Key2;
    return Key1;
}
 
int32_t iInput()
{
    //입력받고 버퍼청소하고 리턴
    int32_t iInput = 0;
    char cBuffer = '\0';
    scanf("%d%c", &iInput, &cBuffer);
    if (cBuffer != '\n')
        ClearBuffer();
 
    return iInput;
}
 
char * strInput()
{
    char* strInput = (char*)calloc(MAX_SIZE, sizeof(char));
    char cBuffer = '\0';
    char cset[] = "1234567890";                //key 값들
    scanf("%999s%c", strInput, &cBuffer);    //MAX_SIZE - 1 개까지 입력가능
    int32_t cch = strlen(strInput);            //문자열길이 저장
    if (cBuffer != '\n')
    {
        SAFE_FREE(strInput);
        ClearBuffer();
        return strInput;
    }
    int32_t iDigit = strspn(strInput, cset);    //cset에 입력된 문자만 카운트에서 리턴함
    if (iDigit != cch)                //숫자가 입력되지 않았다면
        SAFE_FREE(strInput); //다지워줌
    return strInput;
}
 
void ClearBuffer()
{
    char cBuffer = '\0';
    //버퍼지워주는 함수
    while ((cBuffer = getchar()) != '\n' && cBuffer != EOF);
}