// ей результат умножения Width и Length

unsigned short int Area = (Width * Length);

cout << "Width: " << Width << "\n";

cout << "Length: " << Length << endl;

cout << "Area: " << Area << endl;

char responce;

cin >> responce;

return 0;

}

2.2 Разработка проектов с использованием компонентов пользовательского интерфейса MS Visual C++ 2010

Для того чтобы приступить к созданию программы в Visual С++ или, как принято говорить, начать работу над проектом, надо:

1. В меню File окна Microsoft Visual Studio выбрать команду New > Project.

2. В открывшемся окне New Project (рис. 2.1) раскрыть список Visual С++ и выбрать тип приложения -- CLR.

3. Выбрать вид приложения -- Windows Forms Application Visual С++.

4. В поле Name ввести имя проекта и нажать кнопку ОК.



Рис. 2.1. В окне New Project надо выбрать язык разработки, тип приложения и задать имя проекта

В результате описанных действий будет создан проект Visual Studio -- совокупность файлов, необходимых для создания программы.

Окно среды Microsoft Visual Studio 2010 в начале работы над новым проектом приведено на рис. 2.2. В заголовке окна отображается имя проекта, над которым в данный момент идет работа.

Рис. 2.2 - Окно среды разработки Visual С++ работы над новым проектом Windows Forms

В верхней части окна находится строка меню и область отображения панелей инструментов. По умолчанию в области отображения панелей инструментов выводится панель Standard. Чтобы сделать доступными другие панели инструментов, надо выбрать команду View > Toolbars и в раскрывшемся списке сделать щелчок на имени нужной панели.

Центральную часть окна Visual С++ занимает окно конструктора (Designer) формы (рис. 1.2). В нем находится форма -- заготовка окна приложения (окно программы во время его разработки принято называть формой). В окне дизайнера формы в графической форме отображаются инструкции программы (обратите внимание, в заголовке окна указано имя h-файла), обеспечивающие создание окна.

В правой части главного окна Visual Studio обычно отображаются окна Toolbox и Properties.

В окне Toolbox (рис. 2.3) находятся компоненты, которые можно поместить (перетащить) на форму. Компонент-- это объект, реализующий некоторую функциональность. Например, в группе Common Controls находятся компоненты, реализующие пользовательский интерфейс (Label -- область отображения текста; TextBox-- поле ввода/редактирования текста; Button -- командная кнопка), а в группе Data -- компоненты доступа к базам данных.

Рис. 2.3 - Окно ToolboxРис. 2.4 - Окно Properties

В окне Properties (рис. 2.4) отображаются свойства выбранного (выделенного) в данный момент объекта-- компонента или, если ни один из элементов не выделен, самой формы. Обратите внимание, имя и тип объекта отображаются в верхней части окна Properties.

Окно Properties используется для редактирования значений свойств объектов и, как следствие, изменения их вида и поведения. Например, чтобы изменить текст в заголовке формы, надо изменить значение свойства Text.

При отображении свойства могут быть объединены в группы по функциональному признаку (Categorized) или упорядочены по алфавиту (Alphabetical). Чтобы изменить способ отображения, надо сделать щелчок на соответствующей кнопке, находящейся в верхней части окна Properties.

Сделав в окне Properties щелчок на кнопке Events (правая крайняя), можно увидеть события, которые способен воспринимать выбранный объект (компонент или форма).

Создание графического интерфейса приложения

Процесс разработки программы в Microsoft Visual C++ рассмотрим на примере - создадим приложение (программы, предназначенные для решения прикладных задач, принято называть приложениями), позволяющее посчитать доход по вкладу.

Форма

Работа над приложением начинается с создания стартовой формы -- главного окна программы.

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

Настройка формы (а также компонентов) осуществляется путем изменения значений свойств. Свойства объекта (формы, компонента) определяют его вид и поведение. Например, свойство Text определяет текст заголовка окна, а свойство startPosition -- положение окна в момент появления его на экране.

Для изменения значений свойств объектов используется окно Properties. В левой колонке окна перечислены свойства объекта, выбранного в данный момент, в правой -- указаны значения свойств. Имя выбранного объекта отображается в верхней части окна Properties.

Чтобы в заголовке окна отображалось название программы, надо изменить значение свойства Text. Для этого следует щелкнуть левой кнопкой мыши в поле значение свойства Text (в поле появится курсор), ввести в поле редактирования текст Доход и нажать клавишу <Enter>.

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

Некоторые свойства являются сложными. Они представляют собой совокупность других (уточняющих) свойств. Например, свойство Size, определяющее размер формы (компонента), представляет собой совокупность свойств Width и Height. Перед именами сложных свойств стоит значок > , в результате щелчка на котором раскрывается список уточняющих свойств. Значение уточняющего свойства можно задать (изменить) обычным образом -- ввести нужное значение в поле редактирования.

