Продвинутый калькулятор с


Меня попросили создать расширенный калькулятор в C, я называю это передовые, потому что он на самом деле обрабатывает арифметические правила. Было сказано, что мне не нужно обрабатывать исключения код и что я должен предположить, что кодекс юридическая помощь.

Он работает следующим образом:

  1. Введите число и нажмите Enter
  2. Введите оператор и нажмите клавишу Ввод, чтобы
  3. Для завершения ввода пользователя нажмите клавишу X и введите.

Опять же я говорю об этом, я предполагаю, что правильный ввод был введен в программу.

выч.ч

#pragma once

/*Sort the equation, deal with multipliers/divisors then sub and add, load it all in one array then recalculate */

/* Includes ******************************************************************/
#include <stdio.h>
#include <Windows.h>
/* Macros ********************************************************************/

/* Types *********************************************************************/

/* Global Variables *********************************************************/

/* Function Declarations *****************************************************/

/*Accept the equation as input and sort*/
void sort(IN int *numbers, IN char *operators);

/*Return result based on operator*/
int getOp(IN int a, IN int b, IN char op);

/*Create equation*/
void createEqu(IN int *numbers, IN char *operators);

/*Prints the equation*/
void print(IN int *numbers, IN char *operators);

/*Calculate array sum*/
void calSum(IN int *sorted, IN int length);

выч.с

/* Includes ******************************************************************/
#include "calc.h"

/* Macros ********************************************************************/

/* Types *********************************************************************/

/* Public Function Definitions ***********************************************/

/* Global Variables **********************************************************/

/*Create equation*/
void createEqu(IN int *numbers, IN char *operators)
{
    /*Intialize equation creater, 0 get number, 1 get operator*/
    int currentOperation = -1;

    /*Iterate through the arrays*/
    int n = 0;
    int o = 0;

    /*While equation input was not ended by user*/
    while (currentOperation != 2)
    {
        /*Number or operator*/
        if (currentOperation == -1)
        {
            printf("Enter number\n");
            scanf(" %d", &numbers[n]);

            /*If operator is negative, turn number into negative*/
            if (o != 0 && operators[o - 1] == '-')
            {
                numbers[n] = getOp(numbers[n], NULL, operators[o - 1]);
            }
            n++;
        }
        else
        {
            printf("Enter operator\n");
            scanf(" %c", &operators[o]);
            o++;
        }

        currentOperation = currentOperation*-1;
        /*check if the last operator was X to terminate equation input*/
        if (operators[o - 1] == 'X')
        {
            currentOperation = 2;
        }
    }

    /*Each array is terminated with NULL so it would be easy to read through them*/

    operators[o-1] = NULL;
    numbers[n] = NULL;
}

/*Prints the equation*/
void print(IN int *numbers, IN char *operators)
{
    int i = 0;
    for (;operators[i] != NULL; i++)
        printf("%c", operators[i]);
}

/*Return result based on operator*/
int getOp(IN int a, IN int b, IN char op)
{
    if (op == '*')
        return a * b;

    if (op == '/')
        return a / b;

    if (op == '+')
        return a;

    if (op == '-')
        return -a;
}

/*Calculate array sum*/
void calSum(IN int *sorted, IN int length)
{
    int i = 0;
    int finalRes = 0;

    for (; i <= length; i++)
    {
        printf("%d ", sorted[i]);
        finalRes += sorted[i];
    }

    printf("%d", finalRes);
}

/*Accept the equation as input and sort*/
void sort(IN int *numbers, IN char *operators)
{
    int sorted[256];

    /*Iterators of arrays*/
    int s = 0;
    int n = 0;
    int o = 0;

    /*While expression is not over*/
    while (operators[o] != NULL)
    {
        /*If operation is + or - then store integers in sorted array for later calculation*/
        if (operators[o] == '+' || operators[o] == '-')
        {
            /*Save both original numbers                                             */
            sorted[s] = numbers[n];
            sorted[s + 1] = numbers[n + 1];

            s++;
            n++;
            o++;
        }
        else
        {
            /*calculate mandatory expression result and store in next cell value*/
            numbers[n + 1] = getOp(numbers[n], numbers[n + 1], operators[o]);
            n++;
            o++;

            /*If last operation was mandatory by arithmetic rules (div or mul), and its the last operation store result in sorted array*/
            if (operators[o] == NULL)
            {
                sorted[s] = numbers[n];
            }
        }
    }

    calSum(sorted, s);
}

/* Private Function Definitions **********************************************/

главная.с

/* Includes ******************************************************************/
#include "calc.h"

/* Function Definitions ******************************************************/
INT wmain(IN SIZE_T nArgc, IN PCWSTR *ppcwszArgv)
{
    int numbers[256];
    char equ[256];

    createEqu(&numbers, &equ);
    sort(numbers, equ);
    getch();

    /* Succeeded */
    return 0;
}


195
5
задан 4 февраля 2018 в 09:02 Источник Поделиться
Комментарии
2 ответа


  1. Плохое использование NULL. В operators[o] != NULL, NULL это константа нулевого указателя лучше всего использовать указатели. operators[o] это charне указатель. Предлагаю ниже:

    // while (operators[o] != NULL)
    while (operators[o])
    // or
    while (operators[o] != '\0')

  2. Аналогичная проблема с NULL ниже. Не используйте NULL для обозначения нулевого символа.

    // getOp(numbers[n], NULL, operators[o - 1]);
    getOp(numbers[n], '\0', operators[o - 1]);

    // numbers[n] = NULL;
    numbers[n] = '\0';


  3. void print(IN int *numbers, IN char *operators) странно, что он никогда не использует numbers. Конечно, неправильные функции.

  4. Очень подозрительно по поводу правильности значения s в calSum(sorted, s);. Такие немногословные переменная теряет ясности в его роли.

Незначительные


  1. " " в scanf(" %d", &numbers[n]); не служат никакой цели. Код может быть упрощен до scanf("%d", &numbers[n]); и сохранить ту же функциональность.

  2. Код, который не превышает ширины представление является более четким и легче рассмотреть. (Код не требуется горизонтальная полосы прокрутки.)

  3. Я ожидал const для указателя на данные, которые не изменяются код. const лучше передает код умысла и позволяет выбрать оптимизацию.

       // void print(IN int *numbers, IN char *operators)
    void print(const int *numbers, const char *operators)

  4. Роль IN не определен и остается неясным.

2
ответ дан 6 февраля 2018 в 06:02 Источник Поделиться

Странное использование currentOperation в Calc.C: он является переменной состояния. Его значения должны быть государства, которые должны быть определены с #defines.

currentOperation = currentOperation*-1;

При этом изменяется из начального состояния -1 "работа-в-прогресс" государственного 1 а позже от государства 1 для государства -1. Почему бы не использовать задания, чтобы было понятно? Например:

#define STATE_0      -1
#define STATE_1 1
#define STATE_END 2


getOpэто странное имя "вам оператора/операции", где он calaculates в experssion. Не стоит calc или так лучше имя?

Кроме того, эта функция видит + и - как унарные и / и * в виде двоичных. Где/как бинарные + и ручкой?

1
ответ дан 6 февраля 2018 в 10:02 Источник Поделиться