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

ВВЕДЕНИЕ

интеграл трапеция симпсон код программа

При решении ряда актуальных физических и технических задач встречаются определенные интегралы от функций, первообразные которых не выражаются через элементарные функции. Кроме того, в приложениях приходится иметь дело с определенными интегралами, сами подынтегральные функции которых не являются элементарными. Это приводит к необходимости разработки приближенных методов вычисления определенных интегралов. Целью работы является создание программного продукта, использование которого позволит одновременно исследовать два метода вычисления определенных интегралов: метод трапеций и метод Симпсона (парабол).



ТЕОРЕТИЧЕСКАЯ ЧАСТЬ

ВЫЧИСЛЕНИЕ ОПРЕДЕЛЕННОГО ИНТЕГРАЛА ПО ФОРМУЛЕ ТРАПЕЦИЙ И МЕТОДОМ СИМПСОНА

Численные методы - это достаточно большой раздел высшей математики, для которого на практике, в контрольных работах, традиционно предлагается решение таких распространенных задач как приближенное вычисление определенных интегралов. В этой курсовой работе я рассмотрю два метода приближенного вычисления определенного интеграла - метод трапеций и метод Симпсона.

Сначала зададимся вопросом, а зачем вообще нужны приближенные вычисления? Вроде бы можно найти первообразную функции и использовать формулу Ньютона-Лейбница, вычислив точное значение определенного интеграла. В качестве ответа на вопрос сразу рассмотрим демонстрационный пример с рисунком.

Вычислить определенный интеграл

В данном примере интеграл не берётся (неберущийся), так называемый интегральный логарифм. Изобразим на чертеже график подынтегральной функции :

Рисунок 1

Всё нормально. Подынтегральная функция непрерывна на отрезке и определенный интеграл численно равен заштрихованной площади. Поскольку интеграл не берётся, мы применяем численные методы. При этом задача встречается в двух формулировках:

1) Вычислить определенный интеграл приближенно, округляя результат до определённого знака после запятой. Например, до двух знаков после запятой, до трёх знаков после запятой и т.д. Предположим, получился приближенный ответ 5,347. На самом деле он может быть не совсем верным (в действительности, скажем, более точный ответ 5,343). Наша задача состоит лишь в том, чтобы округлить результат до трёх знаков после запятой.

2) Вычислить определенный интеграл приближенно, с определённой точностью. Например, вычислить определённый интеграл приближенно с точностью до 0,001. Что это значит? Это значит, мы должны отыскать такое приближенное значение, которое по модулю (в ту или другую сторону) отличается от истины не более чем на 0,001.

Существуют несколько основных методов приближенного вычисления определенного интеграла, который встречается в задачах:

Метод прямоугольников. Отрезок интегрирования разбивается на несколько частей и строится ступенчатая фигура, которая по площади близка к искомой площади:

Рисунок 2

В данном примере проведено разбиение отрезка интегрирования на три отрезка: . Очевидно, что чем чаще разбиение (больше более мелких промежуточных отрезков), тем выше точность. «Ступенчатое» приближение является самым простым, и, видимо, поэтому довольно редко встречается в практических задачах.

Метод трапеций. Идея аналогична. Отрезок интегрирования разбивается на несколько промежуточных отрезков, и график подынтегральной функции приближается ломаной линией:

Рисунок 3

Таким образом, наша площадь приближается суммой площадей трапеций. Отсюда и название метода. Легко заметить, что метод трапеций даёт значительно лучшее приближение, чем метод прямоугольников (при одинаковом количестве отрезков разбиения). И, естественно, чем больше более мелких промежуточных отрезков мы рассмотрим, тем будет выше точность.

Метод Симпсона (метод парабол). Это более совершенный способ - график подынтегральной функции приближается не ломаной линией, а маленькими параболками. Сколько промежуточных отрезков - столько и маленьких парабол. Если взять те же три отрезка, то метод Симпсона даст ещё более точное приближение, чем метод прямоугольников или метод трапеций.

Чертеж визуально будет иметь примерно такой вид: приближение будет накладываться на график функции .

Задача на вычисление определенного интеграла по формуле Симпсона - самая популярное задание на практике.

ВЫЧИСЛЕНИЕ ОПРЕДЕЛЕННОГО ИНТЕГРАЛА МЕТОДОМ ТРАПЕЦИЙ

Рассмотрим определенный интеграл , где - функция, непрерывная на отрезке . Проведём разбиение отрезка на равных отрезков:

. При этом, очевидно: (нижний предел интегрирования) и (верхний предел интегрирования). Точки также называют узлами.

