Курсовой проект. Теоретическая часть

• Название: Теоретическая часть
• Анкор: Курсовой проект
• Дата: 10.05.2022
• Размер: 0.59 Mb.
• Имя файла: Курсовой проект.docx
• Тип: Документы; #520380

Оглавление

Введение 3

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

1.1.Объектно-ориентированное программирование 4

1.2. Инкапсуляция 6

1.3. Полиморфизм 6

1.4.Наследование 8

1.5. Абстрагирование 8

1.6.Статические классы и методы 9

1.7.Виртуальные функции и чистые виртуальные функции 10

1.8. Множественное наследование. Интерфейсы 12

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

2.1. Постановка задачи 13

2.2.Программирование задачи 13

2.3. Результаты работы 17

3.Заключение 19

Листинг программы 20

Файл Form1.cs 20

Файл Ships.cs 23

Файл Places.cs 24

Файл ShipAI.cs 25

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

Введение

На сегодняшний момент язык программирования C# одни из самых мощных, быстро развивающихся и востребованных языков в ИТ-отрасли. В настоящий момент на нем пишутся самые различные приложения: от небольших десктопных программок до крупных веб-порталов и веб-сервисов, обслуживающих ежедневно миллионы пользователей.

Несмотря на то что язык ещё очень молод, он претерпел множество изменений. В 2002 году вышла первая версия языка C#. На сегодняшний день момент существует 6-я версия C#.

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

1.1.Объектно-ориентированное программирование

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

Класс – это общее описание объекта. Он содержит в себе поля, свойства, методы. Поля определяют состояние, а методы поведение будущего объекта. Класс является неким шаблоном, по которому создаётся объект класса. Начинаются классы с ключевого слова class. Пример класса:

Class Myclass

{
protected string name; //это поле класса Myclass

public Myclass() //это конструктор класса Myclass

{name=” ”; }

public void enter() //метод класса Myclass

{……..}

}

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

Существует 2 типа конструкторов. Это конструкторы с параметрами и без параметров. Пример конструктора без параметров:

public Myclass()

{

name=” ”;

}

Пример конструктора с параметрами:

public Myclass(string N)

{

name=N;

}

Объект – это экземпляр класса. Если класс был общим описанием какого-либо объекта, то объект это конкретный экземпляр. Например, есть класс студент. У этого класса есть поля, такие как имя, фамилия, курс, группа, возраст. А объектом этого класса будет являться студент 2 курса группы И-141, Мирошников Иван.

Объекты класса создаются так: Myclass my_object=new Myclass();

Myclass – это название класса, my_object – имя объекта, new Myclass() – это объявление конструктора.

1.2. Инкапсуляция

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

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

На самом деле объект является переменной определённого пользователем типа. Может показаться странным, что объект, который объединяет коды и данные, можно рассматривать как переменную. Однако применительно к объектно-ориентированному программированию это именно так. Каждый элемент данных такого типа является составной переменной.

1.3. Полиморфизм

Полиморфизм - это то свойство, которое позволяет одно и то же имя использовать для решения двух или более схожих, но технически разных задач. Целью полиморфизма, применительно к объектно-ориентированному программированию, является использование одного имени для задания общих для класса действий. Выполнение каждого конкретного действия будет определяться типом данных. Например для языка Си, в котором полиморфизм поддерживается недостаточно, нахождение абсолютной величины числа требует трёх различных функций: abs(), labs() и labs(). Эти функции подсчитывают и возвращают абсолютную величину целых, длинных целых и чисел с плавающей точкой соответственно. В С++ каждая из этих функций может быть названа abs(). Тип данных, который используется при вызове функции, определяет, какая конкретная версия функции действительно выполняется. В С++ можно использовать одно имя функции для множества различных действий. Это называется перегрузкой функций (function overloading) В более общем смысле, концепцией полиморфизма является идея "один интерфейс, множество методов". Это означает, что можно создать общий интерфейс для группы близких по смыслу действий. Преимуществом полиморфизма является то, что он помогает снижать сложность программ, разрешая использование того же интерфейса для задания единого класса действий. Выбор же конкретного действия, в зависимости от ситуации, возлагается на компилятор. Вам, как программисту, не нужно делать этот выбор самому. Нужно только помнить и использовать общий интерфейс. Пример из предыдущего абзаца показывает, как, имея три имени для функции определения абсолютной величины числа вместо одного, обычная задача становится более сложной, чем это действительно необходимо.

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

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