Размер формы (компоненты) можно изменить и с помощью мыши путем перемещения границы. По окончании перемещения границы значения свойств Width и Height будут соответствовать установленному размеру формы.

В результате выбора некоторых свойств, например Font, в поле значения свойства отображается кнопка, на которой изображены три точки. Это значит, что задать значение свойства можно в дополнительном диалоговом окне, которое появится в результате щелчка на этой кнопке. Например, значение свойства Font можно задать путем ввода значений уточняющих свойств (Name, Size, Style и др.), а можно воспользоваться стандартным диалоговым окном Шрифт, которое появится в результате щелчка на кнопке с тремя точками.

Компоненты

Поля ввода/редактирования, поля отображения текста, командные кнопки, списки, переключатели и другие элементы, обеспечивающие взаимодействие пользователя с программой, называют компонентами пользовательского интерфейса. Они находятся в окне Tollbox на вкладке Common Control.

Программа "Доход" должна получить от пользователя исходные данные -- сумму и срок вклада. Для ввода данных с клавиатуры предназначен компонент TextBox. Таким образом, на форму разрабатываемого приложения нужно поместить два компонента TextBox.

Чтобы на форму добавить компонент TextBox, надо:

1. В палитре компонентов (окно Toolbox) раскрыть вкладку Common Control. Сделать щелчок на значке компонента TextBox.

2. Установить указатель мыши в ту точку формы, в которой должен быть левый верхний угол компонента, и сделать щелчок левой кнопкой мыши.

Каждому добавленному компоненту среда разработки присваивает имя, которое состоит из названия компонента и его порядкового номера. Например, первый добавленный на форму компонент TextBox получает имя textBoxl, второй -- textBox2. Программист путем изменения значения свойства Name может поменять имя компонента. Однако в простых программах имена компонентов, как правило, не меняют.

Отображение текста на поверхности формы (подсказок, результата расчета) обеспечивает компонент Label. В окне программы "Доход" текст отображается слева от полей ввода-редактирования (информация о назначении полей). Результат расчета также отображается в окне программы. Поэтому в форму надо добавить три компонента Label.

Добавляется компонент Label на форму точно так же, как и поле редактирования (компонент TextBox).

Последнее, что надо сделать на этапе создания формы, -- добавить на форму командную кнопку Расчет. Назначение этой кнопки очевидно. Командная кнопка, компонент Button, добавляется на форму точно так же, как и другие компоненты. Значок компонента Button находится на вкладке Common Controls.

Окончательный вид формы с установленными компонентами имеет следующий вид (рис 2.5.)

Рис. 2.5 - Окончательный вид формы для приложения «Доход».

Завершив работу по созданию формы, можно приступить к программированию -- созданию процедур обработки событий.

Событие и функция обработки события

Событие -- это то, что происходит во время работы программы. Например, командная кнопка может реагировать на щелчок кнопкой мыши -- событие click. Реакцией на событие должно быть какое-либо действие. В Visual С++ реакция на событие реализуется как функция обработки события. Таким образом, для того чтобы программа в ответ на действия пользователя выполняла некоторую работу, программист должен написать функцию обработки соответствующего события.

Чтобы создать функцию обработки события, сначала надо выбрать компонент, для которого создается функция обработки события. Для этого в окне конструктора формы надо сделать щелчок левой кнопкой мыши на нужном компоненте. Затем в окне Properties щелчком на кнопке Events нужно открыть вкладку Events, выбрать событие (сделать щелчок мышью на имени события), в поле значения свойства ввести имя функции обработки события и нажать клавишу <Enter>.

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

В листинге 2.1 .приведена функция обработки события click для кнопки Расчет.

// Листинг 2.1. Обработка события click для кнопки Расчет

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

{

double sum; // сумма

int period; // срок

double percent; // процентная ставка

double profit; // доход

sum = Convert::ToDouble(textBox1->Text);

period = Convert::ToInt32(textBox2->Text);

if (sum < 10000)

percent = 8.5;

else

percent = 12;

profit = sum * (percent/100/12) * period;

label3->Text = "Процентная ставка: " + percent.ToString("n") + "%\n" +

"Доход:" + profit.ToString("c");

}

Функция button1ciick вычисляет доход по вкладу и выводит результат в поле компонента label3. Исходные данные (сумма и срок вклада) вводятся из полей редактирования textBox1 и textBox2 путем обращения к свойству Text. Значением свойства Text является строка, которая находится в поле редактирования. Свойство Text строкового типа, поэтому для преобразования строк в числа используются принадлежащие пространству имен System:: Convert функции ToDouble и ToInt32. Следует обратить внимание, что функция ToDouble возвращает результат только в том случае, если строка, переданная ей в качестве параметра, является изображением дробного числа, что предполагает использование запятой в качестве десятичного разделителя (при стандартной для России настройке операционной системы). Параметр функции ToInt32 должен быть изображением целого числа. Другие функции преобразования строк приведены в табл. 2.1.

