'def title Задачи - ООП, Седмица 9, 15.04.2026
'def  desc Условията на задачите за упражнение.

# {title}

{pagenav 5 min;14 April 2026;26 April 2026}

## За решаване

### Задача 1

.solution-link {url Решение;https://github.com/Syndamia/oop-2025-solutions/tree/main/Week09/Exercise01}

.note
{i (26.04.2026)} Променено от "дата на производство" в "година на производство"

Реализирайте клас {` Locomotive}, който съдържа:
.bulleted
- идентификационен номер
- име на производител
- име на модел
- година на производство
- дължина в милиметри
- брой цилиндри в двигателя
- дали поддържа връзка с втори локомотив, така че и двата да се управляват от един машинист (так. нар. {url multiple working;https://en.wikipedia.org/wiki/Multiple_working})

За него реализирайте нужните селектори и мутатори.

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

```
Train #9999
+ Model: ZZZ
+ Manufacturer: ZZZ
+ Year of manufacture: 2000
- Length: 9999mm
- Engine cyllinders: 9999
- Multiple working: Yes

### Задача 2

.solution-link {url Решение;https://github.com/Syndamia/oop-2025-solutions/tree/main/Week09/Exercise02}

Реализирайте клас {` Vector}, който съхранява неограничено количество от числа с плаваща запетая.

Реализирайте оператори:
.bulleted
- {` +}, който покомпонентно събира елементи
- {` -}, който покомпонентно изважда елементи
- {` &}, който връща евклидовата дължина на вектора
- {` *}, който връща умножение на вектор и скалар
- {` *}, който връща точковото (покомпонентно) умножение на два вектора
- {` ^}, който връща векторнотно умножение на векторите
- {` ||}, който връща дали двата вектора са паралелни
- {` ==}, който връща дали двата вектора са равни
- {` !=}, който връща дали двата вектора са различни

За всички тези оператори реализирайте съотвените оператори за присвояване ({` +=}, {` -=}, ...).
Ако единия вектор има повече елементи, нека те да се игнорират/оставят.

### Задача 3

.solution-link {url Решение;https://github.com/Syndamia/oop-2025-solutions/tree/main/Week09/Exercise03}

Реализирайте клас {` String}, който съхранява низ с неограничен размер.
Имплементирайте следните оператори:
.bulleted
- {` +}, конкатенира (слепва) втория низ в края на първия
- {` ==}, {` !=}, {` >}, {` >=}, {` <}, {` <=}, които сравняват двата низа (както {` strcmp} ги сравнява)
- {` []}, който връща буква по подаден индекс
- {` []}, който връща подниза между два индекса (вкл.), разделени със запетая.
  Тоест {` text[X(3), 5]} трябва да върне подниз с начало и край индекси 3 и 5.
  {` X} е помощен клас, наименуван по ваш начин.
- {` <<}, който връща дали левия низ завършва със съдържанието на десния низ
- {` >>}, който връща дали десния низ започва със съдържанието на левия низ

### Задача 4

.solution-link {url Решение;https://github.com/Syndamia/oop-2025-solutions/tree/main/Week09/Exercise04}

Реализирайте клас {` Rover}, който съхранява координатите на движещ се роувър.
В началото роувъра започва в координати {` (0,0)} и сочи напред (към {` (0,1)})

Реализирайте следните оператори:
.bulleted
- {` <}, роувъра от дясната страна на оператора се придвижва наляво с лявата страна на брой единици
- {` >}, роувъра от лявата страна на оператора се придвижва надясно с дясната страна на брой единици
- {` ^}, роувъра от лявата страна на оператора се придвижва напред с дясната страна на брой единици
- {` <<}, роувъра от дясната страна на оператора се завърта обратно на часовниковата стрелка с лявата страна на брой градуси
- {` >>}, роувъра от лявата страна на оператора се завърта по часовниковата стрелка с дясната страна на брой градуси

Реализирайте и съответните оператори за вход/изход от/към поток.

### Задача 5

.solution-link {url Решение;https://github.com/Syndamia/oop-2025-solutions/tree/main/Week09/Exercise05}

Реализирайте клас {` StringArray}, който съхранява неограничено (и оразмеряемо) количество низове.
Реализирайте нужните оператори и помощни класове, чрез които следния код е валиден:

.note
{i (26.04.2026)}
Обновени конвертирания, така че примера да работи.
Променени първите три размери.

```cpp
StringArray s;
s[ Z(7) +++ Z(4) +++ Z(3) ] ("") (X("Hello")|"World") [ Z(4) +++ Z(5) +++ Z(1) ] ("!") [ Z(2) ] (X("Code")|"A"|"B");

В квадратните скоби се изреждат максимални размери на очаквани низове, разделени с {` +++}.
В кръглите скоби се подават низове, разделени с {` |}.
Класовете {` Z} и {` X} са класове, наименувани по ваш начин.

.question
Защо ни трябва експлицитното конвертиране?
Защо числата винаги ги конвертираме експлицитно, а низовете само веднъж (когато са изредени повече от един)?

Тоест,
.bulleted
- първо очакваме три низа, с максимални размери от 7, 4 и 3
- след това ни се подава един низ с размер 0
- след това ни се подават два низа, съответно с размери 5 и 5 (скъсяваме ги)
- след това очакваме три низа, с максимални размери от 4, 5 и 1
- след това ни се подава един низ с размер 1
- след това допълнително очакваме един низ с размер 2
- след това ни се подават три низа, с размери 4, 1 и 1

Финално, в {` s} трябва да имаме низовете {` "", "Hell", "Wor", "!", "Code", "A", "B"}.

Ако ни се подаде низ с по-голям размер от очаквания, трябва да съхраним само броя знаци, които очакваме.
Ако ни се подаде низ, който не очакваме, трябва да го игнорираме.