Алгоритм sort_heap()
|
template< class RandomAccessIterator > void sort_heap( RandomAccessIterator first, RandomAccessIterator last ); template< class RandomAccessIterator, class Compare > void sort_heap( RandomAccessIterator first, |
RandomAccessIterator last, Compare comp );
sort_heap()
сортирует последовательность в диапазоне [first,last), предполагая, что это правильно построенный хип; в противном случае поведение программы не определено. (Разумеется, после сортировки хип перестает быть хипом!) В первом варианте при сравнении используется оператор “меньше”, определенный для типа элементов контейнера, а во втором – операция comp.
|
#include <algorithm> #include <vector> #include <assert.h> template <class Type> void print_elements( Type elem ) { cout << elem << " "; }
int main() { int ia[] = { 29,23,20,22,17,15,26,51,19,12,35,40 }; vector< int, allocator > vec( ia, ia+12 );
// печатается: 51 35 40 23 29 20 26 22 19 12 17 15 make_heap( &ia[0], &ia[12] ); void (*pfi)( int ) = print_elements; for_each( ia, ia+12, pfi ); cout << "\n\n"; // печатается: 12 17 15 19 23 20 26 51 22 29 35 40 // минимальный хип: в корне наименьший элемент make_heap( vec.begin(), vec.end(), greater<int>() ); for_each( vec.begin(), vec.end(), pfi ); cout << "\n\n"; // печатается: 12 15 17 19 20 22 23 26 29 35 40 51 sort_heap( ia, ia+12 ); for_each( ia, ia+12, pfi ); cout << "\n\n"; // добавим новый наименьший элемент vec.push_back( 8 ); // печатается: 8 17 12 19 23 15 26 51 22 29 35 40 20 // новый наименьший элемент должен оказаться в корне push_heap( vec.begin(), vec.end(), greater<int>() ); for_each( vec.begin(), vec.end(), pfi ); cout << "\n\n"; // печатается: 12 17 15 19 23 20 26 51 22 29 35 40 8 // наименьший элемент должен быть заменен на следующий по порядку pop_heap( vec.begin(), vec.end(), greater<int>() ); for_each( vec.begin(), vec.end(), pfi ); cout << "\n\n"; |
}
#
#include, директива
использование с using-директивой, 68, 427
использование с директивой связывания, 354
*
умножения оператор
комплексных чисел, 155
ч
члены класса
функции-члены
константные, 611–14
подвижные (volatile), 611–14
Д
деструктор(ы)
для элементов масс??а
освобождение динамической памяти, 693–94
abort(), функция
вызов из terminate() как подразумеваемое поведение, 541
abs(), функция
поддержка для комплексных чисел, 156
accumulate(), обобщенный алгоритм, 1104
adjacent_difference(), обобщенный алгоритм, 1106
adjacent_find(), обобщенный алгоритм, 1107
ainooi
к базовому классу, 880–88
algorithm, заголовочный файл, 584
any(), функция
в классе bitset, 167
append(), функция
конкатенация строк, 287
argc, переменная
счетчик аргументов в командной строке, 356
argv, массив
для доступа к аргументам в командной строке, 356
assert(), макрос, 51
использование для отладки, 226
at(), функция
контроль выхода за границы диапазона во время выполнения, 289
atoi(), функция
применение для обработки аргументов в командной строке, 360
auto_ptr, шаблон класса, 395–400
memory, заголовочный файл, 395
инициализация, 397
подводные камни, 399
aункции
интерфейс
включение объявления исключений в, 546
B
back(), функция
поддержка очереди, 316
back_inserter(), адаптор функции
использование в операции вставки push_back(), 577
begin(), функция
итератор
возврат с помощью, 578
использование, 261
binary_search(), обобщенный алгоритм, 1108
bind1st(), адаптор функции, 573
bind2nd(), адаптор функции, 573
bitset, заголовочный файл, 168
bitset, класс, 165
size(), функция, 167
test(), функция, 167
to_long(), функция, 170
to_string(), функция, 170
заголовочный файл bitset, 168
оператор доступа к биту ([]), 167
операции, 168–71
break, 218–19
break, инструкция
использование для выхода из инструкции switch, 203
сравнение с инструкцией return, 346
C
C, язык
символьные строки
динамическое выделение памяти для, 401
необходимость доступа из класса string, 128
отсутствие завершающего нуля как программная ошибка, 402
C_str(), функция
преобразование объектов класса string в C-строки, 137
C++, язык
std, пространство имен, 426–28
введение в (глава), 12–13
компоненты
(часть 2), 319
типы данных (глава), 98–140
предопределенные операторы (таблица), 727
case, ключевое слово
использование в инструкции switch (таблица), 202
catch-обработчик, 62, 534, 537
критерий выбора, 63
определение, 537
универсальный обработчик, 543–45
cerr, 26
представление стандартного вывода для ошибок с помощью, 1041
char *, указатель
работы с C-строками символов, 92
char, тип, 76
check_range(), пример функции
как закрытая функция-член, 51
cin, 26
использование итератора istream_iterator, 579
представление стандартного ввода с помощью, 1041
class, ключевое слово
typename как синоним, 479
использование в определении класса, 594
использование в определении шаблона класса, 801
использование в параметрах-типах шаблона
класса, 800
функции, 476
const, квалификатор
вопросы разрешения перегрузки функций
параметры-типы, 432
вопросы разрешения перезагрузки функций
использование преобразования квалификаторов, 449
ранжирование преобразований, связанных с инициализацией ссылочных параметров, 473
константная функция-член, 611–14
константные объекты, динамическое выделение и освобождение памяти, 402–3
константные параметры
параметры-ссылки с квалификатором const, 330, 340
передача массива из константных элементов, 336
константный итератор, 262
контейнеры, необходимость константного итератора, 575
преобразование объектов в константы, 101
сравнение с volatile, 127
ссылка, инициализация объектом другого типа, 105
указатели на константные объекты, 101
const_cast, оператор, 180
continue, инструкция, 219
copy(), обобщенный алгоритм, 1109
использование класса inserter, 305
конкатенация векторов с помощью, 557
count(), обобщенный алгоритм, 1112
использование istream_iterator и ostream_iterator, 581
использование с контейнерами multimap и multiset, 311
использование с множествами, 306
использование с отображениями, 298
count(), функция
в классе bitset, 167
count_if(), обобщенный алгоритм, 1114
cout, 26
представление стандартного вывода с помощью, 1041
cпецификации
исключений
для документирования исключений, 546
D
default, ключевое слово
использование в инструкции switch, 202, 205
delete, оператор, 35, 162–63, 744–53
безопасное и небезопасное использование, примеры, 394
для массивов, 749–51
объектов класса, 750
синтаксис, 402
для одиночного объекта, 392
использование класса-распределителя памяти (сноска), 256
размещения, 751–53
deque (двустороння очередь, дека)
использование итераторов с произвольным доступом, 583
как последовательный контейнер, 248–301
применение для реализации стека, 314
требования к вставке и доступу, 252
do-while, инструкция, 216–18
сравнение с инструкциями for и while, 209
E
иници??изация
массива
динамически выделенных объектов классов, 691–94
копиру??ий
конструктор, 680–82
end(), функция
итератор, использование, 261
endl, манипулятор потока iostream, 27
enum, ключевое слово, 112
equal_range(), обобщенный алгоритм
использование с контейнерами multimap и multiset, 310
extern "C"
и перегруженные функции, 438–39
неприменимость безопасного связывания, 440
указатели на функции, 373–75
extern, ключевое слово
использование с указателями на функции, 373
использование с членами пространства имен, 418
как директива связывания, 354
объявление
константы, 386
шаблона функции, 481
объявления объектов
без определения, 382
размещение в заголовочном файле, 384
F
f, суффикс
нотация для литерала с плавающей точкой одинарной точности, 77
find(), обобщенный алгоритм
использование с контейнерами multiset и multimap, 309
поиск объектов в множестве, 306
поиск подстроки, 273
поиск элемента отображения, 298
find_first_of(), обобщенный алгоритм
нахождение знаков препинания, 280
нахождение первого символа в строке, 273
find_last_ of(), 279
find_last_not_of(), 279
for, инструкция, 209–12
использование с инструкцией if, 196
front(), функция
поддержка очереди, 316
front_inserter(), адаптор функции
использование в операции push_front(), 577
fstream, класс
файловый ввод / вывод, 1042
full(), функция
модификация алгоритма динамического роста стека, 317
functional, заголовочный файл, 568
G
get(), функция, 1063–66
getline(), функция, 270, 1066–68
goto, инструкция, 219–22
greater, объект-функция, 571
greater_equal, объект-функция, 571
I
i?enaaeaaiea
почленное для объектов класса, 925–29
i?iecaiaiua eeannu
ae?ooaeuiua ooieoee, 899–925
определение
при одиночном наследовании, 876–78
присваивание
оператор
перегруженный, 925–29
if, инструкция, 192–98
If, инструкция
условный оператор как альтернатива, 158
insert(), функция
вставка символов в строку, 286
добавление элементов в множество, 305
реализация, 266
списки, 222
inserter(), адаптор функции
для вставки с помощью insert(), 577
inserter, класс, 305
Iomanip, заголовочный файл, 136
iostream библиотека
iostream.h, заголовочный файл, пример использования, 563
ввод
istream_iterator, 579
итератор чтения, 582
вывод
ostream_iterator, 580–82
итератор записи, 582
итератор чтения, 582
итераторы, 578–82
манипуляторы
endl, 27
операторы, сцепление, 28–29
iostream.h, заголовочный файл
пример использования для манипуляций с текстом, 563
isalpha(), функция, 206
ctype, заголовочный файл, 283
isdigit(), функция
ctype, заголовочный файл, 283
ispunct(), функция
ctype, заголовочный файл, 283
isspace(), функция
ctype, заголовочный файл, 283
istream_iterator, 579–80
iterator, заголовочный файл, 578
L
less, объект-функция, 572
less_equal, объект-функция, 572
limits, заголовочный файл, 145
list, заголовочный файл, 256
locale, заголовочный файл, 283
l-значение, 81
как возвращаемое значение, подводные камни, 348
оператор присваивания, требования, 149
преобразования, 447
преобразование точного соответствия, 445
точное соответствие при разрешении перегрузки функций, 457
трансформация, 450, 469
преобразование аргументов шаблона функции, 486
M
main(), 15
обработка аргументов в командной строке, 356–65
map, заголовочный файл, 293
использование с контейнером multimap, 309
memory, заголовочный файл, 395
merge(), обобщенный алгоритм
специализированная версия для спискаов, 588
minus(), объект-функция, 570
modulus, объект-функция, 571
multimap (мультиотображение), контейнер, 309–12
map, заголовочный файл, 310
сравнение с отображением, 303
multiplies, объект-функция, 570
multiset (мультимножество), контейнер, 309–12
set, заголовочный файл, 310
N
negate, объект-функция, 571
new оператор, 162–63
для константных объектов, 403–4
для массивов, 400–402
классов, 749–51
для объектов классов, 745
для одиночных объектов, 392–95
использование класса распределителя памяти (сноска), 256
оператор размещения new, 403–4
для объектов класса, 751–53
спецификации
исключений, 546–50
и указат??и на функции, 548–50
статические члены класса, 621–27
данные-члены, 621–27
функции-члены, 626–27
not_equal_to, объект-функция
(код), 571
not1(), адаптор функции
как адаптор-отрицатель, 573
not2(), адаптор функции
как адаптор-отрицатель, 573
numeric, заголовочный файл, 584
использование численных обобщенных алгоритмов, 586
O
oaaeiiu eeannia
конкретизация, 800–811
члены
шаблонов, 826–31
ofstream, тип, 1076–86
фун??ии-члены
volatile, 611–14
функции-члены
константные, 611–14
ostream_iterator, 580–82
P
pair, класс, 127
использование для возврата нескольких значений, 197
plus, объект-функция, 568, 570
pop_back(), функция
для удаления элементов из последовательного контейнера, 267
использование для реализации динамического роста стека, 317
push_back(), функция
векторы, вставка элементов, 123
поддержка в контейнерах, 257
стеки, использования для динамического выделения памяти, 317
push_front(), функция
поддержка в списковых контейнерах, 257
pаголовочные файлы
содержимое
объявления функций, с включением явной спецификации исключений, 546
Q
queue, заголовочный файл, 315
R
register, ключевое слово, 389–90
reinterpret_cast, оператор
опасности, 181
reinterpret_cast, оператор, 181
release()б функция
управление объектами с помощью класса auto_ptr, 400
reserve(), функция
использование для установки емкости контейнера, 255
reset(), функция
в классе bitset, 167
установка указателя auto_ptr, 398
resize(), функция
использование для изменения размера контейнера, 258
return, инструкция
завершение функции с помощью, 346
неявное преобразование типа в, 176
сравнение с выражением throw, 531
r-значение, 81
использование при вычислении выражений, 141
S
set, заголовочный файл, 304, 310
size(), функция
для модификации алгоритма выделения памяти в стеке, 317
sizeof, оператор, 159–62
использование с типом ссылки, 161
использование с типом указателя, 161
как константное выражение, 162
sort(), обобщенный алгоритм
вызов, 120
передача объекта=функции в качестве аргумента, 569
stack, заголовочный файл, 312
static_cast
сравнение с неявным преобразованием, 180
static_cast, оператор
опасности, 181
std, пространство имен, 426–28
string, заголовочный файл, 67
string, строковый тип, 95–98
substr(), функция, 275
пустая строка, 96
смешение объектов типа string и C-строк, 97
switch, инструкция, 207
использование ключевого слова case, 202
использование ключевого слова default, 202, 205
T
terminate(), функция, 541
this, указатель, 616–20
tolower(), функция
locale, заголовочный файл, 283
преобразование заглавных букв в строчные, 283
toupper(), функция
ctype, заголовочный файл, 283
locale, заголовочный файл, 283
true, ключевое слово, 108
typedef
для объявления указателя на функцию, 372
для улучшения читабельности, 295, 369
как синоним существующего имени типа, 431
массива указателей на функции, 369
typename, 242
использование с параметрами шаблона функции, 480
U
unexpected(), функция
для обработки нераспознанных исключений, 547
unique(), обобщенный алгоритм
удаление дубликатов из вектора, 557
unique_copy(), обобщенный алгоритм
запись целых чисел из вектора в стандартный вывод, 579
using-директивы, 423–26
влияние на разрешение перегрузки функции, 463
для объявления перегруженных функций, 437–38
сравнение с using-объявлениями, 423–26
using-объявления, 422–23
влияние на разрешение перегрузки функции, 462
для объявления перегруженных функций, 434–36
сравнение с using-директивами, 423–26
utility, заголовочный файл, 127
V
vector, заголовочный файл, 70, 121, 256
void
в списке параметров функции, 325
указатель, 179
void*
преобразование в void* как стандартное преобразование, 456
volatile, квалификатор, 127
для типа параметра, в связи с перегрузкой функций, 432
для функции-члена, 611–14
использование преобразования квалификаторов, 471
преобразование
квалификаторов, 449
W
while, инструкция, 213–16
сравнение с инструкциями for и do-while, 209
А
абстракция
объекта, класс комплексных чисел как пример, 154
стандартная библиотека, преимущества использования, 165
автоматические объекты, 388–90
объявление с ключевым словом register, 389–90
особенности хранения, 388
адапторы
функций, для объектов-функций, 573
адапторы функций, 573
адрес(а)
как значение указателя, 88
конкретизированных шаблонов функций, 484
алгоритм(ы)
функция
выведение аргумента шаблона, 489
разрешение перегрузки, 511
шаблон как, 475
аргумент(ы), 321
передача, 345
использование указателей для, 87
передача по значению, 327
по умолчанию, 340–43
должны быть хвостовыми, 341
и виртуальные функции, 913
и устоявшие функции, 472–73
тип
преобразования, разрешение перегрузки функции, 444–60
преобразования, расширение типа, 451–53
преобразования, ссылок, 457–59
преобразования, стандартные, 453–57
шаблона класса
для параметров-констант, 805–9
для параметров-типов, 800–811
шаблонов функции
явные, 490–93
шаблонов функций
выведение аргументов, 485–90
явная спецификация, мотивировка, 492
явная спецификация, недостатки, 492
явное специфицирование, 490
арифметические
исключения, 143
объекты-функции, 570
операторы, 142–45
таблица, 142
операции, поддержка для комплексных чисел, 126
преобразования, 175, 142–45
bool в int, 109
неявное выполнение при вычислении выражений, 175
типов, расширение типа перечисления, 112
указатели, 90
ассоциативность
операторов, влияние на вычисление выражений, 171–74
порядок вычисления подвыражений, 142
ассоциативные контейнеры, 248–301
неприменимость обобщенных алгоритмов переупорядочения, 587
ассоциирование
значений, использование класса pair, 127
Б
базовые классы
абстрактные базовые классы, 865–69, 908
видимость классов
при виртуальном наследовании, 983–84
видимость членов
при множественном наследовании, 968–71
при одиночном наследовании, 966–68
виртуальные базовые классы, 974–87
деструкторы, 896–99
доступ
к базовым классам, 958–64
к закрытым базовым классам, 963
к защищенным членам, 871
к членам, 880–88
доступ к элементам отображения с помощью, 299
конструирование
виртуальное наследование, 974–82
множественное наследование, 950–51
одиночное наследование, 889–96
почленная инициализация, 925–27
конструкторы, 889–99
определение базового класса
при виртуальном наследовании, 976–78
при множественном наследовании, 950–55
при одиночном наследовании, 871–75
преобразование к базовому классу, 865–69
при выведении аргументов шаблона функции, 487
присваивание, почленное присваивание, 927–29
байты
запись с помощью put(), 1063
чтение с помощью get(), 1063–66
безопасное связывание, 384
перегруженных функций, 440
бесконечный
рекурсия, 351
цикл, избежание в операциях поиска в строке, 274
бинарные
операторы, 141
битовое поле
как средство экономии памяти, 643–45
битовый вектор, 164
в сравнении с классом bitset, 164
блок
try-блок, 533–37
инструкций, 188
комментария, 24
функции, 321
функциональный try-блок, 533–37
и конструкторы, 1024–26
больше (>), оператор
поддержка в арифметических типах данных, 30
булевский(е)
константы, операторы, дающие в результате, 146
стандартные преобразования при разрешении перегрузки функции, 453
тип bool, 108–10
В
вектор(ы)
find(), обобщенный алгоритм, 554
емкость, связь с размером, 258
идиоматическое употребление в STL, 123
объектов класса, 689–96
присваивание, сравнение со встроенными массивами, 122
сравнение со списками, 251–52
требования к вставке и доступу, 252
увеличение размера, 253–56
вертикальная табуляция ()
как escape-последовательность, 77
взятия адреса (&) оператор
использование в определении ссылки, 104, 105
использование с именем функции, 367
как унарный оператор, 141
взятия индекса оператор ([]), 736
использование в векторах, 121
использование в классе bitset, 168
использование в отображениях, 294
отсутствие поддержки в контейнерах multimap и multiset, 312
взятия остатка, оператор (%), 142
видимость
определения символической константы, 386
переменных в условии цикла, 211, 379–81
роль в выборе функции-кандидата при разрешении перегрузки функции, 460
требование к встроенным функциям, 353, 387
членов класса, 607, 645–52
висячий
проблемы висячего else, описание и устранение, 195
указатель, 389
как проблема динамически выделенного объекта, 394
возврат каретки (\\r)
как escape-последовательность, 77
время жизни, 381
auto_ptr, влияние на динамически выделенные объекты, 395
автоматических объектов, 388
динамически выделенных объектов, 392
сравнение с указателями на них, 394
и область видимости (глава), 376–428
локальных объектов
автоматических и статических, 388
влияние раскрутки стека на объекты типа класса, 541
проблема возврата ссылки на локальный объект, 348
вставка элементов
в вектор, 123
в контейнер, с помощью адапторов функций, 577
в контейнеры multimap и multiset, 311
в отображение, 294
в последовательные контейнеры, 265
в стек, 314
использование push_back(), 257
итераторы, обозначение диапазона, 575–77
различные механизмы для разных типов контейнеров, 252
встроенные функции, 133, 322
объекты-функции, 559, 566
объявление, 352–53
шаблонов функций как, 481
определение, размещение в заголовочном файле, 385
перегруженные операторы вызова, 559
преимущества, 352
сравнение с не-встроенными функциями-членами, 605–7
встроенный(е)
массивы
запрет иниициализации другим массивом, 115
запрет использования в качестве возвращаемого значения функции, 324
запрет присваивания другому массиву, 324
запрет ссылаться на, 115
инициализация при выделении из хипа, 400
отсутствие поддержки операции erase(), 557
поддержка в обобщенных алгоритмах, 553
сравнение с векторами, 122
типы данных
арифметические, 30–33
выполнение
непоследовательные инструкции, 20
условное, 20
выражения
(глава), 141–87
использование аргументов по умолчанию, 342
порядок вычисления подвыражений, 142
разрешение имен, 377
вычисление
логических операторов, 146
порядок вычисления подвыражений, 142
вычитание
minus, объект-функция, 570
комплексных чисел, 154
Г
глобальное пространство имен
проблема засорения, 66, 406
глобальные объекты
и функции, 381–87
сравнение с параметрами и возвращаемыми значениями функций, 349–50
глобальные функции, 381
горизонтальная табуляция (\\t)
как escape-последовательность, 77
Д
данные члены, 595–96
данные-члены
битовые поля, 643–45
изменчивые (mutable), 614–16
статические, 621–28
в шаблонах классов, 821–24
указатель this, 616–21
члены базового и производного классов, 870–79
двойная кавычка (\\ ")
как escape-последовательность, 77
двойная обратная косая черта (\\)
как escape-последовательность, 77
двунаправленный итератор, 583
декремента оператор (--)
встроенный, 153–54
перегруженный, 740–44
постфиксная форма, 153, 743
префиксная форма, 153, 742
деление
комплексных чисел, 155
целочисленное, 143
деления по модулю оператор (%), 142
деструктор(ы), 682–89
для элементов массива, 690
динамическое выделение памяти
для массива, 162, 400–402
исчерпание памяти, исключение bad_alloc, 393
как требование к динамически растущему вектору, 253
объектов, 392–406
управление с помощью класса auto_ptr, 395
динамическое освобождение памяти
для массивов, 400–402
объектов, 392–406
константных, 402–3
одиночных объектов, 392–95
оператор delete, 134, 392, 394, 744–53
управление с помощью класса auto_ptr, 395
утечка памяти, 395
директивы, 21–24
директивы связывания, 353–55
в связи с перегрузкой, 438
использование с указателями на функции, 373
для элементов массива
динамическое выделение памяти, 691–94
доступ
к контейнеру
использование итератора для, 261
последовательный доступ как критерий выбора типа, 252
к массиву, 31
индекс, 45
индексирование, 113
к пространству имен
механизмы, компромиссные решения, 68
к членам, 598–99, 607–8
оператор доступа к членам ->, 740
произвольный, итератор с произвольным доступом, 583
уровни, protected, 49
друзья, 730–33
и специальные права доступа, 137, 599–600
перегруженные операторы, 730–33
См. также доступ, класс(ы), наследование, 815–21
Е
емкость контейнерных типов
в сравнении с размером, 253
начальная, связь с размером, 258
З
забой (, 77
заголовочные файлы
как средство повторного использования объявлений функций, 323
по имени
algorithm, 72, 584
bitset, 167
complex, 125
fstream, 1042
functional, 568
iomanip, 136
iterator, 578
limits, 145
locale, 283
map, 293
memory, 395
numeric, 584, 586
queue, 315
set, 304
sstream, 1044
stack, 312
string, 68
vector, 70, 121, 256
предкомпилированные, 385
содержимое
включение определения шаблона функции, преимущества и недостатки, 495
встроенные функции, 353
директивы связывания, 354
объявления, 82, 385–87
объявления явных специализаций шаблонов, 503
спецификация аргументов по умолчанию, 341
запись активации, 327
автоматическое включение объектов в, 388
запятая (,)
неправильное использование для индексации массива, 117
оператор, 163
звонок ()
как escape-последовательность, 77
знак вопроса ()
как escape-последовательность, 77
И
И, оператор, 142
идентификатор, 83
использования в качестве спецификатора типа класса, 129
как часть определения массива, 113
соглашения по именованию, 83
иерархии
определение, 862–69
идентификация членов, 870–80
исключений, в стандартной библиотеке C++, 1026–29
поддержка мезанизма классов, 128
изменчивый (mutable) член, 614–16
именование
соглашения об именовании идентификаторов, 83
имя, 83
typedef, как синоним, 126–27
именование членов класса, 607–8
квалифицированные имена, 410–12
статических членов класса, 622–23
членов вложенных пространств имен, 412–14
шаблонов функций как членов пространства имен, 524
область видимости объявления, 376
параметра шаблона
функции, 478
перегруженные операторы, 727–28
переменной, 83
псевдонимы пространства имен, как альтернативные имена, 420–21
разрешение, 377
в локальной области видимости, 379
в области видимости класса, 649–52
в определении шаблона функции, 514–20
инициализация
векторов, 121
сравнение с инициализацией встроенных массивов, 122
комплексного числа, 154
массива
динамически выделенного, 400
динамически выделенных объектов классов, 749
многомерного, 116
указателей на функции, 369
недопустимость инициализации другим массивом, 115
объектов
автоматических, 388
автоматических, по сравнению с локальными статическими, 391
глобальных, инициализация по умолчанию, 382
динамически выделенных, 393
константных, 101
статических локальных, 390, 391
поведение auto_ptr, 397
сравнение с присваиванием, 148
ссылок, 104
указателя на функцию, 367
влияние на спецификацию исключений, 549
вопросы, связанные с перегруженными функциями, 439
инкремента оператор (++)
встроенный, 154
перегруженный, 740–44
постфиксная форма, 153, 743
префиксная форма, 153, 742
инструкции, 188–98
break
для выхода из инструкции switch, 203
break, инструкция, 218–19
continue, 219
do-while, 216–17
сравнение с инструкциями for и while, 209
for, 209–13
goto, 219–21
if, 20, 192–98
if-else, условный оператор как альтернатива, 158
switch, 201–3
использование ключевого слова default, 202, 205
while, 213–16
сравнение с инструкциями for и do-while, 209
блок, 188
объявления, 189–92
простые, 188–89
составные, 188–89
инструкция
while, 21
использование преобразования квалификаторов, 449
использование шаблонов, 62
итератор с произвольным доступом, 583
итератор(ы), 123, 261
begin(), доступ к элементам контейнера, 261
end(), доступ к элементам контейнера, 261
iterator, заголовочный файл, 578
абстракция, использование а обобщенных алгоритмах для обхода, 552
адаптор, 557
вставка элементов в последовательные контейнеры, 266
доступ к подмножеству контейнера с помощью, 262
использование в обобщенных алгоритмах, 575–83
категории, 582–83
двунаправленный итератор, 583
итератор записи, 582
итератор с произвольным доступом, 583
итератор чтения, 582
однонаправленный итератор, 583
обозначение интервала с включенной левой границей, 583
обратные итераторы, 578
потоковык итераторы ввода/вывода, 578–82
istream_iterator, 579–80
ostream_iterator, 580–82
запись целых чисел из вектора в стандартный вывод, 578
чтение целых чисел из стандартного ввода в вектор, 579
требования к поведению, выдвигаемые обобщенными алгоритмами, 584
удаление элементов из последовательного контейнера, 267
К
китайский язык
поддержка двухбайтовых символьных литералов, 77
класс(ы)
возвращаемые значения, 347–49
вопросы эффективности, 712–18
друзья, 599–600, 731
заголовок, 594
объединение, 638–43
объявление, сравнение с определением класса, 600–601
определение, 594–601
сравнение с объявлением класса, 600–601
параметры
вопросы эффективности, 330, 712–18
для возврата сразу нескольких значений, 350
для передачи сразу нескольких параметров, 350
тело, 594
командная строка
класс, 363–65
опции, 356–65
argc, argv - аргументы main(), 356
использование встроенного массива для обработки, 356
пример программы, 361–63
комментарии, 24–26
блочные, 25
комплексные числа, 18, 125–26
выражения с участием, 155
заголовочный файл complex, 125
как абстракция класса, 30
операции, 154–58
представление, 156
типы данных, 30
композиция
объектов, 963–65
сравнение с наследованием, 960–62
конкретизация
шаблона функции, 482
явное объявление специализации
шаблона функции, 497–98
Конкретизация
шаблона функции
разрешение перегрузки, 506–13
конктеризация
точка конкретизации, 518
константы
константные выражения
sizeof() как пример, 162
размер массива должен быть, 113
литерал, 76–78
подстановка, 386
преобразование объектов в, 101
ссылки, рассматриваемые как, 104
конструктор(ы)
вызовы виртуальных функций в, 923–25
для базовых классов, 899
почленная инициализация, 925–30
при виртуальном наследовании, 974–82
при единичном наследовании, 896
при множественном наследовании, 950–51
для элементов массива
список инициализации массива, 689–91
и функциональные try-блоки, 1024–26
как коверторы, 761–64
конструкторы по умолчанию, 678–79
для элементов вектора, 694–96
копирующие конструкторы, 237, 680–82
почленная инициализация, 703–9, 925–30
ограничение возможности созданий объектов, 680
список инициализации членов, 696–703
контейнерные типы
определение, 256–61
контейнерные типы, 248–301
вопросы выделения памяти при копировании, 577
емкость, 253
связь с размером, 253–58
и итераторы, 261–65
инициализация, с помощью пары итераторов, 263
очереди с приоритетами, 315
параметры, 338–40, 350
преимущества, автоматическое управление памятью, 402
размер, 258
связь с емкостью, 253–56
требования к типам, с которыми конкретизируется контейнер, 259
копирование
вопросы выделения памяти, 577
использование ссылок для избежания, 330
как операция инициализации, 258
массивов, 115
сравнение со стоимостью произвольного доступа, 252
строк, 96
копирующий
конструктор, 43, 131
для динамического увеличения размера вектора, 255
оператор присваивания, реализация, 237
Л
лексикографическое упорядочение, 289
в обобщенных алгоритмах перестановок, 586
в обобщенныых алгоритмах сравнения, 586
при сортировке строк, 366–75
литеральные константы, 76–78
C-строки
сравнение с символьными литералами, 114
f суффикс, 77
U суффикс, 76
с плавающей точкой, 77
логические встроенные операторы, 145–48
оператор ИЛИ (||), 146
оператор НЕ (!), 147
логические объекты-функции
logical_and, 572
logical_not, 572
logical_or, 572
локализация
влияние глобального объекта на, 349
константной переменной или объекта, 100
локальность объявления, 190, 385
на уровне файла, использование безымянного пространства имен, 419
локальная область видимости, 376, 378–81
try-блок, 535
доступ к членам в глобальной области видимости, скрытым за локальными объектами, 411
имена в пространстве имен, скрытые за локальными объектами, 414
переменная, неинициализированная, 388
разрешение имени, 379
локальные объекты, 388–92
проблема возврата ссылки на, 348
статические, 388, 390–92
М
массив(ы), 113–20
в сравнении с векторами, 122
динамическое выделение и освобождение, 400–402
массивов объектов классов, 691–94, 744–53
индексирование, 31, 113–16
многомерных массивов, 116–17
отсутствие контроля выхода за границы диапазона, 116
инициализация, 31, 114–15
динамически выделенных массивов, 400
динамически выделенных массивов объектов класса, 690–94
многомерных массивов, 116–17
недопустимость инициализации другим массивом, 115
использование оператора sizeof(), 159
как параметры функций, 335–39
для передачи нескольких параметров, 350
многомерные, 338
преобразование массива в указатель, 448
многомерные, 116–17
недопустимость использования auto_ptr, 395
недопустимость использования в качестве возвращаемого значения функции, 324
недопустимость присваивания другому массиву, 115
недопустимость ссылок на массив, 115
обход
с помощью манипуляции указателем, 118
с помощью пары итераторов, 263–64
объектов класса, 689–96
определение, 30, 113
перегруженный оператор
delete[], 749–51
new[], 749–51
поддержка обобщенными алгоритмами, 553
размер, не является частью типа параметра, 335
связь с типом указателей, 118–20
указателей на функции, 369–70
меньше, оператор
поддержка в арифметических типах данных, 30
требование о поддержке типом элементов контейнера, 259
минус(-)
для выделения опций в командной строке, 357
многоточие (...), 343–44
использование в типах функций, 367
множество (set), контейнерный тип
set, заголовочный файл, 304
size(), 307
обход, 306–7
ограничение на изменение порядка, 587
определени, 304–6
поиск элементов, 306
сравнение с отображением, 292
модели компиляции
с разделением, 834–37
шаблонов класса
с включением, 833
с разделением, 834–36
шаблонов классов, 831–38
шаблонов функций, 494–98
с включением, 494–95
с разделением, 495–97
Н
наилучшая из устоявших функций, 442
неинициализированный
автоматический объект, 388
глобальный объект, 382
локальный статический объект, 391
неоднозначность
перегруженных
функций, диагносцирование во время разрешения перегрузки, 454
указателя, стандартные преобразования, 456
шаблона функции
аргумента, разрешение с помощью явной спецификации, 492
конкретизации, ошибка, 484
конкретизация, опасность перегрузки, 505
неявные преобразования типов, 176
новая строка ()
как escape-последовательность, 77
О
область видимости, 376–81
видимость класса, 645–52
и определение класса, 594
разрешение имен в, 649–52
глобальная область видимости, 376
и время жизни (глава), 376–428
и перегрузка, 434–38
локальная область видимости, 378–81
обращение к скрытым членам глобальной области видимости, 411
разрешение имен в, 379
объявлений исключений в catch-обработчиках, 540
параметра шаблона
функции, 478–81
пространства имен, 376
управляющих переменных в инструкции for, 379
область видимости глобального пространства имен, 376, 406
доступ к скрытым членам с помощью оператора разрешения области видимости, 411
обобщенные алгоритмы
(глава), 552–92
algorithm, заголовочный файл, 584
numeric, заголовочный файл, 584
алфавитный указатель (приложение), 1103–94
генерирования, 586
использование итераторов, 575–83
категории и описания, 583–87
когда не надо использовать, 587–92
модификации, 586
независимость от типа, 552, 553
нотация для диапазона элементов, 583
обзор, 552–56
объекты-функции как аргументы, 567
использование предопределенных объектов-функций, 569
перестановки, 586
подстановки, 585
пример использования, 556–66
работа с хипом, 587
сравнения, 586
удаления, 585
численные, 586
обработка исключений
bad_alloc, исключение нехватки памяти, 393
обратная косая черта (
как escape-символ, 280
как префикс escape-последовательности, 77
обратные итераторы, 578
обход
заполнение множества с помощью, 305
использование с контейнерами multimap и multiset, 309
множества, 306–7
невозможность обхода перечислений, 112
обход отображения, 303
отображения текста на вектор позиций, 298–301
параллельный обход двух векторов, 296
объединение
разновидность класса, 638–43
объект(ы)
автоматические, 388–89
объявление с ключевым словом register, 389–90
глобальные
и функции, 381–87
сравнение с параметрами и возвращаемыми значениями функций, 349–50
использование памяти, 82
локальные, 388–92
определение, 87
переменные как, 81
члены пространства имен, 407–8
объектное программирование, 593
объектно-ориентированное программирование
проектирование
(пример), 46–55
объекты-функции, 566–75
functional, заголовочный файл, 568
арифметические, 570
использование в обобщенных алгоритмах, 552
источники, 568
логические, 572
предопределенные, 568–70
преимущества по сравнению с указателями на функции, 567
реализация, 573–75
сравнительные, 571
Объекты-функции
адапторы функций для, 573
объявление
инструкция, 14
объявления
базового класса, виртуальное, 976–78
в части инициализации цикла for, 210
видимость имени, вводимого объявлением, 376
друзей, в шаблоне класса, 815–21
и определение, 382–83
инструкция, 189–92
исключения, 538
класса bitset, 167
объектов, 169
класса, сравнение с определением, 600–601
локальность, 190
перегруженное
оператора, 131
функции, 429
пространства имен, 407
сопоставление объявлений в разных файлах, 383
указателя на функцию, 366
включение спецификации исключений в, 548
функции, 322
задание аргументов по умолчанию, 341
как часть шаблона функции, 477
размещение в заголовочном файле, 385
функции-члена, перегруженное, 776–78
шаблона функции
определение используемых имен, 516
связь с определением, 515
требования к размещению явных объявлений конкретизации, 497
явная специализация, 499
явной конкретизации
шаблона класса, 837–38
шаблона функции, 497–98
одиночная кавычка (_)
как escape-последовательность, 77
однонаправленный итератор, 583
оператор "меньше"
характеристики и синтаксис, 146
оператор ввода, 27
оператор вывода, 1045
перегрузка, 1069. См. cout. См. cout
оператор вызова функции, 736–38
операторы
встроенные
(глава), 141–87, 141–87
sizeof, 159–62
арифметические, 142–45
бинарные, 141
декремента (--), 153–54
доступа к членам класса (. и ->), 607–8
запятая, 163
инкремента (++), 153–54
логические, 145–48
побитовые, 164–66
приоритеты, 171–74
равенства, 145–48
разрешения области видимости (
), 410–12
составного присваивания, 152
сравнения, 145–48
перегруженные
delete, 744–49
delete(), размещения, 751–53
delete[], 749–51
new, 744–49
new(), размещения, 751–53
new[], 749–51
взятия индекса ([]), 736
вопросы проектирования, 728–30
вызова функции (()), 736–38
вызова функции для объектов-функций, 567
декремента (--), 740–44
доступа к членам (->), 738–40
имена, 727–28
инкремента (++), 740–44
объявленные как друзья, 730–33
присваивания (=), 733–35
с параметрами-ссылками, преимущества, 335
члены и не-члены класса, 723–27
определения, 15
typedef, 126
базового класса, 871–75
иерархии классов, 862–69
исключений, как иерархий классов, 1013–14
класса, 594–601
сравнение с определением класса, 600–601
класса-диспетчера запросов (пример), 934–39
массива, 113
многомерных массивов, 116
множеств, 304–6
недопустимость размещения в заголовочном файле, 385
объекта, 382
объектов класса bitset, 169
объектов класса complex, 125
последовательных контейнеров, 256–61
производного класса, 876–78
пространств имен, 406–20
членов, 415–17
сравнение с объявлениями, 381–83
функции
и локальная область видимости, 378
как часть шаблона функции, 477
шаблона класса, 791–800
разрешение имен в, 844–46
опции
в командной строке, 356–65
отображения, 292–309
map, заголовочный файл, 293
заполнение, 293
невозможность переупорядочения, 587
недопустимость использования итераторов с произвольным доступом, 583
сравнение с множествами, 292
текста
заполнение, 292–98
определение, 292–98
отрицатели
как адапторы функций, 573
очереди, 315–16
queue, заголовочный файл, 315
size(), 315
top(), функция, 316
очереди с приоритетами, 315, 316
очередь с приоритетами, 315
size(), 315
top(), функция, 316
ошибки
assert(), макрос, 226
бесконечная рекурсия, 351
в инструкции if, 193
в циклах, 197
зацикливание, 93
висячие указатели, 389
как избежать, 394
динамического выделения памяти, 395
итератор, использование, 226
компиляции, конфликты в области видимости using-объявления, 437
массив
индекс за концом, 94
области видимости, подводные камни using-директивы, 426
оператор присваивания вместо оператора равенства, 100
порядка вычисления подвыражений, 142
проблема висячего else, 195
проблемы константных ссылок и указателей, 106
проблемы побитовых операторов, 166
проблемы, связанные с глобальными объектами, 349
пропуска
завершающего нуля в C-строке, 402
скобок при освобождении динамически выделенного массива, 402
редактора связей
повторные определения, 386
смещения на единицу при доступе к массиву, 31
фазы связывания при наличии объявления в нескольких файлах, 383
Ошибки
конкретизации шаблона функции, 484
П
память
утечка, 35
параметр(ы)
объявление, сравнение с объявлением исключений, 540
размер, важность для передачи по значению, 327
списки параметров
переменной длины, многоточие, 343
различия перегруженных функций, 431
ссылочные, 329–33
влияние на преобразования при разрешении перегрузки функции, 457
преимущества эффективности, 330, 540
ранжирование, 471
сравнение с параметрами-указателями, 333–35
шаблона
использование указателей на константы, 101
не являюшиеся типами, 476
являюшиеся типами, проверка, 325–26
параметры функций
аргументы по умолчаниюю, 340–43
использования многоточия, 343–44
массивы, 335–39
при разрешении перегруженных функций, 430
проверка типов, 325–26
списки параметров, 325
сравнение параметров указательного и ссылочного типов, 333–35
сравнение с глобальными объектами, 349–50
ссылки, 107, 329–33
использование для возврата нескольких значений, 197
на константы, 331
преимущества в эффективности, 330
сравнение с параметрами-указателями, 333–35
тип возвращаемого значения
тип pair, 197
указатели, 329
указатели на функции, 370–73
переменные
глобальные параметры и возвращаемые значения, 349–50
константные, 100
объявление как член пространства имен, 408
переносимость
знак остатка, 143
перестановки, обобщенные алгоритмы, 589
перечисления, 110–13
основания для включения в язык, 110
расширение типа при разрешении перегрузки функции, 452
точное соответствие при разрешении перегрузки функции, 445
по умолчанию
аргументы, 340–43
и виртуальные функции, 910–13
влияние на выбор устоявших функций, 472
и устоявшие функции, 472–73
конструктор, см. конструктор, 678–79
побитовый(е)
оператор И (&), 164
оператор И с присваиванием (&=), 152, 164
оператор ИЛИ (!), 165
оператор ИСКЛЮЧАЮЩЕЕ ИЛИ (^), 165
оператор НЕ (~), 164
оператор сдвига (<<,>>), 165
операторы, 164–66
поддержка в классе bitset, 170
повторное возбуждение
исключения, 542–43
позиция
разрешение аргумента по позиции в списке, 341
поиск
rfind(), 278
подстрок, 280
элементов
множества, 306
отображения текста, 298–99
ПОО (правило одного определения), 382, 416–18
последовательные контейнеры, 248–319
вставка элементов, 265
критерии выбора, 252
обобщенные алгоритмы, 269–70
определение, 256
перестановка элементов, 269
присваивание, 268
удаление элементов, 267
предостережения
использование знакового бита в битовых векторах, 166
неопределенность порядка вычисления бинарных операторов сравнения, 147
опасности приведения типов, 178
подводные камни
using-директивы, 426
возврата l-значение, 348
возврата ссылки на объект, 348
глобальные объекты, 349
приведения типов, 181
шаблона класса auto_ptr, 399
представление
влияние на расширение типа перечисления, 452
информация о реализации в заголовочном файле limits, 145
строк, 92
целых чисел,
143
преобразование
bool в int, 109
l-значения в r-значение, 446–47
арифметическое, 177–78
бинарного объекта-функции в унарный, использование адаптора-связывателя, 573
выбор преобразования между типами классов, 764–76
выведение аргументов шаблона функции, 486
как точное соответствие при разрешении перегрузки функции, 459
квалификаторов
влияние на последовательность преобразований, 470
при выведении аргументов шаблона функции, 487
ранжирование при разрешении перегрузки функции, 470
конверторы, 445
конструкторы
конструкторы как конверторы, 761–64
множественные, разрешение неоднозначности приведения, 468
недопустимость преобразований между типами указателей на функции, 439
неявные преобразования типов, 176
определенное пользователем, 445
последовательности
определенных пользователем преобразований, 764–67
определенных пользователем, ранжирование при разрешении перегрузки функций, 771–76
определенных пользователем, с учетом наследования, 1034–36
стандартных преобразований, 468–72
ранжирование инициализации ссылок при разрешении перегрузки функции, 457
расширения типа, 175
аргументов, 451–53
типа перечисления в арифметические типы, 112
с потерей точности, предупреждение компилятора, 326
стандартное, 453–57
типа аргумента, 444–60
трансформации l-значений, 450
трансформация I-значений
преобразования при выведении аргументов шаблона функции, 486
трансформация I-значения
ранжирование при разрешении перегрузки функции, 468
указателей
в тип void* и обратно, 179
преобразования квалификаторов, 449
стандартные преобразования указателей, 456
трансформации l-значений, массива в указатель, 448
трансформации l-значений, функции в указатель, 448
явные преобразования типов, 144, 175, 178
препроцессор
комментарий
парный(/**/), 25
константы
__cplusplus__, 23
макросы
шаблоны функций как более безопасная альтернатива, 474
предкомпилированные заголовочные файлы, 385
приведение(я), 144
const_cast, оператор, опасность применения,, 180
dynamic_cast (), оператор, 1001–7
dynamic_cast()
идентификация класса объекта во время выполнения, 182
reinterpret_cast
опасности, 181
reinterpret_cast, оператор, 181
static_cast
сравнение с неявными преобразованиями, 180
static_cast, оператор, 181
выбор конкретизируемого шаблона функции, 485
для принудительного установления точного соответствия, 450
опасности, 181
сравнение нового синтаксиса со старым, 182
старый синтаксис, 182–83
применение для подавления оптимизации, 127
примеры
класс IntArray, 45
IntSortedArray, производный класс, 54
класс iStack, 183–87
поддержка динамического выделения памяти, 316–17
преобразование в шаблон stack, 318–19
класс String, 128–39
класс связанного списка, 221–47
обработка аргументов в командной строке, 356–57
система текстового поиска
(глава 6), 248–319
функция sort, 365
шаблон класса Array, 55–62, 849–57
SortedArray, производный класс, 993–98
примитивные типы
(глава), 98–139
присваивание
векторам, сравнение с встроенными массивами, 122
и поведение auto_ptr, 397
комплексных чисел, 155
массиву, недопустимость присваивания другого массива, 115
оператор
и требования к l-значению, 81
перегруженный, 709–12, 733–35
составной, 152
последовательному контейнеру, 268–69
почленное для объектов класса, 709–12
ссылке, 107
указателю на функцию, 367
вопросы, связанные с перегруженностью функции, 439
проверка
выхода за границы диапазона, 289
не выолняется для массивов, 116
типа
назначение и опасности приведения типов, 182
неявные преобразования, 326
объявления, разнесенного по нескольким файлам, 384
отмена с помощью многоточия в списке параметров, 343
параметра, 325–27
сохранения в шаблоне функции, 476
указателя, 88
программа, 14–21
производительность
auto_ptr, 397
классы, локальность ссылок, 191
компиляции
зависимость от размера заголовочного файла, 385
при конкретизации шаблонов функций, 497
контейнеров
емкость, 255
компромиссы при выборе контейнера, 252
сравнение списка и вектора, 254
определения шаблона функции в заголовочном файле, 495
сравнение обработки исключений и вызовов функций, 550
ссылок
объявление исключений в catch-обработчиках, 540
параметры, 330
параметры и типы возвращаемых значений, 389
указателей на функции
проигрыш по сравнению с параметрами-ссылками, 540
проигрыш по сравнению со встроенными функциями, 559
сравнение с объектами-функциями, 567
функций
вопросы, связанные с возвращаемыми значениями, 324
накладные расходы на вызов рекурсивных функций, 351
недостатки, 352
передачи аргументов по значению, 328
преимущества встроенных функций, 133
производные классы
деструкторы, 896–99
конструирование, 889–96
почленная инициализация, 925–27
конструкторы, 892–93
определение
при виртуальном наследовании, 976–78
при множественном наследовании, 950–55
присваивание почленное, 927–28
пространства имен, 406–20
безымянные, 418–20
инкапсуляция сущностей внутри файлов, 419
отличие от других пространств имен, 419
вложенные, 412–14
и using-объявления,
435
объявления перегруженных функций внутри, 434–38
глобальное, 376
доступ к скрытым членам с помощью оператора разрешения области видимости, 411
проблема загрязнения пространства имен, 406
область видимости, 376
std, 426–28
определения, 408–10
определенные пользователем, 407
псевдонимы, 420–21
члены
определения, 416
требование правила одного определения, 416–18
шаблоны функций, 521–24
процедурное программирование
(часть 3), 592–782
псевдоним(ы)
имен типов, typedef, 127
пространства имен, 66, 420–21
Р
равенство
оператор(ы), 145–48
потенциальная возможность выхода за границы, 116
разрешение перегрузки функции, 443
(глава), 429–73
выбор преобразования, 767
детальное описание процедуры, 460–73
наилучшая из устоявших функция, 453
для вызовов с аргументами типа класса, 771–76
и перегрузка, 468–72
ранжирование
последовательностей определенных пользователем преобразований, 1034–36
последовательностей стандартных преобразований, 468–72
устоявшие функции, 465–68
для вызовов операторных функций, 787–88
для вызовов функций-членов, 779–82
и аргументы по умолчанию, 472–73
и наследование, 1034–36
функции-кандидаты, 461–65
для вызовов в области видимости класса, 770–71
для вызовов операторных функций, 783–87
для вызовов с аргументами типа класса, 767–70
для вызовов функций-членов, 778
и наследование, 1031–34
явные приведения как указания компилятору, 451
разрешения области видимости оператор (
)
доступ к членам глобальной области видимости, 411
), 410–12
)
доступ к членам вложенного пространства имен, 412–14
Разрешения области видимости оператор (
)
доступ к шаблону функции как члену пространства имен, 524
разыменования оператор (*)
использование с возвращенным типом указателя, 367
как унарный оператор, 141
не требуется для вызова функции, 368
опасности, связанные с указателями, 333
приоритет, 118
ранжирование
определений шаблона функции, 505
последовательностей стандартных преобразований, 468–72
рассказ об Алисе Эмме, 250
и реализация класса string, 137
рекурсивные функции, 352
С
С, язык
символьные строки
использование итератора istream_iterator, 579
функции
указатели на функции, 373
связыватель
как класс адаптора функции, 573
сигнатура, 325
символ(ы)
литералы
синтаксис записи, 77
массив символов, инициализация, 114, 115
нулевой, для завершения строкового литерала, 78
символы
& (амперсанд)
оператор взятия адреса
использование в определении ссылки, 104
&& (двойной амперсанд)
оператор логического И, 146
символы
(двойное двоеточие)
оператор разрешения области видимости класса, 42
(двойное двоеточие)
оператор разрешения области видимости, 410–12
-- (двойной минус)
оператор декремента, 153, 740–44
- (минус)
использование для обозначения опций в командной строке, 357
! (восклицательный знак)
оператор "логическое НЕ"
вычисление, 147
характеристики и синтаксис, 145
% (процент)
оператор деления по модулю, 142
оператор вычисления остатка, характеристики и синтаксис, 143
%= (процент равно)
оператор вычисления остатка с присваиванием, 152
& (амперсанд)
оператор взятия адреса
использование с именем функции, 164
как унарный оператор, 141
оператор побитового И, 164
&& (двойной амперсанд)
оператор логического И, 142
&= (амперсанд равно)
оператор побитового И с присваиванием, 164
как оператор составного присваивания, 152
() (круглые скобки)
использование оператора вызова для передачи объекта-функции, 567
оператор вызова, перегрузка в объектах-функциях, 559
(обратная косая черта a)
escape-последовательность "звонок", 77
(обратная косая черта n)
escape-последовательность "новая строка", 77
(обратная косая черта v)
escape-последовательность "вертикальная табуляция", 77
(обратная косая черта знак вопроса)
escape-последовательность "знак вопроса", 77
(обратная косая черта)
как escape-символ, 280
* (звездочка)
оператор разыменования
доступ к объектам с помощью, 89
использование для задания типа возвращаемого значения, 366
как унарный оператор, 141
не требуется для вызова функции, 368
определение указателей с помощью, 87
приоритет, 118
оператор умножения
характеристики и синтаксис, 142
*= (звездочка равно)
оператор умножения с присваиванием, 152
, (запятая)
неправильное применение для индексации массива, 117
оператор, 163
. (точка)
оператор "точка", 38
... (многоточие), 343–44
для обозначения универсального catch-обработчика, 544
использование в типах функций, 367
/ (косая черта)
оператор деления
характеристики и синтаксис, 142
/= (косая черта равно)
оператор деления с присваиванием, 152
; (точка с запятой)
для завершения инструкций, 188
?: (знак вопроса двоеточие)
условный оператор, 133, 158
сокращенная запись if-else, 199
[,) (левая квадрнатная, правая круглая скобки)
для обозначения интервала с включенной левой границей, 583
[] (квадратные скобки)
для динамического выделения памяти под массив, 400
для освобождения выделенной под массив памяти, 402
оператор взятия индекса
для доступа к вектору, 121
для проверки битов в битовом векторе, 168
инициализация отображения с помощью, 294
не поддерживается для контейнеров multiset и multimap, 312
оператор взятия индекса, 736
оператор индексирования массива, перегрузка в определении класса массива, 45
\\ " (обратная косая черта двойная кавычка)
escape-последовательность двойной кавычки, 77
\\ (двойная обратная косая черта)
escape-последовательность "обратная косая черта", 77
\\t (обратная косая черта t)
escape-последовательность горизонтальнаятабуляция, 77
^ (крышка)
оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ, 164
^= (крышка равно)
оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ с присваиванием, 164
как оператор составного присваивания, 152
__STDC__, 23
_обратная косая черта одиночная кавычка)
escape-последовательность "одиночная кавычка", 77
{} (фигурные скобки)
использование в объявлениях пространств имен, 408
использование в предложении catch, 536
использование в составной директиве связывания, 354
как ограничители составной инструкции, 188
при инициализации вложенного массива, 117
| (вертикальная черта)
оператор побитового ИЛИ, 164
|| (двойная вертикальная черта)
оператор логического ИЛИ
характеристики и синтаксис, 145
оператор логического ИЛИ
вычисление, 146
|= (вертикальная черта равно)
оператор побитового ИЛИ с присваиванием, 164
как оператор составного присваивания, 152
~ (тильда)
оператор побитового НЕ, 164
+ (плюс)
оператор сложения
поддержка в арифметических типах данных, 30
++ (двойной плюс)
оператор инкремента, 153, 740–44
+= (плюс равно)
оператор сложения с присваиванием, 146
+= (плюс равно)оператор сложения с присваиванием
как оператор составного присваивания, 152
< (левая угловая скобка)
оператор "меньше"
вопросы поддержки, 566
использование при сортировке по длине, 558
перегруженный оператор в определении контейнера, 259
<< (двойная левая угловая скобка)
оператор вывода, 26
оператор сдвига влево, 164
<<=(двойная левая угловая скобка равно)
оператор левого сдвига с присваиванием, 152
<> (угловые скобки)
явный шаблон
применение в специализациях, 499
спецификации аргументов, 490
-= (минус равно)
оператор вычитания с присваиванием, 152
= (равно)
оператор присваивания, 100, 733–35
и l-значение, 81
использование с объектами классов, 39
использование с псевдонимами пространств имен, 420
== (двойное равно)
оператор равенства, 100
поддержка в арифметических типах данных, 30
оператор равенства, необходимость наличия в определении контейнера, 259
-> (минус правая угловая скобка)
оператор "стрелка"
перегруженный оператор доступа к членам, 740
>> (двойная правая угловая скобка)
оператор ввода, 1051–63
перегрузка. cin. cin
оператор сдвига вправо, 164
>>=(двойная правая угловая скобка равно)
оператор правого сдвига с присваиванием, 152
символы:, 77
сложения (+) оператор
комплексных чисел, 155
сокрытие информации, 39, 598
вопросы, связанные с вложенными пространствами имен, 414
доступ к
закрытым членам класса, 607
имена в локальной области видимости, 378
объявление члена пространства имен, обход с помощью оператора разрешения области видимости, 411
параметры шаблона, имена в глобальной области видимости, 478
сравнение с перегрузкой, 434
во вложенных областях видимости, 461
члены глобальной области видимости, доступ с помощью оператора разрешения области видимости, 411
составные
выражения, 142
инструкции, 188–89
директивы связывания, 354
присваивания
оператор, 152
операторы над комплексными числами, 156
состояния условий
в применении к библиотеке iostream, 1086–88
спецификации
явные, аргументов шаблона функции, 490
списки
list, заголовочный файл, 256
merge(), обобщенный алгоритм
специализированная реализация для списка, 588
push_front(), поддержка, 257
size(), 221
влияние размера объекта на производительность, 254
как последовательный контейнер, 256–61
неприменимость итераторов с произвольным доступом, 583
неприменимость обобщенных алгоритмов, требующих произвольного доступа, 588
обобщенные, 241–47
поддержка операций merge() и sort(), 269
сравнение с векторами, 251–52
требования к вставке и доступу, 252
списки параметров переменной длины
использование многоточия, 343
сравнения
объекты-функции, 571
операторы, 145–48
поддержка в контейнерах, 258
ссылки
для объявления исключения в catch-обработчике, 543
инициализация
как преобразование точного соответствия, 457–59
ранжирование при разрешении перегрузки функции, 471–72
ссылки на const, 105–8
использование с sizeof(), 161
как тип возвращаемого значения функции, 348
недопустимость массив ссылок, 115
параметры-ссылки, 107, 329–33
необходимость для перегрузки операторов, 335
преимущества эффективности, 330
парамтеры-ссылки
по сравнению с параметрами-указателями, 333–35
сравнение с указателями, 104
статические объекты
объявление локальных объектов как, 390–92
объявление, сравнение с безымянным пространством имен, 419
статические члены класса
указатели на, 636–37
статическое выделение памяти, 33
стек, контейнерный тип, 312–15
stack, заголовочный файл, 312
top(), функция, 154, 313
динамическое выделение памяти, 317
операции (таблица), 313
реализация с помощью контейнера deque, 314
стека, пример класса, 183–87, 183–87
строки
append(), 287–88
assign(), 287
compare(), 289
erase(), 267, 285
insert(), 266
replace(), 290–91
swap(), 268, 288
поиск подстроки, 273–79, 285–86, 290
присваивание, 266
Т
тело
функции, 321
тип
точное соответствие, 445–51
тип(ы)
bool, 108–10
C-строка, 92–95
typedef, синоним типа, 126
арифметические, 30–33
базовые
(глава), 98–139
для определения нескольких объектов одного и того же типа pair, 128
имя класса как, 595
использование с директивой препроцессора include, 68
поверка
назначение и опасности приведения, 182
проверка
неявные преобразования, 326
объявления в нескольких файлах, 384
подавление, многоточие в списке параметров функции, 343
сравнение, функция strcmp(), 133
С-строка
динамическое выделение памяти, 401
точка конкретизации
шаблона функции, 518
точное соответствие, 445–51
У
угловые скобки (<>)
шаблон
использование для определения, 56
спецификации аргументов, 490
явные
специализации шаблона, 498
спецификации аргументов шаблона, 490
указатели, 87–90
sizeof(), использование с, 161
void*, 89
преобразование в тип void* и обратно, 179
адресация
C-строк, 92
объектов, 89
объектов класса, использование оператора ->, 603
элементов массива, 118
вектор указателей, преимущества, 255
висячий
возвращенное значение, указывающее на автоматический объект, 389
указывающий на освобожденную память, 394
использование в обобщенных алгоритмах, 120
как значение, возвращаемое функцией, 370
как итераторы для встроенного массива, 264
константные указатели, 101
на константные объекты, 101
нулевой указатель, 455
как операнд оператора delete, 394
параметры, 329, 334
сравнение с параметрами-ссылками, 333–35
сравнение с массивами, 118–20
сравнение со ссылками, 43, 106
указатели на функции, 365–75
вызов по, 368–69
и спецификации исключений, 548–50
инициализация, 367
как возвращаемые значения, 370–73
как параметры, 370–73
массивы, 369–70
на перегруженные функции, 439–40
на функции, объявленные как extern "C", 373–75
написанные на других языках, 374
недостатки по сравнению со встроенными функциями, 559
присваивание, 367
сравнение с указателями на данные (сноска), 87
указатели на члены, 628–38
указатели на данные-члены, 634
указатели на статические члены, 636–38
указатели на функции-члены, 632
умножения оператор (*)
поддержка в арифметических типах данных, 30
унарные операторы, 141
условный
директивы препроцессора, 21
инструкции
if, 192–98
инструкция
switch, 201–3
оператор (?
)
сравнение с функциями, 352
оператор (?:), 133
сокращение для if-else, 199
условный оператор
инструкция, 188
Ф
файл(ы)
ввод/вывод, 28–29
входной
открытие, 28
выходной
открытие, 29
несколько
размещение определения пространства имен в, 410
сопоставление объявлений в, 383
объявления локальных сущностей
использование безымянного пространства имен, 419
фигурные скобки ({})
использование в объявлениях пространств имен, 408
использование в предложении catch, 535
использование в составной директиве связывания, 354
как ограничители составной инструкции, 188
при инициализации вложенного массива, 117
функции
(глава), 320–75
function, заголовочный файл, 568
try-блок, 536
возвращаемые значения, 346–50
локальный объект, проблема возвращения ссылки на, 348
объект класса, 348–50
объект класса как средство вернуть несколько значений, 350
параметр-ссылка как средство возврата дополнительного значения, 329
сравнение с глобальными объектами, 349–50
указатель на функцию, 372
вызовы, 322
заключенные в try-блок, 536
недостатки, 352
сравнение с обработкой исключений, 542
и глобальные объекты, 381–87
и локальная область видимости, 378
имя функции
перегрузка, 429
преобразуется в указатель, 367
интерфейс
объявление функции как, 323
прототип функции как описание, 323
конверторы, 757–61
конструкторы как, 761–64
локальное хранение, 327
на другом языке, директивы связывания, 353–55
обращение к, 322
объявления
как часть шаблона функции, 477
как члена пространства имен, 407
сравнение с определениями, 382
объявления перегруженных функций, 429–32
и область видимости, 434–38
как перегружаются, 429–32
когда не надо перегружать, 432–34
причины для перегрузки функций, 429
оператор вызова функции (()), 736–38
определение, 321
как часть шаблона функции, 477
сравнение с объявлениями, 382
преимущества, 352
преобразование функции в указатель, 448
прототип, 323–27
рекурсивные, 350–52
сигнатура, 325
списки параметров, 325
тип
недопустимость возврата из функции, 324
преобразование в указатель на функцию, 347
тип возвращаемого значения, 324–25
недопустимость указания для конструкторов, 671
недостаточен для разрешения перегруженных функций, 431
ссылка, 348
указатель на функцию, 370–73
функции-кандидаты, 442, 460–65
вызов с аргументами типа класса, 767–70
для вызовов в области видимости класса, 770–71
для вызовов функций-членов, 778
для перегруженных операторов, 783–87
для шаблонов функций,, 507
наследование и, 1031–34
функции-члены, 129, 596–98, 604–14
встроенные функции
сравнение с не-встроенными, 605–7
вызов, 131
модификация для обработки исключений, 531
независимые от типа, 50
определение, 132
открытые
доступ к закрытым членам с помощью, 40
сравнение с закрытыми, 608–10
перегруженные
и разрешение, 776–82
объявление, 777–78
проблемы, 434
функции-кандидаты, 778
специальные, 610–11
статические, 626–27
устоявшие, перегрузка и, 779–82
Х
хип, 162, 392, 587
выделение памяти для классов в, 749–51
выделение памяти для массива в, 400
выделение памяти для объекта в, 392
исключение bad_alloc, 393
обобщенные алгоритмы, 587, 1191
См. также обобщенные алгоритмы, 1192
Ц
целые
константы, перечисления как средство группировки, 110
расширение булевских константы до целых, 146
расширение типа, 177
стандартные преобразования, 177
при разрешении перегрузки функции, 453
типы данных, 75
цикл(ы), 20
завершение
break, инструкция, 218
continue, инструкция, 219
инструкции
for, 196
while, 213–16
инструкции
do-while, 216–17
for, 209–13
while, 21
ошибки программирования, 198
бесконечные циклы, 274
условие останова, 32
Ч
числа с плавающей точкой
арифметика, характеристики и смежные темы, 145
правила преобразования типов, 177
стандартные преобразования при разрешении перегрузки функции, 453
численные обобщенные алгоритмы, 586
numeric, заголовочный файл, 586
читабельность
typedef, 126
в объявлениях указателей на функции, 369
как синоним контейнерных типпов, 295
имен параметров, 325
имен перегруженных функций, 432
квалификатор const для объявления констант, 100
параметров-ссыслок, 335
разделение обработчиков исключений, 534
рекурсивных функций, 351
члены класса
this
использование в перегруженном операторе присваивания, 710
когда использовать в функциях-членах, 619–21
указатель this, 616–20
битовые поля, 643–45
данные-члены, 594–96
защищенные, 871
изменчивые (mutable), 614–16
статические, 621–25
тип члена, 631–36
доступ, 599–600, 607–8
друзья, 599–600
статические, 621–28
функции-члены, 596–98, 604–16
встроенные и не-встроенные, 605–7
закрытые и открытые, 608–10
конверторы, 757–61
перегруженные, объявления, 776–78
специальные функции-члены, 610–11
спецификации исключений для, 1021–24
статические, 626–28
тип члена, 631–33
члены-классы
открытые и закрытые, 598–99
шаблоны, 826–31
Ш
шаблон класса Array
Array_RC, производный класс, 990–92
шаблоны классов
(глава), 791–857
вложенные типы, 824–26
и пространства имен, 846–48
модели компиляции, 831–38
с включением, 833
с разделением, 834–37
объявления друзей в, 815–21
определения, 791–800
разрешение имен в, 844–46
параметры, 794–97, 805–11
параметры-константы, 805–11
параметры-типы, 800–805
статические члены классов, 821–24
точка конкретизации, для функций-членов, 846
частичные специализации, 842–44
члены
функций, 811–15
явные
объявления конкретизации, 837–38
специализации, 838–42
шаблоны функций
(глава), 592–782
и пространства имен, 521–24
конкретизации, 592–782
модели компиляции, 494–98
с включением, 494–95
с разделением, 495–97
определение, 474–82
параметры, 475–82
для повышения гибкости обобщенных алгоритмом, 566
параметры-константы, 476
параметры-типы, 476
перегрузка, 503–6
передача объектов-функций шаблону, 569
разрешение имен в определениях, 514–20
разрешение перегрузки при конкретизации, 506–14
тип возвращаемого значения и выведение аргументов шаблона, 491
точка конкретизации, 518
явные
аргументы, 490–93
объявления конкретизации, 497–98
спецаиализации, 498–503
Э
эффективность
сравнение с гибкостью при выделении памяти, 33
Я
явное
преобразование, 178–82
преобразование типа, 144, 175
[1]
Во время написания этой книги не все компиляторы С++ поддерживали пространства имен. Если ваш компилятор таков, откажитесь от данной директивы. Большинство программ, приводимых нами, используют компиляторы, не поддерживающие пространство имен, поэтому директива using
в них отсутствует.
[2]
Как было сказано ранее, не все компиляторы поддерживают пространства имен, поэтому эта разница проявляется только для последних версий компиляторов.
[3] Объявление функции inline – это всего лишь подсказка компилятору. Однако компилятор не всегда может сделать функцию встроенной, существуют некоторые ограничения. Подробнее об этом сказано в разделе 7.6.
[4] Вот как выглядит общее решение этой проблемы:
Example2( elemType nval = elemType() ) " _val( nval ) {}
[5]
На самом деле для указателей на функции это не совсем так: они отличаются от указателей на данные (см. раздел 7.9).
[6] STL расшифровывается как Standard Template Library. До появления стандартной библиотеки С++ классы vector, string и другие, а также обобщенные алгоритмы входили в отдельную библиотеку с названием STL.
[7]
Проверку на неравенство 0 можно опустить. Полностью эквивалентна приведенной и более употребима следующая запись: ptr && *ptr.
[8]
До принятия стандарта языка С++ видимость объектов, определенных внутри круглых скобок for, простиралась на весь блок или функцию, содержащую данную инструкцию. Например, употребление двух циклов for внутри одного блока
{
// верно для стандарта С++
// в предыдущих версиях C++ - ошибка:
ival определена дважды
for (int ival = 0; ival < size; ++iva1 ) // ...
for (int ival = size-1; ival > 0; ival ) // ...
}
в ранних версиях языка вызывало ошибку: ival определена дважды. В стандарте С++ данный текст синтаксически правилен, так как каждый экземпляр ival является локальным для своего блока.
[9]
Замечание. Для упрощения программы мы требуем, чтобы каждое слово было отделено пробелом от скобок и логических операторов. Таким образом, запросы вида
(War || Rights)
Civil&&(War||Rights)
не будут поняты нашей системой. Хотя удобство пользователей не должно приноситься в жертву простоте реализации, мы считаем, что в данном случае можно смириться с таким ограничением.
[10]
Иллюстрация Елены Дрискилл (Elena Driskill).
[11]
Отметим, что deque не поддерживает операцию reserve()
[12]
Существующие на сегодняшний день реализации не поддерживают шаблоны с параметрами по умолчанию. Второй параметр – allocator – инкапсулирует способы выделения и освобождения памяти. В С++ он имеет значение по умолчанию, и его задавать не обязательно. Стандартная реализация использует операторы new и delete. Применение распределителя памяти преследует две цели: упростить реализацию контейнеров путем отделения всех деталей, касающихся работы с памятью, и позволить программисту при желании реализовать собственную стратегию выделения памяти. Определения объектов для компилятора, не поддерживающего значения по умолчанию параметров шаблонов, выглядят следующим образом:
vector< string, allocator > svec;
list< int, allocator > ilist;
[13]
Если функция-член push_front()
используется часто, следует применять тип deque, а не vector: в deque
эта операция реализована наиболее эффективно.
[14]
Последняя форма insert()
требует, чтобы компилятор работал с шаблонами функций-членов. Если ваш компилятор еще не поддерживает это свойство стандарта С++, то оба контейнера должны быть одного типа, например два списка или два вектора, содержащих элементы одного типа.
[15]
Программа компилировалась компилятором, не поддерживающим значений параметров по умолчанию шаблонов. Поэтому нам пришлось явно указать аллокатор:
vector<string,allocator> *lines_of_text;
Для компилятора, полностью соответствующего стандарту С++, достаточно отметить тип элементов:
vector<string> *lines_of_text;
[16]
Конечно, в английском языке существуют исключения из правил. Наш эвристический алгоритм превратит crises
(множ. число от crisis – прим. перев.) в cris. Ошибочка!
[17] Таким образом, как мы видим, определения встроенных функций могут встретиться в программе несколько раз! – Прим. ред.
[18]
Полный текст реализации класса CommandOpt можно найти на Web-сайте издательства Addison-Wesley.
1. Если имеющийся у Вас компилятор пока не поддерживает параметр шаблонов по умолчанию, то конструктору istream_iterator необходимо будет явно передать также и второй аргумент: тип difference_type, способный хранить результат вычитания двух итераторов контейнера, куда помещаются элементы. Например, в разделе 12.2 при изучении программы, которая должна транслироваться компилятором, не поддерживающим параметры шаблонов по умолчанию, мы писали:
typedef vector<string,allocator>::difference_type diff_type
istream_iterator< string, diff_type > input_set1( infile1 ), eos;
istream_iterator< string, diff_type > input_set2( infile2 );
Если бы компилятор полностью удовлетворял стандарту C++, достаточно было бы написать так:
istream_iterator< string > input_set1( infile1 ), eos;
istream_iterator< string > input_set2( infile2 );
1 Более подробное обсуждение этой темы с примерами и приблизительными оценками производительности см. в [LIPPMAN96a].
2 В реальной программе мы объявили бы член _name как имеющий тип string. Здесь он объявлен как C-строка, чтобы отложить рассмотрение вопроса об инициализации членов класса до раздела 14.4.
3 Для тех, кто раньше программировал на C: приведенное выше определение класса Account на C выглядело бы так:
typedef struct {
char *_name;
unsigned int _acct_nmbr;
double _balance;
} Account;
4 См. статью Джерри Шварца в [LIPPMAN96b], где приводится дискуссия по этому поводу и описывается решение, остающееся пока наиболее распространенным.
5 Сигнатура ассоциированного конструктора имеет следующий смысл. Копирующий конструктор применяет некоторое значение к каждому элементу по очереди. Задавая в качестве второго аргумента объект класса, мы делаем создание временного объекта излишним:
explicit vector( size_type n, const T& value=T(), const Allocator&=Allocator());
1 Напомним, что для упрощения реализации необходимо, чтобы между любыми двумя словами, включая скобки и операторы запроса, был пробел. В реальной системе такое требование вряд ли разумно, но мы полагаем, что для вводного курсе, каковым является наша книга, это вполне приемлемо.
2 В объявлении унаследованной виртуальной функции, например eval(), в производном классе ключевое слово virtual необязательно. Компилятор делает правильное заключение на основе сравнения с прототипом функции.
3 Увы! Правые скобки не распознаются, пока OrQuery не выведет все ассоциированное с ним частичное решение.
[19]
Полный текст программы можно найти на FTP-сайте издательства Addison-Wesley по адресу, указанному на задней стороне обложки.
1 Здесь есть потенциальная опасность появления висячей ссылки, если пользователь сохранит адрес какого-либо элемента исходного массива перед тем, как grow() скопирует массив в новую область памяти. См. статью Тома Каргилла в [LIPPMAN96b].
1 Кроме того, программист может устанавливать и сбрасывать флаги состояния формата с помощью функций-членов setf() и unsetf(). Мы их рассматривать не будем; исчерпывающие ответы на вопросы, относящиеся к этой теме, можно получить в [STROUSTRUP97].
[O.A.1]Как должны быть оформлены ссылки на книги, указанные в библиографии? Пришлите ваши пожелания.
[O.A.2]Нумерация сносок сбита, как и вся остальная. Необходима проверка.
[O.A.3]Нумерация сносок сбита.
[O.A.4]Нумерация сносок сбита.
[O.A.5]Нумерация сносок сбита.
[O.A.6]Нумерация сносок сбита.
