Бьерн Страуструп. Язык программирования С++ Второе дополненное издание



Pdf көрінісі
бет154/256
Дата11.07.2022
өлшемі2,87 Mb.
#37591
1   ...   150   151   152   153   154   155   156   157   ...   256
Байланысты:
Бьерн Страуструп. Язык программирования С . М Бином, 2011

8.3.2 Список без принудительной связи 
После "экскурса" в вопросы построения и использования списка с принудительной связью перейдем к 
построению списков без принудительной связи. Это значит, что элементы списка не обязаны содержать 
дополнительную информацию, помогающую в реализации списочного класса. Поскольку мы больше не 
можем рассчитывать, что объект в списке имеет поле связи, такую связь надо предусмотреть в 
реализации: 
template 
struct Tlink : public slink { 

info; 
Tlink(const T& a) : info(a) { } 
}; 
Класс Tlink хранит копию объектов типа T помимо поля связи, которое идет от его базового класса 
slink. Отметим, что используется инициализатор в виде info(a), а не присваивание info=a. Это 
существенно для эффективности операции в случае типов, имеющих нетривиальные конструкторы 
копирования и операции присваивания ($$7.11). Для таких типов (например, для String) определив 
конструктор как 
Tlink(const T& a) { info = a; } 
мы получим, что будет строиться стандартный объект String, а уже затем ему будет присваиваться 
значение. Имея класс, определяющий связь, и класс Islist, получить определение списка без 
принудительной связи совсем просто: 
template 
class Slist : private slist_base { 
public: 
void insert(const T& a) 

slist_base::insert(new 
Tlink(a)); 

void append(const T& a) 

slist_base::append(new 
Tlink(a)); 


get(); 
// 
... 
}; 
template 
T Slist::get() 

Tlink* lnk = (Tlink*) slist_base::get(); 
T i = lnk->info; 
delete 
lnk; 
return 
i; 

Работать со списком Slist так же просто, как и со списком Ilist. Различие в том, что можно включать в 
Slist объект, класс которого не является производным от slink, а также можно включать один объект в 
два списка: 
void f(int i) 

Slist 
lst1; 
Slist 
lst2; 
lst1.insert(i); 


Бьерн Страуструп.
Язык программирования С++ 
 
210 
lst2.insert(i); 
// 
... 
int i1 = lst1.get(); 
int i2 = lst2.get(); 
// 
... 

Однако, список с принудительной связью, например Islist, позволял создавать существенно более 
эффективную программу и давал более компактное представление. Действительно, при каждом 
включении объекта в список Slist нужно разместить объект Tlink, а при каждом удалении объекта из Slist 
нужно удалить объект Tlink, причем каждый раз копируется объект типа T. Когда возникает такая 
проблема дополнительных расходов, могут помочь два приема. Во-первых, Tlink является прямым 
кандидатом для размещения с помощью практически оптимальной функции размещения специального 
назначения (см. $$5.5.6). Тогда дополнительные расходы при выполнении программы сократятся до 
обычно приемлемого уровня. Во-вторых, полезным оказывается такой прием, когда объекты хранятся в 
"первичном" списке, имеющим принудительную связь, а списки без принудительной связи используются 
только, когда требуется включение объекта в несколько списков: 
void f(name* p) 

