N 진수를 입력받아서 N진수로 변환하기

메뉴입니다 초라합니다.

첫번째 메뉴를 선택해서 16진수를 3진수로 변환해 봤습니다.

다띄우기 모드입니다 10진수로 입력받아서 2진수부터 36진수까지 다띄웁니다.

광폭화 모드를 누르면

1부터 메모리가 허용하는선까지 2진수부터 36진수까지 쭈루루루루루룩 변환을 시도합니다.

프로그램의 흐름은

사용자로부터 몃진수 숫자 타입으로 입력받을건지 알아냅니다.

그다음 사용자로부터 그 진수의 숫자를 입력받습니다.

사용자가 올바른 진수형으로 입력했는지

배열 하나하나 검색합니다.

사용자가 제대로 입력했으면

어떤 진수형으로 변환하고싶어하는지 입력받은뒤

계산을 합니다

문자열로 입력된 숫자를 정수형으로 고쳐줍니다

그다음에 그 정수형으로 사용자가 원하는 진수형으로 변환해주고

그정수형을 다시 문자열로 바꿔준다음에

출력합니다.

아래는 코드입니다

코드 제일 밑에 실행파일 첨부했습니다.

#include <stdio.h>        //printf() scanf() NULL getchar() EOF
#include <stdlib.h>        //malloc() calloc() free() size_t atoi()
#include <stdbool.h>    //bool
#include <stdarg.h>        //va_list va_start va_arg var_end
#include <string.h>        //strlen()
#include <Windows.h>
 
#if defined(_WIN32) || defined(_WIN64)    ////윈도우용
#include <crtdbg.h>
#define CLEAR "cls"    
#else    ////리눅스&맥 용
#define CLEAR "clear"
#endif
 
 
#define MAX_SYSTEM 35 //2진수부터 36진수까지의 값을 저장할숫자
#define MAX_SIZE 32    //문자열 배열의 크기
 
//C11부터 추가된 _Generic() 라는 옛날에 출시된 신기술 입니다.
//비주얼 스튜디오에서 _Generic() 인식이 안되신다면
//컴파일러를 C11 지원이되는 컴파일러로 바꾸셔야합니다
//바꾸시는법은 제블로그에 설명되있습니다.
//변수의 타입에 작동하는 switch문 이라고 보시면 됩니다.
//모든 자료형을 구현해넣기보다 기본적인 서식자 3개만 판별하도록 하겠습니다.
#define GET_FMT_SPEC(T) _Generic((T), int*: "%d%c", float*: "%f%c", char*: "%31s%c")
 
enum TYPE_NAME    //자료 이름을 쉽게 가르키기위한 이넘문 입니다.
{
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_STR
};
 
enum MAIN_MENU    //메뉴 평범한 모드와 광폭화모드
{
    MM_NONE,
    MM_NORMAL,
    MM_ALL,
    MM_BERSERK,
    MM_EXIT
};
 
void* Input(enum TYPE_NAME _eType, ...);    //입력값의 주소를 반환하고 입력타입과 변수의 주소를 넘기면 됩니다.
void Run();        //Run() 함수에서 프로그램의 로직을 돌리겠습니다.
void Display();    //Display() 함수는 전광판같은 존재로 결과값을 출력합니다.
int Menu();        //Menu() 함수는 사용자에게서 메뉴를 출력하고 선택받은 값을 리턴합니다.
bool Proceed();    //Procced() 함수는 메뉴가 잘입력 됬을경우 진행하는 함수입니다.
bool Check(char* _strInput);    //Check() 함수는 입력값이 정상인지 확인합니다.
void Reset(char* _strInput);    //문자열을 리셋하는 함수입니다.
int ctoi(char _cChar);        //문자를 정수로 변환하는 함수입니다.
char itoc(int _iInt, int _iNumberSystem);        //숫자를 숫자문자로 보이게 합니다.
void ConvertToDec();        //입력받은 N진수의 숫자를 10진수로 변환합니다
//변환하고싶은 진수, 변환될 10진수 형태의 정수, 결과가 저장될 문자열배열, 문자열배열을 기억할 인덱스 정수
void Calculate(const int _iDesiredSystem, const int _iDecimal, char* const _pResult);
void Output(char* _strInput);    //문자열을 입력받으면 출력해줍니다.
void Normal();                    //노말모드
void Berserk();                    //광폭화 모드
void All();                        //다띠우기 모드
void Button(void(*fpMode)());
 
