Реалізація програми для зчитування функції з файлу в об’єктно орієнтованому стилі з використанням, процедур та функцій мови С++

Размещено на http://www.allbest.ru

Размещено на http://www.allbest.ru

Вступ

Метою написання курсового проекту є реалізація програми в об'єктно орієнтованому стилі з використанням, процедур та функцій мовою С++. При виконанні завдання потрібно набути практичних навиків при програмуванні мовою С++ та зрозуміти її концепції.

Для забезпечення виконання поставленого завдання, потрібно розробити деякі процедури та функції, які б забезпечували реалізацію даного завдання.

1. Розробка алгоритму функціонування

Алгоритм - система точно сформованих правил, що визначає (задає) послідовність команд (дій, вказівок), які потрібно виконати над вихідними даними для отримання результату за скінчене число кроків.

Процедура - блок з формальними параметрами або без них, виконання якого відбувається після приведення його до стану готовності до виконання.

Дана програма складається з таких процедур:

private: System::Void Form1_Load(System::Object sender, System::EventArgs e) - це є головна процедура, яка виводить на екран головну форму.

private: System::Void відкритиToolStripMenuItem_Click(System::Object sender, System::EventArgs e) - процедура яка відкриває файл.

private: System::Void вийтиToolStripMenuItem_Click(System::Object sender, System::EventArgs e) - процедура яка закриває програму

private: System::Void button2_Click(System::Object sender, System::EventArgs e) - процедура яка відкриває вікно з числовими значеннями функції.

private: System::Void button1_Click(System::Object sender, System::EventArgs e)- процедура , яка виводить графік функції.

Процедуру визначають за допомогою опису, що розміщений у розділі процедур і функцій. Вона має таку ж структуру, як і підпрограма, тобто складається із заголовку і блоку - тіла процедури. Заголовок починається із службового слова, що містять ім'я, що відповідає цій процедурі, а також може містити параметри - деяку додаткову інформацію, яка полегшує використання цієї процедури.

2. Створення програми із описом основних структур, процедур, модулів, файлів

Дана частина програми, дозволяє запустити головне вікно програми:

int main(void)

{

Application::EnableVisualStyles();

Application::SetCompatibleTextRenderingDefault(false);

// Создание главного окна и его запуск

Application::Run(gcnew Form1());

return 0;

}

Функція, яка відкриває файл і зчитує функцію:

private: System::Void відкритиToolStripMenuItem_Click(System::Object sender, System::EventArgs e) {

if (openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK)

{

String FName = openFileDialog1->FileName;

if (FName != "")

{

textBox1->Text = System::IO::File::ReadAllText(FName);;

}

}

}

Функція, яка будує графік функції в заданих межах:

private: System::Void button1_Click(System::Object sender, System::EventArgs e) {

double x1, x2, dX; String s = textBox1->Text;

this->chart1->Visible = false;

if (Parse(this->x1->Text, x1) == false ||

Parse(this->x2->Text, x2) == false ||

Parse(this->dX->Text, dX) == false) {

MessageBox::Show("Введіть x1,x2,dx", "Помилка", MessageBoxButtons::OK);

return;

}

if (x1 >= x2 || x1 + dX >= x2) {

MessageBox::Show("Неправильний ввід. Потрібно x1<x1+dX<x2", "Помилка", MessageBoxButtons::OK);

return;

}

if ((x2 - x1) / dX > maxCollectionSize) {

MessageBox::Show("Багато кроків (Max="+maxCollectionSize+")",

"Помилка", MessageBoxButtons::OK);

dX = (x2 - x1) / (double)maxCollectionSize;

this->dX->Text = Math::Round(dX, 2).ToString(nfi);

}

this->chart1->Visible=true;

if (!Check (s,x1)) {

MessageBox::Show ("Введіть вірну функцію, неможливо обчислити значення функції при заданому значені х",

"Помилка",MessageBoxButtons::OK);

return;

}

Go (s, x1, x2, dX);

}

Код, що перетворює стрічку в функцію f(x):

#include "stdafx.h"

#include <math.h>

#include "parser.h"

#define OP_PLUS 0

#define OP_MINUS 1

#define OP_MULTIPLY 2

