ПРАКТИЧЕСКО УПРАЖНЕНИЕ No 9

ИЗПОЛЗВАНЕ НА КЛАСОВЕТЕ ARRAY, SORTEDARRAY И

ASSOCIATION ОТ КОНТЕЙНЕРНАТА БИБЛИОТЕКА НА BORLAND C++

1. Цел на упражнението
Усвояване използването на класове, произхождащи от клас
AbstractArray и Object от контейнерната библиотека на класовете на
Borland C++.

2. Основни методи при работа с класовете

2.1. Клас AbstractArray

В контейнерната библиотека на Borland C++ има специална
йерархия от класове за работа с масиви. Двата класа в тази йерархия,
от които могат да се създават обекти, са Array и SortedArray. Всички
характеристики, които са общи за тези два класа са обединени в
базовия клас AbstractArray. Масивите започват съществуването си
като празни. Клас Array позволява явно да се определя индекса в
масива, докато клас SortedArray поддържа всички обекти в подреден
вид. Масивите, създадени от клас SortedArray, могат свободно да
преместват обекти, така че индекса, на който даден обект се съхранява
може да се променя. Добавен към контейнер-масив елемент по
подразбиране се счита собственост на масива. За да се изтрие обект,
притежаван от контейнер, трябва да се изтрие елемента от контейнера.
Масиви, които са динамично резервирани, имат допълнителната
възможност за променлив размер по време на изпълнение на програма.
Клас AbstractArray е производен на клас Collection и има следните
специфични методи:
• AbstractArray( int upper, int lower=0, sizeType s=0 ); - Конструкторът
създава масив от елементи с индекси от lower до upper, където lower
може да бъде число, по-голямо 0. Ако параметърът s е различен от
нула, масивът може да нараства по време на изпълнение, на порции
от по s елемента. В противен случай масивът се ограничава до
фиксиран размер.
• Object& operator [] (int i) const;-Връща по адрес елемента с индекс i.
• int lowerBound( void ) const; - Връща най-малкия възможен за
използване индекс в масива.
• int upperBound( void ) const; - Връща най-големия индекс до
момента, присвоен на масива. За разлика от долната граница, горната
граница може да варира при разширяване на масива. Стойността й
може само да нараства, тъй като масивите никога не намаляват по
време на изпълнение.

1
• sizeType arraySize( void ) const; - Връща размера на заделения
масив.
• virtual void detach( Object&, DeleteType = NoDelete); - Претърсва
масив (започвайки от най-макия индекс) за даден обект. Ако обектът
бъде намерен, то той се изключва от масива и в зависимост от
стойността на втория параметър се изтрива. Ако един и същ обект се
среща няколко пъти в масива, само екземплярът с най-малък индекс е
обект на въздействие от страна на функцията.
• virtual void detach( int i, DeleteType = NoDelete); - Отстранява обекта
с индекс i.
• void destroy( int i ); - Изключва и изтрива обект с индекс i на масива.

2.2. Клас Array

Клас Array е производен на клас AbstactArray и осъществява
структура "масив" със следните специфични методи:
• Array( int upper, int lower=0, sizeType s=0 ); - Конструкторът създава
масив със зададените горна и долна граници за неговите индекси.
• virtual void add( Object& ); - Добавя обект на следващия индекс по
подразбиране. За да се определи този индекс, се сканира
съдържимото до момента в масива, като се търси първия свободен и
достъпен индекс. Ако такъв не бъде открит, масивът се разширява
(ако е възможно).
• void addAt( Object&, int ); - Добавя елемент в масива на даден
индекс. Ако индексът е извън края на масива, масивът при
възможност се разширява.

2.3 Клас SortedArray

Клас SortedArray (сортиран масив) е контейнер, съхраняващ
обекти подредени в нарастващ ред в масив. Сортираният масив е по-
различен, тъй като при него на елементите не се позволява да бъдат
вмъквани на произволни индекси. Само обекти, производни на клас
Sortable, могат да се вмъкват в сортиран масив. Клас SortedArray е
производен на клас AbstractArray и има следните специфични методи:
• Array( int upper, int lower=0, sizeType s=0 ); - Конструкторът заделя
място в паметта за масив, като използва конструктора на базовия клас
AbstractArray.
• virtual void add( Object& ); - Вмъква обект в масив, като масива
остава подреден в нарастващ ред.
• virtual void detach( Object&, DeleteType=NoDelete ); - Изключва обект
от сортиран масив и уплътнява масива така, че да няма празни
индекси между елементите.

2
 2.4. Клас Association