//전역변수
static int g_iNumberSystem = 0;                //사용자가 선택한 진수를 저장할 변수 입니다.
static int g_iDesiredSystem = 0;            //사용자가 변환하고자하는 진수를 입력받습니다.
static char g_strInput[MAX_SIZE] = { 0 };    //사용자에게서 숫자를 입력받고 문자열로 저장합니다.
static int g_iPointIndex = 0;                //문자열의 .을 저장할인덱스 입니다.
static int g_iStrtoDec = 0;                    //문자열에서 정수로 변경된 정수
static char g_strResult[MAX_SIZE] = { 0 };  //10진수에서 N진수로 변환된 숫자들이 하나하나 저장될 배열
 
//N 진법의 소수를 입력받아서 N 진법으로 변환하는 프로그램을 만들어 보겠습니다.
int main()
{
#if defined(_WIN32) || defined(_WIN64)    //윈도우용 메모리릭 검사
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    //_CrtSetBreaAlloc();
#else    //타 OS에서 컴파일시 메모리릭 라이브러리를 찾아 검사 해주세요.
#endif
    system("mode con cols=80 lines=40");
 
    Run();        //딱히 초기화할게없어서 그냥 바로 구동하겠습니다.
 
    return 0;    //종료
}
 
//TYPE_NAME 의 자료형과 매개변수의 자료형이 꼭 매치가 되야 합니다.
void* Input(enum TYPE_NAME _eType, ...)
{
    //제일먼저 인자들을 지역변수에 저장해둡니다.
    //지역변수에 따로저장해두면 코드수정에 용의해집니다.
    enum TYPE_NAME eType = _eType;
 
    va_list args;                //... 에 입력될 변수들의 리스트 입니다.
    va_start(args, _eType);        //첫번째 인자는 args 넣어주시고 두번째는 끝함수인자를 넣어주시면됩니다
 
    void* pData = NULL;    //변수의 주소값을 저장한후 나중에 반환할 변수
    char cBuffer = 0;    //정수를 입력받을때 문자가 섞여있는지 판단해줄 변수
 
    switch (eType)
    {
    case TYPE_INT:                                     //swtich문으로 자료형별로 대응합니다.
    {                                                 //va_args는 다음 인자를호출해주는 녀석 입니다.
        int* pInt = va_arg(args, int*);                 //scanf 는 입력이 잘된 갯수만큼 그정수를 리턴해줍니다
        scanf(GET_FMT_SPEC(pInt), pInt, &cBuffer);
        if (cBuffer != '\n')
            *pInt = 0;                                //버퍼에 개행문자가 입력됬다면 잘입력된겁니다.
        pData = pInt;                                //주소값을 저장한후 리턴합니다.
    }
    break;
    case TYPE_FLOAT:
    {
        float* pFloat = va_arg(args, float*);
        scanf(GET_FMT_SPEC(pFloat), pFloat, &cBuffer);
        if (cBuffer != '\n')
            *pFloat = 0.f;
        pData = pFloat;
    }
    break;
    case TYPE_STR:
    {
        char* pStr = va_arg(args, char*);
        scanf(GET_FMT_SPEC(pStr), pStr, &cBuffer);
        if (cBuffer != '\n')
        {
            int iSize = strlen(pStr);
            for (int i = 0; i < iSize; ++i)
                pStr[i] = '0';
        }
        pData = pStr;
    }
    break;
    }
 
    //C++ Template 처럼 해보고싶었지만 시간이 많이 필요할것 같습니다.
    //함수포인터로 콜백 형식으로 만들어도 될것 같은데
    //근본적으로 자료형으로 하나하나 일일이 만들어주기가 힘듭니다.
    //scanf 함수의 예외처리에 대응하기 위해서 scanf를 랩핑하는 형식으로 코드를 짜봤습니다.
 
    if (cBuffer != '\n')
    {
        while ((cBuffer = getchar()) != '\n' && cBuffer != EOF)
            continue;    //cBuffer가 개행이아니면 뭔가 잘못됬다는거고 버퍼를 청소합니다.
    }
    va_end(args);        //스택을 정렬해줍니다.
 
    return pData;        //편의를위해 보이드 포인터 주소값도 리턴해주겠습니다.
}
 
void Run()
{
    while (true)
    {
        switch (Menu())    //메뉴선택입니다.
        {
        case MM_NORMAL:
            Button(Normal);
            break;
        case MM_ALL:
            Button(All);
            break;
        case MM_BERSERK:
            Button(Berserk);
            break;
        case MM_EXIT:
            return;
        }
    }
}
 