#define OP_DIVIDE 3

#define OP_PERCENT 4

#define OP_POWER 5

#define OP_UMINUS 6

#define OP_SIN 10

#define OP_COS 11

#define OP_TG 12

#define OP_CTG 13

#define OP_ARCSIN 14

#define OP_ARCCOS 15

#define OP_ARCTG 16

#define OP_ARCCTG 17

#define OP_SH 18

#define OP_CH 19

#define OP_TH 20

#define OP_CTH 21

#define OP_EXP 22

#define OP_LG 23

#define OP_LN 24

#define OP_SQRT 25

#define OP_X 26

// PI...

#define M_PI 3.1415926535897932384626433832795

// Member functions

TParserNode *TParser::CreateNode(double _value, TParserNode *_left, TParserNode *_right)

{

TParserNode *pNode = new TParserNode(_value, _left, _right);

history.push_back(pNode);

return pNode;

}

void TParser::SendError(int errNum)

{

static char *errs[7] = { NULL,

NULL,

"Unexpected end of expression",

"End of expression expected",

"'(' or '[' expected",

"')' or ']' expected",

NULL

};

static char buffer[80];

int len = strlen(curToken);

if(*curToken=='\0')

strcpy(curToken, "EOL");

switch(errNum)

{

case 0:

sprintf(buffer, "Unknown keyword: '%s'", curToken);

errs[0] = buffer;

break;

case 1:

sprintf(buffer, "Unknown symbol: '%s'", curToken);

errs[1] = buffer;

break;

case 6:

sprintf(buffer, "Unexpected '%s'", curToken);

errs[6] = buffer;

break;

}

TError error(errs[errNum], pos-len);

for(int i=0; i<history.size(); i++)

delete history[i];

history.clear();

root = NULL;

throw error;

return;

}

bool TParser::GetToken(void)

{

*curToken = '\0';

while(expr[pos]==' ') pos++;

if(expr[pos]=='\0')

{

curToken[0] = '\0';

typToken = PARSER_END;

return true;

}

else if(IsDelim())

{

curToken[0] = expr[pos++];

curToken[1] = '\0';

switch(*curToken)

{

case '+': typToken = PARSER_PLUS; return true;

case '-': typToken = PARSER_MINUS; return true;

case '*': typToken = PARSER_MULTIPLY; return true;

case '/': typToken = PARSER_DIVIDE; return true;

case '%': typToken = PARSER_PERCENT; return true;

case '': typToken = PARSER_POWER; return true;

case '[':

case '(': typToken = PARSER_L_BRACKET; return true;

case ']':

case ')': typToken = PARSER_R_BRACKET; return true;

}

}

else if(IsLetter())

{

int i=0;

while(IsLetter()) curToken[i++] = expr[pos++];

curToken[i] = '\0';

int len = strlen(curToken);

for(i=0; i<len; i++)

if(curToken[i]>='A' && curToken[i]<='Z')

curToken[i] += 'a' - 'A';

if(!strcmp(curToken, "x")) { typToken = PARSER_X; return true; }

else if(!strcmp(curToken, "pi")) { typToken = PARSER_PI; return true; }

else if(!strcmp(curToken, "e")) { typToken = PARSER_E; return true; }

else if(!strcmp(curToken, "sin")) { typToken = PARSER_SIN; return true; }

else if(!strcmp(curToken, "cos")) { typToken = PARSER_COS; return true; }

else if(!strcmp(curToken, "tg")) { typToken = PARSER_TG; return true; }

else if(!strcmp(curToken, "ctg")) { typToken = PARSER_CTG; return true; }

else if(!strcmp(curToken, "arcsin")) { typToken = PARSER_ARCSIN; return true; }

else if(!strcmp(curToken, "arccos")) { typToken = PARSER_ARCCOS; return true; }

else if(!strcmp(curToken, "arctg")) { typToken = PARSER_ARCTG; return true; }

else if(!strcmp(curToken, "arcctg")) { typToken = PARSER_ARCCTG; return true; }

else if(!strcmp(curToken, "sh")) { typToken = PARSER_SH; return true; }

else if(!strcmp(curToken, "ch")) { typToken = PARSER_CH; return true; }

else if(!strcmp(curToken, "th")) { typToken = PARSER_TH; return true; }

else if(!strcmp(curToken, "cth")) { typToken = PARSER_CTH; return true; }

else if(!strcmp(curToken, "exp")) { typToken = PARSER_EXP; return true; }

else if(!strcmp(curToken, "lg")) { typToken = PARSER_LG; return true; }

else if(!strcmp(curToken, "ln")) { typToken = PARSER_LN; return true; }

else if(!strcmp(curToken, "sqrt")) { typToken = PARSER_SQRT; return true; }

else SendError(0);

}

else if(IsDigit() || IsPoint())

{

int i=0;

while(IsDigit()) curToken[i++] = expr[pos++];

if(IsPoint())

{

curToken[i++] = expr[pos++];

while(IsDigit()) curToken[i++] = expr[pos++];

}

curToken[i] = '\0';

typToken = PARSER_NUMBER;

return true;

}

else

{

curToken[0] = expr[pos++];

curToken[1] = '\0';

SendError(1);

}

return false;

}