Islist 
lst1; 
Slist 
lst2; 
lst1.insert(p); 
// связь через объект `*p' 
lst2.insert(p); 
//
для хранения `p' используется 
// отдельный объект типа список 
// 
... 

Конечно, подобные трюки можно делать только в отдельном компоненте программы, чтобы не 
допустить путаницы списочных типов в интерфейсах различных компонент. Но это именно тот случай, 
когда ради эффективности и компактности программы на них стоит идти. 
Поскольку конструктор Slist копирует параметр для insert(), список Slist пригоден только для таких 
небольших объектов, как целые, комплексные числа или указатели. Если для объектов копирование 
слишком накладно или неприемлемо по смысловым причинам, обычно выход бывает в том, чтобы 
вместо объектов помещать в список указатели на них. Это сделано в приведенной выше функции f() 
для lst2. 
Отметим, что раз параметр для Slist::insert() копируется, передача объекта производного класса 
функции insert(), ожидающей объект базового класса, не пройдет гладко, как можно было (по наивности) 
подумать: 
class smiley : public circle { 
/* ... */ }; 
void g1(Slist& olist, const smiley& grin) 

olist.insert(grin); 
// 
ловушка! 

В список будет включена только часть circle объекта типа smiley. Отметим, что эта неприятность будет 
обнаружена транслятором в том случае, который можно считать наиболее вероятным. Так, если бы 
рассматриваемый базовый класс был абстрактным, транслятор запретил бы "урезание" объекта 
производного класса: 
void g2(Slist& olist, const circle& c) 

olist.insert(c); 
// ошибка: попытка создать объект 
// абстрактного класса 

Чтобы избежать "урезания" объекта нужно использовать указатели: 
void g3(Slist& plist, const smiley& grin) 



Бьерн Страуструп.
Язык программирования С++ 
 
211 
olist.insert(&grin); 
// 
прекрасно 

Не нужно использовать параметр-ссылку для шаблонного класса: 
void g4(Slist& rlist, const smiley& grin) 

rlist.insert(grin); 
// ошибка: будет созданы команды, 
// содержащие ссылку на ссылку (shape&&) 

При генерации по шаблону типа ссылки, используемые подобным образом, приведут ошибкам в типах. 
Генерация по шаблону типа для функции 
Slist::insert(T&); 
приведет к появлению недопустимой функции 
Slist::insert(shape&&); 
Ссылка не является объектом, поэтому нельзя иметь ссылку на ссылку. 
Поскольку список указателей является полезной конструкцией, имеет смысл дать ему специальное имя: 
template 
class Splist : private Slist
public: 
void insert(T* p) { Slist::insert(p); } 
void append(T* p) { Slist::append(p); } 
T* get() { return (T*) Slist::get(); } 
}; 
class Isplist : private slist_base { 
public: 
void insert(T* p) { slist_base::insert(p); } 
void append(T* p) { slist_base::append(p); } 
T* get() { return (T*) slist_base::get(); } 
}; 
Эти определения к тому же улучшают контроль типов и еще больше сокращают необходимость 
дублировать функции. 
Часто бывает полезно, чтобы тип элемента, указываемый в шаблоне типа, сам был шаблонным 
классом. Например, разреженную матрицу, содержащую даты, можно определить так: 
typedef Slist< Slist > dates; 
Обратите внимание на наличие пробелов в этом определении. Если между первой и второй угловой 
скобкой > нет пробелов, возникнет синтаксическая ошибка, поскольку >> в определении 
typedef Slist> dates; 
будет трактоваться как операция сдвига вправо. Как обычно, вводимое в typedef имя служит синонимом 
обозначаемого им типа, а не является новым типом. Конструкция typedef полезна для именования для 
длинных имен шаблонных классов также, как она полезна для любых других длинных имен типов. 
Отметим, что параметр шаблона типа, который может по разному использоваться в его определении, 
должен все равно указываться среди списка параметров шаблона один раз. Поэтому шаблон типа, в 
котором используется объект T и список элементов T, надо определять так: 
template class mytemplate { 

ob; 
Slist 
slst; 
// 
... 
}; 
а вовсе не так: 


Бьерн Страуструп.
Язык программирования С++ 
 
212 
template > class mytemplate { 

obj; 
Slist 
slst; 
// 
... 
}; 
В $$8.6 и $$R.14.2 даны правила, что может быть параметром шаблона типа. 


Достарыңызбен бөлісу:
1   ...   150   151   152   153   154   155   156   157   ...   256




©emirsaba.org 2024
әкімшілігінің қараңыз

    Басты бет