Таблица 2.1. Функции преобразования строк

Вычисленные значения процентной ставки и величины дохода выводятся в поле label3 путем присваивания значения свойству Text. Для преобразования дробного числа в строку (свойство Text строкового типа) используется функция (метод) ToString. Параметр метода ToString задает формат строки-результата: "с" -- финансовый (от англ. currency); "n" -- числовой (от англ. number). Следует обратить внимание, при использовании финансового формата после числового значения выводится обозначение денежной единицы (в соответствии с настройкой операционной системы). В табл. 2.2 приведены возможные форматы представления числовой информации.

Таблица 2.2. Форматы представления чисел

3.Задачи для самостоятельного решения (в графическом режиме)

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

Вариант 2. Для тела, брошенного под углом к горизонту с начальной скоростью , определите дальность полета тела . Воспользуйтесь соотношением:

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

и .

Вариант 4. Человек, находящийся на краю обрыва высотой , бросает с начальной скоростью камень под углом к горизонту. Написать программу, которой по введенному пользователем времени определяется положение камня (высота от дна обрыва и расстояние до края обрыва ). Предусмотреть случай, когда камень упал на дно обрыва. Уравнения движения камня имеют вид: вдоль горизонтальной оси , вдоль направленной вверх вертикальной оси (координата отсчитывается от дна обрыва). Время полета камня определяется условием , т.е. , откуда получаем:

Вариант 5. Самолет летит на высоте над землей со скоростью . При подлете к наземному объекту он сбрасывает бомбу. Написать программу, которой вычисляется подлетное расстояние до объекта, на котором производится сбрасывание бомбы. Воспользоваться тем, что бомба до земли летит за время . Расстояние вычисляется как .

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

Вариант 7. Мотоциклист едет из пункта в пункт и обратно. Написать программу, в которой по известной средней скорости движения , расстоянию между пунктами и времени движения из пункта в пункт вычислить среднюю скорость мотоциклиста при движении из пункта в пункт и скорость при движении из пункта в пункт (воспользуйтесь соотношениями и ).

Вариант 8. Поезд метро едет на протяжении времени с постоянной скоростью , а затем такой же промежуток времени тормозит до полной остановки. Написать программу для вычисления пути , пройденного поездом. При составлении программы воспользуйтесь набором соотношений: ( и пути, пройденные поездом при равномерном и равнозамедленном движении соответственно), , , где - ускорение при равнозамедленном движении. Для сравнения рассчитайте результат по соотношению .

Вариант 9. Математический маятник совершает колебания по закону . Частота маятника известна. В начальный момент координата в раз меньше амплитуды . В какой момент времени отклонение маятника максимально? Написать программу для определения параметра при условии, что параметры и вводятся пользователем. При составлении программы воспользоваться соотношениями и .

Вариант 10. Написать программу для вычисления ускорения свободного падения как функции высоты над поверхностью Земли на основании значений гравитационной постоянной , массы Земли и ее радиуса . Воспользоваться тем, что на тело массой действует сила , которая по закону всемирного тяготения равна , откуда получаем

Вариант 11. Написать программу для расчета ускорения тела массой , которое находится на горизонтальной плоскости и к которому под углом (к горизонту) приложена сила . Коэффициент трения тела о плоскость равен . Предусмотреть вариант, когда тело неподвижно. Воспользоваться тем, что если тело движется, на него вдоль плоскости движения действует равнодействующая сила , где сила трения . Ускорение тела а ищется из второго закона Ньютона .

Вариант 12. Тело соскальзывает с наклонной плоскости (угол наклона ) с ускорением . Написать программу для определения коэффициента трения тела о плоскость. Воспользоваться тем, что по второму закону Ньютона , где сила трения . Отсюда получаем .

3.1 Методы и приемы используемые при работе с объектами

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

// overLoad Constr.cpp : Defines the entry point for the console application.

//

// Перегрузка конструкторов.

#include "stdafx.h"

#include <iostream>

using namespace std;

#include <conio.h>

class Sample {

int x;

int y;

public:

// Перегрузим конструктор по умолчанию.

Sample () { x = y = 0; }

// Конструктор с одним параметром.

Sample (int i) { x = y = i; }

// Конструктор с двумя параметрами.

Sample(int i, int j) { x = i; y = j; }

// методы доступа

int get_x(){ return x; }

int get_y(){ return y; }

};