Тогда определенный интеграл можно вычислить приближенно по формуле трапеций:

,

где:

- длина каждого из маленьких отрезков или шаг;

- значения подынтегральной функции в точках .

Пример 1

Вычислить приближенно определенный интеграл по формуле трапеций. Результаты округлить до трёх знаков после запятой.

а) Разбив отрезок интегрирования на 3 части.

б) Разбив отрезок интегрирования на 5 частей.

Решение:

а)

Рисунок 4

По условию отрезок интегрирования нужно разделить на 3 части, то есть .

Вычислим длину каждого отрезка разбиения: . Параметр также называют шагом.

Точек (узлов разбиения) будет на одну больше, чем количество отрезков:

А общая формула трапеций сокращается до таких размеров:

Для расчетов можно использовать обычный микрокалькулятор:

В соответствии с условием задачи, все вычисления следует округлять до 3-го знака после запятой.

Окончательно:

б) Разобьём отрезок интегрирования на 5 равных частей, то есть .

Если , то формула трапеций принимает следующий вид:

Найдем шаг разбиения:

, то есть, длина каждого промежуточного отрезка равна 0,6.

При чистовом оформлении задачи все вычисления удобно оформлять расчетной таблицей:

Таблица 1

В первой строке записываем «счётчик»

Вторая строка формируется так - сначала записываем нижний предел интегрирования , остальные значения получаем, последовательно приплюсовывая шаг .

Нижняя строка заполняется по следующему принципу - например, если , то .

В результате:

Итак, если для 3 отрезков разбиения приближённое значение составило, то для 5 отрезков . Таким образом, с большой долей уверенности можно утверждать, что, по крайне мере .



ВЫЧИСЛЕНИЕ ОПРЕДЕЛЕННОГО ИНТЕГРАЛА ПО ФОРМУЛЕ СИМПСОНА

Рассмотрим определенный интеграл , где - функция, непрерывная на отрезке . Проведём разбиение отрезка на чётное количество равных отрезков. Чётное количество отрезков обозначают через .

На практике отрезков может быть:

два:

четыре:

восемь:

десять:

двадцать:

Внимание! Число понимается как единое число. То есть, нельзя сокращать, например, делить на два, получая . Запись лишь обозначает, что количество отрезков чётно.

Итак, наше разбиение имеет следующий вид:

Термины аналогичны терминам метода трапеций:

Точки называют узлами.

Формула Симпсона для приближенного вычисления определенного интеграла имеет следующий вид:

,

где:

- длина каждого из маленьких отрезков или шаг;

- значения подынтегральной функции в точках .

Детализируя это нагромождение, разберу формулу подробнее:

- сумма первого и последнего значения подынтегральной функции;

- сумма членов с чётными индексами умножается на 2;

- сумма членов с нечётными индексами умножается на 4.

Пример 2

Вычислить приближенно определенный интеграл по формуле Симпсона с точностью до 0,001. Разбиение начать с двух отрезков

Интеграл снова неберущийся.

Решение: Обращая внимание на тип задания можно заметить, что определенный интеграл необходимо вычислить с определенной точностью. Как и для метода трапеций, существует формула, которая сразу позволит определить нужное количество отрезков (значение «эн») чтобы гарантированно достичь требуемой точности. По ходу решения задачи станет необходимо находить четвертую производную. Это достаточно сложно, поэтому на практике практически всегда используется упрощенный метод оценки погрешности.

Начало решения. Если у нас два отрезка разбиения , то узлов будет на один больше: . И формула Симпсона принимает весьма компактный вид:

Вычислим шаг разбиения:

Заполним расчетную таблицу:

Таблица 2

В верхнюю строку записываем «счётчик» индексов

Во второй строке сначала пишем нижний предел интегрирования , а затем последовательно приплюсовываем шаг .

В третью строку заносим значения подынтегральной функции. Например, если , то . Принцип для определения знаков после запятой тот же, что и в методе трапеций, смотрим на требуемую точность: 0,001. И прибавляем дополнительно 2-3 разряда. То есть, округлять нужно до 5-6 знаков после запятой.

В результате:

Первичный результат получен. Теперь удваиваем количество отрезков до четырёх: . Формула Симпсона для данного разбиения принимает следующий вид:

Вычислим шаг разбиения:

Заполним расчетную таблицу:

Таблица 3

Таким образом:

Найдём абсолютное значение разности между приближениями:

Если при использовании метода средних прямоугольников и метода трапеций нам даётся пособление в одну треть, то сейчас - оно составляет одну пятнадцатую:

