void stack_sub() /* Вычетание */
{
int a = stack_pop();
	stack_push( stack_pop() - a );
}

void stack_div() /* Деление */
{
int a = stack_pop();
	stack_push( stack_pop() / a );
}

Стековый калькулятор
На входе - строка, содержащая выражение в постфиксной записи.
На выходе - результат вычислений.

Пример:
вход:
1 23 + 4 -
5 1 - *  
выход:
80

Должны поддерживаться следующие двухместные
арифметические операции:
+ - * /
Каждая из них берет аргументы со стека, сначала
первый, потом - второй, выполняет над ними действие
и результат помещает на вершину стека.

В качестве операндов допустимы как целочисленные константы, так и имена переменных.
Имя переменной может содержать символы A-Z,a-z,0-9,_, но начинаться с цифры не может.
Решение оформить в виде отдельного .c модуля, .h файл приведен ниже.
Предусмотреть корректную обработку ошибок.
Снабдить модульными тестами (unit-tests).

#ifndef EXEC_POSTFIX_H
#define EXEC_POSTFIX_H

/* типы лексем: константы, операции, имена переменных */
typedef enum { tt_CONST, tt_OPER, tt_ID } TokenType;

/* виды операций: сложение, вычитание, умножение, деление */
typedef enum { op_ADD, op_SUB, op_MUL, op_DIV } OperType;

/* максимальная длина имени переменной */
#define MAX_ID_LEN 40

typedef struct {
    TokenType ttype;
    union Value {
        /* с лексемой связано одно из следующих значений */
        int inum;
        OperType otype;
        char id[MAX_ID_LEN + 1];
    } tvalue;
} Token;

typedef struct {
    char id[MAX_ID_LEN + 1];
    int value;
} Variable;

/* перевести текстовую строку (s) в массив лексем (*tokens).
   получается массив длиной (*len).
   память под выходной массив выделяется внутри функции,
   а освобождается вызывающей стороной.
   в случае успеха вернуть 0, иначе какой-либо код ошибки. */
int tokenize(const char *s, Token **tokens, int *len);

/* вычислить переданное постфиксное выражение (postfix, длина - len),
   с использованем массива именованных переменных (vlist, длина vlen),
   результат записать в *result.
   в случае успеха вернуть 0, иначе какой-либо код ошибки. */
int execute_postfix(const Token *postfix, int len,
                    const Variable *vlist, int vlen, int *result);

#endif

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

using namespace std;

#define BUFFER_LENGTH 81

//Структура, которая будет хранить один элемент списка
struct Node
{
     int value;   //Значение элемента списка
     Node* next;  //Ссылка на следующее значение
};

/* Функции самого стека */
void stack_push(Node * beg, int key) /* Добавить элемент в стек */
{
     //Берем начальный элемент
     Node *tec = beg;
     //проходим все элементы списка до последнего...
     while (tec->next != NULL) tec = tec->next;
     //Создаем новый элемент
     Node * T = new Node;
     T->value = key;
     T->next = NULL;
     //Подключаем элемент в список в конец...
     tec->next = T;
}

int stack_pop(Node * beg) /* Извлечь элемент из стека */
{
    Node *tec = beg;
    if (tec->next == NULL)
    return -1;
    else
    {
        Node *prev = tec;
        while (tec->next != NULL)
        {
            prev = tec;
            tec = tec->next;
        }
        int a = tec->value;
        prev->next = NULL;
        return a;
    }
}

Node * stack_init() /* Начальная инициализация стека*/
{
    Node * T = new Node;
    T->next = NULL;
    T->value = -1;
     return T;
}

void Print(Node * beg)
{
     //Берем первый элемент списка
     Node *tec = beg;
    while (tec->next != NULL)
     {
          //Переходим на следующий элемент
          tec = tec->next;
        //Печатаем значение текущего элемента
          cout << tec->value << "   ";
     }
     cout << endl;
}

/* Функции стекового калькулятора */
void stack_add(Node * beg) /* Сложение */
{
    int a = stack_pop(beg);
    int b = stack_pop(beg);
    stack_push(beg, a + b);
}

void stack_sub(Node * beg) /* Вычетание */
{
    int a = stack_pop(beg);
    int b = stack_pop(beg);
    stack_push(beg, b - a );
}

void stack_mul(Node * beg) /* Умножение */
{
    int a = stack_pop(beg);
    int b = stack_pop(beg);
    stack_push(beg, a * b );
}

void stack_div(Node * beg) /* Деление */
{
    int a = stack_pop(beg);
    int b = stack_pop(beg);
    stack_push(beg, b / a );
}


/* Функции работы с пользователем */
void parse(Node *stack, char *str) /* Функция распознавания строки */
{
    char *st;
    st = strtok(str, " ");
     while (st != NULL)
     {
          switch(st[0])
          {
               case '.':
                    Print(stack);
                    break;
                  case '+':
                    stack_add(stack);
                    break;
               case '-':
                    stack_sub(stack);
                    break;
               case '*':
                    stack_mul(stack);
                    break;
               case '/':
                    stack_div(stack);
                    break;
               default:
                    stack_push(stack, atoi(st));
                    break;
          }
      st = strtok(NULL, " ");
     }
}


/* Главная функция */
int main()
{
    char buf[BUFFER_LENGTH];
    Node * stack = stack_init();

    printf( "Введите строки для вычисления:\n" );
    printf( "(для выхода введите строку, начинающуюся с символа '#')\n" );
    gets(buf);
    while (1)
    {
         if ((strlen(buf) > 0) && (buf[0] != '#'))
         {
               parse(stack, buf);
            cout << stack_pop(stack) << endl;
           }
        else return 0;
        gets(buf);
    }
    
}