int main() {

Sample t; // активизация конструктора по умолчанию

Sample tl(5);// используем Sample(int)

Sample t2(9, 10); // используем Sample(int, int)

cout << "t.x: " << t.get_x() << ", t.y: " << t.get_y() << "\n" ;

cout << "tl.x: " << tl.get_x() << ", tl.y: " << tl.get_y() << "\n";

cout << "t2.x: " << t2.get_x() << ", t2.y: " << t2.get_y() << "\n";

getch();

return 0 ;

}

Вот вывод этой программы:

t.х: 0, t.y: 0

tl.x: 5, tl.y: 5

t2.x: 9, t2.y: 10

В программе создаются три конструктора. Первым объявлен конструктор без параметров; он инициализирует х и у, присваивая им значение 0. Этот конструктор становится конструктором по умолчанию, замещая собой конструктор по умолчанию, автоматически предоставляемый С++. Второй конструктор принимает один параметр, присваивая его значение одновременно х и у. Третий конструктор принимает два параметра, инициализируя х и у индивидуально.

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

Присваивание объектов

Если у вас есть два объекта одного типа (другими словами, два объекта одного класса), тогда один объект можно присвоить другому. При этом недостаточно, чтобы два класса были физически одинаковы -- они должны иметь еще и одно имя. По умолчанию, если один объект присваивается другому, второму объекту фактически присваивается побитовая (точная) копия данных первого объекта. В этом случае после присваивания оба объекта будут идентичны, но существовать независимо. Приведенная ниже программа демонстрирует присваивание объектов:

Пример присваивания объектов.

Важно понимать, что все данные-члены одного объекта при выполнении присваивания присваиваются данным-членам другого объекта. Это относится и к сложным данным, таким как массивы. Например, в следующей версии уже знакомого нам класса stack символы реально помещаются только в стек s1, но после выполнения присваивания массив stck объекта s2 также содержит символы a, b и с.

#include <iostream>

using namespace std;

#define SIZE 10

// Объявление класса stack для символов

class stack {

char stck[SIZE]; // содержит стек

int tos; // индекс вершины стека

public:

stack(); // конструктор

void push(char ch); // помещает в стек символ

char pop(); // выталкивает символ из стека

};

// Инициализация стека

stack::stack(){

cout << "Работа конструктора стека\n";

tos = 0;

}

// Помещение символа в стек

void stack::push(char ch) {

if (tos==SIZE) {

cout « "Стек полон \n";

return;

}

stck[tos] = ch;

tos++;

}

// Выталкивание символа из стека

char stack::pop(){

if (tos==0) {

cout << "Стек пуст \n";

return 0; // возврат нуля при пустом стеке

}

tos--;

return stck[tos];

}