, и точность здесь уже не страдает:



КЛАССЫ В С++

Классы и объекты в С++ являются основными концепциями объектно-ориентированного программирования -- ООП. Объектно-ориентированное программирование -- расширение структурного программирования, в котором основными концепциями являются понятия классов и объектов. Основное отличие языка программирования С++ от С состоит в том, что в С нет классов, а следовательно язык С не поддерживает ООП, в отличие от С++.

Классы в С++ -- это абстракция описывающая методы, свойства, ещё не существующих объектов. Объекты -- конкретное представление абстракции, имеющее свои свойства и методы. Созданные объекты на основе одного класса называются экземплярами этого класса. Эти объекты могут иметь различное поведение, свойства, но все равно будут являться объектами одного класса. В ООП существует три основных принципа построения классов:

1. Инкапсуляция -- это свойство, позволяющее объединить в классе и данные, и методы, работающие с ними и скрыть детали реализации от пользователя.

2. Наследование -- это свойство, позволяющее создать новый класс-потомок на основе уже существующего, при этом все характеристики класса родителя присваиваются классу-потомку.

3. Полиморфизм -- свойство классов, позволяющее использовать объекты классов с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

Структура объявления классов:

1 2 3 4 5 6 7 8 9 10	// объявление классов в С++ class /*имя класса*/ { private: /* методы и поля класса, которые доступны только в этом классе и для работы с этими полями реализуются такие функции как get и set */ public: /* список методов доступных для всех классов*/ protected: /* список методов доступных в классах наследниках */ };

Объявление класса начинается с зарезервированного ключевого слова class, после которого пишется имя класса. В фигурных скобочках, строки 3 -- 10 объявляется тело класса, причём после закрывающейся скобочки обязательно нужно ставить точку с запятой, строка 10. В теле класса объявляются три метки спецификации доступа, строки 4, 6, 8, после каждой метки нужно обязательно ставить двоеточие. В строке 4 объявлена метка спецификатора доступа private. Все методы и свойства класса, объявленные после спецификатор доступа private будут доступны только внутри класса. В строке 6 объявлен спецификатор доступа public, все методы и свойства класса, объявленные после спецификатора доступа public будут доступны другим функциям и объектам в программе. При объявлении класса, не обязательно объявлять три спецификатора доступа, и не обязательно их объявлять в таком порядке. Но лучше сразу определиться с порядком объявления спецификаторов доступа, и стараться его придерживаться. Разработаем программу, в которой объявим простейший класс, в котором будет объявлена одна функция, печатающая сообщение.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19	// classes.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include <iostream> using namespace std; // начало объявления класса class CppStudio // имя класса { public: // спецификатор доступа void message() // функция (метод класса) выводящая сообщение на экран { cout << "website: cppstudio.com\ntheme: Classes and Objects in C + +\n"; } }; // конец объявления класса CppStudio int main(int argc, char* argv[]) { CppStudio objMessage; // объявление объекта objMessage.message(); // вызов функции класса message system("pause"); return 0; }

В строках 7 -- 14 мы определили класс с именем CppStudio. Имя класса принято начинать с большой буквы, последующие слова в имени также должны начинаться с большой буквы. В теле класса объявлен спецификатор доступа public, который позволяет вызывать другим функциям методы класса, объявленные после public. Вот именно поэтому в главной функции, в строке 19 мы смогли вызвать функцию message(). В классе CppStudio объявлена всего одна функция, которая не имеет параметров и выводит сообщение на экран, строка 12. Методы класса -- это те же функции, только объявлены они внутри класса, поэтому всё, что относится к функциям актуально и для методов классов. Объявление классов выполняется аналогично объявлению функций, то есть класс можно объявлять в отдельном файле или в главном файле. В строке 18 объявлена переменная objMessage типа CppStudio, так вот, переменная objMessage -- это объект класса CppStudio. Таким образом, класс является сложным типом данных. После того как объект класса объявлен, можно воспользоваться его методами. Метод всего один -- функция message(). Для этого обращаемся к методу объекта objMessage через точку, как показано в строке 19, в результате программа выдаст текстовое сообщение (см. Рисунок 1).

Рисунок 5 -- Классы в С++

SET -- ФУНКЦИИ И GET -- ФУНКЦИИ КЛАССОВ

