C언어 계산기 프로그램 5안(우선순위 괄호 계산기)

코드 정리...

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
int main()
{
    char formula[100];  // 입력받는 변수
    char copy[100];
    char* op_type = "()+-*/";
    int index = 0;      // 몇 개 입력받았는지
    int op_index;       // 연산자 숫자
    int result;
    char op[100];        //  연산자를  저장
    int num[100] = { 0, };        // 숫자를  저장
    int check_char = 0;
    int copy_num[100] = { 0 };
    char copy_op[100] = { 0, };
    int copy_op_index = 0;
    //bool op_ok = false;                 //for문중에 연산을 하였나 확인, 연산을 하였으면 true, 연산을 하지 않았으면 false
    bool step1 = false;                 // 숫자와 연산자 조건
    bool step2 = false;                 // 우선순위 연산
 
 
    printf("계산기 프로그램을 실행합니다.\n");
 
 
    for (;;)
    {
        printf("\n계산 식을 입력하시오 : ");
 
 
 
 
        //1. 입력이 되었는지
        for (;;)
        {
            if (strlen(formula) != 0)
            {
                gets_s(formula, sizeof(formula));
                memcpy(copy, formula, sizeof(formula));
            }
            else
            {
                printf("\n계산식이 입력되지 않았습니다. 다시 입력해주세요.");
            }
            break;
        }
 
 
        op_index = 0;
        result = 0;
 
 
        memset(copy_num, 0, sizeof(copy_num));
        memset(copy_op, 0, sizeof(copy_op));
        memset(op, 0, sizeof(op));
 
 
        // 2. 숫자와 연산자일때만 통과
        for (int i = 0; formula[i] != 0; i++)               //받은 데이터 하나하나 체크
        {
            if ((formula[i] >= 48 && formula[i] <= 57) || (formula[i] >= 40 && formula[i] <= 47)) //숫자와 연산자일때만 통과
            {
                step1 = true;
                break;
            }
            step1 = false;
            printf("\n숫자와 연산자만 입력해주세요.");
            break;
        }
        // 3. 연속되었는지 // 연산자 유무
        if (step1 == true)
        {
            for (int i = 0; ; i++)
            {
                index = strcspn(copy, op_type);             // 연산자의 index구하기
                if (index == 0)                             // index 0번째에 연산자가오면 중복된 연산자이므로 계산 break;
                {
                    printf("%s= 연산자가 중복되었습니다.", formula);
                    break;
                }
                if (strlen(copy) == index)                  // 연산자가 없으면(더이상 남아있지 않을 경우)
                {
                    num[i] = atoi(copy);                    // 마지막 숫자 저장, 
                    op_index = i;                           // 연산자의 개수
                    break;
                }
                op[i] = copy[index];                        // 연산자 저장
                num[i] = atoi(copy);                        // 숫자 저장
                memcpy(copy, &copy[index + 1], strlen(copy) - index);   // 저장된 연산자 이후부터 복사
            }
            // 데이터가 바뀌니까 유지를 위해 다시 복사본을 만듬
            memcpy(copy_num, num, sizeof(num));
            memcpy(copy_op, op, sizeof(op));
            copy_op_index = op_index;
            if (op_index == 0)                              // 연산자가 없을 때
            {
                printf("\n올바른 연산자를 다시 입력해주세요.");
            }
            else
            {
                //result = num[0];                          // 초기화. 맨 앞 숫자 무조건 저장. 이후 변할 값.
                step2 = true;                              // 연산 초기화
                //break;
            }
 
        }
        //4. 우선순위 연산 (우선순위1. 괄호, 우선순위2. 곱셈 나눗셈, 우선순위3. 덧셈, 뺼셈)
        if (step2 = true)
        {
            for (int i = 0; ;)                              // 연산자 세면서 연산 
            {
                step2 = false;                              // 연산확인 초기화
                if (i >= op_index)                          // 연산자보다 많이 돌아갔을 때
                {
                    break;
                }
                switch (op[i])                              // 연산자 종류
                {
                case '*':
                    num[i] = num[i] * num[i + 1];           // 확인하는 연산자의 앞과 뒤를 곱함
                    step2 = true;                           // 이번 for문에 연산 함
                    break;
                case '/':
                    if (num[i + 1] == 0)
                    {
                        printf("오류가 발생했습니다! 0으로 나눌 수 없습니다!\n");
                    }
                    else
                    {
                        num[i] = num[i] / num[i + 1];       // 확인하는 연산자의 앞과 뒤를 나눔
                        step2 = true;                       // 이번 for문에 연산함
                    }
                    break;
                }
                if (step2 == true)                          // -->곱셈이나 나눗셈을 --> 나눗셈연산을 없에야함
                {
                    for (int j = i; j <= op_index; )
                    {
                        if (j >= op_index) op[j] = 0;       //마지막 연산자를 없앰
                        else op[j] = op[j + 1];             // 연산자를 한칸씩 옴김
                        j++;
                        num[j] = num[j + 1];                // 옴겨진 연산자 뒤의 숫자를 옴김
                    }
                    op_index = op_index - 1;                // 연산을 한번 햇으니 기존 연산자를 뺌
                    step2 = false;                          // 연산자 확인을 초기화
                }
                else                                        // 연산자가 곱셈이나 나눗셈이 아닐경우
                {
                    i++;
                }
            }
            //우선순위 있는 연산자는 연산 종료, 우선순위 낮은 연산자 연산 시작
            result = num[0];
            for (int i = 0;; i++) // 
            {
                if (i >= op_index)
                {
                    break;
                }
                switch (op[i])
                {
                case '+':
                    result = result + num[i + 1];
                    break;
                case '-':
                    result = result - num[i + 1];
                    break;
                default:
                    printf("\n잘못된 연산자를 사용하였습니다.");
                    continue;
                }
            }
            for (int i = 0;;)                               // 입력받은 연산자만큼
            {
                printf("%d %c ", copy_num[i], copy_op[i]);  // 연산자 앞 숫자, 연산자
                i++;
                if (i >= copy_op_index)                     // 연산자 개수
                {
                    printf("%d = %d ", copy_num[i], result); // 연산자 이후 숫자와 연산값
                    break;
                }
            }
        }
    }
    return 0;
}
 

 

