OPZ

#define _CRT_SECURE_NO_WARNINGS
/*#include <iostream>
#include <stdio.h>
#include <stdlib.h>

struct stackNode {
    int data;
    struct stackNode* nextPtr;
};

typedef struct stackNode StackNode;
typedef StackNode* StackNodePtr;

void push(StackNodePtr*, int);
int pop(StackNodePtr*);
int isEmpty(StackNodePtr);
void printStack(StackNodePtr);
void instructions(void);

int main()
{
    StackNodePtr stackPtr = NULL;
    int choice, value;
    instructions();
    printf("? ");
    scanf("%d", &choice);

    while (choice != 3) {

        switch (choice) {
        case 1: //затолкнуть значение в стек
            printf("Enter an integer: ");
            scanf("%d", &value);
            push(&stackPtr, value);
            printStack(stackPtr);
            break;
        case 2: //вытолкнуть значение из стека
            if (!isEmpty(stackPtr))
                printf("The popped value is %d.\n", pop(&stackPtr));
            printStack(stackPtr);
            break;
        default:
            printf("invalid choice. \n\n");
            instructions();
            break;
        }

        printf("? ");
        scanf("%d", &choice);
    }

    printf("End of run.\n");
    return 0;
}

//вывести инструкцию
void instructions(void) {
    printf("Enter choice:\n"
        "1 to push a value off the stack\n"
        "2 to pop a value of the stack\n"
        "3 to end prorham\n");
}

//вставить значение на вершине стека

void push(StackNodePtr* topPtr, int info) {
    StackNodePtr newPtr;

    newPtr = (StackNode*)malloc(sizeof(StackNode));
    if (newPtr != NULL) {
        newPtr->data = info;
        newPtr->nextPtr = *topPtr;
        *topPtr = newPtr;
    }
    else
        printf("%d not inserted. No memory available.\n", info);
}

//удалить узел на вершине стека

int pop(StackNodePtr* topPtr) {
    StackNodePtr tempPtr;
    int popValue;

    tempPtr = *topPtr;
    popValue = (*topPtr)->data;
    *topPtr = (*topPtr)->nextPtr;
    free(tempPtr);
    return popValue;
}
//распечатать стек
void printStack(StackNodePtr currentPtr) {
    if (currentPtr == NULL)
        printf("The stack is empty.\n\n");
    else {
        printf("The stack is:\n");

        while (currentPtr != NULL) {
            printf("%d --> ", currentPtr->data);
            currentPtr = currentPtr->nextPtr;
        }

        printf("NULL\n\n");
    }
}
//стек пуст
int isEmpty(StackNodePtr topPtr) {
    return topPtr == NULL;
}*/

#include <iostream>
#include <string>
using namespace std;
const int n = 20;
/*
//НАША СТРУКТУРА
struct List
{
    char x;                                              //информационный элемент
    List* Next, * Head;                                   //Голова стека и указатель на следующий элемент
};

//ФУНКЦИЯ ДОБАВЛЕНИЯ ЭЛЕМЕНТА В СТЕК (в список LIFO)
void push(char x, List*& MyList)                          //Принимаем элемент стека и указатель на стек, при этом говорим, что принимаемый указатель будет сам по себе указателем
{
    List* temp = new List;                              //Выделяем память для нового элемента
    temp->x = x;                                        //Записываем в поле x принимаемый в функцию элемент x
    temp->Next = MyList->Head;                          //Указываем, что следующий элемент это предыдущий
    MyList->Head = temp;                                //Сдвигаем голову на позицию вперед
}

void pop(List*& MyList)
{
    int temp = Next->x;                 // извлекаем в переменную temp значение в вершине стека
    List* MyStack = Next;                   // запоминаем указатель на вершину стека, чтобы затем
                                            // освободить выделенную под него память
    Next = Next->Next;                      // вершиной становится предшествующий top элемент
    delete MyStack;                         // освобождаем память, тем самым удалили вершину
    std::cout << temp;                      //Вывод текущего элемента на экран
}

//ФУНКЦИЯ ОТОБРАЖЕНИЯ СТЕКА
void Show(List* MyList)                                 //Нужен только сам стек
{
    List* temp = MyList->Head;                          //Объявляем указатель и Указываем ему, что его позиция в голове стека
    //с помощью цикла проходим по всему стеку
    while (temp != NULL)                                //выходим при встрече с пустым полем
    {
        cout << temp->x << " ";                         //Выводим на экран элемент стека
        temp = temp->Next;                              //Переходим к следующему элементу
    }
}

//ФУНКЦИЯ УДАЛЕНИЯ СТЕКА ИЗ ПАМЯТИ
void ClearList(List* MyList)
{
    while (MyList->Head != NULL)                        //Пока по адресу не пусто
    {
        List* temp = MyList->Head->Next;                    //Временная переменная для хранения адреса следующего элемента
        delete MyList->Head;                                //Освобождаем адрес обозначающий начало
        MyList->Head = temp;                                //Меняем адрес на следующий
    }
}

int main()
{
    List* MyList = new List; //Выделяем память для стека


    MyList->Head = NULL; //Во избежание ошибок инициализируем первый элемент


    char flag = 'a';
    while (flag != '0') {
        cin >> flag;
        push(flag, MyList);
    }

    pop(MyList);
    pop(MyList);
    pop(MyList);

    Show(MyList); //Выводим стек на экран

    ClearList(MyList); //Очищаем память.
    delete MyList->Head;
    delete MyList;
} */