Каждый объект имеет какие-то свои свойства или атрибуты, которые характеризуют его на протяжении всей жизни. Атрибуты объекта хранятся в переменных, объявленных внутри класса, которому принадлежит данный объект. Причём, объявление переменных должно выполняться со спецификатором доступа private. Такие переменные называются элементами данных. Так как элементы данных объявлены в private, то и доступ к ним могут получить только методы класса, внешний доступ к элементам данных запрещён. Поэтому принято объявлять в классах специальные методы -- так называемые set и get функции, с помощью которых можно манипулировать элементами данных. set-функции инициализируют элементы данных, get-функции позволяют просмотреть значения элементов данных. Доработаем класс CppStudio так, чтобы в нём можно было хранить дату в формате дд.мм.гг. Для изменения и просмотра даты реализуем соответственно set и get функции.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37	// classes.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include <iostream> using namespace std; class CppStudio // имя класса { private: // спецификатор доступа private int day, // день month, // месяц year; // год public: // спецификатор доступа public void message() // функция (метод класса) выводящая сообщение на экран { cout << "\nwebsite: cppstudio.comntheme: Classes and Objects in C + +\n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "Date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio int main(int argc, char* argv[]) { setlocale(LC_ALL, "rus"); // установка локали int day, month, year; cout << "Введите текущий день месяц и год!\n"; cout << "день: "; cin >> day; cout << "месяц: "; cin >> month; cout << "год: "; cin >> year; CppStudio objCppstudio; // объявление объекта objCppstudio.message(); // вызов функции класса message objCppstudio.setDate(day, month, year); // инициализация даты objCppstudio.getDate(); // отобразить дату system("pause"); return 0; }

В определении класса появился новый спецификатор доступа private, строка 9. Данный спецификатор доступа ограничивает доступ к переменным, которые объявлены после него и до начала спецификатора доступа public, строки 9 -- 12. Таким образом, к переменным day, month, year, могут получить доступ только методы класса. Функции, не принадлежащие классу, не могут обращаться к этим переменным. Элементы данных или методы класса, объявленные после спецификатора доступа private, но до начала следующего спецификатора доступа называются закрытыми элементами данных и закрытыми методами класса. Следуя принципу наименьших привилегий и принципу хорошего программирования, целесообразно объявлять элементы данных после спецификатора доступа private, а методы класса -- после спецификатора доступа public. Тогда, для манипулирования элементами данных, объявляются специальные функции -- get и set. В класс CppStudio мы добавили два метода setDate() и getDate(), подробно рассмотрим каждый метод. Метод setDate() определён с 18 по 23 строки. Как уже ранее упоминалось, set -- функции инициализируют элементы данных, поэтому метод setDate() выполняет именно такую функцию. То есть метод setDate() инициализирует переменные day, month, year. Чтобы просмотреть, значения в закрытых элементах данных объявлена функция getDate(), которая возвращает значения из переменных day, month, year в виде даты. На этом определение класса закончено, в main(), как и всегда, создаем объект класса, и через объект вызываем его методы, строки 39 -- 41. Если бы элементы данных были объявлены после спецификатора public, мы бы смогли к ним обратиться точно так же, как и к методам класса. Результат работы программы показан на рисунке 2.

Рисунок 6 -- Классы в С++

КОНСТРУКТОР И ДЕСТРУКТОР КЛАССОВ В C++

Начнем с того, что когда мы создаем элементы (переменные) класса, мы не можем присвоить им значения в самом определении класса. Компилятор выдаст ошибку. Поэтому нам необходимо создавать отдельный метод (так называемую set-функцию) класса, с помощью которого и будет происходить инициализация элементов. При этом если необходимо создать, к примеру, 20 объектов класса, то чтобы инициализировать элементы потребуется 20 раз вызвать set-функции.

Тут нам как раз сможет помочь конструктор класса. Кстати, конструктор (от слова construct -- создавать) - это специальный метод класса, который предназначен для инициализации элементов класса некоторыми начальными значениями.

В отличие от конструктора, деструктор (от слова destruct -- разрушать) -- специальный метод класса, который служит для уничтожения элементов класса. Чаще всего его используют тогда, когда в конструкторе, при создании объекта класса, динамически был выделен участок памяти и необходимо, эту память очистить, если эти значения уже не нужны для дальнейшей работы программы.

Важно запомнить:

1. конструктор и деструктор, мы всегда объявляем в разделе public;

2. при объявлении конструктора, тип данных возвращаемого значения не указывается, в том числе -- void!!!;

3. у деструктора также нет типа данных для возвращаемого значения, к тому же деструктору нельзя передавать никаких параметров;

4. имя класса и конструктора должно быть идентично;

5. имя деструктора идентично имени конструктора, но с приставкой ~ ;