--> 미완성, 추가 중

--> 추가

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define size_max 100
 
char formula[size_max];  // 입력받는 변수
char copy[size_max];
 
int index = 0;      // 몇 개 입력받았는지
int op_index;       // 연산자 숫자
int result;
char op[size_max];        //  연산자를  저장
int num[size_max] = { 0, };        // 숫자를  저장
 
int copy_num[size_max] = { 0 };
char copy_op[size_max] = { 0, };
int copy_op_index = 0;
 
//bool step1 = false;                 // 숫자와 연산자 조건
bool step2 = false;                 // 우선순위 연산
 
int bracket_index = 0;      // 몇 개 입력받았는지
int bracket_start[size_max] = { 0 };// 괄호 시작부분
int bracket_end[size_max] = { 0 };//괄호 끝부분
 
int copy_bracket_index = 0;      // 몇 개 입력받았는지
int copy_bracket_start[size_max] = { 0 };
int copy_bracket_end[size_max] = { 0 };
 
 
bool copy_bracket_bool[size_max] = { false };   // 괄호 만큼 true로 변함
bool bracket_bool[size_max] = { false };  //괄호 갯수
 
char bracket_start_char = '(';
char bracket_end_char = ')';
 
void inputFormula(void)
{
    //1. 입력이 되었는지
    for (;;)
    {
 
        gets_s(formula, sizeof(formula));
 
        if (strlen(formula) != 0)
        {
            memcpy(copy, formula, sizeof(formula));
        }
        else
        {
            printf("\n계산식이 입력되지 않았습니다. 다시 입력해주세요.");
        }
        break;
    }
}
 