1.4.Наследование

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

1.5. Абстрагирование

Смысл абстрагирования. Абстрагирование является одним из основных методов, используемых для решения сложных задач. Хоар считает, что "абстрагирование проявляется в нахождении сходств между определенными объектами, ситуациями или процессами реального мира, и в принятии решений на основе этих сходств, отвлекаясь на время от имеющихся различий". Шоу определила это понятие так: "Упрощенное описание или изложение системы, при котором одни свойства и детали выделяются, а другие опускаются. Хорошей является такая абстракция, которая подчеркивает детали, существенные для рассмотрения и использования, и опускает те, которые на данный момент несущественны". Берзинс, Грей и Науман рекомендовали, чтобы "идея квалифицировалась как абстракция только, если она может быть изложена, понята и проанализирована независимо от механизма, который будет в дальнейшем принят для ее реализации". Суммируя эти разные точки зрения, получим следующее определение абстракции:

“Абстракция выделяет существенные характеристики некоторого объекта, отличающие его от всех других видов объектов и, таким образом, четко определяет его концептуальные границы с точки зрения наблюдателя”.

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

1.6.Статические классы и методы

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

1.7.Виртуальные функции и чистые виртуальные функции

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

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

Одни языки программирования (например, C++, C#) требуют явно указывать, что данный метод является виртуальным. В других языках (например, Java, Python) все методы являются виртуальными по умолчанию (но только те методы, для которых это возможно; например в Java методы с доступом private не могут быть переопределены в связи с правилами видимости).

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

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

Пример виртуальной функции языка C++ :

class Ancestor

{

public:

virtual void function1 () { cout << "Ancestor::function1()" << endl; }

void function2 () { cout << "Ancestor::function2()" << endl; }

};

class Descendant : public Ancestor

{

public:

virtual void function1 () { cout << "Descendant::function1()" << endl; }

void function2 () { cout << "Descendant::function2()" << endl; }

};

1.8. Множественное наследование. Интерфейсы

Множественное наследование - наследование от нескольких базовых классов одновременно.

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

В языке C# подобную проблему позволяют решить интерфейсы. Они играют важную роль в системе ООП. Интерфейсы позволяют определить некоторый функционал, не имеющий конкретной реализации. Затем этот функционал реализуют классы, применяющие данные интерфейсы.

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

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

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

2.1. Постановка задачи

Цель работы: Разработать программу в среде C++ Builder, прорисовывающую графический объект и реализующую возможность управляемого перемещения, с использованием основных средств ООП в соответствии с заданием.

Программа должна выполнять в общем три задачи:

1. 
   Создание поля для игры.
   
2. 
   Расположение объектов согласно заданным координатам.
   
3. 
   Уничтожение объектов по указанным координатам.
   
4. 
   Вывод результатов игры.
   

Все полученные результаты отобразить на экране.

Название игры: Морской бой

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

2.2.Программирование задачи

Объявление классов в C#.

Класс Places

Это класс карты игры.

public class Places

{

public static int weight, height; // длина и ширина поля

static Places() // статический конструктор класса Places

{

weight = 11;

height = 11;

}

public char[,] map = new char[weight, height]; // поле для игры

public void create() // метод создания поля игры

{

for (int i = 1; i < weight; i++)

{

for (int j = 1; j < height; j++)

{

this.map[i, j] = Convert.ToChar("+");

}

}

}

}

Класс Ships

public class Ships

{

Form1 form;

public int ships_leght;

public int coordX, coordY;

public Ships()

{

coordX = 0;

coordY = 0;

}
public Ships(int k)

{

ships_leght = k;
}

public virtual void fight_places(Places p)

{

int a = coordX;

int b = coordY;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

p.map[i, j] = Convert.ToChar("X");

}
}

}
public virtual void vert(Places p)