6. в классе допустимо создавать несколько конструкторов, если это необходимо. Имена, согласно пункту 2 нашего списка, будут одинаковыми. Компилятор будет их различать по передаваемым параметрам (как при перегрузке функций). Если мы не передаем в конструктор параметры, он считается конструктором по умолчанию;

7. в классе может быть объявлен только один деструктор;

Пример, который показывает, как работает конструктор:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46	# include <iostream> using namespace std; class AB //класс { private: int a; int b; public: AB() //это конструктор: 1) у конструктора нет типа возвращаемого значения! в том числе void!!! // 2) имя должно быть таким, как и у класса (в этом случае AB) { a = 0;//присвоим начальные значения переменным b = 0; cout << "Работа конструктора при создании нового объекта: " << endl;//и здесь же их отобразим на экран cout << "a = " << a << endl; cout << "b = " << b << endl << endl; } void setAB() // с помощью этого метода изменим начальные значения заданные конструктором { cout << "Введите целое число а: "; cin >> a; cout << "Введите целое число b: "; cin >> b; } void getAB() //выведем на экран измененные значения { cout << "a = " << a << endl; cout << "b = " << b << endl << endl; } }; int main() { setlocale(LC_ALL, "rus"); AB obj1; //конструктор сработает на данном этапе (во время создания объекта класса) obj1.setAB(); //присвоим новые значения переменным obj1.getAB(); //и выведем их на экран AB obj2; //конструктор сработает на данном этапе (во время создания 2-го объекта класса) return 0; }

Результат работы программы:

Рисунок 7.

Как видно из результата работы программы, конструктор срабатывает сразу, при создании объектов класса, поэтому, явно вызывать конструктор не нужно.

Как и в обычных функциях, мы можем передавать конструктору параметры. Через параметры, конструктору можно передавать любые данные, которые будут необходимы при инициализации объектов класса.

Рассмотрим еще один пример, это все та же программа, только в код внесены некоторые изменения. Тут же покажем принцип работы деструктора:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50	# include <iostream> using namespace std; class AB //класс { private: int a; int b; public: AB(int A, int B) //эти параметры мы передадим при создании объекта в main { a = A;//присвоим нашим элементам класса значения параметров b = B; cout << "Тут сработал конструктор, который принимает параметры: " << endl;//и здесь же их отобразим на экран cout << "a = " << a << endl; cout << "b = " << b << endl << endl; } void setAB() { cout << "Введите целое число а: "; cin >> a; cout << "Введите целое число b: "; cin >> b; } void getAB() { cout << "a = " << a << endl; cout << "b = " << b << endl << endl; } ~AB() // это деструктор. не будем заставлять его чистить память, пусть просто покажет где он сработал { cout << "Тут сработал деструктор" << endl; } }; int main() { setlocale(LC_ALL, "rus"); AB obj1(100, 100); //передаем конструктору параметры obj1.setAB(); //присвоим новые значения переменным obj1.getAB(); //и выведем их на экран AB obj2(200, 200); //передаем конструктору параметры }

Результат работы программы:

Рисунок 8.

Деструктор срабатывает в тот момент, когда завершается работа программы и уничтожаются все данные. Как видно, он сработал 2 раза, так как и конструктор.

ОБЪЯВЛЕНИЕ КЛАССА В ОТДЕЛЬНОМ ФАЙЛЕ

До сих пор объявление класса выполнялось в файле с главной функцией и всё работало. Предположим, необходимо написать какую-то программу, для этого необходимо воспользоваться классом CppStudio -- разработанный ранее нами класс. Чтобы воспользоваться этим классом, необходимо подключить файл, в котором он объявлен. Как мы уже говорили, подключение файлов выполняется с помощью препроцессорной директивы #include. Но даже, если мы сможем подключить файл с классом, появится новая проблема -- так как в файле с классом уже есть функция main(), то при построении проекта компилятор выдаст ошибку. Суть ошибки: «В проекте найдено несколько main() -- функций». Именно поэтому класс необходимо объявлять в отдельном файле, чтобы его можно было неоднократно использовать. Ранее мы объявляли в отдельном файле функции, таким же образом размещается класс в отдельном файле. Для этого необходимо выполнить 3 шага:

1. добавить в проект заголовочный файл *.h;

2. в заголовочном файле объявить пользовательский класс, в нашем случае -- CppStudio;

3. подключить заголовочный файл к программе, в нашем случае -- #include "CppStudio.h".