bool TParser::Compile(char *_expr)

{

pos = 0;

expr = _expr;

*curToken = '\0';

if(root!=NULL)

{

DelTree(root);

root = NULL;

}

history.clear();

GetToken();

if(typToken==PARSER_END) SendError(2);

root = Expr();

if(typToken!=PARSER_END) SendError(3);

history.clear();

return true;

}

TParserNode *TParser::Expr(void)

{

TParserNode *temp = Expr1();

while(1)

{

if(typToken==PARSER_PLUS)

{

GetToken();

temp = CreateNode(OP_PLUS, temp, Expr1());

}

else if(typToken==PARSER_MINUS)

{

GetToken();

temp = CreateNode(OP_MINUS, temp, Expr1());

}

else break;

}

return temp;

}

TParserNode *TParser::Expr1(void)

{

TParserNode *temp = Expr2();

while(1)

{

if(typToken==PARSER_MULTIPLY)

{

GetToken();

temp = CreateNode(OP_MULTIPLY, temp, Expr2());

}

else if(typToken==PARSER_DIVIDE)

{

GetToken();

temp = CreateNode(OP_DIVIDE, temp, Expr2());

}

else if(typToken==PARSER_PERCENT)

{

GetToken();

temp = CreateNode(OP_PERCENT, temp, Expr2());

}

else break;

}

return temp;

}

TParserNode *TParser::Expr2(void)

{

TParserNode *temp = Expr3();

while(1)

{

if(typToken==PARSER_POWER)

{

GetToken();

temp = CreateNode(OP_POWER, temp, Expr2());

}

else break;

}

return temp;

}

TParserNode *TParser::Expr3(void)

{

TParserNode *temp;

if(typToken==PARSER_PLUS)

{

GetToken();

temp = Expr4();

}

else if(typToken==PARSER_MINUS)

{

GetToken();

temp = CreateNode(OP_UMINUS, Expr4());

}

else

temp = Expr4();

return temp;

}

TParserNode *TParser::Expr4(void)

{

TParserNode *temp;

if(typToken>=PARSER_SIN && typToken<=PARSER_X)

{

temp = CreateNode(OP_SIN-PARSER_SIN+typToken);

GetToken();

if(typToken!=PARSER_L_BRACKET) SendError(4);

GetToken();

temp->left = Expr();

if(typToken!=PARSER_R_BRACKET) SendError(5);

GetToken();

}

else

temp = Expr5();

return temp;

}

TParserNode *TParser::Expr5(void)

{

TParserNode *temp;

switch(typToken)

{

case PARSER_NUMBER:

temp = CreateNode((double)atof(curToken));

GetToken();

break;

case PARSER_PI:

temp = CreateNode((double)M_PI);

GetToken();

break;

case PARSER_E:

temp = CreateNode((double)exp(1.));

GetToken();

break;

case PARSER_L_BRACKET:

GetToken();

temp = Expr();

if(typToken!=PARSER_R_BRACKET) SendError(5);

GetToken();

break;

default:

SendError(6);

}

return temp;

}

double TParser::Evaluate(void)

{

result = CalcTree(root);

return result;

}