int main() {

// Образование двух, автоматически инициализируемых стеков

stack s1, s2;

int i ;

s1.push(`a'1);

s1.push('b');

s1.push(`с' 1) ;

// копирование s1 в s2

s2 = s1; // теперь s2 и s1 идентичны

for(i=0; i<3; i++) cout << "символ из s1:" « sl.pop()

« "\n";

for(i=0; i<3; i++) cout << "символ из s2:" « s2.pop()

« "\n";

return 0;

}

При присваивании одного объекта другому необходимо быть очень внимательным.Вот вывод этой программы:

ob1 перед присваиванием: а равно 10 b равно 20

оb2 перед присваиванием: а равно 0 b равно 0

ob1 после присваивания: а равно 10 b равно 20

ob2 после присваивания: а равно 10 b равно 20

ob1 после изменения оb1: а равно -1 b равно -1

ob2 после изменения оb1: а равно 10 b равно 20

Как видно из этой программы, присваивание одного объекта другому создает два объекта, содержащих одни и те же значения. Однако в остальном эти два объекта совершенно независимы. Так, последующая модификация данных одного объекта никак не отражается на данных другого.

Передача объектов функциям

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

// Передача функции объекта.

#include <iostream>

using namespace std;

class MyClass {

int val;

public:

MyClass(int i) { val = i;}

int getval() { return val; }

void setval(int i) { val = i; }

};

void display (MyClass ob){

cout << ob.getval() << '\n';

}

void change (MyClass ob)

{

ob.setval(100) ; // не влияет на аргумент

cout << "Значение ob внутри change () : ";

display(ob);

}

int main() {

MyClass a(10) ;

cout << "Значение а перед вызовом change(): ";

display(a);

change (a) ;

cout << "Значение а после вызова change(): ";

display(a);

return 0;

}

Ниже показан вывод программы:

Значение а перед вызовом change(): 10

Значение ob внутри change(): 100

Значение а после вызова change(): 10

Как видно из вывода программы, изменение значения ob внутри change() не влияет на значение а внутри main().

Конструкторы, деструкторы и передача объектов

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

// ConstrDestr.cpp : Defines the entry point for the console application.

//

// Конструкторы, деструкторы и передача объектов

#include "stdafx.h"

#include <iostream>

using namespace std;

#include <conio.h>

class MyClass {

int val;

public:

MyClass(int i) { val = i ;

cout << "In constructor \n" ;

}

~MyClass () { cout << " Delete\n"; }

int getval () { return val; }

};

void display(MyClass ob) {

cout << ob.getval() << '\n';

}

int main() {

{

MyClass a(10);

cout << "before display(). \n";

display(a);

cout << "\nafter display() . \n";

}

getch();

return 0;

}

Результатом работы программы будет этот неожиданный вывод:

Внутри конструктора

Перед вызовом display () .

10

Уничтожаем

После возврата из display().

Уничтожаем // Обратите внимание на второе сообщение "Уничтожаем".

Вы видите, что по ходу программы конструктор вызывается один раз (что происходит, когда создается объект а), но имеются два вызова деструктора. Посмотрим, почему так получается.

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

Когда при вызове функции создается копия аргумента, обычный конструктор не вызывается. Вместо этого вызывается конструктор копий объекта. Конструктор копий определяет, каким образом должна создаваться копия объекта. (Позже в этой работе будет рассказано, как создать собственный конструктор копий.) При этом, если в классе конструктор копий не описан явным образом, С++ предоставляет такой конструктор по умолчанию. Конструктор копий по умолчанию создает побитовую (т. е| полностью идентичную) копию объекта. Причина, по которой создается именно побитовая копия, если вдуматься, очевидна. Поскольку обычный конструктор используется для той или иной инициализации объекта, он не должен вызываться ради копирования уже существующего объекта. Такой вызов изменит содержимое объекта. Передавая объект функции, вы хотите использовать текущее, а не начальное состояние объекта.

Однако, когда функция завершается, и копия объекта, использованная в качестве аргумента, уничтожается, вызывается функция деструктора. Это необходимая операция, так как объект уходит из области видимости. Вот почему в последнем примере мы видели два вызова деструктора. Первый вызов был сделан, когда параметр функции display() вышел из области видимости. Второй - когда при завершении программы был уничтожен объект а внутри main().

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

Передача объектов по ссылке

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

// Конструкторы, деструкторы и передача объектов.

#include <iostream>

using namespace std;

#include <conio>

class MyClass {

int val;

public:

MyClass(int i) { val = i ;

cout << "Внутри конструктора\n";

}

~MyClass() { cout << "Уничтожаем\n"; }

int getval () { return val; }

void setval(int i) { val = i; }

};

void display (MyClass &ob){ //Здесь объект класса MyClass передается по ссылке.

cout << ob.getval() << '\n';

}

void change(MyClass &ob)

{

ob.setval(100) ;

}

int main() {

MyClass a(10) ;

cout << "Перед вызовом display() . \n";

display(a);

cout << "После возврата из display() .\n";

change(a) ;

cout << "После вызова change().\n";

display(a);

getch();

return 0;

}

Ниже приведен вывод этой программы:

Внутри конструктора

Перед вызовом display().

10

После возврата из display () .

После вызова change().

100

Уничтожаем

В этой программе обе функции, и display(), и change(), используют передачу параметра по ссылке. Следовательно, в функцию передается не копия аргумента, а его адрес, и функция выполняет операции непосредственно над аргументом. Например, когда вызывается фуню change(), ей по ссылке передается а. Изменения параметра ob, выполненные в change(), влияют на а в main(). Заметьте также, что выполняются только по одному вызову конструктора и деструктора. Так пронсходит потому, что создается и уничтожается только один объект, а во временных объектах эта программа не нуждается.

3.2Потенциальные проблемы при передаче объектов

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

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

Возврат объектов

Объекты могут не только передаваться в функции, но и возвращаться из них. Для возврата объекта прежде всего необходимо при объявлении функции указать, что она возвращает тип класса. В самой функции следует вернуть объект, используя обычное предложение return. Приведенная ниже программа имеет функцию-член с именем mkBigger( ). Эта функция возвращает объект, который придает переменной val значение вдвое большее, чем вызывающий объект:

// Возврат объектов.

#include <conio>

#include <iostream>

using namespace std;

class MyClass {

int val;

public:

// Обычный конструктор.

MyClass(int i) { val = i ;

cout << "Внутри конструктора\n";

}

~MyClass () {

cout << "Уничтожаем\n";

}

int getval() { return val; } // Возврат объекта.

MyClass mkBigger () { //mkBigger( ) возвращает объект класса MyClass.

MyClass ob(val * 2);

return ob;

}

};

void display(MyClass ob)

{

cout << ob.getval() << '\n';

}

int main()

{

cout << "Перед конструированием a.\n";

MyClass a(10);

cout << "После конструирования a.\n\n";

cout << "Перед вызовом display(). \n";

display(a);

cout << "После возврата из display().\n\n";

cout << "Перед вызовом mkBigger().\n";

a = a.mkBigger();

cout << "После возврата из mkBigger().\n\n";

cout << "Перед вторым вызовом display(). \n";

display(a);

cout << "После возврата из display().\n\n";

getch();

return 0 ;

}

Программа выводит следующее:

Перед конструированием а.

Внутри конструктора

После конструирования а.

Перед вызовом display () .

10

Уничтожаем

После возврата из display().

Перед вызовом mkBigger().

Внутри конструктораЧ

Уничтожаем

Уничтожаем //Обратите внимание на второе сообщение "Уничтожаем'

После возврата из mkBigger().

Перед вторым вызовом display() .

20

Уничтожаем

После возврата из display().

Уничтожаем

В этом примере функция mkBigger() создает локальный объект с именем о, у которого значение val вдвое больше, чем у вызывающего объекта. Этот объект затем возвращается функцией и присваивается объекту а внутри main(). Далее о уничтожается, в результате чего появляется первое сообщение "Уничтожаем". Но откуда берется второй вызов деструктора?

Когда функция возвращает объект, то автоматически создается временный объект, содержащий возвращаемое значение. Именно этот объект фактически возвращается функцией. После того, как значение возвращено, этот объект уничтожается. Вот почему на экран было выведено второе сообщение "Уничтожаем" перед сообщением "После возврата из mkBigger()". Это индикация уничтожения временного объекта.

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

Последнее замечание: функция может вернуть объект по ссылке, но нужно проявлять осторожность, чтобы объект, на который указывает ссылка, не ушел из области видимости при завершении функции.

Создание и использование конструктора копий

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

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

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

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

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

§ когда один объект явным образом инициализирует другой, это имеет место при объявлении;

§ когда создается копия объекта с целью передачи ее в функцию:

§ когда создается временный объект (обычно в качестве возвращаемого значения).

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

имя-класса (const имя-класса & объект) {

//тело конструктора

}

Здесь объект представляет собой ссылку на объект, используемый для инициализации другого объекта. Пусть, например, у нас есть класс MyClass, и у есть объект типа MyClass. Тогда следующие предложения будут вызывать конструктор копий класса MyClass:

class х = у; //у явным образом инициализирует х

func1(у);//у передается как параметр

у = func2(); //У принимает возвращаемый объект

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

Не забывайте, что конструктор копий не вызывается, когда один объект присваивается другому. Например, в приведенном ниже фрагменте конструктор копий вызван не будет:

MyClass х;

MyClass у;

х = у; // здесь конструктор копий не вызывается.

Последнее предложение обслуживается оператором присваивания, а не конструктором копий.

Приведенная ниже программа демонстрирует создание конструктора копий:

// cpyConstr.cpp : Defines the entry point for the console application.

//

/* Конструктор копий активизируется, когда объект передается функции. */

#include "stdafx.h"

#include <iostream>

using namespace std;

#include <conio.h>

class MyClass {

int val;

int copynumber;

public:

// Обычный конструктор.

MyClass(int i) { val = i ;

copynumber = 0 ;

cout << "In constructor\n";

}

// Конструктор копий

MyClass (const MyClass &o) {

val = o.val;

copynumber = o.copynumber + 1;

cout << "In copy constructor.\n";

}

~MyClass() {

if(copynumber == 0)

cout << "Delete primitive.\n";

else

cout << "Delete copy " << copynumber << "\n";

}

int getval() { return val; }

};

void display(MyClass ob)

{cout << ob.getval() << '\n'; }

int main() {

{MyClass a(10) ;

display(a);}

getch();

return 0;

}

Программа выводит на экран следующее:

Внутри обычного конструктора

Внутри конструктора копий.

10

Уничтожение копии 1

Уничтожение оригинала.

Вот что происходит при запуске программы. Когда внутри main() создается объект а, значение его переменной copynumber устанавливается в 0 обычным конструктором. Далее а передается параметру ob функции display(). В процессе передачи параметра вызывается конструктор копий, и создается копия а. Конструктор копирования, выполняя свой код, инкрементирует значение copynumber. Когда display() завершается ob уходит из области видимости. Это приводит к вызову его деструктора. Наконец, когда завершается main(), а уходит из области видимости.

Дружественные функции

В принципе к закрытым членам класса имеют доступ только другие члены этого класса. Однако имеется возможность организовать доступ к закрытым членам класса из функции, не входящей в данный класс, посредством объявления ее другом класса. Чтобы сделать функцию другом класса (создать дружественную классу функцию), вы включаете ее прототип в открытую (public) секцию объявления класса и предваряете ее ключевым словом friend. Например, в приведенном ниже фрагменте функция frnd() объявлена другом класса MyClass:

class MyClass {

// . . .

public:

friend void frnd(MyClass ob) ;

// . . .

};

Вы видите, что ключевое слово friend предваряет остальные элементы прототипа. Функция может быть другом более чем одного класса.

Ниже приведен короткий пример использования дружественной функции для выяснения того, имеют ли закрытые поля класса MyClass общий знаменатель:

// Демонстрация дружественной функции.

#include <iostream>

using namespace std;

class MyClass {

int a, b;

public :

MyClass(int i, int j) { a=i; b=j; }

friend int comDenom(MyClass x) ; // дружественная функция

};

/* Обратите внимание на то, что comDenom ()

не является функцией-членом какого-либо класса. */

int comDenom(MyClass х)

{

/* Поскольку comDenom() дружественна классу MyClass,

она может непосредственно обращаться к а и Ь. */

int max = х.а < x.b ? х.а : x.b;

for(int i=2; i <= max; i++)

if((x.a%i)==0 && (x.b%i)==0) return i;

return 0;

}

int main()

MyClass n(18, 111);

if(comDenom(n))

cout << "Общий знаменатель равен " << comDenom(n) << "\n";

else

cout << "Общего знаменателя нет.\n";

return 0;

}