В зависимости от среды разработки, способы добавления файлов в проект могут отличаться, но суть задачи от этого не меняется. В MVS2010 заголовочный файл можно добавить, вызвав контекстное меню (клик правой кнопкой мыши) в «обозревателе решений», выбрав пункт «создать новый элемент». В появившемся диалоговом окне выбираем нужный нам тип файла -- это *.h и заполняем поле «Имя файла». Как и прежде, имя выбираем осмысленное, как правило, такое же, как и имя класса. Теперь к нашему проекту добавлен новый заголовочный файл -- CppStudio.h .

В только что созданном заголовочном файле объявляем класс и, если необходимо, подключаем дополнительные заголовочные. Вот, что должно было получиться:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32	// заголовочный файл CppStudio.h #include <iostream> using namespace std; // объявление класса class CppStudio // имя класса { private: // спецификатор доступа private int day, // день month, // месяц year; // год public: // спецификатор доступа public CppStudio(int date_day, int date_month, int date_year ) // конструктор класса { setDate(date_day, date_month, date_year); // вызов функции установки даты } void message() // функция (метод класса) выводящая сообщение на экран { cout << "nwebsite: cppstudio.comntheme: Classes and Objects in C + +n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio

Чтобы главная функция увидела созданный нами класс и смогла его использовать, необходимо включить определение класса в исполняемом файле, с функцией main(). Делается это так:

· MVS

· Code::Blocks

· Dev-C++

· QtCreator

1 2 3 4 5 6 7 8 9 10 11 12 13 14	// classes.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" // подключаем класс CppStudio #include "CppStudio.h" int main(int argc, char*argv[]) { CppStudio objCppstudio(11,11,2011); // объявление объекта и инициализвция элементов данных objCppstudio.message(); // вызов функции message objCppstudio.getDate(); // отобразить дату system("pause"); return 0; }

В строке 5 подключено определение класса CppStudio, только после этого можно создавать объекты класса, использовать его методы и т. д. Результат работы программы точно такой же, как и раньше, изменилась лишь структура проекта.

ОТДЕЛЕНИЕ ИНТЕРФЕЙСА ОТ РЕАЛИЗАЦИИ

Интерфейс класса -- конструкция, определяющая методы и свойства, предоставляемые классом. Реализация класса -- это способ осуществления работоспособности класса. До этого мы не отделяли интерфейс класса от его реализации, то есть реализация методов осуществлялась внутри класса. Отделение интерфейса от реализации класса выполняется для того, чтобы скрыть способ осуществления работоспособности класса. Отделение интерфейса от реализации выполняется за 5 шагов:

1. добавить в проект заголовочный файл *.h;

2. определить интерфейс класса в заголовочном файле

3. добавить в проект исполняемый файл *.cpp;

4. в исполняемом файле выполнить реализацию класса;

5. подключить заголовочный файл к программе.

Как добавить заголовочный файл в проект, мы уже знаем, точно также добавляется и исполняемый файл, имена этим файлам даются, как правило, одинаковые. Интерфейс класса должен выглядеть так:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	// заголовочный файл класса СppStudio.h // интерфейс класса // объявление класса class CppStudio // имя класса { private: // спецификатор доступа private int day, // день month, // месяц year; // год public: // спецификатор доступа public CppStudio(int, int, int); // конструктор класса void message(); // функция (метод класса) выводящая сообщение на экран void setDate(int, int, int); // установка даты в формате дд.мм.гг void getDate(); // отобразить текущую дату }; // конец объявления класса CppStudio

В интерфейсе класса остались объявленные переменные и прототипы методов класса. Теперь рассмотрим содержимое файла реализации методов класса.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28	// файл реализации класса CppStudio.cpp #include <iostream> using namespace std; // подключаем интерфейс класса к файлу его реализации #include "CppStudio.h" CppStudio::CppStudio(int date_day, int date_month, int date_year ) // конструктор класса { setDate(date_day, date_month, date_year); // вызов функции установки даты } void CppStudio::message() // функция (метод класса) выводящая сообщение на экран { cout << "nwebsite: cppstudio.comntheme: Classes and Objects in C + +n"; } void CppStudio::setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void CppStudio::getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; }

Чтобы связать интерфейс класса и его реализацию, необходимо в файле реализации подключить заголовочный файл с определением класса, строка 6 (выделенная строка). После этого можно объявлять методы класса. Методы класса объявляются точно так же как и функции, только перед именем метода необходимо написать имя класса и поставить унарную операцию разрешения области действия «::».

1 2 3 4 5	// синтаксис объявления методов класса вне тела класса /*возвращаемый тип данных*/ /*имя класса*/::/*имя метода*/(/* параметры метода*/) { // операторы }