{

int a = coordX;

int b = coordY;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{
p.map[j, i] = Convert.ToChar("X");

}

//else

//{

// MessageBox.Show("Нельзя так близко ставить корабли", "Близко!", MessageBoxButtons.OK, MessageBoxIcon.Error);

// //form.enter_coordinates(this);

//}

}

}}

В этом классе присутствуют виртуальные методы, которые переопределяются в классе-наследнике.

Класс ShipAI

Это класс-наследник от производного класса Ship.

class ShipAI : Ships

{

Random rand = new Random();

public void enter()

{

coordX = rand.Next(1, 9);

coordY = rand.Next(1, 9);

}

public ShipAI(int k) : base(k)

{
}
public void placement()

{

int a = rand.Next(1, 2);

switch(a)

{

case 1: break;

case 2: break;

}

}

public override void fight_places(Places p)

{

enter();

int a = coordX;

int b = coordY;

for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

//if ((p.map[i, j] != Convert.ToChar("X")) && (p.map[i, j + ships_leght] != Convert.ToChar("X")) && (p.map[i + 1, j] != Convert.ToChar("X")) && (p.map[i - 1, j] != Convert.ToChar("X")))

p.map[i, j] = Convert.ToChar("X");

}

}

}

public override void vert(Places p)

{

int a = coordY;

int b = coordX;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

if ((p.map[i, j] != Convert.ToChar("X")) && (p.map[i + ships_leght, j] != Convert.ToChar("X")) && (p.map[i, j + 1] != Convert.ToChar("X")) && (p.map[i, j - 1] != Convert.ToChar("X")))

{ p.map[j, i] = Convert.ToChar("X"); }
}

}

}

}

В этом классе переопределяются методы производного класса. Например такой метод как fight_places(Places p) в классе Ship реализутеся так:

public virtual void fight_places(Places p)

{

int a = coordX;

int b = coordY;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

p.map[i, j] = Convert.ToChar("X");

}
}

}

А в классе ShipAI так:

public override void fight_places(Places p)

{

enter();

int a = coordX;

int b = coordY;

for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

if ((p.map[i, j] != Convert.ToChar("X")) && (p.map[i, j + ships_leght] != Convert.ToChar("X")) && (p.map[i + 1, j] != Convert.ToChar("X")) && (p.map[i - 1, j] != Convert.ToChar("X")))

p.map[i, j] = Convert.ToChar("X");

}

}

}

2.3. Результаты работы

Рис1. При запуске игры.



Рис2. Расстановка кораблей.



Рис3.Атака-промах.

3.Заключение

После проделанной работы была освоена технология объектно-ориентированного программирования. В ходе работы была создана компьютерная игра, работающей на платформе .NET Framework. Были приобретены навыки работы в Visual Studio, WinForms, а так же был изучен объектно-ориентированный язык С#.

Листинг программы

Файл Form1.cs

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;
namespace WindowsFormsApplication2