void operatorFormula()
{
 
    const char* op_type = "+-*/";
    // 3. 연속되었는지 // 연산자 유무 // 괄호 유무
    //if (step1 == true)
    //{
        bracket_index = 0;
        for (int i = 0; ; i++)          // 시작과 끝
        {
            int bracket_start_index = strcspn(copy, &bracket_start_char);       // 시작 괄호 인덱스 찾기
            if (bracket_start_index == 0)                   // 시작괄호 인덱스가 없으면 넘어감(있으면 들어감)
            {
                bracket_start[bracket_index] = i;   //인덱스 (인덱스가 있는경우
                bracket_bool[bracket_index] = true; //괄호가 있으면(찾으면) true(괄호 열린 횟수대로)
                memcpy(copy, &copy[1], strlen(copy));   // 저장된 연산자(ex.여는 괄호) 이후부터 복사
            }
            int bracket_end_index;
            bracket_end_index = 0;
 
            if (bracket_bool[bracket_index] == true)    //있으면 true
            {
                bracket_end_index = strcspn(copy, &bracket_end_char);   // )인덱스를 넣고(여는 괄호다음부터0)
                if (bracket_end_index == 0)     // )인덱스가 처음으로 오면
                {
                    printf("%s= 괄호에 관한 에러가 있습니다.", formula);
                    break;
                }
            }
 
 
            index = strcspn(copy, op_type);             // 연산자의 index구하기
            if (index == 0)                             // index 0번째에 연산자가오면 중복된 연산자이므로 계산 break;
            {
                printf("%s= 연산자가 중복되었습니다.", formula);
                break;
            }
            if (strlen(copy) == index)                  // 연산자가 없으면(더이상 남아있지 않을 경우)
            {
 
                if (bracket_bool[bracket_index] == true)        // 괄호 연산자
                {
                    bracket_end[bracket_index] = i;
                    bracket_index++;
                }
                num[i] = atoi(copy);                    // 마지막 숫자 저장, 
                op_index = i;                           // 연산자의 개수
                break;
 
            }
            op[i] = copy[index];                        // 연산자 저장
            num[i] = atoi(copy);                        // 숫자 저장
 
 
            if ((bracket_bool[bracket_index] == true) && (index > bracket_end_index))   // 괄호연산자가 있으며, 끝나는 괄호보다 연산자 인덱스가 클경우
            {
                bracket_end[bracket_index] = i;
                bracket_index++;
            }
 
            memcpy(copy, &copy[index + 1], strlen(copy) - index);   // 저장된 연산자 이후부터 복사
        }
 
 
        // 데이터가 바뀌니까 유지를 위해 다시 복사본을 만듬
        memcpy(copy_num, num, sizeof(num));
        memcpy(copy_op, op, sizeof(op));
        memcpy(copy_bracket_start, bracket_start, sizeof(bracket_start));
        memcpy(copy_bracket_end, bracket_end, sizeof(bracket_end));
        memcpy(copy_bracket_bool, bracket_bool, sizeof(bracket_bool));
 
 
        copy_op_index = op_index;
        copy_bracket_index = bracket_index;      // 몇 개 입력받았는지
 
 
        if (op_index == 0)                              // 연산자가 없을 때
        {
            printf("\n올바른 연산자를 다시 입력해주세요.");
        }
        else
        {
            step2 = true;                              // 연산 초기화
 
        }
 
    //}
}
 