В этом примере функция comDenom() не является членом MyClass. Однако она имеет полный доступ к закрытым членам MyClass. Конкретно, она может обратиться к х.а и x.b. Заметьте также, . что comDenom() вызывается обычным образом, т. е. без связи с каким-либо объектом и без оператора-точки. Поскольку comDenom() не является функцией-членом, ее не надо уточнять именем объекта (собственно говоря, ее нельзя уточнять именем объекта). Обычно дружественной функции передаются один или несколько объектов класса, которому она является другом, как это и имеет место в случае comDenom().

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

Третья причина, оправдывающая введение в язык дружественных функций, заключается в том, что в некоторых случаях два или несколько классов могут содержать члены, взаимосвязанные с другими частями вашей программы. Представьте себе, например, два различных класса, Cube и Cylinder, которые определяют характеристики куба и цилиндра, причем одной из характеристик является цвет объекта. Чтобы получить возможность легко сравнивать цвета куба и цилиндра, вы можете определить дружественную функцию, которая сравнивает цветовые характеристики двух объектов, возвращая истину, если цвета совпадают и ложь, если они различаются. Приведенная ниже программа иллюстрирует эту идею:

// Дружественные функции могут быть друзьями двух или более классов.

#include <iostream>

using namespace std;

class Cylinder; // упреждающее объявление

