Каталог :: Программирование и комп-ры

Курсовая: Калькулятор

Вступ
Сьогодні комп’ютери все більш і більш входять до нашого життя. Для їх
єфективного використання необхідні зручні і практичні програми, які
створюються на мовах програмування. Одна з таких поширювальних мов є мова Сі.
Сі – це мова програмування загального призначення, добре відома своєю
ефективністю, економічністю, і переносимістю. Вказані приорітети Сі
забезпечують добру якість розробки майже будь – якого виду програмного
продукту. Використання Сі в якості інстументальної мови дозволяє отримувати
швидкі і компактні програми. В більшості випадках програми, написані на Сі,
порівняні по швидкості з програмами, які написані на мові ассемблера. При
цьому вони мають кращу наглядність та їх легше супроводжувати.
Сі поєднує ефективність і потужність в відносно малій за розмірамі мові. Хоч
Сі не містить вмонтованих компонентів мови, виконуючих ввод – вивід, розподіл
пам’яті, маніпуляцій з екраном або управління процесами, однак, системне
оточення Сі має бібліотеку об’єктних модулів, в яких реалізовані подібні
функції. Бібліотека підтримує більшість з функцій, які вимагаються.
Це рішення дозволяє ізолювать мовні особливості від специфіки процесора, на
якому виконується результативна програма. Суворе визначення мови робить її
незалежною від будь-яких деталей операційної системи або машини. В цей же час
програмісти можуть добавити до бібліотеки специфічні системні програми, щоб
більш ефективно використовувати конкретні особливості машини.
Сі – гнучка мова, яка дозволяє приймати в конкретних випадках самі
різноманітні рішення. Однак, Сі накладає незначні обмеження в таких,
наприклад, діях, як перетворення типів. В більшості випадках це є
достоїнством, однак програмісти повинні знати мову добре, щоб розуміти, як
будуть виконуватись їх програми.
1 Теоретичні відомості
1.1                  Мова програмування
Програма написана на об`єктно-орієнтованій системі програмування MS Visual
С++. Основою цієї мови, як можна побачити з назви є язик програмування С++.
Головною причиною мого вибору стало те, що ця система об’єктно-орієнтована і
програмувати інтерфейс користувача на ній досить легко. В MS Visual С++
присутні багато різних компонентів, які надають широкий вибір при
проектуванні, що дозволяє найкращим чином налагодити програму під поставлену
задачу. Вбудований потужний довідник (MSDN) та різні програми, які
допомагають програмісту при написані коду програми.
2 Розробка та опис алгоритма розв’язку задачі
Алгоритмом називається директива, яка визначає порядок виконання дій
(операцій) над даними з метою отримання шуканого результату.
Процес підготовки розв’язку задачі на ЕОМ називається алгоритмізацією.
Розробка алгоритму складається з декількох етапів:
1 Вивчення завдання даного для алгоритму задачі. Часто завдання представлене
в описовій формі з використанням формул, таблиць, графіків і т. і.. Необхідно
глибоко вивчити процес, що алгоритмізується, виявити закономірності явищ, що
його складають. Визначається вхідна вихідна інформація, задаються області
зміни аргументів, точність обчислень. Вхідна інформація повинна бути повною.
2 Виконується математична формалізація описової умови задачі. Її мета –
побудувати масиви арифметичних і логічних операторів. До масиву логічних
операторів входять всі умови що відображають закономірності процесу який
алгоритмізуеться.
3 Будується схема алгоритму.
Загальний вигляд алгоритму розв’язку задачі зображено на рисунку 1.
     
     
     
     Режим вводу числа – це режим при якому натискання на кнопки з цифрами та
кнопки „крапка”, додає відповідну цифру до числа на екрані (поточного числа)
     Бінарні операції – це будь-які математичні операції з двома аргументами,
наприклад +, - і т.ін.
     Унарні операції – це операції з одним аргументом, наприклад sin, cos і т.ін.
     Операції з пам’яттю: MC – зброс пам’ятті у нуль, MR – зчитування числа з
пам’ятті на екран, MS – запис поточного числа у пам’ять, M+ – додати поточне
число до числа у пам’ятті і зберегти результат у пам’ятті.
     Виконати операції в стеці – виконування всіх операцій, які зберігаються у
стеці відповідно приоритету операцій.
3 Опис програми
3.1 Опис функціональних можливостей
C – це сброс числа у ‘0’ та весь стек.
CE – сброс числа у ‘0’ .
MC – очищення числа з пам’яті.
MR – виведення числа з пам’яті.
MS – зберігає поточне число у пам’ять.
M+ – додає поточне число до того, що у пам’яті.
sin – сінус числа.
cos – косінус числа.
tan – тангенс числа.
pi – число пі.
Exp – експонента числа.
x^y – поперднє введене число взведене у степінь поточного числа.
x^2 – поперднє введене число взведене у другу степінь.
x^3 – поперднє введене число взведене у третю степінь.
ln – натуральний логарифм поточного числа.
log – десятичний логарифм поточного числа.
n! – факторіал поточного числа.
1/x – ділення одиниці на поточне число.
Mod – остача від ділення.
Sqrt – корінь поточного числа.
Int – виділення цілого числа.
+, -,*, / - сума, різниця, множення, ділення відповідно.
3.2     Опис даних
Программа може працювати як з цілими, так і з 
дробовимидробними 
числами. Для того щоб ввести 
дробоведробне 
число користувач має натиснути на кнопку „крапка”. 
При цьому дляДля 
того, щоб цифри які вводяться
, записувались правильно
, програма зберігає інформацію про наявність крапки у булевській змінній
m_bHasDot:
bool m_bHasDot;
Для зберігання інформації про режим вводу використовується змінна:
bool bNeedClear;
Якшо вона дорівнюватиме true, то це буде означати, що при наступному
натисканні будь-якої цифри ми повинні стерти з екрана поточне число, перейти
у режим вводу (присвоїти bNeedClear значення false) і показати введену цифру
на екрані.
Для зручності зберігання числа і операції ми створюємо структуру:
struct OPERAND {
double val;
OPERATION op;
};
де OPERATION – це:
enum OPERATION {NONE=0, ADD, SUB, MULT, DIV, MOD, POW};
при цьоому операції ми записуємо у порядку приоритету бінарних математичних
операцій.
     Поточну операцію ми будемо зберігати у змінній:
     OPERATION cur_op;
      
Також програма повинна зберігати стек. Для цього можна використовувати готовий
шаблонний класс
vector з ATL бібліотеки <vector>:
std::vector<OPERAND> stack;
Для того, щоб підключити цю бібліотеку до проекта, ми повинні написати рядок:
#include <vector>
Оскільки ця бібліотека використовує namespace std, ми повинні додавати std::
перед кожним типом із цієї бібліотеці.
Також програма може зберігати одне значення в пам’ятті. Для його зберігання
будемо використовувати тип double:
double mem;
4            Результати роботи програми та їх аналіз 
     Програма запускається за
допомогою файла 
CalcSimple.
exe. При записку ми
бачимо вікно 
(рисунок 2) з усіма можливими функціями, які описані у п. 3.1
-5 сторінок..
      
     
     
     
     Рисунок 2 – Початковий вигляд програми.
      
     Програма прац
ює аналогічно, будь якому калькулятору. Так при діленні на нуль, видає, що було
зробленно помилку (рисунок 3).
      
     
                       
Рисунок 3  Результат роботи програми при діленні на нуль.
Тепер можно перевірити, як працює пам’ять програми (MS). Коли ми записуємо в
пам’ять поточне число, то з’являється літера ‘М’ (рисунок 4, рисунок 5). –
     
 Рисунок 4 – Результат роботи програми до записування поточного числа у пам’ять. 
      
     
Рисунок 5 – Результат роботи програми після записування поточного числа у
пам’ять.
   Також програма передбачає виділення цілого числа Int (рисунок 6, рисунок7)   
     
           Рисунок 6 – Результат роботи програми до використання Int.           
     
          Рисунок 7 – Результат роботи програми після використання Int.          
Зміна знаку +/- (рисунок 8, рисунок 9).
     
           Рисунок 8 – Результат роботи програми до використання +/-.           
     
          Рисунок 8 – Результат роботи програми після використання +/-.          
Остача від ділення Mod (рисунок 12).
На прикладі, 5 Mod 2
     
         Рисунок 12 – Результат роботи програми після використання Mod.         
Висновки
В ході реалізації проекту я ознайомилась з об`єктно-орієнтованою системою
програмування MS Visual C++. Більш детально ознайомилась з вікном Workspace
View, до якого входять: Class View, Resource View та File View. Засвоїла
теоретичний матеріал. Здобула практичне вміння створювати прості алгоритми та
програми основані на діалогових вікнах. Створила зручну програму калькулятор,
в якій є всі мінімально важливі фунції підрахунку.
Література
1        Вычислительная техника и программирование. Под ред. А.В.Ретрова. -
М.: Высшая школа, 1990
2        Кузнецов А.А. и др. Основы информатики. - М.: Дрофа, 1998
3        Кушниренко А.Г. и др. Информатика. - М.: Дрофа, 1998
4        Лебедев Г.В., Кушниренко А.Г. 12 лекций по преподаванию курса
информатики. - М.: Дрофа, 1998
5        Шауцукова Л.З. Информатика 10 - 11. М.: Просвещение, 2000
6        Л.И. Шолмов. Язык Си. 1988г.
7        Г. Шилдт. C для профессиональных программистов. 1989г.
8        Б.В. Керниган, Д.М. Ричи. Язык Си. 1995г.
9        Современное проектирование на С++ - Андрей Александреску 2002
10   Язык программирования С++ - Бьярн Страуструп
Додаток
Текст програми мовою MS Visual С++
// CalcSimpleDlg.h : header file
//
#if
!defined(AFX_CALCSIMPLEDLG_H__B693EEFB_E41A_473A_821E_879CCB2736CE__INCLUDED_
)
#define AFX_CALCSIMPLEDLG_H__B693EEFB_E41A_473A_821E_879CCB2736CE__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <vector>
enum OPERATION {NONE=0, ADD, SUB, MULT, DIV, MOD, POW};
struct OPERAND {
double val;
OPERATION op;
};
/////////////////////////////////////////////////////////////////////////////
// CCalcSimpleDlg dialog
class CCalcSimpleDlg : public CDialog
{
// Construction
public:
CCalcSimpleDlg(CWnd* pParent = NULL); // standard constructor
double GetValue();
void SetValue(double d, int len=-1);
void AddDigitToEnd(char c);
void OnButtonDigit(int digit);
void CalcStack(OPERAND &op);
void PerformCurOp();
// Dialog Data
//{{AFX_DATA(CCalcSimpleDlg)
enum { IDD = IDD_CALCSIMPLE_DIALOG };
CString  m_sEdit;
//}}AFX_DATA
bool m_bHasDot;
std::vector<OPERAND> stack;
double mem;
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CCalcSimpleDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CCalcSimpleDlg)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnButton1();
afx_msg void OnButton2();
afx_msg void OnButton3();
afx_msg void OnButton4();
afx_msg void OnButton5();
afx_msg void OnButton6();
afx_msg void OnButton7();
afx_msg void OnButton8();
afx_msg void OnButton9();
afx_msg void OnButton0();
afx_msg void OnDot();
afx_msg void OnPlusMinus();
afx_msg void OnClear();
afx_msg void OnClearCurrent();
afx_msg void OnAdd();
afx_msg void OnSub();
afx_msg void OnMult();
afx_msg void OnDiv();
afx_msg void OnEqual();
afx_msg void OnMod();
afx_msg void OnSin();
afx_msg void OnCos();
afx_msg void OnTan();
afx_msg void OnPi();
afx_msg void OnExp();
afx_msg void OnLn();
afx_msg void OnXpowY();
afx_msg void OnXpow3();
afx_msg void OnXpow2();
afx_msg void On1divX();
afx_msg void OnLog10();
afx_msg void OnFactorial();
afx_msg void OnMemClear();
afx_msg void OnMemRead();
afx_msg void OnMemSave();
afx_msg void OnMemPlus();
afx_msg void OnSqrt();
afx_msg void OnInt();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately
before the previous line.
#endif //
!defined(AFX_CALCSIMPLEDLG_H__B693EEFB_E41A_473A_821E_879CCB2736CE__INCLUDED_
)
// CalcSimpleDlg.cpp : implementation file
//
#include "stdafx.h"
#include "CalcSimple.h"
#include "CalcSimpleDlg.h"
#include <vector>
#include <MATH.H>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
int priors[] = {0,1,1,2,2,3,4};
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
OPERATION cur_op = NONE;
bool bNeedClear = false;
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CCalcSimpleDlg dialog
CCalcSimpleDlg::CCalcSimpleDlg(CWnd* pParent /*=NULL*/)
: CDialog(CCalcSimpleDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CCalcSimpleDlg)
m_sEdit = _T("0.");
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
m_bHasDot = false;
mem = 0.;
}
void CCalcSimpleDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CCalcSimpleDlg)
DDX_Text(pDX, IDC_EDIT1, m_sEdit);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CCalcSimpleDlg, CDialog)
//{{AFX_MSG_MAP(CCalcSimpleDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON1, OnButton1)
ON_BN_CLICKED(IDC_BUTTON2, OnButton2)
ON_BN_CLICKED(IDC_BUTTON3, OnButton3)
ON_BN_CLICKED(IDC_BUTTON4, OnButton4)
ON_BN_CLICKED(IDC_BUTTON5, OnButton5)
ON_BN_CLICKED(IDC_BUTTON6, OnButton6)
ON_BN_CLICKED(IDC_BUTTON7, OnButton7)
ON_BN_CLICKED(IDC_BUTTON8, OnButton8)
ON_BN_CLICKED(IDC_BUTTON9, OnButton9)
ON_BN_CLICKED(IDC_BUTTON0, OnButton0)
ON_BN_CLICKED(IDC_DOT, OnDot)
ON_BN_CLICKED(IDC_PLUSMINUS,OnPlusMinus)
ON_BN_CLICKED(IDC_CLEAR,OnClear)
ON_BN_CLICKED(IDC_CLEAR_CURRENT,OnClearCurrent)
ON_BN_CLICKED(IDC_PLUS,OnAdd)
ON_BN_CLICKED(IDC_MINUS,OnSub)
ON_BN_CLICKED(IDC_MULT,OnMult)
ON_BN_CLICKED(IDC_DIV,OnDiv)
ON_BN_CLICKED(IDC_EQUAL,OnEqual)
ON_BN_CLICKED(IDC_MOD,OnMod)
ON_BN_CLICKED(IDC_SIN,OnSin)
ON_BN_CLICKED(IDC_COS,OnCos)
ON_BN_CLICKED(IDC_TAN,OnTan)
ON_BN_CLICKED(IDC_PI,OnPi)
ON_BN_CLICKED(IDC_EXP,OnExp)
ON_BN_CLICKED(IDC_LN,OnLn)
ON_BN_CLICKED(IDC_XPOWY,OnXpowY)
ON_BN_CLICKED(IDC_XPOW3,OnXpow3)
ON_BN_CLICKED(IDC_XPOW2,OnXpow2)
ON_BN_CLICKED(IDC_1DIVX,On1divX)
ON_BN_CLICKED(IDC_MEMC,OnMemClear)
ON_BN_CLICKED(IDC_MEMR,OnMemRead)
ON_BN_CLICKED(IDC_MEMS,OnMemSave)
ON_BN_CLICKED(IDC_MEMP,OnMemPlus)
ON_BN_CLICKED(IDC_LOG10,OnLog10)
ON_BN_CLICKED(IDC_FACTORIAL,OnFactorial)
ON_BN_CLICKED(IDC_SQRT,OnSqrt)
ON_BN_CLICKED(IDC_INT,OnInt)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CCalcSimpleDlg message handlers
BOOL CCalcSimpleDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog.  The framework does this automatically
//  when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE);          // Set big icon
SetIcon(m_hIcon, FALSE);         // Set small icon
return TRUE;  // return TRUE  unless you set the focus to a control
}
void CCalcSimpleDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.
void CCalcSimpleDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CCalcSimpleDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
double CCalcSimpleDlg::GetValue()
{
UpdateData();
return atof(m_sEdit);
}
void CCalcSimpleDlg::SetValue(double d,int len)
{
int dec,sign;
char *buf = _fcvt(d,len!=-1?len+1:64,&dec,&sign);
CString s;
if(sign)
s+='-';
if( !dec || (dec == sign && !sign))
s += '0';
for(int i=0;i<dec;i++)
s += buf[i];
s += '.';
int k=s.GetLength();
for(;i<strlen(buf);i++)
{
s+=buf[i];
if(buf[i] != '0')
k = s.GetLength();
}
if(len != -1)
m_sEdit = s.Left(len);
else
m_sEdit = s.Left(k);
UpdateData(0);
}
void CCalcSimpleDlg::AddDigitToEnd(char c)
{
UpdateData();
m_sEdit += c;
SetValue(atof(m_sEdit),m_sEdit.GetLength());
}
void CCalcSimpleDlg::OnButtonDigit(int digit)
{
if(bNeedClear)
{
bNeedClear = false;
m_bHasDot = false;
m_sEdit = "0.";
UpdateData(0);
}
if(m_bHasDot)
AddDigitToEnd(digit+'0');
else
{
double d = GetValue();
if(d >= 0.)
SetValue(d*10.+(double)digit);
else
SetValue(d*10.-(double)digit);
}
}
void CCalcSimpleDlg::OnButton1()
{
OnButtonDigit(1);
}
void CCalcSimpleDlg::OnButton2()
{
OnButtonDigit(2);
}
void CCalcSimpleDlg::OnButton3()
{
OnButtonDigit(3);
}
void CCalcSimpleDlg::OnButton4()
{
OnButtonDigit(4);
}
void CCalcSimpleDlg::OnButton5()
{
OnButtonDigit(5);
}
void CCalcSimpleDlg::OnButton6()
{
OnButtonDigit(6);
}
void CCalcSimpleDlg::OnButton7()
{
OnButtonDigit(7);
}
void CCalcSimpleDlg::OnButton8()
{
OnButtonDigit(8);
}
void CCalcSimpleDlg::OnButton9()
{
OnButtonDigit(9);
}
void CCalcSimpleDlg::OnButton0()
{
OnButtonDigit(0);
}
void CCalcSimpleDlg::OnDot()
{
m_bHasDot = true;
}
void CCalcSimpleDlg::OnPlusMinus()
{
SetValue(-GetValue());
}
void CCalcSimpleDlg::OnClear()
{
stack.clear();
OnClearCurrent();
}
void CCalcSimpleDlg::OnClearCurrent()
{
m_bHasDot = false;
cur_op = NONE;
bNeedClear = false;
m_sEdit = "0.";
UpdateData(0);
}
OPERAND last = {0,NONE};
void CCalcSimpleDlg::OnAdd()
{
OPERAND op = {GetValue(),ADD};
CalcStack(op);
//stack.push_back(op);
cur_op = ADD;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::OnSub()
{
OPERAND op = {GetValue(),SUB};
CalcStack(op);
//stack.push_back(op);
cur_op = SUB;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::OnMult()
{
OPERAND op = {GetValue(),MULT};
CalcStack(op);
//stack.push_back(op);
cur_op = MULT;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::OnDiv()
{
OPERAND op = {GetValue(),DIV};
CalcStack(op);
//stack.push_back(op);
cur_op = DIV;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::CalcStack(OPERAND &op)
{
if(stack.size() == 0)
{
stack.push_back(op);
return;
}
while(stack.size() > 0)
{
OPERAND st = stack.back();
if(priors[op.op] > priors[st.op])
{
stack.push_back(op);
return;
}
else
{
OPERATION old = cur_op;
cur_op = st.op;
PerformCurOp();
cur_op = old;
}
}
if(op.op != NONE)
{
//stack.push_back(first);
op.val = GetValue();
stack.push_back(op);
}
}
void CCalcSimpleDlg::OnEqual()
{
OPERAND op = {GetValue(),NONE};
if(last.op != cur_op)
{
last = op;
last.op = cur_op;
}
if(stack.size() == 0)
stack.push_back(last);
CalcStack(op);
bNeedClear = true;
}
void CCalcSimpleDlg::PerformCurOp()
{
OPERAND op = stack.back();
double d = GetValue();
switch(cur_op)
{
case ADD:
d += op.val;
break;
case SUB:
d = op.val - d;
break;
case MULT:
d = op.val * d;
break;
case DIV:
d = op.val / d;
break;
case MOD:
{
double f = op.val;
while(f>d)
f-=d;
d = f;
}
break;
case POW:
d = pow(op.val, d);
break;
}
stack.pop_back();
SetValue(d);
}
void CCalcSimpleDlg::OnMod()
{
OPERAND op = {GetValue(),MOD};
CalcStack(op);
//stack.push_back(op);
cur_op = MOD;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::OnSin()
{
SetValue(sin(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnCos()
{
SetValue(cos(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnTan()
{
SetValue(tan(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnPi()
{
SetValue(3.1415926535897932384626433832795);
bNeedClear = true;
}
void CCalcSimpleDlg::OnExp()
{
SetValue(exp(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnLn()
{
SetValue(log(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnXpowY()
{
OPERAND op = {GetValue(),POW};
CalcStack(op);
cur_op = POW;
last.op = NONE;
bNeedClear = true;
}
void CCalcSimpleDlg::OnXpow3()
{
SetValue(pow(GetValue(),3));
bNeedClear = true;
}
void CCalcSimpleDlg::OnXpow2()
{
SetValue(pow(GetValue(),2));
bNeedClear = true;
}
void CCalcSimpleDlg::On1divX()
{
SetValue(1/GetValue());
bNeedClear = true;
}
void CCalcSimpleDlg::OnMemClear()
{
mem=0.;
SetDlgItemText(IDC_MEM_USED,"");
bNeedClear = true;
}
void CCalcSimpleDlg::OnMemRead()
{
SetValue(mem);
bNeedClear = true;
}
void CCalcSimpleDlg::OnMemSave()
{
mem = GetValue();
SetDlgItemText(IDC_MEM_USED,"M");
bNeedClear = true;
}
void CCalcSimpleDlg::OnMemPlus()
{
mem += GetValue();
SetDlgItemText(IDC_MEM_USED,"M");
bNeedClear = true;
}
void CCalcSimpleDlg::OnLog10()
{
SetValue(log10(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnFactorial()
{
double d = 1.;
int n = GetValue();
while(n)
{
d*=n--;
}
SetValue(d);
bNeedClear = true;
}
void CCalcSimpleDlg::OnSqrt()
{
SetValue(sqrt(GetValue()));
bNeedClear = true;
}
void CCalcSimpleDlg::OnInt()
{
SetValue(int(GetValue()));
bNeedClear = true;
}
Зміст
Вступ
1 Теоретичні відомості
1.1 Мова програмування
2 Розробка та опис алгоритма розв’язку задачі
3 Опис програми
3.1 Опис функціональних можливостей
3.2 Опис даних
4 Результати роботи програми та їх аналіз 
Висновки
Література
Додаток