void Display()
{
    //전역변수를 지역변수에 저장합니다.
    const int iNumberSystem = g_iNumberSystem;
    const int iDesiredSystem = g_iDesiredSystem;
    const char* const pInput = g_strInput;
    const char* const pResult = g_strResult;
    printf("============ 진 수 변 환 기 ===============\n");
    printf("현재 선택된 진수(Number System) :: %d 진수\n", iNumberSystem);
    printf("입력값 :: %s\n", pInput);
    printf("변환에 선택된 진수(Number System) :: %d 진수\n", iDesiredSystem);
    Output(pResult);
    printf("\n");
    printf("===========================================\n");
}
 
int Menu()
{
    system(CLEAR);
    printf("메뉴를 선택하세요.\n");
    printf("%d. N진수를 N진수로 변환.\n", MM_NORMAL);
    printf("%d. 다띄우기 모드.\n", MM_ALL);
    printf("%d. 광폭화 모드\n", MM_BERSERK);
    printf("%d. 종료\n", MM_EXIT);
    int iInput = 0;    //입력값을 저장할 변수
    Input(TYPE_INT, &iInput);
    if (iInput <= 0)    return 0;
    return iInput;    //잘통과 됬으면 값을 리턴합니다.
}
 
bool Proceed()
{
    //전역변수를 지역변수에 받아옵니다.
    const int iNumberSystem = g_iNumberSystem;
    int* const pDesiredSystem = &g_iDesiredSystem;
    char* pInput = g_strInput;
    //전역변수 끝
 
 
    char strInput[MAX_SIZE] = { 0 };
    while (true)
    {
        printf("%d 진수 형식의 숫자를 입력해주세요.\n", iNumberSystem);
        Input(TYPE_STR, strInput);
        if (!Check(strInput))
        {
            Reset(strInput);    //잘못된 숫자면 다시시작합니다.
            continue;
        }
        else
        {
            memcpy(pInput, strInput, strlen(strInput));    //복사후 종료
            break;
        }
    }
 
    int iDesiredSystem = 0;
    while (true)
    {
        printf("몃진수로 숫자를 변환할까요?.\n");
        Input(TYPE_INT, &iDesiredSystem);
        if (iDesiredSystem == iNumberSystem)
        {
            printf("같은 진수형 입니다.\n");
            iDesiredSystem = 0;
            continue;
        }
        else if (iDesiredSystem < 2)
        {
            printf("2진수 이상이여야 합니다.\n");
            iDesiredSystem = 0;
            continue;
        }
        else
        {
            *pDesiredSystem = iDesiredSystem;
            break;
        }
    }
    return true;
}
 
bool Check(char* _strInput)
{
    //전역변수를 지역변수화 해줍니다.
    const int iNumberSystem = g_iNumberSystem;
    char* pInput = _strInput;
    int* const pPointIndex = &g_iPointIndex;
 
    int iLength = strlen(pInput);    //문자열의 길이를 받아옵니다.
    int iConverted = 0;                //변환값
    int iPointIndex = 0;
 
    for (int i = 0; i < iLength; ++i)
    {
        iConverted = ctoi(pInput[i]);    //변환해서 저장해준후 사용합니다.
 
        if (iConverted == '.')    //만약 현재자릿수가 소수점 . 이라면
        {
            iPointIndex = i;    //저장합니다
        }
        else if (iConverted < 0 || iNumberSystem <= iConverted)
        {
            printf("%d 진수의 숫자가 아닙니다.\n", iNumberSystem);
            return false;
        }
    }
 
    //값전달후 종료
    *pPointIndex = iPointIndex;
    return true;
}
 
void Reset(char* _strInput)        //문자열을 0으로 초기화합니다
{
    char* const pInput = _strInput;
    int iLength = strlen(pInput);
    for (int i = 0; i < iLength; ++i)
    {
        pInput[i] = 0;
    }
}
 
int ctoi(char _cChar)
{
    char cChar = _cChar;    //인자를 지역변수에 저장합니다.
    int iConverted = 0;        //변환값을 저장할 변수입니다.
 
    if ('0' <= cChar && cChar <= '9')
    {
        iConverted = cChar - '0';    //문자열 '0' 을 빼준뒤
                                    //문자열 '0'은 정수 48입니다.
                                    //반환합니다
    }
    else if ('A' <= cChar && cChar <= 'Z')    //만약 문자열이 A-Z 사이라면 이렇게 변환해줍니다.
    {                                        //'A' 를 빼주고 10을 더합니다.
        iConverted = 10 + cChar - 'A';        //'A' 는 10을 가르킵니다
                                            //'A'일때 'A' 를 빼주고 10을 더해주면 정수로 10이 됩니다.
    }
    else
        iConverted = cChar;    //변환이 안되는거면 걍 그값을 반환합니다.
 
    return iConverted;
}
 