enum colors { red, green, yellow };

class Cube {

colors color;

public:

Cube (colors c) { color = c; }

friend bool sameColor(Cube x, Cylinder y) ;

};

class Cylinder {

colors color;

public:

Cylinder(colors c) { color= c; }

friend bool sameColor(Cube x, Cylinder у) ;

//...

};

bool sameColor(Cube x, Cylinder y)

{

if(x.color == y.color) return true;

else return false;

}

int main() {

Cube cubel(red);

Cube cube2(green);

Cylinder cyl(green);

if(sameColor(cubel, cyl))

cout << "куб1 and цилиндр одного цвета.\n";

else

cout << "куб1 and цилиндр разных цветов.\n" ;

if(sameColor(cube2, cyl))

cout << "куб2 and цилиндр одного цвета.\n";

else

cout << "куб2 and цилиндр разных цветов.\n";

return 0;

}

Вот вывод этой программы:

куб1 and цилиндр разных цветов.

куб2 and цилиндр одного цвета.

Обратите внимание на то, что эта программа использует упреждащее объявление (называемое также упреждающей ссылкой, или ссылкой вперед) в отношении класса MyClass. Такая ссылка необходима из-за того, что объявление функции sameColor() внутри Cube ссылается на класс Cylinder еще перед его объявлением. Для того, чтобы создать упреждающее объявление класса, просто используйте форму, показанную в этой программе.

Друг одного класса может быть членом другого. Например, предущую программу можно переписать так, чтобы функция sameColor() была членом Cube. Обратите внимание на оператор разрешения видимости при объявлении sameColor() другом Cylinder:

/* Функция может быть членом одного класса и другом второго. */

#include <iostream>

using namespace std;

class Cylinder; // упреждающее объявление

enum colors { red, green, yellow };

class Cube {

colors color;

public:

Cube(colors c) { color= c; }

bool sameColor (Cylinder y) ; //sameColor() теперь член класса Cube.

//…

};

class Cylinder {

colors color;

public:

Cylinder(colors c) { color = c; }

friend bool Cube::sameColor(Cylinder у) ;

// ...

};

bool Cube::sameColor(Cylinder у) {

if(color == у.color)return true;

else return false;

}