double TParser::CalcTree(TParserNode *tree)

{

static double temp;

if(tree->left==NULL && tree->right==NULL)

return tree->value;

else

switch((int)tree->value)

{

case OP_PLUS:

return CalcTree(tree->left)+CalcTree(tree->right);

case OP_MINUS:

return CalcTree(tree->left)-CalcTree(tree->right);

case OP_MULTIPLY:

return CalcTree(tree->left)*CalcTree(tree->right);

case OP_DIVIDE:

return CalcTree(tree->left)/CalcTree(tree->right);

case OP_PERCENT:

return (int)CalcTree(tree->left)%(int)CalcTree(tree->right);

case OP_POWER:

return (double)pow(CalcTree(tree->left),CalcTree(tree->right));

case OP_UMINUS:

return -CalcTree(tree->left);

case OP_SIN:

return sin(CalcTree(tree->left));

case OP_COS:

return cos(CalcTree(tree->left));

case OP_TG:

return tan(CalcTree(tree->left));

case OP_CTG:

return 1.0/tan(CalcTree(tree->left));

case OP_ARCSIN:

return asin(CalcTree(tree->left));

case OP_ARCCOS:

return acos(CalcTree(tree->left));

case OP_ARCTG:

return atan(CalcTree(tree->left));

case OP_ARCCTG:

return M_PI/2.0-atan(CalcTree(tree->left));

case OP_SH:

temp = CalcTree(tree->left);

return (exp(temp)-exp(-temp))/2.0;

case OP_CH:

temp = CalcTree(tree->left);

return (exp(temp)+exp(-temp))/2.0;

case OP_TH:

temp = CalcTree(tree->left);

return (exp(temp)-exp(-temp))/(exp(temp)+exp(-temp));

case OP_CTH:

temp = CalcTree(tree->left);

return (exp(temp)+exp(-temp))/(exp(temp)-exp(-temp));

case OP_EXP:

return exp(CalcTree(tree->left));

case OP_LG:

return log10(CalcTree(tree->left));

case OP_LN:

return log(CalcTree(tree->left));

case OP_SQRT:

return sqrt(CalcTree(tree->left));

case OP_X:

return x[int(CalcTree(tree->left))];

}

return 0;

}

void TParser::DelTree(TParserNode *tree)

{

if(tree==NULL) return;

DelTree(tree->left);

DelTree(tree->right);

delete tree;

return;

}

Функція, що відкриває вікно відображення числових значень:

private: System::Void button2_Click(System::Object sender, System::EventArgs e) {

Form2 F2 = gcnew Form2;

using namespace System::Windows::Forms::DataVisualization::Charting;

for each (DataPoint p in chart1->Series[0]->Points) {

F2->Do (p->XValue, p->YValues[0],nfi);

}

F2->Show();

}

3. Опис технології роботи програми - ввід даних, основні режими роботи, вивід результатів

Після запуску програми на екрані комп'ютера з'являється вікно яке головне вікно програми курсової роботи (мал. 1).



Мал. 1

Далі натискаємо на вкладку Файл->Відкрити і завантажуємо файл із записаною в ньому функцією, для якої потрібно побудувати графік (мал. 2).

Мал. 2

Завантаживши файл в поле буде записана функція. Для побудови графіка потрібно вказати межі графіка та крок і натиснути на кнопку «Побудувати». Після цього на головному вікні з'явиться графік даної функції (мал. 3).

Мал. 3

Для того, щоб переглянути числові значення функції потрібно натиснути на кнопку «Показати числові значення» (мал. 4).

Мал. 4

Висновок

алгоритм числовий програмування

В ході виконання курсової роботи було розроблено windows додаток, що дозволяє будувати графіки заданої функції. Програма має можливість зчитувати функцію з файлу і будувати її графік на заданому користувачем діапазоні із заданим кроком. Програма має зручний та зрозумілий графічний інтерфейс виконаний на основі windows-форм.

Даний додаток буде потрібний, як студентам чи учням в процесі навчання, так і професійним користувачам, в яких виникає необхідність в побудові графіків.

Написану програму було детально протестовано на тестових даних і помилок в процесі роботи не виникало.

Размещено на Allbest.ru

...