Так как методы класса объявляются вне тела класса, то необходимо связать реализацию метода с классом, а для этого воспользуемся бинарной операцией разрешения области действия. Бинарная операция разрешения области действия привязывает метод, объявленный извне, к классу, имя которого совпадает с именем в объявлении метода. Вот именно поэтому в объявлении метода класса необходимо добавлять имя класса и операцию разрешения области действия.

Итак, интерфейс класса определён, методы класса объявлены, осталось подключить заголовочный файл в исполняемом файле с main() функцией и программа готова.

· MVS

· Code::Blocks

· Dev-C++

· QtCreator

1 2 3 4 5 6 7 8 9 10 11 12 13 14	// classes.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" // подключаем класс CppStudio #include "CppStudio.h" int main(int argc, char*argv[]) { CppStudio objCppstudio(11,11,2011); // объявление объекта и инициализвция элементов данных objCppstudio.message(); // вызов функции message objCppstudio.getDate(); // отобразить дату system("pause"); return 0; }

В строке 5 подключаем заголовочный файл класса, после чего можно создавать объекты этого класса.

Несколько советов о том, как следует формировать интерфейс будущего класса и что для этого надо или не надо делать.

ЦИКЛЫ FOR, WHILE И DO WHILE В ЯЗЫКЕ C++

Цикл -- многократное прохождение по одному и тому же коду программы. Циклы необходимы программисту для многократного выполнения одного и того же кода, пока истинно какое-то условие. Если условие всегда истинно, то такой цикл называется бесконечным, у такого цикла нет точки выхода.

В языке программирования С++ существуют такие циклы:

· цикл for

· цикл while

· цикл do while

Ш Тело цикла for будет выполняться до тех пор, пока условие будет истинно (т. е. true).

1 2 3 4 5 6	// форма записи оператора цикла for: for (/*выражение1*/; /*выражение2*/; /*выражение3*/ ) { /*один оператор или блок операторов*/; }

Если в теле цикла for должен выполниться один оператор, тогда фигурные скобки можно опустить:

1 2	for (/*выражение1*/; /*выражение2*/; /*выражение3*/) /*один оператор*/;

Ш Оператор цикла while или цикл while -- цикл, повторяющий одно и то же действие, пока условие продолжения цикла while остаётся истинным.

1 2 3 4 5 6	// форма записи цикла while while (/*условие продолжения цикла while*/) { /*блок операторов*/; /*управление условием*/; }

Условие продолжения цикла должно быть истинно true, как только условие стало ложным, выполняется выход из цикла. Также как и в условных операторах выбора, фигурные скобочки могут опускаться в том случае, если тело цикла -- это один оператор. Но, как правило, в цикле выполняется несколько операторов, так как кроме выполнения полезного действия необходимо делать условие цикла while ложным, иначе цикл будет бесконечным, а это, в свою очередь, приведет к зависанию программы.

Ш Цикл do while отличается от цикла while тем, что в do while сначала выполняется тело цикла, а затем проверяется условие продолжения цикла. Из-за такой особенности do while называют циклом с постусловием. Таким образом, если условие do while заведомо ложное, то хотя бы один раз блок операторов в теле цикла do while выполнится. В итоге do while отличается от цикла while структурой. Если в while сначала выполняется проверка условия продолжения цикла, и если условие истинно, то только тогда выполняется тело цикла. Цикл do while работает с точностью до наоборот, сначала выполняется тело цикла, а потом проверяется условие, вот почему тело цикла do while, хотя бы раз, выполнится.

1 2 3 4 5 6	// форма записи оператора цикла do while: do // начало цикла do while { /*блок операторов*/; } while (/*условие выполнения цикла*/); // конец цикла do while

В начале цикла do while пишется зарезервированное слово do, после идут фигурные скобочки, которые можно опускать, в случае использования одного оператора в теле цикла do while. После закрывающей фигурной скобочки, обозначающей конец тела цикла do while, стоит условие цикла do while, после которого обязательно нужно ставить точку с запятой.



ПРАКТИЧЕСКАЯ ЧАСТЬ

Программа разрабатывается в объектно-ориентированной среде программирования Visual Studio 2017, как консольное приложение.

Код программы:

// начало кода

// ConsoleApplication7.cpp: определяет точку входа для консольного приложения.

//

#include "stdafx.h"

#include "iostream"

using namespace std; // начало объявления класса

double f(double x) {

return sin((3 * x) / 2) + 0.5;

}

class integralTrap // имя класса для вычисления интеграла методом трапеции