int main() {

Cube cubel(red);

Cube cube2(green);

Cylinder cyl(green);

if(cubel.sameColor(cyl))

cout << "куб1 and цилиндр одного цвета.\n";

else

cout << "куб1 and цилиндр разных цветов.\n";

if(cube2.sameColor(cyl))

cout << "куб2 and цилиндр одного цвета.\n";

else

cout << "куб2 and цилиндр разных цветов.\n";

return 0;

}

Поскольку функция sameCoior() является членом Cube, она может непосредственно обращаться к переменной color объектов типа Cube. Только объекты типа Cylinder должны передаваться этой функции.

Заключение

В процессе выполнение дипломной работы решены задачи:

?проведен обзор предметной области;

?созданы задачи для бизнес-процесса;

?спроектирован бизнес-процесс обучающей системы;

?разработаны пректы для предметной области.

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

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

Проведено проектирование и реализация пользовательского интерфейса.

При анализе эргономичности системы определены основные требования и заложены эргономическая организация рабочего места и интерфейса системы.

На этапе анализа безопасности определен перечень возможных угроз, методы и средства защиты от них.

Произведен расчет затраченного времени на создание программы, себестоимости программного продукта, ценообразования.

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

Таким образом, технология разработки проектов с использованием инерфейса MS Visual Studio 2010 является одним из средств совершенствования образовательного процесса.

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

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

Список сокращений

ПО - программное обеспечение;

ИТ - информационных технологий;

ИС - информационная система;

ПЗ - пояснительная записка;

ПК - персональный компьютер;

ОЗУ - оперативно запоминающее устройство;

ЭМУ - электронный мультимедийный учебник;

ВУЗ - высшее учебное заведение;

ИП - индивидуальный предприниматель;

АО - акционерное общество;

ОАО - общество с ограниченной ответственностью;

ЗАО - закрытое акционерное общество;- unifiedmodelinglanguage (унифицированный язык моделирования);- WorkFlowDiagramm (диаграмма потоков данных);

VGA - videographicsadapter (графический видео адаптер).

Список использованной литературы

1. Р. Лафоре. ООП в С++. 4-е издание. 2011. М., СПб. и т.д. "Питер". 924 с.

2. Г. Шилдт. Самоучитель С++. 3-е издание. 2007. Санкт-Петербург, «БХВ-Петербург. 684 с.

3. Д. Либерти, Б. Джонс. Освой самостоятельно С++ за 21 день. 5-е издание. 2007. М., СПб., Киев, "Вильямс". 784 с.

4. Н. Культин. Основы программирования в Microsoft Visual C++2010. Санкт_Петербург. «БХВ-Петербург». 2010. 376 с.

5. Вендров, А. М. Практикум по проектированию программного обеспечения экономических информационных систем. [Текст] / А. М. Вендров. - М.: Финансы и статистика, 2002. - 438 с.

6. Маклаков, С. В. BPWin и ERWin. CASE - средства разработки Информационных систем. [Текст] / С. В. Маклаков. - М.: ДИАЛОГ-МИФИ, 2000. - 256 с.

7. Чепурина, М. Н. Курс экономической теории. [Текст] / под ред. М. Н. Чепурина [и др]. - М.: Киров, 1994. - 248 с.

8. Мунипов, В.М. Эргономика: человекоориентированное проектирование техники, программных средств и среды [Текст] / В.М. Мунипов, В.П. Зинченко. - М.: Логос, 2001. - 120 с.

9. Ведев Д. Защита данных в компьютерных сетях.// Открытые системы. -№3.- 1995.- С.12-16.

10. Гриценко, Е.М. Технология разработки мультимедийных образовательных ресурсов. [Текст] / Е.М. Гриценко, Г.М. Рудакова.- Красноярск: СибГТУ, 2008. - 68 с.

11. Бхангал Ш. Flash. Трюки. 100 советов и рекомендаций профессионала - СПб.: Питер, 2005. - 460 с: ил.

12. Андерсон, Э. MacromediaFlash MX 2004 / Энди Андерсон, Марк дел Лима, Стив Джонсон; пер. с англ. Латышевой Д.А. - М.: НТ Пресс, 2005. - 543, [1] с : ил.

13. Безручко, В.Т. Практикум по курсу «Информатика». Работа в Windows 2000, Word, Excel : учебник / В.Т. Безручко. - М. : Финансы и статистика, 2010. - 544 с.

14. Волков, Е.А. Численные методы / Е.А. Волков. - М. : Наука, 2000. - 642 с.

15. Голицына И.Н. Эффективное управление учебной деятельностью с помощью компьютерных информационных технологий / И.Н. Голицына // EducationTechnology&Society. - 2003. - № 6. - С. 77-83.

16. Горнова, Н.В. Формирование готовности студентов к использованию информационных технологий в профессионально-педагогической деятельности / Н.В. Горнова. - Саратов : Сателлит, 2004. - 132 с.

...