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

• Название: Данной курсовой работы посвящена изучению объектноориентированного программирования. Она довольно актуальна, посколькуооп это один из самых эффективных подходов к современному программированию
• Анкор: абстрактные классы
• Дата: 26.04.2022
• Размер: 34.22 Kb.
• Имя файла: ref_graf.docx
• Тип: Реферат; #498498

Содержание

Введение 2

1 Теоретическая часть 4

1.1 Алгоритм 4

1.2 Волновой алгоритм 4

Имеется другая последовательность обхода, которую образно можно представить в виде волны, распространяющейся от корня дерева к вершинам. Такой обход уже нельзя назвать рекурсивным, потому что ее нельзя реализовать с помощью механизма явного рекурсивного вызова функции. Тем не менее, идея разветвляющегося алгоритма с идентичными шагами остается в силе. Для того, чтобы шаги алгоритма выполняются «по слоям», нужно вместо явного стека использовать аналогичную очередь шагов алгоритма. 4

1.3 Задача поиска минимального пути 4

2 Практическая часть 6

Заключение 11

Список литературы 12

Введение

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

Объектно-ориентированное программирование (ООП) – методология программирования, основанная на представлении программы в виде совокупности объектов, каждый из которых является экземпляром определённого класса, а классы образуют иерархию наследования.

C# является полноценным объектно-ориентированным языком. Это значит, что практическая часть курсовой работы будет представлена на данном языке программирования. C# является одним из наиболее популярных языков за счет простоты своего изучения.

Первая глава работы – теоретическая часть. В ней будут рассмотрены абстрактные классы С#, а также абстрактные методы и свойства. Помимо этого, будет рассмотрен принцип полиморфизма.

Вторая глава работы – практическая часть. В ней будет приведено решение задачи. Сама задача звучит так: описать класс, реализующий тип данных «вещественная матрица» и работу с ними.Класс должен реализовывать некоторые операции над матрицами (операции сравнения на равенство/неравенство;сложение, вычитание с числом; операции вычисления обратной; сортировка по определителю).

Курсовая работа состоит из:

• 
  введения;
  
• 
  теоретической части;
  
• 
  практической части;
  
• 
  заключения;
  
• 
  списка литературы;
  
• 
  листинга программы.
  

1 Теоретическая часть

1.1 Алгоритм

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

1.2 Волновой алгоритм

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

1.3 Задача поиска минимального пути

Идея «волны» иногда позволяет резко сократить число просматриваемых вариантов в сравнении с рекурсивным перебором. Например, алгоритм определения кратчайших путей на графе можно решить, представив его как распространение «волны» из исходной вершины. Такая волна, проходя через вершины, запоминает в них длину пройденного пути. Перечислим «составные части» такого алгоритма:

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

2 Практическая часть

Создадим класс pol (создается отдельно от главной программы), поля которого имеют названия:

• 
  double[] a ;
  
• 
  double[] coeff (создан как параметр);
  

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

Public pol(double[]coeff)
{
if (coeff == null) throw new ArgumentException("Нулевая ссылка в аргумент", "коэффициент");
if (coeff.Length == 0) throw new ArgumentException("нулевая длинна аргумента", "коэффициент");
a = coeff;
}
public double this[int i]
{
get { return a[i]; }
}

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

public double this[int i]
{
get { return a[i]; }
}

Далее переходим к написанию свойств, они служат для организации доступа к полям класса:

public int Stroki

{

get { returnstroki; }

set

{

if (value < 0)

{

stroki = 1;

}

else

{

stroki = value;

}

}

}
public int Kolonki

{

get { returnkolonki; }

set

{

if (value < 0)

{

kolonki = 1;

}

else

{

kolonki = value;

}

}

}

Создаем индексатор, который будет удобен для работы с массивом, описанном в классе. Индексатор – это разновидность свойств:

public int Order
{
get { return a.Length - 1; }

}

public double Compute (double arg)
{
double value = 1;
return a.Aggregate((x, y) =>{ value *= arg;return x + y * value;});
}

Далее переходим к написанию перегрузки операторов. Перегрузка операций в С# похожа на переопределение методов:

public static pol operator +(pol x, pol y)
{
return new pol(Enumerable.Range(0, Math.Max(x.a.Length, y.a.Length)).Select(i => (i <= x.Order ? x[i] : 0) + (i <= y.Order ? y[i] : 0)).ToArray());

Если есть оператор «плюс», тогда необходимо написать перегрузку с противоположным знаком. В этом случае, тот самый противоположный знак – «минус»:

public static pol operator -(pol x, pol y)
{
return new pol(Enumerable.Range(0, Math.Max(x.a.Length, y.a.Length)).Select(i => (i <= x.Order ? x[i] : 0) - (i <= y.Order ? y[i] : 0)).ToArray()); ;
}
Создаю еще одну перегрузку для умножения и деления полиномов. Операции умножения и деления должны быть перегружены парами, следовательно, пишу как для«*», так и для«/»:

public static pol operator *(pol x, pol y)
{
var um = new double[x.Order + y.Order + 1];
double[] xArr = x.a.Concat(Enumerable.Repeat(0d, um.Length - x.a.Length)).ToArray();
double[] yArr = y.a.Concat(Enumerable.Repeat(0d, um.Length - y.a.Length)).ToArray();
for (int i = 0; i < um.Length; i++)
for (int j = 0; j <= i; j++)
um[i] += xArr[j] * yArr[i - j];
return new pol(um);
}

public static pol operator /(pol x,pol y)
{
var del = new double[x.Order + y.Order + 1];
double[] xArr = x.a.Concat(Enumerable.Repeat(1d, del.Length - x.a.Length)).ToArray();
double[] yArr = y.a.Concat(Enumerable.Repeat(1d, del.Length - y.a.Length)).ToArray();
for (int i = 0; i < del.Length; i++)
for (int j = 0; j <= i; j++)
del[i] += xArr[j] / yArr[i - j];
return new pol(del);
}

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

public override string ToString()
{
if (a.All(d => d == 0)) return "0";
var res = new StringBuilder("");
for (int i = a.Length - 1; i > 1; i--)
{
if (a[i] != 0) res.Append(a[i] + "x^" + i + "+");
}
if (res.Length != 0) res.Remove(res.Length - 1, 1);
if (a[1] != 0) res.Append("+" + a[1] + "x");
if (a[0] != 0) res.Append("+" + a[0]);
res.Replace("+", string.Empty, 0, 1).Replace("+-", "-");
return res.ToString();
}
}
}