void strTest()
{
 
    // 2. 숫자와 연산자일때만 통과
 
    for (int i = 0; formula[i] != 0; i++)               //받은 데이터 하나하나 체크
    {
        if (formula[i] >= 40 && formula[i] <= 57) //숫자와 연산자일때만 통과
        {
 
            operatorFormula();
            //step1 = true;
            continue;
            //break;
        }
        //step1 = false;
        printf("\n숫자와 연산자만 입력해주세요.");
        break;
    }
}
 
 
 
 
void printfFormula()
{
    int bracked_count = 0;
    for (int i = 0; i <= copy_op_index; i++)                               // 입력받은만큼 출력
    {
        if (copy_bracket_bool[bracked_count] == true)
        {
            if (copy_bracket_start[bracked_count] == i)
            {
                printf("(");
            }
        }
        printf("%d", copy_num[i]);  // 연산자 앞 숫자, 연산자
        if (copy_bracket_bool[bracked_count] == true)
        {
            if (copy_bracket_end[bracked_count] == i)
            {
                printf(")");
                bracked_count++;
            }
        }
 
        if (i < copy_op_index)                     // 연산자 개수
        {
            printf(" %c ", copy_op[i]); // 연산자 이후 숫자와 연산값
 
        }
 
        if (i == copy_op_index)                     // 연산자 개수
        {
            printf("= %d ", result); // 계산한 값 출력
            //오류 == 0 ->무시  printf("%s = %d ",formula, result); 
            break;
        }
 
    }
}
 
 
void allOperatorFormula()
{
    //4. 우선순위 연산 (우선순위1. 괄호, 우선순위2. 곱셈 나눗셈, 우선순위3. 덧셈, 뺼셈)
    if (step2 = true)
    {
 
        //괄호 연산
        for (int b = 0; b < bracket_index; b++)
        {
            int start = bracket_start[b];       // 첫번째 연산자 인덱스 == 0 괄호 시작 인덱스
            int end = bracket_end[b];           // 두번째 연산자 인덱스 == 0 괄호 끝 인덱스
 
            for (int i = start; ;)                              // 괄호안의 연산자 세면서 연산 
            {
                step2 = false;                              // 연산확인 초기화
 
                if (i >= end)                          // 닫는 괄호 인덱스 클때
                {
                    break;
                }
 
                /*------------------------------------------------------------------------------*/
                switch (op[i])                              // 연산자 종류
                {
                case '*':
                    num[i] = num[i] * num[i + 1];           // 확인하는 연산자의 앞과 뒤를 곱함
                    step2 = true;                           // 이번 for문에 연산 함
                    break;
                case '/':
                    if (num[i + 1] == 0)
                    {
                        printf("오류가 발생했습니다! 0으로 나눌 수 없습니다!\n");
                    }
                    else
                    {
                        num[i] = num[i] / num[i + 1];       // 확인하는 연산자의 앞과 뒤를 나눔
                        step2 = true;                       // 이번 for문에 연산함
                    }
                    break;
                }
 
                if (step2 == true)                          // -->곱셈이나 나눗셈을 --> 나눗셈연산을 없에야함
                {
                    for (int j = i; j <= op_index; )
                    {
                        if (j >= op_index) op[j] = 0;       //마지막 연산자를 없앰
                        else op[j] = op[j + 1];             // 연산자를 한칸씩 옴김
                        j++;
                        num[j] = num[j + 1];                // 옴겨진 연산자 뒤의 숫자를 옴김
                    }
                    op_index = op_index - 1;                // 연산을 한번 햇으니 기존 연산자를 뺌
                    step2 = false;                          // 연산자 확인을 초기화
                    end--;
                }
                else                                        // 연산자가 곱셈이나 나눗셈이 아닐경우
                {
                    i++;
                }
            }
            //우선순위 있는 연산자는 연산 종료, 우선순위 낮은 연산자 연산 시작
            for (int i = start;; ) // 괄호 시작 인덱스
            {
                step2 = false;
 
                if (i >= end)   // 괄호 끝나면
                {
                    break;
                }
 
                switch (op[i])
                {
                case '+':
                    num[i] = num[i] + num[i + 1];           // 확인하는 연산자의 앞과 뒤를 곱함
                    step2 = true;
                    break;
                case '-':
                    num[i] = num[i] - num[i + 1];           // 확인하는 연산자의 앞과 뒤를 곱함
                    step2 = true;
                    break;
                default:
                    printf("\n잘못된 연산자를 사용하였습니다.");
                    continue;
                }
 
                if (step2 == true)                          // -->곱셈이나 나눗셈을 --> 나눗셈연산을 없에야함
                {
                    for (int j = i; j <= op_index; )
                    {
                        if (j >= op_index) op[j] = 0;       //마지막 연산자를 없앰
                        else op[j] = op[j + 1];             // 연산자를 한칸씩 옴김
                        j++;
                        num[j] = num[j + 1];                // 옴겨진 연산자 뒤의 숫자를 옴김
                    }
                    op_index = op_index - 1;                // 연산을 한번 햇으니 기존 연산자를 뺌
                    end--;
                    step2 = false;                          // 연산자 확인을 초기화
 
                }
                else                                        // 연산자가 곱셈이나 나눗셈이 아닐경우
                {
                    i++;
                }
 
            }
 
            int move = bracket_end[b] - bracket_start[b];   // 다른 연산자, 괄호가 남아있으니 그만큼 움직여 이동
            for (int bm = b + 1; bm < bracket_index; bm++)  //지금 연산한 괄호 외의 괄호 계산
            {
                bracket_start[bm] = bracket_start[bm] - move;
                bracket_end[bm] = bracket_end[bm] - move;
            }
        }
 
 
 
 
 
 
 
 
        for (int i = 0; ;)                              // 연산자 세면서 연산 
        {
            step2 = false;                              // 연산확인 초기화
            if (i >= op_index)                          // 연산자보다 많이 돌아갔을 때
            {
                break;
            }
            switch (op[i])                              // 연산자 종류
            {
            case '*':
                num[i] = num[i] * num[i + 1];           // 확인하는 연산자의 앞과 뒤를 곱함
                step2 = true;                           // 이번 for문에 연산 함
                break;
            case '/':
                if (num[i + 1] == 0)
                {
                    printf("오류가 발생했습니다! 0으로 나눌 수 없습니다!\n");
                }
                else
                {
                    num[i] = num[i] / num[i + 1];       // 확인하는 연산자의 앞과 뒤를 나눔
                    step2 = true;                       // 이번 for문에 연산함
                }
                break;
            }
            if (step2 == true)                          // -->곱셈이나 나눗셈을 --> 나눗셈연산을 없에야함
            {
                for (int j = i; j <= op_index; )
                {
                    if (j >= op_index) op[j] = 0;       //마지막 연산자를 없앰
                    else op[j] = op[j + 1];             // 연산자를 한칸씩 옴김
                    j++;
                    num[j] = num[j + 1];                // 옴겨진 연산자 뒤의 숫자를 옴김
                }
                op_index = op_index - 1;                // 연산을 한번 햇으니 기존 연산자를 뺌
                step2 = false;                          // 연산자 확인을 초기화
            }
            else                                        // 연산자가 곱셈이나 나눗셈이 아닐경우
            {
                i++;
            }
        }
        //우선순위 있는 연산자는 연산 종료, 우선순위 낮은 연산자 연산 시작
        result = num[0];
        for (int i = 0;; i++) // 
        {
            if (i >= op_index)
            {
                break;
            }
            switch (op[i])
            {
            case '+':
                result = result + num[i + 1];
                break;
            case '-':
                result = result - num[i + 1];
                break;
            default:
                printf("\n잘못된 연산자를 사용하였습니다.");
                continue;
            }
        }
        
        printfFormula();
        
    }
}
 
int main()
{
 
    printf("계산기 프로그램을 실행합니다.\n");
 
 
    for (;;)
    {
        printf("\n계산 식을 입력하시오 : ");
 
        inputFormula();
 
 
        op_index = 0;
        result = 0;
 
 
        memset(copy_num, 0, sizeof(copy_num));
        memset(copy_op, 0, sizeof(copy_op));
        memset(op, 0, sizeof(op));
 
 
        strTest();
 
 
        allOperatorFormula();
        
    }
    return 0;
}
 

 

 

--> 교훈 : 처음부터 설계를 잘하자... 질문봇이되자