Асоциацията е връзка между два обекта. Какво ще означава
връзката между обектите зависи изцяло от програмиста: всъщност класа
дори няма средство (начин) да управлява принципа на връзка. Първият
елемент на един асоциативен обект се нарича ключ, а вторият -
стойност. Клас Association е производен на клас Object и има
следните специфични методи:
• Association( Object& key, Object& value ); - Kонструкторът приема
два псевдонима на обекти от клас Object и ги използва за
инициализиране членовете-данни aKey и aValue.
• Association( const Association& ); - Този "copy" конструктор приема
псевдоним на друг обект Association, инициализирайки себе се със
същия ключ и стойност.
• Object& key( void ) const;
• Object& value( void ) const; - Тези функции извличат стойностите от
private обектите, съхранени в асоциативен обект.
• virtual int isAssociation( void ) const; - Връща ненулева стойност, ако
обектите, указвани чрез Object&, са от клас Association.
• private:
Object& aKey;
Object& aValue;
Тези обекти могат да указват всеки обект, производен от клас Object.
Самият клас не налага ограничения или правила за това как да се
използва асоциация. Ключът и стойността на асоциация са със свободен
формат. Деструкторите за aKey и aValue автоматично се извикват,
когато се унищожава съответния асоциативен обект.
За да се формира асоциативен обект, трябва двата обекта да се
предадат по адрес на клас Association.

3. Задачи за изпълнение

Задача 1:
Да се декларира oбект от клас Array (масив) индексите, на който се
изменят от 0 до 5, като на масива се даде възможност да нараства по
време на изпълнение с по 9 елемента.
• Да се добавят 3 обекта от клас DANNI (виж фиг. 8.1. и 8.2) в масива
(да се използва функция add);
• Да се добави обект от клас DANNI на позиции 4 и 5 (да се използва
функция addAt);
• Да се изключи обект от клас DANNI, намиращ се на позиция 2 в
създадения вече масив (да се използва функция detach);
• Да се замени обект от клас DANNI, намиращ се на позиция 1 с нов
обект. (да се използва функция addAt);
• Да се добави нов обект от клас DANNI (да се използва функция add).

3
• Да се създаде Project включващ:
MAIN.CPP - съдържа главната програма;
DANNI.CPP - съдържа дефинициите на потребителския клас.

Задача 2:
Aналогично на Задача 1 да се декларира обект от клас
SortedArray (сортиран масив) индексите, на който се изменят от 0 до 5,
като се предвиди възможност масивът да нараства по време на
изпълнение с по 9 елемента.
• Да се добавят няколко обекта от клас DANNI в масива (да се използва
функция add).
• Да се изключи обект от клас DANNI, намиращ се на позиция 2 в
създадения вече масив (да се използва функция detach).
• Да се добавят два нови обекта от клас DANNI (да се използва
функция add).
• Във файлa DANNI.CPP, съдържащ дефинициите на потребителския
клас, да се дефинират функцията isSortable и функцията isLessThan,
съдържаща критерия, по който ще се определя кога един обект е по-
малък от друг.

Задача 3:
Да се разгледа, компилира и изпълни програмата от фиг. 9.1,
представяща пример за използване на класa Association.

Задача 4:
Аналогично на програмата от Задача 3 да се създаде асоциативен
обект, отразяващ връзката между обект от клас String и обект от
потребителски дефиниран клас DANNI.

4
// ******************* MAIN.CPP ******************** //
// **** Пример за използване на класа Association **** //

#ifndef __IOSTREAM_H
#include <iostream.h>
#define __IOSTREAM_H
#endif
#include <conio.h>
#ifndef __ASSOC_H
#include <assoc.h>
#endif
#ifndef __STRNG_H
#include <strng.h>
#endif

void main( void )

{
const int SIZE=4;
const int BUFFER_SIZE=100;

Association *ukazat[SIZE];
char *name = new char[BUFFER_SIZE];
char *number = new char[BUFFER_SIZE];
clrscr();
for ( int i=0; i<SIZE; i++ )
{
cout << "\nИме? ";
cin >> name;
String *nameStr = new String(name);
cout << "\nНомер? ";
cin >> number;
String *numberStr = new String(number);
ukazat[i] = new Association(*nameStr, *numberStr);
} // end for
delete name;
delete number;

cout << "\nТелефонен указател: ";

for ( i=0; i<SIZE; i++ )
{
cout << "\n Телефон [" << i << "] = " << ukazat[i]->key()
<< ": " << ukazat[i]->value();
} // end for
getch();
} // end main

// *************** END MAIN.CPP ******************* //

Фиг. 9.1