Описание созданного класса pol на этом заканчивается, поэтому переходим к главной программе. Сейчас здесь будет приведено объяснение сути каждого кейса, всего в моей программе их 7:

1. 
   case 1 отвечает за заполнение массива:
   

{

Console.WriteLine("Задайте коэффициенты 1 полинома");
Console.WriteLine("Первый коэффициент задается как коэффициент*d!!!!");
var b = new pol(new[] {Convert.ToDouble(Console.ReadLine())});

Console.WriteLine("Задайте коэффициенты 2 полинома");
Console.WriteLine("Первый коэффициент задается как коэффициент*d!!!!");

var c = new pol(new[] {Convert.ToDouble(Console.ReadLine())})

b = bp;

c = cp;

}

2. 
   сase 2 отвечает за выведение полиномов на экран:
   

var s1 = new pol(new[] {bp});
Console.WriteLine("pol1 = {0}", s1);
var s2 = new pol(new[] {cp});
Console.WriteLine("pol2 = {0}", s2);
break;

3. 
   сase 3 отвечает за перегрузку «плюс». В данном кейсе два созданных полинома складываются:
   

var s1 = new pol(new[] {bp});
Console.WriteLine("pol1 = {0}", s1);
var s2 = new pol(new[] {cp});
Console.WriteLine("pol2 = {0}", s2);
break;

4. 
   сase 4 отвечает за перегрузку «минус». В данном кейсе из первого полинома вычитается второй:
   

var s1 = new pol(new[] {bp});
var s2 = new pol(new[] {cp});
Console.WriteLine("pol1 - pol2 = {0}", s1 - s2);
break;

5. 
   сase 5 отвечает за перегрузку «*». В данном кейсе первый полином умножается на второй:
   

var s1 = new pol(new[] { bp });
var s2 = new pol(new[] { cp });
Console.WriteLine("pol1 * pol2 = {0}", s1 * s2);
break;

6. 
   сase 6 отвечает за перегрузку «/». В данном кейсе первый полином делится на второй на второй:
   

var s1 = new pol(new[] { bp });
var s2 = new pol(new[] { cp });
Console.WriteLine("pol1 / pol2 = {0}", s1 / s2);
break;

7. 
   сase 7 отвечает за выведения всех полиномов на экран:
   

var s1 = new pol(new[] { bp });
var s2 = new pol(new[] { cp });
Console.WriteLine("{0}", s1);
Console.WriteLine("{0}", s2);
Console.WriteLine("{0}", s1 + s2);
Console.WriteLine("{0}", s1 - s2);
Console.WriteLine("{0}", s1 * s2);

8. 
   сase 0 – выход.
   

Заключение

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

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

Список литературы

1. C# LanguageSpecification. MicrosoftCorporation, 2005.

2. Васильев, А. Программирование на С# для начинающих – основные сведения/А. Васильев// Эксмо.– 2018.– 48 с.

3. Зиборов, В.В. Visual C# 2012 на примерах / В.В. Зиборов. – М.: БХВ-Петербург, 2013. – 480 c.

4. Касаткин, А. И. Профессиональное программирование на языке си. Управление ресурсами / А.И. Касаткин. – М.: Высшая школа, 2012. – 432 c.

5. Марченко, А. Л. Основы программирования на С# 2.0 / А.Л. Марченко. – М.: Интернет-университет информационных технологий, Бином. Лаборатория знаний, 2011. – 552 c.

6. Подбельский, В. В. Язык С#. Базовый курс / В.В. Подбельский. – М.: Финансы и статистика, Инфра-М, 2011. – 384 c.

7. Пугачев, С. Разработка приложений для Windows 8 на языке C# / С. Пугачев, А. Шериев, К. Кичинский. – М.: БХВ-Петербург, 2016. – 416 c.

8. Рихтер, Джеффри CLR via C#. Программирование на платформе Microsoft.NET Framework 4.5 на языке C# / Джеффри Рихтер. – М.: Питер, 2016. – 365 c.

9. Троелсен, Эндрю Язык программирования C# 2010 и платформа .NET 4 / Эндрю Троелсен. – Москва: Огни, 2016. – 238 c.

10. Фленов, М.Е. Библия C# (+ CD-ROM) / М.Е. Фленов. – М.: БХВ-Петербург, 2015. – 532 c.