{

public: // спецификатор доступа public

integralTrap(double A, double B, double N, double EPS) {

a = A;

b = B;

n = N;

eps = EPS;

}

double trap() {

double x = a; // значению x присвоим значение нижнего предела

double S = 0; // изначально обнуляем значение площади интеграла

while (x < b)

{

S = S + (f(x + n) + f(x))*n / 2; // вычисление площади по формуле

if (0.5*(f(x + n) + f(x))*n >= eps) // если разность значения площади и предыдущего значения площади меньше или равна заданной точности Eps, то выводим значение на экран

x = x + n; // х увеличиваем на шаг

else

break;

}

return S;

}

private: // спецификатор доступа private

double a, b, eps;

int n;

}; // конец объявления класса integralTrap

class integralSimp // имя класса для вычисления интеграла методом Симпсона

{

public: // спецификатор доступа public

integralSimp(double A, double B, double N, double EPS) {

a = A;

b = B;

n = N;

eps = EPS;

}

double simpson_integral() {

const double h = (b - a) / n; // формула вычисления шага

double k1 = 0, k2 = 0;

for (int i = 1; i < n; i += 2) {

k1 += f(a + i * h);

k2 += f(a + (i + 1)*h);

}

return h / 3 * (f(a) + 4 * k1 + 2 * k2); // вычисление площади по формуле

}

double result() {

double s;

double s1 = simpson_integral(); // первое приближение для интеграла

do {

s = s1; // второе приближение

n = 2 * n; // увеличение числа шагов в два раза,

// т.е. уменьшение значения шага в два раза

s1 = simpson_integral();

} while (fabs(s1 - s) > eps); // если разность значения площади и предыдущего значения площади меньше или равна заданной точности Eps, то выводим значение на экран

return s1;

}

private: // спецификатор доступа private

double a, b, eps;

int n;

}; // конец объявления класса integralSimp

int main()

{

const double a = 0; // значение нижнего предела

const double b = 3.14; // значение верхнего предела

double eps; // значение точности

int n = 1;

cout << "Integral : (sin3x/2 + 0.5)dx" << endl;

cout << "Interval : [0 , 3.14]" << endl;

cout << "Enter accurancy - Eps" << endl;

cin >> eps;

while (eps > 1 || eps < 0) {

cin >> eps;

}

integralSimp simp = integralSimp(a, b, n, eps);

cout << "Result of method Simpsona :" << endl;

cout << simp.result();

cout << endl;

cout << "Result of method trapeze" << endl;

integralTrap traps = integralTrap(a, b, n, eps);

cout << traps.trap();

cout << endl;

cout << "Press any button for exit" << endl;

return 0;

}

// конец кода



ВИЗУАЛИЗАЦИЯ МЕТОДОВ

Запускается программа с помощью сочетания клавиш Ctrl+F5. После их нажатия открывается файл с выведенным интегралом и его интервалом, а также сообщением о введении точности Eps.

Рисунок 9 - Ввод точности Eps

После введения точности Eps=0.0001, в файле видим следующую запись: первое - Результат метода Симпсона: 2.2382 и второе - Результат метода трапеции: 2.02138.

Рисунок 10 - Вывод данных

Для продолжения программирования либо же завершения работы в Visual Studio 2017 требуется нажать любую клавишу.



ЗАКЛЮЧЕНИЕ

В процессе разработки курсовой работы были проработаны следующие методы вычисления определенных интегралов - метод трапеций и метод Симпсона (парабол). Был представлен ход вычисления интеграла в виде кода программы, благодаря которой и задавалась проверка на точность вычислений.

Также в процессе выполнения курсовой работы были закреплены практические навыки по разработке пользовательских приложений при помощи объектно-ориентированного языка программирования в Visual Studio 2017 и современных компьютерных технологий обработки информации и навыки в составлении текстовой документации.

Разработанный мною код программы предоставит пользователю больше свободного времени, чем он имел бы, если бы вычислял определённый интеграл самостоятельно. А поскольку данная программа решает заданный интеграл двумя методами одновременно специалист своего дела может скорее перейти к задачам физического и технического характеров.



СПИСОК ЛИТЕРАТУРЫ И САЙТОВ

1. Михеева Е.В. Информационные технологии в профессиональной деятельности: Учебное пособие для сред. проф. образования. - 2-е издание, стер. - М.: Издательский центр "Академия", 2005. - 384 с.

2. http://mathprofi.ru/formula_simpsona_metod_trapecij.html

3. http://cppstudio.com/post/439/

4. http://cppstudio.com/post/352/

5. http://cppstudio.com/post/361/

6. http://cppstudio.com/post/348/

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