char itoc(int _iInt, int _iNumberSystem)
{
    int iInt = _iInt;    //인자를 지역변수에 저장
    const int iDesiredSystem = _iNumberSystem;    //지역변수 저장
 
    char cConverted = 0;    //변환될 값이 저장될 변수
 
    if (0 <= iInt && iInt <= 9)
    {
        cConverted = iInt + '0';    //'0' 48을 더해줍니다.
    }
    else if ((10 <= iInt && iInt <= MAX_SYSTEM) && 10 < iDesiredSystem)
    {
        cConverted = iInt + 55;    //55를 더해주면 그에 상응하는 문자로 변환됩니다
    }                            // 'A' 는 65 입니다.
    else
        cConverted = iInt;    //변환이안되면 그냥 그 정수값을 반환합니다.
 
    return cConverted;
}
 
void ConvertToDec()
{
    //전역변수받아서 지역변수로 바꿔줍니다.
    const int iNumberSystem = g_iNumberSystem;        //몃진수로 입력받았는지 기억하고있는 변수
    const char* const pInput = g_strInput;            //사용자가 입력한 문자형타입의 숫자
    int* const pStrtoDec = &g_iStrtoDec;            //문자열 정수로 변환된 변수가 저장될 변수
    //전역변수 끝
 
    int iStrtoDec = 0;                                //변환된 값이 저장될 변수
    int iLength = strlen(pInput);                    //입력받은 숫자의 문자열의 길이를 구합니다.
 
    //------------------입력받은 N진수를 10진수로 변환해주는 과정
    if (iNumberSystem != 10)                        //입력받은 숫자형이 10진수가아니면
    {                                                //10진수로 변환해줍니다.
        int iDecimal = 0;
        int iConverted = 0;                            //for 문을 돌리겠습니다.
        for (int i = 0; i < iLength; ++i)            //문자열의 0번째부터 변환을 시작합니다.
        {
            iDecimal = 1;                                //iDecimal은 항상 1로 초기화시켜 줍니다
            iConverted = ctoi(pInput[i]);                //첫번재 문자열의 문자를 숫자로 바꿔줍니다.    
            for (int j = iLength - 1 - i; 0 < j; --j)    //그진수의 N승 번만큼 for문을 돌려서 곱해줍니다.
            {
                iDecimal *= iNumberSystem;
            }
            iConverted *= iDecimal;                        //다 곱한다음에 iConverted와 더해줍니다.
            iStrtoDec += iConverted;                    //변환값들을 iStrtoDec에 누적합니다.
        }
    }
    else
        iStrtoDec = atoi(pInput);    //10진수라면 atoi 함수로 해결
 
    *pStrtoDec = iStrtoDec;    //변환된값을 넘겨줍니다    
}
 
void Calculate(const int _iDesiredSystem, const int _iDecimal, char* const _pResult)
{
    //전역변수와 인자들을 지역변수에 저장
    const int iDesiredSystem = _iDesiredSystem;    //사용자가 몃진수로 변환할지를 알고있는 변수
    const int iPointIndex = g_iPointIndex;        //소수점이 입력됬다면 소수점의 위치를 알고있는 숫자.    
    int const StrtoDec = _iDecimal;            //문자열에서 정수로 변환된 정수를 가리키는 포인터
    char* const pResult = _pResult;            //변환된값을 저장할 변수;
 
    //전역변수 끝
 
    int iStrtoDec = StrtoDec;                    //변환된 숫자의 자릿수를
    char cConvertedArr[MAX_SIZE] = { 0 };        //하나하나 배열에 저장해둘것입니다.                
 
 
    int iIndex = 0;                                //배열의 인덱스                            
    while (iDesiredSystem <= iStrtoDec && iIndex < MAX_SIZE - 2)
    {
        cConvertedArr[iIndex] = itoc(iStrtoDec % iDesiredSystem, iDesiredSystem);
        ++iIndex;
        iStrtoDec /= iDesiredSystem;
    }
    cConvertedArr[iIndex] = itoc(iStrtoDec, iDesiredSystem);    //마지막숫자를 마지막 인덱스에 저장해줍니다.
    memcpy(pResult, cConvertedArr, MAX_SIZE);        //마무리로 배열을 복사해줍니다
    g_iStrtoDec = iStrtoDec;
}
 