/*
int main()
{
    stek* p = 0;
    int voice = 10;
    char str[10];
    char out[10];
    int j = 0;
    scanf("%s", str);
    int len = strlen(str);
    for (int i = 0; i < len; i++)
        if (str[i] > '0' && str[i] <= '9') {
            out[j] = str[i];
            j++;
        }
        else switch (str[i]) {
        case '+':   push(p, str[i]); break;
        case '-':   push(p, str[i]); break;
        case '*':   push(p, str[i]); break;
        case '/':   push(p, str[i]); break;
        default:
            cout << "undefined operatop " << str[i] << endl;
            return 0;

        }



    char ch;
    while (voice!=0)
    {
        printf("Input char\n");
        //scanf("%c", &ch);
        //std::cin >> ch;
         ch = getchar();
        push(p, ch);
        voice--;
    }                               //вывели на экран текущий элемент стека = 100
    voice = 10;
    while (voice != 0) {
        pop(p);
        voice--;
    }
    return 0;
}*/
struct stek
{
    char value;
    struct stek* next;                      // указатель на следующий элемент списка (стека)
};

bool empty(stek*& NEXT)
{
    if (NEXT == NULL) {
    //  std::cout << "Empty\n";
        return true;
    }
    return false;
}

void push(stek*& NEXT, char VALUE)
{
    stek* MyStack = new stek;               // объявляем новую динамическую переменную типа stek
    MyStack->value = VALUE;                 // записываем значение, которое помещается в стек
    MyStack->next = NEXT;                   // связываем новый элемент стека с предыдущим
    NEXT = MyStack;                         // новый элемент стека становится его вершиной
}
// извлекаем и возвращаем верхний элемент из стека
char pop(stek*& NEXT)
{
    if (empty(NEXT))
        return -1;
    char temp = NEXT->value;                 // извлекаем в переменную temp значение в вершине стека
    stek* MyStack = NEXT;                   // запоминаем указатель на вершину стека, чтобы затем
                                            // освободить выделенную под него память
    NEXT = NEXT->next;                      // вершиной становится предшествующий top элемент
    delete MyStack;                         // освобождаем память, тем самым удалили вершину
    //std::cout << temp;                      //Вывод текущего элемента на экран
    return temp;                            // возвращаем значение, которое было в вершине
}

//возвращает верхний элемент стека
char top(stek*& NEXT)
{
    char temp = NEXT->value;                 // извлекаем в переменную temp значение в вершине стека
    return temp;                             //возвращаем значение, которое было на вершине
}
inline int prior(char c) {
    switch (c) {
    case '(': return 1;
    case '+': case '-': return 2;
    case '*': case '/': return 3;
    default: return 0;
    }
}

void input(char a[]) {
    for (int i = 0; i < n; i++) {           //считываем инфиксную запись до "="
        cin >> a[i];
        if (a[i] == '=') {
            break;
        }
    }
}

int strlen1(char a[]) {
    int i = n - 1;
    while (a[i] > 0 && !a[i])
        i--;
    return i;

}

void inopz(char infix[],char postfix[], stek *&p) {
    int j = 0;
    int k = 0;
    while (infix[j] != '=') {
        if ((infix[j] >= 'A' && infix[j] <= 'Z') || (infix[j] >= 'a' && infix[j] <= 'z') || (infix[j] >= '0' && infix[j] <= '9')) {
            postfix[k] = infix[j];
            k++;
        }
        if (infix[j] == '+' || infix[j] == '-' || infix[j] == '*' || infix[j] == '/') {
            if (empty(p) || prior(infix[j]) > prior(p->value))
                push(p, infix[j]);
            else
            {
                while (!empty(p) && prior(infix[j]) <= prior(top(p))) {
                    postfix[k] = pop(p);
                    k++;
                }
                if (empty(p) || prior(infix[j]) > prior(p->value))
                    push(p, infix[j]);
            }
        }
        if (infix[j] == '(')
            push(p, infix[j]);
        if (infix[j] == ')') {
            while (top(p) != '(') {
                postfix[k] = pop(p);
                k++;
            }
            pop(p);
        }
        j++;
    }
    if (!empty(p))
        while (!empty(p)) {
            postfix[k] = pop(p);
            k++;
        }for (int i = 0; i < k; i++)
            cout << postfix[i];
}

int calculate(char post[], stek*& p) {
    int n1, n2, res;
    cout <<endl<<  strlen1(post)<< endl;
    int size = strlen(post);
    for (int i = 0; i < size; ++i) {
        if ((post[i] >= 'A' && post[i] <= 'Z') || (post[i] >= 'a' && post[i] <= 'z') || (post[i] >= '0' && post[i] <= '9')) {
            push(p, post[i]);
        }
        else {
            n2 = pop(p);
            n1 = pop(p);
            switch (post[i]) {
            case '+': res = n1 + n2; break;
            case '-': res = n1 - n2; break;
            case '*': res = n1 * n2; break;
            case '/': res = n1 / n2; break;
            default: cout << "ERORR !\n";
            }
            push(p, res);
        }
    }
    return pop(p);
}
int main()
{
    stek* p = 0;                            //создаем стек
    char infix[n];                          //масив инфиксной записи
    char postfix[n];                        //массив постфиксной записи
    input(infix);
    inopz(infix, postfix, p);
    cout << endl << strlen1(postfix) << endl;
    cout << calculate(postfix, p);

    return 0;
}