{

public partial class Form1 : Form

{

static int count = 9;

static int count_2 = 23;

//==================================================================================================================

Places map = new Places();

Places map_AI = new Places();

Ships ship_4 = new Ships(4);

Ships ship_3 = new Ships(3);

Ships ship_2 = new Ships(2);

Ships ship_2_1 = new Ships(2);

Ships ship_2_2 = new Ships(2);

Ships ship_1 = new Ships(1);

Ships ship_1_1 = new Ships(1);

Ships ship_1_2 = new Ships(1);

Ships ship_1_3 = new Ships(1);

//==================================================================================================================

ShipAI shipAI_4 = new ShipAI(4);

ShipAI shipAI_3 = new ShipAI(3);

ShipAI shipAI_2 = new ShipAI(2);

ShipAI shipAI_2_1 = new ShipAI(2);

ShipAI shipAI_2_2 = new ShipAI(2);

ShipAI shipAI_1 = new ShipAI(1);

ShipAI shipAI_1_1 = new ShipAI(1);

ShipAI shipAI_1_2 = new ShipAI(1);

ShipAI shipAI_1_3 = new ShipAI(1);

//===================================================================================================================

public void enter_coordinates(Ships ship)

{

label1.Text = "";

ship.coordX = Convert.ToInt32(textBox1.Text);

ship.coordY = Convert.ToInt32(textBox2.Text);

if (comboBox1.Text == "Вертикально")

{

ship.vert(map);

print(label1, map);

}

else

{

ship.fight_places(map);

print(label1, map);

}
}

//===================================================================================================================

public Form1()

{

InitializeComponent();

}

//===================================================================================================================

private void Form1_Load(object sender, EventArgs e)

{

map.create();

map_AI.create();

comboBox1.Items.Add("Вертикально");

comboBox1.Items.Add("Горизонтально");

print(label1, map);

print(label2, map_AI);

}

//===================================================================================================================

private void label3_Click(object sender, EventArgs e)

{
}

//===================================================================================================================

private void label1_Click(object sender, EventArgs e)

{
}

//===================================================================================================================

private void button1_Click(object sender, EventArgs e)

{

enter_for_AI();

//while(count_2!=0)

//{
//}

}

//===================================================================================================================

private void button3_Click(object sender, EventArgs e)

{

switches();

count--;

}

//===================================================================================================================

public void switches()

{

switch (count)

{

case 9: enter_coordinates(ship_4); break;

case 8: enter_coordinates(ship_3); break;

case 7: enter_coordinates(ship_2); break;

case 6: enter_coordinates(ship_2_1); break;

case 5: enter_coordinates(ship_2_2); break;

case 4: enter_coordinates(ship_1); break;

case 3: enter_coordinates(ship_1_1); break;

case 2: enter_coordinates(ship_1_2); break;

case 1: enter_coordinates(ship_1_3); break;

}

}

//===================================================================================================================

private void textBox1_TextChanged(object sender, EventArgs e)

{ }

//===================================================================================================================

private void button2_Click(object sender, EventArgs e)

{

Close();

}

//===================================================================================================================

static void print(Label l, Places p)

{

for (int i = 1; i < 11; i++)

{

for (int j = 0; j < 11; j++)

{

l.Text += Convert.ToString(p.map[i, j]) + " ";

}
}

}

//===================================================================================================================

private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)

{

}

//===================================================================================================================

private void button5_Click(object sender, EventArgs e)

{

textBox1.ClearUndo();

textBox1.Text = "";

textBox2.ClearUndo();

textBox2.Text = "";

}

//===================================================================================================================

private void button4_Click(object sender, EventArgs e)

{

attack(map_AI);

}

//===================================================================================================================

public virtual void attack(Places p)

{

int a, b;

a= Convert.ToInt32(textBox1.Text);

b = Convert.ToInt32(textBox2.Text);
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < (b + 1); j++)

{

if (p.map[i, j] == Convert.ToChar("X"))

{

MessageBox.Show("Попадание!", "Попадание", MessageBoxButtons.OK, MessageBoxIcon.Information);

count_2--;

attack(p);

}

else

{

MessageBox.Show("Промах!", "Промах", MessageBoxButtons.OK, MessageBoxIcon.Stop); break;

}

}

}

}

//===================================================================================================================

///

///

///

public void enter_for_AI()

{

shipAI_4.fight_places(map_AI);

shipAI_3.fight_places(map_AI);

shipAI_2.fight_places(map_AI);

shipAI_2_1.fight_places(map_AI);

shipAI_2_2.fight_places(map_AI);

shipAI_1.fight_places(map_AI);

shipAI_1_1.fight_places(map_AI);

shipAI_1_2.fight_places(map_AI);

}

}

}

Файл Ships.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using static System.Console;

public class Ships