void Output(char * _strInput)    //문자열 출력기 뒤에서부터 출력합니다
{
    const char* const pInput = _strInput;
    int iIndex = strlen(pInput);
    for (int i = iIndex - 1; 0 <= i; --i)
    {
        printf("%c", pInput[i]);
    }
}
 
void Normal()
{
    //전역변수를 지역변수에 저장해둡니다.
    int* const pNumberSystem = &g_iNumberSystem;
 
    int iInput = 0;
    while (true)
    {
        system(CLEAR);
        Display();
        printf("입력하실 진수를 정해주세요. (2~36진수) ");
        printf("100입력 하면 뒤로가기.\n");
        Input(TYPE_INT, &iInput);
        if (iInput == 100) break;
        else if (iInput < 2 || 36 < iInput)    // 2부터 35까지 진수까지만 되게합니다
            continue;                        //알파펫 A~-Z 까지 총 26개입니다
        *pNumberSystem = iInput;                //값 전달
 
        if (!Proceed())    continue;            //메뉴가 잘 입력됬다면 진행합니다.
        ConvertToDec();                        //먼저 N진수를 10진수로 변환하는 함수를 호출합니다.
        Calculate(g_iDesiredSystem, g_iStrtoDec, g_strResult);        //계산합니다.
    }
}
 
void Berserk()
{
    //32 문자열을 저장할수있는 35개의 배열 생성
    char** System = NULL;
    char *Systems[MAX_SYSTEM] = { NULL };
    char strResult[(MAX_SYSTEM)* MAX_SIZE] = { NULL };
    System = Systems;
    System[0] = strResult;
    for (int i = 1; i < MAX_SYSTEM; ++i)
    {
        System[i] = System[i - 1] + MAX_SIZE;
    }
    //2차원 배열로
    //한줄의 큰 1차원 배열에 각각의 주소를 저장함
 
    int iDesiredSystem = 2;
    int iStart = 1;
    int iShowSystem = MAX_SYSTEM;
    //j < 10000
    for (int j = iStart; ; ++j)
    {
        iDesiredSystem = 2;
        for (int i = 0; i < MAX_SYSTEM; ++i)
        {
            Calculate(iDesiredSystem, j, System[i]);
            ++iDesiredSystem;
        }
        system(CLEAR);
        printf("미쳐버린 계산기\n");
        for (int i = 0; i < iShowSystem; ++i)
        {
            printf("%d. 진수 :: ", i + 2);
            Output(System[i]);
            printf("\n");
        }
    }
}
 
void All()
{
    //32 문자열을 저장할수있는 35개의 배열 생성
    char** System = NULL;
    char *Systems[MAX_SYSTEM] = { NULL };
    char strResult[(MAX_SYSTEM)* MAX_SIZE] = { NULL };
    System = Systems;
    System[0] = strResult;
    for (int i = 1; i < MAX_SYSTEM; ++i)
    {
        System[i] = System[i - 1] + MAX_SIZE;
    }
    //2차원 배열로
    //한줄의 큰 1차원 배열에 각각의 주소를 저장함
 
    int iStart = 0;
    int iShowSystem = MAX_SYSTEM;
    int iDesiredSystem = 0;
    while (true)
    {
        system(CLEAR);
        printf("미쳐버린 계산기\n");
        printf("다띄우기모드.\n");
        printf("10진수로된 수를 입력해주세요.\n");
        Input(TYPE_INT, &iStart);
        if (iStart == 0) continue;
 
        iDesiredSystem = 2;
        for (int i = 0; i < MAX_SYSTEM; ++i)
        {
            Calculate(iDesiredSystem, iStart, System[i]);
            ++iDesiredSystem;
        }
 
        for (int i = 0; i < iShowSystem; ++i)
        {
            printf("%d. 진수 :: ", i + 2);
            Output(System[i]);
            printf("\n");
        }
        system("pause");
    }
 
}
 
void Button(void(*fpMode)())
{
    fpMode();
}
 

Converter.exe

하다가 주석도 마지막엔 달다말다하고

엉망징창이 되버렸습니다.

소수도 진수로 변환하는 기능을 넣을려고했는데

너무 피곤해서 진수변환은 여기까지만하고 다음 프로젝트로 넘어가야겠네요

소수부분을 진수변환하는 공식을 추가하기만 하면 됩니다.