# Задачи - ООП, Седмица 9, 15.04.2026

'define expected-reading 5 min
'define created 14 April 2026
'define edited 26 April 2026
[$pagenav]

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

### Задача 1

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

.note
[*(26.04.2026)*] Променено от "дата на производство" в "година на производство"

Реализирайте клас [`Locomotive`], който съдържа:
.bulleted
- идентификационен номер
- име на производител
- име на модел
- година на производство
- дължина в милиметри
- брой цилиндри в двигателя
- дали поддържа връзка с втори локомотив, така че и двата да се управляват от един машинист (так. нар. [url https://en.wikipedia.org/wiki/Multiple_working 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
[*(26.04.2026)*]
Обновени конвертирания, така че примера да работи.
Променени първите три размери.

```c++
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"`].

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