{

Form1 form;

public int ships_leght;

public int coordX, coordY;

public Ships()

{

coordX = 0;

coordY = 0;

}
public Ships(int k)

{

ships_leght = k;
}

public virtual void fight_places(Places p)

{

int a = coordX;

int b = coordY;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

p.map[i, j] = Convert.ToChar("X");

}
}

}
public virtual void vert(Places p)

{

int a = coordX;

int b = coordY;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{
p.map[j, i] = Convert.ToChar("X");

}

//else

//{

// MessageBox.Show("Нельзя так близко ставить корабли", "Близко!", MessageBoxButtons.OK, MessageBoxIcon.Error);

// //form.enter_coordinates(this);

//}

}

}


}

Файл Places.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using static System.Console;

public class Places

{

public static int weight, height; // длина и ширина поля

static Places() // статический конструктор класса Places

{

weight = 11;

height = 11;

}

public char[,] map = new char[weight, height]; // поле для игры

public void create() // метод создания поля игры

{

for (int i = 1; i < weight; i++)

{

for (int j = 1; j < height; j++)

{

this.map[i, j] = Convert.ToChar("+");

}

}

}

}

Файл ShipAI.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using static System.Console;

namespace WindowsFormsApplication2

{

class ShipAI : Ships

{

Random rand = new Random();

public void enter()

{

coordX = rand.Next(1, 9);

coordY = rand.Next(1, 9);

}

public ShipAI(int k) : base(k)

{
}
public void placement()

{

int a = rand.Next(1, 2);

switch(a)

{

case 1: break;

case 2: break;

}

}

public override void fight_places(Places p)

{

enter();

int a = coordX;

int b = coordY;

for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

// if ((p.map[i, j] != Convert.ToChar("X")) && (p.map[i, j + ships_leght] != Convert.ToChar("X")) && (p.map[i + 1, j] != Convert.ToChar("X")) && (p.map[i - 1, j] != Convert.ToChar("X")))

p.map[i, j] = Convert.ToChar("X");

}

}

}

public override void vert(Places p)

{

int a = coordY;

int b = coordX;
for (int i = a; i < (a + 1); i++)

{

for (int j = b; j < b + ships_leght; j++)

{

if ((p.map[i, j] != Convert.ToChar("X")) && (p.map[i + ships_leght, j] != Convert.ToChar("X")) && (p.map[i, j + 1] != Convert.ToChar("X")) && (p.map[i, j - 1] != Convert.ToChar("X")))

{ p.map[j, i] = Convert.ToChar("X"); }
}

}

}

}

}

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

1. Бьёрн Страуструп. Язык программирования C++. Специальное издание = The C++ programming language. Special edition. — М.: Бином-Пресс, 2007. — 1104 с.

2. Айвор Хортон. Visual C++ 2010: полный курс = Ivor Horton’s Beginning Visual C++ 2010. — М.: Диалектика, 2010. — С.

3. Бьёрн Страуструп. Язык программирования C++ = The C++ Programming Language / Пер. с англ. — 3-е изд. — СПб.; М.: Невский диалект — Бином, 1999. — 991 с

4. Роберт Лафоре - Объектно-ориентированное программирование C++, 4-е изд (Классика Computer Science) – 2004

5. Герберт Шилдт - Самоучитель C++.

6. Джон Скит. C# для профессионалов: тонкости программирования, 3-е издание, новый перевод = C# in Depth, 3rd ed.. — М.: «Вильямс», 2014. — 608 с. — ISBN 978-5-8459-1909-0.7. C++ Builder в задача и примерах. Петербург, 2005.

8. Семакин И. Г., Шестаков А. П. С12 Основы программирования: Учебник. — М.: Мастерство, 2002. - 432 с.

9. Кристиан Нейгел и др. C# 5.0 и платформа .NET 4.5 для профессионалов = Professional C# 5.0 and .NET 4.5. — М.: «Диалектика», 2013. — 1440 с. — ISBN 978-5-8459-1850-5.