Стандарты программирования на С++

Ñòàíäàðòû
ïðîãðàììèðîâàíèÿ íà C++
titula_Standart-program-C++.indd3 3 27.02.2008 16:58:10

C++ Coding Standards
101 Rules, Guidelines, and Best Practices
Herb Sutter
Andrei Alexandrescu
ADDISON–WESLEY
Boston

Ñòàíäàðòû
ïðîãðàììèðîâàíèÿ íà C++
101 правило и рекомендация
Ãåðá Ñàòòåð
Àíäðåé Àëåêñàíäðåñêó
Издательский дом “Вильямс”

Москва • СанктПетербург • Киев
2008

ББК 32.973.26-018.2.75
С21
УДК 681.3.07
Издательский дом “Вильямс”

Зав. редакцией С.Н. Тригуб
Перевод с английского и редакция канд. техн. наук И.В. Красикова
По общим вопросам обращайтесь в Издательский дом “Вильямс”

по адресу: info@williamspublishing.com, http://www.williamspublishing.com
Саттер, Герб, Александреску, Андрей.

С21 Стандарты программирования на С++. : Пер. с англ. — М. : ООО “И.Д. Вильямс”,
2008. — 224 с. : ил. — Парал. тит. англ.
ISBN 978-5-8459-0859-9 (рус.)
Эта книга поможет новичку стать профессионалом, так как в ней представлен сконцен-
трированный лучший опыт программистов на C++, обобщенный двумя экспертами мирового
класса.
Начинающий программист найдет в ней простые и понятные рекомендации для ежеднев-
ного использования, подкрепленные примерами их конкретного применения на практике.
Опытные программисты найдут в ней советы и новые рекомендации, которые можно сразу
же принять на вооружение. Программисты-профессионалы могут использовать эту книгу как
основу для разработки собственных стандартов кодирования, как для себя лично, так и для
группы, которой они руководят.
Конечно, книга рассчитана в первую очередь на профессиональных программистов с глубо-
кими знаниями языка, однако она будет полезна любому, кто захочет углубить свои знания в
данной области.
ББК 32.973.26-018.2.75
Все названия программных продуктов являются зарегистрированными торговыми марками соответст-

вующих фирм.
Никакая часть настоящего издания ни в каких целях не может быть воспроизведена в какой бы то ни было
форме и какими бы то ни было средствами, будь то электронные или механические, включая фотокопирова-
ние и запись на магнитный носитель, если на это нет письменного разрешения издательства Addison-Wesley
Publishing Company, Inc.
Authorized translation from the English language edition published by Addison-Wesley Publishing Company Inc.,
Copyright © 2005
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic
or mechanical, including photocopying, recording or by any information storage retrieval system, without permission
from the Publisher.
Russian language edition was published by Williams Publishing House according to the Agreement with R&I En-
terprises International, Copyright © 2008
ISBN 978-5-8459-0859-9 (рус.) © Издательский дом “Вильямс”, 2008

ISBN 0-321-11358-6 (англ.) © Pearson Education, Inc., 2005
Стр. 4
Оглавление
ɉɪɟɞɢɫɥɨɜɢɟ 9
ȼɨɩɪɨɫɵ ɨɪɝɚɧɢɡɚɰɢɢ ɢ ɫɬɪɚɬɟɝɢɢ 13
ɋɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ 23
ɋɬɢɥɶ ɤɨɞɢɪɨɜɚɧɢɹ 39
Ɏɭɧɤɰɢɢ ɢ ɨɩɟɪɚɬɨɪɵ 57
ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɥɚɫɫɨɜ ɢ ɧɚɫɥɟɞɨɜɚɧɢɟ 69
Ʉɨɧɫɬɪɭɤɬɨɪɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɤɨɩɢɪɨɜɚɧɢɟ 99
ɉɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢ ɦɨɞɭɥɢ 117
ɒɚɛɥɨɧɵ ɢ ɨɛɨɛɳɟɧɧɨɫɬɶ 133
Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ 143
STL: ɤɨɧɬɟɣɧɟɪɵ 163
STL: ɚɥɝɨɪɢɬɦɵ 173
Ȼɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ 187
ɋɩɢɫɨɤ ɥɢɬɟɪɚɬɭɪɵ 202
Ɋɟɡɸɦɟ ɢɡ ɪɟɡɸɦɟ 206
ɉɪɟɞɦɟɬɧɵɣ ɭɤɚɡɚɬɟɥɶ 220
Стр. 5
Содержание
ɉɪɟɞɢɫɥɨɜɢɟ 9
ȼɨɩɪɨɫɵ ɨɪɝɚɧɢɡɚɰɢɢ ɢ ɫɬɪɚɬɟɝɢɢ 13

0. ɇɟ ɦɟɥɨɱɢɬɟɫɶ, ɢɥɢ ɑɬɨ ɧɟ ɫɥɟɞɭɟɬ ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɬɶ 14
1. Ʉɨɦɩɢɥɢɪɭɣɬɟ ɛɟɡ ɡɚɦɟɱɚɧɢɣ ɩɪɢ ɦɚɤɫɢɦɚɥɶɧɨɦ ɭɪɨɜɧɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ 16
2. ɂɫɩɨɥɶɡɭɣɬɟ ɚɜɬɨɦɚɬɢɱɟɫɤɢɟ ɫɢɫɬɟɦɵ ɫɛɨɪɤɢ ɩɪɨɝɪɚɦɦ 19
3. ɂɫɩɨɥɶɡɭɣɬɟ ɫɢɫɬɟɦɭ ɤɨɧɬɪɨɥɹ ɜɟɪɫɢɣ 20
4. Ɉɞɧɚ ɝɨɥɨɜɚ ɯɨɪɨɲɨ, ɚ ɞɜɟ — ɥɭɱɲɟ 21
ɋɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ 23
5. Ɉɞɢɧ ɨɛɴɟɤɬ — ɨɞɧɚ ɡɚɞɚɱɚ 24
6. Ƚɥɚɜɧɨɟ — ɤɨɪɪɟɤɬɧɨɫɬɶ, ɩɪɨɫɬɨɬɚ ɢ ɹɫɧɨɫɬɶ 25
7. Ʉɨɞɢɪɨɜɚɧɢɟ ɫ ɭɱɟɬɨɦ ɦɚɫɲɬɚɛɢɪɭɟɦɨɫɬɢ 27
8. ɇɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ 29
9. ɇɟ ɩɟɫɫɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ 31
10. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɝɥɨɛɚɥɶɧɵɟ ɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ 32
11. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ 33
12. Ʉɨɞɢɪɨɜɚɧɢɟ ɩɚɪɚɥɥɟɥɶɧɵɯ ɜɵɱɢɫɥɟɧɢɣ 34
13. Ɋɟɫɭɪɫɵ ɞɨɥɠɧɵ ɛɵɬɶ ɜɨ ɜɥɚɞɟɧɢɢ ɨɛɴɟɤɬɨɜ 37
ɋɬɢɥɶ ɤɨɞɢɪɨɜɚɧɢɹ 39
14. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɲɢɛɤɢ ɤɨɦɩɢɥɹɰɢɢ ɢ ɤɨɦɩɨɧɨɜɤɢ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ 40
15. Ⱥɤɬɢɜɧɨ ɢɫɩɨɥɶɡɭɣɬɟ const 42
16. ɂɡɛɟɝɚɣɬɟ ɦɚɤɪɨɫɨɜ 44
17. ɂɡɛɟɝɚɣɬɟ ɦɚɝɢɱɟɫɤɢɯ ɱɢɫɟɥ 46
18. Ɉɛɴɹɜɥɹɣɬɟ ɩɟɪɟɦɟɧɧɵɟ ɤɚɤ ɦɨɠɧɨ ɥɨɤɚɥɶɧɟɟ 47
19. ȼɫɟɝɞɚ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ 48
20. ɂɡɛɟɝɚɣɬɟ ɞɥɢɧɧɵɯ ɮɭɧɤɰɢɣ ɢ ɝɥɭɛɨɤɨɣ ɜɥɨɠɟɧɧɨɫɬɢ 50
21. ɂɡɛɟɝɚɣɬɟ ɡɚɜɢɫɢɦɨɫɬɟɣ ɢɧɢɰɢɚɥɢɡɚɰɢɣ ɦɟɠɞɭ ɟɞɢɧɢɰɚɦɢ ɤɨɦɩɢɥɹɰɢɢ 52
22. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɡɚɜɢɫɢɦɨɫɬɢ ɨɩɪɟɞɟɥɟɧɢɣ ɢ ɢɡɛɟɝɚɣɬɟ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ 53
23. Ⱦɟɥɚɣɬɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɫɚɦɨɞɨɫɬɚɬɨɱɧɵɦɢ 55
24. ɂɫɩɨɥɶɡɭɣɬɟ ɬɨɥɶɤɨ ɜɧɭɬɪɟɧɧɸɸ, ɧɨ ɧɟ ɜɧɟɲɧɸɸ ɡɚɳɢɬɭ ɞɢɪɟɤɬɢɜɵ #include 56
Ɏɭɧɤɰɢɢ ɢ ɨɩɟɪɚɬɨɪɵ 57
25. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ, (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɦɭ) ɭɤɚɡɚɬɟɥɸ ɢɥɢ ɫɫɵɥɤɟ 58
26. ɋɨɯɪɚɧɹɣɬɟ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ 59
27. Ɉɬɞɚɜɚɣɬɟ ɩɪɟɞɩɨɱɬɟɧɢɟ ɤɚɧɨɧɢɱɟɫɤɢɦ ɮɨɪɦɚɦ ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ
ɨɩɟɪɚɬɨɪɨɜ ɢ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ 60
28. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ++ ɢ --, ɢ ɜɵɡɨɜ ɩɪɟɮɢɤɫɧɵɯ ɨɩɟɪɚɬɨɪɨɜ 62
29. ɂɫɩɨɥɶɡɭɣɬɟ ɩɟɪɟɝɪɭɡɤɭ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ 64
30. ɂɡɛɟɝɚɣɬɟ ɩɟɪɟɝɪɭɡɤɢ &&, || ɢ , (ɡɚɩɹɬɨɣ) 65
31. ɇɟ ɩɢɲɢɬɟ ɤɨɞ, ɤɨɬɨɪɵɣ ɡɚɜɢɫɢɬ ɨɬ ɩɨɪɹɞɤɚ ɜɵɱɢɫɥɟɧɢɣ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ 67
ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɥɚɫɫɨɜ ɢ ɧɚɫɥɟɞɨɜɚɧɢɟ 69
32. əɫɧɨ ɩɪɟɞɫɬɚɜɥɹɣɬɟ, ɤɚɤɨɣ ɜɢɞ ɤɥɚɫɫɚ ɜɵ ɫɨɡɞɚɟɬɟ 70
33. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɦɢɧɢɦɚɥɶɧɵɟ ɤɥɚɫɫɵ ɦɨɧɨɥɢɬɧɵɦ 72
34. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɨɦɩɨɡɢɰɢɸ ɧɚɫɥɟɞɨɜɚɧɢɸ 73
Стр. 6
35. ɂɡɛɟɝɚɣɬɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɫɩɪɨɟɤɬɢɪɨɜɚɧɵ ɞɥɹ ɷɬɨɣ ɰɟɥɢ 75
36. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɚɛɫɬɪɚɤɬɧɵɯ ɢɧɬɟɪɮɟɣɫɨɜ 77
37. Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɡɧɚɱɚɟɬ ɡɚɦɟɧɢɦɨɫɬɶ. ɇɚɫɥɟɞɨɜɚɬɶ ɧɚɞɨ
ɧɟ ɞɥɹ ɩɨɜɬɨɪɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɚ ɱɬɨɛɵ ɛɵɬɶ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɧɧɵɦ 79
38. ɉɪɚɤɬɢɤɭɣɬɟ ɛɟɡɨɩɚɫɧɨɟ ɩɟɪɟɤɪɵɬɢɟ 81
39. ȼɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɫɬɨɢɬ ɞɟɥɚɬɶ ɧɟɨɬɤɪɵɬɵɦɢ, ɚ ɨɬɤɪɵɬɵɟ — ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ 83
40. ɂɡɛɟɝɚɣɬɟ ɜɨɡɦɨɠɧɨɫɬɟɣ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ 85
41. Ⱦɟɥɚɣɬɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɡɚɤɪɵɬɵɦɢ (ɤɪɨɦɟ ɫɥɭɱɚɹ ɚɝɪɟɝɚɬɨɜ ɜ ɫɬɢɥɟ ɫɬɪɭɤɬɭɪ C) 87
42. ɇɟ ɞɨɩɭɫɤɚɣɬɟ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɜɨ ɜɧɭɬɪɟɧɧɢɟ ɞɟɥɚ 89
43. Ɋɚɡɭɦɧɨ ɩɨɥɶɡɭɣɬɟɫɶ ɢɞɢɨɦɨɣ Pimpl 91
44. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɧɟ ɹɜɥɹɸɬɫɹ ɧɢ ɱɥɟɧɚɦɢ, ɧɢ ɞɪɭɡɶɹɦɢ 94
45. new ɢ delete ɜɫɟɝɞɚ ɞɨɥɠɧɵ ɪɚɡɪɚɛɚɬɵɜɚɬɶɫɹ ɜɦɟɫɬɟ 95
46. ɉɪɢ ɧɚɥɢɱɢɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ new ɫɥɟɞɭɟɬ ɩɪɟɞɨɫɬɚɜɥɹɬɶ
ɜɫɟ ɫɬɚɧɞɚɪɬɧɵɟ ɬɢɩɵ ɷɬɨɝɨ ɨɩɟɪɚɬɨɪɚ 97
Ʉɨɧɫɬɪɭɤɬɨɪɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɤɨɩɢɪɨɜɚɧɢɟ 99
47. Ɉɩɪɟɞɟɥɹɣɬɟ ɢ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɜ ɨɞɧɨɦ ɩɨɪɹɞɤɟ 100
48. ȼ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɩɪɢɫɜɚɢɜɚɧɢɸ 101
49. ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɨɜ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɜ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɢ ɞɟɫɬɪɭɤɬɨɪɚɯ 102
50. Ⱦɟɥɚɣɬɟ ɞɟɫɬɪɭɤɬɨɪɵ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ ɨɬɤɪɵɬɵɦɢ ɢ ɜɢɪɬɭɚɥɶɧɵɦɢ
ɥɢɛɨ ɡɚɳɢɳɟɧɧɵɦɢ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ 104
51. Ⱦɟɫɬɪɭɤɬɨɪɵ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɢ ɨɛɦɟɧɚ ɧɟ ɨɲɢɛɚɸɬɫɹ 106
52. Ʉɨɩɢɪɭɣɬɟ ɢ ɥɢɤɜɢɞɢɪɭɣɬɟ ɫɨɝɥɚɫɨɜɚɧɧɨ 108
53. əɜɧɨ ɪɚɡɪɟɲɚɣɬɟ ɢɥɢ ɡɚɩɪɟɳɚɣɬɟ ɤɨɩɢɪɨɜɚɧɢɟ 109
54. ɂɡɛɟɝɚɣɬɟ ɫɪɟɡɤɢ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ
ɤɥɨɧɢɪɨɜɚɧɢɹ ɜɦɟɫɬɨ ɤɨɩɢɪɨɜɚɧɢɹ 110
55. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ɩɪɢɫɜɚɢɜɚɧɢɹ 113
56. Ɉɛɟɫɩɟɱɶɬɟ ɛɟɫɫɛɨɣɧɭɸ ɮɭɧɤɰɢɸ ɨɛɦɟɧɚ 114
ɉɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢ ɦɨɞɭɥɢ 117
57. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɢɯ ɫɜɨɛɨɞɧɵɣ ɢɧɬɟɪɮɟɣɫ ɜ ɨɞɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ 118
58. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɮɭɧɤɰɢɢ ɜ ɪɚɡɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ, ɟɫɥɢ ɬɨɥɶɤɨ
ɨɧɢ ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɜɦɟɫɬɧɨɣ ɪɚɛɨɬɵ 120
59. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ
ɢɥɢ ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ #include 122
60. ɂɡɛɟɝɚɣɬɟ ɜɵɞɟɥɟɧɢɹ ɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ ɜ ɪɚɡɧɵɯ ɦɨɞɭɥɹɯ 125
61. ɇɟ ɨɩɪɟɞɟɥɹɣɬɟ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɨɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ 126
62. ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟɤɚɬɶ ɝɪɚɧɢɰɵ ɦɨɞɭɥɟɣ 128
63. ɂɫɩɨɥɶɡɭɣɬɟ ɞɨɫɬɚɬɨɱɧɨ ɩɟɪɟɧɨɫɢɦɵɟ ɬɢɩɵ ɜ ɢɧɬɟɪɮɟɣɫɚɯ ɦɨɞɭɥɟɣ 130
ɒɚɛɥɨɧɵ ɢ ɨɛɨɛɳɟɧɧɨɫɬɶ 133
64. Ɋɚɡɭɦɧɨ ɫɨɱɟɬɚɣɬɟ ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ 134
65. ȼɵɩɨɥɧɹɣɬɟ ɧɚɫɬɪɨɣɤɭ ɹɜɧɨ ɢ ɩɪɟɞɧɚɦɟɪɟɧɧɨ 136
66. ɇɟ ɫɩɟɰɢɚɥɢɡɢɪɭɣɬɟ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ 140
67. ɉɢɲɢɬɟ ɦɚɤɫɢɦɚɥɶɧɨ ɨɛɨɛɳɟɧɧɵɣ ɤɨɞ 142
Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ 143
68. ɒɢɪɨɤɨ ɩɪɢɦɟɧɹɣɬɟ assert ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ ɜɧɭɬɪɟɧɧɢɯ
ɞɨɩɭɳɟɧɢɣ ɢ ɢɧɜɚɪɢɚɧɬɨɜ 144
69. Ɉɩɪɟɞɟɥɢɬɟ ɪɚɡɭɦɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɟɣ ɫɥɟɞɭɣɬɟ 146
70. Ɉɬɥɢɱɚɣɬɟ ɨɲɢɛɤɢ ɨɬ ɫɢɬɭɚɰɢɣ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ ɨɲɢɛɤɚɦɢ 148
Содержание 7
Стр. 7
71. ɉɪɨɟɤɬɢɪɭɣɬɟ ɢ ɩɢɲɢɬɟ ɛɟɡɨɩɚɫɧɵɣ ɜ ɨɬɧɨɲɟɧɢɢ ɨɲɢɛɨɤ ɤɨɞ 151
72. Ⱦɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ 154
73. Ƚɟɧɟɪɢɪɭɣɬɟ ɢɫɤɥɸɱɟɧɢɹ ɩɨ ɡɧɚɱɟɧɢɸ, ɩɟɪɟɯɜɚɬɵɜɚɣɬɟ — ɩɨ ɫɫɵɥɤɟ 158
74. ɍɜɟɞɨɦɥɹɣɬɟ ɨɛ ɨɲɢɛɤɚɯ, ɨɛɪɚɛɚɬɵɜɚɣɬɟ ɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɢɯ ɬɚɦ, ɝɞɟ ɫɥɟɞɭɟɬ 159
75. ɂɡɛɟɝɚɣɬɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ 160
STL: ɤɨɧɬɟɣɧɟɪɵ 163
76. ɉɨ ɭɦɨɥɱɚɧɢɸ ɢɫɩɨɥɶɡɭɣɬɟ vector. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɛɢɪɚɣɬɟ ɤɨɧɬɟɣɧɟɪ,
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɡɚɞɚɱɟ 164
77. ȼɦɟɫɬɨ ɦɚɫɫɢɜɨɜ ɢɫɩɨɥɶɡɭɣɬɟ vector ɢ string 166
78. ɂɫɩɨɥɶɡɭɣɬɟ vector (ɢ string::c_str) ɞɥɹ ɨɛɦɟɧɚ ɞɚɧɧɵɦɢ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ 167
79. ɏɪɚɧɢɬɟ ɜ ɤɨɧɬɟɣɧɟɪɚɯ ɬɨɥɶɤɨ ɡɧɚɱɟɧɢɹ ɢɥɢ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ 168
80. ɉɪɟɞɩɨɱɢɬɚɣɬɟ push_back ɞɪɭɝɢɦ ɫɩɨɫɨɛɚɦ ɪɚɫɲɢɪɟɧɢɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ 169
81. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɩɟɪɚɰɢɢ ɫ ɞɢɚɩɚɡɨɧɚɦɢ ɨɩɟɪɚɰɢɹɦ ɫ ɨɬɞɟɥɶɧɵɦɢ ɷɥɟɦɟɧɬɚɦɢ 170
82. ɂɫɩɨɥɶɡɭɣɬɟ ɩɨɞɯɨɞɹɳɢɟ ɢɞɢɨɦɵ ɞɥɹ ɪɟɚɥɶɧɨɝɨ ɭɦɟɧɶɲɟɧɢɹ
ɟɦɤɨɫɬɢ ɤɨɧɬɟɣɧɟɪɚ ɢ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ 171
STL: ɚɥɝɨɪɢɬɦɵ 173
83. ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ STL 174
84. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɜɵɡɨɜɵ ɚɥɝɨɪɢɬɦɨɜ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɪɚɡɪɚɛɚɬɵɜɚɟɦɵɦ ɰɢɤɥɚɦ 176
85. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɩɨɢɫɤɚ 179
86. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɫɨɪɬɢɪɨɜɤɢ 180
87. Ⱦɟɥɚɣɬɟ ɩɪɟɞɢɤɚɬɵ ɱɢɫɬɵɦɢ ɮɭɧɤɰɢɹɦɢ 182
88. ȼ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɨɜ ɚɥɝɨɪɢɬɦɨɜ ɢ ɤɨɦɩɚɪɚɬɨɪɨɜ ɥɭɱɲɟ
ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɚ ɧɟ ɮɭɧɤɰɢɢ 184
89. Ʉɨɪɪɟɤɬɧɨ ɩɢɲɢɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ 186
Ȼɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ 187
90. ɂɡɛɟɝɚɣɬɟ ɹɜɧɨɝɨ ɜɵɛɨɪɚ ɬɢɩɨɜ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɨɥɢɦɨɪɮɢɡɦ 188
91. Ɋɚɛɨɬɚɣɬɟ ɫ ɬɢɩɚɦɢ, ɚ ɧɟ ɫ ɩɪɟɞɫɬɚɜɥɟɧɢɹɦɢ 190
92. ɂɡɛɟɝɚɣɬɟ reinterpret_cast 192
93. ɂɡɛɟɝɚɣɬɟ ɩɪɢɦɟɧɟɧɢɹ static_cast ɤ ɭɤɚɡɚɬɟɥɹɦ 193
94. ɂɡɛɟɝɚɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ, ɨɬɦɟɧɹɸɳɢɯ const 194
95. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C 195
96. ɇɟ ɩɪɢɦɟɧɹɣɬɟ memcpy ɢɥɢ memcmp ɤ ɧɟ-POD ɬɢɩɚɦ 197
97. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɞɥɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ 198
98. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɢɡɜɟɫɬɧɵɟ ɚɪɝɭɦɟɧɬɵ (ɬɪɨɟɬɨɱɢɹ) 199
99. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ ɢ ɧɟɛɟɡɨɩɚɫɧɵɟ ɮɭɧɤɰɢɢ 200
100. ɇɟ ɪɚɫɫɦɚɬɪɢɜɚɣɬɟ ɦɚɫɫɢɜɵ ɩɨɥɢɦɨɪɮɧɨ 201
ɋɩɢɫɨɤ ɥɢɬɟɪɚɬɭɪɵ 202
Ɋɟɡɸɦɟ ɢɡ ɪɟɡɸɦɟ 206
ɉɪɟɞɦɟɬɧɵɣ ɭɤɚɡɚɬɟɥɶ 220
8 Содержание
Стр. 8
Ɇɢɥɥɢɨɧɚɦ ɧɵɧɟɲɧɢɯ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɧɚ C++
Предисловие
ɂɞɢɬɟ ɩɪɨɬɨɪɟɧɧɨɣ ɞɨɪɨɝɨɣ — ɞɟɥɚɣɬɟ ɨɞɢɧɚɤɨɜɵɟ ɜɟɳɢ ɨɞɢɧɚ-
ɤɨɜɵɦɢ ɫɩɨɫɨɛɚɦɢ. ɇɚɤɚɩɥɢɜɚɣɬɟ ɢɞɢɨɦɵ. ɋɬɚɧɞɚɪɬɢɡɢɪɭɣɬɟ.
ȿɞɢɧɫɬɜɟɧɧɨɟ ɨɬɥɢɱɢɟ ɦɟɠɞɭ ɜɚɦɢ ɢ ɒɟɤɫɩɢɪɨɦ — ɜ ɤɨɥɢɱɟɫɬ-
ɜɟ ɢɫɩɨɥɶɡɭɟɦɵɯ ɢɞɢɨɦ, ɚ ɧɟ ɜ ɪɚɡɦɟɪɟ ɫɥɨɜɚɪɹ.
— Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis) [ɜɵɞɟɥɟɧɨ ɧɚɦɢ]
Ʌɭɱɲɟɟ ɜ ɫɬɚɧɞɚɪɬɟ ɬɨ, ɱɬɨ ɨɧ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɛɨɝɚɬɵɣ ɜɵɛɨɪ.

— ɉɪɢɩɢɫɵɜɚɟɬɫɹ ɪɚɡɧɵɦ ɥɸɞɹɦ
Ɇɵ ɛɵ ɯɨɬɟɥɢ, ɱɬɨɛɵ ɷɬɚ ɤɧɢɝɚ ɫɬɚɥɚ ɨɫɧɨɜɨɣ ɞɥɹ ɫɬɚɧɞɚɪɬɨɜ ɤɨɞɢɪɨɜɚɧɢɹ, ɢɫɩɨɥɶɡɭɟɦɵɯ
ɜɚɲɟɣ ɤɨɦɚɧɞɨɣ, ɩɨ ɞɜɭɦ ɨɫɧɨɜɧɵɦ ɩɪɢɱɢɧɚɦ.
• ɋɬɚɧɞɚɪɬɵ ɤɨɞɢɪɨɜɚɧɢɹ ɞɨɥɠɧɵ ɨɬɪɚɠɚɬɶ ɥɭɱɲɢɣ ɨɩɵɬ ɩɪɨɛ ɢ ɨɲɢɛɨɤ ɜɫɟɝɨ ɫɨɨɛɳɟ-
ɫɬɜɚ ɩɪɨɝɪɚɦɦɢɫɬɨɜ. ȼ ɧɢɯ ɞɨɥɠɧɵ ɫɨɞɟɪɠɚɬɶɫɹ ɩɪɨɜɟɪɟɧɧɵɟ ɢɞɢɨɦɵ, ɨɫɧɨɜɚɧɧɵɟ ɧɚ
ɨɩɵɬɟ ɢ ɬɜɟɪɞɨɦ ɩɨɧɢɦɚɧɢɢ ɹɡɵɤɚ. ȼ ɱɚɫɬɧɨɫɬɢ, ɫɬɚɧɞɚɪɬ ɤɨɞɢɪɨɜɚɧɢɹ ɞɨɥɠɟɧ ɨɫɧɨɜɵ-
ɜɚɬɶɫɹ ɧɚ ɢɫɱɟɪɩɵɜɚɸɳɟɦ ɚɧɚɥɢɡɟ ɥɢɬɟɪɚɬɭɪɵ ɩɨ ɪɚɡɪɚɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ,
ɢ ɨɛɴɟɞɢɧɹɬɶ ɜɨɟɞɢɧɨ ɩɪɚɜɢɥɚ, ɪɟɤɨɦɟɧɞɚɰɢɢ ɢ ɧɚɢɥɭɱɲɢɟ ɩɪɚɤɬɢɱɟɫɤɢɟ ɪɟɲɟɧɢɹ, ɤɨɬɨɪɵɟ
ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɨɤɚɡɵɜɚɸɬɫɹ ɪɚɡɛɪɨɫɚɧɧɵɦɢ ɩɨ ɦɧɨɝɨɱɢɫɥɟɧɧɵɦ ɢɫɬɨɱɧɢɤɚɦ.
• ɉɪɢɪɨɞɚ ɧɟ ɬɟɪɩɢɬ ɩɭɫɬɨɬɵ. ȿɫɥɢ ɜɵ ɧɟ ɪɚɡɪɚɛɨɬɚɟɬɟ ɧɚɛɨɪ ɩɪɚɜɢɥ, ɬɨ ɷɬɨ ɫɞɟɥɚɟɬ
ɤɬɨ-ɬɨ ɞɪɭɝɨɣ. Ɍɚɤɢɟ “ɫɚɦɨɩɚɥɶɧɵɟ” ɫɬɚɧɞɚɪɬɵ, ɤɚɤ ɩɪɚɜɢɥɨ, ɝɪɟɲɚɬ ɬɟɦ, ɱɬɨ ɜɤɥɸɱɚ-
ɸɬ ɧɟɠɟɥɚɬɟɥɶɧɵɟ ɞɥɹ ɫɬɚɧɞɚɪɬɚ ɬɪɟɛɨɜɚɧɢɹ; ɧɚɩɪɢɦɟɪ, ɦɧɨɝɢɟ ɢɡ ɧɢɯ, ɩɨ ɫɭɬɢ, ɡɚ-
ɫɬɚɜɥɹɸɬ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɢɫɩɨɥɶɡɨɜɚɬɶ C++ ɩɪɨɫɬɨ ɤɚɤ ɭɥɭɱɲɟɧɧɵɣ C.
Ɇɧɨɠɟɫɬɜɨ ɬɚɤɢɯ ɩɥɨɯɢɯ ɫɬɚɧɞɚɪɬɨɜ ɤɨɞɢɪɨɜɚɧɢɹ ɪɚɡɪɚɛɨɬɚɧɵ ɥɸɞɶɦɢ, ɤɨɬɨɪɵɟ ɧɟɞɨɫ-
ɬɚɬɨɱɧɨ ɯɨɪɨɲɨ ɩɨɧɢɦɚɸɬ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ C++ ɢɥɢ ɩɵɬɚɸɬɫɹ ɱɪɟɡɦɟɪɧɨ ɞɟɬɚɥɢɡɢ-
ɪɨɜɚɬɶ ɟɝɨ ɩɪɢɦɟɧɟɧɢɟ. ɉɥɨɯɨɣ ɫɬɚɧɞɚɪɬ ɤɨɞɢɪɨɜɚɧɢɹ ɛɵɫɬɪɨ ɬɟɪɹɟɬ ɤɪɟɞɢɬ ɞɨɜɟɪɢɹ, ɢ ɜ ɪɟ-
ɡɭɥɶɬɚɬɟ ɧɟɫɨɝɥɚɫɢɟ ɢɥɢ ɧɟɩɪɢɹɬɢɟ ɩɪɨɝɪɚɦɦɢɫɬɚɦɢ ɱɚɫɬɢ ɟɝɨ ɩɨɥɨɠɟɧɢɣ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ
ɧɚ ɜɟɫɶ ɫɬɚɧɞɚɪɬ ɰɟɥɢɤɨɦ, ɩɟɪɟɱɟɪɤɢɜɚɹ ɫɨɞɟɪɠɚɳɢɟɫɹ ɜ ɧɟɦ ɪɚɡɥɢɱɧɵɟ ɩɨɥɨɠɢɬɟɥɶɧɵɟ ɫɨ-
ɜɟɬɵ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ. ɂ ɷɬɨ — ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ, ɩɨɬɨɦɭ ɱɬɨ ɜ ɯɭɞɲɟɦ ɫɥɭɱɚɟ ɬɚɤɨɣ ɫɬɚɧɞɚɪɬ
ɢ ɟɝɨ ɜɵɩɨɥɧɟɧɢɟ ɦɨɝɭɬ ɛɵɬɶ ɧɚɜɹɡɚɧɵ ɪɭɤɨɜɨɞɫɬɜɨɦ.
Как пользоваться этой книгой

Ⱦɭɦɚɬɶ. ɇɚɞɨ ɞɨɛɪɨɫɨɜɟɫɬɧɨ ɫɥɟɞɨɜɚɬɶ ɭɦɧɵɦ ɫɨɜɟɬɚɦ, ɧɨ ɞɟɥɚɬɶ ɷɬɨ ɧɟ ɜɫɥɟɩɭɸ. ȼɨ
ɦɧɨɝɢɯ ɪɚɡɞɟɥɚɯ ɷɬɨɣ ɤɧɢɝɢ ɟɫɬɶ ɩɨɞɪɚɡɞɟɥ “ɂɫɤɥɸɱɟɧɢɹ”, ɜ ɤɨɬɨɪɨɦ ɩɪɢɜɨɞɹɬɫɹ ɧɟɫɬɚɧ-
ɞɚɪɬɧɵɟ, ɪɟɞɤɨ ɜɫɬɪɟɱɚɸɳɢɟɫɹ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɫɨɜɟɬ ɢɡ ɨɫɧɨɜɧɨɝɨ ɪɚɡɞɟɥɚ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ
ɧɟɩɪɢɦɟɧɢɦ. ɇɢɤɚɤɨɟ ɤɨɥɢɱɟɫɬɜɨ ɞɚɠɟ ɫɚɦɵɯ ɯɨɪɨɲɢɯ (ɦɵ ɧɚ ɷɬɨ ɧɚɞɟɟɦɫɹ) ɫɨɜɟɬɨɜ ɧɟ ɦɨ-
ɝɭɬ ɡɚɦɟɧɢɬɶ ɝɨɥɨɜɭ.
Ʉɚɠɞɚɹ ɤɨɦɚɧɞɚ ɪɚɡɪɚɛɨɬɱɢɤɨɜ ɨɬɜɟɱɚɟɬ ɡɚ ɩɪɢɧɹɬɢɟ ɫɨɛɫɬɜɟɧɧɵɯ ɫɬɚɧɞɚɪɬɨɜ ɢ ɧɟɫɟɬ ɨɬ-
ɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɧɢɯ ɢ ɡɚ ɧɟɭɤɨɫɧɢɬɟɥɶɧɨɟ ɫɥɟɞɨɜɚɧɢɟ ɢɦ. ȼɚɲɚ ɤɨɦɚɧɞɚ — ɧɟ ɢɫɤɥɸɱɟɧɢɟ.
ȿɫɥɢ ɜɵ — ɪɭɤɨɜɨɞɢɬɟɥɶ, ɩɪɟɞɥɨɠɢɬɟ ɱɥɟɧɚɦ ɫɜɨɟɣ ɝɪɭɩɩɵ ɩɨɭɱɚɫɬɜɨɜɚɬɶ ɜ ɪɚɡɪɚɛɨɬɤɟ ɫɬɚɧ-
ɞɚɪɬɨɜ, ɤɨɬɨɪɵɦ ɝɪɭɩɩɚ ɛɭɞɟɬ ɫɥɟɞɨɜɚɬɶ ɜ ɫɜɨɟɣ ɪɚɛɨɬɟ. Ʌɸɞɢ ɜɫɟɝɞɚ ɨɯɨɬɧɟɟ ɫɥɟɞɭɸɬ ɩɪɚ-
ɜɢɥɚɦ, ɤɨɬɨɪɵɟ ɨɧɢ ɫɚɦɢ ɞɥɹ ɫɟɛɹ ɜɵɪɚɛɚɬɵɜɚɸɬ, ɱɟɦ ɬɟɦ, ɤɨɬɨɪɵɟ ɢɦ ɧɚɜɹɡɚɧɵ.
Стр. 9
ɗɬɚ ɤɧɢɝɚ ɩɪɟɞɧɚɡɧɚɱɟɧɚ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɫɥɭɠɢɬɶ ɨɫɧɨɜɨɣ ɞɥɹ ɜɚɲɟɝɨ ɫɬɚɧɞɚɪɬɚ ɤɨɞɢ-
ɪɨɜɚɧɢɹ ɢ ɛɵɬɶ ɜ ɬɨɣ ɢɥɢ ɢɧɨɣ ɦɟɪɟ ɜɤɥɸɱɟɧɧɨɣ ɜ ɧɟɝɨ. ɗɬɨ — ɧɟ ultima ratio ɜ ɫɬɚɧɞɚɪɬɚɯ
ɤɨɞɢɪɨɜɚɧɢɹ, ɢ ɜɚɲɚ ɝɪɭɩɩɚ ɦɨɠɟɬ ɪɚɡɪɚɛɨɬɚɬɶ (ɢɥɢ ɩɪɢɛɚɜɢɬɶ) ɫɜɨɢ ɩɪɚɜɢɥɚ, ɜ ɧɚɢɛɨɥɶɲɟɣ
ɫɬɟɩɟɧɢ ɩɨɞɯɨɞɹɳɢɟ ɞɥɹ ɜɚɲɟɣ ɤɨɧɤɪɟɬɧɨɣ ɝɪɭɩɩɵ ɢɥɢ ɞɥɹ ɤɨɧɤɪɟɬɧɨɣ ɪɟɲɚɟɦɨɣ ɡɚɞɚɱɢ, ɬɚɤ
ɱɬɨ ɜɵ ɧɟ ɞɨɥɠɧɵ ɛɵɬɶ ɫɤɨɜɚɧɵ ɷɬɨɣ ɤɧɢɝɨɣ ɩɨ ɪɭɤɚɦ ɢ ɧɨɝɚɦ. Ɍɟɦ ɧɟ ɦɟɧɟɟ, ɦɵ ɧɚɞɟɟɦɫɹ,
ɱɬɨ ɷɬɚ ɤɧɢɝɚ ɩɨɦɨɠɟɬ ɜɚɦ ɫɛɟɪɟɱɶ ɜɪɟɦɹ ɢ ɭɫɢɥɢɹ ɩɪɢ ɪɚɡɪɚɛɨɬɤɟ ɫɨɛɫɬɜɟɧɧɨɝɨ ɫɬɚɧɞɚɪɬɚ
ɤɨɞɢɪɨɜɚɧɢɹ, ɚ ɬɚɤɠɟ ɛɭɞɟɬ ɫɩɨɫɨɛɫɬɜɨɜɚɬɶ ɩɨɜɵɲɟɧɢɸ ɟɝɨ ɤɚɱɟɫɬɜɚ ɢ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ.
Ɉɡɧɚɤɨɦɶɬɟ ɱɥɟɧɨɜ ɫɜɨɟɣ ɤɨɦɚɧɞɵ ɫ ɷɬɨɣ ɤɧɢɝɨɣ, ɢ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɨɧɢ ɩɨɥɧɨɫɬɶɸ ɩɪɨ-
ɱɬɭɬ ɟɟ ɢ ɩɨɡɧɚɤɨɦɹɬɫɹ ɫɨ ɜɫɟɦɢ ɪɟɤɨɦɟɧɞɚɰɢɹɦɢ ɢ ɢɯ ɨɛɨɫɧɨɜɚɧɢɹɦɢ, ɪɟɲɢɬɟ, ɤɚɤɢɟ ɢɡ ɧɢɯ
ɩɨɞɯɨɞɹɬ ɜɚɦ, ɚ ɤɚɤɢɟ ɜ ɫɢɥɭ ɨɫɨɛɟɧɧɨɫɬɟɣ ɜɚɲɟɝɨ ɩɪɨɟɤɬɚ ɞɥɹ ɜɚɫ ɧɟɩɪɢɦɟɧɢɦɵ. ɉɨɫɥɟ ɷɬɨ-
ɝɨ ɫɬɪɨɝɨ ɩɪɢɞɟɪɠɢɜɚɣɬɟɫɶ ɜɵɛɪɚɧɧɨɣ ɫɬɪɚɬɟɝɢɢ. ɉɨɫɥɟ ɬɨɝɨ ɤɚɤ ɤɨɦɚɧɞɧɵɣ ɫɬɚɧɞɚɪɬ ɩɪɢ-
ɧɹɬ, ɨɧ ɧɟ ɞɨɥɠɟɧ ɧɚɪɭɲɚɬɶɫɹ ɢɧɚɱɟ ɤɚɤ ɩɨ ɫɨɝɥɚɫɨɜɚɧɧɨɦɭ ɪɟɲɟɧɢɸ ɜɫɟɣ ɤɨɦɚɧɞɵ ɜ ɰɟɥɨɦ.
ɂ ɧɚɤɨɧɟɰ, ɩɟɪɢɨɞɢɱɟɫɤɢ ɬɜɨɪɱɟɫɤɢ ɩɟɪɟɫɦɚɬɪɢɜɚɣɬɟ ɫɨɛɫɬɜɟɧɧɵɟ ɫɬɚɧɞɚɪɬɵ ɫ ɭɱɟɬɨɦ
ɩɪɚɤɬɢɱɟɫɤɨɝɨ ɨɩɵɬɚ, ɩɪɢɨɛɪɟɬɟɧɧɨɝɨ ɜɫɟɣ ɤɨɦɚɧɞɨɣ ɩɪɢ ɪɚɛɨɬɟ ɧɚɞ ɩɪɨɟɤɬɨɦ.
Стандарты кодирования и вы
ɏɨɪɨɲɢɟ ɫɬɚɧɞɚɪɬɵ ɤɨɞɢɪɨɜɚɧɢɹ ɦɨɝɭɬ ɩɪɢɧɟɫɬɢ ɧɟɦɚɥɭɸ ɜɵɝɨɞɭ ɫ ɪɚɡɥɢɱɧɵɯ ɬɨɱɟɤ ɡɪɟɧɢɹ.
• ɉɨɜɵɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɤɨɞɚ. Ɋɚɛɨɬɚ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫɨ ɫɬɚɧɞɚɪɬɨɦ ɩɪɢɜɨɞɢɬ ɤ ɨɞɧɨɬɢɩ-
ɧɨɦɭ ɪɟɲɟɧɢɸ ɨɞɢɧɚɤɨɜɵɯ ɡɚɞɚɱ, ɱɬɨ ɩɨɜɵɲɚɟɬ ɹɫɧɨɫɬɶ ɤɨɞɚ ɢ ɭɩɪɨɳɚɟɬ ɟɝɨ ɫɨɩɪɨ-
ɜɨɠɞɟɧɢɟ.
• ɉɨɜɵɲɟɧɢɟ ɫɤɨɪɨɫɬɢ ɪɚɡɪɚɛɨɬɤɢ. Ɋɚɡɪɚɛɨɬɱɢɤɭ ɧɟ ɩɪɢɯɨɞɢɬɫɹ ɪɟɲɚɬɶ ɜɫɟ ɡɚɞɚɱɢ ɢ ɩɪɢɧɢ-
ɦɚɬɶ ɪɟɲɟɧɢɹ “ɫ ɧɭɥɹ”.
• ɉɨɜɵɲɟɧɢɟ ɭɪɨɜɧɹ ɜɡɚɢɦɨɞɟɣɫɬɜɢɹ ɜ ɤɨɦɚɧɞɟ. ɇɚɥɢɱɢɟ ɫɬɚɧɞɚɪɬɚ ɩɨɡɜɨɥɹɟɬ ɭɦɟɧɶ-
ɲɢɬɶ ɪɚɡɧɨɝɥɚɫɢɹ ɜ ɤɨɦɚɧɞɟ ɢ ɭɫɬɪɚɧɢɬɶ ɧɟɧɭɠɧɵɟ ɞɟɛɚɬɵ ɩɨ ɦɟɥɤɢɦ ɜɨɩɪɨɫɚɦ, ɨɛ-
ɥɟɝɱɚɟɬ ɩɨɧɢɦɚɧɢɟ ɢ ɩɨɞɞɟɪɠɤɭ ɱɭɠɨɝɨ ɤɨɞɚ ɱɥɟɧɚɦɢ ɤɨɦɚɧɞɵ.
• ɋɨɝɥɚɫɨɜɚɧɧɨɫɬɶ ɜ ɪɚɛɨɬɟ. ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɫɬɚɧɞɚɪɬɚ ɪɚɡɪɚɛɨɬɱɢɤɢ ɧɚɩɪɚɜɥɹɸɬ
ɫɜɨɢ ɭɫɢɥɢɹ ɜ ɜɟɪɧɨɦ ɧɚɩɪɚɜɥɟɧɢɢ, ɧɚ ɪɟɲɟɧɢɟ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɜɚɠɧɵɯ ɡɚɞɚɱ.
ȼ ɧɚɩɪɹɠɟɧɧɨɣ ɨɛɫɬɚɧɨɜɤɟ, ɩɪɢ ɠɟɫɬɤɢɯ ɜɪɟɦɟɧɧɵɯ ɪɚɦɤɚɯ ɥɸɞɢ ɨɛɵɱɧɨ ɞɟɥɚɸɬ ɬɨ, ɱɟɦɭ
ɢɯ ɭɱɢɥɢ, ɤ ɱɟɦɭ ɨɧɢ ɩɪɢɜɵɤɥɢ. ȼɨɬ ɩɨɱɟɦɭ ɜ ɛɨɥɶɧɢɰɚɯ ɜ ɩɭɧɤɬɚɯ ɩɟɪɜɨɣ ɩɨɦɨɳɢ ɩɪɟɞɩɨ-
ɱɢɬɚɸɬ ɨɩɵɬɧɵɯ, ɬɪɟɧɢɪɨɜɚɧɧɵɯ ɫɨɬɪɭɞɧɢɤɨɜ — ɞɚɠɟ ɯɨɪɨɲɨ ɨɛɭɱɟɧɧɵɟ ɢ ɡɧɚɸɳɢɟ ɧɨɜɢɱ-
ɤɢ ɫɤɥɨɧɧɵ ɤ ɩɚɧɢɤɟ.
ɍ ɪɚɡɪɚɛɨɬɱɢɤɨɜ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ ɪɟɝɭɥɹɪɧɨ ɜɨɡɧɢɤɚɸɬ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɱɬɨ-ɬɨ
ɧɚɞɨ ɛɵɥɨ ɫɞɟɥɚɬɶ ɟɳɟ ɜɱɟɪɚ — ɧɚ ɩɨɡɚɜɱɟɪɚ. Ʉɨɝɞɚ ɧɚ ɧɚɫ ɞɚɜɢɬ ɝɪɚɮɢɤ ɪɚɛɨɬ (ɤɨɬɨɪɵɣ
ɤ ɬɨɦɭ ɠɟ ɢɦɟɟɬ ɬɟɧɞɟɧɰɢɸ ɫɞɜɢɝɚɬɶɫɹ ɜ ɨɞɧɨɦ ɧɚɩɪɚɜɥɟɧɢɢ, ɢ ɬɨ, ɱɬɨ ɩɨ ɩɥɚɧɭ ɞɨɥɠɧɨ ɛɵɥɨ
ɡɚɪɚɛɨɬɚɬɶ ɡɚɜɬɪɚ, ɨɬ ɧɚɫ ɧɚɱɢɧɚɸɬ ɬɪɟɛɨɜɚɬɶ ɟɳɟ ɜɱɟɪɚ…), ɦɵ ɪɚɛɨɬɚɟɦ ɬɚɤ, ɤɚɤ ɩɪɢɭɱɟɧɵ.
ɇɟɪɹɲɥɢɜɵɟ ɩɪɨɝɪɚɦɦɢɫɬɵ, ɤɨɬɨɪɵɟ ɞɚɠɟ ɩɪɢ ɨɛɵɱɧɨɣ ɧɟɫɩɟɲɧɨɣ ɪɚɛɨɬɟ ɧɟ ɩɨɦɧɹɬ ɨ ɩɪɚ-
ɜɢɥɶɧɵɯ ɩɪɢɧɰɢɩɚɯ ɪɚɡɪɚɛɨɬɤɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ (ɚ ɬɨ ɢ ɜɨɜɫɟ ɧɟ ɡɧɚɤɨɦɵ ɫ ɧɢɦɢ),
ɩɪɢ ɧɟɯɜɚɬɤɟ ɜɪɟɦɟɧɢ ɨɤɚɠɭɬɫɹ ɟɳɟ ɧɟɛɪɟɠɧɟɟ, ɚ ɢɯ ɤɨɞ ɛɭɞɟɬ ɢɡɨɛɢɥɨɜɚɬɶ ɨɲɢɛɤɚɦɢ. ɋɨɨɬ-
ɜɟɬɫɬɜɟɧɧɨ, ɩɪɨɝɪɚɦɦɢɫɬ, ɤɨɬɨɪɵɣ ɜɵɪɚɛɨɬɚɥ ɜ ɫɟɛɟ ɯɨɪɨɲɢɟ ɩɪɢɜɵɱɤɢ ɢ ɪɟɝɭɥɹɪɧɨ ɢɦɢ
ɩɨɥɶɡɭɟɬɫɹ, ɩɪɢ “ɩɨɜɵɲɟɧɧɨɦ ɞɚɜɥɟɧɢɢ” ɛɭɞɟɬ ɩɪɨɞɨɥɠɚɬɶ ɜɵɞɚɜɚɬɶ ɤɚɱɟɫɬɜɟɧɧɵɣ ɤɨɞ.
ɋɬɚɧɞɚɪɬɵ ɤɨɞɢɪɨɜɚɧɢɹ, ɩɪɢɜɟɞɟɧɧɵɟ ɜ ɷɬɨɣ ɤɧɢɝɟ, ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɧɚɛɨɪ ɪɟɤɨɦɟɧ-
ɞɚɰɢɣ ɩɨ ɧɚɩɢɫɚɧɢɸ ɜɵɫɨɤɨɤɚɱɟɫɬɜɟɧɧɨɝɨ ɤɨɞɚ ɧɚ C++. ȼ ɧɢɯ ɫɤɨɧɰɟɧɬɪɢɪɨɜɚɧ ɛɨɝɚɬɵɣ
ɤɨɥɥɟɤɬɢɜɧɵɣ ɨɩɵɬ ɜɫɟɝɨ ɫɨɨɛɳɟɫɬɜɚ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɧɚ C++. Ɇɧɨɝɢɟ ɢɡ ɷɬɢɯ ɡɧɚɧɢɣ ɪɚɡɛɪɨ-
ɫɚɧɵ ɩɨ ɱɚɫɬɹɦ ɩɨ ɫɚɦɵɦ ɪɚɡɧɵɦ ɤɧɢɝɚɦ, ɧɨ ɧɟ ɦɟɧɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ ɡɧɚɧɢɣ ɩɟɪɟɞɚɟɬɫɹ ɢɡɭ-
ɫɬɧɨ. Ɇɵ ɩɨɫɬɚɪɚɥɢɫɶ ɫɨɛɪɚɬɶ ɪɚɡɪɨɡɧɟɧɧɵɟ ɫɜɟɞɟɧɢɹ ɜ ɨɞɧɨɣ ɤɧɢɝɟ ɜ ɜɢɞɟ ɤɨɥɥɟɤɰɢɢ ɹɫɧɵɯ,
ɤɨɦɩɚɤɬɧɵɯ ɩɪɚɜɢɥ ɫ ɩɨɹɫɧɟɧɢɹɦɢ, ɩɪɨɫɬɵɯ ɞɥɹ ɩɨɧɢɦɚɧɢɹ ɢ ɫɥɟɞɨɜɚɧɢɹ ɢɦ.
Ʉɨɧɟɱɧɨ, ɞɚɠɟ ɫɚɦɵɟ ɥɭɱɲɢɟ ɫɬɚɧɞɚɪɬɵ ɧɟ ɦɨɝɭɬ ɩɨɦɟɲɚɬɶ ɧɚɩɢɫɚɧɢɸ ɩɥɨɯɨɝɨ ɤɨɞɚ. Ɍɨ
ɠɟ ɦɨɠɧɨ ɫɤɚɡɚɬɶ ɨ ɥɸɛɨɦ ɹɡɵɤɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɩɪɨɰɟɫɫɟ ɢɥɢ ɦɟɬɨɞɨɥɨɝɢɢ. ɏɨɪɨɲɢɣ
ɧɚɛɨɪ ɫɬɚɧɞɚɪɬɨɜ ɜɨɫɩɢɬɵɜɚɟɬ ɯɨɪɨɲɢɟ ɩɪɢɜɵɱɤɢ ɢ ɞɢɫɰɢɩɥɢɧɭ, ɩɪɟɜɵɲɚɸɳɭɸ ɨɛɵɱɧɵɟ
10 Предисловие
Стр. 10
ɧɨɪɦɵ. ɗɬɨ ɫɥɭɠɢɬ ɯɨɪɨɲɢɦ ɮɭɧɞɚɦɟɧɬɨɦ ɞɥɹ ɞɚɥɶɧɟɣɲɟɝɨ ɭɫɨɜɟɪɲɟɧɫɬɜɨɜɚɧɢɹ ɢ ɩɨɜɵɲɟ-
ɧɢɹ ɤɜɚɥɢɮɢɤɚɰɢɢ. ɗɬɨ ɧɟ ɩɪɟɭɜɟɥɢɱɟɧɢɟ ɢ ɧɟ ɤɪɚɫɢɜɵɟ ɫɥɨɜɚ — ɩɟɪɟɞ ɬɟɦ, ɤɚɤ ɧɚɱɚɬɶ ɩɢ-
ɫɚɬɶ ɫɬɢɯɢ, ɧɚɞɨ ɜɥɚɞɟɬɶ ɫɥɨɜɚɪɧɵɦ ɡɚɩɚɫɨɦ ɢ ɡɧɚɬɶ ɝɪɚɦɦɚɬɢɤɭ. Ɇɵ ɧɚɞɟɟɦɫɹ, ɱɬɨ ɧɚɲɚ
ɤɧɢɝɚ ɭɩɪɨɫɬɢɬ ɞɥɹ ɜɚɫ ɩɭɬɶ ɤ ɩɨɷɡɢɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
ɗɬɚ ɤɧɢɝɚ ɩɪɟɞɧɚɡɧɚɱɟɧɚ ɞɥɹ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɜɫɟɯ ɭɪɨɜɧɟɣ.
ȿɫɥɢ ɜɵ ɧɚɱɢɧɚɸɳɢɣ ɩɪɨɝɪɚɦɦɢɫɬ — ɦɵ ɧɚɞɟɟɦɫɹ, ɱɬɨ ɪɟɤɨɦɟɧɞɚɰɢɢ ɢ ɢɯ ɩɨɹɫɧɟɧɢɹ
ɞɨɫɬɚɬɨɱɧɨ ɩɨɭɱɢɬɟɥɶɧɵ ɢ ɩɨɦɨɝɭɬ ɜɚɦ ɜ ɩɨɧɢɦɚɧɢɢ ɬɨɝɨ, ɤɚɤɢɟ ɫɬɢɥɢ ɢ ɢɞɢɨɦɵ C++ ɩɨɞ-
ɞɟɪɠɢɜɚɟɬ ɧɚɢɛɨɥɟɟ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ. ȼ ɨɩɢɫɚɧɢɢ ɤɚɠɞɨɝɨ ɩɪɚɜɢɥɚ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ
ɩɪɢɜɨɞɢɬɫɹ ɤɪɚɬɤɨɟ ɨɛɨɫɧɨɜɚɧɢɟ ɢ ɨɛɫɭɠɞɟɧɢɟ, ɱɬɨɛɵ ɜɵ ɧɟ ɩɪɨɫɬɨ ɦɟɯɚɧɢɱɟɫɤɢ ɡɚɩɨɦɧɢɥɢ
ɩɪɚɜɢɥɨ, ɚ ɩɨɧɹɥɢ ɟɝɨ ɫɭɬɶ.
Ⱦɥɹ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɫɪɟɞɧɟɝɨ ɢ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɩɪɢ ɨɩɢɫɚɧɢɢ ɤɚɠɞɨɝɨ ɩɪɚɜɢɥɚ ɩɪɢɜɨ-
ɞɢɬɫɹ ɫɩɢɫɨɤ ɫɫɵɥɨɤ, ɤɨɬɨɪɵɣ ɩɨɡɜɨɥɢɬ ɜɚɦ ɭɝɥɭɛɥɟɧɧɨ ɢɡɭɱɢɬɶ ɡɚɢɧɬɟɪɟɫɨɜɚɜɲɢɣ ɜɚɫ ɜɨ-
ɩɪɨɫ, ɩɪɨɜɟɞɹ ɩɨɢɫɤ ɤɨɪɧɟɣ ɩɪɚɜɢɥɚ ɜ ɫɢɫɬɟɦɟ ɬɢɩɨɜ, ɝɪɚɦɦɚɬɢɤɟ ɢ ɨɛɴɟɤɬɧɨɣ ɦɨɞɟɥɢ C++.
Ʉɚɤɢɦ ɛɵ ɧɢ ɛɵɥ ɜɚɲ ɭɪɨɜɟɧɶ ɤɚɤ ɩɪɨɝɪɚɦɦɢɫɬɚ — ɜɟɪɨɹɬɧɨ, ɜɵ ɪɚɛɨɬɚɟɬɟ ɧɚɞ ɫɥɨɠɧɵɦ
ɩɪɨɟɤɬɨɦ ɧɟ ɜ ɨɞɢɧɨɱɤɭ, ɚ ɜ ɤɨɦɚɧɞɟ. ɂɦɟɧɧɨ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɪɚɡɪɚɛɨɬɤɚ ɫɬɚɧɞɚɪɬɨɜ ɤɨɞɢɪɨɜɚɧɢɹ
ɨɤɭɩɚɟɬɫɹ ɫɩɨɥɧɚ. ȼɵ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɯ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɞɬɹɧɭɬɶ ɜɫɸ ɫɜɨɸ ɤɨɦɚɧɞɭ
ɤ ɨɞɧɨɦɭ, ɛɨɥɟɟ ɜɵɫɨɤɨɦɭ ɭɪɨɜɧɸ, ɢ ɨɛɟɫɩɟɱɢɬɶ ɩɨɜɵɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɪɚɡɪɚɛɚɬɵɜɚɟɦɨɝɨ ɤɨɞɚ.
Об этой книге
Ɉɫɧɨɜɧɵɦɢ ɩɪɢɧɰɢɩɚɦɢ ɞɢɡɚɣɧɚ ɞɚɧɧɨɣ ɤɧɢɝɢ ɹɜɥɹɸɬɫɹ ɫɥɟɞɭɸɳɢɟ.
• Ʉɪɚɬɤɨɫɬɶ — ɫɟɫɬɪɚ ɬɚɥɚɧɬɚ. ɑɟɦ ɛɨɥɶɲɟ ɫɬɚɧɞɚɪɬ ɤɨɞɢɪɨɜɚɧɢɹ ɩɨ ɪɚɡɦɟɪɭ, ɬɟɦ
ɛɨɥɶɲɟ ɲɚɧɫɨɜ, ɱɬɨ ɨɧ ɛɭɞɟɬ ɛɥɚɝɨɩɨɥɭɱɧɨ ɩɪɨɢɝɧɨɪɢɪɨɜɚɧ. ɑɢɬɚɸɬ ɢ ɢɫɩɨɥɶɡɭɸɬ
ɨɛɵɱɧɨ ɤɨɪɨɬɤɢɟ ɫɬɚɧɞɚɪɬɵ. Ⱦɥɢɧɧɵɟ ɪɚɡɞɟɥɵ, ɤɚɤ ɩɪɚɜɢɥɨ, ɩɪɨɫɬɨ ɩɪɨɫɦɚɬɪɢɜɚɸɬ
“ɩɨ ɞɢɚɝɨɧɚɥɢ”, ɤɨɪɨɬɤɢɟ ɫɬɚɬɶɢ ɨɛɵɱɧɨ ɭɞɨɫɬɚɢɜɚɸɬɫɹ ɜɧɢɦɚɬɟɥɶɧɨɝɨ ɩɪɨɱɬɟɧɢɹ.
• ɇɢɤɚɤɨɣ ɦɚɬɟɪɢɚɥ ɧɟ ɞɨɥɠɟɧ ɜɵɡɵɜɚɬɶ ɞɢɫɤɭɫɫɢɣ. ɗɬɚ ɤɧɢɝɚ ɞɨɤɭɦɟɧɬɢɪɭɟɬ ɲɢɪɨɤɨ
ɢɫɩɨɥɶɡɭɟɦɵɟ ɫɬɚɧɞɚɪɬɵ, ɚ ɧɟ ɢɡɨɛɪɟɬɚɟɬ ɢɯ. ȿɫɥɢ ɧɟɤɨɬɨɪɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɧɟ ɩɪɢɦɟ-
ɧɢɦɚ ɜɨ ɜɫɟɯ ɫɢɬɭɚɰɢɹɯ, ɬɨ ɦɵ ɬɚɤ ɢ ɩɢɲɟɦ — “ɩɨɞɭɦɚɣɬɟ ɨ ɩɪɢɦɟɧɟɧɢɢ X” ɜɦɟɫɬɨ
“ɞɟɥɚɣɬɟ X”. Ʉɪɨɦɟ ɬɨɝɨ, ɤ ɤɚɠɞɨɦɭ ɩɪɚɜɢɥɭ ɭɤɚɡɚɧɵ ɜɫɟ ɨɛɳɟɩɪɢɧɹɬɵɟ ɢɫɤɥɸɱɟɧɢɹ.
• ȼɟɫɶ ɦɚɬɟɪɢɚɥ ɞɨɥɠɟɧ ɛɵɬɶ ɨɛɨɫɧɨɜɚɧ. ȼɫɟ ɪɟɤɨɦɟɧɞɚɰɢɢ ɜ ɷɬɨɣ ɤɧɢɝɟ ɜɡɹɬɵ ɢɡ ɫɭ-
ɳɟɫɬɜɭɸɳɢɯ ɩɟɱɚɬɧɵɯ ɪɚɛɨɬ. ȼ ɤɨɧɰɟ ɤɧɢɝɢ ɩɪɢɜɟɞɟɧ ɫɩɢɫɨɤ ɢɫɩɨɥɶɡɨɜɚɧɧɨɣ ɥɢɬɟɪɚ-
ɬɭɪɵ ɩɨ C++.
• Ɇɚɬɟɪɢɚɥ ɧɟ ɞɨɥɠɟɧ ɛɵɬɶ ɛɚɧɚɥɟɧ. Ɇɵ ɧɟ ɞɚɟɦ ɪɟɤɨɦɟɧɞɚɰɢɢ, ɤɨɬɨɪɵɦ ɜɵ ɢ ɬɚɤ ɫɥɟɞɭɟ-
ɬɟ, ɤɨɬɨɪɵɟ ɨɛɟɫɩɟɱɢɜɚɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ ɢɥɢ ɤɨɬɨɪɵɟ ɭɠɟ ɢɡɥɨɠɟɧɵ ɜ ɞɪɭɝɢɯ ɪɚɡɞɟɥɚɯ.
• ɇɚɩɪɢɦɟɪ, “ɧɟ ɜɨɡɜɪɚɳɚɣɬɟ ɭɤɚɡɚɬɟɥɶ/ɫɫɵɥɤɭ ɧɚ ɥɨɤɚɥɶɧɭɸ ɩɟɪɟɦɟɧɧɭɸ” — ɯɨɪɨ-
ɲɢɣ ɫɨɜɟɬ, ɧɨ ɨɧ ɧɟ ɜɤɥɸɱɟɧ ɜ ɞɚɧɧɭɸ ɤɧɢɝɭ, ɩɨɫɤɨɥɶɤɭ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟ ɤɨɦɩɢɥɹ-
ɬɨɪɵ ɜɵɞɚɸɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɟ, ɤ ɬɨɦɭ ɠɟ ɷɬɨɬ ɜɨɩɪɨɫ ɪɚɫɤɪɵɜɚ-
ɟɬɫɹ ɜ ɩɟɪɜɨɦ ɪɚɡɞɟɥɟ ɤɧɢɝɢ.
• Ɋɟɤɨɦɟɧɞɚɰɢɹ “ɢɫɩɨɥɶɡɭɣɬɟ ɪɟɞɚɤɬɨɪ (ɤɨɦɩɢɥɹɬɨɪ, ɨɬɥɚɞɱɢɤ)” — ɬɨɠɟ ɯɨɪɨɲɢɣ
ɫɨɜɟɬ, ɧɨ, ɤɨɧɟɱɧɨ, ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɷɬɢ ɢɧɫɬɪɭɦɟɧɬɵ ɢ ɛɟɡ ɧɚɲɟɝɨ ɧɚɩɨɦɢɧɚɧɢɹ.
ȼɦɟɫɬɨ ɷɬɨɝɨ ɦɵ ɪɟɤɨɦɟɧɞɭɟɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɵɟ ɫɢɫɬɟɦɵ ɫɛɨɪɤɢ
ɩɪɨɝɪɚɦɦ ɢ ɫɢɫɬɟɦɵ ɭɩɪɚɜɥɟɧɢɹ ɜɟɪɫɢɹɦɢ.
• ȿɳɟ ɨɞɢɧ ɫɨɜɟɬ — “ɧɟ ɡɥɨɭɩɨɬɪɟɛɥɹɣɬɟ goto” — ɢɫɯɨɞɹ ɢɡ ɧɚɲɟɝɨ ɨɩɵɬɚ, ɢ ɬɚɤ
ɲɢɪɨɤɨ ɢɡɜɟɫɬɟɧ ɜɫɟɦ ɩɪɨɝɪɚɦɦɢɫɬɚɦ, ɬɚɤ ɱɬɨ ɧɟɬ ɫɦɵɫɥɚ ɩɨɜɬɨɪɹɬɶɫɹ.
Ʉɚɠɞɵɣ ɪɚɡɞɟɥ ɫɨɫɬɨɢɬ ɢɡ ɫɥɟɞɭɸɳɢɯ ɱɚɫɬɟɣ.
• Ɂɚɝɥɚɜɢɟ. Ʉɪɚɬɤɨɟ ɧɚɡɜɚɧɢɟ ɪɚɡɞɟɥɚ, ɩɨɹɫɧɹɸɳɟɟ, ɨ ɱɟɦ ɛɭɞɟɬ ɢɞɬɢ ɪɟɱɶ.
• Ɋɟɡɸɦɟ. Ʉɪɚɬɤɨɟ ɢɡɥɨɠɟɧɢɟ ɫɭɬɢ ɜɨɩɪɨɫɚ.
Предисловие 11
Стр. 11
• Ɉɛɫɭɠɞɟɧɢɟ. Ɋɚɫɲɢɪɟɧɧɨɟ ɩɨɹɫɧɟɧɢɟ ɪɟɤɨɦɟɧɞɚɰɢɢ. Ɂɚɱɚɫɬɭɸ ɜɤɥɸɱɚɟɬ ɤɪɚɬɤɨɟ
ɨɛɨɫɧɨɜɚɧɢɟ, ɧɨ ɭɱɬɢɬɟ, ɱɬɨ ɩɨɥɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɩɨ ɞɚɧɧɨɦɭ ɜɨɩɪɨɫɭ ɫɥɟɞɭɟɬ ɢɫɤɚɬɶ
ɜ ɩɪɢɜɟɞɟɧɧɵɯ ɫɫɵɥɤɚɯ.
• ɉɪɢɦɟɪɵ (ɟɫɥɢ ɬɚɤɨɜɵɟ ɢɦɟɸɬɫɹ). ɉɪɢɦɟɪɵ, ɞɟɦɨɧɫɬɪɢɪɭɸɳɢɟ ɩɪɚɜɢɥɨ ɢɥɢ ɩɨɡɜɨ-
ɥɹɸɳɢɟ ɥɭɱɲɟ ɟɝɨ ɩɨɧɹɬɶ ɢ ɡɚɩɨɦɧɢɬɶ.
• ɂɫɤɥɸɱɟɧɢɹ (ɟɫɥɢ ɬɚɤɨɜɵɟ ɢɦɟɸɬɫɹ). Ɉɩɢɫɚɧɢɟ ɫɢɬɭɚɰɢɣ (ɨɛɵɱɧɨ ɪɟɞɤɢɯ), ɤɨɝɞɚ ɩɪɢ-
ɜɟɞɟɧɧɨɟ ɩɪɚɜɢɥɨ ɧɟɩɪɢɦɟɧɢɦɨ. Ɉɞɧɚɤɨ ɨɫɬɟɪɟɝɚɣɬɟɫɶ ɩɨɩɚɫɬɶ ɜ ɥɨɜɭɲɤɭ, ɞɭɦɚɹ, ɱɬɨ
ɜɚɲ ɫɥɭɱɚɣ ɨɫɨɛɵɣ ɢ ɱɬɨ ɜ ɜɚɲɟɣ ɫɢɬɭɚɰɢɢ ɷɬɨ ɩɪɚɜɢɥɨ ɧɟɩɪɢɦɟɧɢɦɨ, — ɨɛɵɱɧɨ ɩɪɢ
ɡɞɪɚɜɨɦ ɪɚɡɦɵɲɥɟɧɢɢ ɨɤɚɡɵɜɚɟɬɫɹ, ɱɬɨ ɧɢɱɟɝɨ ɨɫɨɛɨɝɨ ɜ ɜɚɲɟɣ ɫɢɬɭɚɰɢɢ ɧɟɬ ɢ ɨɩɢ-
ɫɚɧɧɨɟ ɩɪɚɜɢɥɨ ɦɨɠɟɬ ɛɵɬɶ ɫ ɭɫɩɟɯɨɦ ɜɚɦɢ ɩɪɢɦɟɧɟɧɨ.
• ɋɫɵɥɤɢ. ȼ ɩɪɢɜɟɞɟɧɧɨɣ ɜ ɷɬɨɦ ɩɨɞɪɚɡɞɟɥɟ ɥɢɬɟɪɚɬɭɪɟ ɩɨ C++ ɜɵ ɧɚɣɞɟɬɟ ɛɨɥɟɟ ɩɨɥ-
ɧɵɣ ɚɧɚɥɢɡ ɪɚɫɫɦɚɬɪɢɜɚɟɦɨɝɨ ɜ ɪɚɡɞɟɥɟ ɜɨɩɪɨɫɚ.
ȼ ɤɚɠɞɨɣ ɱɚɫɬɢ ɤɧɢɝɢ ɢɦɟɟɬɫɹ “ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɣ ɪɚɡɞɟɥ” — ɨɛɵɱɧɨ ɷɬɨ ɩɟɪɜɵɣ ɪɚɡɞɟɥ
ɱɚɫɬɢ. Ɉɞɧɚɤɨ ɢɧɨɝɞɚ ɷɬɨ ɩɪɚɜɢɥɨ ɧɚɪɭɲɚɥɨɫɶ ɜ ɫɜɹɡɢ ɫ ɧɟɨɛɯɨɞɢɦɨɫɬɶɸ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɝɨ
ɢ ɫɜɹɡɧɨɝɨ ɢɡɥɨɠɟɧɢɹ ɦɚɬɟɪɢɚɥɚ.
Благодарности
Ɇɵ ɨɬ ɜɫɟɣ ɞɭɲɢ ɛɥɚɝɨɞɚɪɧɵ ɪɟɞɚɤɬɨɪɭ ɫɟɪɢɢ Ȼɶɹɪɧɭ ɋɬɪɚɭɫɬɪɭɩɭ (Bjarne Stroustrup),
ɪɟɞɚɤɬɨɪɚɦ ɉɢɬɟɪɭ Ƚɨɪɞɨɧɭ (Peter Gordon) ɢ Ⱦɟɛɛɢ Ʌɚɮɮɟɪɬɢ (Debbie Lafferty), ɚ ɬɚɤɠɟ
Ɍɢɪɪɟɥɥɭ Ⱥɥɛɚɯɭ (Tyrrell Albaugh), Ʉɢɦ Ȼɨɞɢɯɚɣɦɟɪ (Kim Boedigheimer), Ⱦɠɨɧɭ Ɏɭɥɥɟɪɭ
(John Fuller), Ȼɟɪɧɚɪɞɭ Ƚɚɮɮɧɢ (Bernard Gaffney), Ʉɭɪɬɭ Ⱦɠɨɧɫɨɧɭ (Curt Johnson), ɑɚɧɞɟ
Ʌɢɪɢ-Ʉɨɬɭ (Chanda Leary-Coutu), ɑɚɪɥɢ Ʌɟɞɞɢ (Charles Leddy), ɏɢɬɟɪɭ Ɇɭɥɥɷɣɧ (Heather
Mullane), ɑɭɬɢ ɉɪɚɫɟɪɬɫɢɯɭ (Chuti Prasertsith), Ʌɚɪɟ ȼɚɣɫɨɧɝ (Lara Wysong) ɢ ɜɫɟɦ ɨɫɬɚɥɶɧɵɦ
ɪɚɛɨɬɧɢɤɚɦ ɢɡɞɚɬɟɥɶɫɬɜɚ Addison-Wesley, ɩɨɦɨɝɚɜɲɢɦ ɧɚɦ ɜ ɧɚɲɟɣ ɪɚɛɨɬɟ ɧɚɞ ɷɬɢɦ
ɩɪɨɟɤɬɨɦ. ɇɚɦ ɛɵɥɨ ɨɱɟɧɶ ɩɪɢɹɬɧɨ ɪɚɛɨɬɚɬɶ ɫ ɧɢɦɢ.
ɇɚ ɢɞɟɸ ɢ ɨɮɨɪɦɥɟɧɢɟ ɤɧɢɝɢ ɧɚɫ ɧɚɬɨɥɤɧɭɥɢ ɧɟɫɤɨɥɶɤɨ ɢɫɬɨɱɧɢɤɨɜ, ɜɤɥɸɱɚɹ ɬɚɤɢɟ, ɤɚɤ
[Cline99], [Peters99], ɚ ɬɚɤɠɟ ɪɚɛɨɬɵ ɥɟɝɟɧɞɚɪɧɨɝɨ ɢ ɲɢɪɨɤɨ ɰɢɬɢɪɭɟɦɨɝɨ Ⱥɥɚɧɚ ɉɟɪɥɢɫɚ
(Alan Perlis).
Ɉɫɨɛɚɹ ɛɥɚɝɨɞɚɪɧɨɫɬɶ ɬɟɦ ɥɸɞɹɦ, ɱɶɢ ɨɬɡɵɜɵ ɩɨɦɨɝɥɢ ɧɚɦ ɫɞɟɥɚɬɶ ɦɧɨɝɢɟ ɱɚɫɬɢ ɤɧɢɝɢ
ɧɚɦɧɨɝɨ ɥɭɱɲɢɦɢ, ɱɟɦ ɨɧɢ ɛɵɥɢ ɛɵ ɛɟɡ ɷɬɢɯ ɡɚɦɟɱɚɧɢɣ. Ɉɫɨɛɟɧɧɨ ɛɨɥɶɲɨɟ ɜɥɢɹɧɢɟ ɧɚ ɤɧɢɝɭ
ɨɤɚɡɚɥɢ ɨɫɬɪɵɟ ɤɨɦɦɟɧɬɚɪɢɢ Ȼɶɹɪɧɚ ɋɬɪɚɭɫɬɪɭɩɚ. Ɇɵ ɨɱɟɧɶ ɯɨɬɢɦ ɩɨɛɥɚɝɨɞɚɪɢɬɶ ɡɚ ɚɤɬɢɜɧɨɟ
ɭɱɚɫɬɢɟ ɜ ɨɛɫɭɠɞɟɧɢɢ ɦɚɬɟɪɢɚɥɚ ɢ ɜɵɫɤɚɡɚɧɧɵɟ ɡɚɦɟɱɚɧɢɹ ɬɚɤɢɯ ɥɸɞɟɣ, ɤɚɤ Ⱦɷɣɜ Ⱥɛɪɚɦɫ (Dave
Abrahams), Ɇɚɪɲɚɥɥ Ʉɥɚɣɧ (Marshall Cline), Ʉɟɜɥɢɧ ɏɟɧɧɢ (Kevlin Henney), Ƚɨɜɚɪɞ ɏɢɧɧɚɧɬ
(Howard Hinnant), Ⱦɠɢɦ ɏɚɣɫɥɨɩ (Jim Hyslop), ɇɢɤɨɥɚɢ Ⱦɠɨɫɚɬɬɢɫ (Nicolai Josuttis), Ƀɨɧ Ʉɚɥɛ
(Jon Kalb), Ɇɚɤɫ ɏɟɫɢɧ (Max Khesin), ɋɬɟɧ Ʌɢɩɩɦɚɧ (Stan Lippman), ɋɤɨɬɬ Ɇɟɣɟɪɫ (Scott
Meyers) ɢ Ⱦɷɜɢɞ ȼɚɧɞɟɜɭɪɞ (Daveed Vandevoorde). Ʉɪɨɦɟ ɬɨɝɨ, ɨɬɞɟɥɶɧɨɟ ɫɩɚɫɢɛɨ ɯɨɬɟɥɨɫɶ ɛɵ
ɫɤɚɡɚɬɶ ɑɚɤɭ Ⱥɥɥɢɫɨɧɭ (Chuck Allison), ɋɚɦɢɪɭ Ȼɚɣɹɸ (Samir Bajaj), Ɇɚɪɤɭ Ȼɚɪɛɭɪɭ (Marc
Barbour), Ɍɪɟɜɢɫɭ Ȼɪɚɭɧɭ (Travis Brown), ɇɢɥɭ Ʉɭɦɛɟɫɭ (Nil Coombes), Ⱦɚɦɢɚɧɭ Ⱦɟɱɟɜɭ (Damian
Dechev), ɋɬɢɜɭ Ⱦɶɸɯɚɪɫɬɭ (Steve Dewhurst), ɉɢɬɟɪɭ Ⱦɢɦɨɜɭ (Peter Dimov), Ⱥɬɬɢɥɟ Ɏɟɯɟɪɭ
(Attila Feher), Ⱥɥɚɧɭ Ƚɪɢɮɮɢɬɫɭ (Alan Griffiths), Ɇɢɱɢ ɏɟɧɧɢɧɝɭ (Michi Henning), Ⱦɠɟɣɦɫɭ
Ʉɚɧɡɟ (James Kanze), Ȼɚɪɬɨɲɭ Ɇɢɥɟɜɫɤɢ (Bartosz Milewski), Ɇɷɬɬɭ Ɇɚɪɤɭɫɭ (Matt Marcus),
Ȼɚɥɨɝɭ ɉɚɥɭ (Balog Pal), ȼɥɚɞɢɦɢɪɭ ɉɪɭɫɭ (Vladimir Prus), Ⱦɷɧɭ ɋɚɤɫɭ (Dan Saks), Ʌɸɤɭ ȼɚɝɧɟɪɭ
(Luke Wagner), Ɇɷɬɶɸ ȼɢɥɶɫɨɧɭ (Matthew Wilson) ɢ Ʌɟɨɪɭ Ɂɨɥɦɚɧɭ (Leor Zolman).
Ʉɚɤ ɨɛɵɱɧɨ, ɜɫɟ ɨɫɬɚɜɲɢɟɫɹ ɜ ɤɧɢɝɟ ɨɲɢɛɤɢ ɢ ɧɟɞɨɫɦɨɬɪɵ — ɧɚ ɧɚɲɟɣ ɫɨɜɟɫɬɢ, ɚ ɧɟ ɧɚ ɢɯ.
Ƚɟɪɛ ɋɚɬɬɟɪ (Herb Sutter)

Ⱥɧɞɪɟɣ Ⱥɥɟɤɫɚɧɞɪɟɫɤɭ (Andrei Alexandrescu)
ɋɢɷɬɥ, ɫɟɧɬɹɛɪɶ 2004
12 Предисловие
Стр. 12
Вопросы организации и стратегии
ȿɫɥɢ ɛɵ ɫɬɪɨɢɬɟɥɢ ɫɬɪɨɢɥɢ ɡɞɚɧɢɹ ɬɚɤ ɠɟ, ɤɚɤ ɩɪɨɝɪɚɦɦɢɫɬɵ
ɩɢɲɭɬ ɩɪɨɝɪɚɦɦɵ, — ɬɨ ɩɟɪɜɵɣ ɠɟ ɡɚɥɟɬɟɜɲɢɣ ɞɹɬɟɥ ɪɚɡɪɭɲɢɥ
ɛɵ ɜɫɸ ɰɢɜɢɥɢɡɚɰɢɸ.
— Ⱦɠɟɪɚɥɶɞ ȼɚɣɧɛɟɪɝ (Gerald Weinberg)
ɋɥɟɞɭɹ ɜɟɥɢɤɨɣ ɬɪɚɞɢɰɢɢ C ɢ C++, ɦɵ ɧɚɱɢɧɚɟɦ ɨɬɫɱɟɬ ɫ ɧɭɥɹ. Ƚɥɚɜɧɵɣ ɫɨɜɟɬ — ɩɨɞ ɧɨ-
ɦɟɪɨɦ 0 — ɝɨɜɨɪɢɬ ɨ ɬɨɦ, ɱɬɨ ɨɫɧɨɜɧɨɣ ɫɨɜɟɬɱɢɤ ɩɨ ɩɨɜɨɞɭ ɫɬɚɧɞɚɪɬɨɜ ɤɨɞɢɪɨɜɚɧɢɹ — ɧɚɲɢ
ɱɭɜɫɬɜɚ ɢ ɨɳɭɳɟɧɢɹ.
Ɉɫɬɚɥɶɧɚɹ ɱɚɫɬɶ ɷɬɨɣ ɝɥɚɜɵ ɫɨɫɬɨɢɬ ɢɡ ɧɟɛɨɥɶɲɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɬɳɚɬɟɥɶɧɨ ɨɬɨɛɪɚɧɧɵɯ
ɜɨɩɪɨɫɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɢɦɟɸɬ ɩɪɹɦɨɝɨ ɨɬɧɨɲɟɧɢɹ ɤ ɤɨɞɭ ɢ ɩɨɫɜɹɳɟɧɵ ɜɚɠɧɵɦ ɢɧɫɬɪɭɦɟɧɬɚɦ
ɢ ɦɟɬɨɞɚɦ ɧɚɩɢɫɚɧɢɹ ɧɚɞɟɠɧɨɝɨ ɤɨɞɚ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɤɧɢɝɢ ɧɚɢɛɨɥɟɟ ɜɚɠɧɨɣ ɦɵ ɫɱɢɬɚɟɦ ɧɭɥɟɜɭɸ ɪɟɤɨɦɟɧɞɚɰɢɸ — “ɇɟ ɦɟɥɨ-
ɱɢɬɟɫɶ, ɢɥɢ ɑɬɨ ɧɟ ɫɥɟɞɭɟɬ ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɬɶ”.
Стр. 13
0. Не мелочитесь, или Что не следует
стандартизировать
Резюме
ɋɤɚɠɟɦ ɤɪɚɬɤɨ: ɧɟ ɦɟɥɨɱɢɬɟɫɶ.
Обсуждение
ȼɨɩɪɨɫɵ ɩɟɪɫɨɧɚɥɶɧɨɝɨ ɜɤɭɫɚ, ɤɨɬɨɪɵɟ ɧɟ ɜɥɢɹɸɬ ɧɚ ɤɨɪɪɟɤɬɧɨɫɬɶ ɢ ɱɢɬɚɟɦɨɫɬɶ ɤɨɞɚ, ɧɟ
ɨɬɧɨɫɹɬɫɹ ɤ ɫɬɚɧɞɚɪɬɭ ɤɨɞɢɪɨɜɚɧɢɹ. Ʌɸɛɨɣ ɩɪɨɮɟɫɫɢɨɧɚɥɶɧɵɣ ɩɪɨɝɪɚɦɦɢɫɬ ɫɦɨɠɟɬ ɥɟɝɤɨ
ɩɪɨɱɟɫɬɶ ɢ ɡɚɩɢɫɚɬɶ ɤɨɞ, ɮɨɪɦɚɬɢɪɨɜɚɧɢɟ ɤɨɬɨɪɨɝɨ ɧɟɦɧɨɝɨ ɨɬɥɢɱɚɟɬɫɹ ɨɬ ɬɨɝɨ, ɤɨɬɨɪɵɦ ɨɧ
ɨɛɵɱɧɨ ɩɨɥɶɡɭɟɬɫɹ.
ɂɫɩɨɥɶɡɭɣɬɟ ɨɞɧɨ ɢ ɬɨ ɠɟ ɮɨɪɦɚɬɢɪɨɜɚɧɢɟ ɜ ɩɪɟɞɟɥɚɯ ɨɞɧɨɝɨ ɢɫɯɨɞɧɨɝɨ ɮɚɣɥɚ ɢɥɢ ɞɚɠɟ
ɰɟɥɨɝɨ ɩɪɨɟɤɬɚ, ɩɨɫɤɨɥɶɤɭ ɩɟɪɟɯɨɞ ɨɬ ɨɞɧɨɝɨ ɫɬɢɥɹ ɮɨɪɦɚɬɢɪɨɜɚɧɢɹ ɤ ɞɪɭɝɨɦɭ ɜ ɩɪɟɞɟɥɚɯ
ɨɞɧɨɝɨ ɮɪɚɝɦɟɧɬɚ ɢɫɯɨɞɧɨɝɨ ɬɟɤɫɬɚ ɞɨɫɬɚɬɨɱɧɨ ɫɢɥɶɧɨ ɪɚɡɞɪɚɠɚɟɬ. ɇɨ ɧɟ ɩɵɬɚɣɬɟɫɶ ɨɛɟɫɩɟ-
ɱɢɬɶ ɨɞɧɨ ɢ ɬɨ ɠɟ ɮɨɪɦɚɬɢɪɨɜɚɧɢɟ ɜ ɪɚɡɧɵɯ ɩɪɨɟɤɬɚɯ ɢɥɢ ɜ ɰɟɥɨɦ ɩɨ ɜɫɟɣ ɤɨɦɩɚɧɢɢ.
ȼɨɬ ɧɟɫɤɨɥɶɤɨ ɜɨɩɪɨɫɨɜ, ɜ ɤɨɬɨɪɵɯ ɧɟ ɜɚɠɧɨ ɬɨɱɧɨɟ ɫɥɟɞɨɜɚɧɢɟ ɩɪɚɜɢɥɭ, ɚ ɬɪɟɛɭɟɬɫɹ ɜɫɟɝɨ
ɥɢɲɶ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɟ ɩɪɢɦɟɧɟɧɢɟ ɫɬɢɥɹ, ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɜ ɮɚɣɥɟ, ɫ ɤɨɬɨɪɵɦ ɜɵ ɪɚɛɨɬɚɟɬɟ.
• ɇɟ ɫɥɟɞɭɟɬ ɨɩɪɟɞɟɥɹɬɶ ɤɨɧɤɪɟɬɧɵɣ ɪɚɡɦɟɪ ɨɬɫɬɭɩɚ, ɧɨ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɬ-
ɫɬɭɩɵ ɞɥɹ ɩɨɞɱɟɪɤɢɜɚɧɢɹ ɫɬɪɭɤɬɭɪɵ ɩɪɨɝɪɚɦɦɵ. Ⱦɥɹ ɨɬɫɬɭɩɚ ɢɫɩɨɥɶɡɭɣɬɟ ɬɨ ɤɨɥɢɱɟ-
ɫɬɜɨ ɫɢɦɜɨɥɨɜ, ɤɨɬɨɪɨɟ ɜɚɦ ɧɪɚɜɢɬɫɹ, ɧɨ ɷɬɨ ɤɨɥɢɱɟɫɬɜɨ ɞɨɥɠɧɨ ɛɵɬɶ ɨɞɢɧɚɤɨɜɨ, ɤɚɤ
ɦɢɧɢɦɭɦ, ɜ ɩɪɟɞɟɥɚɯ ɮɚɣɥɚ.
• ɇɟ ɨɩɪɟɞɟɥɹɣɬɟ ɤɨɧɤɪɟɬɧɭɸ ɞɥɢɧɭ ɫɬɪɨɤɢ, ɧɨ ɨɧɚ ɞɨɥɠɧɚ ɨɫɬɚɜɥɹɬɶ ɬɟɤɫɬ ɭɞɨɛɨ-
ɱɢɬɚɟɦɵɦ. ɂɫɩɨɥɶɡɭɣɬɟ ɬɭ ɞɥɢɧɭ ɫɬɪɨɤɢ, ɤɨɬɨɪɚɹ ɜɚɦ ɩɨ ɞɭɲɟ, ɧɨ ɧɟ ɡɥɨɭɩɨɬɪɟɛɥɹɣɬɟ
ɟɸ. ɂɫɫɥɟɞɨɜɚɧɢɹ ɩɨɤɚɡɚɥɢ, ɱɬɨ ɥɟɝɱɟ ɜɫɟɝɨ ɜɨɫɩɪɢɧɢɦɚɟɬɫɹ ɬɟɤɫɬ, ɜ ɫɬɪɨɤɟ ɤɨɬɨɪɨɝɨ
ɧɚɯɨɞɢɬɫɹ ɞɨ ɞɟɫɹɬɢ ɫɥɨɜ.
• ɋɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɟɩɪɨɬɢɜɨɪɟɱɢɜɵɟ ɫɨɝɥɚɲɟɧɢɹ ɨɛ ɢɦɟɧɨɜɚɧɢɢ, ɧɟ ɫɥɢɲɤɨɦ ɦɟɥɨɱɧɨ
ɪɟɝɥɚɦɟɧɬɢɪɭɹ ɟɝɨ. ɂɦɟɟɬɫɹ ɬɨɥɶɤɨ ɞɜɚ ɢɦɩɟɪɚɬɢɜɧɵɯ ɬɪɟɛɨɜɚɧɢɹ ɩɨ ɩɨɜɨɞɭ ɢɦɟɧɨɜɚɧɢɹ:
ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɢɦɟɧɚ, ɧɚɱɢɧɚɸɳɢɟɫɹ ɫ ɩɨɞɱɟɪɤɢɜɚɧɢɹ ɢɥɢ ɫɨɞɟɪɠɚɳɢɟ ɞɜɨɣɧɨɟ
ɩɨɞɱɟɪɤɢɜɚɧɢɟ, ɢ ɜɫɟɝɞɚ ɢɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɦɚɤɪɨɫɨɜ ɬɨɥɶɤɨ ɩɪɨɩɢɫɧɵɟ ɛɭɤɜɵ (ONLY_
UPPERCASE_NAMES), ɩɪɢ ɷɬɨɦ ɧɢɤɨɝɞɚ ɧɟ ɩɪɢɦɟɧɹɹ ɜ ɤɚɱɟɫɬɜɟ ɢɦɟɧ ɦɚɤɪɨɫɨɜ ɨɛɵɱɧɵɟ
ɫɥɨɜɚ ɢɥɢ ɫɨɤɪɚɳɟɧɢɹ (ɜɤɥɸɱɚɹ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɟ ɩɚɪɚɦɟɬɪɵ ɲɚɛɥɨɧɨɜ, ɬɚɤɢɟ ɤɚɤ T ɢɥɢ U;
ɡɚɩɢɫɶ #define T anything ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɤɪɭɩɧɵɦ ɧɟɩɪɢɹɬɧɨɫɬɹɦ). ȼ ɨɫɬɚɥɶɧɵɯ
ɫɥɭɱɚɹɯ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɩɪɨɬɢɜɨɪɟɱɢɜɵɟ ɡɧɚɱɢɦɵɟ ɢɦɟɧɚ ɢ ɫɥɟɞɭɣɬɟ ɫɨɝɥɚɲɟɧɢɹɦ, ɩɪɢɧɹ-
ɬɵɦ ɞɥɹ ɞɚɧɧɨɝɨ ɮɚɣɥɚ ɢɥɢ ɦɨɞɭɥɹ. (ȿɫɥɢ ɜɵ ɧɟ ɦɨɠɟɬɟ ɫɚɦɢ ɪɚɡɪɚɛɨɬɚɬɶ ɫɨɝɥɚɲɟɧɢɟ ɨɛ
ɢɦɟɧɨɜɚɧɢɢ, ɩɨɩɪɨɛɭɣɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɫɥɟɞɭɸɳɢɦ: ɢɦɟɧɚ ɤɥɚɫɫɨɜ, ɮɭɧɤɰɢɣ ɢ ɩɟɪɟɱɢɫ-
ɥɟɧɢɣ ɞɨɥɠɧɵ ɜɵɝɥɹɞɟɬɶ ɤɚɤ LikeThis, ɢɦɟɧɚ ɩɟɪɟɦɟɧɧɵɯ — likeThis, ɢɦɟɧɚ ɡɚɤɪɵ-
ɬɵɯ ɱɥɟɧɨɜ-ɞɚɧɧɵɯ — likeThis_, ɢ ɢɦɟɧɚ ɦɚɤɪɨɫɨɜ — LIKE_THIS.)
• ɇɟ ɩɪɟɞɩɢɫɵɜɚɣɬɟ ɫɬɢɥɶ ɤɨɦɦɟɧɬɚɪɢɟɜ (ɤɪɨɦɟ ɬɟɯ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɫɩɟɰɢɚɥɶɧɵɣ ɢɧɫɬ-
ɪɭɦɟɧɬɚɪɢɣ ɢɫɩɨɥɶɡɭɟɬ ɢɯ ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ), ɧɨ ɩɢɲɢɬɟ ɬɨɥɶɤɨ ɧɭɠɧɵɟ ɢ ɩɨɥɟɡ-
ɧɵɟ ɤɨɦɦɟɧɬɚɪɢɢ. ȼɦɟɫɬɨ ɤɨɦɦɟɧɬɚɪɢɟɜ ɩɢɲɢɬɟ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɤɨɞ (ɫɦ., ɧɚɩɪɢɦɟɪ,
ɪɭɤɨɜɨɞɫɬɜɨ 16). ɇɟ ɩɢɲɢɬɟ ɤɨɦɦɟɧɬɚɪɢɢ, ɤɨɬɨɪɵɟ ɩɪɨɫɬɨ ɩɨɜɬɨɪɹɸɬ ɤɨɞ. Ʉɨɦɦɟɧɬɚɪɢɢ
ɞɨɥɠɧɵ ɪɚɡɴɹɫɧɹɬɶ ɢɫɩɨɥɶɡɨɜɚɧɧɵɣ ɩɨɞɯɨɞ ɢ ɨɛɨɫɧɨɜɵɜɚɬɶ ɟɝɨ.
ɂ ɧɚɤɨɧɟɰ, ɧɟ ɩɵɬɚɣɬɟɫɶ ɡɚɫɬɚɜɥɹɬɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɭɫɬɚɪɟɜɲɢɟ ɩɪɚɜɢɥɚ (ɫɦ. ɩɪɢɦɟɪɵ 2 ɢ 3),
ɞɚɠɟ ɟɫɥɢ ɨɧɢ ɢɦɟɸɬɫɹ ɜ ɫɬɚɪɵɯ ɫɬɚɧɞɚɪɬɚɯ ɤɨɞɢɪɨɜɚɧɢɹ.
14 Вопросы организации и стратегии
Стр. 14
Примеры
ɉɪɢɦɟɪ 1. Ɋɚɡɦɟɳɟɧɢɟ ɮɢɝɭɪɧɵɯ ɫɤɨɛɨɤ. ɇɟɬ ɧɢɤɚɤɨɣ ɪɚɡɧɢɰɵ ɜ ɩɥɚɧɟ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɢ
ɫɥɟɞɭɸɳɢɯ ɮɪɚɝɦɟɧɬɨɜ:
void using_k_and_r_style() {
// ...
}
void putting_each_brace_on_its_own_line()
{
// ...
}
void or_putting_each_brace_on_its_own_line_indented()
{
// ...
}
ȼɫɟ ɩɪɨɮɟɫɫɢɨɧɚɥɶɧɵɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɦɨɝɭɬ ɥɟɝɤɨ ɱɢɬɚɬɶ ɢ ɩɢɫɚɬɶ ɜ ɤɚɠɞɨɦ ɢɡ ɷɬɢɯ ɫɬɢ-
ɥɟɣ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɫɥɨɠɧɨɫɬɟɣ. ɇɨ ɫɥɟɞɭɟɬ ɛɵɬɶ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɦ. ɇɟ ɪɚɡɦɟɳɚɣɬɟ ɫɤɨɛɤɢ
ɤɚɤ ɩɪɢɞɟɬɫɹ ɢɥɢ ɬɚɤ, ɱɬɨ ɢɯ ɪɚɡɦɟɳɟɧɢɟ ɛɭɞɟɬ ɫɤɪɵɜɚɬɶ ɜɥɨɠɟɧɧɨɫɬɶ ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ, ɢ
ɩɵɬɚɣɬɟɫɶ ɫɥɟɞɨɜɚɬɶ ɫɬɢɥɸ, ɩɪɢɧɹɬɨɦɭ ɜ ɬɨɦ ɢɥɢ ɢɧɨɦ ɮɚɣɥɟ. ȼ ɞɚɧɧɨɣ ɤɧɢɝɟ ɪɚɡɦɟɳɟɧɢɟ
ɫɤɨɛɨɤ ɩɪɢɡɜɚɧɨ ɨɛɟɫɩɟɱɢɬɶ ɦɚɤɫɢɦɚɥɶɧɭɸ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɶ, ɩɪɢ ɷɬɨɦ ɨɫɬɚɜɚɹɫɶ ɜ ɪɚɦɤɚɯ,
ɨɩɪɟɞɟɥɟɧɧɵɯ ɪɟɞɚɤɬɨɪɫɤɢɦɢ ɨɝɪɚɧɢɱɟɧɢɹɦɢ.
ɉɪɢɦɟɪ 2. ɉɪɨɛɟɥɵ ɢɥɢ ɬɚɛɭɥɹɰɢɹ. ȼ ɧɟɤɨɬɨɪɵɯ ɤɨɦɚɧɞɚɯ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɬɚɛɭɥɹɰɢɢ ɡɚ-
ɩɪɟɳɟɧɨ (ɧɚɩɪɢɦɟɪ, [BoostLRG]) ɧɚ ɬɨɦ ɨɫɧɨɜɚɧɢɢ, ɱɬɨ ɪɚɡɦɟɪ ɬɚɛɭɥɹɰɢɢ ɜɚɪɶɢɪɭɟɬɫɹ ɨɬ ɪɟ-
ɞɚɤɬɨɪɚ ɤ ɪɟɞɚɤɬɨɪɭ, ɚ ɷɬɨ ɩɪɢɜɨɞɢɬ ɤ ɬɨɦɭ, ɱɬɨ ɨɬɫɬɭɩɵ ɨɤɚɡɵɜɚɸɬɫɹ ɫɥɢɲɤɨɦ ɦɚɥɵ ɢɥɢ
ɫɥɢɲɤɨɦ ɜɟɥɢɤɢ. ȼ ɞɪɭɝɢɯ ɤɨɦɚɧɞɚɯ ɬɚɛɭɥɹɰɢɢ ɪɚɡɪɟɲɟɧɵ. ȼɚɠɧɨ ɬɨɥɶɤɨ ɛɵɬɶ ɩɨɫɥɟɞɨɜɚ-
ɬɟɥɶɧɵɦ. ȿɫɥɢ ɜɵ ɩɨɡɜɨɥɹɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɚɛɭɥɹɰɢɸ, ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɬɚɤɨɟ ɪɟɲɟɧɢɟ ɧɟ ɛɭ-
ɞɟɬ ɦɟɲɚɬɶ ɹɫɧɨɫɬɢ ɤɨɞɚ ɢ ɟɝɨ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɢ, ɟɫɥɢ ɱɥɟɧɵ ɤɨɦɚɧɞɵ ɛɭɞɭɬ ɫɨɩɪɨɜɨɠɞɚɬɶ
ɤɨɞ ɞɪɭɝ ɞɪɭɝɚ (ɫɦ. ɪɭɤɨɜɨɞɫɬɜɨ 6). ȿɫɥɢ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɬɚɛɭɥɹɰɢɢ ɧɟ ɪɚɡɪɟɲɟɧɨ, ɩɨɡɜɨɥɶɬɟ
ɪɟɞɚɤɬɨɪɭ ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶ ɩɪɨɛɟɥɵ ɜ ɬɚɛɭɥɹɰɢɢ ɩɪɢ ɱɬɟɧɢɢ ɢɫɯɨɞɧɨɝɨ ɮɚɣɥɚ, ɱɬɨɛɵ ɩɪɨ-
ɝɪɚɦɦɢɫɬɵ ɦɨɝɥɢ ɪɚɛɨɬɚɬɶ ɫ ɧɢɦɢ ɜ ɪɟɞɚɤɬɨɪɟ. Ɉɞɧɚɤɨ ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɩɪɢ ɫɨɯɪɚɧɟɧɢɢ ɮɚɣɥɚ
ɬɚɛɭɥɹɰɢɹ ɛɭɞɟɬ ɜɧɨɜɶ ɩɪɟɨɛɪɚɡɨɜɚɧɚ ɜ ɩɪɨɛɟɥɵ.
ɉɪɢɦɟɪ 3. ȼɟɧɝɟɪɫɤɚɹ ɡɚɩɢɫɶ. Ɂɚɩɢɫɶ, ɩɪɢ ɤɨɬɨɪɨɣ ɢɧɮɨɪɦɚɰɢɹ ɨ ɬɢɩɟ ɜɤɥɸɱɚɟɬɫɹ ɜ ɢɦɹ
ɩɟɪɟɦɟɧɧɨɣ, ɩɪɢɧɨɫɢɬ ɩɨɥɶɡɭ ɜ ɹɡɵɤɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɧɟɛɟɡɨɩɚɫɧɨɦ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɬɢɩɨɜ
(ɨɫɨɛɟɧɧɨ ɜ C); ɜɨɡɦɨɠɧɚ, ɯɨɬɹ ɢ ɧɟ ɩɪɢɧɨɫɢɬ ɧɢɤɚɤɨɣ ɩɨɥɶɡɵ (ɬɨɥɶɤɨ ɧɟɞɨɫɬɚɬɤɢ) ɜ ɨɛɴɟɤɬ-
ɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɵɯ ɹɡɵɤɚɯ; ɢ ɧɟɜɨɡɦɨɠɧɚ ɜ ɨɛɨɛɳɟɧɧɨɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ. Ɍɚɤɢɦ ɨɛɪɚ-
ɡɨɦ, ɫɬɚɧɞɚɪɬ ɤɨɞɢɪɨɜɚɧɢɹ C++ ɧɟ ɞɨɥɠɟɧ ɬɪɟɛɨɜɚɬɶ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜɟɧɝɟɪɫɤɨɣ ɡɚɩɢɫɢ, ɛɨɥɟɟ
ɬɨɝɨ, ɦɨɠɟɬ ɩɨɬɪɟɛɨɜɚɬɶ ɟɟ ɡɚɩɪɟɬɚ.
ɉɪɢɦɟɪ 4. Ɉɞɢɧ ɜɯɨɞ, ɨɞɢɧ ɜɵɯɨɞ (Single entry, single exit — “SESE”). ɂɫɬɨɪɢɱɟɫɤɢ ɧɟɤɨ-
ɬɨɪɵɟ ɫɬɚɧɞɚɪɬɵ ɤɨɞɢɪɨɜɚɧɢɹ ɬɪɟɛɭɸɬ, ɱɬɨɛɵ ɤɚɠɞɚɹ ɮɭɧɤɰɢɹ ɢɦɟɥɚ ɜ ɬɨɱɧɨɫɬɢ ɨɞɢɧ ɜɵɯɨɞ,
ɱɬɨ ɩɨɞɪɚɡɭɦɟɜɚɟɬ ɨɞɧɭ ɢɧɫɬɪɭɤɰɢɸ return. Ɍɚɤɨɟ ɬɪɟɛɨɜɚɧɢɟ ɹɜɥɹɟɬɫɹ ɭɫɬɚɪɟɜɲɢɦ ɜ ɹɡɵ-
ɤɚɯ, ɩɨɞɞɟɪɠɢɜɚɸɳɢɯ ɢɫɤɥɸɱɟɧɢɹ ɢ ɞɟɫɬɪɭɤɬɨɪɵ, ɬɚɤ ɱɬɨ ɮɭɧɤɰɢɢ ɨɛɵɱɧɨ ɢɦɟɸɬ ɧɟɫɤɨɥɶɤɨ
ɧɟɹɜɧɵɯ ɜɵɯɨɞɨɜ. ȼɦɟɫɬɨ ɷɬɨɝɨ ɫɬɨɢɬ ɫɥɟɞɨɜɚɬɶ ɫɬɚɧɞɚɪɬɭ ɧɚɩɨɞɨɛɢɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 5, ɤɨɬɨ-
ɪɚɹ ɬɪɟɛɭɟɬ ɨɬ ɮɭɧɤɰɢɣ ɩɪɨɫɬɨɬɵ ɢ ɤɪɚɬɤɨɫɬɢ, ɱɬɨ ɞɟɥɚɟɬ ɢɯ ɛɨɥɟɟ ɩɪɨɫɬɵɦɢ ɞɥɹ ɩɨɧɢɦɚɧɢɹ
ɢ ɛɨɥɟɟ ɭɫɬɨɣɱɢɜɵɦɢ ɤ ɨɲɢɛɤɚɦ.
Ссылки
[BoostLRG] • [Brooks95] §12 • [Constantine95] §29 • [Keffer95] p. 1 • [Kernighan99] §1.1, §1.3,
§1.6-7 • [Lakos96] §1.4.1, §2.7 • [McConnell93] §9, §19 • [Stroustrup94] §4.2-3 • [Stroustrup00]
§4.9.3, §6.4, §7.8, §C.1 • [Sutter00] §6, §20 • [SuttHysl01]
0. Не мелочитесь, или Что не следует стандартизировать 15
Стр. 15
1. Компилируйте без замечаний
при максимальном уровне
предупреждений
Резюме
ɋɥɟɞɭɟɬ ɫɟɪɶɟɡɧɨ ɨɬɧɨɫɢɬɶɫɹ ɤ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ ɤɨɦɩɢɥɹɬɨɪɚ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɚɤɫɢ-
ɦɚɥɶɧɵɣ ɭɪɨɜɟɧɶ ɜɵɜɨɞɚ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ ɜɚɲɢɦ ɤɨɦɩɢɥɹɬɨɪɨɦ. Ʉɨɦɩɢɥɹɰɢɹ ɞɨɥɠɧɚ ɜɵ-
ɩɨɥɧɹɬɶɫɹ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ. ȼɵ ɞɨɥɠɧɵ ɩɨɧɢɦɚɬɶ ɜɫɟ ɜɵɞɚɜɚɟɦɵɟ ɩɪɟɞɭɩɪɟ-
ɠɞɟɧɢɹ ɢ ɭɫɬɪɚɧɹɬɶ ɢɯ ɩɭɬɟɦ ɢɡɦɟɧɟɧɢɹ ɤɨɞɚ, ɚ ɧɟ ɫɧɢɠɟɧɢɹ ɭɪɨɜɧɹ ɜɵɜɨɞɚ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ.
ȼɚɲ ɤɨɦɩɢɥɹɬɨɪ — ɜɚɲ ɞɪɭɝ. ȿɫɥɢ ɨɧ ɜɵɞɚɥ ɩɪɟɞɭɩɪɟɠɞɟɧɢɟ ɞɥɹ ɨɩɪɟɞɟɥɟɧɧɨɣ ɤɨɧɫɬ-
ɪɭɤɰɢɢ, ɡɚɱɚɫɬɭɸ ɷɬɨ ɝɨɜɨɪɢɬ ɨ ɩɨɬɟɧɰɢɚɥɶɧɨɣ ɩɪɨɛɥɟɦɟ ɜ ɜɚɲɟɦ ɤɨɞɟ.
ɍɫɩɟɲɧɚɹ ɫɛɨɪɤɚ ɩɪɨɝɪɚɦɦɵ ɞɨɥɠɧɚ ɩɪɨɢɫɯɨɞɢɬɶ ɦɨɥɱɚ (ɛɟɡ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ). ȿɫɥɢ ɷɬɨ
ɧɟ ɬɚɤ, ɜɵ ɛɵɫɬɪɨ ɩɪɢɨɛɪɟɬɚɟɬɟ ɩɪɢɜɵɱɤɭ ɧɟ ɨɛɪɚɳɚɬɶ ɜɧɢɦɚɧɢɹ ɧɚ ɜɵɜɨɞ ɤɨɦɩɢɥɹɬɨɪɚ
ɢ ɦɨɠɟɬɟ ɩɪɨɩɭɫɬɢɬɶ ɫɟɪɶɟɡɧɭɸ ɩɪɨɛɥɟɦɭ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 2).
ɑɬɨɛɵ ɢɡɛɟɠɚɬɶ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ, ɧɚɞɨ ɩɨɧɢɦɚɬɶ, ɱɬɨ ɨɧɢ ɨɡɧɚɱɚɸɬ, ɢ ɩɟɪɟɮɪɚɡɢɪɨɜɚɬɶ
ɜɚɲ ɤɨɞ ɬɚɤ, ɱɬɨɛɵ ɭɫɬɪɚɧɢɬɶ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ ɢ ɫɞɟɥɚɬɶ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ ɤɨɞɚ ɛɨɥɟɟ ɩɨɧɹɬ-
ɧɵɦ ɤɚɤ ɞɥɹ ɤɨɦɩɢɥɹɬɨɪɚ, ɬɚɤ ɢ ɞɥɹ ɱɟɥɨɜɟɤɚ.
Ⱦɟɥɚɣɬɟ ɷɬɨ ɜɫɟɝɞɚ — ɞɚɠɟ ɟɫɥɢ ɩɪɨɝɪɚɦɦɚ ɜɵɝɥɹɞɢɬ ɤɨɪɪɟɤɬɧɨ ɪɚɛɨɬɚɸɳɟɣ. Ⱦɟɥɚɣɬɟ
ɷɬɨ, ɞɚɠɟ ɟɫɥɢ ɭɛɟɞɢɥɢɫɶ ɜ ɦɹɝɤɨɫɬɢ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ. Ⱦɚɠɟ ɥɟɝɤɢɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ ɦɨɝɭɬ
ɫɤɪɵɜɚɬɶ ɩɨɫɥɟɞɭɸɳɢɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ, ɭɤɚɡɵɜɚɸɳɢɟ ɧɚ ɪɟɚɥɶɧɭɸ ɨɩɚɫɧɨɫɬɶ.
Примеры
ɉɪɢɦɟɪ 1. Ɂɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɫɬɨɪɨɧɧɟɝɨ ɩɪɨɢɡɜɨɞɢɬɟɥɹ. Ȼɢɛɥɢɨɬɟɱɧɵɣ ɡɚɝɨɥɨɜɨɱɧɵɣ
ɮɚɣɥ, ɤɨɬɨɪɵɣ ɜɵ ɧɟ ɦɨɠɟɬɟ ɢɡɦɟɧɢɬɶ, ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ ɤɨɧɫɬɪɭɤɰɢɸ, ɤɨɬɨɪɚɹ ɩɪɢɜɨɞɢɬ
ɤ (ɜɟɪɨɹɬɧɨ, ɦɟɥɤɨɦɭ) ɩɪɟɞɭɩɪɟɠɞɟɧɢɸ. ȼ ɬɚɤɨɦ ɫɥɭɱɚɟ “ɡɚɜɟɪɧɢɬɟ” ɷɬɨɬ ɮɚɣɥ ɜ ɫɜɨɣ ɫɨɛɫɬ-
ɜɟɧɧɵɣ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɜɤɥɸɱɚɬɶ ɢɫɯɨɞɧɵɣ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include ɢ ɢɡɛɢɪɚɬɟɥɶ-
ɧɨ ɨɬɤɥɸɱɚɬɶ ɞɥɹ ɧɟɝɨ ɤɨɧɤɪɟɬɧɵɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ. ȼ ɫɜɨɟɦ ɩɪɨɟɤɬɟ ɜɵ ɛɭɞɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɫɨɛɫɬɜɟɧɧɵɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ, ɚ ɧɟ ɢɫɯɨɞɧɵɣ. ɇɚɩɪɢɦɟɪ (ɭɱɬɢɬɟ — ɭɩɪɚɜɥɟɧɢɟ ɜɵɜɨɞɨɦ
ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ ɜɚɪɶɢɪɭɟɬɫɹ ɨɬ ɤɨɦɩɢɥɹɬɨɪɚ ɤ ɤɨɦɩɢɥɹɬɨɪɭ):
// ǟǫǴǶ: myproj/my_lambda.h – "ǹǬǰǻǽǵǫ" ǯǶȊ lambda.hpp ǳǲ
// ǬǳǬǶǳǹǽǰǵǳ Boost. ǍǼǰǮǯǫ ǭǵǶȉȂǫǴǽǰ ǳǷǰǸǸǹ Ȉǽǹǽ ǿǫǴǶ ǳ Ǹǰ
// ǳǼǺǹǶȇǲǾǴǽǰ lambda.hpp ǸǰǺǹǼǻǰǯǼǽǭǰǸǸǹ. Boost.Lambda
// Ǻǻǳǭǹǯǳǽ ǵ ǭȆǭǹǯǾ ǵǹǷǺǳǶȊǽǹǻǹǷ ǺǻǰǯǾǺǻǰǱǯǰǸǳǴ, ǹ
// ǬǰǲǭǻǰǯǸǹǼǽǳ ǵǹǽǹǻȆȀ ǸǫǷ ǯǹǺǹǯǶǳǸǸǹ ǳǲǭǰǼǽǸǹ. ǕǹǮǯǫ
// ǻǫǲǻǫǬǹǽȂǳǵǳ ǼǯǰǶǫȉǽ ǸǹǭǾȉ ǭǰǻǼǳȉ, ǵǹǽǹǻǫȊ Ǹǰ ǬǾǯǰǽ
// ǭȆǲȆǭǫǽȇ ǺǻǰǯǾǺǻǰǱǯǰǸǳǴ, ǷȆ ǾǯǫǶǳǷ ǳǲ ȈǽǹǮǹ ǿǫǴǶǫ
// ǼǹǹǽǭǰǽǼǽǭǾȉȄǳǰ ǯǳǻǰǵǽǳǭȆ #pragma, Ǹǹ ǼǫǷ ǲǫǮǹǶǹǭǹȂǸȆǴ
// ǿǫǴǶ ǹǼǽǫǸǰǽǼȊ.
//
#pragma warning(push) // ǙǽǵǶȉȂǰǸǳǰ ǺǻǰǯǾǺǻǰǱǯǰǸǳǴ ǽǹǶȇǵǹ
// ǯǶȊ ǯǫǸǸǹǮǹ ǲǫǮǹǶǹǭǹȂǸǹǮǹ ǿǫǴǶǫ
#pragma warning(disable:4512)
#pragma warning(disable:4180)
Стр. 16
#include <boost/lambda /lambda .hpp>
#pragma warning(pop) // ǍǹǼǼǽǫǸǫǭǶǳǭǫǰǷ ǳǼȀǹǯǸȆǴ ǾǻǹǭǰǸȇ
// ǭȆǭǹǯǫ ǺǻǰǯǾǺǻǰǱǯǰǸǳǴ
ɉɪɢɦɟɪ 2. “ɇɟɢɫɩɨɥɶɡɭɟɦɵɣ ɩɚɪɚɦɟɬɪ ɮɭɧɤɰɢɢ”. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɜ ɫɚɦɨɦ ɞɟɥɟ ɫɨɡɧɚ-
ɬɟɥɶɧɨ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɩɚɪɚɦɟɬɪ ɮɭɧɤɰɢɢ (ɇɚɩɪɢɦɟɪ, ɷɬɨ “ɡɚɝɥɭɲɤɚ” ɞɥɹ ɛɭɞɭɳɟɝɨ ɪɚɫɲɢɪɟ-
ɧɢɹ ɢɥɢ ɬɪɟɛɭɟɦɚɹ ɫɬɚɧɞɚɪɬɨɦ ɱɚɫɬɶ ɫɢɝɧɚɬɭɪɵ, ɤɨɬɨɪɭɸ ɜɚɲ ɤɨɞ ɧɟ ɢɫɩɨɥɶɡɭɟɬ). ȿɫɥɢ ɷɬɨɬ
ɩɚɪɚɦɟɬɪ ɜɚɦ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟ ɧɭɠɟɧ, ɩɪɨɫɬɨ ɭɞɚɥɢɬɟ ɟɝɨ ɢɦɹ:
// ... ǭǸǾǽǻǳ ǺǹǶȇǲǹǭǫǽǰǶȇǼǵǹǮǹ ǻǫǼǺǻǰǯǰǶǳǽǰǶȊ ǺǹǯǼǵǫǲǵǫ Ǹǰ
// ǳǼǺǹǶȇǲǾǰǽǼȊ ...
// ǚǻǰǯǾǺǻǰǱǯǰǸǳǰ: "ǸǰǳǼǺǹǶȇǲǾǰǷȆǴ ǺǫǻǫǷǰǽǻ 'localityHint'"
pointer allocate( size_type numObjects,
const void *l
localityHint = 0 ) {
return static_cast<pointer>(
mallocShared( numObjects * sizeof(T) ) );
}
// ǘǹǭǫȊ ǭǰǻǼǳȊ: ǺǻǰǯǾǺǻǰǱǯǰǸǳǰ ǾǼǽǻǫǸǰǸǹ

pointer allocate( size_type numObjects,
const void * /* localityHint */ = 0 ) {
return static_cast<pointer>(
mallocShared( numObjects * sizeof(T) ) );
}
ɉɪɢɦɟɪ 3. “ɉɟɪɟɦɟɧɧɚɹ ɨɩɪɟɞɟɥɟɧɚ, ɧɨ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ”. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɞɟɣɫɬɜɢɬɟɥɶɧɨ
ɧɟ ɧɚɦɟɪɟɧɵ ɨɛɪɚɳɚɬɶɫɹ ɤ ɞɚɧɧɨɣ ɩɟɪɟɦɟɧɧɨɣ (ɤ ɬɚɤɢɦ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ ɱɚɫɬɨ ɩɪɢɜɨɞɹɬ ɥɨ-
ɤɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɫɥɟɞɭɸɳɢɟ ɢɞɢɨɦɟ “ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ ɟɫɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ”, ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 13). ȿɫɥɢ ɨɛɪɚɳɟɧɢɟ ɤ ɨɛɴɟɤɬɭ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟ ɬɪɟɛɭɟɬɫɹ, ɱɚɫɬɨ ɦɨɠɧɨ ɡɚɫɬɚɜɢɬɶ ɤɨɦɩɢ-
ɥɹɬɨɪ ɡɚɦɨɥɱɚɬɶ, ɜɤɥɸɱɢɜ “ɜɵɱɢɫɥɟɧɢɟ” ɫɚɦɨɣ ɩɟɪɟɦɟɧɧɨɣ ɜ ɤɚɱɟɫɬɜɟ ɜɵɪɚɠɟɧɢɹ (ɬɚɤɨɟ ɜɵɱɢɫ-
ɥɟɧɢɟ ɧɟ ɜɥɢɹɟɬ ɧɚ ɫɤɨɪɨɫɬɶ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ):
// ǚǻǰǯǾǺǻǰǱǯǰǸǳǰ: "ǺǰǻǰǷǰǸǸǫȊ 'lock' ǹǺǻǰǯǰǶǰǸǫ, Ǹǹ Ǹǰ
// ǳǼǺǹǶȇǲǾǰǽǼȊ"
void Fun() {
Lock lock;
// ...
}
// ǘǹǭǫȊ ǭǰǻǼǳȊ: ǺǻǰǯǾǺǻǰǱǯǰǸǳǰ Ǹǰ ǯǹǶǱǸǹ ǭȆǭǹǯǳǽȇǼȊ
void Fun() {
Lock lock;
lock;
// ...
}
ɉɪɢɦɟɪ 4. “ɉɟɪɟɦɟɧɧɚɹ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ, ɧɟ ɛɭɞɭɱɢ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɨɣ”. ɂɧɢ-
ɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɭɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 19).
ɉɪɢɦɟɪ 5. “Ɉɬɫɭɬɫɬɜɭɟɬ return”. ɂɧɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪɵ ɬɪɟɛɭɸɬ ɧɚɥɢɱɢɹ ɢɧɫɬɪɭɤɰɢɢ
return ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɩɨɬɨɤ ɭɩɪɚɜɥɟɧɢɹ ɧɟ ɦɨɠɟɬ ɞɨɫɬɢɱɶ ɤɨɧɰɚ ɮɭɧɤɰɢɢ (ɧɚɩɪɢɦɟɪ, ɩɪɢ
ɧɚɥɢɱɢɢ ɛɟɫɤɨɧɟɱɧɨɝɨ ɰɢɤɥɚ, ɢɧɫɬɪɭɤɰɢɢ throw, ɞɪɭɝɢɯ ɢɧɫɬɪɭɤɰɢɣ return). Ɍɚɤɨɟ ɩɪɟɞɭ-
ɩɪɟɠɞɟɧɢɟ ɧɟ ɫɬɨɢɬ ɢɝɧɨɪɢɪɨɜɚɬɶ, ɩɨɫɤɨɥɶɤɭ ɜɵ ɦɨɠɟɬɟ ɬɨɥɶɤɨ ɞɭɦɚɬɶ, ɱɬɨ ɭɩɪɚɜɥɟɧɢɟ ɧɟ
ɞɨɫɬɢɝɚɟɬ ɤɨɧɰɚ ɮɭɧɤɰɢɢ. ɇɚɩɪɢɦɟɪ, ɤɨɧɫɬɪɭɤɰɢɹ switch, ɭ ɤɨɬɨɪɨɣ ɧɟɬ ɜɵɛɨɪɚ default, ɩɪɢ
ɜɧɟɫɟɧɢɢ ɢɡɦɟɧɟɧɢɣ ɜ ɩɪɨɝɪɚɦɦɭ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɩɪɢɹɬɧɨɫɬɹɦ, ɬɚɤ ɱɬɨ ɫɥɟɞɭɟɬ ɢɦɟɬɶ ɜɵ-
ɛɨɪ default, ɤɨɬɨɪɵɣ ɩɪɨɫɬɨ ɜɵɩɨɥɧɹɟɬ assert(false) (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 68 ɢ 90):
// ǚǻǰǯǾǺǻǰǱǯǰǸǳǰ: ǹǽǼǾǽǼǽǭǾȉȄǳǴ "return"
int Fun( Color c ) {
switch( c ) {
case Red: return 2;
case Green: return 0;
1. Компилируйте без замечаний при максимальном уровне предупреждений 17
Стр. 17
case Blue:
case Black: return 1;
}
}
// ǘǹǭǫȊ ǭǰǻǼǳȊ: ǺǻǰǯǾǺǻǰǱǯǰǸǳǰ ǾǼǽǻǫǸǰǸǹ

int Fun( Color c ) {
switch( c ) {
case Red: return 2;
case Green: return 0;
case Blue:
case Black: return 1;
// ǒǸǫȂǰǸǳǰ !"string" ǻǫǭǸǹ false:
default : assert (!"should never get here!");
return -1;
}
}
ɉɪɢɦɟɪ 6. “ɇɟɫɨɨɬɜɟɬɫɬɜɢɟ signed/unsigned”. Ɉɛɵɱɧɨ ɧɟ ɜɨɡɧɢɤɚɟɬ ɧɟɨɛɯɨɞɢɦɨɫɬɶ
ɫɪɚɜɧɢɜɚɬɶ ɢɥɢ ɩɪɢɫɜɚɢɜɚɬɶ ɱɢɫɥɚ ɫ ɪɚɡɧɵɦ ɬɢɩɨɦ ɡɧɚɤɨɜɨɫɬɢ. ɂɡɦɟɧɢɬɟ ɬɢɩɵ ɫɪɚɜɧɢɜɚɟɦɵɯ
ɩɟɪɟɦɟɧɧɵɯ ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɫɨɨɬɜɟɬɫɬɜɨɜɚɥɢ ɞɪɭɝ ɞɪɭɝɭ. ȼ ɤɪɚɣɧɟɦ ɫɥɭɱɚɟ, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ
ɹɜɧɵɦ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɬɢɩɨɜ. (Ʉɨɦɩɢɥɹɬɨɪ ɜɫɟ ɪɚɜɧɨ ɜɫɬɚɜɥɹɟɬ ɜ ɤɨɞ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ
ɢ ɩɪɟɞɭɩɪɟɠɞɚɟɬ ɢɦɟɧɧɨ ɨɛ ɷɬɨɦ, ɬɚɤ ɱɬɨ ɥɭɱɲɟ ɫɞɟɥɚɬɶ ɬɨ ɠɟ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ.)
Исключения
ɂɧɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɜɵɞɚɜɚɬɶ ɭɬɨɦɢɬɟɥɶɧɵɟ, ɚ ɩɨɪɨɣ ɢ ɩɪɨɫɬɨ ɥɨɠɧɵɟ ɩɪɟɞɭɩɪɟɠ-
ɞɟɧɢɹ, ɧɨ ɭ ɜɚɫ ɧɟɬ ɫɩɨɫɨɛɚ ɢɯ ɭɫɬɪɚɧɟɧɢɹ (ɢɥɢ ɬɚɤɨɣ ɫɩɨɫɨɛ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɧɟɪɟɚɥɶɧɨɣ ɢɥɢ
ɧɟɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɣ ɩɟɪɟɞɟɥɤɟ ɬɟɤɫɬɚ ɩɪɨɝɪɚɦɦɵ). ȼ ɬɚɤɢɯ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɩɨ ɪɟɲɟɧɢɸ ɜɫɟɣ
ɤɨɦɚɧɞɵ ɪɚɡɪɚɛɨɬɱɢɤɨɜ ɦɨɠɧɨ ɩɨɣɬɢ ɧɚ ɨɬɤɥɸɱɟɧɢɟ ɤɨɧɤɪɟɬɧɵɯ ɦɟɥɤɢɯ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ,
ɤɨɬɨɪɵɟ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟ ɧɟɫɭɬ ɧɢɤɚɤɨɣ ɨɫɨɛɨɣ ɢɧɮɨɪɦɚɰɢɢ ɢ ɹɜɥɹɸɬɫɹ ɧɟ ɛɨɥɟɟ, ɱɟɦ ɪɟ-
ɡɭɥɶɬɚɬɨɦ ɱɪɟɡɦɟɪɧɨɣ ɨɫɬɨɪɨɠɧɨɫɬɢ ɤɨɦɩɢɥɹɬɨɪɚ. Ɍɚɤɢɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ ɦɨɠɧɨ ɨɬɤɥɸɱɢɬɶ,
ɧɨ ɬɨɥɶɤɨ ɞɚɧɧɵɟ ɤɨɧɤɪɟɬɧɵɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ, ɚ ɧɟ ɜɫɟ, ɦɚɤɫɢɦɚɥɶɧɨ ɥɨɤɚɥɢɡɨɜɚɜ ɩɪɢ ɷɬɨɦ
ɨɛɥɚɫɬɶ ɨɬɤɥɸɱɟɧɢɹ ɢ ɫɨɩɪɨɜɨɞɢɜ ɟɟ ɹɫɧɵɦ ɢ ɩɨɞɪɨɛɧɵɦ ɤɨɦɦɟɧɬɚɪɢɟɦ, ɩɨɱɟɦɭ ɬɚɤɨɣ ɲɚɝ
ɧɟɨɛɯɨɞɢɦ.
Ссылки
[Meyers97] §48 • [Stroustrup94] §2.6.2
Стр. 18
2. Используйте автоматические системы
сборки программ
Резюме
ɇɚɠɢɦɚɣɬɟ ɧɚ ɨɞɧɭ (ɟɞɢɧɫɬɜɟɧɧɭɸ) ɤɧɨɩɤɭ: ɢɫɩɨɥɶɡɭɣɬɟ ɩɨɥɧɨɫɬɶɸ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɵɟ
(“ɜ ɨɞɧɨ ɞɟɣɫɬɜɢɟ”) ɫɢɫɬɟɦɵ, ɤɨɬɨɪɵɟ ɫɨɛɢɪɚɸɬ ɜɟɫɶ ɩɪɨɟɤɬ ɛɟɡ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɩɨɥɶɡɨɜɚɬɟɥɹ.
ɉɪɨɰɟɫɫ ɫɛɨɪɤɢ ɩɪɨɝɪɚɦɦɵ “ɜ ɨɞɧɨ ɞɟɣɫɬɜɢɟ” ɨɱɟɧɶ ɜɚɠɟɧ. Ɉɧ ɞɨɥɠɟɧ ɞɚɜɚɬɶ ɧɚɞɟɠɧɵɣ
ɢ ɜɨɫɩɪɨɢɡɜɨɞɢɦɵɣ ɪɟɡɭɥɶɬɚɬ ɬɪɚɧɫɥɹɰɢɢ ɜɚɲɢɯ ɢɫɯɨɞɧɵɯ ɮɚɣɥɨɜ ɜ ɪɚɫɩɪɨɫɬɪɚɧɹɟɦɵɣ ɩɚ-
ɤɟɬ. ɂɦɟɟɬɫɹ ɛɨɝɚɬɵɣ ɜɵɛɨɪ ɬɚɤɢɯ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɵɯ ɢɧɫɬɪɭɦɟɧɬɨɜ ɫɛɨɪɤɢ, ɬɚɤ ɱɬɨ ɧɟɬ
ɧɢɤɚɤɨɝɨ ɨɩɪɚɜɞɚɧɢɹ ɬɨɦɭ, ɱɬɨ ɜɵ ɢɯ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ. ȼɵɛɟɪɢɬɟ ɨɞɢɧ ɢɡ ɧɢɯ ɢ ɩɪɢɦɟɧɹɣɬɟ ɟɝɨ
ɜ ɫɜɨɟɣ ɪɚɛɨɬɟ.
Ɇɵ ɜɫɬɪɟɱɚɥɢɫɶ ɫ ɨɪɝɚɧɢɡɚɰɢɹɦɢ, ɝɞɟ ɩɨɞɨɛɧɨɟ ɬɪɟɛɨɜɚɧɢɟ ɢɝɧɨɪɢɪɨɜɚɥɨɫɶ. ɇɟɤɨɬɨɪɵɟ
ɩɨɥɚɝɚɸɬ, ɱɬɨ ɧɚɫɬɨɹɳɢɣ ɩɪɨɰɟɫɫ ɫɛɨɪɤɢ ɞɨɥɠɟɧ ɫɨɫɬɨɹɬɶ ɜ ɬɨɦ, ɱɬɨɛɵ ɩɨɳɟɥɤɚɬɶ ɦɵɲɶɸ
ɬɚɦ ɢ ɫɹɦ, ɡɚɩɭɫɬɢɬɶ ɩɚɪɭ ɭɬɢɥɢɬ ɞɥɹ ɪɟɝɢɫɬɪɚɰɢɢ ɫɟɪɜɟɪɨɜ COM/CORBA ɢ ɜɪɭɱɧɭɸ ɫɤɨɩɢ-
ɪɨɜɚɬɶ ɧɟɫɤɨɥɶɤɨ ɮɚɣɥɨɜ. ȼɪɹɞ ɥɢ ɭ ɜɚɫ ɟɫɬɶ ɥɢɲɧɟɟ ɜɪɟɦɹ ɢ ɷɧɟɪɝɢɹ, ɱɬɨɛɵ ɪɚɫɬɪɚɱɢɜɚɬɶ ɢɯ
ɧɚ ɬɨ, ɱɬɨ ɦɚɲɢɧɚ ɫɞɟɥɚɟɬ ɛɵɫɬɪɟɟ ɢ ɥɭɱɲɟ ɜɚɫ. ȼɚɦ ɧɭɠɧɚ ɧɚɞɟɠɧɚɹ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɚɹ
ɫɢɫɬɟɦɚ ɫɛɨɪɤɢ ɩɪɨɝɪɚɦɦɵ “ɜ ɨɞɧɨ ɞɟɣɫɬɜɢɟ”.
ɍɫɩɟɲɧɚɹ ɫɛɨɪɤɚ ɞɨɥɠɧɚ ɩɪɨɢɫɯɨɞɢɬɶ ɦɨɥɱɚ, ɛɟɡ ɤɚɤɢɯ ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 1). ɂɞɟɚɥɶɧɵɣ ɩɪɨɰɟɫɫ ɫɛɨɪɤɢ ɞɨɥɠɟɧ ɜɵɞɚɬɶ ɬɨɥɶɤɨ ɨɞɧɨ ɠɭɪɧɚɥɶɧɨɟ
ɫɨɨɛɳɟɧɢɟ: “ɋɛɨɪɤɚ ɭɫɩɟɲɧɨ ɡɚɜɟɪɲɟɧɚ”.
ȿɫɬɶ ɞɜɟ ɦɨɞɟɥɢ ɫɛɨɪɤɢ — ɢɧɤɪɟɦɟɧɬɧɚɹ ɢ ɩɨɥɧɚɹ. ɉɪɢ ɢɧɤɪɟɦɟɧɬɧɨɣ ɫɛɨɪɤɟ ɤɨɦɩɢɥɢɪɭɸɬɫɹ
ɬɨɥɶɤɨ ɬɟ ɮɚɣɥɵ, ɤɨɬɨɪɵɟ ɩɪɟɬɟɪɩɟɥɢ ɢɡɦɟɧɟɧɢɹ ɫɨ ɜɪɟɦɟɧɢ ɩɨɫɥɟɞɧɟɣ ɢɧɤɪɟɦɟɧɬɧɨɣ ɢɥɢ ɩɨɥɧɨɣ
ɫɛɨɪɤɢ. ɋɥɟɞɫɬɜɢɟ: ɜɬɨɪɚɹ ɢɡ ɞɜɭɯ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɢɧɤɪɟɦɟɧɬɧɵɯ ɫɛɨɪɨɤ ɧɟ ɞɨɥɠɧɚ ɩɟɪɟɡɚɩɢ-
ɫɵɜɚɬɶ ɧɢɤɚɤɢɟ ɮɚɣɥɵ. ȿɫɥɢ ɨɧɚ ɷɬɨ ɞɟɥɚɟɬ — ɩɨ ɜɫɟɣ ɜɢɞɢɦɨɫɬɢ, ɭ ɜɚɫ ɜ ɩɪɨɟɤɬɟ ɢɦɟɟɬɫɹ ɰɢɤɥɢ-
ɱɟɫɤɚɹ ɡɚɜɢɫɢɦɨɫɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 22), ɥɢɛɨ ɜɚɲɚ ɫɢɫɬɟɦɚ ɫɛɨɪɤɢ ɜɵɩɨɥɧɹɟɬ ɧɟɧɭɠɧɵɟ ɨɩɟ-
ɪɚɰɢɢ (ɧɚɩɪɢɦɟɪ, ɫɨɡɞɚɟɬ ɮɢɤɬɢɜɧɵɟ ɜɪɟɦɟɧɧɵɟ ɮɚɣɥɵ, ɱɬɨɛɵ ɡɚɬɟɦ ɩɪɨɫɬɨ ɭɞɚɥɢɬɶ ɢɯ).
ɉɪɨɟɤɬ ɦɨɠɟɬ ɢɦɟɬɶ ɧɟɫɤɨɥɶɤɨ ɜɢɞɨɜ ɩɨɥɧɨɣ ɫɛɨɪɤɢ. Ɋɚɫɫɦɨɬɪɢɬɟ ɜɨɡɦɨɠɧɨɫɬɶ ɩɚɪɚɦɟɬ-
ɪɢɡɚɰɢɢ ɩɪɨɰɟɫɫɚ ɫɛɨɪɤɢ ɩɪɢ ɩɨɦɨɳɢ ɬɚɤɢɯ ɜɚɠɧɵɯ ɩɚɪɚɦɟɬɪɨɜ, ɤɚɤ ɰɟɥɟɜɚɹ ɚɪɯɢɬɟɤɬɭɪɚ,
ɨɬɥɚɞɨɱɧɚɹ ɢɥɢ ɤɨɦɦɟɪɱɟɫɤɚɹ ɜɟɪɫɢɢ, ɜɢɞ ɩɚɤɟɬɚ (ɩɪɨɝɪɚɦɦɚ-ɢɧɫɬɚɥɥɹɬɨɪ ɢɥɢ ɩɪɨɫɬɨ ɧɚɛɨɪ
ɮɚɣɥɨɜ). Ɉɞɧɢ ɭɫɬɚɧɨɜɤɢ ɫɛɨɪɤɢ ɦɨɝɭɬ ɞɚɜɚɬɶ ɬɨɥɶɤɨ ɧɚɢɛɨɥɟɟ ɫɭɳɟɫɬɜɟɧɧɵɟ ɢɫɩɨɥɧɢɦɵɟ
ɢ ɛɢɛɥɢɨɬɟɱɧɵɟ ɮɚɣɥɵ, ɞɪɭɝɢɟ — ɞɨɛɚɜɥɹɬɶ ɤ ɧɢɦ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɮɚɣɥɵ, ɚ ɨɤɨɧɱɚɬɟɥɶɧɚɹ
ɫɛɨɪɤɚ — ɫɨɡɞɚɜɚɬɶ ɩɪɨɝɪɚɦɦɭ-ɢɧɫɬɚɥɥɹɬɨɪ, ɤɨɬɨɪɚɹ ɜɤɥɸɱɚɟɬ ɜ ɫɟɛɹ ɜɫɟ ɜɚɲɢ ɮɚɣɥɵ, ɮɚɣɥɵ
ɫɬɨɪɨɧɧɢɯ ɩɪɨɢɡɜɨɞɢɬɟɥɟɣ ɢ ɤɨɞ ɢɧɫɬɚɥɥɹɰɢɢ.
ɋɨ ɜɪɟɦɟɧɟɦ ɪɚɡɦɟɪ ɩɪɨɟɤɬɚ ɨɛɵɱɧɨ ɜɨɡɪɚɫɬɚɟɬ, ɪɚɫɬɟɬ ɢ ɫɬɨɢɦɨɫɬɶ ɨɬɤɚɡɚ ɨɬ ɚɜɬɨɦɚɬɢ-
ɡɢɪɨɜɚɧɧɨɣ ɫɢɫɬɟɦɵ ɫɛɨɪɤɢ. ȿɫɥɢ ɜɵ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɟɟ ɫ ɫɚɦɨɝɨ ɧɚɱɚɥɚ, ɜɵ ɬɟɪɹɟɬɟ ɜɪɟɦɹ ɢ
ɪɟɫɭɪɫɵ. ȼɫɟ ɪɚɜɧɨ ɫɨ ɜɪɟɦɟɧɟɦ ɩɨɬɪɟɛɧɨɫɬɶ ɜ ɬɚɤɨɣ ɫɢɫɬɟɦɟ ɫɬɚɧɟɬ ɧɟɩɪɟɨɞɨɥɢɦɨɣ, ɧɨ ɩɪɢ
ɷɬɨɦ ɜɵ ɨɤɚɠɟɬɟɫɶ ɩɨɞ ɝɨɪɚɡɞɨ ɛɨɥɶɲɢɦ ɞɚɜɥɟɧɢɟɦ, ɱɟɦ ɜ ɧɚɱɚɥɟ ɩɪɨɟɤɬɚ.
ȼ ɛɨɥɶɲɢɯ ɩɪɨɟɤɬɚɯ ɜɨɡɦɨɠɧɚ ɞɚɠɟ ɫɩɟɰɢɚɥɶɧɚɹ ɞɨɥɠɧɨɫɬɶ “ɯɨɡɹɢɧɚ ɫɛɨɪɤɢ”, ɤɨɬɨɪɵɣ
ɨɬɜɟɱɚɟɬ ɡɚ ɪɚɛɨɬɭ ɷɬɨɣ ɫɢɫɬɟɦɵ.
Ссылки
[Brooks95] §13, §19 • [Dewhurst03] §1 • [GnuMake] • [Stroustrup00] §9.1
2. Используйте автоматические системы сборки программ 19
Стр. 19
3. Используйте систему контроля версий
Резюме
Ʉɚɤ ɝɥɚɫɢɬ ɤɢɬɚɣɫɤɚɹ ɩɨɫɥɨɜɢɰɚ, ɩɥɨɯɢɟ ɱɟɪɧɢɥɚ ɥɭɱɲɟ ɯɨɪɨɲɟɣ ɩɚɦɹɬɢ: ɢɫɩɨɥɶɡɭɣɬɟ ɫɢɫ-
ɬɟɦɵ ɭɩɪɚɜɥɟɧɢɹ ɜɟɪɫɢɹɦɢ. ɇɟ ɨɫɬɚɜɥɹɣɬɟ ɮɚɣɥɵ ɛɟɡ ɩɪɢɫɦɨɬɪɚ ɧɚ ɞɨɥɝɢɣ ɫɪɨɤ. ɉɪɨɜɟɪɹɣɬɟ ɢɯ
ɜɫɹɤɢɣ ɪɚɡ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɨɛɧɨɜɥɟɧɧɵɟ ɦɨɞɭɥɢ ɩɪɨɯɨɞɹɬ ɬɟɫɬɵ ɧɚ ɪɚɛɨɬɨɫɩɨɫɨɛɧɨɫɬɶ. ɍɛɟɞɢ-
ɬɟɫɶ, ɱɬɨ ɜɧɟɫɟɧɧɵɟ ɨɛɧɨɜɥɟɧɢɹ ɧɟ ɩɪɟɩɹɬɫɬɜɭɸɬ ɤɨɪɪɟɤɬɧɨɣ ɫɛɨɪɤɟ ɩɪɨɝɪɚɦɦɵ.
ɉɪɚɤɬɢɱɟɫɤɢ ɜɫɟ ɧɟɬɪɢɜɢɚɥɶɧɵɟ ɩɪɨɟɤɬɵ ɬɪɟɛɭɸɬ ɤɨɦɚɧɞɧɨɣ ɪɚɛɨɬɵ ɢ/ɢɥɢ ɛɨɥɟɟ ɧɟɞɟɥɢ
ɪɚɛɨɱɟɝɨ ɜɪɟɦɟɧɢ. ȼ ɬɚɤɢɯ ɩɪɨɟɤɬɚɯ ɜɵ ɛɭɞɟɬɟ ɩɪɨɫɬɨ ɜɵɧɭɠɞɟɧɵ ɫɪɚɜɧɢɜɚɬɶ ɪɚɡɥɢɱɧɵɟ
ɜɟɪɫɢɢ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɮɚɣɥɚ ɞɥɹ ɜɵɹɫɧɟɧɢɹ ɬɨɝɨ, ɤɨɝɞɚ (ɢ/ɢɥɢ ɤɟɦ) ɛɵɥɢ ɜɧɟɫɟɧɵ ɬɟ ɢɥɢ
ɢɧɵɟ ɢɡɦɟɧɟɧɢɹ. ȼɵ ɛɭɞɟɬɟ ɜɵɧɭɠɞɟɧɵ ɤɨɧɬɪɨɥɢɪɨɜɚɬɶ ɢ ɪɭɤɨɜɨɞɢɬɶ ɜɧɟɫɟɧɢɟɦ ɢɡɦɟɧɟɧɢɣ
ɜ ɢɫɯɨɞɧɵɟ ɮɚɣɥɵ ɩɪɨɟɤɬɚ.
Ʉɨɝɞɚ ɧɚɞ ɩɪɨɟɤɬɨɦ ɪɚɛɨɬɚɸɬ ɧɟɫɤɨɥɶɤɨ ɪɚɡɪɚɛɨɬɱɢɤɨɜ, ɨɧɢ ɜɧɨɫɹɬ ɢɡɦɟɧɟɧɢɹ ɜ ɩɪɨɟɤɬ
ɩɚɪɚɥɥɟɥɶɧɨ, ɜɨɡɦɨɠɧɨ, ɨɞɧɨɜɪɟɦɟɧɧɨ ɜ ɪɚɡɧɵɟ ɱɚɫɬɢ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɮɚɣɥɚ. ȼɚɦ ɧɭɠɟɧ
ɢɧɫɬɪɭɦɟɧɬ, ɤɨɬɨɪɵɣ ɛɵ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɥ ɪɚɛɨɬɭ ɫ ɪɚɡɧɵɦɢ ɜɟɪɫɢɹɦɢ ɮɚɣɥɨɜ ɢ, ɜ ɨɩɪɟɞɟ-
ɥɟɧɧɵɯ ɫɥɭɱɚɹɯ, ɩɨɡɜɨɥɹɥ ɨɛɴɟɞɢɧɹɬɶ ɨɞɧɨɜɪɟɦɟɧɧɨ ɜɧɟɫɟɧɧɵɟ ɢɡɦɟɧɟɧɢɹ. ɋɢɫɬɟɦɚ ɭɩɪɚɜɥɟ-
ɧɢɹ ɜɟɪɫɢɹɦɢ (version control system, VCS) ɚɜɬɨɦɚɬɢɡɢɪɭɟɬ ɜɫɟ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ, ɩɪɢ-
ɱɟɦ ɜɵɩɨɥɧɹɹ ɢɯ ɛɨɥɟɟ ɛɵɫɬɪɨ ɢ ɤɨɪɪɟɤɬɧɨ, ɱɟɦ ɜɵ ɛɵ ɦɨɝɥɢ ɫɞɟɥɚɬɶ ɷɬɨ ɜɪɭɱɧɭɸ. ɂ ɜɪɹɞ ɥɢ
ɭ ɜɚɫ ɟɫɬɶ ɥɢɲɧɟɟ ɜɪɟɦɹ ɧɚ ɢɝɪɵ ɜ ɚɞɦɢɧɢɫɬɪɚɬɨɪɚ — ɭ ɜɚɫ ɯɜɚɬɚɟɬ ɢ ɫɜɨɟɣ ɪɚɛɨɬɵ ɩɨ ɪɚɡɪɚ-
ɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ.
Ⱦɚɠɟ ɟɞɢɧɫɬɜɟɧɧɵɣ ɩɪɨɝɪɚɦɦɢɫɬ ɧɟɪɟɞɤɨ ɜɵɧɭɠɞɟɧ ɜɵɹɫɧɹɬɶ, ɤɚɤ ɢ ɤɨɝɞɚ ɜ ɩɪɨɝɪɚɦɦɭ
ɩɪɨɧɢɤɥɚ ɬɚ ɢɥɢ ɢɧɚɹ ɨɲɢɛɤɚ. VCS, ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɨɬɫɥɟɠɢɜɚɹ ɢɫɬɨɪɢɸ ɢɡɦɟɧɟɧɢɣ ɤɚɠɞɨɝɨ
ɮɚɣɥɚ, ɩɨɡɜɨɥɹɟɬ ɜɚɦ “ɩɟɪɟɜɟɫɬɢ ɫɬɪɟɥɤɢ ɱɚɫɨɜ ɧɚɡɚɞ” ɢ ɨɬɜɟɬɢɬɶ ɧɟ ɬɨɥɶɤɨ ɧɚ ɜɨɩɪɨɫ, ɤɚɤ
ɢɦɟɧɧɨ ɜɵɝɥɹɞɟɥ ɮɚɣɥ ɪɚɧɶɲɟ, ɧɨ ɢ ɤɨɝɞɚ ɷɬɨ ɛɵɥɨ.
ɇɟ ɩɨɪɬɢɬɟ ɫɛɨɪɤɭ. Ʉɨɞ, ɫɨɯɪɚɧɟɧɧɵɣ VCS, ɜɫɟɝɞɚ ɞɨɥɠɟɧ ɭɫɩɟɲɧɨ ɫɨɛɢɪɚɬɶɫɹ.
Ɉɝɪɨɦɧɨɟ ɪɚɡɧɨɨɛɪɚɡɢɟ ɢɧɫɬɪɭɦɟɧɬɚɪɢɹ ɞɚɧɧɨɝɨ ɬɢɩɚ ɧɟ ɩɨɡɜɨɥɹɟɬ ɨɩɪɚɜɞɚɬɶ ɜɚɫ, ɟɫɥɢ ɜɵ ɧɟ
ɢɫɩɨɥɶɡɭɟɬɟ ɨɞɧɭ ɢɡ ɷɬɢɯ ɫɢɫɬɟɦ. ɇɚɢɛɨɥɟɟ ɞɟɲɟɜɨɣ ɢ ɩɨɩɭɥɹɪɧɨɣ ɹɜɥɹɟɬɫɹ CVS (ɫɦ. ɫɫɵɥɤɢ). ɗɬɨ
ɝɢɛɤɢɣ ɢɧɫɬɪɭɦɟɧɬ ɫ ɜɨɡɦɨɠɧɨɫɬɶɸ ɨɛɪɚɳɟɧɢɹ ɩɨ TCP/IP, ɜɨɡɦɨɠɧɨɫɬɶɸ ɨɛɟɫɩɟɱɟɧɢɹ ɩɨɜɵɲɟɧ-
ɧɵɯ ɦɟɪ ɛɟɡɨɩɚɫɧɨɫɬɢ (ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɩɪɨɬɨɤɨɥɚ ssh), ɜɨɡɦɨɠɧɨɫɬɶɸ ɚɞɦɢɧɢɫɬɪɢɪɨɜɚɧɢɹ ɫ
ɩɪɢɦɟɧɟɧɢɟɦ ɫɰɟɧɚɪɢɟɜ ɢ ɞɚɠɟ ɝɪɚɮɢɱɟɫɤɢɦ ɢɧɬɟɪɮɟɣɫɨɦ. Ɇɧɨɝɢɟ ɞɪɭɝɢɟ ɩɪɨɞɭɤɬɵ VCS ɪɚɫ-
ɫɦɚɬɪɢɜɚɸɬ CVS ɜ ɤɚɱɟɫɬɜɟ ɫɬɚɧɞɚɪɬɚ ɥɢɛɨ ɫɬɪɨɹɬ ɧɨɜɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɧɚ ɟɟ ɨɫɧɨɜɟ.
ɉɪɨɟɤɬ, ɧɚɞ ɤɨɬɨɪɵɦ ɪɚɛɨɬɚɟɬ ɨɞɢɧ ɩɪɨɝɪɚɦɦɢɫɬ, ɩɪɢɱɟɦ ɧɟ ɛɨɥɟɟ ɧɟɞɟɥɢ, ɜɟɪɨɹɬɧɨ, ɜ
ɫɨɫɬɨɹɧɢɢ ɜɵɠɢɬɶ ɢ ɛɟɡ ɩɪɢɦɟɧɟɧɢɹ VCS.
Ссылки
[BetterSCM] • [Brooks95] §11, §13 • [CVS]
Стр. 20
4. Одна голова хорошо, а две — лучше
Резюме
Ɋɟɝɭɥɹɪɧɨ ɩɪɨɫɦɚɬɪɢɜɚɣɬɟ ɤɨɞ ɜɫɟɣ ɤɨɦɚɧɞɨɣ. ɑɟɦ ɛɨɥɶɲɟ ɝɥɚɡ — ɬɟɦ ɜɵɲɟ ɤɚɱɟɫɬɜɨ ɤɨ-
ɞɚ. ɉɨɤɚɠɢɬɟ ɜɚɲ ɤɨɞ ɞɪɭɝɢɦ ɢ ɩɨɡɧɚɤɨɦɶɬɟɫɶ ɫ ɢɯ ɤɨɞɨɦ — ɷɬɨ ɩɪɢɧɟɫɟɬ ɩɨɥɶɡɭ ɜɫɟɦ.
Ɋɟɝɭɥɹɪɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɞɪɭɝɢɦɢ ɱɥɟɧɚɦɢ ɤɨɦɚɧɞɵ ɩɪɢɧɨɫɢɬ ɫɜɨɢ ɩɥɨɞɵ.
• ɉɨɜɵɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɤɨɞɚ ɩɪɢ ɞɨɛɪɨɠɟɥɚɬɟɥɶɧɨɣ ɤɪɢɬɢɤɟ ɞɪɭɝɢɦɢ.
• ȼɵɹɜɥɟɧɢɟ ɨɲɢɛɨɤ, ɧɟɩɟɪɟɧɨɫɢɦɨɝɨ ɤɨɞɚ (ɟɫɥɢ ɷɬɨ ɜɚɠɧɨ) ɢ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɩɪɨɛɥɟɦ,
ɫɜɹɡɚɧɧɵɯ ɫ ɦɚɫɲɬɚɛɢɪɨɜɚɧɢɟɦ ɩɪɨɟɤɬɚ.
• ɍɥɭɱɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɞɢɡɚɣɧɚ ɢ ɪɟɚɥɢɡɚɰɢɢ ɩɭɬɟɦ ɨɛɦɟɧɚ ɢɞɟɹɦɢ.
• Ȼɵɫɬɪɨɟ ɨɛɭɱɟɧɢɟ ɧɨɜɵɯ ɱɥɟɧɨɜ ɤɨɦɚɧɞɵ.
• Ɋɚɡɪɚɛɨɬɤɚ ɨɛɳɢɯ ɩɪɢɧɰɢɩɨɜ ɜ ɤɨɦɚɧɞɟ.
• ɉɨɜɵɲɟɧɢɟ ɭɪɨɜɧɹ ɦɟɪɢɬɨɤɪɚɬɢɢ1, ɞɨɜɟɪɢɹ, ɩɪɨɮɟɫɫɢɨɧɚɥɶɧɨɣ ɝɨɪɞɨɫɬɢ ɢ ɫɨɬɪɭɞɧɢ-
ɱɟɫɬɜɚ ɜ ɤɨɦɚɧɞɟ.
ȼɨ ɦɧɨɝɢɯ ɮɢɪɦɚɯ ɟɳɟ ɧɟ ɫɬɨɥɶ ɩɨɩɭɥɹɪɧɵ, ɤɚɤ ɯɨɬɟɥɨɫɶ ɛɵ, ɜɨɡɧɚɝɪɚɠɞɟɧɢɹ ɡɚ ɤɚɱɟɫɬɜɨ
ɤɨɞɚ, ɚ ɬɚɤɠɟ ɤɚɤɢɟ-ɥɢɛɨ ɜɥɨɠɟɧɢɹ ɜɪɟɦɟɧɢ ɢɥɢ ɫɪɟɞɫɬɜ ɜ ɟɝɨ ɩɨɜɵɲɟɧɢɟ. ɇɚɞɟɠɞ ɧɚ ɤɚɪɞɢ-
ɧɚɥɶɧɨɟ ɢɡɦɟɧɟɧɢɟ ɫɢɬɭɚɰɢɢ ɦɚɥɨ, ɧɨ ɜɫɟ ɠɟ ɢɡɦɟɧɟɧɢɹ ɜ ɷɬɨɣ ɨɛɥɚɫɬɢ, ɩɭɫɬɶ ɦɟɞɥɟɧɧɨ, ɧɨ
ɩɪɨɢɫɯɨɞɹɬ; ɜ ɱɚɫɬɧɨɫɬɢ, ɷɬɨ ɫɜɹɡɚɧɨ ɫ ɜɨɩɪɨɫɚɦɢ ɧɚɞɟɠɧɨɫɬɢ ɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɩɪɨɝɪɚɦɦɧɨɝɨ
ɨɛɟɫɩɟɱɟɧɢɹ. Ʉɨɥɥɟɤɬɢɜɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɩɨɦɨɝɚɟɬ ɜ ɪɟɲɟɧɢɢ ɷɬɢɯ ɜɨɩɪɨɫɨɜ, ɜ ɞɨ-
ɩɨɥɧɟɧɢɟ ɤ ɬɨɦɭ, ɱɬɨ ɷɬɨ ɨɬɥɢɱɧɵɣ ɢ ɤ ɬɨɦɭ ɠɟ ɛɟɫɩɥɚɬɧɵɣ ɦɟɬɨɞ ɨɛɭɱɟɧɢɹ ɫɨɬɪɭɞɧɢɤɨɜ.
Ⱦɚɠɟ ɟɫɥɢ ɜɚɲ ɪɚɛɨɬɨɞɚɬɟɥɶ ɧɟ ɧɚɦɟɪɟɧ ɡɚɛɨɬɢɬɶɫɹ ɨ ɪɟɰɟɧɡɢɪɨɜɚɧɢɢ ɤɨɞɚ, ɩɨɫɬɚɪɚɣɬɟɫɶ
ɞɨɧɟɫɬɢ ɦɵɫɥɶ ɨ ɟɝɨ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɞɨ ɦɟɧɟɞɠɟɪɨɜ (ɦɚɥɟɧɶɤɚɹ ɩɨɞɫɤɚɡɤɚ: ɩɨɤɚɠɢɬɟ ɢɦ ɷɬɭ
ɤɧɢɝɭ), ɢ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɨɪɝɚɧɢɡɭɣɬɟ ɬɚɤɨɣ ɨɛɦɟɧ ɨɩɵɬɨɦ. Ɂɚɬɪɚɱɟɧɧɨɟ ɧɚ ɷɬɨ ɜɪɟɦɹ ɨɤɭɩɢɬ-
ɫɹ ɫɬɨɪɢɰɟɣ. ɋɞɟɥɚɣɬɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɨɛɹɡɚɬɟɥɶɧɨɣ ɱɚɫɬɶɸ ɰɢɤɥɚ ɪɚɡɪɚɛɨɬɤɢ ɩɪɨ-
ɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ ɜ ɜɚɲɟɣ ɤɨɦɚɧɞɟ.
Ʌɭɱɲɢɟ ɪɟɡɭɥɶɬɚɬɵ ɞɚɟɬ ɨɩɟɪɚɬɢɜɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ, ɪɚɡɪɚɛɚɬɵɜɚɟɦɨɝɨ ɜ ɧɚɫɬɨɹ-
ɳɢɣ ɦɨɦɟɧɬ. Ⱦɥɹ ɷɬɨɝɨ ɧɟ ɬɪɟɛɭɟɬɫɹ ɧɢɤɚɤɨɝɨ ɮɨɪɦɚɥɢɡɦɚ — ɞɨɫɬɚɬɨɱɧɨ ɩɪɨɫɬɨɣ ɷɥɟɤɬɪɨɧ-
ɧɨɣ ɩɨɱɬɵ. ɉɪɢ ɬɚɤɨɣ ɨɪɝɚɧɢɡɚɰɢɢ ɪɚɛɨɬɵ ɥɟɝɱɟ ɨɬɫɥɟɠɢɜɚɬɶ ɜɚɲɢ ɫɨɛɫɬɜɟɧɧɵɟ ɞɟɣɫɬɜɢɹ ɢ
ɢɡɛɟɝɚɬɶ ɞɭɛɥɢɪɨɜɚɧɢɹ.
Ʉɨɝɞɚ ɜɵ ɪɚɛɨɬɚɟɬɟ ɫ ɱɭɠɢɦ ɤɨɞɨɦ, ɡɚɱɚɫɬɭɸ ɭɞɨɛɧɨ ɢɦɟɬɶ ɩɨɞ ɪɭɤɨɣ ɫɩɢɫɨɤ ɬɨɝɨ, ɧɚ ɱɬɨ
ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɨɛɪɚɳɚɬɶ ɜɧɢɦɚɧɢɟ. Ɇɵ ɫɤɪɨɦɧɨ ɩɪɟɞɥɚɝɚɟɦ ɜ ɤɚɱɟɫɬɜɟ ɜɚɪɢɚɧɬɚ ɬɚɤɨɝɨ ɫɩɢ-
ɫɤɚ ɨɝɥɚɜɥɟɧɢɟ ɞɚɧɧɨɣ ɤɧɢɝɢ.
Ɇɵ ɡɧɚɟɦ, ɱɬɨ ɱɢɬɚɟɦ ɩɪɨɩɨɜɟɞɶ, ɧɨ ɦɵ ɞɨɥɠɧɵ ɛɵɥɢ ɫɤɚɡɚɬɶ ɷɬɨ ɜɫɥɭɯ. Ⱦɚ, ɜɚɲɟ ɷɝɨ
ɦɨɠɟɬ ɧɟɧɚɜɢɞɟɬɶ ɩɨɤɚɡɵɜɚɬɶ ɫɜɨɢ ɢɫɯɨɞɧɵɟ ɬɟɤɫɬɵ ɞɥɹ ɜɫɟɨɛɳɟɣ ɤɪɢɬɢɤɢ, ɧɨ ɩɨɜɟɪɶɬɟ, ɦɚ-
ɥɟɧɶɤɨɦɭ ɝɟɧɢɚɥɶɧɨɦɭ ɩɪɨɝɪɚɦɦɢɫɬɭ ɜɧɭɬɪɢ ɜɚɫ ɩɨ ɞɭɲɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɟɝɨ ɤɨɞɚ, ɩɨɬɨɦɭ
ɱɬɨ ɜ ɪɟɡɭɥɶɬɚɬɟ ɨɧ ɫɦɨɠɟɬ ɩɢɫɚɬɶ ɟɳɟ ɛɨɥɟɟ ɬɚɥɚɧɬɥɢɜɵɟ ɩɪɨɝɪɚɦɦɵ.
Ссылки
[Constantine95] §10, §22, §33 • [McConnell93] §24 • [MozillaCRFAQ]
1
ɋɢɫɬɟɦɚ, ɩɪɢ ɤɨɬɨɪɨɣ ɩɨɥɨɠɟɧɢɟ ɱɟɥɨɜɟɤɚ ɜ ɨɛɳɟɫɬɜɟ ɨɩɪɟɞɟɥɹɟɬɫɹ ɟɝɨ ɫɩɨɫɨɛɧɨɫɬɹɦɢ. — ɉɪɢɦ. ɩɟɪɟɜ.
4. Одна голова хорошо, а две — лучше 21
Стр. 21
Стр. 22
Стиль проектирования
Ⱦɭɪɚɤɢ ɢɝɧɨɪɢɪɭɸɬ ɫɥɨɠɧɨɫɬɢ. ɉɪɚɝɦɚɬɢɤɢ ɬɟɪɩɹɬ ɢɯ. ɇɟɤɨ-
ɬɨɪɵɟ ɭɯɢɬɪɹɸɬɫɹ ɢɯ ɢɡɛɟɝɚɬɶ. ɂ ɬɨɥɶɤɨ ɝɟɧɢɢ ɭɫɬɪɚɧɹɸɬ ɢɯ.
— Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis)
ə ɬɚɤɠɟ ɡɧɚɥ, ɧɨ ɡɚɛɵɥ ɚɮɨɪɢɡɦ ɏɨɚɪɚ ɨ ɬɨɦ, ɱɬɨ ɩɪɟɠɞɟ-

ɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ — ɤɨɪɟɧɶ ɜɫɟɯ ɡɨɥ ɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ.
— Ⱦɨɧɚɥɶɞ Ʉɧɭɬ (Donald Knuth),
The Errors of TeX [Knuth89]
Ɉɱɟɧɶ ɫɥɨɠɧɨ ɨɬɞɟɥɢɬɶ ɫɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɨɬ ɫɬɢɥɹ ɤɨɞɢɪɨɜɚɧɢɹ. Ɇɵ ɩɨɩɵɬɚɥɢɫɶ ɩɨ-

ɦɟɫɬɢɬɶ ɜ ɨɱɟɪɟɞɧɨɦ ɪɚɡɞɟɥɟ ɬɟ ɜɨɩɪɨɫɵ, ɤɨɬɨɪɵɟ ɨɛɵɱɧɨ ɩɪɨɹɜɥɹɸɬɫɹ, ɤɨɝɞɚ ɜɵ ɧɚɱɢɧɚɟɬɟ
ɩɢɫɚɬɶ ɪɟɚɥɶɧɵɣ ɤɨɞ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɜɧɢɦɚɧɢɟ ɭɞɟɥɹɟɬɫɹ ɩɪɢɧɰɢɩɚɦ ɢ ɩɪɚɤɬɢɱɟɫɤɢɦ ɜɨɩɪɨɫɚɦ, ɨɛɥɚɫɬɶ ɩɪɢɦɟ-
ɧɟɧɢɹ ɤɨɬɨɪɵɯ ɛɨɥɶɲɟ, ɱɟɦ ɩɪɨɫɬɨ ɨɬɞɟɥɶɧɵɣ ɤɥɚɫɫ ɢɥɢ ɮɭɧɤɰɢɹ. Ʉɥɚɫɫɢɱɟɫɤɢɟ ɩɪɢɦɟɪɵ —
ɛɚɥɚɧɫ ɦɟɠɞɭ ɩɪɨɫɬɨɬɨɣ ɢ ɹɫɧɨɫɬɶɸ (ɪɟɤɨɦɟɧɞɚɰɢɹ 6), ɢɡɛɟɠɚɧɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢ-
ɡɚɰɢɢ (ɪɟɤɨɦɟɧɞɚɰɢɹ 8) ɢ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɪɟɤɨɦɟɧɞɚɰɢɹ 9). ɗɬɢ ɪɟɤɨɦɟɧɞɚɰɢɢ ɩɪɢɦɟɧɢɦɵ ɧɟ
ɬɨɥɶɤɨ ɧɚ ɭɪɨɜɧɟ ɤɨɞɢɪɨɜɚɧɢɹ ɨɬɞɟɥɶɧɨɣ ɮɭɧɤɰɢɢ, ɧɨ ɢ ɤ ɛɨɥɶɲɢɦ ɨɛɥɚɫɬɹɦ — ɩɪɨɟɤɬɢɪɨ-
ɜɚɧɢɸ ɤɥɚɫɫɨɜ ɢ ɦɨɞɭɥɟɣ ɢɥɢ ɤ ɪɟɲɟɧɢɹɦ ɫ ɞɚɥɟɤɨ ɢɞɭɳɢɦɢ ɩɨɫɥɟɞɫɬɜɢɹɦɢ ɩɨ ɩɨɜɨɞɭ ɚɪɯɢ-
ɬɟɤɬɭɪɵ ɩɪɢɥɨɠɟɧɢɣ. (Ɉɧɢ ɩɪɢɦɟɧɢɦɵ ɬɚɤɠɟ ɞɥɹ ɜɫɟɯ ɩɪɨɝɪɚɦɦɢɫɬɨɜ. ȿɫɥɢ ɜɵ ɫɱɢɬɚɟɬɟ
ɢɧɚɱɟ — ɟɳɟ ɪɚɡ ɩɪɨɱɬɢɬɟ ɩɪɢɜɟɞɟɧɧɭɸ ɜɵɲɟ ɰɢɬɚɬɭ Ʉɧɭɬɚ ɢ ɞɚɠɟ ɡɚɭɱɢɬɟ ɟɟ ɧɚ ɩɚɦɹɬɶ.)
Ɇɧɨɝɢɟ ɢɡ ɩɪɨɱɢɯ ɪɟɤɨɦɟɧɞɚɰɢɣ ɷɬɨɝɨ ɢ ɫɥɟɞɭɸɳɟɝɨ ɪɚɡɞɟɥɨɜ ɢɦɟɸɬ ɞɟɥɨ ɫ ɭɩɪɚɜɥɟɧɢɟɦ
ɡɚɜɢɫɢɦɨɫɬɹɦɢ — ɤɪɚɟɭɝɨɥɶɧɵɦ ɤɚɦɧɟɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ ɢ ɱɚɫɬɨ
ɩɨɜɬɨɪɹɸɳɟɣɫɹ ɜ ɞɚɧɧɨɣ ɤɧɢɝɟ ɬɟɦɨɣ. Ɉɫɬɚɧɨɜɢɬɟɫɶ ɢ ɡɚɞɭɦɚɣɬɟɫɶ ɧɚɞ ɩɪɨɢɡɜɨɥɶɧɨɣ ɦɟɬɨ-
ɞɢɤɨɣ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ — ɥɸɛɨɣ ɯɨɪɨɲɟɣ ɦɟɬɨɞɢɤɨɣ. Ʉɚɤɭɸ ɛɵ
ɦɟɬɨɞɢɤɭ ɜɵ ɧɢ ɜɵɛɪɚɥɢ, ɬɚɤ ɢɥɢ ɢɧɚɱɟ ɜɵ ɫɬɨɥɤɧɟɬɟɫɶ ɫ ɨɫɥɚɛɥɟɧɢɟɦ ɡɚɜɢɫɢɦɨɫɬɟɣ. ɇɚɫɥɟ-
ɞɨɜɚɧɢɟ? Ɋɚɡɪɚɛɚɬɵɜɚɟɦɵɣ ɤɨɞ ɞɨɥɠɟɧ ɞɟɥɚɬɶ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɤɚɤ ɦɨɠɧɨ ɦɟɧɟɟ ɡɚɜɢɫɢ-
ɦɵɦ ɨɬ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. Ɇɢɧɢɦɢɡɚɰɢɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɝɥɨɛɚɥɶɧɵɯ ɩɟɪɟɦɟɧɧɵɯ? ɋɧɢɠɚɟɬ
ɞɚɥɶɧɨɞɟɣɫɬɜɭɸɳɢɟ ɡɚɜɢɫɢɦɨɫɬɢ, ɨɫɭɳɟɫɬɜɥɹɟɦɵɟ ɩɨɫɪɟɞɫɬɜɨɦ ɲɢɪɨɤɨ ɜɢɞɢɦɵɯ ɪɚɡɧɵɦ
ɱɚɫɬɹɦ ɩɪɨɝɪɚɦɦɵ ɞɚɧɧɵɯ. Ⱥɛɫɬɪɚɤɰɢɹ? ɍɫɬɪɚɧɹɟɬ ɡɚɜɢɫɢɦɨɫɬɢ ɦɟɠɞɭ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ
ɭɩɪɚɜɥɹɟɬ ɤɨɧɰɟɩɰɢɹɦɢ, ɢ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ ɢɯ ɪɟɚɥɢɡɭɟɬ. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ? Ⱦɟɥɚɟɬ ɤɨɞ
ɤɥɢɟɧɬɚ ɦɟɧɟɟ ɡɚɜɢɫɢɦɵɦ ɨɬ ɞɟɬɚɥɟɣ ɪɟɚɥɢɡɚɰɢɢ. Ɂɚɛɨɬɚ ɨɛ ɭɩɪɚɜɥɟɧɢɢ ɡɚɜɢɫɢɦɨɫɬɹɦɢ ɨɬɪɚ-
ɠɚɟɬɫɹ ɜ ɭɫɬɪɚɧɟɧɢɢ ɫɨɜɦɟɫɬɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɫɨɫɬɨɹɧɢɹ (ɪɟɤɨɦɟɧɞɚɰɢɹ 10), ɩɪɢɦɟɧɟɧɢɢ
ɫɨɤɪɵɬɢɹ ɢɧɮɨɪɦɚɰɢɢ (ɪɟɤɨɦɟɧɞɚɰɢɹ 11) ɢ ɩɪɨɱɟɦ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɫɚɦɨɣ ɜɚɠɧɨɣ ɧɚɦ ɤɚɠɟɬɫɹ ɪɟɤɨɦɟɧɞɚɰɢɹ 6: “ Ƚɥɚɜɧɨɟ — ɤɨɪɪɟɤɬɧɨɫɬɶ,
ɩɪɨɫɬɨɬɚ ɢ ɹɫɧɨɫɬɶ”.
Стр. 23
5. Один объект — одна задача
Резюме
Ʉɨɧɰɟɧɬɪɢɪɭɣɬɟɫɶ ɨɞɧɨɜɪɟɦɟɧɧɨ ɬɨɥɶɤɨ ɧɚ ɨɞɧɨɣ ɩɪɨɛɥɟɦɟ. Ʉɚɠɞɵɣ ɨɛɴɟɤɬ (ɩɟɪɟɦɟɧɧɚɹ,
ɤɥɚɫɫ, ɮɭɧɤɰɢɹ, ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɦɨɞɭɥɶ, ɛɢɛɥɢɨɬɟɤɚ) ɞɨɥɠɧɵ ɪɟɲɚɬɶ ɨɞɧɭ ɬɨɱɧɨ ɩɨɫɬɚɜ-
ɥɟɧɧɭɸ ɡɚɞɚɱɭ. ɋ ɪɨɫɬɨɦ ɨɛɴɟɤɬɨɜ, ɟɫɬɟɫɬɜɟɧɧɨ, ɭɜɟɥɢɱɢɜɚɟɬɫɹ ɨɛɥɚɫɬɶ ɢɯ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɢ,
ɧɨ ɨɧɢ ɧɟ ɞɨɥɠɧɵ ɨɬɤɥɨɧɹɬɶɫɹ ɨɬ ɫɜɨɟɝɨ ɩɪɟɞɧɚɡɧɚɱɟɧɢɹ.
ɏɨɪɨɲɚɹ ɢɞɟɹ, ɛɭɞɭɱɢ ɜɵɫɤɚɡɚɧɧɨɣ ɜɫɥɭɯ, ɞɨɥɠɧɚ ɛɵɬɶ ɩɨɹɫɧɟɧɚ ɨɞɧɢɦ ɩɪɟɞɥɨɠɟɧɢɟɦ.
Ⱥɧɚɥɨɝɢɱɧɨ, ɤɚɠɞɚɹ ɫɭɳɧɨɫɬɶ ɜ ɩɪɨɝɪɚɦɦɟ ɞɨɥɠɧɚ ɢɦɟɬɶ ɨɞɧɨ ɹɫɧɨɟ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ.
Ɉɛɴɟɤɬ ɫ ɪɚɡɧɨɪɨɞɧɵɦɢ ɩɪɟɞɧɚɡɧɚɱɟɧɢɹɦɢ ɨɛɵɱɧɨ ɧɟɫɨɪɚɡɦɟɪɧɨ ɬɪɭɞɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ, ɩɨ-
ɫɤɨɥɶɤɭ ɨɧ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɧɟɱɬɨ ɛɨɥɶɲɟɟ, ɱɟɦ ɩɪɨɫɬɨ ɫɭɦɦɭ ɪɟɲɟɧɢɣ, ɫɥɨɠɧɨɫɬɟɣ ɢ ɨɲɢɛɨɤ
ɫɨɫɬɚɜɥɹɸɳɢɯ ɟɝɨ ɱɚɫɬɟɣ. Ɍɚɤɨɣ ɨɛɴɟɤɬ ɛɨɥɶɲɟ ɩɨ ɪɚɡɦɟɪɭ (ɡɚɱɚɫɬɭɸ ɛɟɡ ɨɫɨɛɵɯ ɧɚ ɬɨ ɩɪɢɱɢɧ) ɢ
ɫɥɨɠɧɟɟ ɜ ɩɪɢɦɟɧɟɧɢɢ ɢ ɩɨɜɬɨɪɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ. Ɂɚɱɚɫɬɭɸ ɬɚɤɢɟ ɨɛɴɟɤɬɵ ɢɦɟɸɬ ɜɟɫɶɦɚ ɭɛɨɝɢɣ
ɢɧɬɟɪɮɟɣɫ ɞɥɹ ɤɚɠɞɨɝɨ ɢɡ ɫɜɨɢɯ ɨɬɞɟɥɶɧɵɯ ɩɪɟɞɧɚɡɧɚɱɟɧɢɣ, ɩɨɫɤɨɥɶɤɭ ɱɚɫɬɢɱɧɨɟ ɩɟɪɟɤɪɵɬɢɟ ɪɚɡ-
ɧɵɯ ɨɛɥɚɫɬɟɣ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɩɪɢɜɨɞɢɬ ɤ ɧɟɜɨɡɦɨɠɧɨɫɬɢ ɱɟɬɤɨɣ ɪɟɚɥɢɡɚɰɢɢ ɜ ɤɚɠɞɨɣ ɢɡ ɧɢɯ.
Ɉɛɴɟɤɬɵ ɫ ɪɚɡɧɨɪɨɞɧɵɦɢ ɮɭɧɤɰɢɹɦɢ ɨɛɵɱɧɨ ɬɪɭɞɧɵ ɞɥɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɢ ɪɟɚɥɢɡɚɰɢɢ.
“Ɇɧɨɠɟɫɬɜɟɧɧɚɹ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ” ɡɚɱɚɫɬɭɸ ɩɪɢɜɨɞɢɬ ɤ ɬɨɦɭ, ɱɬɨ ɤɨɥɢɱɟɫɬɜɨ ɜɨɡɦɨɠɧɵɯ ɜɚ-
ɪɢɚɧɬɨɜ ɩɨɜɟɞɟɧɢɹ ɢ ɫɨɫɬɨɹɧɢɹ ɨɛɴɟɤɬɨɜ ɪɚɡɪɚɫɬɚɟɬɫɹ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫ ɡɚɤɨɧɚɦɢ ɤɨɦɛɢɧɚɬɨ-
ɪɢɤɢ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɟɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɪɨɬɤɢɟ ɮɭɧɤɰɢɢ ɫ ɱɟɬɤɨ ɭɤɚɡɚɧɧɵɦ ɟɞɢɧɫɬɜɟɧɧɵɦ
ɩɪɟɞɧɚɡɧɚɱɟɧɢɟɦ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 39), ɦɚɥɟɧɶɤɢɟ ɤɥɚɫɫɵ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ ɞɥɹ ɪɟ-
ɲɟɧɢɹ ɨɞɧɨɣ ɤɨɧɤɪɟɬɧɨɣ ɡɚɞɚɱɢ, ɢ ɤɨɦɩɚɤɬɧɵɟ ɦɨɞɭɥɢ ɫ ɱɟɬɤɨ ɨɱɟɪɱɟɧɧɵɦɢ ɝɪɚɧɢɰɚɦɢ.
Ⱥɛɫɬɪɚɤɰɢɢ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɫɬɪɨɢɬɶ ɢɡ ɦɟɧɶɲɢɯ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɚɛ-
ɫɬɪɚɤɰɢɣ. ɂɡɛɟɝɚɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɧɟɫɤɨɥɶɤɢɯ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɚɛɫɬɪɚɤɰɢɣ ɜ ɛɨɥɶɲɨɣ ɧɢɡɤɨ-
ɭɪɨɜɧɟɜɵɣ ɤɨɧɝɥɨɦɟɪɚɬ. Ɋɟɚɥɢɡɚɰɢɹ ɫɥɨɠɧɨɝɨ ɩɨɜɟɞɟɧɢɹ ɢɡ ɧɚɛɨɪɚ ɩɪɨɫɬɵɯ ɫɭɳɟɫɬɜɟɧɧɨ
ɥɟɝɱɟ ɪɟɲɟɧɢɹ ɨɛɪɚɬɧɨɣ ɡɚɞɚɱɢ.
Примеры
ɉɪɢɦɟɪ 1. realloc. ȼ ɫɬɚɧɞɚɪɬɟ C ɮɭɧɤɰɢɹ realloc ɩɨɥɶɡɭɟɬɫɹ ɞɭɪɧɨɣ ɫɥɚɜɨɣ ɩɥɨɯɨ
ɫɩɪɨɟɤɬɢɪɨɜɚɧɧɨɣ ɮɭɧɤɰɢɢ. Ɉɧɚ ɞɟɥɚɟɬ ɨɞɧɨɜɪɟɦɟɧɧɨ ɫɥɢɲɤɨɦ ɦɧɨɝɨ ɞɟɥ: ɜɵɞɟɥɹɟɬ ɩɚɦɹɬɶ,
ɟɫɥɢ ɟɣ ɩɟɪɟɞɚɧɨ ɡɧɚɱɟɧɢɟ NULL, ɨɫɜɨɛɨɠɞɚɟɬ ɟɟ, ɟɫɥɢ ɩɟɪɟɞɚɧ ɧɭɥɟɜɨɣ ɪɚɡɦɟɪ, ɩɟɪɟɪɚɫɩɪɟ-
ɞɟɥɹɟɬ ɟɟ ɧɚ ɬɨɦ ɠɟ ɦɟɫɬɟ, ɟɫɥɢ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɢɥɢ ɩɟɪɟɦɟɳɚɟɬ ɟɟ, ɟɫɥɢ ɬɚɤɨɟ ɩɟɪɟɪɚɫɩɪɟɞɟ-
ɥɟɧɢɟ ɧɟɜɨɡɦɨɠɧɨ. ɗɬɨ ɭɠɟ ɧɟ ɩɪɨɫɬɨ ɪɚɫɲɢɪɟɧɢɟ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ. Ⱦɚɧɧɚɹ ɮɭɧɤɰɢɹ
ɨɛɵɱɧɨ ɪɚɫɫɦɚɬɪɢɜɚɟɬɫɹ ɜɫɟɦɢ ɤɚɤ ɩɪɢɦɟɪ ɧɟɞɚɥɶɧɨɜɢɞɧɨɝɨ, ɨɲɢɛɨɱɧɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
ɉɪɢɦɟɪ 2. basic_string. ȼ ɫɬɚɧɞɚɪɬɟ C++ std::basic_string ɫɥɭɠɢɬ ɬɚɤɢɦ ɠɟ ɩɨɥɶ-
ɡɭɸɳɢɦɫɹ ɞɭɪɧɨɣ ɫɥɚɜɨɣ ɩɪɢɦɟɪɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɦɨɧɨɥɢɬɧɨɝɨ ɤɥɚɫɫɚ. ȼ ɷɬɨɬ ɪɚɡɞɭɬɵɣ ɞɨ
ɧɟɢɦɨɜɟɪɧɵɯ ɪɚɡɦɟɪɨɜ ɤɥɚɫɫ ɞɨɛɚɜɥɟɧɵ ɜɫɟ ɮɭɧɤɰɢɢ, ɨ ɤɨɬɨɪɵɯ ɬɨɥɶɤɨ ɦɨɠɧɨ ɛɵɥɨ ɩɨɞɭɦɚɬɶ.
ɗɬɨɬ ɤɥɚɫɫ ɩɵɬɚɟɬɫɹ ɛɵɬɶ ɤɨɧɬɟɣɧɟɪɨɦ, ɱɬɨ ɧɟ ɫɨɜɫɟɦ ɟɦɭ ɭɞɚɟɬɫɹ; ɜ ɧɟɦ ɬɚɤ ɢ ɨɫɬɚɟɬɫɹ ɧɟɪɚɡ-
ɪɟɲɟɧɧɵɦ ɜɨɩɪɨɫ ɦɟɠɞɭ ɩɪɢɦɟɧɟɧɢɟɦ ɢɬɟɪɚɬɨɪɨɜ ɢ ɢɧɞɟɤɫɢɪɨɜɚɧɢɟɦ. Ʉɪɨɦɟ ɬɨɝɨ, ɜ ɧɟɦ ɫɨ-
ɜɟɪɲɟɧɧɨ ɧɟɨɛɨɫɧɨɜɚɧɧɨ ɞɭɛɥɢɪɭɟɬɫɹ ɦɧɨɠɟɫɬɜɨ ɫɬɚɧɞɚɪɬɧɵɯ ɚɥɝɨɪɢɬɦɨɜ. ȼ ɬɨ ɠɟ ɜɪɟɦɹ ɷɬɨɬ
ɤɥɚɫɫ ɨɫɬɚɜɥɹɟɬ ɨɱɟɧɶ ɦɚɥɨ ɜɨɡɦɨɠɧɨɫɬɟɣ ɞɥɹ ɪɚɫɲɢɪɟɧɢɹ. (ɋɦ. ɩɪɢɦɟɪ ɤ ɪɟɤɨɦɟɧɞɚɰɢɢ 44).
Ссылки
[Henney02a] • [Henney02b] • [McConnell93] §10.5 • [Stroustrup00] §3.8, §4.9.4, §23.4.3.1 •
[Sutter00] §10, §12, §19, §23 • [Sutter02] §1 • [Sutter04] §37-40
24 Стиль проектирования
Стр. 24
6. Главное — корректность, простота
и ясность
Резюме
Ʉɨɪɪɟɤɬɧɨɫɬɶ ɥɭɱɲɟ ɛɵɫɬɪɨɬɵ. ɉɪɨɫɬɨɬɚ ɥɭɱɲɟ ɫɥɨɠɧɨɫɬɢ. əɫɧɨɫɬɶ ɥɭɱɲɟ ɯɢɬɪɨɭɦɢɹ.
Ȼɟɡɨɩɚɫɧɨɫɬɶ ɥɭɱɲɟ ɧɟɧɚɞɟɠɧɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 83 ɢ 99).
ɋɥɨɠɧɨ ɩɪɟɭɜɟɥɢɱɢɬɶ ɡɧɚɱɟɧɢɟ ɩɪɨɫɬɨɬɵ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɢ ɹɫɧɨɫɬɢ ɤɨɞɚ. Ʌɸɞɢ, ɤɨɬɨɪɵɟ
ɛɭɞɭɬ ɫɨɩɪɨɜɨɠɞɚɬɶ ɜɚɲ ɤɨɞ, ɫɤɚɠɭɬ ɜɚɦ ɬɨɥɶɤɨ ɫɩɚɫɢɛɨ ɡɚ ɬɨ, ɱɬɨ ɜɵ ɫɞɟɥɚɥɢ ɜɚɲ ɤɨɞ ɩɨ-
ɧɹɬɧɵɦ. Ʉɫɬɚɬɢ, ɡɚɱɚɫɬɭɸ ɷɬɨ ɛɭɞɟɬɟ ɜɵ ɫɚɦɢ — ɤɨɝɞɚ ɛɭɞɟɬɟ ɜɫɩɨɦɢɧɚɬɶ, ɨ ɱɟɦ ɷɬɨ ɜɵ ɞɭɦɚ-
ɥɢ ɩɨɥɝɨɞɚ ɧɚɡɚɞ ɢ ɤɚɤ ɠɟ ɪɚɛɨɬɚɟɬ ɷɬɨɬ ɤɨɞ, ɤɨɬɨɪɵɣ ɜɵ ɬɨɝɞɚ ɧɚɩɢɫɚɥɢ… ɉɪɢɫɥɭɲɚɣɬɟɫɶ
ɤ ɫɥɟɞɭɸɳɢɦ ɫɥɨɜɚɦ.
ɉɪɨɝɪɚɦɦɚ ɞɨɥɠɧɚ ɛɵɬɶ ɧɚɩɢɫɚɧɚ ɞɥɹ ɱɟɥɨɜɟɤɚ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɟɟ ɱɢɬɚɬɶ, ɢ ɬɨɥɶɤɨ
ɩɨɩɭɬɧɨ — ɞɥɹ ɦɚɲɢɧɵ, ɤɨɬɨɪɚɹ ɛɭɞɟɬ ɟɟ ɜɵɩɨɥɧɹɬɶ.
— Ƚɚɪɨɥɶɞ Ⱥɛɟɥɶɫɨɧ (Harold Abelson)
ɢ Ⱦɠɟɪɚɥɶɞ ɋɚɫɫɦɚɧ (Gerald Jay Sussman)
ɉɢɲɢɬɟ ɩɪɨɝɪɚɦɦɵ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɞɥɹ ɥɸɞɟɣ, ɢ ɬɨɥɶɤɨ ɩɨɬɨɦ ɞɥɹ ɦɚɲɢɧ.
— ɋɬɢɜ Ɇɚɤ-Ʉɨɧɧɟɥɥ (Steve McConnell)
ɋɚɦɵɟ ɞɟɲɟɜɵɟ, ɛɵɫɬɪɵɟ ɢ ɧɚɞɟɠɧɵɟ ɤɨɦɩɨɧɟɧɬɵ ɜɵɱɢɫɥɢɬɟɥɶɧɨɣ ɫɢɫɬɟɦɵ — ɬɟ, ɤɨ-
ɬɨɪɵɯ ɜ ɧɟɣ ɧɟɬ.
— Ƚɨɪɞɨɧ Ȼɟɥɥ (Gordon Bell)
ɗɬɢ ɨɬɫɭɬɫɬɜɭɸɳɢɟ ɤɨɦɩɨɧɟɧɬɵ ɬɚɤɠɟ ɧɚɢɛɨɥɟɟ ɬɨɱɧɵ (ɨɧɢ ɧɢɤɨɝɞɚ ɧɟ ɨɲɢɛɚɸɬɫɹ),
ɧɚɢɛɨɥɟɟ ɧɚɞɟɠɧɵ (ɧɢɤɨɝɞɚ ɧɟ ɥɨɦɚɸɬɫɹ) ɢ ɧɚɢɛɨɥɟɟ ɩɪɨɫɬɵ ɜ ɪɚɡɪɚɛɨɬɤɟ, ɞɨɤɭɦɟɧɬɢ-
ɪɨɜɚɧɢɢ, ɬɟɫɬɢɪɨɜɚɧɢɢ ɢ ɫɨɩɪɨɜɨɠɞɟɧɢɢ. ȼɚɠɧɨɫɬɶ ɩɪɨɫɬɨɬɵ ɞɢɡɚɣɧɚ ɧɟɜɨɡɦɨɠɧɨ
ɩɟɪɟɨɰɟɧɢɬɶ.
— Ƀɨɧ Ȼɟɧɬɥɢ (Jon Bentley)
Ɇɧɨɝɢɟ ɢɡ ɪɟɤɨɦɟɧɞɚɰɢɣ ɷɬɨɣ ɤɧɢɝɢ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ ɩɪɢɜɨɞɹɬ ɤ ɥɟɝɤɨ ɢɡɦɟɧɹɟɦɨɦɭ ɞɢ-
ɡɚɣɧɭ ɢ ɤɨɞɭ, ɚ ɹɫɧɨɫɬɶ ɹɜɥɹɟɬɫɹ ɧɚɢɛɨɥɟɟ ɠɟɥɚɧɧɵɦ ɤɚɱɟɫɬɜɨɦ ɞɥɹ ɩɪɨɝɪɚɦɦɵ, ɤɨɬɨɪɭɸ ɥɟɝɤɨ ɫɨ-
ɩɪɨɜɨɠɞɚɬɶ. Ɍɨ, ɱɬɨ ɜɵ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɩɨɧɹɬɶ, ɜɵ ɧɟ ɫɦɨɠɟɬɟ ɭɜɟɪɟɧɧɨ ɢ ɧɚɞɟɠɧɨ ɩɟɪɟɞɟɥɚɬɶ.
ȼɟɪɨɹɬɧɨ, ɧɚɢɛɨɥɟɟ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɫɨɩɟɪɧɢɱɟɫɬɜɨɦ ɜ ɞɚɧɧɨɣ ɨɛɥɚɫɬɢ ɹɜɥɹɟɬɫɹ ɫɨɩɟɪɧɢɱɟ-
ɫɬɜɨ ɦɟɠɞɭ ɹɫɧɨɫɬɶɸ ɤɨɞɚ ɢ ɟɝɨ ɨɩɬɢɦɢɡɚɰɢɟɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 7, 8 ɢ 9). Ʉɨɝɞɚ — ɧɟ ɟɫɥɢ — ɜɵ
ɧɚɯɨɞɢɬɟɫɶ ɩɟɪɟɞ ɫɨɛɥɚɡɧɨɦ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ ɞɥɹ ɩɨɜɵɲɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ
ɢ, ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɩɟɫɫɢɦɢɡɚɰɢɢ ɞɥɹ ɩɨɜɵɲɟɧɢɹ ɹɫɧɨɫɬɢ, — ɜɫɩɨɦɧɢɬɟ, ɱɬɨ ɝɨɜɨɪɢɬ ɪɟɤɨɦɟɧɞɚ-
ɰɢɹ 8: ɝɨɪɚɡɞɨ ɩɪɨɳɟ ɫɞɟɥɚɬɶ ɤɨɪɪɟɤɬɧɭɸ ɩɪɨɝɪɚɦɦɭ ɛɵɫɬɪɨɣ, ɱɟɦ ɛɵɫɬɪɭɸ — ɤɨɪɪɟɤɬɧɨɣ.
ɂɡɛɟɝɚɣɬɟ “ɬɟɦɧɵɯ ɡɚɤɭɬɤɨɜ” ɹɡɵɤɚ. ɂɫɩɨɥɶɡɭɣɬɟ ɩɪɨɫɬɟɣɲɢɟ ɢɡ ɷɮɮɟɤɬɢɜɧɵɯ ɦɟɬɨɞɨɜ.
Примеры
ɉɪɢɦɟɪ 1. ɂɡɛɟɝɚɣɬɟ ɧɟɭɦɟɫɬɧɨɣ ɢ/ɢɥɢ ɱɟɪɟɫɱɭɪ ɯɢɬɪɨɭɦɧɨɣ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɨɜ.
ȼ ɨɞɧɨɣ ɛɢɛɥɢɨɬɟɤɟ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɝɪɚɮɢɱɟɫɤɨɝɨ ɢɧɬɟɪɮɟɣɫɚ ɩɨɥɶɡɨɜɚɬɟɥɟɣ ɛɟɡ ɧɭɠɞɵ
ɡɚɫɬɚɜɥɹɸɬ ɩɢɫɚɬɶ w+c; ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɞɨɛɚɜɢɬɶ ɜ ɨɤɧɨ w ɞɨɱɟɪɧɢɣ ɭɩɪɚɜɥɹɸɳɢɣ ɷɥɟɦɟɧɬ c
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 26).
6. Главное — корректность, простота и ясность 25
Стр. 25
ɉɪɢɦɟɪ 2. ȼ ɤɚɱɟɫɬɜɟ ɩɚɪɚɦɟɬɪɨɜ ɤɨɧɫɬɪɭɤɬɨɪɚ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɟɧɨɜɚɧɧɵɟ, ɚ ɧɟ
ɜɪɟɦɟɧɧɵɟ ɩɟɪɟɦɟɧɧɵɟ. ɗɬɨ ɩɨɡɜɨɥɢɬ ɢɡɛɟɠɚɬɶ ɜɨɡɦɨɠɧɵɯ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɟɣ ɨɛɴɹɜɥɟɧɢɣ, ɚ
ɬɚɤɠɟ ɡɚɱɚɫɬɭɸ ɩɪɨɹɫɧɹɟɬ ɧɚɡɧɚɱɟɧɢɟ ɜɚɲɟɝɨ ɤɨɞɚ ɢ ɬɟɦ ɫɚɦɵɦ ɭɩɪɨɳɚɟɬ ɟɝɨ ɫɨɩɪɨɜɨɠɞɟ-
ɧɢɟ. Ʉɪɨɦɟ ɬɨɝɨ, ɱɚɫɬɨ ɷɬɨ ɩɪɨɫɬɨ ɛɟɡɨɩɚɫɧɟɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 13 ɢ 31).
Ссылки
[Abelson96] • [Bentley00] §4 • [Cargill92] pp. 91-93 • [Cline99] §3.05-06 • [Constantine95] §29 •
[Keffer95] p. 17 • [Lakos96] §9.1, §10.2.4 • [McConnell93] • [Meyers01] §47 • [Stroustrup00] §1.7,
§2.1, §6.2.3, §23.4.2, §23.4.3.2 • [Sutter00] §40-41, §46 • [Sutter04] §29
Стр. 26
7. Кодирование с учетом масштабируемости
Резюме
ȼɫɟɝɞɚ ɩɨɦɧɢɬɟ ɨ ɜɨɡɦɨɠɧɨɦ ɪɨɫɬɟ ɞɚɧɧɵɯ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɚɫɢɦɩɬɨɬɢɱɟɫɤɨɣ ɫɥɨɠɧɨɫɬɢ ɛɟɡ
ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ. Ⱥɥɝɨɪɢɬɦɵ, ɤɨɬɨɪɵɟ ɪɚɛɨɬɚɸɬ ɫ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɦɢ ɞɚɧɧɵɦɢ,
ɞɨɥɠɧɵ ɢɦɟɬɶ ɩɪɟɞɫɤɚɡɭɟɦɨɟ ɢ, ɠɟɥɚɬɟɥɶɧɨ, ɧɟ ɯɭɠɟ, ɱɟɦ ɥɢɧɟɣɧɨ ɡɚɜɢɫɹɳɟɟ ɨɬ ɤɨɥɢɱɟɫɬɜɚ ɨɛ-
ɪɚɛɚɬɵɜɚɟɦɵɯ ɞɚɧɧɵɯ ɜɪɟɦɹ ɪɚɛɨɬɵ. Ʉɨɝɞɚ ɫɬɚɧɨɜɢɬɫɹ ɜɚɠɧɨɣ ɢ ɧɟɨɛɯɨɞɢɦɨɣ ɨɩɬɢɦɢɡɚɰɢɹ, ɜ
ɨɫɨɛɟɧɧɨɫɬɢ ɢɡ-ɡɚ ɪɨɫɬɚ ɨɛɴɟɦɨɜ ɞɚɧɧɵɯ, ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɫɥɟɞɭɟɬ ɭɥɭɱɲɚɬɶ O-ɫɥɨɠɧɨɫɬɶ ɚɥ-
ɝɨɪɢɬɦɚ, ɚ ɧɟ ɡɚɧɢɦɚɬɶɫɹ ɦɢɤɪɨɨɩɬɢɦɢɡɚɰɢɹɦɢ ɬɢɩɚ ɷɤɨɧɨɦɢɢ ɧɚ ɨɞɧɨɦ ɫɥɨɠɟɧɢɢ.
ɗɬɚ ɪɟɤɨɦɟɧɞɚɰɢɹ ɢɥɥɸɫɬɪɢɪɭɟɬ ɜɚɠɧɭɸ ɬɨɱɤɭ ɪɚɜɧɨɜɟɫɢɹ ɦɟɠɞɭ ɪɟɤɨɦɟɧɞɚɰɢɹɦɢ 8
ɢ 9 — ɧɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ ɢ ɧɟ ɩɟɫɫɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ. ɗɬɨ ɞɟɥɚɟɬ
ɞɚɧɧɵɣ ɦɚɬɟɪɢɚɥ ɬɪɭɞɧɵɦ ɜ ɧɚɩɢɫɚɧɢɢ, ɩɨɫɤɨɥɶɤɭ ɨɧ ɦɨɠɟɬ ɛɵɬɶ ɧɟɜɟɪɧɨ ɢɫɬɨɥɤɨɜɚɧ ɤɚɤ
ɫɨɜɟɬ ɨ “ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ”. ɗɬɨ ɧɟ ɬɚɤ.
ȼɨɬ ɩɪɟɞɩɨɫɵɥɤɢ ɞɥɹ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ. ɉɚɦɹɬɶ ɢ ɞɢɫɤɨɜɚɹ ɟɦɤɨɫɬɶ ɪɚɫɬɭɬ ɷɤɫɩɨɧɟɧ-
ɰɢɚɥɶɧɨ; ɧɚɩɪɢɦɟɪ, ɫ 1988 ɩɨ 2004 ɝɨɞ ɟɦɤɨɫɬɶ ɞɢɫɤɨɜ ɪɨɫɥɚ ɩɪɢɦɟɪɧɨ ɧɚ 112% ɜ ɝɨɞ (ɩɨɱɬɢ
ɜ 1900 ɪɚɡ ɡɚ ɞɟɫɹɬɢɥɟɬɢɟ). Ɉɱɟɜɢɞɧɵɦ ɫɥɟɞɫɬɜɢɟɦ ɷɬɨɝɨ ɮɚɤɬɚ ɹɜɥɹɟɬɫɹ ɬɨ, ɱɬɨ ɥɸɛɨɣ ɜɚɲ
ɫɟɝɨɞɧɹɲɧɢɣ ɤɨɞ ɡɚɜɬɪɚ ɦɨɠɟɬ ɢɦɟɬɶ ɞɟɥɨ ɫ ɛɨɥɶɲɢɦɢ ɨɛɴɟɦɚɦɢ ɞɚɧɧɵɯ — ɧɚɦɧɨɝɨ ɛɨɥɶɲɢ-
ɦɢ! ɉɥɨɯɨɟ (ɯɭɠɟ ɥɢɧɟɣɧɨɝɨ) ɚɫɢɦɩɬɨɬɢɱɟɫɤɨɟ ɩɨɜɟɞɟɧɢɟ ɚɥɝɨɪɢɬɦɚ ɪɚɧɨ ɢɥɢ ɩɨɡɞɧɨ ɩɨɫɬɚɜɢɬ
ɧɚ ɤɨɥɟɧɢ ɞɚɠɟ ɫɚɦɭɸ ɦɨɳɧɭɸ ɫɢɫɬɟɦɭ, ɩɪɨɫɬɨ ɡɚɜɚɥɢɜ ɟɟ ɞɨɫɬɚɬɨɱɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɞɚɧɧɵɯ.
Ɂɚɳɢɬɚ ɩɪɨɬɢɜ ɬɚɤɨɝɨ ɛɭɞɭɳɟɝɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɦɵ ɞɨɥɠɧɵ ɢɡɛɟɠɚɬɶ ɜɫɬɪɚɢɜɚɧɢɹ ɜ ɧɚɲɢ
ɩɪɨɝɪɚɦɦɵ ɬɨɝɨ, ɱɬɨ ɫɬɚɧɟɬ ɡɚɩɚɞɧɟɣ ɩɪɢ ɪɚɛɨɬɟ ɫ ɛɨɥɶɲɢɦɢ ɮɚɣɥɚɦɢ, ɛɨɥɶɲɢɦɢ ɛɚɡɚɦɢ
ɞɚɧɧɵɯ, ɫ ɛɨɥɶɲɢɦ ɤɨɥɢɱɟɫɬɜɨɦ ɩɢɤɫɟɥɟɣ, ɛɨɥɶɲɢɦ ɤɨɥɢɱɟɫɬɜɨɦ ɨɤɨɧ, ɩɪɨɰɟɫɫɨɜ, ɛɢɬɨɜ, ɩɟ-
ɪɟɫɵɥɚɟɦɵɯ ɩɨ ɤɚɧɚɥɚɦ ɫɜɹɡɢ. Ɉɞɧɢɦ ɢɡ ɜɚɠɧɵɯ ɮɚɤɬɨɪɨɜ ɭɫɩɟɯɚ ɬɚɤɨɣ ɡɚɳɢɬɵ ɹɜɥɹɟɬɫɹ ɬɨ,
ɱɬɨ ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɨɛɟɫɩɟɱɢɜɚɟɬ ɝɚɪɚɧɬɢɪɨɜɚɧɧɭɸ ɫɥɨɠɧɨɫɬɶ ɨɩɟɪɚɰɢɣ ɢ ɚɥɝɨ-
ɪɢɬɦɨɜ ɧɚɞ ɤɨɧɬɟɣɧɟɪɚɦɢ STL.
Ɂɞɟɫɶ ɢ ɧɚɞɨ ɢɫɤɚɬɶ ɬɨɱɤɭ ɪɚɜɧɨɜɟɫɢɹ. Ɉɱɟɜɢɞɧɨ, ɱɬɨ ɧɟɜɟɪɧɨ ɩɪɢɛɟɝɚɬɶ ɤ ɩɪɟɠɞɟɜɪɟɦɟɧ-
ɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ ɩɭɬɟɦ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɦɟɧɟɟ ɩɨɧɹɬɧɵɯ ɚɥɝɨɪɢɬɦɨɜ ɜ ɨɠɢɞɚɧɢɢ ɛɨɥɶɲɢɯ
ɨɛɴɟɦɨɜ ɞɚɧɧɵɯ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɧɢɤɨɝɞɚ ɧɟ ɦɚɬɟɪɢɚɥɢɡɨɜɚɬɶɫɹ. ɇɟ ɦɟɧɟɟ ɨɱɟɜɢɞɧɨ ɢ ɬɨ, ɱɬɨ
ɧɟɜɟɪɧɨ ɩɪɢɛɟɝɚɬɶ ɢ ɤ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ, ɡɚɤɪɵɜɚɹ ɝɥɚɡɚ ɧɚ ɫɥɨɠɧɨɫɬɶ ɚɥɝɨ-
ɪɢɬɦɨɜ (O-ɫɥɨɠɧɨɫɬɶ), ɚ ɢɦɟɧɧɨ — ɫɬɨɢɦɨɫɬɶ ɜɵɱɢɫɥɟɧɢɣ ɤɚɤ ɮɭɧɤɰɢɸ ɨɬ ɤɨɥɢɱɟɫɬɜɚ ɷɥɟ-
ɦɟɧɬɨɜ ɞɚɧɧɵɯ, ɫ ɤɨɬɨɪɵɦɢ ɪɚɛɨɬɚɟɬ ɚɥɝɨɪɢɬɦ.
Ⱦɚɧɧɵɣ ɫɨɜɟɬ ɫɨɫɬɨɢɬ ɢɡ ɞɜɭɯ ɱɚɫɬɟɣ. ȼɨ-ɩɟɪɜɵɯ, ɞɚɠɟ ɞɨ ɬɨɝɨ, ɤɚɤ ɫɬɚɧɟɬ ɢɡɜɟɫɬɧɨ, ɛɭɞɭɬ
ɥɢ ɨɛɴɟɦɵ ɞɚɧɧɵɯ ɞɨɫɬɚɬɨɱɧɨ ɜɟɥɢɤɢ, ɱɬɨɛɵ ɞɥɹ ɤɨɧɤɪɟɬɧɵɯ ɜɵɱɢɫɥɟɧɢɣ ɜɨɡɧɢɤɥɚ ɩɪɨɛɥɟ-
ɦɚ, ɩɨ ɭɦɨɥɱɚɧɢɸ ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɚɥɝɨɪɢɬɦɨɜ, ɤɨɬɨɪɵɟ ɪɚɛɨɬɚɸɬ ɫ ɩɨɥɶɡɨɜɚ-
ɬɟɥɶɫɤɢɦɢ ɞɚɧɧɵɦɢ (ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɪɚɫɬɢ), ɧɨ ɧɟ ɫɩɨɫɨɛɧɵ ɤ ɦɚɫɲɬɚɛɢɪɨɜɚɧɢɸ, ɟɫɥɢ ɬɨɥɶɤɨ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɦɟɧɟɟ ɦɚɫɲɬɚɛɢɪɭɟɦɨɝɨ ɚɥɝɨɪɢɬɦɚ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɫɭɳɟɫɬɜɟɧɧɨɦɭ ɩɨɜɵɲɟɧɢɸ
ɩɨɧɹɬɧɨɫɬɢ ɢ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɢ ɤɨɞɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6). ɇɨ ɜɫɟ ɦɵ ɱɚɫɬɨ ɫɬɚɥɤɢɜɚɟɦɫɹ
ɫ ɫɸɪɩɪɢɡɚɦɢ. Ɇɵ ɩɢɲɟɦ ɞɟɫɹɬɶ ɮɪɚɝɦɟɧɬɨɜ ɤɨɞɚ, ɞɭɦɚɹ, ɱɬɨ ɨɧɢ ɧɢɤɨɝɞɚ ɧɟ ɛɭɞɭɬ ɢɦɟɬɶ
ɞɟɥɚ ɫ ɛɨɥɶɲɢɦɢ ɧɚɛɨɪɚɦɢ ɞɚɧɧɵɯ. ɂ ɷɬɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɨɤɚɡɵɜɚɟɬɫɹ ɬɚɤ — ɜ ɞɟɜɹɬɢ ɫɥɭɱɚɹɯ
ɢɡ ɞɟɫɹɬɢ. ȼ ɞɟɫɹɬɨɦ ɫɥɭɱɚɟ ɦɵ ɫɬɚɥɤɢɜɚɟɦɫɹ ɫ ɩɪɨɛɥɟɦɚɦɢ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ. ɗɬɨ ɧɟ ɪɚɡ
ɫɥɭɱɚɥɨɫɶ ɫ ɧɚɦɢ, ɢ ɦɵ ɡɧɚɟɦ, ɱɬɨ ɷɬɨ ɫɥɭɱɚɥɨɫɶ (ɢɥɢ ɫɥɭɱɢɬɫɹ) ɢ ɫ ɜɚɦɢ. Ʉɨɧɟɱɧɨ, ɦɵ ɜɧɨɫɢ-
ɥɢ ɢɫɩɪɚɜɥɟɧɢɹ ɢ ɩɟɪɟɞɚɜɚɥɢ ɢɯ ɩɨɬɪɟɛɢɬɟɥɹɦ, ɧɨ ɥɭɱɲɟ ɛɵɥɨ ɛɵ ɢɡɛɟɠɚɬɶ ɬɚɤɢɯ ɡɚɬɪɭɞɧɟ-
ɧɢɣ ɢ ɜɵɩɨɥɧɟɧɢɹ ɥɢɲɧɟɣ ɪɚɛɨɬɵ. Ɍɚɤ ɱɬɨ ɩɪɢ ɩɪɨɱɢɯ ɪɚɜɧɵɯ ɭɫɥɨɜɢɹɯ (ɜɤɥɸɱɚɹ ɩɨɧɹɬɧɨɫɬɶ
ɢ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɶ) ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɫɥɟɞɭɸɳɢɦɢ ɫɨɜɟɬɚɦɢ.
7. Кодирование с учетом масштабируемости 27
Стр. 27
• ɂɫɩɨɥɶɡɭɣɬɟ ɝɢɛɤɢɟ ɞɢɧɚɦɢɱɟɫɤɢ ɪɚɫɩɪɟɞɟɥɹɟɦɵɟ ɞɚɧɧɵɟ ɜɦɟɫɬɨ ɦɚɫɫɢɜɨɜ ɮɢɤɫɢɪɨ-
ɜɚɧɧɨɝɨ ɪɚɡɦɟɪɚ. Ɇɚɫɫɢɜ “ɛɨɥɶɲɢɣ, ɱɟɦ ɧɚɢɛɨɥɶɲɢɣ ɦɚɫɫɢɜ, ɤɨɬɨɪɵɣ ɦɧɟ ɤɨɝɞɚ-ɥɢɛɨ
ɩɨɬɪɟɛɭɟɬɫɹ” ɩɪɢɜɨɞɢɬ ɤ ɨɲɢɛɤɚɦ ɢ ɧɚɪɭɲɟɧɢɸ ɛɟɡɨɩɚɫɧɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 77).
Ɇɚɫɫɢɜɵ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɪɚɡɦɟɪɵ ɞɚɧɧɵɯ ɮɢɤɫɢɪɨɜɚɧɵ ɢ ɢɡ-
ɜɟɫɬɧɵ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ.
• ɋɥɟɞɭɟɬ ɬɨɱɧɨ ɡɧɚɬɶ ɫɥɨɠɧɨɫɬɶ ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɚɥɝɨɪɢɬɦɚ. ɇɟ ɡɚɛɵɜɚɣɬɟ ɨ ɬɚɤɨɣ
ɥɨɜɭɲɤɟ, ɤɚɤ ɥɢɧɟɣɧɵɣ ɚɥɝɨɪɢɬɦ, ɤɨɬɨɪɵɣ ɜɵɡɵɜɚɟɬ ɞɪɭɝɭɸ ɥɢɧɟɣɧɭɸ ɨɩɟɪɚɰɢɸ, ɱɬɨ
ɜ ɪɟɡɭɥɶɬɚɬɟ ɞɟɥɚɟɬ ɚɥɝɨɪɢɬɦ ɤɜɚɞɪɚɬɢɱɧɵɦ (ɫɦ., ɧɚɩɪɢɦɟɪ, ɪɟɤɨɦɟɧɞɚɰɢɸ 81).
• ɉɨ ɜɨɡɦɨɠɧɨɫɬɢ ɢɫɩɨɥɶɡɭɣɬɟ ɥɢɧɟɣɧɵɟ ɢɥɢ ɛɨɥɟɟ ɛɵɫɬɪɵɟ ɚɥɝɨɪɢɬɦɵ. ɂɞɟɚɥɶɧɵ
ɚɥɝɨɪɢɬɦɵ ɫ ɤɨɧɫɬɚɧɬɧɨɣ ɫɥɨɠɧɨɫɬɶɸ, ɬɚɤɢɟ ɤɚɤ push_back ɢɥɢ ɩɨɢɫɤ ɜ ɯɷɲ-ɬɚɛɥɢɰɟ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 76 ɢ 80). ɇɟɩɥɨɯɢ ɚɥɝɨɪɢɬɦɵ ɫɨ ɫɥɨɠɧɨɫɬɶɸ O(log N), ɬɚɤɢɟ ɤɚɤ ɨɩɟ-
ɪɚɰɢɢ ɫ ɤɨɧɬɟɣɧɟɪɚɦɢ set/map ɢ lower_bound ɢɥɢ upper_bound ɫ ɢɬɟɪɚɬɨɪɚɦɢ ɩɪɨ-
ɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 76, 85 ɢ 86). Ⱦɨɩɭɫɬɢɦɚ ɥɢɧɟɣɧɚɹ ɫɥɨɠɧɨɫɬɶ
O(N), ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɭ vector::insert ɢɥɢ for_each (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 76, 81 ɢ 84).
• ɉɵɬɚɣɬɟɫɶ ɢɡɛɟɠɚɬɶ ɩɪɢɦɟɧɟɧɢɹ ɚɥɝɨɪɢɬɦɨɜ ɫ ɛɨɥɟɟ ɱɟɦ ɥɢɧɟɣɧɨɣ ɫɥɨɠɧɨɫɬɶɸ,
ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ. ɇɚɩɪɢɦɟɪ, ɩɨ ɭɦɨɥɱɚɧɢɸ ɫɥɟɞɭɟɬ ɡɚɬɪɚɬɢɬɶ ɨɩɪɟɞɟɥɟɧɧɵɟ ɭɫɢɥɢɹ
ɧɚ ɩɨɢɫɤ ɡɚɦɟɧɵ ɢɦɟɸɳɟɝɨɫɹ ɚɥɝɨɪɢɬɦɚ ɫɨ ɫɥɨɠɧɨɫɬɶɸ O(N log N) ɢɥɢ O(N2) (ɟɫɥɢ
ɬɚɤɨɜɚɹ ɜɨɡɦɨɠɧɚ), ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɩɪɨɩɨɪɰɢɨɧɚɥɶɧɨɝɨ ɩɚɞɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨ-
ɫɬɢ ɩɪɢ ɫɭɳɟɫɬɜɟɧɧɨɦ ɭɜɟɥɢɱɟɧɢɢ ɨɛɴɟɦɚ ɞɚɧɧɵɯ. Ɍɚɤ, ɢɦɟɧɧɨ ɜ ɷɬɨɦ ɡɚɤɥɸɱɚɟɬɫɹ
ɨɫɧɨɜɧɚɹ ɩɪɢɱɢɧɚ, ɩɨ ɤɨɬɨɪɨɣ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 81 ɫɨɜɟɬɭɟɬɫɹ ɩɪɟɞɩɨɱɢɬɚɬɶ ɨɩɟɪɚɰɢɢ
ɫ ɞɢɚɩɚɡɨɧɚɦɢ (ɤɨɬɨɪɵɟ ɨɛɵɱɧɨ ɥɢɧɟɣɧɵ) ɢɯ ɤɨɩɢɹɦ ɞɥɹ ɪɚɛɨɬɵ ɫ ɨɬɞɟɥɶɧɵɦɢ ɷɥɟ-
ɦɟɧɬɚɦɢ (ɤɨɬɨɪɵɟ ɨɛɵɱɧɨ ɤɜɚɞɪɚɬɢɱɧɵ, ɬɚɤ ɤɚɤ ɨɞɧɚ ɥɢɧɟɣɧɚɹ ɨɩɟɪɚɰɢɹ ɜɵɡɵɜɚɟɬ
ɞɪɭɝɭɸ ɥɢɧɟɣɧɭɸ ɨɩɟɪɚɰɢɸ; ɫɦ. ɩɪɢɦɟɪ 1 ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 81).
• ɇɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɷɤɫɩɨɧɟɧɰɢɚɥɶɧɵɣ ɚɥɝɨɪɢɬɦ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ “ɩɪɢɩɟɪɬɵ
ɤ ɫɬɟɧɟ” ɢ ɧɟ ɢɦɟɟɬɟ ɞɪɭɝɨɝɨ ɜɵɯɨɞɚ. ɂɳɢɬɟ, ɧɟ ɠɚɥɟɹ ɫɢɥ, ɚɥɶɬɟɪɧɚɬɢɜɭ, ɩɪɟɠɞɟ ɱɟɦ
ɩɪɢɛɟɝɧɭɬɶ ɤ ɷɤɫɩɨɧɟɧɰɢɚɥɶɧɨɦɭ ɚɥɝɨɪɢɬɦɭ, ɝɞɟ ɞɚɠɟ ɧɟɛɨɥɶɲɨɟ ɭɜɟɥɢɱɟɧɢɟ ɞɚɧɧɵɯ
ɩɪɢɜɨɞɢɬ ɤ ɫɭɳɟɫɬɜɟɧɧɨɦɭ ɩɚɞɟɧɢɸ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ.
ȼɨ-ɜɬɨɪɵɯ, ɩɨɫɥɟ ɬɨɝɨ ɤɚɤ ɡɚɦɟɪɵ ɩɨɤɚɠɭɬ, ɱɬɨ ɨɩɬɢɦɢɡɚɰɢɹ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɭɠɧɚ ɢ ɜɚɠ-
ɧɚ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɩɪɢ ɪɨɫɬɟ ɞɚɧɧɵɯ, ɫɤɨɧɰɟɧɬɪɢɪɭɣɬɟ ɭɫɢɥɢɹ ɧɚ ɫɧɢɠɟɧɢɢ O-ɫɥɨɠɧɨɫɬɢ, ɚ ɧɟ
ɧɚ ɦɢɤɪɨɨɩɬɢɦɢɡɚɰɢɹɯ ɧɚɩɨɞɨɛɢɟ ɷɤɨɧɨɦɢɢ ɨɞɧɨɝɨ ɫɥɨɠɟɧɢɹ.
ɂɬɚɤ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɥɢɧɟɣɧɵɟ (ɢɥɢ ɥɭɱɲɢɟ) ɚɥɝɨɪɢɬɦɵ ɬɚɦ, ɝɞɟ ɬɨɥɶɤɨ
ɷɬɨ ɜɨɡɦɨɠɧɨ. ɂɡɛɟɝɚɣɬɟ, ɝɞɟ ɦɨɠɟɬɟ, ɚɥɝɨɪɢɬɦɨɜ ɫ ɛɨɥɟɟ ɱɟɦ ɥɢɧɟɣɧɨɣ ɫɥɨɠɧɨɫɬɶɸ, ɢ ɭɠ
ɬɟɦ ɛɨɥɟɟ — ɷɤɫɩɨɧɟɧɰɢɚɥɶɧɵɯ.
Ссылки
[Bentley00] §6, §8, Appendix 4 • [Cormen01] • [Kernighan99] §7 • [Knuth97a] • [Knuth97b] •
[Knuth98] • [McConnell93] §5.1-4, §10.6 • [Murray93] §9.11 • [Sedgewick98] • [Stroustrup00]
§17.1.2
Стр. 28
8. Не оптимизируйте преждевременно
Резюме
Ʉɚɤ ɝɥɚɫɢɬ ɩɨɫɥɨɜɢɰɚ, ɧɟ ɩɨɞɝɨɧɹɣɬɟ ɫɤɚɱɭɳɭɸ ɥɨɲɚɞɶ. ɉɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ
ɧɟɩɪɨɞɭɤɬɢɜɧɚ ɢ ɛɵɫɬɪɨ ɜɯɨɞɢɬ ɜ ɩɪɢɜɵɱɤɭ. ɉɟɪɜɨɟ ɩɪɚɜɢɥɨ ɨɩɬɢɦɢɡɚɰɢɢ: ɧɟ ɨɩɬɢɦɢɡɢɪɭɣ-
ɬɟ. ȼɬɨɪɨɟ ɩɪɚɜɢɥɨ ɨɩɬɢɦɢɡɚɰɢɢ (ɬɨɥɶɤɨ ɞɥɹ ɷɤɫɩɟɪɬɨɜ): ɧɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɧɢ ɜ ɤɨɟɦ ɫɥɭɱɚɟ.
ɋɟɦɶ ɪɚɡ ɨɬɦɟɪɶ, ɨɞɢɧ ɪɚɡ ɨɩɬɢɦɢɡɢɪɭɣ.
ȼ [Stroustrup00] §6 ɢɦɟɟɬɫɹ ɡɚɦɟɱɚɬɟɥɶɧɚɹ ɰɢɬɚɬɚ:
ɉɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ — ɤɨɪɟɧɶ ɜɫɟɯ ɛɟɞ.
— Ⱦɨɧɚɥɶɞ Ʉɧɭɬ (Donald Knuth) [ɰɢɬɢɪɭɟɬ ɏɨɚɪɚ (Hoare)]
ɋ ɞɪɭɝɨɣ ɫɬɨɪɨɧɵ, ɦɵ ɧɟ ɦɨɠɟɦ ɢɝɧɨɪɢɪɨɜɚɬɶ ɷɮɮɟɤɬɢɜɧɨɫɬɶ.
— Ƀɨɧ Ȼɟɧɬɥɢ (Jon Bentley)
ɏɨɚɪ ɢ Ʉɧɭɬ ɫɨɜɟɪɲɟɧɧɨ ɩɪɚɜɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6 ɢ ɷɬɭ). ɇɨ ɩɪɚɜ ɢ Ȼɟɧɬɥɢ (ɪɟɤɨɦɟɧ-
ɞɚɰɢɹ 9).
Ɇɵ ɨɩɪɟɞɟɥɹɟɦ ɩɪɟɠɞɟɜɪɟɦɟɧɧɭɸ ɨɩɬɢɦɢɡɚɰɢɸ ɤɚɤ ɭɫɥɨɠɧɟɧɢɟ ɞɢɡɚɣɧɚ ɢɥɢ ɤɨɞɚ (ɱɬɨ
ɞɟɥɚɟɬ ɟɝɨ ɦɟɧɟɟ ɭɞɨɛɨɱɢɬɚɟɦɵɦ) ɜɨ ɢɦɹ ɩɨɜɵɲɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ, ɤɨɝɞɚ ɭɫɢɥɢɹ ɧɟ
ɨɩɪɚɜɞɵɜɚɸɬɫɹ ɞɨɤɚɡɚɧɧɨɣ ɧɟɨɛɯɨɞɢɦɨɫɬɶɸ ɩɨɜɵɲɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ (ɧɚɩɪɢɦɟɪ, ɪɟ-
ɚɥɶɧɵɦɢ ɢɡɦɟɪɟɧɢɹɦɢ ɢ ɫɪɚɜɧɟɧɢɟɦ ɫ ɩɨɫɬɚɜɥɟɧɧɨɣ ɰɟɥɶɸ). Ɂɚɱɚɫɬɭɸ ɬɚɤɢɟ ɭɫɢɥɢɹ ɜɨɨɛɳɟ
ɧɟ ɩɪɢɜɨɞɹɬ ɤ ɩɨɜɵɲɟɧɢɸ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɩɪɨɝɪɚɦɦɵ.
ȼɫɟɝɞɚ ɩɨɦɧɢɬɟ:
Ƚɨɪɚɡɞɨ, ɝɨɪɚɡɞɨ ɩɪɨɳɟ ɫɞɟɥɚɬɶ ɤɨɪɪɟɤɬɧɭɸ ɩɪɨɝɪɚɦɦɭ ɛɵɫɬɪɨɣ,
ɱɟɦ ɛɵɫɬɪɭɸ — ɤɨɪɪɟɤɬɧɨɣ.
ɉɨɷɬɨɦɭ ɩɨ ɭɦɨɥɱɚɧɢɸ ɧɟ ɤɨɧɰɟɧɬɪɢɪɭɣɬɟɫɶ ɧɚ ɬɨɦ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɤɨɞ ɛɵɫɬɪɵɦ, ɜ ɩɟɪ-
ɜɭɸ ɨɱɟɪɟɞɶ ɟɝɨ ɧɚɞɨ ɫɞɟɥɚɬɶ ɦɚɤɫɢɦɚɥɶɧɨ ɩɨɧɹɬɧɵɦ ɢ ɭɞɨɛɨɱɢɬɚɟɦɵɦ (ɪɟɤɨɦɟɧɞɚɰɢɹ 6).
əɫɧɵɣ ɤɨɞ ɩɪɨɳɟ ɧɚɩɢɫɚɬɶ ɤɨɪɪɟɤɬɧɨ, ɩɪɨɳɟ ɩɨɧɹɬɶ, ɩɪɨɳɟ ɩɟɪɟɞɟɥɚɬɶ — ɢ ɩɪɨɳɟ ɨɩɬɢɦɢ-
ɡɢɪɨɜɚɬɶ. ɍɫɥɨɠɧɟɧɢɹ, ɜɤɥɸɱɚɹ ɨɩɬɢɦɢɡɚɰɢɸ, ɜɫɟɝɞɚ ɦɨɠɧɨ ɜɧɟɫɬɢ ɩɨɡɠɟ — ɢ ɬɨɥɶɤɨ ɩɪɢ
ɧɟɨɛɯɨɞɢɦɨɫɬɢ.
ɂɦɟɸɬɫɹ ɞɜɟ ɨɫɧɨɜɧɵɟ ɩɪɢɱɢɧɵ, ɩɨɱɟɦɭ ɩɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ ɡɚɱɚɫɬɭɸ ɧɟ ɞɟ-
ɥɚɟɬ ɩɪɨɝɪɚɦɦɭ ɛɵɫɬɪɟɟ. ȼɨ-ɩɟɪɜɵɯ, ɨɛɳɟɢɡɜɟɫɬɧɨ, ɱɬɨ ɩɪɨɝɪɚɦɦɢɫɬɵ ɨɛɵɱɧɨ ɩɥɨɯɨ ɩɪɟɞ-
ɫɬɚɜɥɹɸɬ, ɤɚɤɨɣ ɤɨɞ ɛɭɞɟɬ ɛɵɫɬɪɟɟ ɢɥɢ ɦɟɧɶɲɟ ɩɨ ɪɚɡɦɟɪɭ, ɢ ɝɞɟ ɛɭɞɟɬ ɫɚɦɨɟ ɭɡɤɨɟ ɦɟɫɬɨ
ɜ ɪɚɡɪɚɛɚɬɵɜɚɟɦɨɦ ɤɨɞɟ. ȼ ɱɢɫɥɨ ɬɚɤɢɯ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɜɯɨɞɹɬ ɢ ɚɜɬɨɪɵ ɷɬɨɣ ɤɧɢɝɢ, ɢ ɜɵ.
ɉɨɞɭɦɚɣɬɟ ɫɚɦɢ — ɫɨɜɪɟɦɟɧɧɵɟ ɤɨɦɩɶɸɬɟɪɵ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɢɫɤɥɸɱɢɬɟɥɶɧɨ ɫɥɨɠɧɵɟ
ɜɵɱɢɫɥɢɬɟɥɶɧɵɟ ɦɨɞɟɥɢ, ɡɚɱɚɫɬɭɸ ɫ ɧɟɫɤɨɥɶɤɢɦɢ ɪɚɛɨɬɚɸɳɢɦɢ ɩɚɪɚɥɥɟɥɶɧɨ ɩɪɨɰɟɫɫɨɪɚɦɢ,
ɝɥɭɛɨɤɨɣ ɢɟɪɚɪɯɢɟɣ ɤɷɲɢɪɨɜɚɧɢɹ, ɩɪɟɞɫɤɚɡɚɧɢɟɦ ɜɟɬɜɥɟɧɢɹ, ɤɨɧɜɟɣɟɪɢɡɚɰɢɟɣ ɢ ɦɧɨɝɢɦ-
ɦɧɨɝɢɦ ɞɪɭɝɢɦ. Ʉɨɦɩɢɥɹɬɨɪ, ɧɚɯɨɞɹɳɢɣɫɹ ɧɚɞ ɜɫɟɦ ɷɬɢɦ ɚɩɩɚɪɚɬɧɵɦ ɨɛɟɫɩɟɱɟɧɢɟɦ, ɩɪɟɨɛ-
ɪɚɡɭɟɬ ɜɚɲ ɢɫɯɨɞɧɵɣ ɤɨɞ ɜ ɦɚɲɢɧɧɵɣ, ɨɫɧɨɜɵɜɚɹɫɶ ɧɚ ɫɨɛɫɬɜɟɧɧɨɦ ɡɧɚɧɢɢ ɚɩɩɚɪɚɬɧɨɝɨ
ɨɛɟɫɩɟɱɟɧɢɹ ɢ ɟɝɨ ɨɫɨɛɟɧɧɨɫɬɟɣ, ɫ ɬɟɦ ɱɬɨɛɵ ɷɬɨɬ ɤɨɞ ɜ ɦɚɤɫɢɦɚɥɶɧɨɣ ɫɬɟɩɟɧɢ ɢɫɩɨɥɶɡɨɜɚɥ
ɜɫɟ ɜɨɡɦɨɠɧɨɫɬɢ ɚɩɩɚɪɚɬɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ. ɇɚɞ ɤɨɦɩɢɥɹɬɨɪɨɦ ɧɚɯɨɞɢɬɟɫɶ ɜɵ, ɫ ɜɚɲɢɦɢ
ɩɪɟɞɫɬɚɜɥɟɧɢɹɦɢ ɨ ɬɨɦ, ɤɚɤ ɞɨɥɠɟɧ ɪɚɛɨɬɚɬɶ ɬɨɬ ɢɥɢ ɢɧɨɣ ɤɨɞ. ɍ ɜɚɫ ɩɪɚɤɬɢɱɟɫɤɢ ɧɟɬ ɲɚɧ-
ɫɨɜ ɜɧɟɫɬɢ ɬɚɤɭɸ ɦɢɤɪɨɨɩɬɢɦɢɡɚɰɢɸ, ɤɨɬɨɪɚɹ ɜ ɫɨɫɬɨɹɧɢɢ ɫɭɳɟɫɬɜɟɧɧɨ ɩɨɜɵɫɢɬɶ ɩɪɨɢɡɜɨ-
ɞɢɬɟɥɶɧɨɫɬɶ ɝɟɧɟɪɢɪɭɟɦɨɝɨ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦ ɤɨɦɩɢɥɹɬɨɪɨɦ ɤɨɞɚ. ɂɬɚɤ, ɨɩɬɢɦɢɡɚɰɢɢ
ɞɨɥɠɧɵ ɩɪɟɞɲɟɫɬɜɨɜɚɬɶ ɢɡɦɟɪɟɧɢɹ, ɚ ɢɡɦɟɪɟɧɢɹɦ ɞɨɥɠɧɚ ɩɪɟɞɲɟɫɬɜɨɜɚɬɶ ɜɵɪɚɛɨɬɤɚ ɰɟɥɟɣ
8. Не оптимизируйте преждевременно 29
Стр. 29
ɨɩɬɢɦɢɡɚɰɢɢ. ɉɨɤɚ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɨɩɬɢɦɢɡɚɰɢɢ ɧɟ ɞɨɤɚɡɚɧɚ — ɜɚɲɢɦ ɩɪɢɨɪɢɬɟɬɨɦ ʋ1
ɞɨɥɠɧɨ ɛɵɬɶ ɧɚɩɢɫɚɧɢɟ ɤɨɞɚ ɞɥɹ ɱɟɥɨɜɟɤɚ. (ȿɫɥɢ ɤɬɨ-ɬɨ ɩɨɬɪɟɛɭɟɬ ɨɬ ɜɚɫ ɨɩɬɢɦɢɡɚɰɢɢ ɤɨ-
ɞɚ — ɩɨɬɪɟɛɭɣɬɟ ɞɨɤɚɡɚɬɟɥɶɫɬɜ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɷɬɨɝɨ.)
ȼɨ-ɜɬɨɪɵɯ, ɜ ɫɨɜɪɟɦɟɧɧɵɯ ɩɪɨɝɪɚɦɦɚɯ ɜɫɟ ɛɨɥɶɲɟ ɢ ɛɨɥɶɲɟ ɨɩɟɪɚɰɢɣ, ɫɤɨɪɨɫɬɶ ɪɚɛɨɬɵ
ɤɨɬɨɪɵɯ ɨɝɪɚɧɢɱɟɧɚ ɧɟ ɩɪɨɰɟɫɫɨɪɨɦ, ɚ, ɧɚɩɪɢɦɟɪ, ɪɚɛɨɬɨɣ ɫ ɩɚɦɹɬɶɸ, ɞɢɫɤɨɦ ɢɥɢ ɫɟɬɶɸ,
ɨɠɢɞɚɧɢɟɦ ɨɬɜɟɬɚ ɨɬ Web-ɫɟɪɜɢɫɚ ɢɥɢ ɛɚɡɵ ɞɚɧɧɵɯ. ȼ ɥɭɱɲɟɦ ɫɥɭɱɚɟ ɨɩɬɢɦɢɡɚɰɢɹ ɬɚɤɨɝɨ
ɤɨɞɚ ɩɪɢɜɟɞɟɬ ɤ ɬɨɦɭ, ɱɬɨ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɛɭɞɟɬ ɛɵɫɬɪɟɟ ɨɠɢɞɚɬɶ. ɗɬɨ ɬɚɤɠɟ ɨɡɧɚɱɚɟɬ, ɱɬɨ
ɩɪɨɝɪɚɦɦɢɫɬ ɡɪɹ ɬɪɚɬɢɬ ɞɪɚɝɨɰɟɧɧɨɟ ɜɪɟɦɹ ɧɚ ɭɥɭɱɲɟɧɢɟ ɬɨɝɨ, ɱɬɨ ɧɟ ɬɪɟɛɭɟɬ ɭɥɭɱɲɟɧɢɣ,
ɜɦɟɫɬɨ ɬɨɝɨ, ɱɬɨɛɵ ɡɚɧɹɬɶɫɹ ɬɟɦ, ɱɬɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɬɪɟɛɭɟɬ ɟɝɨ ɜɦɟɲɚɬɟɥɶɫɬɜɚ.
ɋɚɦɨ ɫɨɛɨɣ ɪɚɡɭɦɟɟɬɫɹ, ɧɚɫɬɚɧɟɬ ɞɟɧɶ, ɤɨɝɞɚ ɜɚɦ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɩɪɢɞɟɬɫɹ ɡɚɧɹɬɶɫɹ ɨɩɬɢ-
ɦɢɡɚɰɢɟɣ ɜɚɲɟɝɨ ɤɨɞɚ. Ʉɨɝɞɚ ɜɵ ɡɚɣɦɟɬɟɫɶ ɷɬɢɦ — ɧɚɱɧɢɬɟ ɫ ɨɩɬɢɦɢɡɚɰɢɢ ɚɥɝɨɪɢɬɦɨɜ
(ɪɟɤɨɦɟɧɞɚɰɢɹ 7) ɢ ɩɨɩɵɬɚɣɬɟɫɶ ɢɧɤɚɩɫɭɥɢɪɨɜɚɬɶ ɨɩɬɢɦɢɡɚɰɢɸ (ɧɚɩɪɢɦɟɪ, ɜ ɩɪɟɞɟɥɚɯ ɮɭɧɤ-
ɰɢɢ ɢɥɢ ɤɥɚɫɫɚ, ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 5 ɢ 11), ɱɟɬɤɨ ɭɤɚɡɚɜ ɜ ɤɨɦɦɟɧɬɚɪɢɹɯ ɩɪɢɱɢɧɭ ɩɪɨɜɨɞɢɦɨɣ
ɨɩɬɢɦɢɡɚɰɢɢ ɢ ɫɫɵɥɤɭ ɧɚ ɢɫɩɨɥɶɡɨɜɚɧɧɵɣ ɚɥɝɨɪɢɬɦ.
Ɉɛɵɱɧɚɹ ɨɲɢɛɤɚ ɧɨɜɢɱɤɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɤɨɝɞɚ ɨɧ ɩɢɲɟɬ ɧɨɜɵɣ ɤɨɞ, ɬɨ — ɫ ɝɨɪɞɨ-
ɫɬɶɸ! — ɫɬɚɪɚɟɬɫɹ ɫɞɟɥɚɬɶ ɟɝɨ ɨɩɬɢɦɚɥɶɧɵɦ ɰɟɧɨɣ ɩɨɧɹɬɧɨɫɬɢ. ɑɚɳɟ ɜɫɟɝɨ ɷɬɨ ɩɪɢɜɨɞɢɬ
ɤ ɦɢɥɹɦ “ɫɩɚɝɟɬɬɢ” (ɝɨɜɨɪɹ ɩɪɨɳɟ — ɤ “ɫɨɩɥɹɦ” ɜ ɩɪɨɝɪɚɦɦɟ), ɢ ɞɚɠɟ ɤɨɪɪɟɤɬɧɨ ɪɚɛɨɬɚɸ-
ɳɢɣ ɤɨɞ ɫɬɚɧɨɜɢɬɫɹ ɨɱɟɧɶ ɬɪɭɞɧɨ ɱɢɬɚɬɶ ɢ ɦɨɞɢɮɢɰɢɪɨɜɚɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6).
ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɫɫɵɥɤɟ (ɪɟɤɨɦɟɧɞɚɰɢɹ 25), ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɩɪɟɮɢɤɫɧɨɣ ɮɨɪɦɵ
ɨɩɟɪɚɬɨɪɨɜ ++ ɢ -- (ɪɟɤɨɦɟɧɞɚɰɢɹ 28) ɢɥɢ ɩɨɞɨɛɧɵɯ ɢɞɢɨɦ, ɤɨɬɨɪɵɟ ɩɪɢ ɪɚɛɨɬɟ ɞɨɥɠɧɵ ɟɫ-
ɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ “ɫɬɟɤɚɬɶ ɫ ɤɨɧɱɢɤɨɜ ɜɚɲɢɯ ɩɚɥɶɰɟɜ”, ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɟɣ
ɧɟ ɹɜɥɹɸɬɫɹ. ɗɬɨ ɜɫɟɝɨ ɥɢɲɶ ɭɫɬɪɚɧɟɧɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɪɟɤɨɦɟɧɞɚɰɢɹ 9).
Примеры
ɉɪɢɦɟɪ. ɂɪɨɧɢɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ inline. ɗɬɨ ɩɪɨɫɬɟɣɲɚɹ ɞɟɦɨɧɫɬɪɚɰɢɹ ɫɤɪɵɬɨɣ ɫɬɨɢɦɨ-
ɫɬɢ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɦɢɤɪɨɨɩɬɢɦɢɡɚɰɢɢ. ɉɪɨɮɚɣɥɟɪɵ ɥɟɝɤɨ ɦɨɝɭɬ ɫɤɚɡɚɬɶ ɜɚɦ (ɢɫɫɥɟɞɨɜɚɜ
ɤɨɥɢɱɟɫɬɜɨ ɜɵɡɨɜɨɜ ɮɭɧɤɰɢɣ), ɤɚɤɢɟ ɮɭɧɤɰɢɢ ɞɨɥɠɧɵ ɛɵɬɶ ɜɫɬɪɚɢɜɚɟɦɵɦɢ, ɧɨ ɧɟ ɹɜɥɹɸɬɫɹ
ɬɚɤɨɜɵɦɢ. ɇɨ ɬɟ ɠɟ ɩɪɨɮɚɣɥɟɪɵ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɩɨɞɫɤɚɡɚɬɶ, ɤɚɤɢɟ ɜɫɬɪɚɢɜɚɟɦɵɟ ɮɭɧɤɰɢɢ ɧɟ
ɞɨɥɠɧɵ ɛɵɬɶ ɬɚɤɨɜɵɦɢ. Ɉɱɟɧɶ ɦɧɨɝɢɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɢɫɩɨɥɶɡɭɸɬ “ɜɫɬɪɚɢɜɚɧɢɟ ɩɨ ɭɦɨɥɱɚ-
ɧɢɸ” ɜɨ ɢɦɹ ɨɩɬɢɦɢɡɚɰɢɢ, ɩɨɱɬɢ ɜɫɟɝɞɚ ɡɚ ɫɱɟɬ ɛɨɥɶɲɟɣ ɫɜɹɡɧɨɫɬɢ ɩɪɨɝɪɚɦɦɵ ɞɨɫɬɢɝɚɹ
ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ ɜɟɫɶɦɚ ɫɨɦɧɢɬɟɥɶɧɵɯ ɪɟɡɭɥɶɬɚɬɨɜ. (ɋɤɚɡɚɧɧɨɟ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɞɟɥɚɬɶ ɮɭɧɤɰɢɸ
ɜɫɬɪɚɢɜɚɟɦɨɣ ɞɨɥɠɟɧ ɤɨɦɩɢɥɹɬɨɪ, ɚ ɧɟ ɩɪɨɝɪɚɦɦɢɫɬ. ɋɦ. [Sutter00], [Sutter02] ɢ [Sutter04].)
Ʉɨɝɞɚ ɜɵ ɩɢɲɟɬɟ ɛɢɛɥɢɨɬɟɤɢ, ɬɪɭɞɧɨ ɩɪɟɞɫɤɚɡɚɬɶ, ɤɚɤɢɟ ɨɩɟɪɚɰɢɢ ɛɭɞɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜ
ɤɪɢɬɢɱɧɨɦ ɩɨ ɨɬɧɨɲɟɧɢɸ ɤ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɤɨɞɟ. ɇɨ ɞɚɠɟ ɚɜɬɨɪ ɛɢɛɥɢɨɬɟɤɢ ɞɨɥɠɟɧ ɢɫ-
ɩɵɬɚɬɶ ɫɜɨɣ ɤɨɞ ɧɚ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɶ ɜ ɪɚɡɧɨɨɛɪɚɡɧɵɯ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɩɪɢɥɨɠɟɧɢɹɯ ɩɟ-
ɪɟɞ ɬɟɦ, ɤɚɤ ɭɫɥɨɠɧɹɬɶ ɫɜɨɣ ɤɨɞ ɨɩɬɢɦɢɡɚɰɢɟɣ.
Ссылки
[Bentley00] §6 • [Cline99] §13.01-09 • [Kernighan99] §7 • [Lakos96] §9.1.14 • [Meyers97] §33 •
[Murray93] §9.9-10, §9.13 • [Stroustrup00] §6 introduction • [Sutter00] §30, §46 • [Sutter02] §12 •
[Sutter04] §25
Стр. 30
9. Не пессимизируйте преждевременно
Резюме
Ɍɨ, ɱɬɨ ɩɪɨɫɬɨ ɞɥɹ ɜɚɫ, — ɩɪɨɫɬɨ ɢ ɞɥɹ ɤɨɞɚ. ɉɪɢ ɩɪɨɱɢɯ ɪɚɜɧɵɯ ɭɫɥɨɜɢɹɯ, ɜ ɨɫɨɛɟɧɧɨ-
ɫɬɢ — ɫɥɨɠɧɨɫɬɢ ɢ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɢ ɤɨɞɚ, ɪɹɞ ɷɮɮɟɤɬɢɜɧɵɯ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
ɢ ɢɞɢɨɦ ɤɨɞɢɪɨɜɚɧɢɹ ɞɨɥɠɧɵ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ “ɫɬɟɤɚɬɶ ɫ ɤɨɧɱɢɤɨɜ ɜɚɲɢɯ ɩɚɥɶɰɟɜ” ɢ
ɛɵɬɶ ɧɟ ɫɥɨɠɧɟɟ ɜ ɧɚɩɢɫɚɧɢɢ, ɱɟɦ ɢɯ ɩɟɫɫɢɦɢɡɢɪɨɜɚɧɧɵɟ ɚɥɶɬɟɪɧɚɬɢɜɵ. ɗɬɨ ɧɟ ɩɪɟɠɞɟɜɪɟ-
ɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ, ɚ ɢɡɛɟɠɚɧɢɟ ɢɡɥɢɲɧɟɣ ɩɟɫɫɢɦɢɡɚɰɢɢ.
ɂɡɛɟɠɚɧɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ ɧɟ ɜɥɟɱɟɬ ɡɚ ɫɨɛɨɣ ɫɧɢɠɟɧɢɹ ɷɮɮɟɤɬɢɜɧɨɫɬɢ.
ɉɨɞ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɟɣ ɦɵ ɩɨɞɪɚɡɭɦɟɜɚɟɦ ɧɚɩɢɫɚɧɢɟ ɬɚɤɢɯ ɧɟɨɩɪɚɜɞɚɧɧɵɯ
ɩɨɬɟɧɰɢɚɥɶɧɨ ɧɟɷɮɮɟɤɬɢɜɧɵɯ ɜɟɳɟɣ, ɤɚɤ ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɧɢɠɟ.
• ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ ɬɚɦ, ɝɞɟ ɩɪɢɦɟɧɢɦɚ ɩɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɫɫɵɥɤɟ
(ɪɟɤɨɦɟɧɞɚɰɢɹ 25).
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɩɨɫɬɮɢɤɫɧɨɣ ɜɟɪɫɢɢ ++ ɬɚɦ, ɝɞɟ ɫ ɬɟɦ ɠɟ ɭɫɩɟɯɨɦ ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨ-
ɜɚɬɶɫɹ ɩɪɟɮɢɤɫɧɨɣ ɜɟɪɫɢɟɣ (ɪɟɤɨɦɟɧɞɚɰɢɹ 28).
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɩɪɢɫɜɚɢɜɚɧɢɹ ɜ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɜɦɟɫɬɨ ɫɩɢɫɤɚ ɢɧɢɰɢɚɥɢɡɚɰɢɢ
(ɪɟɤɨɦɟɧɞɚɰɢɹ 48).
ɇɟ ɹɜɥɹɟɬɫɹ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɟɣ ɫɧɢɠɟɧɢɟ ɤɨɥɢɱɟɫɬɜɚ ɮɢɤɬɢɜɧɵɯ ɜɪɟɦɟɧɧɵɯ
ɤɨɩɢɣ ɨɛɴɟɤɬɨɜ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɜɨ ɜɧɭɬɪɟɧɧɢɯ ɰɢɤɥɚɯ, ɟɫɥɢ ɷɬɨ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɭɫɥɨɠɧɟɧɢɸ ɤɨɞɚ.
ȼ ɪɟɤɨɦɟɧɞɚɰɢɢ 18 ɩɨɨɳɪɹɟɬɫɹ ɦɚɤɫɢɦɚɥɶɧɨ ɥɨɤɚɥɶɧɨɟ ɨɛɴɹɜɥɟɧɢɟ ɩɟɪɟɦɟɧɧɵɯ, ɧɨ ɬɚɦ ɠɟ
ɩɪɢɜɟɞɟɧɨ ɢ ɨɩɢɫɚɧɢɟ ɢɫɤɥɸɱɟɧɢɹ — ɜɨɡɦɨɠɧɵɣ ɜɵɧɨɫ ɩɟɪɟɦɟɧɧɵɯ ɢɡ ɰɢɤɥɚ. ȼ ɛɨɥɶɲɢɧɫɬɜɟ
ɫɥɭɱɚɟɜ ɬɚɤɨɟ ɞɟɣɫɬɜɢɟ ɧɟ ɭɫɥɨɠɧɹɟɬ ɩɨɧɢɦɚɧɢɟ ɩɪɟɞɧɚɡɧɚɱɟɧɢɹ ɤɨɞɚ, ɛɨɥɟɟ ɬɨɝɨ, ɦɨɠɟɬ ɩɨ-
ɦɨɱɶ ɩɨɹɫɧɢɬɶ, ɱɬɨ ɢɦɟɧɧɨ ɞɟɥɚɟɬɫɹ ɜ ɰɢɤɥɟ ɢ ɤɚɤɢɟ ɜɵɱɢɫɥɟɧɢɹ ɹɜɥɹɸɬɫɹ ɟɝɨ ɢɧɜɚɪɢɚɧɬɚɦɢ.
Ʉɨɧɟɱɧɨ ɠɟ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɝɨɬɨɜɵɟ ɚɥɝɨɪɢɬɦɵ ɜɦɟɫɬɨ ɧɚɩɢɫɚɧɢɹ ɹɜɧɵɯ ɰɢɤ-
ɥɨɜ (ɪɟɤɨɦɟɧɞɚɰɢɹ 84).
Ⱦɜɚ ɜɚɠɧɵɯ ɫɩɨɫɨɛɚ ɭɫɨɜɟɪɲɟɧɫɬɜɨɜɚɧɢɹ ɩɪɨɝɪɚɦɦɵ, ɤɨɬɨɪɵɟ ɞɟɥɚɸɬ ɟɟ ɨɞɧɨɜɪɟɦɟɧɧɨ
ɢ ɹɫɧɟɟ, ɢ ɷɮɮɟɤɬɢɜɧɟɟ — ɷɬɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɚɛɫɬɪɚɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 11 ɢ 36) ɢ ɛɢɛ-
ɥɢɨɬɟɤ (ɪɟɤɨɦɟɧɞɚɰɢɹ 84). ɇɚɩɪɢɦɟɪ, ɢɫɩɨɥɶɡɨɜɚɧɢɟ vector, list, map, find, sort ɢ ɞɪɭ-
ɝɢɯ ɜɨɡɦɨɠɧɨɫɬɟɣ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ, ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɧɧɵɯ ɢ ɪɟɚɥɢɡɨɜɚɧɧɵɯ ɷɤɫɩɟɪ-
ɬɚɦɢ ɦɢɪɨɜɨɝɨ ɤɥɚɫɫɚ, ɧɟ ɬɨɥɶɤɨ ɞɟɥɚɸɬ ɜɚɲ ɤɨɞ ɹɫɧɟɟ ɢ ɥɟɝɱɟ ɩɨɧɢɦɚɟɦɵɦ, ɧɨ ɡɚɱɚɫɬɭɸ ɢ
ɛɨɥɟɟ ɛɵɫɬɪɵɦ.
ɂɡɛɟɠɚɧɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ ɫɬɚɧɨɜɢɬɫɹ ɨɫɨɛɟɧɧɨ ɜɚɠɧɵɦ, ɤɨɝɞɚ ɜɵ ɩɢ-
ɲɟɬɟ ɛɢɛɥɢɨɬɟɤɭ. ɉɪɢ ɷɬɨɦ ɜɵ ɨɛɵɱɧɨ ɧɟ ɡɧɚɟɬɟ ɤɨɧɬɟɤɫɬɚ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜɚɲɟɣ ɛɢɛɥɢɨɬɟɤɢ,
ɚ ɩɨɷɬɨɦɭ ɞɨɥɠɧɵ ɫɭɦɟɬɶ ɫɛɚɥɚɧɫɢɪɨɜɚɬɶ ɷɮɮɟɤɬɢɜɧɨɫɬɶ ɢ ɜɨɡɦɨɠɧɨɫɬɶ ɩɨɜɬɨɪɧɨɝɨ ɢɫɩɨɥɶ-
ɡɨɜɚɧɢɹ. ɇɟ ɡɚɛɵɜɚɣɬɟ ɭɪɨɤɨɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 7 — ɫɥɟɞɭɟɬ ɤɭɞɚ ɛɨɥɶɲɟ ɡɚɛɨɬɢɬɶɫɹ ɨ ɦɚɫɲɬɚ-
ɛɢɪɭɟɦɨɫɬɢ, ɱɟɦ ɨ ɜɵɢɝɪɵɲɟ ɩɚɪɵ ɬɚɤɬɨɜ ɩɪɨɰɟɫɫɨɪɚ.
Ссылки
[Keffer95] pp.12-13 • [Stroustrup00] §6 introduction • [Sutter00] §6
9. Не пессимизируйте преждевременно 31
Стр. 31
10. Минимизируйте глобальные и совместно
используемые данные
Резюме
ɋɨɜɦɟɫɬɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɜɵɡɵɜɚɟɬ ɫɩɨɪɵ ɢ ɪɚɡɞɨɪɵ. ɂɡɛɟɝɚɣɬɟ ɫɨɜɦɟɫɬɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɹ ɞɚɧɧɵɯ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɝɥɨɛɚɥɶɧɵɯ ɞɚɧɧɵɯ. ɋɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ ɭɫɢɥɢɜɚɸɬ
ɫɜɹɡɧɨɫɬɶ, ɱɬɨ ɩɪɢɜɨɞɢɬ ɤ ɫɧɢɠɟɧɢɸ ɫɨɩɪɨɜɨɠɞɚɟɦɨɫɬɢ, ɚ ɡɚɱɚɫɬɭɸ ɢ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ.
ɗɬɨ ɭɬɜɟɪɠɞɟɧɢɟ ɧɨɫɢɬ ɛɨɥɟɟ ɨɛɳɢɣ ɯɚɪɚɤɬɟɪ, ɱɟɦ ɛɨɥɟɟ ɭɡɤɨɟ ɬɪɟɛɨɜɚɧɢɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 18.
ɋɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ ɞɚɧɧɵɯ ɫɨ ɜɧɟɲɧɢɦ ɫɜɹɡɵɜɚɧɢɟɦ ɜ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɩɪɨɫɬɪɚɧɫɬɜɚ
ɢɦɟɧ ɢɥɢ ɩɪɟɞɫɬɚɜɥɹɸɳɢɯ ɫɨɛɨɣ ɫɬɚɬɢɱɟɫɤɢɟ ɱɥɟɧɵ ɤɥɚɫɫɨɜ. ɂɯ ɩɪɢɦɟɧɟɧɢɟ ɭɫɥɨɠɧɹɟɬ ɥɨ-
ɝɢɤɭ ɩɪɨɝɪɚɦɦɵ ɢ ɩɪɢɜɨɞɢɬ ɤ ɬɟɫɧɨɣ ɫɜɹɡɢ ɦɟɠɞɭ ɪɚɡɥɢɱɧɵɦɢ (ɢ, ɱɬɨ ɟɳɟ ɯɭɠɟ, ɨɬɞɚɥɟɧɧɵ-
ɦɢ) ɱɚɫɬɹɦɢ ɩɪɨɝɪɚɦɦɵ. ɋɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ ɞɟɥɚɸɬ ɦɟɧɟɟ ɷɮɮɟɤɬɢɜɧɵɦ ɬɟɫ-
ɬɢɪɨɜɚɧɢɟ ɦɨɞɭɥɟɣ, ɩɨɫɤɨɥɶɤɭ ɤɨɪɪɟɤɬɧɨɫɬɶ ɮɪɚɝɦɟɧɬɚ ɤɨɞɚ, ɢɫɩɨɥɶɡɭɸɳɟɝɨ ɨɛɳɢɟ ɞɚɧɧɵɟ,
ɨɛɭɫɥɨɜɥɟɧɚ ɢɫɬɨɪɢɟɣ ɢɡɦɟɧɟɧɢɹ ɷɬɢɯ ɞɚɧɧɵɯ, ɚ ɤɪɨɦɟ ɬɨɝɨ, ɨɛɭɫɥɚɜɥɢɜɚɟɬ ɮɭɧɤɰɢɨɧɢɪɨɜɚ-
ɧɢɟ ɧɟɤɨɬɨɪɨɝɨ, ɩɨɤɚ ɧɟɢɡɜɟɫɬɧɨɝɨ, ɤɨɞɚ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɬɢ ɞɚɧɧɵɟ ɩɨɡɠɟ.
ɂɦɟɧɚ ɨɛɴɟɤɬɨɜ ɜ ɝɥɨɛɚɥɶɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɩɪɢɜɨɞɹɬ ɤ ɟɝɨ ɞɨɩɨɥɧɢɬɟɥɶɧɨɦɭ ɡɚɫɨɪɟɧɢɸ.
ȿɫɥɢ ɜɚɦ ɧɢɤɚɤ ɧɟ ɨɛɨɣɬɢɫɶ ɛɟɡ ɝɥɨɛɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ, ɨɛɴɟɤɬɨɜ ɜ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɩɪɨ-
ɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢɥɢ ɫɬɚɬɢɱɟɫɤɢɯ ɱɥɟɧɨɜ ɤɥɚɫɫɨɜ, ɭɛɟɞɢɬɟɫɶ ɜ ɢɯ ɤɨɪɪɟɤɬɧɨɣ ɢɧɢɰɢɚɥɢɡɚɰɢɢ.
ɉɨɪɹɞɨɤ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɬɚɤɢɯ ɨɛɴɟɤɬɨɜ ɢɡ ɪɚɡɧɵɯ ɟɞɢɧɢɰ ɤɨɦɩɢɥɹɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ, ɩɨɷɬɨ-
ɦɭ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɬɪɟɛɭɸɬɫɹ ɫɩɟɰɢɚɥɶɧɵɟ ɦɟɬɨɞɢɤɢ (ɫɦ. ɩɪɢɥɚɝɚɟɦɵɟ
ɫɫɵɥɤɢ). ɉɪɚɜɢɥɚ ɩɨɪɹɞɤɚ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɞɨɫɬɚɬɨɱɧɨ ɫɥɨɠɧɵ, ɩɨɷɬɨɦɭ ɥɭɱɲɟ ɢɯ ɢɡɛɟɝɚɬɶ; ɧɨ
ɟɫɥɢ ɜɵ ɜɫɟ ɠɟ ɜɵɧɭɠɞɟɧɵ ɢɦɟɬɶ ɫ ɧɢɦɢ ɞɟɥɨ, ɬɨ ɞɨɥɠɧɵ ɯɨɪɨɲɨ ɢɯ ɢɡɭɱɢɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɫ ɜɟɥɢɱɚɣɲɟɣ ɨɫɬɨɪɨɠɧɨɫɬɶɸ.
Ɉɛɴɟɤɬɵ, ɧɚɯɨɞɹɳɢɟɫɹ ɜ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ, ɫɬɚɬɢɱɟɫɤɢɟ ɱɥɟɧɵ ɢɥɢ
ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɪɚɡɧɵɦɢ ɩɨɬɨɤɚɦɢ ɢɥɢ ɩɪɨɰɟɫɫɚɦɢ, ɫɧɢɠɚɸɬ ɭɪɨɜɟɧɶ ɪɚɫɩɚɪɚɥɥɟ-
ɥɢɜɚɧɢɹ ɜ ɦɧɨɝɨɩɨɬɨɱɧɵɯ ɢ ɦɧɨɝɨɩɪɨɰɟɫɫɨɪɧɵɯ ɫɪɟɞɚɯ, ɢ ɱɚɫɬɨ ɹɜɥɹɸɬɫɹ ɭɡɤɢɦ ɦɟɫɬɨɦ ɫ
ɬɨɱɤɢ ɡɪɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɢ ɦɚɫɲɬɚɛɢɪɭɟɦɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 7). ɋɬɚɪɚɣɬɟɫɶ
ɢɡɛɚɜɢɬɶɫɹ ɨɬ ɫɨɜɦɟɫɬɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɞɚɧɧɵɯ; ɢɫɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɧɟɝɨ ɫɪɟɞɫɬɜɚ ɤɨɦɦɭ-
ɧɢɤɚɰɢɢ (ɧɚɩɪɢɦɟɪ, ɨɱɟɪɟɞɶ ɫɨɨɛɳɟɧɢɣ).
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɨɛɟɫɩɟɱɢɬɶ ɧɢɡɤɭɸ ɫɜɹɡɧɨɫɬɶ ɢ ɦɢɧɢɦɢɡɢɪɨɜɚɬɶ ɜɡɚɢɦɨɞɟɣɫɬɜɢɟ ɤɥɚɫ-
ɫɨɜ (ɫɦ. [Cargill92]).
Ɍɚɤɢɟ ɫɪɟɞɫɬɜɚ ɭɪɨɜɧɹ ɩɪɨɝɪɚɦɦɵ, ɤɚɤ cin, cout ɢ cerr, ɹɜɥɹɸɬɫɹ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧɧɵ-
ɦɢ ɢ ɪɟɚɥɢɡɭɸɬɫɹ ɫɩɟɰɢɚɥɶɧɵɦ ɨɛɪɚɡɨɦ. Ɏɚɛɪɢɤɚ ɞɨɥɠɧɚ ɩɨɞɞɟɪɠɢɜɚɬɶ ɪɟɟɫɬɪ ɮɭɧɤɰɢɣ, ɤɨ-
ɬɨɪɵɟ ɞɨɥɠɧɵ ɜɵɡɵɜɚɬɶɫɹ ɞɥɹ ɫɨɡɞɚɧɢɹ ɞɚɧɧɨɝɨ ɬɢɩɚ, ɢ ɬɚɤɨɣ ɪɟɟɫɬɪ ɨɛɵɱɧɨ ɨɞɢɧ ɧɚ ɜɫɸ
ɩɪɨɝɪɚɦɦɭ (ɬɟɦ ɧɟ ɦɟɧɟɟ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ, ɱɬɨɛɵ ɨɧ ɛɵɥ ɜɧɭɬɪɟɧɧɢɦ ɨɛɴɟɤɬɨɦ ɩɨ ɨɬɧɨɲɟ-
ɧɢɸ ɤ ɮɚɛɪɢɤɟ, ɚ ɧɟ ɝɥɨɛɚɥɶɧɵɦ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɦ ɨɛɴɟɤɬɨɦ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11).
Ʉɨɞ, ɜ ɤɨɬɨɪɨɦ ɨɛɴɟɤɬ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɬɫɹ ɪɚɡɧɵɦɢ ɩɨɬɨɤɚɦɢ, ɞɨɥɠɟɧ ɨɛɟɫɩɟɱɢɬɶ ɫɟ-
ɪɢɚɥɢɡɚɰɢɸ ɨɛɪɚɳɟɧɢɣ ɤ ɬɚɤɨɦɭ ɨɛɴɟɤɬɭ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 12 ɢ [Sutter04c]).
Ссылки
[Cargill92] pp. 126.136, 169-173 • [Dewhurst03] §3 • [Lakos96] §2.3.1 • [McConnell93] §5.1-4 •
[Stroustrup00] §C.10.1 • [Sutter00] §47 • [Sutter02] §16, Appendix A • [Sutter04c] • [SuttHysl03]
Стр. 32
11. Сокрытие информации
Резюме
ɇɟ ɜɵɩɭɫɤɚɣɬɟ ɜɧɭɬɪɟɧɧɸɸ ɢɧɮɨɪɦɚɰɢɸ ɡɚ ɩɪɟɞɟɥɵ ɨɛɴɟɤɬɚ, ɨɛɟɫɩɟɱɢɜɚɸɳɟɝɨ ɚɛɫɬɪɚɤɰɢɸ.
Ⱦɥɹ ɦɢɧɢɦɢɡɚɰɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ ɦɟɠɞɭ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ ɪɚɛɨɬɚɟɬ ɫ ɚɛɫɬɪɚɤ-
ɰɢɟɣ, ɢ ɪɟɚɥɢɡɚɰɢɟɣ ɚɛɫɬɪɚɤɰɢɢ, ɜɧɭɬɪɟɧɧɢɟ ɞɚɧɧɵɟ ɬɚɤɨɣ ɪɟɚɥɢɡɚɰɢɢ ɞɨɥɠɧɵ ɛɵɬɶ ɫɤɪɵɬɵ.
ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɦɨɠɟɬ ɨɛɪɚɬɢɬɶɫɹ ɤ ɷɬɨɣ ɢɧɮɨɪɦɚɰɢɢ (ɢɥɢ, ɱɬɨ ɟɳɟ
ɯɭɠɟ, ɢɡɦɟɧɢɬɶ ɟɟ), ɢ ɬɚɤɚɹ ɭɬɟɱɤɚ ɩɪɟɞɧɚɡɧɚɱɟɧɧɨɣ ɫɭɝɭɛɨ ɞɥɹ ɜɧɭɬɪɟɧɧɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ
ɢɧɮɨɪɦɚɰɢɹ ɞɟɥɚɟɬ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɡɚɜɢɫɢɦɵɦ ɨɬ ɜɧɭɬɪɟɧɧɟɝɨ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɚɛɫɬɪɚɤɰɢɢ.
Ɉɬɤɪɵɜɚɬɶ ɫɥɟɞɭɟɬ ɚɛɫɬɪɚɤɰɢɢ (ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɢɡ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɣ ɩɪɟɞɦɟɬɧɨɣ ɨɛɥɚɫɬɢ,
ɧɨ, ɤɚɤ ɦɢɧɢɦɭɦ, ɚɛɫɬɪɚɤɰɢɸ get/set), ɚ ɧɟ ɞɚɧɧɵɟ.
ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ ɭɦɟɧɶɲɚɟɬ ɫɬɨɢɦɨɫɬɶ ɩɪɨɟɤɬɚ, ɫɪɨɤɢ ɪɚɡɪɚɛɨɬɤɢ ɢ/ɢɥɢ ɪɢɫɤ ɞɜɭɦɹ
ɨɫɧɨɜɧɵɦɢ ɩɭɬɹɦɢ.
• Ɉɧɨ ɥɨɤɚɥɢɡɭɟɬ ɢɡɦɟɧɟɧɢɹ. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ ɫɧɢɠɚɟɬ ɨɛɥɚɫɬɶ “ɷɮɮɟɤɬɚ ɜɨɥɧɵ”
ɜɧɨɫɢɦɨɝɨ ɢɡɦɟɧɟɧɢɹ ɢ, ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ, ɟɝɨ ɫɬɨɢɦɨɫɬɶ.
• Ɉɧɨ ɭɫɢɥɢɜɚɟɬ ɢɧɜɚɪɢɚɧɬɵ. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ ɨɝɪɚɧɢɱɢɜɚɟɬ ɤɨɞ, ɨɬɜɟɬɫɬɜɟɧɧɵɣ
ɡɚ ɫɨɯɪɚɧɟɧɢɟ (ɢ, ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ, ɡɚ ɧɚɪɭɲɟɧɢɟ) ɢɧɜɚɪɢɚɧɬɨɜ ɩɪɨɝɪɚɦɦɵ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 41).
ɇɟ ɩɨɡɜɨɥɹɣɬɟ “ɡɚɫɜɟɬɢɬɶɫɹ” ɞɚɧɧɵɦ ɢɡ ɥɸɛɨɝɨ ɨɛɴɟɤɬɚ, ɤɨɬɨɪɵɣ ɨɛɟɫɩɟɱɢɜɚɟɬ ɚɛɫɬɪɚɤɰɢɸ
(ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 10). Ⱦɚɧɧɵɟ — ɜɫɟɝɨ ɥɢɲɶ ɨɞɧɨ ɢɡ ɜɨɩɥɨɳɟɧɢɣ ɚɛɫɬɪɚɤɰɢɢ, ɤɨɧɰɟɩ-
ɬɭɚɥɶɧɨɟ ɫɨɫɬɨɹɧɢɟ. ȿɫɥɢ ɜɵ ɫɤɨɧɰɟɧɬɪɢɪɭɟɬɟɫɶ ɧɚ ɤɨɧɰɟɩɰɢɢ, ɚ ɧɟ ɧɚ ɟɟ ɩɪɟɞɫɬɚɜɥɟɧɢɹɯ, ɜɵ
ɫɦɨɠɟɬɟ ɩɪɟɞɥɨɠɢɬɶ ɜɞɭɦɱɢɜɵɣ ɢɧɬɟɪɮɟɣɫ, ɚ “ɜɵɥɢɡɚɬɶ” ɪɟɚɥɢɡɚɰɢɸ ɦɨɠɧɨ ɢ ɩɨɡɠɟ — ɧɚ-
ɩɪɢɦɟɪ, ɩɭɬɟɦ ɩɪɢɦɟɧɟɧɢɹ ɤɷɲɢɪɨɜɚɧɢɹ ɜɦɟɫɬɨ ɜɵɱɢɫɥɟɧɢɹ “ɧɚ ɥɟɬɭ”, ɢɥɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɪɚɡ-
ɥɢɱɧɵɯ ɨɩɬɢɦɢɡɢɪɭɸɳɢɯ ɩɪɟɞɫɬɚɜɥɟɧɢɣ (ɧɚɩɪɢɦɟɪ, ɩɨɥɹɪɧɵɯ ɤɨɨɪɞɢɧɚɬ ɜɦɟɫɬɨ ɞɟɤɚɪɬɨɜɵɯ).
Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɵɣ ɩɪɢɦɟɪ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɱɥɟɧɵ-ɞɚɧɧɵɟ ɤɥɚɫɫɨɜ ɧɢɤɨɝɞɚ ɧɟ ɞɟɥɚɸɬɫɹ
ɞɨɫɬɭɩɧɵɦɢ ɢɡɜɧɟ ɩɪɢ ɩɨɦɨɳɢ ɫɩɟɰɢɮɢɤɚɬɨɪɚ public (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41) ɢɥɢ ɩɨɫɪɟɞɫɬ-
ɜɨɦ ɭɤɚɡɚɬɟɥɟɣ ɢɥɢ ɞɟɫɤɪɢɩɬɨɪɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 42). ɗɬɨɬ ɩɪɢɧɰɢɩ ɜ ɬɨɣ ɠɟ ɫɬɟɩɟɧɢ
ɩɪɢɦɟɧɢɦ ɢ ɤ ɛɨɥɶɲɢɦ ɫɭɳɧɨɫɬɹɦ — ɧɚɩɪɢɦɟɪ, ɬɚɤɢɦ, ɤɚɤ ɛɢɛɥɢɨɬɟɤɢ, ɤɨɬɨɪɵɟ ɬɚɤɠɟ ɧɟ
ɞɨɥɠɧɵ ɪɚɡɪɟɲɚɬɶ ɞɨɫɬɭɩ ɤ ɜɧɭɬɪɟɧɧɟɣ ɢɧɮɨɪɦɚɰɢɢ ɢɡɜɧɟ. Ɇɨɞɭɥɢ ɢ ɛɢɛɥɢɨɬɟɤɢ ɞɨɥɠɧɵ
ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɢɧɬɟɪɮɟɣɫɵ, ɤɨɬɨɪɵɟ ɨɩɪɟɞɟɥɹɸɬ ɚɛɫɬɪɚɤɰɢɢ ɢ ɪɚɛɨɬɭ ɫ ɧɢɦɢ, ɢ ɬɚɤɢɦ ɨɛɪɚ-
ɡɨɦ ɨɛɟɫɩɟɱɢɜɚɸɬ ɛɨɥɶɲɭɸ ɛɟɡɨɩɚɫɧɨɫɬɶ ɞɥɹ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ ɢ ɦɟɧɶɲɭɸ ɫɜɹɡɧɨɫɬɶ, ɱɟɦ
ɩɪɢ ɩɪɢɦɟɧɟɧɢɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɞɚɧɧɵɯ.
Ɍɟɫɬɢɪɨɜɚɧɢɟ ɤɨɞɚ ɡɚɱɚɫɬɭɸ ɬɪɟɛɭɟɬ ɜɨɡɦɨɠɧɨɫɬɢ ɨɛɪɚɳɟɧɢɹ ɤɨ “ɜɧɭɬɪɟɧɧɨɫɬɹɦ” ɬɟɫɬɢ-
ɪɭɟɦɨɝɨ ɤɥɚɫɫɚ ɢɥɢ ɦɨɞɭɥɹ.
ɋɨɜɨɤɭɩɧɨɫɬɢ ɡɧɚɱɟɧɢɣ (struct ɜ ɫɬɢɥɟ C), ɤɨɬɨɪɵɟ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɩɪɨɫɬɨ ɧɚɛɨɪ
ɞɚɧɧɵɯ ɛɟɡ ɩɪɟɞɨɫɬɚɜɥɟɧɢɹ ɤɚɤɢɯ-ɥɢɛɨ ɚɛɫɬɪɚɤɰɢɣ, ɧɟ ɬɪɟɛɭɸɬ ɫɨɤɪɵɬɢɹ ɫɜɨɢɯ ɞɚɧɧɵɯ, ɤɨ-
ɬɨɪɵɟ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɹɜɥɹɸɬɫɹ ɢɧɬɟɪɮɟɣɫɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41).
Ссылки
[Brooks95] §19 • [McConnell93] §6.2 • [Parnas02] • [Stroustrup00] §24.4 • [SuttHysl04a]
11. Сокрытие информации 33
Стр. 33
12. Кодирование параллельных вычислений
Резюме
ȿɫɥɢ ɜɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɢɫɩɨɥɶɡɭɟɬ ɧɟɫɤɨɥɶɤɨ ɩɨɬɨɤɨɜ ɢɥɢ ɩɪɨɰɟɫɫɨɜ, ɫɥɟɞɭɟɬ ɦɢɧɢɦɢɡɢ-
ɪɨɜɚɬɶ ɤɨɥɢɱɟɫɬɜɨ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɨɛɴɟɤɬɨɜ, ɝɞɟ ɷɬɨ ɬɨɥɶɤɨ ɦɨɠɧɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 10), ɢ ɚɤɤɭɪɚɬɧɨ ɪɚɛɨɬɚɬɶ ɫ ɨɫɬɚɜɲɢɦɢɫɹ.
Ɋɚɛɨɬɚ ɫ ɩɨɬɨɤɚɦɢ — ɨɬɞɟɥɶɧɚɹ ɛɨɥɶɲɚɹ ɬɟɦɚ. Ⱦɚɧɧɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɨɤɚɡɚɥɚɫɶ ɜ ɤɧɢɝɟ,
ɩɨɬɨɦɭ ɱɬɨ ɷɬɚ ɬɟɦɚ ɨɱɟɧɶ ɜɚɠɧɚ ɢ ɬɪɟɛɭɟɬ ɪɚɫɫɦɨɬɪɟɧɢɹ. Ʉ ɫɨɠɚɥɟɧɢɸ, ɨɞɧɚ ɪɟɤɨɦɟɧɞɚɰɢɹ
ɧɟ ɜ ɫɢɥɚɯ ɫɞɟɥɚɬɶ ɷɬɨ ɩɨɥɧɨ ɢ ɤɨɪɪɟɤɬɧɨ, ɩɨɷɬɨɦɭ ɦɵ ɬɨɥɶɤɨ ɪɟɡɸɦɢɪɭɟɦ ɧɟɫɤɨɥɶɤɨ ɧɚɢɛɨ-
ɥɟɟ ɜɚɠɧɵɯ ɩɨɥɨɠɟɧɢɣ ɢ ɩɨɫɨɜɟɬɭɟɦ ɨɛɪɚɬɢɬɶɫɹ ɤ ɭɤɚɡɚɧɧɵɦ ɧɢɠɟ ɫɫɵɥɤɚɦ ɡɚ ɞɨɩɨɥɧɢɬɟɥɶ-
ɧɨɣ ɢɧɮɨɪɦɚɰɢɟɣ. ɋɪɟɞɢ ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɯ ɜɨɩɪɨɫɨɜ, ɤɚɫɚɸɳɢɯɫɹ ɩɚɪɚɥɥɟɥɶɧɵɯ ɜɵɱɢɫɥɟ-
ɧɢɣ, ɬɚɤɢɟ ɤɚɤ ɢɡɛɟɠɚɧɢɟ ɜɡɚɢɦɨɛɥɨɤɢɪɨɜɨɤ (deadlock), ɧɟɭɫɬɨɣɱɢɜɵɯ ɜɡɚɢɦɨɛɥɨɤɢɪɨɜɨɤ
(livelock) ɢ ɭɫɥɨɜɢɣ ɝɨɧɤɢ (race conditions).
ɋɬɚɧɞɚɪɬ C++ ɧɢɱɟɝɨ ɧɟ ɝɨɜɨɪɢɬ ɨ ɩɨɬɨɤɚɯ. Ɍɟɦ ɧɟ ɦɟɧɟɟ, C++ ɩɨɫɬɨɹɧɧɨ ɢ ɲɢɪɨɤɨ ɩɪɢɦɟ-
ɧɹɟɬɫɹ ɞɥɹ ɧɚɩɢɫɚɧɢɹ ɤɨɞɚ ɫ ɢɧɬɟɧɫɢɜɧɵɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɦɧɨɝɨɩɨɬɨɱɧɨɫɬɢ. ȿɫɥɢ ɜ ɜɚɲɟɦ
ɩɪɢɥɨɠɟɧɢɢ ɩɨɬɨɤɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɸɬ ɞɚɧɧɵɟ, ɧɚ ɷɬɨ ɫɥɟɞɭɟɬ ɨɛɪɚɬɢɬɶ ɨɫɨɛɨɟ ɜɧɢɦɚɧɢɟ.
• Ɉɡɧɚɤɨɦɶɬɟɫɶ ɫ ɞɨɤɭɦɟɧɬɚɰɢɟɣ ɩɨ ɰɟɥɟɜɨɣ ɩɥɚɬɮɨɪɦɟ ɧɚ ɩɪɟɞɦɟɬ ɥɨɤɚɥɶɧɵɯ ɩɪɢ-
ɦɢɬɢɜɨɜ ɫɢɧɯɪɨɧɢɡɚɰɢɢ. Ɉɛɵɱɧɨ ɨɧɢ ɨɯɜɚɬɵɜɚɸɬ ɞɢɚɩɚɡɨɧ ɨɬ ɩɪɨɫɬɵɯ ɚɬɨɦɚɪɧɵɯ
ɨɩɟɪɚɰɢɣ ɫ ɰɟɥɵɦɢ ɱɢɫɥɚɦɢ ɞɨ ɦɟɠɩɪɨɰɟɫɫɧɵɯ ɜɡɚɢɦɨɢɫɤɥɸɱɟɧɢɣ ɢ ɫɟɦɚɮɨɪɨɜ.
• ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ “ɨɛɟɪɧɭɬɶ” ɩɪɢɦɢɬɢɜɵ ɩɥɚɬɮɨɪɦɵ ɜ ɫɨɛɫɬɜɟɧɧɵɟ ɚɛɫɬɪɚɤɰɢɢ. ɗɬɨ
ɯɨɪɨɲɚɹ ɦɵɫɥɶ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɟɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɦɟɠɩɥɚɬɮɨɪɦɟɧɧɚɹ ɩɟɪɟɧɨɫɢɦɨɫɬɶ.
ȼɵ ɦɨɠɟɬɟ ɬɚɤɠɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɛɢɛɥɢɨɬɟɤɨɣ (ɧɚɩɪɢɦɟɪ, pthreads [Butenhof97]), ɤɨɬɨ-
ɪɚɹ ɫɞɟɥɚɟɬ ɷɬɨ ɡɚ ɜɚɫ.
• ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɜɚɦɢ ɬɢɩɵ ɦɨɠɧɨ ɛɟɡɨɩɚɫɧɨ ɩɪɢɦɟɧɹɬɶ ɜ ɦɧɨɝɨɩɨ-
ɬɨɱɧɵɯ ɩɪɨɝɪɚɦɦɚɯ. ȼ ɱɚɫɬɧɨɫɬɢ, ɤɚɠɞɵɣ ɬɢɩ ɞɨɥɠɟɧ ɤɚɤ ɦɢɧɢɦɭɦ
• ɝɚɪɚɧɬɢɪɨɜɚɬɶ ɧɟɡɚɜɢɫɢɦɨɫɬɶ ɨɛɴɟɤɬɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɨɜɦɟɫɬɧɨ.
Ⱦɜɚ ɩɨɬɨɤɚ ɦɨɝɭɬ ɫɜɨɛɨɞɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɪɚɡɥɢɱɧɵɟ ɨɛɴɟɤɬɵ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɫɩɟ-
ɰɢɚɥɶɧɵɯ ɞɟɣɫɬɜɢɣ ɫɨ ɫɬɨɪɨɧɵ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ;
• ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ ɫɨ ɫɬɨɪɨɧɵ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ ɩɪɢ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɢ ɨɞɧɨɝɨ ɨɛɴɟɤɬɚ ɜ ɪɚɡɧɵɯ ɩɨɬɨɤɚɯ. Ɇɧɨɝɢɟ ɬɢɩɵ ɬɪɟɛɭɸɬ ɫɟɪɢɚɥɢɡɚɰɢɢ
ɞɨɫɬɭɩɚ ɤ ɬɚɤɢɦ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɦ ɨɛɴɟɤɬɚɦ, ɧɨ ɟɫɬɶ ɬɢɩɵ, ɞɥɹ ɤɨɬɨɪɵɯ ɷɬɨ
ɭɫɥɨɜɢɟ ɧɟ ɹɜɥɹɟɬɫɹ ɨɛɹɡɚɬɟɥɶɧɵɦ. Ɉɛɵɱɧɨ ɬɚɤɢɟ ɬɢɩɵ ɥɢɛɨ ɫɩɪɨɟɤɬɢɪɨɜɚɧɵ ɬɚɤɢɦ
ɨɛɪɚɡɨɦ, ɱɬɨ ɢɡɛɟɝɚɸɬ ɬɪɟɛɨɜɚɧɢɣ ɛɥɨɤɢɪɨɜɤɢ, ɥɢɛɨ ɜɵɩɨɥɧɹɸɬ ɛɥɨɤɢɪɨɜɤɭ ɫɚɦɨ-
ɫɬɨɹɬɟɥɶɧɨ. ȼ ɥɸɛɨɦ ɫɥɭɱɚɟ, ɜɵ ɞɨɥɠɧɵ ɛɵɬɶ ɨɡɧɚɤɨɦɥɟɧɵ ɫ ɨɝɪɚɧɢɱɟɧɢɹɦɢ, ɧɚɤɥɚ-
ɞɵɜɚɟɦɵɦɢ ɢɫɩɨɥɶɡɭɟɦɵɦɢ ɜɚɦɢ ɬɢɩɚɦɢ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɫɤɚɡɚɧɧɨɟ ɜɵɲɟ ɩɪɢɦɟɧɢɦɨ ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɬɨɝɨ, ɹɜɥɹɟɬɫɹ ɥɢ ɬɢɩ ɧɟɤɨɬɨ-
ɪɵɦ ɫɬɪɨɤɨɜɵɦ ɬɢɩɨɦ, ɤɨɧɬɟɣɧɟɪɨɦ STL ɧɚɩɨɞɨɛɢɟ vector ɢɥɢ ɧɟɤɨɬɨɪɵɦ ɢɧɵɦ ɬɢ-
ɩɨɦ. (Ɇɵ ɡɚɦɟɬɢɥɢ, ɱɬɨ ɪɹɞ ɚɜɬɨɪɨɜ ɞɚɸɬ ɫɨɜɟɬɵ, ɢɡ ɤɨɬɨɪɵɯ ɜɵɬɟɤɚɟɬ, ɱɬɨ ɫɬɚɧɞɚɪɬ-
ɧɵɟ ɤɨɧɬɟɣɧɟɪɵ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɧɟɱɬɨ ɨɬɞɟɥɶɧɨɟ. ɗɬɨ ɧɟ ɬɚɤ — ɤɨɧɬɟɣɧɟɪ ɩɪɟɞ-
ɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɩɪɨɫɬɨ ɨɛɴɟɤɬ ɞɪɭɝɨɝɨ ɬɢɩɚ.) ȼ ɱɚɫɬɧɨɫɬɢ, ɟɫɥɢ ɜɵ ɯɨɬɢɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɤɨɦɩɨɧɟɧɬɵ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ (ɧɚɩɪɢɦɟɪ, string ɢɥɢ ɤɨɧɬɟɣɧɟɪɵ) ɜ ɦɧɨɝɨɩɨ-
ɬɨɱɧɨɣ ɩɪɨɝɪɚɦɦɟ, ɩɪɨɤɨɧɫɭɥɶɬɢɪɭɣɬɟɫɶ ɫɧɚɱɚɥɚ ɫ ɞɨɤɭɦɟɧɬɚɰɢɟɣ ɪɚɡɪɚɛɨɬɱɢɤɚ ɢɫ-
ɩɨɥɶɡɭɟɦɨɣ ɜɚɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ, ɱɬɨɛɵ ɭɡɧɚɬɶ, ɤɚɤ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɩɨɥɶɡɨ-
ɜɚɬɶɫɹ ɟɸ ɜ ɦɧɨɝɨɩɨɬɨɱɧɨɦ ɩɪɢɥɨɠɟɧɢɢ.
Стр. 34
ɉɪɢ ɪɚɡɪɚɛɨɬɤɟ ɫɨɛɫɬɜɟɧɧɨɝɨ ɬɢɩɚ, ɤɨɬɨɪɵɣ ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɦɧɨɝɨɩɨɬɨɱ-
ɧɨɣ ɩɪɨɝɪɚɦɦɟ, ɜɵ ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ ɬɟ ɠɟ ɞɜɟ ɜɟɳɢ. ȼɨ-ɩɟɪɜɵɯ, ɜɵ ɞɨɥɠɧɵ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ
ɪɚɡɥɢɱɧɵɟ ɩɨɬɨɤɢ ɦɨɝɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɪɚɡɥɢɱɧɵɟ ɨɛɴɟɤɬɵ ɜɚɲɟɝɨ ɬɢɩɚ ɛɟɡ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɛɥɨ-
ɤɢɪɨɜɨɤ (ɡɚɦɟɬɢɦ, ɱɬɨ ɨɛɵɱɧɨ ɬɢɩ ɫ ɢɡɦɟɧɹɟɦɵɦɢ ɫɬɚɬɢɱɟɫɤɢɦɢ ɞɚɧɧɵɦɢ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɨɛɟɫ-
ɩɟɱɢɬɶ ɬɚɤɭɸ ɝɚɪɚɧɬɢɸ). ȼɨ-ɜɬɨɪɵɯ, ɜɵ ɞɨɥɠɧɵ ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɢɦɟɧɧɨ ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ
ɩɨɥɶɡɨɜɚɬɟɥɢ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɛɟɡɨɩɚɫɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɨɛɴɟɤɬ ɜ ɪɚɡɧɵɯ ɩɨɬɨɤɚɯ.
Ɏɭɧɞɚɦɟɧɬɚɥɶɧɵɣ ɜɨɩɪɨɫ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɤɚɤ ɪɚɫɩɪɟɞɟɥɢɬɶ ɨɬɜɟɬɫɬɜɟɧ-
ɧɨɫɬɶ ɡɚ ɤɨɪɪɟɤɬɧɨɟ ɜɵɩɨɥɧɟɧɢɟ ɩɪɨɝɪɚɦɦɵ (ɛɟɡ ɭɫɥɨɜɢɣ ɝɨɧɤɢ ɢ ɜɡɚɢɦɨɛɥɨɤɢɪɨɜɨɤ) ɦɟɠɞɭ
ɤɥɚɫɫɨɦ ɢ ɟɝɨ ɤɥɢɟɧɬɨɦ. ȼɨɬ ɨɫɧɨɜɧɵɟ ɜɨɡɦɨɠɧɨɫɬɢ.
• ȼɧɟɲɧɹɹ ɛɥɨɤɢɪɨɜɤɚ. Ɂɚ ɛɥɨɤɢɪɨɜɤɭ ɨɬɜɟɱɚɟɬ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ. ɉɪɢ ɬɚɤɨɦ ɜɵɛɨɪɟ
ɤɨɞ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɨɛɴɟɤɬ, ɞɨɥɠɟɧ ɫɚɦ ɜɵɹɫɧɹɬɶ, ɢɫɩɨɥɶɡɭɟɬɫɹ ɥɢ ɷɬɨɬ ɨɛɴɟɤɬ
ɞɪɭɝɢɦɢ ɩɨɬɨɤɚɦɢ ɢ, ɟɫɥɢ ɷɬɨ ɬɚɤ, ɨɬɜɟɱɚɟɬ ɡɚ ɫɟɪɢɚɥɢɡɚɰɢɸ ɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ. ɇɚ-
ɩɪɢɦɟɪ, ɫɬɪɨɤɨɜɵɟ ɬɢɩɵ ɨɛɵɱɧɨ ɢɫɩɨɥɶɡɭɸɬ ɜɧɟɲɧɸɸ ɛɥɨɤɢɪɨɜɤɭ (ɢɥɢ ɧɟɢɡɦɟɧɹɟ-
ɦɨɫɬɶ — ɫɦ. ɬɪɟɬɶɸ ɜɨɡɦɨɠɧɨɫɬɶ).
• ȼɧɭɬɪɟɧɧɹɹ ɛɥɨɤɢɪɨɜɤɚ. Ʉɚɠɞɵɣ ɨɛɴɟɤɬ ɫɟɪɢɚɥɢɡɭɟɬ ɜɫɟ ɨɛɪɚɳɟɧɢɹ ɤ ɫɟɛɟ, ɨɛɵɱɧɨ
ɩɭɬɟɦ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɛɥɨɤɢɪɨɜɚɧɢɹ ɜɫɟɯ ɨɬɤɪɵɬɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɬɚɤ ɱɬɨ
ɩɨɥɶɡɨɜɚɬɟɥɸ ɧɟ ɧɚɞɨ ɩɪɟɞɩɪɢɧɢɦɚɬɶ ɧɢɤɚɤɢɯ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɞɟɣɫɬɜɢɣ ɩɨ ɫɟɪɢɚɥɢɡɚ-
ɰɢɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɨɛɴɟɤɬɚ. ɇɚɩɪɢɦɟɪ, ɨɱɟɪɟɞɢ ɩɪɨɢɡɜɨɞɢɬɟɥɶ/ɩɨɬɪɟɛɢɬɟɥɶ ɨɛɵɱɧɨ ɢɫ-
ɩɨɥɶɡɭɸɬ ɜɧɭɬɪɟɧɧɸɸ ɛɥɨɤɢɪɨɜɤɭ, ɩɨɫɤɨɥɶɤɭ ɫɚɦ ɫɦɵɫɥ ɢɯ ɫɭɳɟɫɬɜɨɜɚɧɢɹ ɫɨɫɬɨɢɬ ɜ ɫɨ-
ɜɦɟɫɬɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɪɚɡɧɵɦɢ ɩɨɬɨɤɚɦɢ, ɢ ɢɯ ɢɧɬɟɪɮɟɣɫɵ ɫɩɪɨɟɤɬɢɪɨɜɚɧɵ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɛɥɨɤɢɪɨɜɨɤ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɭɪɨɜɧɹ ɞɥɹ ɨɬɞɟɥɶɧɵɯ ɜɵɡɨɜɨɜ ɮɭɧɤ-
ɰɢɣ-ɱɥɟɧɨɜ (Push, Pop). ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɡɚɦɟɬɢɦ, ɱɬɨ ɷɬɨɬ ɜɚɪɢɚɧɬ ɩɪɢɦɟɧɢɦ, ɬɨɥɶɤɨ
ɟɫɥɢ ɜɵ ɡɧɚɟɬɟ ɞɜɟ ɜɟɳɢ.
ȼɨ-ɩɟɪɜɵɯ, ɜɵ ɞɨɥɠɧɵ ɡɚɪɚɧɟɟ ɡɧɚɬɶ ɨ ɬɨɦ, ɱɬɨ ɨɛɴɟɤɬɵ ɞɚɧɧɨɝɨ ɬɢɩɚ ɩɪɚɤɬɢɱɟɫɤɢ
ɜɫɟɝɞɚ ɛɭɞɭɬ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɪɚɡɧɵɦɢ ɩɨɬɨɤɚɦɢ; ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵ
ɩɪɨɫɬɨ ɪɚɡɪɚɛɨɬɚɟɬɟ ɛɟɫɩɨɥɟɡɧɭɸ ɛɥɨɤɢɪɨɜɤɭ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɛɨɥɶɲɢɧɫɬɜɨ ɬɢɩɨɜ ɧɟ
ɭɞɨɜɥɟɬɜɨɪɹɸɬ ɷɬɨɦɭ ɭɫɥɨɜɢɸ; ɩɨɞɚɜɥɹɸɳɟɟ ɛɨɥɶɲɢɧɫɬɜɨ ɨɛɴɟɤɬɨɜ ɞɚɠɟ ɜ ɩɪɨɝɪɚɦ-
ɦɚɯ ɫ ɢɧɬɟɧɫɢɜɧɵɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɦɧɨɝɨɩɨɬɨɱɧɨɫɬɢ ɧɟ ɪɚɡɞɟɥɹɸɬɫɹ ɪɚɡɧɵɦɢ ɩɨɬɨ-
ɤɚɦɢ (ɢ ɷɬɨ ɯɨɪɨɲɨ — ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 10).
ȼɨ-ɜɬɨɪɵɯ, ɜɵ ɞɨɥɠɧɵ ɡɚɪɚɧɟɟ ɛɵɬɶ ɭɜɟɪɟɧɵ, ɱɬɨ ɛɥɨɤɢɪɨɜɤɚ ɧɚ ɭɪɨɜɧɟ ɮɭɧɤɰɢɣ ɨɛɟɫ-
ɩɟɱɢɜɚɟɬ ɤɨɪɪɟɤɬɧɵɣ ɭɪɨɜɟɧɶ ɦɨɞɭɥɶɧɨɫɬɢ, ɤɨɬɨɪɨɝɨ ɞɨɫɬɚɬɨɱɧɨ ɞɥɹ ɛɨɥɶɲɢɧɫɬɜɚ ɜɵ-
ɡɵɜɚɸɳɢɣ ɮɭɧɤɰɢɣ. ȼ ɱɚɫɬɧɨɫɬɢ, ɢɧɬɟɪɮɟɣɫ ɬɢɩɚ ɞɨɥɠɟɧ ɛɵɬɶ ɫɩɪɨɟɤɬɢɪɨɜɚɧ ɜ ɩɨɥɶɡɭ
ɫɚɦɨɞɨɫɬɚɬɨɱɧɵɯ ɨɩɟɪɚɰɢɣ ɫ ɧɟɜɵɫɨɤɨɣ ɫɬɟɩɟɧɶɸ ɞɟɬɚɥɢɡɚɰɢɢ. ȿɫɥɢ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ
ɞɨɥɠɟɧ ɛɥɨɤɢɪɨɜɚɬɶ ɧɟɫɤɨɥɶɤɨ ɨɩɟɪɚɰɢɣ, ɚ ɧɟ ɨɞɧɭ, ɬɨ ɬɚɤɨɣ ɫɩɨɫɨɛ ɧɟɩɪɢɦɟɧɢɦ. ȼ ɷɬɨɦ
ɫɥɭɱɚɟ ɨɬɞɟɥɶɧɵɟ ɮɭɧɤɰɢɢ ɦɨɝɭɬ ɛɵɬɶ ɫɨɛɪɚɧɵ ɜ ɛɥɨɤɢɪɭɟɦɵɣ ɦɨɞɭɥɶ ɛɨɥɶɲɟɝɨ ɦɚɫ-
ɲɬɚɛɚ, ɪɚɛɨɬɚ ɫ ɤɨɬɨɪɵɦ ɜɵɩɨɥɧɹɟɬɫɹ ɩɪɢ ɩɨɦɨɳɢ ɞɨɩɨɥɧɢɬɟɥɶɧɨɣ (ɜɧɟɲɧɟɣ) ɛɥɨɤɢ-
ɪɨɜɤɢ. ɇɚɩɪɢɦɟɪ, ɪɚɫɫɦɨɬɪɢɦ ɬɢɩ, ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ ɢɬɟɪɚɬɨɪ, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɫɬɚɬɶ
ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦ ɩɟɪɟɞ ɬɟɦ, ɤɚɤ ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɟɝɨ, ɢɥɢ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɚɥɝɨɪɢɬɦ ɧɚɩɨ-
ɞɨɛɢɟ find, ɜɨɡɜɪɚɳɚɸɳɢɣ ɜɟɪɧɵɣ ɨɬɜɟɬ, ɤɨɬɨɪɵɣ ɫɬɚɧɨɜɢɬɫɹ ɧɟɜɟɪɧɵɦ ɞɨ ɬɨɝɨ, ɤɚɤ ɜɵ
ɢɦ ɜɨɫɩɨɥɶɡɭɟɬɟɫɶ, ɢɥɢ ɩɨɥɶɡɨɜɚɬɟɥɶ ɧɚɩɢɲɟɬ ɤɨɞ if(c.empty()) c.push_back(x);
(ɞɪɭɝɢɟ ɩɪɢɦɟɪɵ ɦɨɠɧɨ ɧɚɣɬɢ ɜ [Sutter02]). ȼ ɬɚɤɢɯ ɫɥɭɱɚɹɯ ɜɵɡɵɜɚɸɳɚɹ ɮɭɧɤɰɢɹ
ɞɨɥɠɧɚ ɜɵɩɨɥɧɢɬɶ ɜɧɟɲɧɸɸ ɛɥɨɤɢɪɨɜɤɭ ɧɚ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɜɫɟɯ ɨɬɞɟɥɶɧɵɯ ɜɵɡɨɜɨɜ
ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɬɚɤ ɱɬɨ ɨɬɞɟɥɶɧɵɟ ɛɥɨɤɢɪɨɜɤɢ ɞɥɹ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɨɤɚɡɵɜɚɸɬɫɹ
ɧɟɧɭɠɧɨɣ ɪɚɫɬɨɱɢɬɟɥɶɧɨɫɬɶɸ.
ɂɬɚɤ, ɜɧɭɬɪɟɧɧɹɹ ɛɥɨɤɢɪɨɜɤɚ ɫɜɹɡɚɧɚ ɫ ɨɬɤɪɵɬɵɦ ɢɧɬɟɪɮɟɣɫɨɦ ɬɢɩɚ. Ɉɧɚ ɫɬɚɧɨɜɢɬɫɹ
ɩɪɢɦɟɧɢɦɚ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɨɬɞɟɥɶɧɵɟ ɨɩɟɪɚɰɢɢ ɬɢɩɚ ɹɜɥɹɸɬɫɹ ɫɚɦɢ ɩɨ ɫɟɛɟ ɡɚ-
ɜɟɪɲɟɧɧɵɦɢ; ɞɪɭɝɢɦɢ ɫɥɨɜɚɦɢ, ɤɨɝɞɚ ɭɪɨɜɟɧɶ ɚɛɫɬɪɚɤɰɢɢ ɬɢɩɚ ɪɚɫɬɟɬ ɢ ɜɵɪɚɠɚɟɬɫɹ
ɢ ɢɧɤɚɩɫɭɥɢɪɭɟɬɫɹ ɛɨɥɟɟ ɬɨɱɧɨ (ɧɚɩɪɢɦɟɪ, ɤɚɤ ɭ ɨɱɟɪɟɞɢ ɩɪɨɢɡɜɨɞɢɬɟɥɶ/ɩɨɬɪɟɛɢɬɟɥɶ
12. Кодирование параллельных вычислений 35
Стр. 35
ɩɨ ɨɬɧɨɲɟɧɢɸ ɤ ɨɛɵɱɧɨɦɭ ɤɨɧɬɟɣɧɟɪɭ vector). Ɉɛɴɟɞɢɧɟɧɢɟ ɩɪɢɦɢɬɢɜɧɵɯ ɨɩɟɪɚɰɢɣ
ɞɥɹ ɨɛɪɚɡɨɜɚɧɢɹ ɛɨɥɟɟ ɤɪɭɩɧɵɯ ɨɛɳɢɯ ɨɩɟɪɚɰɢɣ — ɷɬɨɬ ɩɨɞɯɨɞ ɬɪɟɛɭɟɬɫɹ ɞɥɹ ɬɨɝɨ,
ɱɬɨɛɵ ɨɛɟɫɩɟɱɢɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɩɪɨɫɬɨɝɨ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ ɫ ɛɨɥɶɲɢɦ ɜɧɭɬɪɟɧɧɢɦ ɫɨ-
ɞɟɪɠɚɧɢɟɦ. ȼ ɫɢɬɭɚɰɢɹɯ, ɤɨɝɞɚ ɤɨɦɛɢɧɢɪɨɜɚɧɢɟ ɩɪɢɦɢɬɢɜɨɜ ɦɨɠɟɬ ɛɵɬɶ ɩɪɨɢɡɜɨɥɶ-
ɧɵɦ ɢ ɜɵ ɧɟ ɦɨɠɟɬɟ ɨɩɪɟɞɟɥɢɬɶ ɪɚɡɭɦɧɵɣ ɧɚɛɨɪ ɫɰɟɧɚɪɢɟɜ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɜɢɞɟ ɨɞ-
ɧɨɣ ɢɦɟɧɨɜɚɧɧɨɣ ɨɩɟɪɚɰɢɢ, ɢɦɟɸɬɫɹ ɞɜɟ ɚɥɶɬɟɪɧɚɬɢɜɵ. Ɇɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɦɨ-
ɞɟɥɶɸ ɮɭɧɤɰɢɣ ɨɛɪɚɬɧɨɝɨ ɜɵɡɨɜɚ (ɬ.ɟ. ɜɵɡɵɜɚɸɳɚɹ ɮɭɧɤɰɢɹ ɞɨɥɠɧɚ ɜɵɡɜɚɬɶ ɨɞɧɭ
ɮɭɧɤɰɢɸ-ɱɥɟɧ, ɩɟɪɟɞɚɜɚɹ ɟɣ ɡɚɞɚɧɢɟ, ɤɨɬɨɪɨɟ ɫɥɟɞɭɟɬ ɜɵɩɨɥɧɢɬɶ, ɜ ɜɢɞɟ ɤɨɦɚɧɞɵ ɢɥɢ
ɨɛɴɟɤɬɚ-ɮɭɧɤɰɢɢ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 87 ɩɨ 89). ȼɬɨɪɨɣ ɦɟɬɨɞ ɫɨɫɬɨɢɬ ɜ ɧɟɤɨɬɨɪɨɦ
ɫɩɨɫɨɛɟ ɩɪɟɞɨɫɬɚɜɥɟɧɢɹ ɜɵɡɵɜɚɸɳɟɦɭ ɤɨɞɭ ɜɨɡɦɨɠɧɨɫɬɢ ɛɥɨɤɢɪɨɜɤɢ ɜ ɨɬɤɪɵɬɨɦ ɢɧ-
ɬɟɪɮɟɣɫɟ.
• ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ, ɧɟ ɬɪɟɛɭɸɳɟɟ ɛɥɨɤɢɪɨɜɨɤ, ɜɤɥɸɱɚɹ ɧɟɢɡɦɟɧɹɟɦɨɫɬɶ (ɨɛɴɟɤɬɵ,
ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ). Ɇɨɠɧɨ ɪɚɡɪɚɛɨɬɚɬɶ ɬɢɩɵ, ɞɥɹ ɤɨɬɨɪɵɯ ɛɥɨɤɢ-
ɪɨɜɤɚ ɨɤɚɠɟɬɫɹ ɩɨɥɧɨɫɬɶɸ ɧɟɧɭɠɧɨɣ (ɫɦ. ɫɫɵɥɤɢ). Ɉɞɧɢɦ ɢɡ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ ɩɪɢ-
ɦɟɪɨɜ ɹɜɥɹɸɬɫɹ ɧɟɢɡɦɟɧɹɟɦɵɟ ɨɛɴɟɤɬɵ, ɤɨɬɨɪɵɟ ɧɟ ɬɪɟɛɭɸɬ ɛɥɨɤɢɪɨɜɤɢ, ɩɨɫɤɨɥɶɤɭ
ɨɧɢ ɧɢɤɨɝɞɚ ɧɟ ɢɡɦɟɧɹɸɬɫɹ. ɇɚɩɪɢɦɟɪ, ɛɭɞɭɱɢ ɫɨɡɞɚɧ, ɨɛɴɟɤɬ ɧɟɢɡɦɟɧɹɟɦɨɝɨ ɫɬɪɨɤɨ-
ɜɨɝɨ ɬɢɩɚ ɛɨɥɶɲɟ ɧɟ ɦɨɞɢɮɢɰɢɪɭɟɬɫɹ, ɚ ɜɫɟ ɫɬɪɨɤɨɜɵɟ ɨɩɟɪɚɰɢɢ ɩɪɢɜɨɞɹɬ ɤ ɫɨɡɞɚɧɢɸ
ɧɨɜɵɯ ɫɬɪɨɤ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɧɢɱɟɝɨ ɧɟ ɞɨɥɠɟɧ ɡɧɚɬɶ ɨ ɞɟɬɚɥɹɯ ɪɟɚɥɢɡɚɰɢɢ ɜɚɲɢɯ ɬɢɩɨɜ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). ȿɫɥɢ ɜɚɲ ɬɢɩ ɜɧɭɬɪɟɧɧɟ ɢɫɩɨɥɶɡɭɟɬ ɤɚɤɢɟ-ɬɨ ɦɟɬɨɞɢɤɢ ɪɚɡɞɟɥɟɧɢɹ
ɞɚɧɧɵɯ (ɧɚɩɪɢɦɟɪ, ɤɨɩɢɪɨɜɚɧɢɟ ɩɪɢ ɡɚɩɢɫɢ), ɜɵ ɧɟ ɞɨɥɠɧɵ ɧɟɫɬɢ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɜɫɟ
ɜɨɡɦɨɠɧɵɟ ɜɨɩɪɨɫɵ ɛɟɡɨɩɚɫɧɨɫɬɢ ɩɨɬɨɤɨɜ, ɧɨ ɨɛɹɡɚɧɵ ɨɛɟɫɩɟɱɢɬɶ ɤɨɪɪɟɤɬɧɨɫɬɶ ɪɚɛɨɬɵ ɜɵ-
ɡɵɜɚɸɳɟɝɨ ɤɨɞɚ ɩɪɢ ɨɛɵɱɧɨɣ ɪɚɛɨɬɟ — ɬ.ɟ. ɬɢɩ ɞɨɥɠɟɧ ɛɵɬɶ ɛɟɡɨɩɚɫɟɧ ɜ ɩɥɚɧɟ ɦɧɨɝɨɩɨɬɨɱ-
ɧɨɫɬɢ ɜ ɬɨɣ ɠɟ ɦɟɪɟ, ɤɚɤ ɟɫɥɢ ɛɵ ɨɧ ɧɟ ɢɫɩɨɥɶɡɨɜɚɥ ɦɟɬɨɞɢɤɢ ɫɨɜɦɟɫɬɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ
ɞɚɧɧɵɯ (ɫɦ. [Sutter04c]). Ʉɚɤ ɭɩɨɦɢɧɚɥɨɫɶ, ɜɫɟ ɤɨɪɪɟɤɬɧɨ ɧɚɩɢɫɚɧɧɵɟ ɬɢɩɵ ɞɨɥɠɧɵ ɩɨɡɜɨ-
ɥɹɬɶ ɪɚɛɨɬɭ ɫ ɪɚɡɥɢɱɧɵɦɢ ɨɛɴɟɤɬɚɦɢ ɜ ɪɚɡɧɵɯ ɩɨɬɨɤɚɯ ɛɟɡ ɫɢɧɯɪɨɧɢɡɚɰɢɢ.
ȼ ɱɚɫɬɧɨɫɬɢ, ɟɫɥɢ ɜɵ ɪɚɡɪɚɛɚɬɵɜɚɟɬɟ ɛɢɛɥɢɨɬɟɤɭ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɭɸ ɞɥɹ ɲɢɪɨɤɨɝɨ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɹ, ɜɵ ɞɨɥɠɧɵ ɩɪɟɞɭɫɦɨɬɪɟɬɶ ɛɟɡɨɩɚɫɧɨɫɬɶ ɜɚɲɢɯ ɨɛɴɟɤɬɨɜ ɜ ɦɧɨɝɨɩɨɬɨɱɧɵɯ ɩɪɨɝɪɚɦɦɚɯ,
ɤɚɤ ɨɩɢɫɚɧɨ ɜɵɲɟ, ɧɨ ɩɪɢ ɷɬɨɦ ɛɟɡ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɧɚɤɥɚɞɧɵɯ ɪɚɫɯɨɞɨɜ ɩɪɢ ɪɚɛɨɬɟ ɜ ɨɞɧɨɩɨ-
ɬɨɱɧɨɣ ɩɪɨɝɪɚɦɦɟ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɜɵ ɩɢɲɟɬɟ ɛɢɛɥɢɨɬɟɤɭ, ɫɨɞɟɪɠɚɳɭɸ ɬɢɩ, ɢɫɩɨɥɶɡɭɸɳɢɣ
ɤɨɩɢɪɨɜɚɧɢɟ ɩɪɢ ɡɚɩɢɫɢ, ɢ ɜɵ ɞɨɥɠɧɵ ɨɛɟɫɩɟɱɢɬɶ, ɤɚɤ ɦɢɧɢɦɭɦ, ɧɟɤɨɬɨɪɭɸ ɜɧɭɬɪɟɧɧɸɸ ɛɥɨ-
ɤɢɪɨɜɤɭ, ɬɨ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɪɚɡɪɚɛɨɬɚɬɶ ɟɟ ɬɚɤ, ɱɬɨɛɵ ɜ ɨɞɧɨɩɨɬɨɱɧɨɦ ɜɚɪɢɚɧɬɟ ɜɚɲɟɣ ɛɢɛ-
ɥɢɨɬɟɤɢ ɟɟ ɧɟ ɛɵɥɨ (ɨɛɵɱɧɨ ɞɥɹ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɸɬɫɹ ɞɢɪɟɤɬɢɜɵ ɩɪɟɩɪɨɰɟɫɫɨɪɚ #ifdef).
ȿɫɥɢ ɢɫɩɨɥɶɡɭɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɛɥɨɤɢɪɨɜɨɤ, ɬɨ ɢɡɛɟɠɚɬɶ ɜɡɚɢɦɨɛɥɨɤɢɪɨɜɤɢ ɦɨɠɧɨ ɩɭɬɟɦ ɢɯ
ɡɚɩɪɨɫɚ ɜ ɨɞɢɧɚɤɨɜɨɦ ɩɨɪɹɞɤɟ (ɨɫɜɨɛɨɠɞɟɧɢɟ ɛɥɨɤɢɪɨɜɨɤ ɦɨɠɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɜ ɥɸɛɨɦ ɩɨ-
ɪɹɞɤɟ). Ɉɞɧɨ ɢɡ ɪɟɲɟɧɢɣ ɫɨɫɬɨɢɬ ɜ ɡɚɩɪɨɫɟ ɛɥɨɤɢɪɨɜɨɤ ɜ ɩɨɪɹɞɤɟ ɜɨɡɪɚɫɬɚɧɢɹ ɚɞɪɟɫɨɜ ɜ ɩɚ-
ɦɹɬɢ, ɱɬɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɭɞɨɛɧɨɟ, ɨɞɧɨɡɧɚɱɧɨɟ ɭɩɨɪɹɞɨɱɟɧɢɟ ɜ ɩɪɟɞɟɥɚɯ ɩɪɢɥɨɠɟɧɢɹ.
Ссылки
[Alexandrescu02a] • [Alexandrescu04] • [Butenhof97] • [Henney00] • [Henney01] • [Meyers04] •
[Schmidt01] • [Stroustrup00] §14.9 • [Sutter02] §16 • [Sutter04c]
Стр. 36
13. Ресурсы должны быть во владении
объектов
Резюме
ɇɟ ɪɚɛɨɬɚɣɬɟ ɜɪɭɱɧɭɸ, ɟɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɦɨɳɧɵɟ ɢɧɫɬɪɭɦɟɧɬɵ. ɂɞɢɨɦɚ C++ “ɜɵɞɟɥɟɧɢɟ
ɪɟɫɭɪɫɚ ɟɫɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ” (resource acquisition is initialization — RAII) ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɦɨɳɧɵɣ ɢɧɫɬɪɭɦɟɧɬ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ ɫ ɪɟɫɭɪɫɚɦɢ. RAII ɩɨɡɜɨɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ ɚɜɬɨ-
ɦɚɬɢɱɟɫɤɢ ɨɛɟɫɩɟɱɢɬɶ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɬɨɝɨ, ɱɬɨ ɜ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɧɚɞɨ ɞɟɥɚɬɶ ɜɪɭɱɧɭɸ. ɉɪɢ
ɜɵɞɟɥɟɧɢɢ ɪɟɫɭɪɫɚ ɩɟɪɟɞɚɣɬɟ ɟɝɨ ɨɛɴɟɤɬɭ-ɜɥɚɞɟɥɶɰɭ. ɇɢɤɨɝɞɚ ɧɟ ɜɵɞɟɥɹɣɬɟ ɧɟɫɤɨɥɶɤɨ ɪɟɫɭɪ-
ɫɨɜ ɜ ɨɞɧɨɣ ɢɧɫɬɪɭɤɰɢɢ.
ɋɢɦɦɟɬɪɢɹ ɤɨɧɫɬɪɭɤɬɨɪ/ɞɟɫɬɪɭɤɬɨɪ, ɨɛɟɫɩɟɱɢɜɚɟɦɚɹ ɹɡɵɤɨɦ C++, ɜɨɫɩɪɨɢɡɜɨɞɢɬ ɫɢɦ-
ɦɟɬɪɢɸ, ɩɪɢɫɭɳɭɸ ɩɚɪɚɦ ɮɭɧɤɰɢɣ ɡɚɯɜɚɬɚ/ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɚ, ɬɚɤɢɦ ɤɚɤ fopen/fclose,
lock/unlock ɢ new/delete. ɗɬɨ ɞɟɥɚɟɬ ɫɬɟɤɨɜɵɟ ɨɛɴɟɤɬɵ (ɢɥɢ ɨɛɴɟɤɬɵ ɫɨ ɫɱɟɬɱɢɤɨɦ ɫɫɵ-
ɥɨɤ), ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ ɤɨɬɨɪɵɯ ɩɪɨɢɫɯɨɞɢɬ ɡɚɯɜɚɬ ɪɟɫɭɪɫɚ (ɚ ɜ ɞɟɫɬɪɭɤɬɨɪɟ ɟɝɨ ɨɫɜɨɛɨɠɞɟɧɢɟ),
ɩɪɟɜɨɫɯɨɞɧɵɦ ɢɧɫɬɪɭɦɟɧɬɨɦ ɞɥɹ ɚɜɬɨɦɚɬɢɡɚɰɢɢ ɭɩɪɚɜɥɟɧɢɹ ɪɟɫɭɪɫɚɦɢ.
Ⱥɜɬɨɦɚɬɢɡɚɰɢɹ ɥɟɝɤɨ ɪɟɚɥɢɡɭɟɦɚ, ɷɥɟɝɚɧɬɧɚ, ɧɟɞɨɪɨɝɚ ɢ ɩɨ ɫɭɬɢ ɛɟɡɨɩɚɫɧɚ ɜ ɩɥɚɧɟ ɨɲɢ-
ɛɨɤ. ȿɫɥɢ ɜɵ ɧɟ ɛɭɞɟɬɟ ɟɸ ɩɨɥɶɡɨɜɚɬɶɫɹ, ɬɨ ɨɛɪɟɱɟɬɟ ɫɟɛɹ ɧɚ ɧɟɬɪɢɜɢɚɥɶɧɭɸ ɢ ɤɪɨɩɨɬɥɢɜɭɸ
ɪɭɱɧɭɸ ɪɚɛɨɬɭ ɩɨ “ɫɩɚɪɢɜɚɧɢɸ” ɜɵɡɨɜɨɜ ɡɚɯɜɚɬɚ ɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ, ɜɤɥɸɱɚɸɳɭɸ ɨɬ-
ɫɥɟɠɢɜɚɧɢɟ ɜɫɟɯ ɜɟɬɜɥɟɧɢɣ ɢ ɢɫɤɥɸɱɟɧɢɣ. ɗɬɨ ɫɨɜɟɪɲɟɧɧɨ ɧɟɩɪɢɟɦɥɟɦɵɣ ɩɭɬɶ ɞɥɹ C++, ɤɨ-
ɬɨɪɵɣ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɜɨɡɦɨɠɧɨɫɬɶ ɚɜɬɨɦɚɬɢɡɚɰɢɢ ɷɬɨɣ ɪɚɛɨɬɵ ɩɪɢ ɩɨɦɨɳɢ ɩɪɨɫɬɨɣ ɜ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɢ ɢɞɢɨɦɵ RAII.
Ʉɨɝɞɚ ɜɵ ɢɦɟɟɬɟ ɞɟɥɨ ɫ ɪɟɫɭɪɫɨɦ, ɤɨɬɨɪɵɣ ɬɪɟɛɭɟɬ ɫɩɚɪɢɜɚɧɢɹ ɜɵɡɨɜɨɜ ɮɭɧɤɰɢɣ ɡɚɯɜɚ-
ɬɚ/ɨɫɜɨɛɨɠɞɟɧɢɹ, ɢɧɤɚɩɫɭɥɢɪɭɣɬɟ ɷɬɨɬ ɪɟɫɭɪɫ ɜ ɨɛɴɟɤɬ, ɤɨɬɨɪɵɣ ɜɵɩɨɥɧɢɬ ɷɬɭ ɪɚɛɨɬɭ ɡɚ ɜɚɫ
ɢ ɨɫɜɨɛɨɞɢɬ ɪɟɫɭɪɫ ɜ ɫɜɨɟɦ ɞɟɫɬɪɭɤɬɨɪɟ. ɇɚɩɪɢɦɟɪ, ɜɦɟɫɬɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɜɵɡɨɜɚ ɩɚɪɵ
ɮɭɧɤɰɢɣ (ɧɟ ɱɥɟɧɨɜ) OpenPort/ClosePort ɦɨɠɧɨ ɩɨɫɬɭɩɢɬɶ ɢɧɚɱɟ:
class Port {
public:
Port( const string& destination ); // ǍȆǲǹǭ OpenPort
~Port(); // ǍȆǲǹǭ ClosePort
// ǚǹǻǽȆ ǹǬȆȂǸǹ Ǹǰ ǵǶǹǸǳǻǾȉǽǼȊ, ǽǫǵ Ȃǽǹ ǲǫǺǻǰȄǫǰǷ
// ǵǹǺǳǻǹǭǫǸǳǰ ǳ ǺǻǳǼǭǫǳǭǫǸǳǰ
};
void DoSomething() {
Port port1( "server1:80" );
// ...
} // ǒǫǬȆǽȇ ǲǫǵǻȆǽȇ Ǻǹǻǽ ǸǰǶȇǲȊ — ǹǸ ǬǾǯǰǽ ǲǫǵǻȆǽ
// ǫǭǽǹǷǫǽǳȂǰǼǵǳ Ǻǻǳ ǭȆȀǹǯǰ ǳǲ ǹǬǶǫǼǽǳ ǭǳǯǳǷǹǼǽǳ
shared_ptr<Port> port2 = /*...*/; // port2 ǬǾǯǰǽ ǲǫǵǻȆǽ
// ǫǭǽǹǷǫǽǳȂǰǼǵǳ, ǵǹǮǯǫ ǬǾǯǰǽ ǾǸǳȂǽǹǱǰǸ ǺǹǼǶǰǯǸǳǴ
// ǼǼȆǶǫȉȄǳǴǼȊ Ǹǫ ǸǰǮǹ ǹǬȅǰǵǽ shared_ptr
ȼɵ ɦɨɠɟɬɟ ɬɚɤɠɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɛɢɛɥɢɨɬɟɤɢ, ɤɨɬɨɪɵɟ ɪɟɚɥɢɡɭɸɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɲɚɛɥɨɧ
ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ (ɫɦ. [Alexandrescu00c]).
ɉɪɢ ɪɟɚɥɢɡɚɰɢɢ ɢɞɢɨɦɵ RAII ɫɥɟɞɭɟɬ ɨɫɨɛɨ ɬɳɚɬɟɥɶɧɨ ɩɨɞɯɨɞɢɬɶ ɤ ɜɨɩɪɨɫɭ ɨ ɤɨɩɢɪɭɸ-
ɳɟɦ ɤɨɧɫɬɪɭɤɬɨɪɟ ɢ ɩɪɢɫɜɚɢɜɚɧɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 49): ɨɛɵɱɧɨ ɝɟɧɟɪɢɪɭɟɦɵɟ ɤɨɦɩɢɥɹɬɨ-
ɪɨɦ ɜɟɪɫɢɢ ɷɬɢɯ ɮɭɧɤɰɢɣ ɧɟ ɩɨɞɯɨɞɹɬ. ȿɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɥɢɲɟɧɨ ɫɦɵɫɥɚ, ɤɨɩɢɪɭɸɳɢɣ ɤɨɧ-
ɫɬɪɭɤɬɨɪ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ ɦɨɠɧɨ ɹɜɧɵɦ ɨɛɪɚɡɨɦ ɡɚɩɪɟɬɢɬɶ, ɞɟɥɚɹ ɢɯ ɡɚɤɪɵɬɵɦɢ
13. Ресурсы должны быть во владении объектов 37
Стр. 37
ɱɥɟɧɚɦɢ ɢ ɧɟ ɨɩɪɟɞɟɥɹɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 53). ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤ-
ɬɨɪ ɞɭɛɥɢɪɭɟɬ ɪɟɫɭɪɫ ɢɥɢ ɢɫɩɨɥɶɡɭɟɬ ɫɱɟɬɱɢɤ ɫɫɵɥɨɤ ɧɚ ɧɟɝɨ, ɢ ɬɨ ɠɟ ɞɟɥɚɟɬ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢ-
ɫɜɚɢɜɚɧɢɹ, ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɨɫɜɨɛɨɞɢɜ ɪɟɫɭɪɫ, ɤɨɬɨɪɵɦ ɨɛɴɟɤɬ ɜɥɚɞɟɥ ɞɨ ɩɪɢɫɜɚɢɜɚɧɢɹ.
Ʉɥɚɫɫɢɱɟɫɤɨɣ ɨɲɢɛɤɨɣ ɹɜɥɹɟɬɫɹ ɨɫɜɨɛɨɠɞɟɧɢɟ ɫɬɚɪɨɝɨ ɪɟɫɭɪɫɚ ɞɨ ɬɨɝɨ, ɤɚɤ ɭɫɩɟɲɧɨ ɞɭɛɥɢ-
ɪɨɜɚɧ ɧɨɜɵɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71).
Ɉɛɟɫɩɟɱɶɬɟ, ɱɬɨɛɵ ɜɫɟ ɪɟɫɭɪɫɵ ɩɪɢɧɚɞɥɟɠɚɥɢ ɨɛɴɟɤɬɚɦ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɯɪɚɧɢɬɶ ɜɫɟ ɞɢ-
ɧɚɦɢɱɟɫɤɢ ɜɵɞɟɥɟɧɧɵɟ ɪɟɫɭɪɫɵ ɩɨɫɪɟɞɫɬɜɨɦ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ, ɚ ɧɟ ɨɛɵɱɧɵɯ, ɭɤɚɡɚɬɟɥɟɣ.
Ʉɪɨɦɟ ɬɨɝɨ, ɫɥɟɞɭɟɬ ɜɵɩɨɥɧɹɬɶ ɤɚɠɞɨɟ ɹɜɧɨɟ ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, new) ɜ ɨɬɞɟɥɶɧɨɣ
ɢɧɫɬɪɭɤɰɢɢ, ɤɨɬɨɪɚɹ ɬɭɬ ɠɟ ɩɟɪɟɞɚɟɬ ɪɟɫɭɪɫ ɭɩɪɚɜɥɹɸɳɟɦɭ ɨɛɴɟɤɬɭ (ɧɚɩɪɢɦɟɪ, shared_ptr).
ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɦɨɠɟɬ ɜɨɡɧɢɤɧɭɬɶ ɭɬɟɱɤɚ ɪɟɫɭɪɫɨɜ, ɫɜɹɡɚɧɧɚɹ ɫ ɬɟɦ, ɱɬɨ ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟ-
ɧɢɹ ɩɚɪɚɦɟɬɪɨɜ ɮɭɧɤɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 31). ɇɚɩɪɢɦɟɪ:
void Fun(shared_ptr<Widget> sp1, shared_ptr<Widget> sp2);
// ...
new Widget),
Fun(shared_ptr<Widget>(n
shared_ptr<Widget>(n
new Widget));
Ɍɚɤɨɣ ɤɨɞ ɧɟɛɟɡɨɩɚɫɟɧ. ɋɬɚɧɞɚɪɬ C++ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ ɛɨɥɶɲɭɸ ɫɜɨɛɨɞɭ ɞɟɣ-
ɫɬɜɢɣ ɩɨ ɩɟɪɟɭɩɨɪɹɞɨɱɟɧɢɸ ɜɵɪɚɠɟɧɢɣ, ɤɨɬɨɪɵɟ ɫɨɡɞɚɸɬ ɞɜɚ ɚɪɝɭɦɟɧɬɚ ɮɭɧɤɰɢɢ. ȼ ɱɚɫɬɧɨ-
ɫɬɢ, ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɱɟɪɟɞɨɜɚɬɶ ɜɵɩɨɥɧɟɧɢɟ ɷɬɢɯ ɞɜɭɯ ɜɵɪɚɠɟɧɢɣ: ɫɧɚɱɚɥɚ ɞɥɹ ɨɛɨɢɯ ɨɛɴ-
ɟɤɬɨɜ ɦɨɠɟɬ ɛɵɬɶ ɜɵɩɨɥɧɟɧɨ ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ (ɩɪɢ ɩɨɦɨɳɢ ɨɩɟɪɚɬɨɪɚ new), ɚ ɭɠɟ ɡɚɬɟɦ
ɛɭɞɭɬ ɜɵɡɜɚɧɵ ɞɜɚ ɤɨɧɫɬɪɭɤɬɨɪɚ Widget. Ɍɚɤɚɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɞɟɣɫɬɜɢɣ ɦɨɠɟɬ ɩɪɢɜɟɫ-
ɬɢ ɤ ɭɬɟɱɤɟ: ɟɫɥɢ ɨɞɢɧ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɫɝɟɧɟɪɢɪɭɟɬ ɢɫɤɥɸɱɟɧɢɟ, ɬɨ ɩɚɦɹɬɶ ɞɥɹ ɞɪɭɝɨɝɨ ɨɛɴ-
ɟɤɬɚ ɧɢɤɨɝɞɚ ɧɟ ɛɭɞɟɬ ɨɫɜɨɛɨɠɞɟɧɚ (ɛɨɥɟɟ ɞɟɬɚɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɩɨ ɷɬɨɦɭ ɜɨɩɪɨɫɭ ɜɵ ɧɚɣ-
ɞɟɬɟ ɜ [Sutter02]).
ɗɬɚ ɬɨɧɤɚɹ ɩɪɨɛɥɟɦɚ ɢɦɟɟɬ ɩɪɨɫɬɨɟ ɪɟɲɟɧɢɟ: ɫɥɟɞɭɣɬɟ ɩɪɢɜɟɞɟɧɧɨɦɭ ɜɵɲɟ ɫɨɜɟɬɭ ɢ ɧɢ-
ɤɨɝɞɚ ɧɟ ɜɵɞɟɥɹɣɬɟ ɜ ɨɞɧɨɣ ɢɧɫɬɪɭɤɰɢɢ ɛɨɥɶɲɟ ɨɞɧɨɝɨ ɪɟɫɭɪɫɚ. ɋɥɟɞɭɟɬ ɜɵɩɨɥɧɹɬɶ ɤɚɠɞɨɟ
ɹɜɧɨɟ ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, new) ɜ ɨɬɞɟɥɶɧɨɣ ɢɧɫɬɪɭɤɰɢɢ, ɤɨɬɨɪɚɹ ɬɭɬ ɠɟ ɩɟɪɟɞɚɟɬ
ɪɟɫɭɪɫ ɭɩɪɚɜɥɹɸɳɟɦɭ ɨɛɴɟɤɬɭ (ɧɚɩɪɢɦɟɪ, shared_ptr), ɧɚɩɪɢɦɟɪ:
shared_ptr<Widget> sp1(new Widget), sp2(new Widget);
Fun( sp1, sp2 );
ɋɦ. ɬɚɤɠɟ ɨɩɢɫɚɧɢɟ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɩɪɟɢɦɭɳɟɫɬɜ ɬɚɤɨɝɨ ɫɬɢɥɹ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 31.
Ɇɨɠɧɨ ɱɟɪɟɫɱɭɪ ɭɜɥɟɱɶɫɹ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦɢ ɭɤɚɡɚɬɟɥɹɦɢ. Ɉɛɵɱɧɵɟ ɭɤɚɡɚɬɟɥɢ ɜɩɨɥɧɟ
ɩɨɞɯɨɞɹɬ ɞɥɹ ɤɨɞɚ, ɜ ɤɨɬɨɪɨɦ ɭɤɚɡɵɜɚɟɦɵɣ ɨɛɴɟɤɬ ɜɢɞɟɧ ɬɨɥɶɤɨ ɜ ɨɝɪɚɧɢɱɟɧɧɨɦ ɨɛɴɟɦɟ
(ɧɚɩɪɢɦɟɪ, ɜɧɭɬɪɢ ɤɥɚɫɫɚ — ɬɢɩɚ ɭɤɚɡɚɬɟɥɹ ɧɚ ɭɡɟɥ ɞɟɪɟɜɚ ɜ ɤɥɚɫɫɟ Tree, ɢɫɩɨɥɶɡɭɸɳɢɣɫɹ
ɞɥɹ ɧɚɜɢɝɚɰɢɢ ɩɨ ɞɟɪɟɜɭ).
Ссылки
[Alexandrescu00c] • [Cline99] §31.03-05 • [Dewhurst03] §24, §67 • [Meyers96] §9-10 •
[Milewski01] • [Stroustrup00] §14.3-4, §25.7, §E.3, §E.6 • [Sutter00] §16 • [Sutter02] §20-21 •
[Vandevoorde03] §20.1.4
Стр. 38
Стиль кодирования
Ʉɨɧɫɬɚɧɬɚ ɞɥɹ ɨɞɧɨɝɨ ɹɜɥɹɟɬɫɹ ɩɟɪɟɦɟɧɧɨɣ ɞɥɹ ɞɪɭɝɨɝɨ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɩɟɪɟɣɞɟɦ ɨɬ ɜɨɩɪɨɫɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɤ ɜɨɩɪɨɫɚɦ, ɤɨɬɨɪɵɟ ɩɨɹɜɥɹɸɬ-

ɫɹ ɜ ɨɫɧɨɜɧɨɦ ɩɪɢ ɪɟɚɥɶɧɨɦ ɤɨɞɢɪɨɜɚɧɢɢ.
ɉɪɚɜɢɥɚ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ ɢɡ ɷɬɨɝɨ ɪɚɡɞɟɥɚ ɩɪɢɦɟɧɢɦɵ ɛɟɡɨɬɧɨɫɢɬɟɥɶɧɨ ɤ ɤɨɧɤɪɟɬɧɨɣ ɨɛ-
ɥɚɫɬɢ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ (ɧɚɩɪɢɦɟɪ, ɮɭɧɤɰɢɹɦ, ɤɥɚɫɫɚɦ ɢɥɢ ɩɪɨɫɬɪɚɧɫɬɜɚɦ ɢɦɟɧ), ɧɨ
ɩɪɢɜɨɞɹɬ ɤ ɩɨɜɵɲɟɧɢɸ ɤɚɱɟɫɬɜɚ ɜɚɲɟɝɨ ɤɨɞɚ. Ɇɧɨɝɢɟ ɢɡ ɩɪɟɞɫɬɚɜɥɟɧɧɵɯ ɢɞɢɨɦ ɩɨɡɜɨɥɹɸɬ
ɜɚɲɟɦɭ ɤɨɦɩɢɥɹɬɨɪɭ ɚɤɬɢɜɧɟɟ ɩɨɦɨɝɚɬɶ ɜɚɦ ɜ ɪɚɛɨɬɟ, ɚ ɜɚɦ — ɢɡɛɟɠɚɬɶ ɨɩɚɫɧɵɯ ɦɟɫɬ
(ɜɤɥɸɱɚɹ ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ), ɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɜɫɟɝɞɚ ɜ ɫɨɫɬɨɹɧɢɢ ɜɵɹɜɢɬɶ.
ȼɫɟ ɷɬɨ ɞɟɥɚɟɬ ɜɚɲ ɤɨɞ ɛɨɥɟɟ ɧɚɞɟɠɧɵɦ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɜɚɠɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 14: “ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɲɢɛɤɢ
ɤɨɦɩɢɥɹɰɢɢ ɢ ɤɨɦɩɨɧɨɜɤɢ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ”.
14. Предпочитайте ошибки компиляции... 39
Стр. 39
14. Предпочитайте ошибки компиляции...
14. Предпочитайте ошибки компиляции

и компоновки ошибкам времени
выполнения
14. Предпочитайте ошибки компиляции...
Резюме
ɇɟ ɫɬɨɢɬ ɨɬɤɥɚɞɵɜɚɬɶ ɞɨ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɜɵɹɜɥɟɧɢɟ ɨɲɢɛɨɤ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɨɛ-
ɧɚɪɭɠɢɬɶ ɩɪɢ ɟɟ ɫɛɨɪɤɟ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɢɫɚɬɶ ɤɨɞ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɤɨɦɩɢɥɹɬɨɪ ɞɥɹ
ɩɪɨɜɟɪɤɢ ɢɧɜɚɪɢɚɧɬɨɜ ɜ ɩɪɨɰɟɫɫɟ ɤɨɦɩɢɥɹɰɢɢ, ɜɦɟɫɬɨ ɬɨɝɨ, ɱɬɨɛɵ ɩɪɨɜɟɪɹɬɶ ɢɯ ɜɨ ɜɪɟɦɹ ɪɚ-
ɛɨɬɵ ɩɪɨɝɪɚɦɦɵ. ɉɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɡɚɜɢɫɹɬ ɨɬ ɜɵɩɨɥɧɢɦɨɝɨ ɤɨɞɚ ɢ ɞɚɧɧɵɯ, ɬɚɤ
ɱɬɨ ɜɵ ɬɨɥɶɤɨ ɢɡɪɟɞɤɚ ɦɨɠɟɬɟ ɩɨɥɧɨɫɬɶɸ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɧɢɯ. ɉɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ,
ɧɚɩɪɨɬɢɜ, ɧɟ ɡɚɜɢɫɹɬ ɨɬ ɞɚɧɧɵɯ ɢ ɩɪɟɞɵɫɬɨɪɢɢ ɢɫɩɨɥɧɟɧɢɹ, ɱɬɨ ɨɛɵɱɧɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɛɨɥɟɟ
ɜɵɫɨɤɭɸ ɫɬɟɩɟɧɶ ɧɚɞɟɠɧɨɫɬɢ.
əɡɵɤ C++ ɩɪɟɞɥɚɝɚɟɬ ɦɚɫɫɭ ɫɪɟɞɫɬɜ ɞɥɹ “ɭɫɤɨɪɟɧɢɹ” ɨɛɧɚɪɭɠɟɧɢɹ ɨɲɢɛɨɤ ɜɨ ɜɪɟɦɹ ɤɨɦ-
ɩɢɥɹɰɢɢ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɷɬɢɯ ɜɨɡɦɨɠɧɨɫɬɟɣ ɫɬɚɬɢɱɟɫɤɢɯ ɩɪɨɜɟɪɨɤ ɞɚɟɬ ɦɚɫɫɭ ɩɪɟɢɦɭɳɟɫɬɜ,
ɜɤɥɸɱɚɹ ɫɥɟɞɭɸɳɢɟ.
• ɋɬɚɬɢɱɟɫɤɢɟ ɩɪɨɜɟɪɤɢ ɧɟ ɡɚɜɢɫɹɬ ɨɬ ɞɚɧɧɵɯ ɢ ɥɨɝɢɤɢ ɩɪɨɝɪɚɦɦɵ. ɋɬɚɬɢɱɟɫɤɢɟ ɩɪɨ-
ɜɟɪɤɢ ɝɚɪɚɧɬɢɪɭɸɬ ɧɟɡɚɜɢɫɢɦɨɫɬɶ ɨɬ ɜɯɨɞɧɵɯ ɞɚɧɧɵɯ ɩɪɨɝɪɚɦɦɵ ɢɥɢ ɩɨɬɨɤɚ ɟɟ ɜɵ-
ɩɨɥɧɟɧɢɹ. ȼ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɷɬɨɦɭ, ɱɬɨɛɵ ɭɛɟɞɢɬɶɫɹ ɜ ɞɨɫɬɚɬɨɱɧɨɣ ɫɬɪɨɝɨɫɬɢ ɬɟɫ-
ɬɢɪɨɜɚɧɢɹ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, ɜɵ ɞɨɥɠɧɵ ɩɪɨɜɟɪɢɬɶ ɟɝɨ ɧɚ ɩɪɟɞɫɬɚɜɢɬɟɥɶɧɨɦ ɧɚɛɨ-
ɪɟ ɜɯɨɞɧɵɯ ɞɚɧɧɵɯ. ɗɬɨ ɞɨɫɬɚɬɨɱɧɨ ɛɨɥɶɲɚɹ ɢ ɧɟɩɪɢɹɬɧɚɹ ɪɚɛɨɬɚ ɞɥɹ ɜɫɟɯ ɧɟɬɪɢɜɢ-
ɚɥɶɧɵɯ ɫɢɫɬɟɦ.
• ɋɬɚɬɢɱɟɫɤɢ ɜɵɪɚɠɟɧɧɵɟ ɦɨɞɟɥɢ ɛɨɥɟɟ ɫɬɪɨɝɢ. Ɂɚɱɚɫɬɭɸ ɬɨ, ɱɬɨ ɩɪɨɝɪɚɦɦɚ ɩɨɥɚɝɚɟɬɫɹ ɧɚ
ɩɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ, ɚ ɧɟ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, ɨɬɪɚɠɚɟɬ ɥɭɱɲɢɣ ɞɢɡɚɣɧ, ɩɨ-
ɫɤɨɥɶɤɭ ɦɨɞɟɥɶ, ɫɨɡɞɚɜɚɟɦɚɹ ɩɪɨɝɪɚɦɦɨɣ, ɤɨɪɪɟɤɬɧɨ ɜɵɪɚɠɟɧɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɢɫɬɟɦɵ
ɬɢɩɨɜ C++. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɜɵ ɢ ɤɨɦɩɢɥɹɬɨɪ ɨɤɚɡɵɜɚɟɬɟɫɶ ɩɚɪɬɧɟɪɚɦɢ ɫ ɨɛɳɢɦ ɜɡɝɥɹɞɨɦ
ɧɚ ɢɧɜɚɪɢɚɧɬɵ ɩɪɨɝɪɚɦɦ. Ɂɚɱɚɫɬɭɸ ɩɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɪɢɯɨɞɢɬɫɹ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ ɬɚɦ, ɝɞɟ ɬɟɨɪɟɬɢɱɟɫɤɢ ɩɪɨɜɟɪɤɭ ɦɨɠɧɨ ɛɵɥɨ ɛɵ ɩɪɨɜɟɫɬɢ ɫɬɚɬɢɱɟɫɤɢ, ɧɨ ɫɞɟɥɚɬɶ ɷɬɨ
ɧɟɜɨɡɦɨɠɧɨ ɢɡ-ɡɚ ɨɝɪɚɧɢɱɟɧɢɣ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68).
• ɋɬɚɬɢɱɟɫɤɢɟ ɩɪɨɜɟɪɤɢ ɧɟ ɩɪɢɜɨɞɹɬ ɤ ɧɚɤɥɚɞɧɵɦ ɪɚɫɯɨɞɚɦ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ. ɉɪɢ
ɡɚɦɟɧɟ ɞɢɧɚɦɢɱɟɫɤɢɯ ɩɪɨɜɟɪɨɤ ɫɬɚɬɢɱɟɫɤɢɦɢ ɫɨɡɞɚɜɚɟɦɚɹ ɜɵɩɨɥɧɢɦɚɹ ɩɪɨɝɪɚɦɦɚ
ɨɤɚɡɵɜɚɟɬɫɹ ɛɵɫɬɪɟɟ, ɨɫɬɚɜɚɹɫɶ ɫɬɨɥɶ ɠɟ ɤɨɪɪɟɤɬɧɨɣ.
Ɉɞɢɧ ɢɡ ɧɚɢɛɨɥɟɟ ɦɨɳɧɵɯ ɢɧɫɬɪɭɦɟɧɬɨɜ ɫɬɚɬɢɱɟɫɤɢɯ ɩɪɨɜɟɪɨɤ ɜ ɋ++ — ɫɬɚɬɢɱɟɫɤɚɹ
ɩɪɨɜɟɪɤɚ ɬɢɩɨɜ. ɋɩɨɪɵ ɨ ɬɨɦ, ɞɨɥɠɧɵ ɥɢ ɬɢɩɵ ɩɪɨɜɟɪɹɬɶɫɹ ɫɬɚɬɢɱɟɫɤɢ (C++, Java, ML,
Haskell) ɢɥɢ ɞɢɧɚɦɢɱɟɫɤɢ (Smalltalk, Ruby, Python, Lisp), ɜɫɟ ɟɳɟ ɚɤɬɢɜɧɨ ɩɪɨɞɨɥɠɚɸɬɫɹ.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɧɟɬ ɹɜɧɨɝɨ ɩɨɛɟɞɢɬɟɥɹ, ɢ ɢɦɟɸɬɫɹ ɹɡɵɤɢ ɢ ɫɬɢɥɢ ɪɚɡɪɚɛɨɬɤɢ, ɤɨɬɨɪɵɟ ɞɚɸɬ
ɯɨɪɨɲɢɟ ɪɟɡɭɥɶɬɚɬɵ ɤɚɤ ɜ ɨɞɧɨɦ, ɬɚɤ ɢ ɜɨ ɜɬɨɪɨɦ ɫɥɭɱɚɟ. ɋɬɨɪɨɧɧɢɤɢ ɫɬɚɬɢɱɟɫɤɨɣ ɩɪɨɜɟɪɤɢ
ɚɪɝɭɦɟɧɬɢɪɭɸɬ ɫɜɨɸ ɩɨɡɢɰɢɸ ɬɟɦ, ɱɬɨ ɨɛɪɚɛɨɬɤɚ ɛɨɥɶɲɨɝɨ ɤɥɚɫɫɚ ɨɲɢɛɨɤ ɜɪɟɦɟɧɢ ɜɵɩɨɥ-
ɧɟɧɢɹ ɦɨɠɟɬ ɛɵɬɶ ɩɪɨɫɬɨ ɭɫɬɪɚɧɟɧɚ, ɱɬɨ ɞɚɟɬ ɛɨɥɟɟ ɧɚɞɟɠɧɭɸ ɢ ɤɚɱɟɫɬɜɟɧɧɭɸ ɩɪɨɝɪɚɦɦɭ.
ɉɨɤɥɨɧɧɢɤɢ ɞɢɧɚɦɢɱɟɫɤɢɯ ɩɪɨɜɟɪɨɤ ɝɨɜɨɪɹɬ, ɱɬɨ ɤɨɦɩɢɥɹɬɨɪɵ ɫɩɨɫɨɛɧɵ ɜɵɹɜɢɬɶ ɬɨɥɶɤɨ
ɱɚɫɬɶ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɨɲɢɛɨɤ, ɬɚɤ ɱɬɨ ɟɫɥɢ ɜɵ ɜɫɟ ɪɚɜɧɨ ɞɨɥɠɧɵ ɩɢɫɚɬɶ ɬɟɫɬɵ ɞɥɹ ɜɚɲɢɯ ɦɨ-
ɞɭɥɟɣ, ɜɵ ɦɨɠɟɬɟ ɜɨɨɛɳɟ ɧɟ ɜɨɥɧɨɜɚɬɶɫɹ ɨ ɫɬɚɬɢɱɟɫɤɢɯ ɩɪɨɜɟɪɤɚɯ, ɩɨɥɭɱɢɜ ɩɪɢ ɷɬɨɦ ɦɟɧɟɟ
ɨɝɪɚɧɢɱɢɜɚɸɳɭɸ ɫɪɟɞɭ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
40 Стиль кодирования
Стр. 40
ɉɨɧɹɬɧɨ ɨɞɧɨ: ɜ ɤɨɧɬɟɤɫɬɟ ɫɬɚɬɢɱɟɫɤɢ ɬɢɩɢɡɢɪɨɜɚɧɧɨɝɨ ɹɡɵɤɚ C++, ɨɛɟɫɩɟɱɢɜɚɸɳɟɝɨ
ɫɬɪɨɝɭɸ ɩɪɨɜɟɪɤɭ ɬɢɩɨɜ ɢ ɦɢɧɢɦɚɥɶɧɭɸ ɚɜɬɨɦɚɬɢɱɟɫɤɭɸ ɩɪɨɜɟɪɤɭ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ,
ɩɪɨɝɪɚɦɦɢɫɬɵ ɨɩɪɟɞɟɥɟɧɧɨ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɢɫɬɟɦɭ ɬɢɩɨɜ ɞɥɹ ɫɜɨɟɣ ɩɨɥɶɡɵ ɜɟɡɞɟ, ɝɞɟ
ɬɨɥɶɤɨ ɷɬɨ ɜɨɡɦɨɠɧɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 90 ɩɨ 100). ȼ ɬɨ ɠɟ ɜɪɟɦɹ ɬɟɫɬɢɪɨɜɚɧɢɟ ɜɪɟɦɟɧɢ
ɜɵɩɨɥɧɟɧɢɹ ɰɟɥɟɫɨɨɛɪɚɡɧɨ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɜɟɪɨɤ, ɡɚɜɢɫɹɳɢɯ ɨɬ ɞɚɧɧɵɯ ɢ ɩɨɬɨɤɚ ɜɵɩɨɥ-
ɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ (ɧɚɩɪɢɦɟɪ, ɩɪɨɜɟɪɤɚ ɜɵɯɨɞɚ ɡɚ ɝɪɚɧɢɰɵ ɦɚɫɫɢɜɚ ɢɥɢ ɤɨɪɪɟɤɬɧɨɫɬɢ ɜɯɨɞ-
ɧɵɯ ɞɚɧɧɵɯ) (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 70 ɢ 71).
Примеры
ɂɦɟɟɬɫɹ ɪɹɞ ɩɪɢɦɟɪɨɜ, ɝɞɟ ɜɵ ɦɨɠɟɬɟ ɡɚɦɟɧɢɬɶ ɩɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɜɟɪɤɚ-
ɦɢ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ.
ɉɪɢɦɟɪ 1. Ʌɨɝɢɱɟɫɤɢɟ ɭɫɥɨɜɢɹ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ. ȿɫɥɢ ɜɵ ɩɪɨɜɟɪɹɟɬɟ ɥɨɝɢɱɟɫɤɨɟ ɭɫɥɨ-
ɜɢɟ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ ɧɚɩɨɞɨɛɢɟ sizeof(int) >= 8, ɢɫɩɨɥɶɡɭɣɬɟ ɫɬɚɬɢɱɟɫɤɢɟ ɩɪɨɜɟɪɤɢ
(ɨɛɪɚɬɢɬɟ ɬɚɤɠɟ ɜɧɢɦɚɧɢɟ ɧɚ ɪɟɤɨɦɟɧɞɚɰɢɸ 91).
ɉɪɢɦɟɪ 2. ɉɨɥɢɦɨɪɮɢɡɦ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ. ɉɨɞɭɦɚɣɬɟ ɨ ɡɚɦɟɧɟ ɩɨɥɢɦɨɪɮɢɡɦɚ ɜɪɟɦɟ-
ɧɢ ɜɵɩɨɥɧɟɧɢɹ (ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ) ɩɨɥɢɦɨɪɮɢɡɦɨɦ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ (ɲɚɛɥɨɧɵ) ɩɪɢ
ɨɩɪɟɞɟɥɟɧɢɢ ɨɛɨɛɳɟɧɧɵɯ ɮɭɧɤɰɢɣ ɢɥɢ ɬɢɩɨɜ. ɉɨɫɥɟɞɧɢɣ ɩɪɢɜɨɞɢɬ ɤ ɤɨɞɭ ɫ ɥɭɱɲɟɣ ɫɬɚɬɢɱɟ-
ɫɤɨɣ ɩɪɨɜɟɪɤɨɣ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 64).
ɉɪɢɦɟɪ 3. ɉɟɪɟɱɢɫɥɟɧɢɹ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɨɩɪɟɞɟɥɟɧɢɢ ɩɟɪɟɱɢɫɥɟɧɢɣ (ɢɥɢ, ɱɬɨ ɟɳɟ ɥɭɱɲɟ,
ɩɨɥɧɨɫɬɶɸ ɡɚɤɨɧɱɟɧɧɵɯ ɬɢɩɨɜ), ɤɨɝɞɚ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɜɵɪɚɡɢɬɶ ɫɢɦɜɨɥɶɧɵɟ ɤɨɧɫɬɚɧɬɵ ɢɥɢ ɨɝ-
ɪɚɧɢɱɟɧɧɵɟ ɰɟɥɨɱɢɫɥɟɧɧɵɟ ɡɧɚɱɟɧɢɹ.
ɉɪɢɦɟɪ 4. ɉɨɧɢɠɚɸɳɟɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ. ȿɫɥɢ ɜɵ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɟɬɟ ɨɩɟɪɚɬɨɪ
dynamic_cast (ɢɥɢ, ɱɬɨ ɟɳɟ ɯɭɠɟ, ɧɟɩɪɨɜɟɪɹɟɦɵɣ static_cast) ɞɥɹ ɩɨɧɢɠɚɸɳɟɝɨ ɩɪɟ-
ɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ, ɜɨɡɦɨɠɧɨ, ɜɚɲ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɫɥɢɲɤɨɦ ɦɚɥɭɸ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɨɫɬɶ? ɉɨɞɭɦɚɣɬɟ ɧɚɞ ɩɟɪɟɩɪɨɟɤɬɢɪɨɜɚɧɢɟɦ ɜɚɲɢɯ ɢɧɬɟɪɮɟɣɫɨɜ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ
ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɦɨɝɥɚ ɜɵɪɚɡɢɬɶ ɧɟɨɛɯɨɞɢɦɵɟ ɜɵɱɢɫɥɟɧɢɹ ɩɨɫɪɟɞɫɬɜɨɦ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ.
ɇɟɤɨɬɨɪɵɟ ɭɫɥɨɜɢɹ ɧɟ ɦɨɝɭɬ ɛɵɬɶ ɩɪɨɜɟɪɟɧɵ ɜ ɩɪɨɰɟɫɫɟ ɤɨɦɩɢɥɹɰɢɢ ɢ ɬɪɟɛɭɸɬ ɩɪɨɜɟɪɤɢ
ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ. ȼ ɬɚɤɨɦ ɫɥɭɱɚɟ ɞɥɹ ɨɛɧɚɪɭɠɟɧɢɹ ɜɧɭɬɪɟɧɧɢɯ ɩɪɨɝɪɚɦɦɧɵɯ ɨɲɢɛɨɤ
ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ assert (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68) ɢ ɫɥɟɞɨɜɚɬɶ ɫɨɜɟɬɚɦ ɢɡ ɨɫɬɚɥɶɧɨɣ ɱɚɫɬɢ
ɪɚɡɞɟɥɚ, ɩɨɫɜɹɳɟɧɧɨɝɨ ɨɛɪɚɛɨɬɤɟ ɨɲɢɛɨɤ, ɞɥɹ ɩɪɨɱɢɯ ɨɲɢɛɨɤ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, ɬɚɤɢɯ
ɤɚɤ ɨɲɢɛɤɢ, ɡɚɜɢɫɹɳɢɟ ɨɬ ɞɚɧɧɵɯ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 69 ɩɨ 75).
Ссылки
[Alexandrescu01] §3 • [Boost] • [Meyers97] §46 • [Stroustrup00] §2.4.2 • [Sutter02] §4 •
[Sutter04] §2, §19
14. Предпочитайте ошибки компиляции... 41
Стр. 41
15. Активно используйте const
Резюме
const — ɜɚɲ ɞɪɭɝ: ɧɟɢɡɦɟɧɹɟɦɵɟ ɡɧɚɱɟɧɢɹ ɩɪɨɳɟ ɩɨɧɢɦɚɬɶ, ɨɬɫɥɟɠɢɜɚɬɶ ɢ ɦɨɬɢɜɢɪɨ-
ɜɚɬɶ, ɬ.ɟ. ɬɚɦ, ɝɞɟ ɷɬɨ ɰɟɥɟɫɨɨɛɪɚɡɧɨ, ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɫɬɚɧɬɵ ɜɦɟɫɬɨ ɩɟɪɟɦɟɧɧɵɯ.
ɋɞɟɥɚɣɬɟ const ɨɩɢɫɚɧɢɟɦ ɩɨ ɭɦɨɥɱɚɧɢɸ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɡɧɚɱɟɧɢɹ — ɷɬɨ ɛɟɡɨɩɚɫɧɨ, ɩɪɨ-
ɜɟɪɹɟɦɨ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 14) ɢ ɢɧɬɟɝɪɢɪɭɟɦɨ ɫ ɫɢɫɬɟɦɨɣ ɬɢɩɨɜ C++.
ɇɟ ɜɵɩɨɥɧɹɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ ɬɢɩɨɜ ɫ ɨɬɛɪɚɫɵɜɚɧɢɟɦ const ɤɪɨɦɟ ɤɚɤ ɩɪɢ ɜɵɡɨɜɟ ɧɟɤɨɪ-
ɪɟɤɬɧɨɣ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɭɩɨɬɪɟɛɥɟɧɢɹ const ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 94).
Ʉɨɧɫɬɚɧɬɵ ɭɩɪɨɳɚɸɬ ɤɨɞ, ɩɨɫɤɨɥɶɤɭ ɜɚɦ ɞɨɫɬɚɬɨɱɧɨ ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ ɜɡɝɥɹɧɭɬɶ ɧɚ ɟɟ ɨɩ-
ɪɟɞɟɥɟɧɢɟ, ɱɬɨɛɵ ɡɧɚɬɶ, ɱɟɦɭ ɨɧɚ ɪɚɜɧɚ ɜɟɡɞɟ. Ɋɚɫɫɦɨɬɪɢɦ ɬɚɤɨɣ ɤɨɞ:
void Fun( vector<int>& v ) {
// ...
const size_t len = v.size();
// ... ǳ ǰȄǰ 30 Ǽǽǻǹǵ ...
}
ɍɜɢɞɟɜ ɬɚɤɨɟ ɨɩɪɟɞɟɥɟɧɢɟ len, ɜɵ ɩɨɥɭɱɚɟɬɟ ɧɚɞɟɠɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨ ɫɟɦɚɧɬɢɤɟ ɷɬɨɣ
ɤɨɧɫɬɚɧɬɵ ɜ ɩɪɟɞɟɥɚɯ ɨɛɥɚɫɬɢ ɟɟ ɜɢɞɢɦɨɫɬɢ (ɜ ɩɪɟɞɩɨɥɨɠɟɧɢɢ, ɱɬɨ ɤɨɞ ɧɟ ɭɫɬɪɚɧɹɟɬ ɟɟ ɤɨɧ-
ɫɬɚɧɬɧɨɫɬɶ, ɱɟɝɨ ɨɧ ɞɟɥɚɬɶ ɧɟ ɞɨɥɠɟɧ, ɤɚɤ ɜɵ ɭɡɧɚɟɬɟ ɞɚɥɟɟ): ɷɬɨ ɢɧɮɨɪɦɚɰɢɹ ɨ ɞɥɢɧɟ v ɜ ɨɩ-
ɪɟɞɟɥɟɧɧɨɣ ɬɨɱɤɟ ɩɪɨɝɪɚɦɦɵ. ȼɡɝɥɹɧɭɜ ɧɚ ɨɞɧɭ ɫɬɪɨɤɭ, ɜɵ ɩɨɥɭɱɢɥɢ ɜɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɢɧ-
ɮɨɪɦɚɰɢɸ ɞɥɹ ɜɫɟɣ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ. ȿɫɥɢ ɛɵ ɩɟɪɟɦɟɧɧɚɹ len ɧɟ ɛɵɥɚ ɨɩɪɟɞɟɥɟɧɚ ɤɚɤ
const, ɨɧɚ ɦɨɝɥɚ ɛɵ ɛɵɬɶ ɩɨɡɠɟ ɢɡɦɟɧɟɧɚ — ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɢɥɢ ɤɨɫɜɟɧɧɨ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɨɩɢɫɚɧɢɟ const ɧɟ ɹɜɥɹɟɬɫɹ ɝɥɭɛɨɤɢɦ. ɑɬɨɛɵ ɩɨɧɹɬɶ ɱɬɨ ɢɦɟɟɬɫɹ ɜ ɜɢɞɭ,
ɪɚɫɫɦɨɬɪɢɦ ɤɥɚɫɫ C, ɤɨɬɨɪɵɣ ɢɦɟɟɬ ɱɥɟɧ ɬɢɩɚ X*. ȼ ɨɛɴɟɤɬɟ C, ɤɨɬɨɪɵɣ ɹɜɥɹɟɬɫɹ ɤɨɧɫɬɚɧɬɨɣ,
ɱɥɟɧ X* ɬɚɤɠɟ ɹɜɥɹɟɬɫɹ ɤɨɧɫɬɚɧɬɨɣ, ɧɨ ɫɚɦ ɨɛɴɟɤɬ X, ɧɚ ɤɨɬɨɪɵɣ ɨɧ ɭɤɚɡɵɜɚɟɬ, ɤɨɧɫɬɚɧɬɨɣ ɧɟ
ɹɜɥɹɟɬɫɹ (ɫɦ. [Saks99]).
Ʌɨɝɢɱɟɫɤɭɸ ɤɨɧɫɬɚɧɬɧɨɫɬɶ ɫɥɟɞɭɟɬ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɱɥɟɧɨɜ, ɨɩɢɫɚɧɧɵɯ
ɤɚɤ mutable. Ʉɨɝɞɚ ɤɨɧɫɬɚɧɬɧɚɹ ɮɭɧɤɰɢɹ-ɱɥɟɧ ɤɥɚɫɫɚ ɨɩɪɚɜɞɚɧɧɨ ɬɪɟɛɭɟɬ ɦɨɞɢɮɢɤɚɰɢɢ ɩɟ-
ɪɟɦɟɧɧɨɣ-ɱɥɟɧɚ (ɬ.ɟ. ɤɨɝɞɚ ɷɬɚ ɩɟɪɟɦɟɧɧɚɹ ɧɟ ɜɥɢɹɟɬ ɧɚ ɧɚɛɥɸɞɚɟɦɨɟ ɫɨɫɬɨɹɧɢɟ ɨɛɴɟɤɬɚ, ɧɚ-
ɩɪɢɦɟɪ, ɟɫɥɢ ɷɬɨ ɤɷɲɢɪɨɜɚɧɧɵɟ ɞɚɧɧɵɟ), ɨɛɴɹɜɢɬɟ ɷɬɭ ɩɟɪɟɦɟɧɧɭɸ-ɱɥɟɧ ɤɚɤ mutable. Ɂɚɦɟ-
ɬɢɦ, ɱɬɨ ɟɫɥɢ ɜɫɟ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ ɫɤɪɵɬɵ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 43), ɨɩɢɫɚɧɢɟ mutable ɧɟ ɹɜɥɹɟɬɫɹ ɧɟɨɛɯɨɞɢɦɵɦ ɧɢ ɞɥɹ ɤɷɲɢɪɨɜɚɧɧɨɣ ɢɧɮɨɪɦɚɰɢɢ, ɧɢ
ɞɥɹ ɧɟɢɡɦɟɧɧɨɝɨ ɭɤɚɡɚɬɟɥɹ ɧɚ ɧɟɟ.
Ɇɨɞɢɮɢɤɚɬɨɪ const ɧɚɩɨɦɢɧɚɟɬ ɜɢɪɭɫɧɨɟ ɡɚɛɨɥɟɜɚɧɢɟ — ɩɨɹɜɢɜɲɢɫɶ ɜ ɜɚɲɟɦ ɤɨɞɟ
ɨɞɢɧ ɪɚɡ, ɨɧ ɩɪɢɜɟɞɟɬ ɤ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɢɡɦɟɧɟɧɢɹ ɫɢɝɧɚɬɭɪ ɮɭɧɤɰɢɣ, ɤɨ-
ɬɨɪɵɟ ɟɳɟ ɧɟ ɹɜɥɹɸɬɫɹ ɤɨɪɪɟɤɬɧɵɦɢ ɜ ɩɥɚɧɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ const. ɗɬɨ ɤɚɤ ɪɚɡ ɧɟ ɨɲɢɛɤɚ,
ɚ ɯɨɪɨɲɟɟ ɫɜɨɣɫɬɜɨ, ɫɭɳɟɫɬɜɟɧɧɨ ɭɜɟɥɢɱɢɜɚɸɳɟɟ ɦɨɳɶ ɦɨɞɢɮɢɤɚɬɨɪɚ const, ɤɨɬɨɪɵɣ ɟɳɟ
ɧɟ ɬɚɤ ɞɚɜɧɨ ɛɵɥ ɞɨɫɬɚɬɨɱɧɨ ɡɚɛɪɨɲɟɧ, ɚ ɟɝɨ ɜɨɡɦɨɠɧɨɫɬɢ ɧɟ ɜɩɨɥɧɟ ɩɨɧɹɬɵ ɢ ɨɰɟɧɟɧɵ. ɉɟ-
ɪɟɞɟɥɤɚ ɫɭɳɟɫɬɜɭɸɳɟɝɨ ɤɨɞɚ ɞɥɹ ɟɝɨ ɤɨɪɪɟɤɬɧɨɫɬɢ ɜ ɩɥɚɧɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ const ɬɪɟɛɭɟɬ
ɭɫɢɥɢɣ, ɧɨ ɨɧɢ ɫɬɨɹɬ ɬɨɝɨ ɢ ɞɚɠɟ ɩɨɡɜɨɥɹɸɬ ɜɵɹɜɢɬɶ ɫɤɪɵɬɵɟ ɨɲɢɛɤɢ.
Ʉɨɪɪɟɤɬɧɨɟ ɩɪɢɦɟɧɟɧɢɟ const ɞɚɟɬ ɨɬɥɢɱɧɵɟ ɪɟɡɭɥɶɬɚɬɵ ɢ ɩɨɜɵɲɚɟɬ ɷɮɮɟɤɬɢɜɧɨɫɬɶ.
ɑɪɟɡɜɵɱɚɣɧɨ ɜɚɠɧɨ ɩɪɚɜɢɥɶɧɨ ɢ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɨɞɢɮɢɤɚɬɨɪ const ɜ ɜɚɲɢɯ
ɩɪɨɝɪɚɦɦɚɯ. ɉɨɧɢɦɚɧɢɟ ɬɨɝɨ, ɤɚɤ ɢ ɝɞɟ ɢɡɦɟɧɹɟɬɫɹ ɫɨɫɬɨɹɧɢɟ ɩɪɨɝɪɚɦɦɵ, ɨɫɨɛɟɧɧɨ ɧɟɨɛɯɨ-
ɞɢɦɨ, ɚ ɦɨɞɢɮɢɤɚɬɨɪ const ɩɨ ɫɭɬɢ ɞɨɤɭɦɟɧɬɢɪɭɟɬ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɜ ɤɨɞɟ ɩɪɨɝɪɚɦɦɵ, ɝɞɟ
ɢɦɟɧɧɨ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɩɨɦɨɱɶ ɜɚɦ ɜ ɷɬɨɦ. ɉɪɚɜɢɥɶɧɨɟ ɭɩɨɬɪɟɛɥɟɧɢɟ const ɩɨɦɨɠɟɬ ɜɚɦ
ɥɭɱɲɟ ɪɚɡɨɛɪɚɬɶɫɹ ɫ ɜɨɩɪɨɫɚɦɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɢ ɫɞɟɥɚɬɶ ɜɚɲ ɤɨɞ ɛɨɥɟɟ ɧɚɞɟɠɧɵɦ ɢ ɛɟɡɨ-
Стр. 42
ɩɚɫɧɵɦ. ȿɫɥɢ ɜɵ ɜɵɹɫɧɢɥɢ, ɱɬɨ ɧɟɤɨɬɨɪɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ ɧɟɜɨɡɦɨɠɧɨ ɫɞɟɥɚɬɶ ɤɨɧɫɬɚɧɬɧɨɣ,
ɡɧɚɱɢɬ, ɜɵ ɛɨɥɟɟ ɞɟɬɚɥɶɧɨ ɪɚɡɨɛɪɚɥɢɫɶ ɫ ɬɟɦ, ɤɚɤ, ɝɞɟ ɢ ɩɨɱɟɦɭ ɷɬɚ ɮɭɧɤɰɢɹ ɦɨɞɢɮɢɰɢɪɭɟɬ
ɫɨɫɬɨɹɧɢɟ ɨɛɴɟɤɬɚ. Ʉɪɨɦɟ ɬɨɝɨ, ɜɵ ɫɦɨɠɟɬɟ ɩɨɧɹɬɶ, ɤɚɤɢɟ ɱɥɟɧɵ-ɞɚɧɧɵɟ ɨɛɴɟɞɢɧɹɸɬ ɮɢɡɢ-
ɱɟɫɤɭɸ ɢ ɥɨɝɢɱɟɫɤɭɸ ɤɨɧɫɬɚɧɬɧɨɫɬɶ (ɫɦ. ɩɪɢɜɟɞɟɧɧɵɟ ɧɢɠɟ ɩɪɢɦɟɪɵ).
ɇɢɤɨɝɞɚ ɧɟ ɩɪɢɛɟɝɚɣɬɟ ɤ ɩɪɟɨɛɪɚɡɨɜɚɧɢɸ ɤɨɧɫɬɚɧɬɧɨɝɨ ɬɢɩɚ ɜ ɧɟɤɨɧɫɬɚɧɬɧɵɣ, ɤɪɨɦɟ ɫɥɭ-
ɱɚɟɜ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ, ɧɟɤɨɪɪɟɤɬɧɨɣ ɜ ɩɥɚɧɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɦɨɞɢɮɢɤɚɬɨɪɚ const (ɧɟ ɦɨɞɢ-
ɮɢɰɢɪɭɸɳɟɣ ɩɚɪɚɦɟɬɪ, ɤɨɬɨɪɵɣ ɬɟɦ ɧɟ ɦɟɧɟɟ ɨɩɢɫɚɧ ɤɚɤ ɧɟɤɨɧɫɬɚɧɬɧɵɣ), ɚ ɬɚɤɠɟ ɬɚɤɨɝɨ
ɪɟɞɤɨɝɨ ɫɥɭɱɚɹ, ɤɚɤ ɫɩɨɫɨɛ ɡɚɦɟɧɵ mutable ɜ ɫɬɚɪɨɦ ɤɨɦɩɢɥɹɬɨɪɟ, ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɳɟɦ ɷɬɭ
ɜɨɡɦɨɠɧɨɫɬɶ.
Примеры
ɉɪɢɦɟɪ. ɂɡɛɟɝɚɣɬɟ const ɜ ɨɛɴɹɜɥɟɧɢɹɯ ɮɭɧɤɰɢɣ, ɩɪɢɧɢɦɚɸɳɢɯ ɩɚɪɚɦɟɬɪɵ ɩɨ ɡɧɚɱɟ-
ɧɢɸ. Ⱦɜɚ ɫɥɟɞɭɸɳɢɯ ɨɛɴɹɜɥɟɧɢɹ ɚɛɫɨɥɸɬɧɨ ɷɤɜɢɜɚɥɟɧɬɧɵ:
void Fun( int x );
void Fun( const int x ); // ǙǬȅȊǭǶǰǸǳǰ ǽǹǴ Ǳǰ ǼǫǷǹǴ ǿǾǸǵȁǳǳ:
// const ǲǯǰǼȇ ǳǮǸǹǻǳǻǾǰǽǼȊ
ȼɨ ɜɬɨɪɨɦ ɨɛɴɹɜɥɟɧɢɢ ɦɨɞɢɮɢɤɚɬɨɪ const ɢɡɛɵɬɨɱɟɧ. Ɇɵ ɪɟɤɨɦɟɧɞɭɟɦ ɨɛɴɹɜɥɹɬɶ
ɮɭɧɤɰɢɢ ɛɟɡ ɬɚɤɢɯ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɯ ɦɨɞɢɮɢɤɚɬɨɪɨɜ const, ɱɬɨɛɵ ɬɨɬ, ɤɬɨ ɱɢɬɚɟɬ ɜɚɲɢ ɡɚ-
ɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɧɟ ɛɵɥ ɞɟɡɨɪɢɟɧɬɢɪɨɜɚɧ. Ɉɞɧɚɤɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɬɚɤɨɝɨ ɦɨɞɢɮɢɤɚɬɨɪɚ
ɢɦɟɟɬ ɡɧɚɱɟɧɢɟ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɮɭɧɤɰɢɢ ɢ ɟɝɨ ɩɪɢɦɟɧɟɧɢɟ ɦɨɠɟɬ ɛɵɬɶ ɨɩɪɚɜɞɚɧɨ ɫ ɬɨɱɤɢ ɡɪɟ-
ɧɢɹ ɨɛɧɚɪɭɠɟɧɢɹ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɝɨ ɢɡɦɟɧɟɧɢɹ ɩɟɪɟɞɚɧɧɨɝɨ ɩɚɪɚɦɟɬɪɚ:
void Fun( const int x ) { // ǙǺǻǰǯǰǶǰǸǳǰ ǿǾǸǵȁǳǳ Fun
// ...
++x; // ǙȃǳǬǵǫ: ǸǰǶȇǲȊ ǳǲǷǰǸȊǽȇ ǵǹǸǼǽǫǸǽǸǹǰ ǲǸǫȂǰǸǳǰ
// ...
}
Ссылки
[Allison98] §10 • [Cline99] §14.02-12 • [Dewhurst03] §6, §31-32, §82 • [Keffer95] pp. 5-6 •
[Koenig97] §4 • [Lakos96] §9.1.6, §9.1.12 • [Meyers97] §21 • [Murray93] §2.7 • [Stroustrup00]
§7.2, §10.2.6, §16.3.1 • [Sutter00] §43
15. Активно используйте const 43
Стр. 43
16. Избегайте макросов
Резюме
Ɇɚɤɪɨɫ — ɫɚɦɵɣ ɧɟɩɪɢɹɬɧɵɣ ɢɧɫɬɪɭɦɟɧɬ C ɢ C++, ɨɛɨɪɨɬɟɧɶ, ɫɤɪɵɜɚɸɳɢɣɫɹ ɩɨɞ ɥɢɱɢ-
ɧɨɣ ɮɭɧɤɰɢɢ, ɤɨɬ, ɝɭɥɹɸɳɢɣ ɫɚɦ ɩɨ ɫɟɛɟ ɢ ɧɟ ɨɛɪɚɳɚɸɳɢɣ ɧɢɤɚɤɨɝɨ ɜɧɢɦɚɧɢɹ ɧɚ ɝɪɚɧɢɰɵ
ɜɚɲɢɯ ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ. Ȼɟɪɟɝɢɬɟɫɶ ɟɝɨ!
Ɍɪɭɞɧɨ ɧɚɣɬɢ ɹɡɵɤ, ɞɨɫɬɚɬɨɱɧɨ ɤɪɚɫɨɱɧɵɣ, ɱɬɨɛɵ ɜɵɪɚɡɢɬɶ ɜɫɟ, ɱɬɨ ɯɨɱɟɬɫɹ ɫɤɚɡɚɬɶ ɨ ɦɚɤ-
ɪɨɫɚɯ. ɇɨ ɬɟɦ ɧɟ ɦɟɧɟɟ ɩɪɢɜɟɞɟɦ ɧɟɫɤɨɥɶɤɨ ɰɢɬɚɬ.
Ɇɚɤɪɨɫɵ ɩɨ ɦɧɨɝɢɦ ɩɪɢɱɢɧɚɦ — ɜɟɫɶɦɚ ɧɟɩɪɢɹɬɧɚɹ ɜɟɳɶ, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɫɬɚɬɶ ɩɨ-
ɩɪɨɫɬɭ ɨɩɚɫɧɨɣ. ȼ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɷɬɨ ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɦɚɤɪɨɫɵ — ɫɪɟɞɫɬɜɨ ɡɚɦɟɧɵ
ɬɟɤɫɬɚ, ɞɟɣɫɬɜɭɸɳɟɟ ɜɨ ɜɪɟɦɹ ɨɛɪɚɛɨɬɤɢ ɢɫɯɨɞɧɨɝɨ ɬɟɤɫɬɚ ɩɪɟɩɪɨɰɟɫɫɨɪɨɦ, ɬ.ɟ. ɟɳɟ
ɞɨ ɬɨɝɨ, ɤɚɤ ɧɚɱɧɟɬɫɹ ɤɚɤɚɹ-ɥɢɛɨ ɩɪɨɜɟɪɤɚ ɫɢɧɬɚɤɫɢɫɚ ɢ ɫɟɦɚɧɬɢɤɢ. — [Sutter04] §31
Ɇɧɟ ɧɟ ɧɪɚɜɢɬɫɹ ɛɨɥɶɲɢɧɫɬɜɨ ɜɢɞɨɜ ɩɪɟɩɪɨɰɟɫɫɨɪɨɜ ɢ ɦɚɤɪɨɫɨɜ. Ɉɞɧɚ ɢɡ ɰɟɥɟɣ C++ —
ɫɞɟɥɚɬɶ ɩɪɟɩɪɨɰɟɫɫɨɪ C ɢɡɥɢɲɧɢɦ (§4.4, §18), ɩɨɫɤɨɥɶɤɭ ɹ ɫɱɢɬɚɸ ɟɝɨ ɛɨɥɶɲɨɣ ɨɲɢɛ-
ɤɨɣ. — [Stroustrup94] §3.3.1.
Ɇɚɤɪɨɫɵ ɩɨɱɬɢ ɧɢɤɨɝɞɚ ɧɟ ɹɜɥɹɸɬɫɹ ɧɟɨɛɯɨɞɢɦɵɦɢ ɜ C++. ɂɫɩɨɥɶɡɭɣɬɟ const (§5.4) ɢɥɢ
enum (§4.8) ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɹɜɧɵɯ ɤɨɧɫɬɚɧɬ [ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15], inline (§7.1.1) ɞɥɹ
ɬɨɝɨ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɚɤɥɚɞɧɵɯ ɪɚɫɯɨɞɨɜ ɧɚ ɜɵɡɨɜ ɮɭɧɤɰɢɢ [ɧɨ ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8],
template (ɝɥɚɜɚ 13) ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɫɟɦɟɣɫɬɜ ɮɭɧɤɰɢɣ ɢ ɬɢɩɨɜ [ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 64
ɩɨ 67], ɢ namespace (§8.2) ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɤɨɧɮɥɢɤɬɨɜ ɢɦɟɧ [ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ
ɫ 57 ɩɨ 59]. — [Stroustrup00] §1.6.1
ɉɟɪɜɨɟ ɩɪɚɜɢɥɨ ɩɨ ɩɪɢɦɟɧɟɧɢɸ ɦɚɤɪɨɫɨɜ ɝɥɚɫɢɬ: ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɢɯ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɭ
ɜɚɫ ɧɟ ɛɭɞɟɬ ɞɪɭɝɨɝɨ ɜɵɯɨɞɚ. ɉɪɚɤɬɢɱɟɫɤɢ ɥɸɛɨɣ ɦɚɤɪɨɫ ɫɜɢɞɟɬɟɥɶɫɬɜɭɟɬ ɨ ɧɟɫɨɜɟɪ-
ɲɟɧɫɬɜɟ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɩɪɨɝɪɚɦɦɵ ɢɥɢ ɩɪɨɝɪɚɦɦɢɫɬɚ. — [Stroustrup00] §7.8
Ɉɫɧɨɜɧɚɹ ɩɪɨɛɥɟɦɚ ɫ ɦɚɤɪɨɫɚɦɢ C++ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɨɧɢ ɜɵɝɥɹɞɹɬ ɝɨɪɚɡɞɨ ɩɪɢ-
ɜɥɟɤɚɬɟɥɶɧɟɟ, ɱɟɦ ɹɜɥɹɸɬɫɹ ɬɚɤɨɜɵɦɢ ɧɚ ɫɚɦɨɦ ɞɟɥɟ. Ɇɚɤɪɨɫɵ ɢɝɧɨɪɢɪɭɸɬ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨ-
ɫɬɢ, ɢɝɧɨɪɢɪɭɸɬ ɩɪɨɱɢɟ ɜɨɡɦɨɠɧɨɫɬɢ ɢ ɩɪɚɜɢɥɚ ɹɡɵɤɚ, ɢ ɡɚɦɟɧɹɸɬ ɜɫɟ ɫɢɦɜɨɥɵ, ɤɨɬɨɪɵɟ ɩɟ-
ɪɟɨɩɪɟɞɟɥɹɸɬ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #define, ɞɨ ɫɚɦɨɝɨ ɤɨɧɰɚ ɮɚɣɥɚ. ɉɪɢɦɟɧɟɧɢɟ ɦɚɤɪɨ-
ɫɨɜ ɜɧɟɲɧɟ ɩɨɯɨɞɢɬ ɧɚ ɢɦɹ ɢɥɢ ɜɵɡɨɜ ɮɭɧɤɰɢɢ, ɧɨ ɧɟ ɢɦɟɟɬ ɫ ɧɢɦɢ ɧɢɱɟɝɨ ɨɛɳɟɝɨ. Ɇɚɤɪɨɫɵ
“ɧɟɝɢɝɢɟɧɢɱɧɵ”, ɜ ɬɨɦ ɫɦɵɫɥɟ, ɱɬɨ ɨɧɢ ɦɨɝɭɬ ɛɵɬɶ ɪɚɫɤɪɵɬɵ ɧɟɨɠɢɞɚɧɧɨ, ɩɪɢɱɟɦ ɩɪɟɜɪɚ-
ɬɢɬɶɫɹ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɤɨɧɬɟɤɫɬɚ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɫɚɦɵɟ ɪɚɡɧɵɟ ɤɨɧɫɬɪɭɤɰɢɢ. ɉɨɞɫɬɚ-
ɧɨɜɤɚ ɬɟɤɫɬɚ, ɜɵɩɨɥɧɹɟɦɚɹ ɦɚɤɪɨɫɚɦɢ, ɞɟɥɚɟɬ ɧɚɩɢɫɚɧɢɟ ɯɨɬɹ ɛɵ ɜ ɧɟɛɨɥɶɲɨɣ ɫɬɟɩɟɧɢ
“ɩɪɢɥɢɱɧɨɝɨ” ɦɚɤɪɨɫɚ ɫɦɟɫɶɸ ɢɫɤɭɫɫɬɜɚ ɢ ɱɟɪɧɨɣ ɦɚɝɢɢ.
ɉɪɨɝɪɚɦɦɢɫɬɵ, ɤɨɬɨɪɵɟ ɩɨɥɚɝɚɸɬ, ɱɬɨ ɬɹɠɟɥɟɟ ɜɫɟɝɨ ɪɚɫɲɢɮɪɨɜɚɬɶ ɨɲɢɛɤɢ, ɫɜɹɡɚɧɧɵɟ ɫ
ɲɚɛɥɨɧɚɦɢ, ɜɟɪɨɹɬɧɨ, ɩɪɨɫɬɨ ɧɢɤɨɝɞɚ ɧɟ ɢɦɟɥɢ ɞɟɥɚ ɫ ɩɥɨɯɨ ɧɚɩɢɫɚɧɧɵɦɢ ɢɥɢ ɧɟɜɟɪɧɨ ɢɫ-
ɩɨɥɶɡɨɜɚɧɧɵɦɢ ɦɚɤɪɨɫɚɦɢ. ɒɚɛɥɨɧɵ ɹɜɥɹɸɬɫɹ ɱɚɫɬɶɸ ɫɢɫɬɟɦɵ ɬɢɩɨɜ C++, ɢ ɬɟɦ ɫɚɦɵɦ ɩɨ-
ɡɜɨɥɹɸɬ ɤɨɦɩɢɥɹɬɨɪɭ ɤɭɞɚ ɥɭɱɲɟ ɫɩɪɚɜɥɹɬɶɫɹ ɫ ɧɢɦɢ, ɱɟɦ ɫ ɦɚɤɪɨɫɚɦɢ, ɤɨɬɨɪɵɟ ɢɦɟɸɬ ɦɚɥɨ
ɨɛɳɟɝɨ ɫ ɹɡɵɤɨɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. ɏɭɠɟ ɬɨɝɨ, ɜ ɨɬɥɢɱɢɟ ɨɬ ɲɚɛɥɨɧɨɜ ɧɟɜɟɪɧɵɟ ɦɚɤɪɨɫɵ
ɦɨɝɭɬ ɛɵɬɶ ɪɚɫɤɪɵɬɵ ɜ ɧɟɱɬɨ, ɱɬɨ ɜ ɫɢɥɭ ɱɢɫɬɨɣ ɫɥɭɱɚɣɧɨɫɬɢ ɫɤɨɦɩɢɥɢɪɭɟɬɫɹ, ɧɟ ɢɦɟɹ ɩɪɢ
ɷɬɨɦ ɧɢɤɚɤɨɝɨ ɫɦɵɫɥɚ. ɂ ɧɚɤɨɧɟɰ, ɨɲɢɛɤɚ ɜ ɦɚɤɪɨɫɟ ɨɛɧɚɪɭɠɢɜɚɟɬɫɹ ɬɨɥɶɤɨ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ
ɦɚɤɪɨɫ ɪɚɫɤɪɵɜɚɟɬɫɹ, ɚ ɧɟ ɩɪɢ ɟɝɨ ɨɩɪɟɞɟɥɟɧɢɢ.
Стр. 44
Ⱦɚɠɟ ɜ ɬɟɯ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ, ɝɞɟ ɩɪɢɦɟɧɟɧɢɟ ɦɚɤɪɨɫɨɜ ɨɩɪɚɜɞɚɧɧɨ (ɫɦ. ɩɨɞɪɚɡɞɟɥ, ɩɨɫɜɹ-
ɳɟɧɧɵɣ ɢɫɤɥɸɱɟɧɢɹɦ), ɧɟɥɶɡɹ ɞɚɠɟ ɩɨɞɭɦɚɬɶ ɨ ɬɨɦ, ɱɬɨɛɵ ɧɚɩɢɫɚɬɶ ɦɚɤɪɨɫ, ɤɨɬɨɪɵɣ ɹɜɥɹ-
ɟɬɫɹ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɫɥɨɜɨɦ ɢɥɢ ɚɛɛɪɟɜɢɚɬɭɪɨɣ. Ⱦɥɹ ɜɫɟɯ ɦɚɤɪɨɫɨɜ ɤɚɤ ɦɨɠɧɨ ɫɤɨɪɟɟ
ɩɪɢɦɟɧɹɣɬɟ ɞɢɪɟɤɬɢɜɭ #undef, ɜɫɟɝɞɚ ɞɚɜɚɹ ɢɦ ɧɟɨɛɵɱɧɵɟ ɭɪɨɞɥɢɜɵɟ ɢɦɟɧɚ ɜ ɜɟɪɯɧɟɦ ɪɟɝɢ-
ɫɬɪɟ, ɢɡɛɟɝɚɹ ɩɪɢ ɷɬɨɦ ɪɚɡɦɟɳɟɧɢɹ ɢɯ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ.
Примеры
ɉɪɢɦɟɪ. ɉɟɪɟɞɚɱɚ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ ɲɚɛɥɨɧɚ ɦɚɤɪɨɫɭ. Ɇɚɤɪɨɫɵ ɩɨɧɢɦɚɸɬ ɜ ɞɨɫɬɚɬɨɱ-
ɧɨɣ ɦɟɪɟ ɬɨɥɶɤɨ ɤɪɭɝɥɵɟ ɢ ɤɜɚɞɪɚɬɧɵɟ ɫɤɨɛɤɢ. ȼ C++, ɨɞɧɚɤɨ, ɨɩɪɟɞɟɥɟɧɚ ɧɨɜɚɹ ɤɨɧɫɬɪɭɤɰɢɹ
ɫ ɭɝɥɨɜɵɦɢ ɫɤɨɛɤɚɦɢ, ɢɫɩɨɥɶɡɭɟɦɚɹ ɜ ɲɚɛɥɨɧɚɯ. Ɇɚɤɪɨɫɵ ɧɟ ɦɨɝɭɬ ɤɨɪɪɟɤɬɧɨ ɨɛɪɚɛɨɬɚɬɶ ɷɬɭ
ɫɢɬɭɚɰɢɸ, ɬɚɤ ɱɬɨ ɜɵɡɨɜ
MACRO( Foo<int, double> )
ɦɚɤɪɨɫ ɜɨɫɩɪɢɧɢɦɚɟɬ ɬɚɤ, ɛɭɞɬɨ ɟɦɭ ɩɟɪɟɞɚɧɵ ɞɜɚ ɚɪɝɭɦɟɧɬɚ, ɚ ɢɦɟɧɧɨ Foo<int ɢ double>,
ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɷɬɚ ɤɨɧɫɬɪɭɤɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɟɞɢɧɵɣ ɨɛɴɟɤɬ C++.
Ɇɚɤɪɨɫɵ ɨɫɬɚɸɬɫɹ ɟɞɢɧɫɬɜɟɧɧɨ ɜɨɡɦɨɠɧɵɦ ɪɟɲɟɧɢɟɦ ɞɥɹ ɧɟɤɨɬɨɪɵɯ ɜɚɠɧɵɯ ɡɚɞɚɱ, ɬɚɤɢɯ
ɤɚɤ ɡɚɳɢɬɚ ɞɢɪɟɤɬɢɜɵ #include (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 24), ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɞɢɪɟɤɬɢɜ #ifdef ɢ
#if defined ɞɥɹ ɭɫɥɨɜɧɨɣ ɤɨɦɩɢɥɹɰɢɢ ɢ ɪɟɚɥɢɡɚɰɢɹ assert (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68).
ɉɪɢ ɭɫɥɨɜɧɨɣ ɤɨɦɩɢɥɹɰɢɢ (ɧɚɩɪɢɦɟɪ, ɫɢɫɬɟɦɧɨ-ɡɚɜɢɫɢɦɵɯ ɱɚɫɬɟɣ) ɢɡɛɟɝɚɣɬɟ ɪɚɡɛɪɨɫɚ ɩɨ
ɜɫɟɦɭ ɬɟɤɫɬɭ ɞɢɪɟɤɬɢɜ #ifdef. ȼɦɟɫɬɨ ɷɬɨɝɨ ɥɭɱɲɟ ɨɪɝɚɧɢɡɨɜɚɬɶ ɤɨɞ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɦɚɤɪɨɫɨɜ ɨɛɟɫɩɟɱɢɜɚɥɨ ɜɨɡɦɨɠɧɨɫɬɶ ɚɥɶɬɟɪɧɚɬɢɜɧɵɯ ɪɟɚɥɢɡɚɰɢɣ ɨɞɧɨɝɨ ɨɛ-
ɳɟɝɨ ɢɧɬɟɪɮɟɣɫɚ, ɤɨɬɨɪɵɣ ɡɚɬɟɦ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜ ɩɪɨɝɪɚɦɦɟ.
Ɇɨɠɧɨ (ɧɨ ɨɫɬɨɪɨɠɧɨ) ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɚɤɪɨɫɵ ɜɦɟɫɬɨ ɛɨɥɶɲɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɤɨɩɢɪɨɜɚɧɢɣ
ɢ ɜɫɬɚɜɨɤ ɛɥɢɡɤɢɯ ɮɪɚɝɦɟɧɬɨɜ ɤɨɞɚ.
Ɂɚɦɟɬɢɦ, ɱɬɨ [C99] ɢ [Boost] ɜɤɥɸɱɚɸɬ ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ ɭɦɟɪɟɧɧɵɟ ɢ ɪɚɞɢɤɚɥɶɧɵɟ ɪɚɫɲɢ-
ɪɟɧɢɹ ɩɪɟɩɪɨɰɟɫɫɨɪɨɜ.
Ссылки
[Boost] • [C99] • [Dewhurst03] §25-28 • [Lakos96] §2.3.4 • [Meyers96] §1 • [Stroustrup94] §3.3.1 •
[Stroustrup00] §1.6.1, §7.8 • [Sutter02] §34-35 • [Sutter04] §31 • [Sutter04a]
16. Избегайте макросов 45
Стр. 45
17. Избегайте магических чисел
Резюме
ɂɡɛɟɝɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɨɞɟ ɥɢɬɟɪɚɥɶɧɵɯ ɤɨɧɫɬɚɧɬ ɧɚɩɨɞɨɛɢɟ 42 ɢɥɢ 3.1415926.
Ɍɚɤɢɟ ɤɨɧɫɬɚɧɬɵ ɧɟ ɫɚɦɨɨɱɟɜɢɞɧɵ ɢ ɭɫɥɨɠɧɹɸɬ ɫɨɩɪɨɜɨɠɞɟɧɢɟ ɤɨɞɚ, ɩɨɫɤɨɥɶɤɭ ɜɧɨɫɹɬ ɜ ɧɟ-
ɝɨ ɬɪɭɞɧɨɨɩɪɟɞɟɥɢɦɵɣ ɜɢɞ ɞɭɛɥɢɪɨɜɚɧɢɹ. ɂɫɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɧɢɯ ɫɢɦɜɨɥɶɧɵɟ ɢɦɟɧɚ ɢ ɜɵ-
ɪɚɠɟɧɢɹ ɧɚɩɨɞɨɛɢɟ width*aspectRatio.
ɂɦɟɧɚ ɞɨɛɚɜɥɹɸɬ ɢɧɮɨɪɦɚɰɢɸ ɢ ɜɜɨɞɹɬ ɟɞɢɧɭɸ ɬɨɱɤɭ ɫɨɩɪɨɜɨɠɞɟɧɢɹ; ɜ ɨɬɥɢɱɢɟ ɨɬ ɧɢɯ
ɞɭɛɥɢɪɨɜɚɧɧɵɟ ɩɨ ɜɫɟɣ ɩɪɨɝɪɚɦɦɟ ɨɛɵɱɧɵɟ ɱɢɫɥɚ ɚɧɨɧɢɦɧɵ ɢ ɬɪɭɞɧɨ ɫɨɩɪɨɜɨɠɞɚɟɦɵ. Ʉɨɧ-
ɫɬɚɧɬɵ ɞɨɥɠɧɵ ɛɵɬɶ ɩɟɪɟɱɢɫɥɟɧɢɹɦɢ ɢɥɢ const-ɡɧɚɱɟɧɢɹɦɢ, ɫ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦɢ ɨɛɥɚɫɬɹ-
ɦɢ ɜɢɞɢɦɨɫɬɢ ɢ ɢɦɟɧɚɦɢ.
Ɉɞɧɨ ɱɢɫɥɨ 42 ɦɨɠɟɬ ɧɟ ɛɵɬɶ ɬɟɦ ɠɟ ɱɢɫɥɨɦ 42, ɱɬɨ ɢ ɞɪɭɝɨɟ. ɑɬɨ ɟɳɟ ɯɭɠɟ, ɩɪɨɝɪɚɦɦɢɫɬ
ɦɨɠɟɬ ɜɵɩɨɥɧɹɬɶ ɤɚɤɢɟ-ɬɨ ɜɵɱɢɫɥɟɧɢɹ “ɜ ɭɦɟ” (ɧɚɩɪɢɦɟɪ: “ȼɨɬ ɷɬɨ 84 — ɩɪɨɫɬɨ ɭɞɜɨɟɧɧɨɟ
42, ɤɨɬɨɪɨɟ ɛɵɥɨ ɩɹɬɶɸ ɫɬɪɨɤɚɦɢ ɪɚɧɟɟ”), ɱɬɨ ɫɨɜɟɪɲɟɧɧɨ ɡɚɩɭɬɵɜɚɟɬ ɤɨɞ ɢ ɞɟɥɚɟɬ ɩɨɫɥɟ-
ɞɭɸɳɭɸ ɡɚɦɟɧɭ 42 ɞɪɭɝɨɣ ɤɨɧɫɬɚɧɬɨɣ ɢɫɬɨɱɧɢɤɨɦ ɨɝɪɨɦɧɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɨɲɢɛɨɤ.
Ʌɭɱɲɟ ɡɚɦɟɧɹɬɶ ɬɚɤɢɟ ɠɟɫɬɤɨ ɤɨɞɢɪɨɜɚɧɧɵɟ ɜɟɥɢɱɢɧɵ ɫɢɦɜɨɥɶɧɵɦɢ ɤɨɧɫɬɚɧɬɚɦɢ. ɋɬɪɨ-
ɤɢ ɥɭɱɲɟ ɯɪɚɧɢɬɶ ɨɬɞɟɥɶɧɨ ɨɬ ɤɨɞɚ (ɧɚɩɪɢɦɟɪ, ɜ ɨɬɞɟɥɶɧɨɦ .cpp-ɮɚɣɥɟ ɢɥɢ ɮɚɣɥɟ ɪɟɫɭɪɫɚ),
ɱɬɨ ɩɨɡɜɨɥɢɬ ɧɟɩɪɨɝɪɚɦɦɢɫɬɚɦ ɩɪɨɫɦɨɬɪɟɬɶ ɢ ɨɛɧɨɜɢɬɶ ɢɯ, ɫɧɢɠɚɹ ɤɨɥɢɱɟɫɬɜɨ ɞɭɛɥɢɤɚɬɨɜ
ɢ ɩɨɦɨɝɚɹ ɜ ɢɧɬɟɪɧɚɰɢɨɧɚɥɢɡɚɰɢɢ ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ.
Примеры
ɉɪɢɦɟɪ 1. ȼɚɠɧɵɟ ɤɨɧɫɬɚɧɬɵ ɢɡ ɩɪɟɞɦɟɬɧɨɣ ɨɛɥɚɫɬɢ ɧɚ ɭɪɨɜɧɟ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ.
const size_t PAGE_SIZE = 8192,
WORDS_PER_PAGE = PAGE_SIZE / sizeof(int),
INFO_BITS_PER_PAGE = 32 * CHAR_BIT;
ɉɪɢɦɟɪ 2. Ʉɨɧɫɬɚɧɬɵ, ɫɩɟɰɢɮɢɱɧɵɟ ɞɥɹ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ. ȼɵ ɦɨɠɟɬɟ ɨɩɪɟɞɟɥɢɬɶ ɫɬɚɬɢɱɟ-
ɫɤɢɟ ɢɧɬɟɝɪɚɥɶɧɵɟ ɤɨɧɫɬɚɧɬɵ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ; ɤɨɧɫɬɚɧɬɵ ɞɪɭɝɢɯ ɬɢɩɨɜ ɬɪɟɛɭɸɬ ɨɬ-
ɞɟɥɶɧɨɝɨ ɨɩɪɟɞɟɥɟɧɢɹ ɢɥɢ ɩɪɢɦɟɧɟɧɢɹ ɤɨɪɨɬɤɢɯ ɮɭɧɤɰɢɣ.
// ǟǫǴǶ widget.h
class Widget {
// ǒǸǫȂǰǸǳǰ ǾǵǫǲǫǸǹ ǭ ǹǬȅȊǭǶǰǸǳǳ
static const int defaultWidth = 400;
// ǒǸǫȂǰǸǳǰ ǾǵǫǲǫǸǹ ǭ ǹǺǻǰǯǰǶǰǸǳǳ
static const double defaultPercent;
static const char* Name() { return "Widget"; }
};
// ǟǫǴǶ widget.cpp
// ǒǸǫȂǰǸǳǰ ǾǵǫǲǫǸǹ ǭ ǹǺǻǰǯǰǶǰǸǳǳ
const double Widget::defaultPercent = 66.67;
// ǝǻǰǬǾǰǽǼȊ ǹǬȅȊǭǶǰǸǳǰ
const int Widget::defaultWidth;
Ссылки
[Dewhurst03] §2 • [Kernighan99] §1.5 • [Stroustrup00] §4.8, §5.4
Стр. 46
18. Объявляйте переменные как можно
локальнее
Резюме
ɂɡɛɟɝɚɣɬɟ “ɪɚɡɞɭɜɚɧɢɹ” ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ. ɉɟɪɟɦɟɧɧɵɯ ɞɨɥɠɧɨ ɛɵɬɶ ɤɚɤ ɦɨɠɧɨ ɦɟɧɶ-
ɲɟ, ɚ ɜɪɟɦɹ ɢɯ ɠɢɡɧɢ — ɤɚɤ ɦɨɠɧɨ ɤɨɪɨɱɟ. ɗɬɚ ɪɟɤɨɦɟɧɞɚɰɢɹ ɩɨ ɫɭɬɢ ɹɜɥɹɟɬɫɹ ɱɚɫɬɧɵɦ ɫɥɭ-
ɱɚɟɦ ɪɟɤɨɦɟɧɞɚɰɢɢ 10.
ɉɟɪɟɦɟɧɧɵɟ, ɜɪɟɦɹ ɠɢɡɧɢ ɤɨɬɨɪɵɯ ɩɪɟɜɵɲɚɟɬ ɧɟɨɛɯɨɞɢɦɨɟ, ɢɦɟɸɬ ɪɹɞ ɧɟɞɨɫɬɚɬɤɨɜ.
• Ɉɧɢ ɞɟɥɚɸɬ ɩɪɨɝɪɚɦɦɭ ɬɪɭɞɧɨ ɩɨɧɢɦɚɟɦɨɣ ɢ ɫɨɩɪɨɜɨɠɞɚɟɦɨɣ. ɇɚɩɪɢɦɟɪ, ɞɨɥɠɟɧ ɥɢ
ɤɨɞ ɨɛɧɨɜɥɹɬɶ ɫɬɪɨɤɭ path ɧɚ ɭɪɨɜɧɟ ɦɨɞɭɥɹ, ɟɫɥɢ ɢɡɦɟɧɟɧ ɬɨɥɶɤɨ ɬɟɤɭɳɢɣ ɞɢɫɤ?
• Ɉɧɢ ɡɚɫɨɪɹɸɬ ɤɨɧɬɟɤɫɬ ɫɜɨɢɦɢ ɢɦɟɧɚɦɢ. ɇɟɩɨɫɪɟɞɫɬɜɟɧɧɵɦ ɫɥɟɞɫɬɜɢɟɦ ɹɜɥɹɟɬɫɹ ɬɨ,
ɱɬɨ ɩɟɪɟɦɟɧɧɵɟ ɧɚ ɭɪɨɜɧɟ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ, ɧɚɢɛɨɥɟɟ ɜɢɞɢɦɵɟ ɫɪɟɞɢ ɜɫɟɯ ɨɫɬɚɥɶ-
ɧɵɯ, ɨɞɧɨɜɪɟɦɟɧɧɨ ɹɜɥɹɸɬɫɹ ɢ ɧɚɢɯɭɞɲɢɦɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 10).
• Ɉɧɢ ɧɟ ɜɫɟɝɞɚ ɦɨɝɭɬ ɛɵɬɶ ɤɨɪɪɟɤɬɧɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɵ. ɇɢɤɨɝɞɚ ɧɟ ɨɛɴɹɜɥɹɣɬɟ ɩɟ-
ɪɟɦɟɧɧɭɸ ɞɨ ɬɨɝɨ, ɤɚɤ ɜɵ ɫɦɨɠɟɬɟ ɤɨɪɪɟɤɬɧɨ ɟɟ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ. ɇɟɢɧɢɰɢɚɥɢɡɢɪɨ-
ɜɚɧɧɵɟ ɩɟɪɟɦɟɧɧɵɟ — ɢɫɬɨɱɧɢɤ “ɪɚɫɩɨɥɡɚɸɳɢɯɫɹ” ɨɲɢɛɨɤ ɜɨ ɜɫɟɯ ɩɪɨɝɪɚɦɦɚɯ C
ɢ C++, ɢ ɬɪɟɛɭɸɬ ɨɫɨɛɨɝɨ ɜɧɢɦɚɧɢɹ ɜ ɫɜɹɡɢ ɫ ɬɟɦ, ɱɬɨ ɧɟ ɜɫɟɝɞɚ ɦɨɝɭɬ ɛɵɬɶ ɨɛɧɚɪɭɠɟ-
ɧɵ ɤɨɦɩɢɥɹɬɨɪɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 19).
ȼ ɱɚɫɬɧɨɫɬɢ, ɫɬɚɪɵɟ ɜɟɪɫɢɢ ɹɡɵɤɚ C ɞɨ [C99] ɬɪɟɛɨɜɚɥɢ, ɱɬɨɛɵ ɩɟɪɟɦɟɧɧɵɟ ɛɵɥɢ ɨɩɪɟɞɟ-
ɥɟɧɵ ɬɨɥɶɤɨ ɜ ɧɚɱɚɥɟ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ; ɬɚɤɨɣ ɫɬɢɥɶ ɜ C++ ɜɵɲɟɥ ɢɡ ɭɩɨɬɪɟɛɥɟɧɢɹ. ɋɟɪɶɟɡ-
ɧɚɹ ɩɪɨɛɥɟɦɚ ɬɚɤɨɝɨ ɨɝɪɚɧɢɱɟɧɢɹ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɡɚɱɚɫɬɭɸ ɜ ɧɚɱɚɥɟ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɧɟ
ɢɦɟɟɬɫɹ ɞɨɫɬɚɬɨɱɧɨɣ ɢɧɮɨɪɦɚɰɢɢ ɞɥɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɩɟɪɟɦɟɧɧɵɯ. ȼ ɪɟɡɭɥɶɬɚɬɟ ɭ ɜɚɫ ɨɫɬɚɟɬ-
ɫɹ ɞɜɚ ɜɵɯɨɞɚ — ɥɢɛɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɩɟɪɟɦɟɧɧɵɟ ɧɟɤɨɬɨɪɵɦ ɡɧɚɱɟɧɢɟɦ ɩɨ ɭɦɨɥɱɚɧɢɸ
(ɧɚɩɪɢɦɟɪ, ɧɭɥɟɦ), ɱɬɨ ɨɛɵɱɧɨ ɪɚɫɬɨɱɢɬɟɥɶɧɨ ɢ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɨɲɢɛɤɚɦ (ɟɫɥɢ ɩɟɪɟɦɟɧɧɚɹ
ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɧɚ ɞɨ ɬɨɝɨ, ɤɚɤ ɩɪɢɨɛɪɟɬɟɬ ɧɟɤɨɬɨɪɨɟ ɨɫɦɵɫɥɟɧɧɨɟ ɡɧɚɱɟɧɢɟ), ɥɢɛɨ ɨɫɬɚɜɢɬɶ
ɢɯ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɦɢ, ɱɬɨ ɨɩɚɫɧɨ. ɇɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɚɹ ɩɟɪɟɦɟɧɧɚɹ ɩɨɥɶɡɨɜɚɬɟɥɶ-
ɫɤɨɝɨ ɬɢɩɚ ɛɭɞɟɬ ɫɚɦɨɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶɫɹ ɧɟɤɨɬɨɪɵɦ ɩɭɫɬɵɦ ɡɧɚɱɟɧɢɟɦ.
Ʌɟɱɟɧɢɟ ɷɬɨɣ ɛɨɥɟɡɧɢ ɨɱɟɧɶ ɩɪɨɫɬɨɟ — ɨɩɪɟɞɟɥɹɣɬɟ ɤɚɠɞɭɸ ɩɟɪɟɦɟɧɧɭɸ ɧɚɫɬɨɥɶɤɨ ɥɨ-
ɤɚɥɶɧɨ, ɧɚɫɤɨɥɶɤɨ ɦɨɠɟɬɟ, ɱɬɨ ɨɛɵɱɧɨ ɨɡɧɚɱɚɟɬ ɬɨɱɤɭ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɟ ɩɟɪɟɞ ɟɟ ɩɟɪɜɵɦ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɟɦ, ɤɨɝɞɚ ɭ ɜɚɫ ɭɠɟ ɞɨɫɬɚɬɨɱɧɨ ɞɚɧɧɵɯ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɢɧɢɰɢɚɥɢɡɚɰɢɢ.
ɂɧɨɝɞɚ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜɵɝɨɞɧɵɦ ɜɵɧɟɫɟɧɢɟ ɩɟɪɟ-
ɦɟɧɧɨɣ ɡɚ ɩɪɟɞɟɥɵ ɰɢɤɥɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).
ɉɨɫɤɨɥɶɤɭ ɤɨɧɫɬɚɧɬɵ ɧɟ ɹɜɥɹɸɬɫɹ ɱɚɫɬɶɸ ɫɨɫɬɨɹɧɢɹ ɩɪɨɝɪɚɦɦɵ, ɞɚɧɧɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɧɚ
ɧɢɯ ɧɟ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 17).
Ссылки
[Dewhurst03] §3, §48, §66 • [Dewhurst03] §95 [McConnell93] §5.1-4, §10.1 • [Stroustrup00]
§4.9.4, §6.3
18. Объявляйте переменные как можно локальнее 47
Стр. 47
19. Всегда инициализируйте переменные
Резюме
ɇɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɩɟɪɟɦɟɧɧɵɟ — ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɣ ɢɫɬɨɱɧɢɤ ɨɲɢɛɨɤ ɜ ɩɪɨɝɪɚɦ-
ɦɚɯ ɧɚ C ɢ C++. ɂɡɛɟɝɚɣɬɟ ɢɯ, ɜɵɪɚɛɨɬɚɜ ɩɪɢɜɵɱɤɭ ɨɱɢɳɚɬɶ ɩɚɦɹɬɶ ɩɟɪɟɞ ɟɟ ɢɫɩɨɥɶɡɨɜɚɧɢ-
ɟɦ; ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ ɩɪɢ ɢɯ ɨɩɪɟɞɟɥɟɧɢɢ.
ȼ ɬɪɚɞɢɰɢɹɯ ɧɢɡɤɨɭɪɨɜɧɟɜɨɣ ɷɮɮɟɤɬɢɜɧɨɫɬɢ C++ (ɤɚɤ ɢ C), ɨɬ ɤɨɦɩɢɥɹɬɨɪɚ ɡɚɱɚɫɬɭɸ ɧɟ
ɬɪɟɛɭɟɬɫɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɩɟɪɟɦɟɧɧɵɯ, ɩɨɤɚ ɜɵ ɧɟ ɫɞɟɥɚɟɬɟ ɷɬɨ ɹɜɧɨ (ɧɚɩɪɢɦɟɪ, ɥɨɤɚɥɶɧɵɟ
ɩɟɪɟɦɟɧɧɵɟ, ɱɥɟɧɵ, ɨɩɭɳɟɧɧɵɟ ɜ ɫɩɢɫɤɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɤɨɧɫɬɪɭɤɬɨɪɚ). Ɍɚɤɢɟ ɩɟɪɟɦɟɧɧɵɟ
ɧɚɞɨ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɹɜɧɨ.
ɂɦɟɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɩɪɢɱɢɧ, ɩɨ ɤɨɬɨɪɵɦ ɩɟɪɟɦɟɧɧɚɹ ɦɨɠɟɬ ɨɫɬɚɬɶɫɹ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧ-
ɧɨɣ. ɇɨ ɧɢ ɨɞɧɚ ɢɡ ɧɢɯ ɧɟ ɹɜɥɹɟɬɫɹ ɞɨɫɬɚɬɨɱɧɨ ɫɟɪɶɟɡɧɨɣ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɨɩɪɚɜɞɚɬɶ ɨɩɚɫ-
ɧɨɫɬɶ ɧɟɨɩɪɟɞɟɥɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ.
ȿɫɥɢ ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɩɪɨɰɟɞɭɪɧɵɣ ɹɡɵɤ (ɬɚɤɨɣ ɤɚɤ Pascal, C, Fortran ɢɥɢ Cobol), ɜɵ ɦɨɠɟ-
ɬɟ ɨɩɪɟɞɟɥɢɬɶ ɩɟɪɟɦɟɧɧɵɟ ɨɬɞɟɥɶɧɨ ɨɬ ɤɨɞɚ, ɢɯ ɢɫɩɨɥɶɡɭɸɳɟɝɨ, ɢ ɩɪɢɫɜɨɢɬɶ ɢɦ ɡɧɚɱɟɧɢɹ
ɩɨɡɠɟ, ɤɨɝɞɚ ɷɬɢ ɩɟɪɟɦɟɧɧɵɟ ɛɭɞɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ. ɗɬɨɬ ɩɨɞɯɨɞ ɭɫɬɚɪɟɥ ɢ ɧɟ ɪɟɤɨɦɟɧɞɭɟɬɫɹ
ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 18).
Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɨɟ ɡɚɛɥɭɠɞɟɧɢɟ ɩɨ ɩɨɜɨɞɭ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɯ ɩɟɪɟɦɟɧɧɵɯ ɡɚɤɥɸɱɚ-
ɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɨɧɢ ɩɪɢɜɨɞɹɬ ɤ ɤɪɚɯɭ ɩɪɨɝɪɚɦɦɵ, ɬɚɤ ɱɬɨ ɧɟɫɤɨɥɶɤɨ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɯ
ɩɟɪɟɦɟɧɧɵɯ ɛɵɫɬɪɨ ɨɛɧɚɪɭɠɢɜɚɸɬɫɹ ɩɪɨɫɬɵɦ ɬɟɫɬɢɪɨɜɚɧɢɟɦ. ɇɚ ɫɚɦɨɦ ɞɟɥɟ ɩɪɨɝɪɚɦɦɵ ɫ
ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɦɢ ɩɟɪɟɦɟɧɧɵɦɢ ɦɨɝɭɬ ɛɟɡɭɤɨɪɢɡɧɟɧɧɨ ɪɚɛɨɬɚɬɶ ɝɨɞɚɦɢ, ɟɫɥɢ ɛɢɬɵ ɜ
ɩɚɦɹɬɢ ɫɨɨɬɜɟɬɫɬɜɭɸɬ ɬɪɟɛɨɜɚɧɢɹɦ ɩɪɨɝɪɚɦɦɵ. ɉɨɡɠɟ ɜɵɡɨɜ ɫ ɞɪɭɝɢɦ ɤɨɧɬɟɤɫɬɨɦ, ɩɟɪɟɤɨɦ-
ɩɢɥɹɰɢɹ ɢɥɢ ɤɚɤɢɟ-ɬɨ ɢɡɦɟɧɟɧɢɹ ɜ ɞɪɭɝɨɣ ɱɚɫɬɢ ɩɪɨɝɪɚɦɦɵ ɦɨɝɭɬ ɩɪɢɜɟɫɬɢ ɤ ɩɨɫɥɟɞɫɬɜɢɹɦ
ɪɚɡɧɨɣ ɫɬɟɩɟɧɢ ɬɹɠɟɫɬɢ — ɨɬ ɧɟɨɛɴɹɫɧɢɦɨɝɨ ɩɨɜɟɞɟɧɢɹ ɞɨ ɩɟɪɢɨɞɢɱɟɫɤɨɝɨ ɚɜɚɪɢɣɧɨɝɨ ɡɚ-
ɜɟɪɲɟɧɢɹ ɩɪɨɝɪɚɦɦɵ.
Примеры
ɉɪɢɦɟɪ 1. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɢɧɢɰɢɚɥɢɡɢɪɭɸɳɟɝɨ ɡɧɚɱɟɧɢɹ ɩɨ ɭɦɨɥɱɚɧɢɸ ɢɥɢ ɨɩɟɪɚɬɨɪɚ ?:
ɞɥɹ ɫɧɢɠɟɧɢɹ ɫɬɟɩɟɧɢ ɫɦɟɲɢɜɚɧɢɹ ɩɨɬɨɤɚ ɞɚɧɧɵɯ ɢ ɩɨɬɨɤɚ ɭɩɪɚɜɥɟɧɢɹ.
// ǘǰ ǻǰǵǹǷǰǸǯǾǰǽǼȊ: Ǹǰ ǳǸǳȁǳǫǶǳǲǳǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ
int speedupFactor ;
if( condition )
speedupFactor = 2;
else
speedupFactor = -1;
// ǖǾȂȃǰ: ǳǸǳȁǳǫǶǳǲǳǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ

int speedupFactor = -1;
if( condition )
speedupFactor = 2;
int speedupFactor = condition ? 2 : -1;
ȼɚɪɢɚɧɬɵ, ɨɬɦɟɱɟɧɧɵɟ ɤɚɤ ɥɭɱɲɢɟ, ɧɟ ɢɦɟɸɬ ɩɪɨɦɟɠɭɬɤɚ ɦɟɠɞɭ ɨɩɪɟɞɟɥɟɧɢɟɦ ɢ ɢɧɢɰɢɚ-
ɥɢɡɚɰɢɟɣ.
Стр. 48
ɉɪɢɦɟɪ 2. Ɂɚɦɟɧɚ ɫɥɨɠɧɵɯ ɜɵɱɢɫɥɟɧɢɣ ɜɵɡɨɜɨɦ ɮɭɧɤɰɢɢ. ɂɧɨɝɞɚ ɜɵɱɢɫɥɟɧɢɟ ɡɧɚɱɟɧɢɹ
ɩɪɨɢɫɯɨɞɢɬ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨ ɥɭɱɲɟ ɢɧɤɚɩɫɭɥɢɪɨɜɚɬɶ ɟɝɨ ɜ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11).
// ǘǰ ǻǰǵǹǷǰǸǯǾǰǽǼȊ: Ǹǰ ǳǸǳȁǳǫǶǳǲǳǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ
int speedupFactor ;
if( condition ) {
// ... ǵǹǯ ...
speedupFactor = someValue;
} else {
// ... ǵǹǯ ...
speedupFactor = someOtherValue;
}
int speedupFactor = ComputeSpeedupFactor ();
ɉɪɢɦɟɪ 3. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɦɚɫɫɢɜɨɜ. Ⱦɥɹ ɛɨɥɶɲɢɯ ɫɨɫɬɚɜɧɵɯ ɬɢɩɨɜ, ɬɚɤɢɯ ɤɚɤ ɦɚɫɫɢɜɵ,
ɤɨɪɪɟɤɬɧɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɧɟ ɜɫɟɝɞɚ ɨɡɧɚɱɚɟɬ ɪɟɚɥɶɧɨɟ ɨɛɪɚɳɟɧɢɟ ɤ ɞɚɧɧɵɦ. ɉɭɫɬɶ, ɧɚɩɪɢ-
ɦɟɪ, ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ API, ɤɨɬɨɪɵɣ ɡɚɫɬɚɜɥɹɟɬ ɜɚɫ ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɢɤɫɢɪɨɜɚɧɧɵɟ ɦɚɫɫɢɜɵ char
ɪɚɡɦɟɪɚ MAX_PATH (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 77 ɢ 78). ȿɫɥɢ ɜɵ ɭɜɟɪɟɧɵ, ɱɬɨ ɦɚɫɫɢɜɵ ɜɫɟɝɞɚ ɛɭɞɭɬ
ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ ɫɬɪɨɤɢ ɜ ɫɬɢɥɟ C ɫ ɡɚɜɟɪɲɚɸɳɢɦ ɧɭɥɟɜɵɦ ɫɢɦɜɨɥɨɦ, ɬɨ ɬɚɤɨɝɨ ɧɟɦɟɞ-
ɥɟɧɧɨɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɛɭɞɟɬ ɞɨɫɬɚɬɨɱɧɨ:
// ǏǹǺǾǼǽǳǷǹ: ǜǹǲǯǫǸǳǰ ǺǾǼǽǹǴ Ǽǽǻǹǵǳ
char path[MAX_PATH]; path[0] = '\0';
Ȼɨɥɟɟ ɛɟɡɨɩɚɫɧɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɡɚɩɨɥɧɹɟɬ ɜɫɟ ɷɥɟɦɟɧɬɵ ɦɚɫɫɢɜɚ ɧɭɥɟɜɵɦɢ ɡɧɚɱɟɧɢɹɦɢ:
// ǖǾȂȃǰ: ǲǫǺǹǶǸȊǰǷ ǸǾǶȊǷǳ ǭǰǼȇ ǷǫǼǼǳǭ
char path[MAX_PATH] = { '\0' };
Ɋɟɤɨɦɟɧɞɨɜɚɧɵ ɨɛɚ ɜɚɪɢɚɧɬɚ, ɧɨ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ ɜɵ ɞɨɥɠɧɵ ɩɪɟɞɩɨɱɢɬɚɬɶ ɛɟɡɨɩɚɫɧɨɫɬɶ ɢɡ-
ɥɢɲɧɟɣ ɷɮɮɟɤɬɢɜɧɨɫɬɢ.
ȼɯɨɞɧɵɟ ɛɭɮɟɪɵ ɢ ɞɚɧɧɵɟ, ɨɩɢɫɚɧɧɵɟ ɤɚɤ volatile, ɤɨɬɨɪɵɟ ɡɚɩɢɫɵɜɚɸɬɫɹ ɧɟɩɨɫɪɟɞ-
ɫɬɜɟɧɧɨ ɚɩɩɚɪɚɬɧɵɦ ɨɛɟɫɩɟɱɟɧɢɟɦ ɢɥɢ ɞɪɭɝɢɦɢ ɩɪɨɰɟɫɫɚɦɢ, ɧɟ ɬɪɟɛɭɸɬ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɩɪɨ-
ɝɪɚɦɦɨɣ.
Ссылки
[Dewhurst03] §48 • [Stroustrup00] §4.9.5, §6.3
19. Всегда инициализируйте переменные 49
Стр. 49
20. Избегайте длинных функций и глубокой
вложенности
Резюме
Ʉɪɚɬɤɨɫɬɶ — ɫɟɫɬɪɚ ɬɚɥɚɧɬɚ. ɑɟɪɟɫɱɭɪ ɞɥɢɧɧɵɟ ɮɭɧɤɰɢɢ ɢ ɱɪɟɡɦɟɪɧɨ ɜɥɨɠɟɧɧɵɟ ɛɥɨɤɢ ɤɨ-
ɞɚ ɡɚɱɚɫɬɭɸ ɩɪɟɩɹɬɫɬɜɭɸɬ ɪɟɚɥɢɡɚɰɢɢ ɩɪɢɧɰɢɩɚ “ɨɞɧɚ ɮɭɧɤɰɢɹ — ɨɞɧɚ ɡɚɞɚɱɚ” (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 5), ɢ ɨɛɵɱɧɨ ɷɬɚ ɩɪɨɛɥɟɦɚ ɪɟɲɚɟɬɫɹ ɥɭɱɲɢɦ ɪɚɡɞɟɥɟɧɢɟɦ ɡɚɞɚɱɢ ɧɚ ɨɬɞɟɥɶɧɵɟ ɱɚɫɬɢ.
Ʉɚɠɞɚɹ ɮɭɧɤɰɢɹ ɞɨɥɠɧɚ ɩɪɟɞɫɬɚɜɥɹɬɶ ɫɨɛɨɣ ɫɜɹɡɧɭɸ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ, ɧɟɫɭɳɭɸ ɡɧɚɱɢɦɨɟ
ɢɦɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5 ɢ ɨɛɫɭɠɞɟɧɢɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 70). Ʉɨɝɞɚ ɮɭɧɤɰɢɹ ɜɦɟɫɬɨ ɷɬɨɝɨ ɩɵɬɚ-
ɟɬɫɹ ɨɛɴɟɞɢɧɢɬɶ ɦɚɥɵɟ ɤɨɧɰɟɩɬɭɚɥɶɧɵɟ ɷɥɟɦɟɧɬɵ ɬɚɤɨɝɨ ɪɨɞɚ ɜ ɨɞɧɨɦ ɛɨɥɶɲɨɦ ɬɟɥɟ ɮɭɧɤ-
ɰɢɢ, ɷɬɨ ɩɪɢɜɨɞɢɬ ɤ ɬɨɦɭ, ɱɬɨ ɨɧɚ ɧɚɱɢɧɚɟɬ ɞɟɥɚɬɶ ɫɥɢɲɤɨɦ ɦɧɨɝɨɟ.
ɑɪɟɡɦɟɪɧɨ ɛɨɥɶɲɚɹ ɩɨ ɪɚɡɦɟɪɭ ɮɭɧɤɰɢɹ ɢ ɱɪɟɡɦɟɪɧɚɹ ɜɥɨɠɟɧɧɨɫɬɶ ɛɥɨɤɨɜ (ɧɚɩɪɢɦɟɪ,
ɛɥɨɤɨɜ if, for, while ɢ try) ɞɟɥɚɸɬ ɮɭɧɤɰɢɢ ɛɨɥɟɟ ɬɪɭɞɧɵɦɢ ɞɥɹ ɩɨɧɢɦɚɧɢɹ ɢ ɫɨɩɪɨɜɨɠ-
ɞɟɧɢɹ, ɩɪɢɱɟɦ ɡɚɱɚɫɬɭɸ ɛɟɡ ɤɚɤɢɯ ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɨɫɧɨɜɚɧɢɣ.
Ʉɚɠɞɵɣ ɞɨɩɨɥɧɢɬɟɥɶɧɵɣ ɭɪɨɜɟɧɶ ɜɥɨɠɟɧɧɨɫɬɢ ɩɪɢɜɨɞɢɬ ɤ ɢɡɥɢɲɧɢɦ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦ
ɧɚɝɪɭɡɤɚɦ ɩɪɢ ɱɬɟɧɢɢ ɤɨɞɚ, ɩɨɫɤɨɥɶɤɭ ɩɪɢ ɷɬɨɦ ɬɪɟɛɭɟɬɫɹ ɯɪɚɧɢɬɶ ɜ ɩɚɦɹɬɢ “ɫɬɟɤ” ɧɚɩɨɞɨɛɢɟ
“ɜɨɲɥɢ ɜ ɰɢɤɥ… ɜɨɲɥɢ ɜ ɛɥɨɤ try… ɜɨɲɥɢ ɜ ɭɫɥɨɜɧɵɣ ɨɩɟɪɚɬɨɪ… ɟɳɟ ɜ ɨɞɢɧ ɰɢɤɥ…”. ȼɚɦ
ɧɢɤɨɝɞɚ ɧɟ ɩɪɢɯɨɞɢɥɨɫɶ ɩɪɨɞɢɪɚɬɶɫɹ ɫɤɜɨɡɶ ɫɥɨɠɧɵɣ ɤɨɞ ɢ ɢɫɤɚɬɶ, ɤɚɤɨɣ ɠɟ ɢɦɟɧɧɨ ɢɡ ɦɧɨ-
ɠɟɫɬɜɚ ɤɨɧɫɬɪɭɤɰɢɣ for, while ɢ ɬ.ɩ. ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɜɨɬ ɷɬɚ ɡɚɤɪɵɜɚɸɳɚɹ ɮɢɝɭɪɧɚɹ ɫɤɨɛɤɚ?
Ȼɨɥɟɟ ɯɨɪɨɲɟɟ ɢ ɩɪɨɞɭɦɚɧɧɨɟ ɪɚɡɥɨɠɟɧɢɟ ɡɚɞɚɱɢ ɧɚ ɮɭɧɤɰɢɢ ɩɨɡɜɨɥɢɬ ɱɢɬɚɬɟɥɸ ɜɚɲɟɣ ɩɪɨ-
ɝɪɚɦɦɵ ɨɞɧɨɜɪɟɦɟɧɧɨ ɭɞɟɪɠɢɜɚɬɶ ɜ ɝɨɥɨɜɟ ɫɭɳɟɫɬɜɟɧɧɨ ɛɨɥɶɲɢɣ ɤɨɧɬɟɤɫɬ.
ȼɨɫɩɨɥɶɡɭɣɬɟɫɶ ɡɞɪɚɜɵɦ ɫɦɵɫɥɨɦ. Ɉɝɪɚɧɢɱɢɜɚɣɬɟ ɞɥɢɧɭ ɢ ɝɥɭɛɢɧɭ ɜɚɲɢɯ ɮɭɧɤɰɢɣ. Ⱦɚ-
ɥɟɟ ɩɪɢɜɟɞɟɧɵ ɧɟɤɨɬɨɪɵɟ ɞɨɛɪɵɟ ɫɨɜɟɬɵ, ɤɨɬɨɪɵɟ ɩɨɦɨɝɭɬ ɜɚɦ ɜ ɷɬɨɦ.
• ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɫɜɹɡɧɨɫɬɶ. ɉɭɫɬɶ ɨɞɧɚ ɮɭɧɤɰɢɹ ɪɟɲɚɟɬ ɬɨɥɶɤɨ ɨɞɧɭ ɡɚɞɚɱɭ (ɫɦ. ɪɟɤɨ-
• ɇɟ ɩɨɜɬɨɪɹɣɬɟɫɶ. ɋɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɢɦɟɧɨɜɚɧɧɭɸ ɮɭɧɤɰɢɸ ɩɨɜɬɨɪɭ ɫɯɨɠɢɯ
ɮɪɚɝɦɟɧɬɨɜ ɤɨɞɚ.
• ɉɨɥɶɡɭɣɬɟɫɶ ɨɩɟɪɚɬɨɪɨɦ &&. ɂɡɛɟɝɚɣɬɟ ɜɥɨɠɟɧɧɵɯ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɤɨɧɫɬɪɭɤɰɢɣ
if ɬɚɦ, ɝɞɟ ɢɯ ɦɨɠɧɨ ɡɚɦɟɧɢɬɶ ɨɩɟɪɚɬɨɪɨɦ &&.
• ɇɟ ɧɚɝɪɭɠɚɣɬɟ try. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɫɜɨɛɨɠɞɟɧɢɟ ɪɟɫɭɪɫɨɜ ɜ ɞɟɫɬɪɭɤ-
ɬɨɪɚɯ, ɚ ɧɟ ɜ try-ɛɥɨɤɚɯ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13).
• ɉɨɥɶɡɭɣɬɟɫɶ ɚɥɝɨɪɢɬɦɚɦɢ. Ɉɧɢ ɤɨɪɨɱɟ, ɱɟɦ ɪɭɤɨɩɢɫɧɵɟ ɰɢɤɥɵ, ɢ ɡɚɱɚɫɬɭɸ ɥɭɱɲɟ ɢ
ɷɮɮɟɤɬɢɜɧɟɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 84).
• ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ switch ɞɥɹ ɞɟɫɤɪɢɩɬɨɪɨɜ ɬɢɩɨɜ. ɉɪɢɦɟɧɹɣɬɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɩɨɥɢ-
ɦɨɪɮɧɵɟ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 90).
Стр. 50
Ɏɭɧɤɰɢɹ ɦɨɠɟɬ ɧɚ ɡɚɤɨɧɧɵɯ ɨɫɧɨɜɚɧɢɹɯ ɛɵɬɶ ɞɥɢɧɧɨɣ ɢ/ɢɥɢ ɝɥɭɛɨɤɨɣ, ɟɫɥɢ ɟɟ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɨɫɬɶ ɧɟɥɶɡɹ ɪɚɡɭɦɧɨ ɪɚɡɞɟɥɢɬɶ ɧɚ ɨɬɞɟɥɶɧɵɟ ɩɨɞɡɚɞɚɱɢ, ɩɨɫɤɨɥɶɤɭ ɤɚɠɞɨɟ ɬɚɤɨɟ ɩɨɬɟɧ-
ɰɢɚɥɶɧɨɟ ɪɚɡɞɟɥɟɧɢɟ ɬɪɟɛɭɟɬ ɩɟɪɟɞɚɱɢ ɦɚɫɫɵ ɥɨɤɚɥɶɧɵɯ ɩɟɪɟɦɟɧɧɵɯ ɢ ɤɨɧɬɟɤɫɬɚ (ɱɬɨ ɩɪɢɜɨ-
ɞɢɬ ɤ ɟɳɟ ɦɟɧɟɟ ɭɞɨɛɨɱɢɬɚɟɦɨɦɭ ɪɟɡɭɥɶɬɚɬɭ). ɇɨ ɟɫɥɢ ɧɟɫɤɨɥɶɤɨ ɬɚɤɢɯ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɮɭɧɤ-
ɰɢɣ ɩɨɥɭɱɚɸɬ ɚɧɚɥɨɝɢɱɧɵɟ ɚɪɝɭɦɟɧɬɵ, ɨɧɢ ɦɨɝɭɬ ɛɵɬɶ ɤɚɧɞɢɞɚɬɚɦɢ ɜ ɱɥɟɧɵ ɧɨɜɨɝɨ ɤɥɚɫɫɚ.
Ссылки
[Piwowarski82] • [Miller56]
20. Избегайте длинных функций и глубокой вложенности 51
Стр. 51
21. Избегайте зависимостей инициализаций
между единицами компиляции
Резюме
Ɉɛɴɟɤɬɵ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɜ ɪɚɡɧɵɯ ɟɞɢɧɢɰɚɯ ɤɨɦɩɢɥɹɰɢɢ ɧɟ ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ
ɞɪɭɝ ɨɬ ɞɪɭɝɚ ɩɪɢ ɢɧɢɰɢɚɥɢɡɚɰɢɢ, ɩɨɫɤɨɥɶɤɭ ɩɨɪɹɞɨɤ ɢɯ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ. ȼ ɩɪɨ-
ɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɚɦ ɨɛɟɫɩɟɱɟɧɚ ɝɨɥɨɜɧɚɹ ɛɨɥɶ ɩɪɢ ɩɨɩɵɬɤɚɯ ɪɚɡɨɛɪɚɬɶɫɹ ɫɨ ɫɛɨɹɦɢ ɜ ɪɚɛɨɬɟ
ɩɪɨɝɪɚɦɦɵ ɩɨɫɥɟ ɜɧɟɫɟɧɢɹ ɧɟɛɨɥɶɲɢɯ ɢɡɦɟɧɟɧɢɣ ɜ ɜɚɲ ɩɪɨɟɤɬ ɢ ɧɟɜɨɡɦɨɠɧɨɫɬɶɸ ɟɝɨ ɩɟɪɟ-
ɧɨɫɚ ɞɚɠɟ ɧɚ ɧɨɜɭɸ ɜɟɪɫɢɸ ɬɨɝɨ ɠɟ ɫɚɦɨɝɨ ɤɨɦɩɢɥɹɬɨɪɚ.
Ʉɨɝɞɚ ɜɵ ɨɩɪɟɞɟɥɹɟɬɟ ɞɜɚ ɨɛɴɟɤɬɚ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɜ ɪɚɡɧɵɯ ɟɞɢɧɢɰɚɯ ɤɨɦɩɢ-
ɥɹɰɢɢ, ɤɨɧɫɬɪɭɤɬɨɪ ɤɚɤɨɝɨ ɢɡ ɨɛɴɟɤɬɨɜ ɛɭɞɟɬ ɜɵɡɜɚɧ ɩɟɪɜɵɦ, ɧɟ ɨɩɪɟɞɟɥɟɧɨ. ɑɚɳɟ ɜɫɟɝɨ (ɧɨ
ɧɟ ɜɫɟɝɞɚ) ɜɚɲ ɢɧɫɬɪɭɦɟɧɬɚɪɢɣ ɛɭɞɟɬ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɢɯ ɜ ɬɨɦ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɤɨɦɩɨ-
ɧɭɸɬɫɹ ɫɤɨɦɩɢɥɢɪɨɜɚɧɧɵɟ ɨɛɴɟɤɬɧɵɟ ɮɚɣɥɵ, ɧɨ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɷɬɨ ɩɪɟɞɩɨɥɨɠɟɧɢɟ ɧɟɥɶɡɹ,
ɞɚɠɟ ɟɫɥɢ ɨɧɨ ɢ ɜɵɩɨɥɧɹɟɬɫɹ, — ɜɵ ɠɟ ɧɟ ɯɨɬɢɬɟ, ɱɬɨɛɵ ɤɨɪɪɟɤɬɧɨɫɬɶ ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ ɡɚ-
ɜɢɫɟɥɚ ɨɬ ɜɚɲɟɝɨ ɮɚɣɥɚ ɩɪɨɟɤɬɚ ɢɥɢ makefile (ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨ ɧɟɩɪɢɹɬɧɨ-
ɫɬɹɯ, ɫɜɹɡɚɧɧɵɯ ɫ ɡɚɜɢɫɢɦɨɫɬɶɸ ɨɬ ɩɨɪɹɞɤɚ, ɦɨɠɧɨ ɩɨɱɟɪɩɧɭɬɶ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 59).
Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɜ ɤɨɞɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɥɸɛɨɝɨ ɨɛɴɟɤɬɚ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɜɵ ɧɟ
ɦɨɠɟɬɟ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɬɨ, ɱɬɨ ɭɠɟ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧ ɧɟɤɨɬɨɪɵɣ ɨɛɴɟɤɬ, ɨɩɪɟɞɟɥɟɧɧɵɣ ɜ ɞɪɭ-
ɝɨɣ ɟɞɢɧɢɰɟ ɤɨɦɩɢɥɹɰɢɢ. ɗɬɨ ɠɟ ɤɚɫɚɟɬɫɹ ɢ ɞɢɧɚɦɢɱɟɫɤɢ ɢɧɢɰɢɚɥɢɡɢɪɭɟɦɵɯ ɩɟɪɟɦɟɧɧɵɯ
ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ (ɩɪɢɦɟɪ ɬɚɤɨɝɨ ɤɨɞɚ ɧɚ ɭɪɨɜɧɟ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ: bool reg_success =
LibRegister("mylib");).
Ɂɚɦɟɬɢɦ, ɱɬɨ ɟɳɟ ɞɨ ɬɨɝɨ, ɤɚɤ ɛɭɞɟɬ ɜɵɡɜɚɧ ɤɨɧɫɬɪɭɤɬɨɪ, ɨɛɴɟɤɬ ɧɚ ɭɪɨɜɧɟ ɩɪɨɫɬɪɚɧɫɬɜɚ
ɢɦɟɧ ɫɬɚɬɢɱɟɫɤɢ ɢɧɢɰɢɚɥɢɡɢɪɭɟɬɫɹ ɧɭɥɹɦɢ (ɜ ɨɬɥɢɱɢɟ ɨɬ, ɫɤɚɠɟɦ, ɚɜɬɨɦɚɬɢɱɟɫɤɨɝɨ ɨɛɴɟɤɬɚ,
ɤɨɬɨɪɵɣ ɨɛɵɱɧɨ ɫɨɞɟɪɠɢɬ ɦɭɫɨɪ). ɉɚɪɚɞɨɤɫɚɥɶɧɨ, ɧɨ ɷɬɚ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɧɭɥɹɦɢ ɦɨɠɟɬ ɡɚ-
ɬɪɭɞɧɢɬɶ ɨɛɧɚɪɭɠɟɧɢɟ ɨɲɢɛɤɢ, ɩɨɫɤɨɥɶɤɭ ɜɦɟɫɬɨ ɚɜɚɪɢɣɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɬɚɤɨɣ
ɡɚɩɨɥɧɟɧɧɵɣ ɧɭɥɹɦɢ (ɧɨ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɣ) ɨɛɴɟɤɬ ɫɨɡɞɚɟɬ ɜɢɞɢɦɨɫɬɶ
ɤɨɪɪɟɤɬɧɨɫɬɢ. ȼɚɦ ɤɚɠɟɬɫɹ, ɱɬɨ ɫɬɪɨɤɚ ɩɭɫɬɚ, ɭɤɚɡɚɬɟɥɶ ɢɦɟɟɬ ɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɰɟɥɨɟ ɱɢɫɥɨ
ɪɚɜɧɨ ɧɭɥɸ, — ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɢɤɚɤɨɣ ɤɨɞ ɟɳɟ ɢ ɧɟ ɩɵɬɚɥɫɹ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ
ɜɚɲɢ ɨɛɴɟɤɬɵ.
ɑɬɨɛɵ ɪɟɲɢɬɶ ɷɬɭ ɩɪɨɛɥɟɦɭ, ɢɡɛɟɝɚɣɬɟ ɩɟɪɟɦɟɧɧɵɯ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɜɟɡɞɟ, ɝɞɟ
ɬɨɥɶɤɨ ɦɨɠɧɨ; ɬɚɤɢɟ ɩɟɪɟɦɟɧɧɵɟ — ɜɨɨɛɳɟ ɨɩɚɫɧɚɹ ɩɪɚɤɬɢɤɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 10). ȿɫɥɢ
ɜɚɦ ɧɭɠɧɚ ɬɚɤɚɹ ɩɟɪɟɦɟɧɧɚɹ, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɡɚɜɢɫɟɬɶ ɨɬ ɞɪɭɝɨɣ, ɩɨɞɭɦɚɣɬɟ ɨ ɩɪɢɦɟɧɟɧɢɢ
ɲɚɛɥɨɧɚ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Singleton; ɩɪɢ ɚɤɤɭɪɚɬɧɨɦ ɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɦɨɠɧɨ ɢɡɛɟɠɚɬɶ ɧɟ-
ɹɜɧɵɯ ɡɚɜɢɫɢɦɨɫɬɟɣ, ɨɛɟɫɩɟɱɢɜɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɨɛɴɟɤɬɚ ɩɪɢ ɟɝɨ ɩɟɪɜɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ.
Singleton ɨɫɬɚɟɬɫɹ ɝɥɨɛɚɥɶɧɨɣ ɩɟɪɟɦɟɧɧɨɣ ɜ ɲɤɭɪɟ ɨɜɰɵ (ɟɳɟ ɪɚɡ ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 10), ɢ ɧɟ
ɪɚɛɨɬɚɟɬ ɩɪɢ ɜɡɚɢɦɧɵɯ ɢɥɢ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɹɯ (ɢ ɡɞɟɫɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɧɭɥɹɦɢ ɬɚɤɠɟ
ɫɩɨɫɨɛɫɬɜɭɟɬ ɨɛɳɟɣ ɧɟɪɚɡɛɟɪɢɯɟ).
Ссылки
[Dewhurst03] §55 • [Gamma95] • [McConnell93] §5.1-4 • [Stroustrup00] §9.4.1, §10.4.9
Стр. 52
22. Минимизируйте зависимости определений...
22. Минимизируйте зависимости

определений и избегайте циклических
зависимостей
22. Минимизируйте зависимости определений...
Резюме
ɂɡɛɟɝɚɣɬɟ ɢɡɥɢɲɧɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ. ɇɟ ɜɤɥɸɱɚɣɬɟ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include ɨɩ-
ɪɟɞɟɥɟɧɢɹ ɬɚɦ, ɝɞɟ ɞɨɫɬɚɬɨɱɧɨ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɝɨ ɨɛɴɹɜɥɟɧɢɹ.
ɂɡɛɟɝɚɣɬɟ ɜɡɚɢɦɨɡɚɜɢɫɢɦɨɫɬɟɣ. ɐɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨɫɬɢ ɜɨɡɧɢɤɚɸɬ, ɤɨɝɞɚ ɞɜɚ ɦɨɞɭɥɹ
ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɢɥɢ ɨɩɨɫɪɟɞɨɜɚɧɧɨ ɡɚɜɢɫɹɬ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. Ɇɨɞɭɥɶ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɛɨ-
ɫɨɛɥɟɧɧɭɸ ɟɞɢɧɢɰɭ; ɜɡɚɢɦɨɡɚɜɢɫɢɦɵɟ ɦɨɞɭɥɢ ɧɟ ɹɜɥɹɸɬɫɹ ɩɨɥɧɨɫɬɶɸ ɨɬɞɟɥɶɧɵɦɢ ɦɨɞɭɥɹ-
ɦɢ, ɛɭɞɭɱɢ ɩɨ ɫɭɬɢ ɱɚɫɬɹɦɢ ɨɞɧɨɝɨ ɛɨɥɶɲɟɝɨ ɦɨɞɭɥɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɰɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨ-
ɫɬɢ ɹɜɥɹɸɬɫɹ ɩɪɨɬɢɜɧɢɤɚɦɢ ɦɨɞɭɥɶɧɨɫɬɢ ɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɭɝɪɨɡɭ ɛɨɥɶɲɢɦ ɩɪɨɟɤɬɚɦ. ɂɡɛɟ-
ɝɚɣɬɟ ɢɯ.
ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɟɞɜɚɪɢɬɟɥɶɧɵɟ ɨɛɴɹɜɥɟɧɢɹ ɜɟɡɞɟ, ɝɞɟ ɧɟ ɬɪɟɛɭɟɬɫɹ ɩɨɥɧɨɟ
ɨɩɪɟɞɟɥɟɧɢɟ ɬɢɩɚ. ɉɨɥɧɨɟ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ C ɬɪɟɛɭɟɬɫɹ ɜ ɞɜɭɯ ɨɫɧɨɜɧɵɯ ɫɥɭɱɚɹɯ.
• Ʉɨɝɞɚ ɜɚɦ ɧɟɨɛɯɨɞɢɦɨ ɡɧɚɬɶ ɪɚɡɦɟɪ ɨɛɴɟɤɬɚ C. ɇɚɩɪɢɦɟɪ, ɩɪɢ ɫɨɡɞɚɧɢɢ ɨɛɴɟɤɬɚ C
ɜ ɫɬɟɤɟ ɢɥɢ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɟɝɨ ɜ ɤɚɱɟɫɬɜɟ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɯɪɚɧɢɦɨɝɨ (ɧɟ ɱɟɪɟɡ
ɭɤɚɡɚɬɟɥɶ) ɱɥɟɧɚ ɞɪɭɝɨɝɨ ɤɥɚɫɫɚ.
• Ʉɨɝɞɚ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɢɦɹ ɢɥɢ ɜɵɡɨɜ ɱɥɟɧɚ C. ɇɚɩɪɢɦɟɪ, ɤɨɝɞɚ ɜɵ ɜɵɡɵɜɚɟɬɟ ɮɭɧɤɰɢɸ-
ɱɥɟɧ ɷɬɨɝɨ ɤɥɚɫɫɚ.
ɇɟ ɛɭɞɟɦ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɜ ɷɬɨɣ ɤɧɢɝɟ ɬɪɢɜɢɚɥɶɧɵɟ ɫɥɭɱɚɢ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ, ɤɨ-
ɬɨɪɵɟ ɩɪɢɜɨɞɹɬ ɤ ɨɲɢɛɤɚɦ ɤɨɦɩɢɥɹɰɢɢ — ɞɭɦɚɟɦ, ɜɵ ɭɫɩɟɲɧɨ ɫɩɪɚɜɢɬɟɫɶ ɫ ɧɢɦɢ, ɜɨɫɩɨɥɶ-
ɡɨɜɚɜɲɢɫɶ ɦɧɨɝɢɦɢ ɯɨɪɨɲɢɦɢ ɫɨɜɟɬɚɦɢ, ɢɦɟɸɳɢɦɢɫɹ ɜ ɥɢɬɟɪɚɬɭɪɟ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ 1. Ɇɵ
ɠɟ ɨɛɪɚɬɢɦɫɹ ɤ ɰɢɤɥɢɱɟɫɤɢɦ ɡɚɜɢɫɢɦɨɫɬɹɦ, ɤɨɬɨɪɵɟ ɨɫɬɚɸɬɫɹ ɜ ɤɨɦɩɢɥɢɪɭɟɦɨɦ ɤɨɞɟ, ɢ ɩɨ-
ɫɦɨɬɪɢɦ, ɤɚɤ ɨɧɢ ɜɥɢɹɸɬ ɧɚ ɟɝɨ ɤɚɱɟɫɬɜɨ ɢ ɤɚɤɢɟ ɞɟɣɫɬɜɢɹ ɫɥɟɞɭɟɬ ɩɪɟɞɩɪɢɧɹɬɶ, ɱɬɨɛɵ ɢɡɛɟ-
ɠɚɬɶ ɢɯ.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɡɚɜɢɫɢɦɨɫɬɢ ɢ ɢɯ ɰɢɤɥɵ ɫɥɟɞɭɟɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɧɚ ɭɪɨɜɧɟ ɦɨɞɭɥɟɣ. Ɇɨ-
ɞɭɥɶ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɛɪɚɡɭɸɳɢɣ ɟɞɢɧɨɟ ɰɟɥɨɟ ɧɚɛɨɪ ɫɨɜɦɟɫɬɧɨ ɨɩɭɛɥɢɤɨɜɚɧɧɵɯ ɤɥɚɫ-
ɫɨɜ ɢ ɮɭɧɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5). ɐɢɤɥɢɱɟɫɤɚɹ ɡɚɜɢɫɢɦɨɫɬɶ ɜ ɩɪɨɫɬɟɣɲɟɦ ɜɢɞɟ ɩɪɟɞɫɬɚɜ-
ɥɹɟɬ ɫɨɛɨɣ ɞɜɚ ɤɥɚɫɫɚ, ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɡɚɜɢɫɹɳɢɯ ɞɪɭɝ ɨɬ ɞɪɭɝɚ:
class Child; // ǞǼǽǻǫǸǰǸǳǰ ȁǳǵǶǳȂǰǼǵǹǴ ǲǫǭǳǼǳǷǹǼǽǳ
class Parent { // ...
Child* myChild_;
};
// ǍǹǲǷǹǱǸǹ, ǭ ǯǻǾǮǹǷ ǲǫǮǹǶǹǭǹȂǸǹǷ ǿǫǴǶǰ
class Child { // ...
Parent* myParent_;
};
Ʉɥɚɫɫɵ Parent ɢ Child ɡɚɜɢɫɹɬ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. ɉɪɢɜɟɞɟɧɧɵɣ ɤɨɞ ɤɨɦɩɢɥɢɪɭɟɬɫɹ, ɧɨ ɦɵ
ɫɬɚɥɤɢɜɚɟɦɫɹ ɫ ɮɭɧɞɚɦɟɧɬɚɥɶɧɨɣ ɩɪɨɛɥɟɦɨɣ: ɷɬɢ ɞɜɚ ɤɥɚɫɫɚ ɛɨɥɶɲɟ ɧɟ ɹɜɥɹɸɬɫɹ ɧɟɡɚɜɢɫɢ-
ɦɵɦɢ, ɢ ɛɨɥɟɟ ɬɨɝɨ, ɫɬɚɧɨɜɹɬɫɹ ɜɡɚɢɦɨɡɚɜɢɫɢɦɵ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. ɗɬɨ ɧɟ ɜɫɟɝɞɚ ɩɥɨɯɨ, ɧɨ ɞɨɥɠ-
ɧɨ ɢɦɟɬɶ ɦɟɫɬɨ ɥɢɲɶ ɜ ɬɨɦ ɫɥɭɱɚɟ, ɤɨɝɞɚ ɨɛɚ ɤɥɚɫɫɚ ɹɜɥɹɸɬɫɹ ɱɚɫɬɹɦɢ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɦɨ-
22. Минимизируйте зависимости определений... 53
Стр. 53
ɞɭɥɹ (ɪɚɡɪɚɛɨɬɚɧɧɨɝɨ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɱɟɥɨɜɟɤɨɦ ɢɥɢ ɤɨɦɚɧɞɨɣ, ɨɬɬɟɫɬɢɪɨɜɚɧɧɨɝɨ ɢ ɜɵɩɭ-
ɳɟɧɧɨɝɨ ɤɚɤ ɟɞɢɧɨɟ ɰɟɥɨɟ).
ȼ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɨɩɢɫɚɧɧɨɣ ɫɢɬɭɚɰɢɢ, ɪɚɫɫɦɨɬɪɢɦ, ɱɬɨ ɛɭɞɟɬ, ɟɫɥɢ ɤɥɚɫɫ Child ɧɟ
ɞɨɥɠɟɧ ɛɭɞɟɬ ɯɪɚɧɢɬɶ ɨɛɪɚɬɧɭɸ ɫɜɹɡɶ ɫ ɨɛɴɟɤɬɨɦ Parent? Ɍɨɝɞɚ Child ɦɨɠɟɬ ɛɵɬɶ ɜɵɩɭɳɟɧ
ɜ ɫɨɛɫɬɜɟɧɧɨɦ ɨɬɞɟɥɶɧɨɦ ɧɟɛɨɥɶɲɨɦ ɦɨɞɭɥɟ (ɢ, ɜɨɡɦɨɠɧɨ, ɩɨɞ ɞɪɭɝɢɦ ɢɦɟɧɟɦ), ɩɨɥɧɨɫɬɶɸ ɧɟ-
ɡɚɜɢɫɢɦɨ ɨɬ Parent — ɱɬɨ, ɤɨɧɟɱɧɨ, ɫɭɳɟɫɬɜɟɧɧɨ ɩɨɜɵɲɚɟɬ ɝɢɛɤɨɫɬɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
ȼɫɟ ɫɬɚɧɨɜɢɬɫɹ ɟɳɟ ɯɭɠɟ, ɤɨɝɞɚ ɡɚɜɢɫɢɦɨɫɬɢ ɨɯɜɚɬɵɜɚɸɬ ɧɟɫɤɨɥɶɤɨ ɦɨɞɭɥɟɣ. Ɍɚɤɨɣ ɦɨɳ-
ɧɵɣ “ɤɥɟɣ”, ɤɚɤ ɡɚɜɢɫɢɦɨɫɬɢ, ɨɛɴɟɞɢɧɹɸɬ ɷɬɢ ɦɨɞɭɥɹ ɜ ɟɞɢɧɭɸ ɦɨɧɨɥɢɬɧɭɸ ɩɭɛɥɢɤɭɟɦɭɸ
ɟɞɢɧɢɰɭ. ȼɨɬ ɩɨɱɟɦɭ ɰɢɤɥɵ ɹɜɥɹɸɬɫɹ ɫɚɦɵɦɢ ɫɬɪɚɲɧɵɦɢ ɜɪɚɝɚɦɢ ɦɨɞɭɥɶɧɨɫɬɢ.
ɑɬɨɛɵ ɪɚɡɨɪɜɚɬɶ ɰɢɤɥɵ, ɩɪɢɦɟɧɢɬɟ ɩɪɢɧɰɢɩ ɢɧɜɟɪɫɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ (Dependency Inver-
sion Principle), ɨɩɢɫɚɧɧɵɣ ɜ [Martin96a] ɢ [Martin00] (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 36): ɧɟ ɞɟɥɚɣɬɟ
ɦɨɞɭɥɢ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɡɚɜɢɫɹɳɢɦɢ ɨɬ ɦɨɞɭɥɟɣ ɧɢɡɤɨɝɨ ɭɪɨɜɧɹ; ɜɦɟɫɬɨ ɷɬɨɝɨ ɞɟɥɚɣɬɟ ɢɯ ɡɚ-
ɜɢɫɢɦɵɦɢ ɨɬ ɚɛɫɬɪɚɤɰɢɣ. ȿɫɥɢ ɜɵ ɦɨɠɟɬɟ ɨɩɪɟɞɟɥɢɬɶ ɧɟɡɚɜɢɫɢɦɵɟ ɚɛɫɬɪɚɤɬɧɵɟ ɤɥɚɫɫɵ ɞɥɹ
Parent ɢɥɢ Child, ɜɵ ɪɚɡɨɪɜɟɬɟ ɰɢɤɥ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵ ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ ɢɯ ɱɚɫɬɹɦɢ
ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɦɨɞɭɥɹ.
ɑɚɫɬɧɵɣ ɜɢɞ ɡɚɜɢɫɢɦɨɫɬɢ, ɨɬ ɤɨɬɨɪɨɣ ɫɬɪɚɞɚɸɬ ɧɟɤɨɬɨɪɵɟ ɩɪɨɟɤɬɵ, — ɷɬɨ ɬɪɚɧɡɢɬɢɜɧɚɹ
ɡɚɜɢɫɢɦɨɫɬɶ ɨɬ ɩɪɨɢɡɜɨɞɧɵɯ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɚɹ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ, ɤɨɝɞɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɡɚɜɢɫɢɬ
ɨɬ ɜɫɟɯ ɫɜɨɢɯ ɧɚɫɥɟɞɧɢɤɨɜ, ɩɪɹɦɵɯ ɢ ɧɟɩɪɹɦɵɯ. Ɋɹɞ ɪɟɚɥɢɡɚɰɢɣ ɲɚɛɥɨɧɚ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
Visitor ɩɪɢɜɨɞɹɬ ɤ ɬɚɤɨɦɭ ɜɢɞɭ ɡɚɜɢɫɢɦɨɫɬɢ, ɤɨɬɨɪɚɹ ɞɨɩɭɫɬɢɦɚ ɬɨɥɶɤɨ ɜ ɢɫɤɥɸɱɢɬɟɥɶɧɨ ɫɬɚ-
ɛɢɥɶɧɵɯ ɢɟɪɚɪɯɢɹɯ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɚɦ ɥɭɱɲɟ ɢɡɦɟɧɢɬɶ ɫɜɨɣ ɩɪɨɟɤɬ, ɧɚɩɪɢɦɟɪ, ɜɨɫ-
ɩɨɥɶɡɨɜɚɜɲɢɫɶ ɲɚɛɥɨɧɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Acyclic Visitor [Martin98].
Ɉɞɧɢɦ ɢɡ ɫɢɦɩɬɨɦɨɜ ɱɪɟɡɦɟɪɧɵɯ ɡɚɜɢɫɢɦɨɫɬɟɣ ɹɜɥɹɟɬɫɹ ɩɟɪɟɤɨɦɩɢɥɹɰɢɹ ɛɨɥɶɲɢɯ ɱɚɫɬɟɣ
ɩɪɨɟɤɬɚ ɩɪɢ ɜɧɟɫɟɧɢɢ ɧɟɛɨɥɶɲɢɯ ɥɨɤɚɥɶɧɵɯ ɢɡɦɟɧɟɧɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 2).
ɐɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨɫɬɢ ɦɟɠɞɭ ɤɥɚɫɫɚɦɢ — ɧɟ ɜɫɟɝɞɚ ɩɥɨɯɨ, ɩɨɤɚ ɤɥɚɫɫɵ ɪɚɫɫɦɚɬɪɢɜɚ-
ɸɬɫɹ ɤɚɤ ɱɚɫɬɶ ɨɞɧɨɝɨ ɦɨɞɭɥɹ ɢ ɫɨɜɦɟɫɬɧɨ ɬɟɫɬɢɪɭɸɬɫɹ ɢ ɜɵɩɭɫɤɚɸɬɫɹ. ɉɪɨɫɬɚɹ ɧɟɩɨɫɪɟɞɫɬ-
ɜɟɧɧɚɹ ɪɟɚɥɢɡɚɰɢɹ ɬɚɤɢɯ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɤɚɤ Command ɢ Visitor ɩɪɢɜɨɞɹɬ ɤ ɢɧ-
ɬɟɪɮɟɣɫɚɦ, ɤɨɬɨɪɵɟ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ ɨɤɚɡɵɜɚɸɬɫɹ ɜɡɚɢɦɨɡɚɜɢɫɢɦɵɦɢ. Ɍɚɤɢɟ ɡɚɜɢɫɢ-
ɦɨɫɬɢ ɦɨɠɧɨ ɪɚɡɪɭɲɢɬɶ, ɧɨ ɷɬɨ ɬɪɟɛɭɟɬ ɛɨɥɟɟ ɱɟɬɤɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
Ссылки
[Alexandrescu01] §3 • [Boost] • [Gamma95] • [Lakos96] §0.2.1, §4.6-14, §5 • [Martin96a] •
[Martin96b] • [Martin98] §7 • [Martin00] • [McConnell93] §5 • [Meyers97] §46 • [Stroustrup00]
§24.3.5 • [Sutter00] §26 • [Sutter02] §37 • [Sutter03]
Стр. 54
23. Делайте заголовочные файлы
самодостаточными
Резюме
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɤɚɠɞɵɣ ɧɚɩɢɫɚɧɧɵɣ ɜɚɦɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɤɨɦɩɢɥɢɪɭɟɦ ɫɚɦɨɫɬɨɹɬɟɥɶ-
ɧɨ, ɬ.ɟ. ɱɬɨ ɨɧ ɜɤɥɸɱɚɟɬ ɜɫɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɨɬ ɤɨɬɨɪɵɯ ɡɚɜɢɫɢɬ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ.
ȿɫɥɢ ɨɞɢɧ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɧɟ ɪɚɛɨɬɚɟɬ, ɩɨɤɚ ɧɟ ɜɤɥɸɱɟɧ ɞɪɭɝɨɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ,
ɩɪɨɟɤɬ ɩɨɥɭɱɚɟɬɫɹ ɨɱɟɧɶ ɧɟɭɤɥɸɠɢɦ, ɚ ɧɚ ɩɨɥɶɡɨɜɚɬɟɥɹ ɜɨɡɥɚɝɚɟɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɚɹ ɡɚɞɚɱɚ
ɫɥɟɞɢɬɶ ɡɚ ɬɟɦ, ɤɚɤɢɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɚɞɨ ɜɤɥɸɱɢɬɶ ɜ ɢɫɯɨɞɧɵɣ ɬɟɤɫɬ.
Ɋɚɧɶɲɟ ɧɟɤɨɬɨɪɵɟ ɷɤɫɩɟɪɬɵ ɫɨɜɟɬɨɜɚɥɢ, ɱɬɨɛɵ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɟ ɜɤɥɸɱɚɥɢ ɞɪɭɝɢɟ ɡɚɝɨ-
ɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɢɡ-ɡɚ ɧɚɤɥɚɞɧɵɯ ɪɚɫɯɨɞɨɜ ɧɚ ɦɧɨɝɨɤɪɚɬɧɨɟ ɨɬɤɪɵɬɢɟ ɢ ɚɧɚɥɢɡ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣ-
ɥɨɜ, ɡɚɳɢɳɟɧɧɵɯ ɞɢɪɟɤɬɢɜɚɦɢ ɩɪɟɩɪɨɰɟɫɫɨɪɨɜ ɨɬ ɩɨɜɬɨɪɧɨɣ ɨɛɪɚɛɨɬɤɢ. Ʉ ɫɱɚɫɬɶɸ, ɫɟɣɱɚɫ ɷɬɨɬ
ɫɨɜɟɬ ɭɫɬɚɪɟɥ. Ɇɧɨɝɢɟ ɫɨɜɪɟɦɟɧɧɵɟ ɤɨɦɩɢɥɹɬɨɪɵ C++ ɪɚɫɩɨɡɧɚɸɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ ɡɚɳɢɬɭ ɡɚ-
ɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ ɚɜɬɨɦɚɬɢɱɟɫɤɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 24) ɢ ɩɪɨɫɬɨ ɧɟ ɨɬɤɪɵɜɚɸɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ
ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɞɜɚɠɞɵ. ɇɟɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪɵ ɢɫɩɨɥɶɡɭɸɬ ɩɪɟɞɤɨɦɩɢɥɹɰɢɸ ɡɚɝɨɥɨɜɨɱɧɵɯ
ɮɚɣɥɨɜ, ɤɨɬɨɪɚɹ ɩɨɡɜɨɥɹɟɬ ɢɡɛɟɠɚɬɶ ɚɧɚɥɢɡɚ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ.
Ɉɞɧɚɤɨ ɧɟ ɜɤɥɸɱɚɣɬɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɜ ɤɨɬɨɪɵɯ ɜɵ ɧɟ ɧɭɠɞɚɟɬɟɫɶ, ɬɚɤ ɤɚɤ ɷɬɨ ɧɚ-
ɩɪɚɫɧɨ ɫɨɡɞɚɟɬ ɩɚɪɚɡɢɬɧɵɟ ɡɚɜɢɫɢɦɨɫɬɢ.
Ⱦɥɹ ɝɚɪɚɧɬɢɢ ɫɚɦɨɞɨɫɬɚɬɨɱɧɨɫɬɢ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ ɫɤɨɦɩɢɥɢɪɭɣɬɟ ɤɚɠɞɵɣ ɢɡ ɧɢɯ ɨɬ-
ɞɟɥɶɧɨ ɨɬ ɞɪɭɝɢɯ ɢ ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɷɬɨ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɨɲɢɛɤɚɦ ɢɥɢ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ.
Примеры
Ɋɹɞ ɬɨɧɤɢɯ ɦɨɦɟɧɬɨɜ ɜɨɡɧɢɤɚɟɬ ɜ ɫɜɹɡɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɲɚɛɥɨɧɨɜ.
ɉɪɢɦɟɪ 1. Ɂɚɜɢɫɢɦɵɟ ɢɦɟɧɚ. ɒɚɛɥɨɧɵ ɤɨɦɩɢɥɢɪɭɸɬɫɹ ɜ ɬɨɱɤɟ, ɝɞɟ ɨɧɢ ɨɩɪɟɞɟɥɟɧɵ, ɫ ɬɟɦ
ɢɫɤɥɸɱɟɧɢɟɦ, ɱɬɨ ɜɫɟ ɡɚɜɢɫɢɦɵɟ ɢɦɟɧɚ ɢɥɢ ɬɢɩɵ ɧɟ ɤɨɦɩɢɥɢɪɭɸɬɫɹ ɞɨ ɬɨɱɤɢ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ.
ɗɬɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ template<class T> class Widget ɫ ɱɥɟɧɨɦ std::deque<T> ɧɟ ɩɪɢɜɟ-
ɞɟɬ ɤ ɨɲɢɛɤɟ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ, ɞɚɠɟ ɟɫɥɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ <deque> ɧɟ ɜɤɥɸɱɟɧ — ɟɫɥɢ
ɩɪɢ ɷɬɨɦ ɧɟ ɩɪɨɢɫɯɨɞɢɬ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɟ Widget. ɉɨɫɤɨɥɶɤɭ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɲɚɛɥɨɧ Widget
ɫɭɳɟɫɬɜɭɟɬ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɛɵɬɶ ɢɧɫɬɚɧɰɢɪɨɜɚɧɧɵɦ, ɟɝɨ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɞɨɥɠɟɧ ɫɨɞɟɪɠɚɬɶ
ɫɬɪɨɤɭ #include <deque>.
ɉɪɢɦɟɪ 2. ɒɚɛɥɨɧɵ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɢ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ ɲɚɛɥɨɧɨɜ ɢɧɫɬɚɧɰɢɪɭɸɬɫɹ ɬɨɥɶɤɨ ɩɪɢ
ɢɫɩɨɥɶɡɨɜɚɧɢɢ. ɉɪɟɞɩɨɥɨɠɢɦ, ɱɬɨ Widget ɧɟ ɢɦɟɟɬ ɱɥɟɧɚ ɬɢɩɚ std::deque<T>, ɧɨ ɮɭɧɤɰɢɹ-
ɱɥɟɧ Widget ɫ ɢɦɟɧɟɦ Transmogrify ɢɫɩɨɥɶɡɭɟɬ deque. Ɍɨɝɞɚ ɜɵɡɵɜɚɸɳɚɹ Widget ɮɭɧɤɰɢɹ
ɦɨɠɟɬ ɢɧɫɬɚɧɰɢɪɨɜɚɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ Widget, ɞɚɠɟ ɟɫɥɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ <deque> ɧɟ ɜɤɥɸ-
ɱɟɧ — ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɮɭɧɤɰɢɹ-ɱɥɟɧ Transmogrify. ɉɨ ɭɦɨɥɱɚɧɢɸ ɡɚɝɨɥɨɜɨɱ-
ɧɵɣ ɮɚɣɥ Widget ɜɫɟ ɠɟ ɞɨɥɠɟɧ ɜɤɥɸɱɚɬɶ <deque>, ɩɨɫɤɨɥɶɤɭ ɷɬɨ ɧɟɨɛɯɨɞɢɦɨ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ,
ɞɥɹ ɧɟɤɨɬɨɪɵɯ ɩɨɥɶɡɨɜɚɬɟɥɟɣ Widget. ȼ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ, ɤɨɝɞɚ ɛɨɥɶɲɨɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ
ɜɤɥɸɱɚɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɨɛɟɫɩɟɱɟɧɢɹ ɪɚɛɨɬɨɫɩɨɫɨɛɧɨɫɬɢ ɧɟɫɤɨɥɶɤɢɯ ɪɟɞɤɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɮɭɧɤɰɢɣ
ɲɚɛɥɨɧɚ, ɫɥɟɞɭɟɬ ɩɨɞɭɦɚɬɶ ɨ ɬɨɦ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɷɬɢ ɮɭɧɤɰɢɢ ɧɟ ɱɥɟɧɚɦɢ ɢ ɜɵɧɟɫɬɢ ɢɯ ɜ ɨɬɞɟɥɶ-
ɧɵɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ, ɜɤɥɸɱɚɸɳɢɣ ɭɩɨɦɹɧɭɬɵɣ ɛɨɥɶɲɨɣ ɮɚɣɥ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44).
Ссылки
[Lakos96] §3.2 • [Stroustrup00] §9.2.3 • [Sutter00] §26-30 • [Vandevoorde03] §9-10
23. Делайте заголовочные файлы самодостаточными 55
Стр. 55
24. Используйте только внутреннюю,
но не внешнюю защиту директивы
#include
Резюме
ɉɪɟɞɨɬɜɪɚɳɚɣɬɟ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɟ ɦɧɨɠɟɫɬɜɟɧɧɨɟ ɜɤɥɸɱɟɧɢɟ ɜɚɲɢɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣ-
ɥɨɜ ɞɢɪɟɤɬɢɜɨɣ #include, ɢɫɩɨɥɶɡɭɹ ɜ ɧɢɯ ɡɚɳɢɬɭ ɫ ɭɧɢɤɚɥɶɧɵɦɢ ɢɦɟɧɚɦɢ.
Ʉɚɠɞɵɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɞɨɥɠɟɧ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜɧɭɬɪɟɧɧɸɸ ɡɚɳɢɬɭ ɞɢɪɟɤɬɢɜɵ
#include, ɱɬɨɛɵ ɩɪɟɞɨɬɜɪɚɬɢɬɶ ɩɟɪɟɨɩɪɟɞɟɥɟɧɢɹ ɜ ɫɥɭɱɚɟ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɜɤɥɸɱɟɧɢɹ ɞɚɧ-
ɧɨɝɨ ɮɚɣɥɚ. ɇɚɩɪɢɦɟɪ, ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ foo.h ɞɨɥɠɟɧ ɢɦɟɬɶ ɬɚɤɨɣ ɨɛɳɢɣ ɜɢɞ:
#ifndef FOO_H_INCLUDED_
#define FOO_H_INCLUDED_
// ... ǜǹǯǰǻǱǳǷǹǰ ǿǫǴǶǫ ...
#endif
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɫɥɟɞɭɸɳɢɟ ɩɪɚɜɢɥɚ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɡɚɳɢɬɵ ɜɤɥɸɱɟɧɢɹ.
• ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɡɚɳɢɬɵ ɭɧɢɤɚɥɶɧɵɟ ɢɦɟɧɚ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɢɦɟɧɚ,
ɭɧɢɤɚɥɶɧɵɟ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɜ ɩɪɟɞɟɥɚɯ ɜɚɲɟɝɨ ɩɪɢɥɨɠɟɧɢɹ. ȼɵɲɟ ɦɵ ɢɫɩɨɥɶɡɨɜɚɥɢ
ɨɞɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɟ ɫɨɝɥɚɲɟɧɢɟ ɞɥɹ ɢɫɩɨɥɶɡɭɟɦɵɯ ɜ ɡɚɳɢɬɟ ɢɦɟɧ; ɢɦɟɧɚ ɞɥɹ ɡɚ-
ɳɢɬɵ ɦɨɝɭɬ ɜɤɥɸɱɚɬɶ ɢɦɹ ɩɪɢɥɨɠɟɧɢɹ, ɚ ɧɟɤɨɬɨɪɵɟ ɢɧɫɬɪɭɦɟɧɬɵ ɝɟɧɟɪɢɪɭɸɬ ɢɦɟɧɚ
ɞɥɹ ɡɚɳɢɬɵ, ɫɨɞɟɪɠɚɳɢɟ ɫɥɭɱɚɣɧɵɟ ɱɢɫɥɚ.
• ɇɟ ɩɵɬɚɣɬɟɫɶ ɯɢɬɪɢɬɶ. ɇɟ ɪɚɡɦɟɳɚɣɬɟ ɧɢɤɚɤɨɝɨ ɤɨɞɚ ɢɥɢ ɤɨɦɦɟɧɬɚɪɢɟɜ ɞɨ ɢ ɩɨɫɥɟ
ɡɚɳɢɳɟɧɧɨɣ ɱɚɫɬɢ, ɢ ɫɥɟɞɭɣɬɟ ɩɨɤɚɡɚɧɧɨɣ ɜɵɲɟ ɫɬɚɧɞɚɪɬɧɨɣ ɮɨɪɦɟ ɡɚɳɢɬɵ. ɋɨɜɪɟ-
ɦɟɧɧɵɟ ɩɪɟɩɪɨɰɟɫɫɨɪɵ ɦɨɝɭɬ ɨɛɧɚɪɭɠɢɬɶ ɡɚɳɢɬɭ, ɧɨ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɦɚɥɨɢɧɬɟɥɥɟɤ-
ɬɭɚɥɶɧɵɦɢ ɢ ɨɠɢɞɚɬɶ ɤɨɞɚ ɡɚɳɢɬɵ ɫɬɪɨɝɨ ɜ ɧɚɱɚɥɟ ɢ ɜ ɤɨɧɰɟ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ.
ɂɡɛɟɝɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɭɫɬɚɪɟɜɲɟɣ ɜɧɟɲɧɟɣ ɡɚɳɢɬɵ ɞɢɪɟɤɬɢɜɵ #include, ɪɟɤɨɦɟɧ-
ɞɭɟɦɨɣ ɜ ɧɟɤɨɬɨɪɵɯ ɫɬɚɪɵɯ ɤɧɢɝɚɯ:
#ifndef FOO_H_INCLUDED_ // ǘǐ ǻǰǵǹǷǰǸǯǾǰǽǼȊ
#include "foo.h"
#define FOO_H_INCLUDED_
#endif
ȼɧɟɲɧɹɹ ɡɚɳɢɬɚ ɭɬɨɦɢɬɟɥɶɧɚ, ɭɫɬɚɪɟɥɚ ɞɥɹ ɫɨɜɪɟɦɟɧɧɵɯ ɤɨɦɩɢɥɹɬɨɪɨɜ ɢ ɧɟɧɚɞɟɠɧɚ ɢɡ-ɡɚ
ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɫɨɝɥɚɫɨɜɚɧɢɹ ɢɦɟɧ ɞɥɹ ɡɚɳɢɬɵ.
ȼ ɨɱɟɧɶ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɦɨɠɟɬ ɛɵɬɶ ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɦɧɨɝɨɤɪɚɬɧɨɝɨ
ɜɤɥɸɱɟɧɢɹ.
Ссылки
[C++03, §2.1] • [Stroustrup00] §9.3.3
Стр. 56
Функции и операторы
ȿɫɥɢ ɜɚɲɚ ɩɪɨɰɟɞɭɪɚ ɢɦɟɟɬ ɞɟɫɹɬɶ ɩɚɪɚɦɟɬɪɨɜ —
ɜɟɪɨɹɬɧɨ, ɜɵ ɝɞɟ-ɬɨ ɨɲɢɛɥɢɫɶ.
Ɏɭɧɤɰɢɢ, ɜɤɥɸɱɚɹ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ

ɟɞɢɧɢɰɵ ɪɚɛɨɬɵ. Ʉɚɤ ɜɵ ɭɜɢɞɢɬɟ ɩɨɡɠɟ ɜ ɪɚɡɞɟɥɟ “Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ” (ɜ ɱɚɫɬ-
ɧɨɫɬɢ, ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 70), ɷɬɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɜɥɢɹɟɬ ɧɚ ɧɚɲɢ ɪɚɫɫɭɠɞɟɧɢɹ ɨ ɤɨɪɪɟɤɬɧɨɫɬɢ
ɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɤɨɞɚ.
ɇɨ ɞɚɜɚɣɬɟ ɫɧɚɱɚɥɚ ɪɚɫɫɦɨɬɪɢɦ ɧɟɤɨɬɨɪɵɟ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ ɜɨɩɪɨɫɵ ɧɚɩɢɫɚɧɢɹ ɮɭɧɤ-
ɰɢɣ, ɜ ɬɨɦ ɱɢɫɥɟ ɨɩɟɪɚɬɨɪɨɜ. ȼ ɱɚɫɬɧɨɫɬɢ, ɦɵ ɨɛɪɚɬɢɦ ɨɫɨɛɨɟ ɜɧɢɦɚɧɢɟ ɧɚ ɢɯ ɩɚɪɚɦɟɬɪɵ,
ɫɟɦɚɧɬɢɤɭ ɢ ɩɟɪɟɝɪɭɡɤɭ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɧɚɢɛɨɥɟɟ ɜɚɠɧɨɣ ɧɚɦ ɩɪɟɞɫɬɚɜɥɹɟɬɫɹ ɪɟɤɨɦɟɧɞɚɰɢɹ 26 — “ɋɨɯɪɚɧɹɣɬɟ ɟɫ-
ɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ”.
24. Используйте только внутреннюю, но не внешнюю защиту директивы #include 57
Стр. 57
25. Передача параметров по значению,
(интеллектуальному) указателю
или ссылке
Резюме
ȼɵ ɞɨɥɠɧɵ ɱɟɬɤɨ ɭɹɫɧɢɬɶ ɪɚɡɧɢɰɭ ɦɟɠɞɭ ɜɯɨɞɧɵɦɢ, ɜɵɯɨɞɧɵɦɢ ɩɚɪɚɦɟɬɪɚɦɢ ɢ ɩɚɪɚɦɟɬ-
ɪɚɦɢ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɦɢ ɢ ɞɥɹ ɜɜɨɞɚ, ɢ ɞɥɹ ɜɵɜɨɞɚ ɢɧɮɨɪɦɚɰɢɢ, ɚ ɬɚɤɠɟ ɦɟɠɞɭ ɩɟɪɟɞɚɱɟɣ
ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ ɢ ɩɨ ɫɫɵɥɤɟ, ɢ ɤɨɪɪɟɤɬɧɨ ɢɯ ɢɫɩɨɥɶɡɨɜɚɬɶ.
ɉɪɚɜɢɥɶɧɵɣ ɜɵɛɨɪ ɫɩɨɫɨɛɚ ɩɟɪɟɞɚɱɢ ɚɪɝɭɦɟɧɬɨɜ ɜ ɮɭɧɤɰɢɸ — ɩɨ ɡɧɚɱɟɧɢɸ, ɫɫɵɥɤɟ ɢɥɢ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɭɤɚɡɚɬɟɥɟɣ — ɜɟɫɶɦɚ ɧɟɨɛɯɨɞɢɦɵɣ ɧɚɜɵɤ, ɤɨɬɨɪɵɣ ɩɨɦɨɠɟɬ ɜɚɦ ɫɞɟɥɚɬɶ
ɜɚɲ ɤɨɞ ɦɚɤɫɢɦɚɥɶɧɨ ɛɟɡɨɩɚɫɧɵɦ ɢ ɷɮɮɟɤɬɢɜɧɵɦ.
ɏɨɬɹ ɷɮɮɟɤɬɢɜɧɨɫɬɶ ɧɟ ɞɨɥɠɧɚ ɛɵɬɶ ɧɚɲɟɣ ɝɥɚɜɧɨɣ ɰɟɥɶɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8), ɩɪɢ
ɩɪɨɱɢɯ ɪɚɜɧɵɯ ɭɫɥɨɜɢɹɯ, ɜɤɥɸɱɚɹ ɩɨɧɹɬɧɨɫɬɶ ɤɨɞɚ, ɦɵ ɧɟ ɞɨɥɠɧɵ ɛɟɡ ɤɪɚɣɧɟɣ ɧɟɨɛɯɨɞɢɦɨ-
ɫɬɢ ɫɧɢɠɚɬɶ ɟɝɨ ɷɮɮɟɤɬɢɜɧɨɫɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).
ȼɚɦ ɫɬɨɢɬ ɫɥɟɞɨɜɚɬɶ ɩɪɢɜɟɞɟɧɧɵɦ ɧɢɠɟ ɪɟɤɨɦɟɧɞɚɰɢɹɦ ɩɪɢ ɜɵɛɨɪɟ ɫɩɨɫɨɛɚ ɩɟɪɟɞɚɱɢ
ɩɚɪɚɦɟɬɪɨɜ. ȼɨɬ ɪɟɤɨɦɟɧɞɚɰɢɢ ɞɥɹ ɜɯɨɞɧɵɯ ɩɚɪɚɦɟɬɪɨɜ (ɤɨɬɨɪɵɟ ɩɟɪɟɞɚɸɬ ɢɧɮɨɪɦɚɰɢɸ
ɜ ɮɭɧɤɰɢɸ, ɧɨ ɧɟ ɜɨɡɜɪɚɳɚɸɬ ɟɟ).
• ȼɫɟɝɞɚ ɨɩɢɫɵɜɚɣɬɟ ɜɫɟ ɭɤɚɡɚɬɟɥɢ ɢɥɢ ɫɫɵɥɤɢ ɧɚ ɜɯɨɞɧɵɟ ɩɚɪɚɦɟɬɪɵ ɤɚɤ const.
• ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɩɟɪɟɞɚɱɭ ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ (ɧɚɩɪɢɦɟɪ, char ɢɥɢ float) ɢ ɨɛɴɟɤ-
ɬɨɜ-ɡɧɚɱɟɧɢɣ ɫ ɧɟɞɨɪɨɝɢɦɢ ɨɩɟɪɚɰɢɹɦɢ ɤɨɩɢɪɨɜɚɧɢɹ (ɧɚɩɪɢɦɟɪ, Point ɢɥɢ complex
<float>) ɩɨ ɡɧɚɱɟɧɢɸ.
• ȼɯɨɞɧɵɟ ɚɪɝɭɦɟɧɬɵ ɩɪɨɱɢɯ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɬɢɩɨɜ ɥɭɱɲɟ ɩɟɪɟɞɚɜɚɬɶ ɤɚɤ ɫɫɵɥɤɢ ɧɚ
const.
• ɉɨɞɭɦɚɣɬɟ ɨ ɩɟɪɟɞɚɱɟ ɩɨ ɡɧɚɱɟɧɢɸ ɜɦɟɫɬɨ ɩɟɪɟɞɚɱɢ ɩɨ ɫɫɵɥɤɟ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɬɪɟɛɭɟɬ
ɫɨɡɞɚɧɢɹ ɤɨɩɢɢ ɚɪɝɭɦɟɧɬɚ. Ʉɨɧɰɟɩɬɭɚɥɶɧɨ ɩɟɪɟɞɚɱɚ ɩɨ ɡɧɚɱɟɧɢɸ ɷɤɜɢɜɚɥɟɧɬɧɚ ɩɟɪɟ-
ɞɚɱɟ ɫɫɵɥɤɢ ɧɚ ɤɨɧɫɬɚɧɬɧɵɣ ɨɛɴɟɤɬ ɢ ɜɵɩɨɥɧɟɧɢɟ ɤɨɩɢɪɨɜɚɧɢɹ, ɢ ɦɨɠɟɬ ɩɨɦɨɱɶ ɤɨɦ-
ɩɢɥɹɬɨɪɭ ɜ ɜɵɩɨɥɧɟɧɢɢ ɨɩɬɢɦɢɡɚɰɢɢ ɩɨ ɭɫɬɪɚɧɟɧɢɸ ɜɪɟɦɟɧɧɵɯ ɩɟɪɟɦɟɧɧɵɯ.
Ⱦɚɥɟɟ ɩɪɢɜɟɞɟɧɵ ɪɟɤɨɦɟɧɞɚɰɢɢ ɞɥɹ ɜɵɯɨɞɧɵɯ ɩɚɪɚɦɟɬɪɨɜ (ɚ ɬɚɤɠɟ ɩɚɪɚɦɟɬɪɨɜ ɞɥɹ ɨɞɧɨ-
ɜɪɟɦɟɧɧɨɝɨ ɜɜɨɞɚ ɢ ɜɵɜɨɞɚ ɢɧɮɨɪɦɚɰɢɢ).
• ȿɫɥɢ ɚɪɝɭɦɟɧɬ ɧɟɨɛɹɡɚɬɟɥɟɧ, ɥɭɱɲɟ ɩɟɪɟɞɚɬɶ ɟɝɨ ɤɚɤ (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ) ɭɤɚɡɚɬɟɥɶ
(ɱɬɨ ɩɨɡɜɨɥɢɬ ɜɵɡɵɜɚɸɳɟɣ ɮɭɧɤɰɢɢ ɩɟɪɟɞɚɬɶ ɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ ɤɚɤ ɭɤɚɡɚɧɢɟ, ɱɬɨ ɚɪ-
ɝɭɦɟɧɬ ɨɬɫɭɬɫɬɜɭɟɬ); ɬɨɬ ɠɟ ɫɨɜɟɬ ɩɪɢɦɟɧɢɦ ɢ ɜ ɫɥɭɱɚɟ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɫɨɯɪɚɧɹɟɬ ɤɨ-
ɩɢɸ ɭɤɚɡɚɬɟɥɹ ɢɥɢ ɤɚɤ-ɬɨ ɢɧɚɱɟ ɪɚɛɨɬɚɟɬ ɫ ɩɪɢɧɚɞɥɟɠɧɨɫɬɶɸ ɚɪɝɭɦɟɧɬɚ.
• ȿɫɥɢ ɚɪɝɭɦɟɧɬ ɨɛɹɡɚɬɟɥɶɧɵɣ ɢ ɮɭɧɤɰɢɹ ɧɟ ɫɨɯɪɚɧɹɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟɝɨ ɢɥɢ ɤɚɤɢɦ-ɬɨ
ɢɧɵɦ ɨɛɪɚɡɨɦ ɜɥɢɹɟɬ ɧɚ ɟɝɨ ɩɪɢɧɚɞɥɟɠɧɨɫɬɶ, ɬɨ ɬɚɤɨɣ ɚɪɝɭɦɟɧɬ ɥɭɱɲɟ ɩɟɪɟɞɚɜɚɬɶ ɩɨ
ɫɫɵɥɤɟ. ɗɬɨ ɭɤɚɡɵɜɚɟɬ, ɱɬɨ ɧɚɥɢɱɢɟ ɞɚɧɧɨɝɨ ɚɪɝɭɦɟɧɬɚ ɨɛɹɡɚɬɟɥɶɧɨ, ɢ ɡɚɫɬɚɜɥɹɟɬ ɜɵ-
ɡɵɜɚɸɳɭɸ ɮɭɧɤɰɢɸ ɨɬɜɟɱɚɬɶ ɡɚ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɤɨɪɪɟɤɬɧɨɝɨ ɨɛɴɟɤɬɚ.
ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɮɭɧɤɰɢɢ ɫ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 98).
Ссылки
[Alexandrescu03a] • [Cline99] §2.10-11, 14.02-12, 32.08 • [Dewhurst03] §57 • [Koenig97] §4 •
[Lakos96] §9.1.11-12 • [McConnell93] §5.7 • [Meyers97] §21-22 • [Stroustrup94] §11.4.4 •
[Stroustrup00] §5.5, §11.6, §16.3.4 • [Sutter00] §6, §46
58 Функции и операторы
Стр. 58
26. Сохраняйте естественную семантику
перегруженных операторов
Резюме
ɉɪɨɝɪɚɦɦɢɫɬɵ ɧɟɧɚɜɢɞɹɬ ɫɸɪɩɪɢɡɵ. ɉɟɪɟɝɪɭɠɚɣɬɟ ɨɩɟɪɚɬɨɪɵ ɬɨɥɶɤɨ ɜ ɫɥɭɱɚɟ ɜɟɫɤɢɯ ɧɚ
ɬɨ ɨɫɧɨɜɚɧɢɣ, ɢ ɫɨɯɪɚɧɹɣɬɟ ɩɪɢ ɷɬɨɦ ɢɯ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ. ȿɫɥɢ ɷɬɨ ɨɤɚɡɵɜɚɟɬɫɹ
ɫɥɨɠɧɵɦ, ɜɨɡɦɨɠɧɨ, ɜɵ ɧɟɜɟɪɧɨ ɢɫɩɨɥɶɡɭɟɬɟ ɩɟɪɟɝɪɭɡɤɭ ɨɩɟɪɚɬɨɪɨɜ.
ɏɨɬɹ ɜɫɟ (ɤɚɤ ɦɵ ɧɚɞɟɟɦɫɹ) ɫɨɝɥɚɫɧɵ ɫ ɬɟɦ, ɱɬɨ ɧɟ ɫɥɟɞɭɟɬ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɜɵɱɢɬɚɧɢɟ ɤɚɤ
ɨɩɟɪɚɬɨɪ operator+, ɩɪɨɱɢɟ ɫɢɬɭɚɰɢɢ ɧɟ ɫɬɨɥɶ ɨɱɟɜɢɞɧɵ. ɇɚɩɪɢɦɟɪ, ɨɡɧɚɱɚɟɬ ɥɢ ɨɩɟɪɚɬɨɪ
operator* ɜɚɲɟɝɨ ɤɥɚɫɫɚ Tensor ɫɤɚɥɹɪɧɨɟ ɢɥɢ ɜɟɤɬɨɪɧɨɟ ɭɦɧɨɠɟɧɢɟ? Ⱦɨɥɠɟɧ ɥɢ ɨɩɟɪɚɬɨɪ
operator+=(Tensor&t, unsigned u) ɩɪɢɛɚɜɥɹɬɶ u ɤ ɤɚɠɞɨɦɭ ɢɡ ɷɥɟɦɟɧɬɨɜ t, ɢɥɢ ɞɨɥɠɟɧ
ɢɡɦɟɧɹɬɶ ɪɚɡɦɟɪ t? ȼ ɬɚɤɢɯ ɧɟɨɞɧɨɡɧɚɱɧɵɯ ɢɥɢ ɧɟ ɩɨɞɞɚɸɳɢɯɫɹ ɢɧɬɭɢɬɢɜɧɨɦɭ ɩɨɧɢɦɚɧɢɸ
ɫɥɭɱɚɹɯ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɟɧɨɜɚɧɧɵɟ ɮɭɧɤɰɢɢ, ɚ ɧɟ ɩɪɢɛɟɝɚɬɶ ɤ ɲɢɮɪɨɜɚɧɢɸ.
Ⱦɥɹ ɬɢɩɨɜ-ɡɧɚɱɟɧɢɣ (ɧɨ ɧɟ ɞɥɹ ɜɫɟɯ ɬɢɩɨɜ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 32) ɫɥɟɞɭɟɬ ɩɪɢɞɟɪɠɢɜɚɬɶɫɹ
ɩɪɚɜɢɥɚ: “ȿɫɥɢ ɧɟ ɡɧɚɟɲɶ, ɤɚɤ ɩɨɫɬɭɩɢɬɶ — ɩɨɫɬɭɩɚɣ ɬɚɤ, ɤɚɤ int” [Meyers96]. ɉɨɞɪɚɠɚɧɢɟ
ɩɨɜɟɞɟɧɢɸ ɨɩɟɪɚɬɨɪɨɜ ɜɫɬɪɨɟɧɧɵɯ ɬɢɩɨɜ ɢ ɜɡɚɢɦɨɨɬɧɨɲɟɧɢɹɦ ɦɟɠɞɭ ɧɢɦɢ ɝɚɪɚɧɬɢɪɭɟɬ, ɱɬɨ
ɜɵ ɧɢɤɨɝɨ ɧɟ ɩɪɢɜɟɞɟɬɟ ɜ ɡɚɦɟɲɚɬɟɥɶɫɬɜɨ. ȿɫɥɢ ɜɵɛɪɚɧɧɚɹ ɜɚɦɢ ɫɟɦɚɧɬɢɤɚ ɡɚɫɬɚɜɥɹɟɬ ɤɨɝɨ-
ɬɨ ɭɞɢɜɥɟɧɧɨ ɩɨɞɧɹɬɶ ɛɪɨɜɢ, ɦɨɠɟɬ ɛɵɬɶ, ɩɟɪɟɝɪɭɡɤɚ ɨɩɟɪɚɬɨɪɚ — ɧɟ ɫɚɦɚɹ ɥɭɱɲɚɹ ɢɞɟɹ?
ɉɪɨɝɪɚɦɦɢɫɬɵ ɨɠɢɞɚɸɬ, ɱɬɨ ɨɩɟɪɚɬɨɪɵ ɢɞɭɬ ɜ ɫɜɹɡɤɟ — ɟɫɥɢ ɜɵɪɚɠɟɧɢɟ a@b ɢɦɟɟɬ ɨɩ-
ɪɟɞɟɥɟɧɧɵɣ ɫɦɵɫɥ ɞɥɹ ɧɟɤɨɬɨɪɨɝɨ ɨɩɪɟɞɟɥɟɧɧɨɝɨ ɜɚɦɢ ɨɩɟɪɚɬɨɪɚ @ (ɜɨɡɦɨɠɧɨ, ɩɨɫɥɟ ɩɪɟɨɛ-
ɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ), ɬɨ ɡɚɞɚɣɬɟ ɫɚɦɢ ɫɟɛɟ ɜɨɩɪɨɫ: ɦɨɠɧɨ ɥɢ ɧɚɩɢɫɚɬɶ b@a ɛɟɡ ɧɟɩɪɢɹɬɧɵɯ ɩɨ-
ɫɥɟɞɫɬɜɢɣ? Ɇɨɠɧɨ ɥɢ ɧɚɩɢɫɚɬɶ a@=b? (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 27.) ȿɫɥɢ ɨɩɟɪɚɬɨɪ ɢɦɟɟɬ ɨɛɪɚɬ-
ɧɵɣ ɨɩɟɪɚɬɨɪ (ɧɚɩɪɢɦɟɪ, + ɢ -, * ɢ /), ɬɨ ɩɨɞɞɟɪɠɢɜɚɸɬɫɹ ɥɢ ɨɧɢ ɨɛɚ?
Ɉɬ ɢɦɟɧɨɜɚɧɧɵɯ ɮɭɧɤɰɢɣ ɧɟ ɨɠɢɞɚɟɬɫɹ ɧɚɥɢɱɢɟ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɯ ɜɡɚɢɦɨɨɬɧɨɲɟɧɢɣ, ɬɚɤ
ɱɬɨ ɞɥɹ ɛɨɥɶɲɟɣ ɹɫɧɨɫɬɢ ɤɨɞɚ, ɟɫɥɢ ɜɨɡɦɨɠɧɨ ɧɟɜɟɪɧɨɟ ɢɫɬɨɥɤɨɜɚɧɢɟ ɫɟɦɚɧɬɢɤɢ ɩɟɪɟɝɪɭ-
ɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ, ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɟɧɧɨ ɮɭɧɤɰɢɢ.
ɂɦɟɸɬɫɹ ɜɵɫɨɤɨɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɛɢɛɥɢɨɬɟɤɢ (ɧɚɩɪɢɦɟɪ, ɝɟɧɟɪɚɬɨɪɵ ɫɢɧɬɚɤɫɢɱɟɫɤɢɯ
ɚɧɚɥɢɡɚɬɨɪɨɜ), ɜ ɩɪɟɞɦɟɬɧɨɣ ɨɛɥɚɫɬɢ ɤɨɬɨɪɵɯ ɫɨɝɥɚɲɟɧɢɹ ɨ ɫɟɦɚɧɬɢɤɟ ɨɩɟɪɚɬɨɪɨɜ ɫɭɳɟɫɬ-
ɜɟɧɧɨ ɨɬɥɢɱɚɸɬɫɹ ɨɬ ɢɯ ɡɧɚɱɟɧɢɣ ɜ C++ (ɧɚɩɪɢɦɟɪ, ɩɪɢ ɪɚɛɨɬɟ ɫ ɪɟɝɭɥɹɪɧɵɦɢ ɜɵɪɚɠɟɧɢɹɦɢ
ɨɩɟɪɚɬɨɪ operator* ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɞɥɹ ɜɵɪɚɠɟɧɢɹ “ɧɨɥɶ ɢɥɢ ɛɨɥɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ”).
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɧɚɣɬɢ ɚɥɶɬɟɪɧɚɬɢɜɭ ɧɟɨɛɵɱɧɨɣ ɩɟɪɟɝɪɭɡɤɟ ɨɩɟɪɚɬɨɪɚ (ɧɚɩɪɢɦɟɪ, ɜ ɪɟɝɭ-
ɥɹɪɧɵɯ ɜɵɪɚɠɟɧɢɹɯ [C++TR104] ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɬɪɨɤɢ, ɬɚɤ ɱɬɨ * ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɟɫɬɟ-
ɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ, ɛɟɡ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɨɜ). ȿɫɥɢ ɜɫɟ ɠɟ ɩɨɫɥɟ ɬɳɚɬɟɥɶɧɵɯ ɪɚɡɦɵɲɥɟɧɢɣ
ɜɵ ɪɟɲɢɥɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɩɟɪɚɬɨɪɵ, ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɱɟɬɤɨ ɨɩɪɟɞɟɥɢɥɢ ɟɞɢɧɭɸ ɫɯɟɦɭ ɞɥɹ
ɜɫɟɯ ɜɚɲɢɯ ɫɨɝɥɚɲɟɧɢɣ, ɢ ɩɪɢ ɷɬɨɦ ɧɟ ɡɚɬɟɹɥɢ ɨɩɚɫɧɵɟ ɢɝɪɵ ɫɨ ɜɫɬɪɨɟɧɧɵɦɢ ɨɩɟɪɚɬɨɪɚɦɢ.
Ссылки
[Cline99] §23.02-06 • [C++TR104] §7 • [Dewhurst03] §85-86 • [Koenig97] §4 • [Lakos96] §9.1.1 •
[Meyers96] §6 • [Stroustrup00] §11.1 • [Sutter00] §41
26. Сохраняйте естественную семантику перегруженных операторов 59
Стр. 59
27. Отдавайте предпочтение каноническим формам...
27. Отдавайте предпочтение каноническим

формам арифметических операторов
и операторов присваивания
27. Отдавайте предпочтение каноническим формам...
Резюме
ȿɫɥɢ ɦɨɠɧɨ ɡɚɩɢɫɚɬɶ a+b, ɬɨ ɧɟɨɛɯɨɞɢɦɨ, ɱɬɨɛɵ ɦɨɠɧɨ ɛɵɥɨ ɡɚɩɢɫɚɬɶ ɢ a+=b. ɉɪɢ ɨɩ-
ɪɟɞɟɥɟɧɢɢ ɛɢɧɚɪɧɵɯ ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ ɨɩɟɪɚɬɨɪɨɜ ɨɞɧɨɜɪɟɦɟɧɧɨ ɩɪɟɞɨɫɬɚɜɥɹɣɬɟ ɢ ɢɯ ɩɪɢ-
ɫɜɚɢɜɚɸɳɢɟ ɜɟɪɫɢɢ, ɩɪɢɱɟɦ ɞɟɥɚɣɬɟ ɷɬɨ ɫ ɦɢɧɢɦɚɥɶɧɵɦ ɞɭɛɥɢɪɨɜɚɧɢɟɦ ɢ ɦɚɤɫɢɦɚɥɶɧɨɣ ɷɮ-
ɮɟɤɬɢɜɧɨɫɬɶɸ.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɞɥɹ ɧɟɤɨɬɨɪɨɝɨ ɛɢɧɚɪɧɨɝɨ ɨɩɟɪɚɬɨɪɚ @ (+, -, * ɢ ɬ.ɞ.) ɜɵ ɞɨɥɠɧɵ ɬɚɤɠɟ
ɨɩɪɟɞɟɥɢɬɶ ɟɝɨ ɩɪɢɫɜɚɢɜɚɸɳɭɸ ɜɟɪɫɢɸ, ɬɚɤ ɱɬɨɛɵ a@=b ɢ a=a@b ɢɦɟɥɢ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɫɦɵɫɥ
(ɩɪɢɱɟɦ ɩɟɪɜɚɹ ɜɟɪɫɢɹ ɦɨɠɟɬ ɛɵɬɶ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɚ). Ʉɚɧɨɧɢɱɟɫɤɢɣ ɫɩɨɫɨɛ ɞɨɫɬɢɠɟɧɢɹ
ɞɚɧɧɨɣ ɰɟɥɢ ɫɨɫɬɨɢɬ ɜ ɨɩɪɟɞɟɥɟɧɢɢ @ ɩɨɫɪɟɞɫɬɜɨɦ @= ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
T& T::operator@=( const T& ) {
// ... ǻǰǫǶǳǲǫȁǳȊ ...
return *this;
}
T operator@( const T& lhs, const T& rhs ) {
T temp( lhs );
return temp @= rhs;
}
ɗɬɢ ɞɜɟ ɮɭɧɤɰɢɢ ɪɚɛɨɬɚɸɬ ɜ ɬɚɧɞɟɦɟ. ȼɟɪɫɢɹ ɨɩɟɪɚɬɨɪɚ ɫ ɩɪɢɫɜɚɢɜɚɧɢɟɦ ɜɵɩɨɥɧɹɟɬ ɜɫɸ
ɧɟɨɛɯɨɞɢɦɭɸ ɪɚɛɨɬɭ ɢ ɜɨɡɜɪɚɳɚɟɬ ɫɜɨɣ ɥɟɜɵɣ ɩɚɪɚɦɟɬɪ. ȼɟɪɫɢɹ ɛɟɡ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɨɡɞɚɟɬ
ɜɪɟɦɟɧɧɭɸ ɩɟɪɟɦɟɧɧɭɸ ɢɡ ɥɟɜɨɝɨ ɚɪɝɭɦɟɧɬɚ, ɢ ɦɨɞɢɮɢɰɢɪɭɟɬ ɟɟ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɮɨɪɦɵ
ɨɩɟɪɚɬɨɪɚ ɫ ɩɪɢɫɜɚɢɜɚɧɢɟɦ, ɩɨɫɥɟ ɱɟɝɨ ɜɨɡɜɪɚɳɚɟɬ ɷɬɭ ɜɪɟɦɟɧɧɭɸ ɩɟɪɟɦɟɧɧɭɸ.
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɱɬɨ ɡɞɟɫɶ operator@ — ɮɭɧɤɰɢɹ-ɧɟ ɱɥɟɧ, ɬɚɤ ɱɬɨ ɨɧɚ ɨɛɥɚɞɚɟɬ ɠɟɥɚɬɟɥɶ-
ɧɵɦ ɫɜɨɣɫɬɜɨɦ ɜɨɡɦɨɠɧɨɫɬɢ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɤɚɤ ɥɟɜɨɝɨ, ɬɚɤ ɢ ɩɪɚɜɨɝɨ ɩɚɪɚɦɟɬɪɚ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44). ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɜɵ ɨɩɪɟɞɟɥɢɬɟ ɤɥɚɫɫ String, ɤɨɬɨɪɵɣ ɢɦɟɟɬ ɧɟɹɜɧɵɣ
ɤɨɧɫɬɪɭɤɬɨɪ, ɩɨɥɭɱɚɸɳɢɣ ɚɪɝɭɦɟɧɬ ɬɢɩɚ char, ɬɨ ɨɩɟɪɚɬɨɪ operator+(const String&,
const String&), ɤɨɬɨɪɵɣ ɧɟ ɹɜɥɹɟɬɫɹ ɱɥɟɧɨɦ ɤɥɚɫɫɚ, ɩɨɡɜɨɥɹɟɬ ɨɫɭɳɟɫɬɜɥɹɬɶ ɨɩɟɪɚɰɢɢ ɤɚɤ ɬɢɩɚ
char+String, ɬɚɤ ɢ String+char; ɮɭɧɤɰɢɹ-ɱɥɟɧ String::operator+(const String&) ɩɨ-
ɡɜɨɥɹɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɨɥɶɤɨ ɨɩɟɪɚɰɢɸ String+char. Ɋɟɚɥɢɡɚɰɢɹ, ɨɫɧɨɜɧɨɣ ɰɟɥɶɸ ɤɨɬɨɪɨɣ ɹɜɥɹ-
ɟɬɫɹ ɷɮɮɟɤɬɢɜɧɨɫɬɶ, ɦɨɠɟɬ ɨɩɪɟɞɟɥɢɬɶ ɪɹɞ ɩɟɪɟɝɪɭɡɨɤ ɨɩɟɪɚɬɨɪɚ operator@, ɧɟ ɹɜɥɹɸɳɢɯɫɹ
ɱɥɟɧɚɦɢ ɤɥɚɫɫɚ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɭɜɟɥɢɱɟɧɢɹ ɤɨɥɢɱɟɫɬɜɚ ɜɪɟɦɟɧɧɵɯ ɩɟɪɟɦɟɧɧɵɯ ɜ ɩɪɨɰɟɫɫɟ ɩɪɟɨɛ-
ɪɚɡɨɜɚɧɢɣ ɬɢɩɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 29).
Ɍɚɤɠɟ ɞɟɥɚɣɬɟ ɧɟ ɱɥɟɧɨɦ ɮɭɧɤɰɢɸ operator@= ɜɟɡɞɟ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 44). ȼ ɥɸɛɨɦ ɫɥɭɱɚɟ, ɜɫɟ ɨɩɟɪɚɬɨɪɵ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ, ɞɨɥɠɧɵ ɛɵɬɶ ɩɨɦɟɳɟɧɵ ɜ ɬɨ
ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɱɬɨ ɢ ɤɥɚɫɫ T, ɬɚɤ ɱɬɨ ɨɧɢ ɛɭɞɭɬ ɥɟɝɤɨ ɞɨɫɬɭɩɧɵ ɞɥɹ ɜɵɡɵɜɚɸɳɢɯ ɮɭɧɤ-
ɰɢɣ ɩɪɢ ɨɬɫɭɬɫɬɜɢɢ ɤɚɤɢɯ-ɥɢɛɨ ɫɸɪɩɪɢɡɨɜ ɫɨ ɫɬɨɪɨɧɵ ɩɨɢɫɤɚ ɢɦɟɧ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57).
Ʉɚɤ ɜɚɪɢɚɧɬ ɦɨɠɧɨ ɩɪɟɞɭɫɦɨɬɪɟɬɶ ɨɩɟɪɚɬɨɪ operator@, ɩɪɢɧɢɦɚɸɳɢɣ ɩɟɪɜɵɣ ɩɚɪɚɦɟɬɪ
ɩɨ ɡɧɚɱɟɧɢɸ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ ɜɵ ɨɛɟɫɩɟɱɢɬɟ ɧɟɹɜɧɨɟ ɤɨɩɢɪɨɜɚɧɢɟ ɤɨɦɩɢɥɹɬɨɪɨɦ, ɱɬɨ ɨɛɟɫɩɟ-
ɱɢɬ ɟɦɭ ɛɨɥɶɲɭɸ ɫɜɨɛɨɞɭ ɞɟɣɫɬɜɢɣ ɩɨ ɨɩɬɢɦɢɡɚɰɢɢ:
Стр. 60
T& operator@=(T
T& lhs, const T& rhs) {
// ... ǻǰǫǶǳǲǫȁǳȊ ...
return lhs;
}
T operator@(T
T lhs, const T& rhs) {// lhs ǺǰǻǰǯǫǸǹ Ǻǹ ǲǸǫȂǰǸǳȉ
return lhs @= rhs;
}
ȿɳɟ ɨɞɢɧ ɜɚɪɢɚɧɬ — ɨɩɟɪɚɬɨɪ operator@, ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ const-ɡɧɚɱɟɧɢɟ. ɗɬɚ
ɦɟɬɨɞɢɤɚ ɢɦɟɟɬ ɬɨ ɩɪɟɢɦɭɳɟɫɬɜɨ, ɱɬɨ ɩɪɢ ɷɬɨɦ ɡɚɩɪɟɳɚɟɬɫɹ ɬɚɤɨɣ ɧɟ ɢɦɟɸɳɢɣ ɫɦɵɫɥɚ ɤɨɞ,
ɤɚɤ a+b=c, ɧɨ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɦɵ ɬɟɪɹɟɦ ɜɨɡɦɨɠɧɨɫɬɶ ɩɪɢɦɟɧɟɧɢɹ ɩɨɬɟɧɰɢɚɥɶɧɨ ɩɨɥɟɡɧɵɯ
ɤɨɧɫɬɪɭɤɰɢɣ ɧɚɩɨɞɨɛɢɟ a = (b+c).replace(pos,n,d). Ⱥ ɷɬɨ ɜɟɫɶɦɚ ɜɵɪɚɡɢɬɟɥɶɧɵɣ ɤɨɞ,
ɤɨɬɨɪɵɣ ɜ ɨɞɧɨɣ ɫɬɪɨɱɤɟ ɜɵɩɨɥɧɹɟɬ ɤɨɧɤɚɬɟɧɚɰɢɸ ɫɬɪɨɤ b ɢ c, ɡɚɦɟɧɹɟɬ ɧɟɤɨɬɨɪɵɟ ɫɢɦɜɨɥɵ
ɢ ɩɪɢɫɜɚɢɜɚɟɬ ɩɨɥɭɱɟɧɧɵɣ ɪɟɡɭɥɶɬɚɬ ɩɟɪɟɦɟɧɧɨɣ a.
Примеры
ɉɪɢɦɟɪ. Ɋɟɚɥɢɡɚɰɢɹ += ɞɥɹ ɫɬɪɨɤ. ɉɪɢ ɤɨɧɤɚɬɟɧɚɰɢɢ ɫɬɪɨɤ ɩɨɥɟɡɧɨ ɡɚɪɚɧɟɟ ɡɧɚɬɶ ɞɥɢɧɭ,
ɱɬɨɛɵ ɜɵɞɟɥɹɬɶ ɩɚɦɹɬɶ ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ:
String& String::operator+=( const String& rhs ) {
// ... ǛǰǫǶǳǲǫȁǳȊ ...
return *this;
}
String operator+( const String& lhs, const String& rhs ) {

String temp; // ǓǲǸǫȂǫǶȇǸǹ ǺǾǼǽǫ
// ǍȆǯǰǶǰǸǳǰ ǯǹǼǽǫǽǹȂǸǹǮǹ ǵǹǶǳȂǰǼǽǭǫ ǺǫǷȊǽǳ
temp.Reserve(lhs.size()+rhs.size());
// ǕǹǸǵǫǽǰǸǫȁǳȊ Ǽǽǻǹǵ ǳ ǭǹǲǭǻǫǽ
return (temp += lhs) += rhs;
}
ȼ ɧɟɤɨɬɨɪɵɯ ɫɥɭɱɚɹɯ (ɧɚɩɪɢɦɟɪ, ɨɩɟɪɚɬɨɪ operator*= ɞɥɹ ɤɨɦɩɥɟɤɫɧɵɯ ɱɢɫɟɥ), ɨɩɟɪɚ-
ɬɨɪ ɦɨɠɟɬ ɢɡɦɟɧɹɬɶ ɥɟɜɵɣ ɚɪɝɭɦɟɧɬ ɧɚɫɬɨɥɶɤɨ ɫɭɳɟɫɬɜɟɧɧɨ, ɱɬɨ ɛɨɥɟɟ ɜɵɝɨɞɧɵɦ ɦɨɠɟɬ ɨɤɚ-
ɡɚɬɶɫɹ ɪɟɚɥɢɡɚɰɢɹ ɨɩɟɪɚɬɨɪɚ operator*= ɩɨɫɪɟɞɫɬɜɨɦ ɨɩɟɪɚɬɨɪɚ operator*, ɚ ɧɟ ɧɚɨɛɨ-
ɪɨɬ.
Ссылки
[Alexandrescu03a] • [Cline99] §23.06 • [Meyers96] §22 • [Sutter00] §20
27. Отдавайте предпочтение каноническим формам... 61
Стр. 61
28. Предпочитайте канонический вид ++ и --,
и вызов префиксных операторов
Резюме
Ɉɫɨɛɟɧɧɨɫɬɶ ɨɩɟɪɚɬɨɪɨɜ ɢɧɤɪɟɦɟɧɬɚ ɢ ɞɟɤɪɟɦɟɧɬɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɭ ɧɢɯ ɟɫɬɶ ɩɪɟɮɢɤɫ-
ɧɚɹ ɢ ɩɨɫɬɮɢɤɫɧɚɹ ɮɨɪɦɵ ɫ ɧɟɦɧɨɝɨ ɨɬɥɢɱɚɸɳɟɣɫɹ ɫɟɦɚɧɬɢɤɨɣ. Ɉɩɪɟɞɟɥɹɣɬɟ ɨɩɟɪɚɬɨɪɵ
operator++ ɢ operator-- ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɩɨɞɪɚɠɚɥɢ ɩɨɜɟɞɟɧɢɸ ɫɜɨɢɯ ɜɫɬɪɨɟɧɧɵɯ ɞɜɨɣ-
ɧɢɤɨɜ. ȿɫɥɢ ɬɨɥɶɤɨ ɜɚɦ ɧɟ ɬɪɟɛɭɟɬɫɹ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɮɢɤɫɧɵɟ ɜɟɪɫɢɢ
ɨɩɟɪɚɬɨɪɨɜ.
ɋɬɚɪɚɹ ɲɭɬɤɚ ɝɥɚɫɢɬ, ɱɬɨ ɹɡɵɤ ɧɚɡɵɜɚɟɬɫɹ C++, ɚ ɧɟ ++C, ɩɨɬɨɦɭ ɱɬɨ ɹɡɵɤ ɛɵɥ ɭɥɭɱɲɟɧ
(ɧɚ ɱɬɨ ɭɤɚɡɵɜɚɟɬ ɢɧɤɪɟɦɟɧɬ), ɧɨ ɦɧɨɝɢɟ ɩɪɨɞɨɥɠɚɸɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɝɨ ɤɚɤ C (ɩɪɟɞɵɞɭɳɟɟ
ɡɧɚɱɟɧɢɟ ɞɨ ɢɧɤɪɟɦɟɧɬɚ). Ʉ ɫɱɚɫɬɶɸ, ɷɬɭ ɲɭɬɤɭ ɦɨɠɧɨ ɫɱɢɬɚɬɶ ɭɫɬɚɪɟɜɲɟɣ, ɧɨ ɷɬɨ ɨɬɥɢɱɧɚɹ
ɢɥɥɸɫɬɪɚɰɢɹ ɞɥɹ ɩɨɧɢɦɚɧɢɹ ɨɬɥɢɱɢɹ ɦɟɠɞɭ ɞɜɭɦɹ ɮɨɪɦɚɦɢ ɨɩɟɪɚɬɨɪɨɜ.
ȼ ɫɥɭɱɚɟ ++ ɢ -- ɩɨɫɬɮɢɤɫɧɵɟ ɮɨɪɦɵ ɨɩɟɪɚɬɨɪɨɜ ɜɨɡɜɪɚɳɚɸɬ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ, ɜ ɬɨ ɜɪɟ-
ɦɹ ɤɚɤ ɩɪɟɮɢɤɫɧɵɟ ɮɨɪɦɵ ɜɨɡɜɪɚɳɚɸɬ ɧɨɜɨɟ ɡɧɚɱɟɧɢɟ. Ʌɭɱɲɟ ɜɫɟɝɨ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɩɨɫɬɮɢɤɫ-
ɧɵɣ ɨɩɟɪɚɬɨɪ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɩɪɟɮɢɤɫɧɨɝɨ. ȼɨɬ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ɬɚɤɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ:
// ---- ǚǻǰǿǳǵǼǸȆǰ ǹǺǰǻǫǽǹǻȆ --------------------
T& T::operator++() // ǚǻǰǿǳǵǼǸȆǴ ǭǳǯ:
{
// ǍȆǺǹǶǸǰǸǳǰ // - ǍȆǺǹǶǸǰǸǳǰ
// ǳǸǵǻǰǷǰǸǽǫ // ǯǰǴǼǽǭǳǴ
return *this; // - return *this;
}
T& T::operator--() // ǚǻǰǿǳǵǼǸȆǴ ǭǳǯ:
{
// ǍȆǺǹǶǸǰǸǳǰ // - ǍȆǺǹǶǸǰǸǳǰ
// ǯǰǵǻǰǷǰǸǽǫ // ǯǰǴǼǽǭǳǴ
return *this; // - return *this;
}
// ---- ǚǹǼǽǿǳǵǼǸȆǰ ǹǺǰǻǫǽǹǻȆ -------------------

T T::operator++(int) // ǚǹǼǽǿǳǵǼǸȆǴ ǭǳǯ:
{
T old( *this ); // - ǒǫǺǹǷǳǸǫǰǷ Ǽǽǫǻǹǰ ǲǸǫȂǰǸǳǰ
++*this; // - ǍȆǲǹǭ ǺǻǰǿǳǵǼǸǹǴ ǭǰǻǼǳǳ
return old; // - Ǎǹǲǭǻǫǽ ǼǽǫǻǹǮǹ ǲǸǫȂǰǸǳȊ
}
T T::operator--(int) // ǚǹǼǽǿǳǵǼǸȆǴ ǭǳǯ:
{
T old( *this ); // - ǒǫǺǹǷǳǸǫǰǷ Ǽǽǫǻǹǰ ǲǸǫȂǰǸǳǰ
--*this; // - ǍȆǲǹǭ ǺǻǰǿǳǵǼǸǹǴ ǭǰǻǼǳǳ
return old; // - Ǎǹǲǭǻǫǽ ǼǽǫǻǹǮǹ ǲǸǫȂǰǸǳȊ
}
ȼ ɜɵɡɵɜɚɸɳɟɦ ɤɨɞɟ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɟɮɢɤɫɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɚɦ ɧɟ ɬɪɟ-
ɛɭɟɬɫɹ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ, ɜɨɡɜɪɚɳɚɟɦɨɟ ɩɨɫɬɮɢɤɫɧɨɣ ɜɟɪɫɢɟɣ. ɉɪɟɮɢɤɫɧɚɹ ɮɨɪɦɚ ɫɟɦɚɧɬɢ-
ɱɟɫɤɢ ɷɤɜɢɜɚɥɟɧɬɧɚ, ɨɧɚ ɜɜɨɞɢɬɫɹ ɩɪɚɤɬɢɱɟɫɤɢ ɬɚɤ ɠɟ, ɢ ɡɚɱɚɫɬɭɸ ɧɟɦɧɨɝɨ ɷɮɮɟɤɬɢɜɧɟɟ, ɬɚɤ
ɤɚɤ ɫɨɡɞɚɟɬ ɧɚ ɨɞɢɧ ɨɛɴɟɤɬ ɦɟɧɶɲɟ. ɗɬɨ ɧɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ, ɚ ɭɫɬɪɚɧɟɧɢɟ
ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).
Стр. 62
ɒɚɛɥɨɧɵ, ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɥɹ ɧɚɭɱɧɵɯ ɜɵɱɢɫɥɟɧɢɣ (ɧɚɩɪɢɦɟɪ, ɲɚɛɥɨɧɵ ɞɥɹ ɩɪɟɞɫɬɚɜɥɟ-
ɧɢɹ ɬɟɧɡɨɪɨɜ ɢɥɢ ɦɚɬɪɢɰ), ɤ ɤɨɬɨɪɵɦ ɩɪɟɞɴɹɜɥɹɸɬɫɹ ɠɟɫɬɤɢɟ ɬɪɟɛɨɜɚɧɢɹ ɩɨ ɩɪɨɢɡɜɨɞɢɬɟɥɶ-
ɧɨɫɬɢ. Ⱦɥɹ ɬɚɤɢɯ ɲɚɛɥɨɧɨɜ ɱɚɫɬɨ ɩɪɢɯɨɞɢɬɫɹ ɢɫɤɚɬɶ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵɟ ɫɩɨɫɨɛɵ ɪɟɚɥɢɡɚɰɢɢ
ɩɪɟɮɢɤɫɧɵɯ ɮɨɪɦ ɨɩɟɪɚɬɨɪɨɜ.
Ссылки
[Cline99] §23.07-08 • [Dewhurst03] §87 • [Meyers96] §6 • [Stroustrup00] §19.3 • [Sutter00] §6, §20
28. Предпочитайте канонический вид ++ и , и вызов префиксных операторов 63
Стр. 63
29. Используйте перегрузку, чтобы избежать
неявного преобразования типов
Резюме
ɇɟ ɩɪɟɭɦɧɨɠɚɣɬɟ ɨɛɴɟɤɬɵ ɫɜɟɪɯ ɧɟɨɛɯɨɞɢɦɨɫɬɢ (Ȼɪɢɬɜɚ Ɉɤɤɚɦɚ): ɧɟɹɜɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚ-
ɧɢɟ ɬɢɩɨɜ ɨɛɟɫɩɟɱɢɜɚɟɬ ɨɩɪɟɞɟɥɟɧɧɨɟ ɫɢɧɬɚɤɫɢɱɟɫɤɨɟ ɭɞɨɛɫɬɜɨ (ɨɞɧɚɤɨ ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 40), ɧɨ ɜ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɞɨɩɭɫɬɢɦɚ ɨɩɬɢɦɢɡɚɰɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8) ɢ ɠɟɥɚɬɟɥɶɧɨ
ɢɡɛɟɠɚɬɶ ɫɨɡɞɚɧɢɹ ɢɡɥɢɲɧɢɯ ɨɛɴɟɤɬɨɜ, ɦɨɠɧɨ ɨɛɟɫɩɟɱɢɬɶ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤɰɢɢ ɫ ɫɢɝɧɚ-
ɬɭɪɚɦɢ, ɬɨɱɧɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɬɢɩɚɦ ɚɪɝɭɦɟɧɬɨɜ, ɢ ɬɟɦ ɫɚɦɵɦ ɢɡɛɟ-
ɠɚɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ.
Ʉɨɝɞɚ ɜɵ ɪɚɛɨɬɚɟɬɟ ɜ ɨɮɢɫɟ ɢ ɭ ɜɚɫ ɡɚɤɚɧɱɢɜɚɟɬɫɹ ɛɭɦɚɝɚ, ɱɬɨ ɜɵ ɞɟɥɚɟɬɟ? ɉɪɚɜɢɥɶɧɨ —
ɜɵ ɢɞɟɬɟ ɤ ɤɨɩɢɪɨɜɚɥɶɧɨɦɭ ɚɩɩɚɪɚɬɭ ɢ ɞɟɥɚɟɬɟ ɧɟɫɤɨɥɶɤɨ ɤɨɩɢɣ ɱɢɫɬɨɝɨ ɥɢɫɬɚ ɛɭɦɚɝɢ.
Ʉɚɤ ɛɵ ɝɥɭɩɨ ɷɬɨ ɧɢ ɡɜɭɱɚɥɨ, ɧɨ ɡɚɱɚɫɬɭɸ ɷɬɨ ɢɦɟɧɧɨ ɬɨ, ɱɬɨ ɞɟɥɚɟɬ ɧɟɹɜɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚ-
ɧɢɟ ɬɢɩɨɜ: ɫɨɡɞɚɧɢɟ ɢɡɥɢɲɧɢɯ ɜɪɟɦɟɧɧɵɯ ɨɛɴɟɤɬɨɜ ɬɨɥɶɤɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɜɵɩɨɥɧɢɬɶ ɧɟɤɨ-
ɬɨɪɵɟ ɬɪɢɜɢɚɥɶɧɵɟ ɨɩɟɪɚɰɢɢ ɧɚɞ ɧɢɦɢ ɢ ɬɭɬ ɠɟ ɢɯ ɜɵɛɪɨɫɢɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 40). ȼ ɤɚ-
ɱɟɫɬɜɟ ɩɪɢɦɟɪɚ ɦɨɠɧɨ ɪɚɫɫɦɨɬɪɟɬɶ ɫɪɚɜɧɟɧɢɟ ɫɬɪɨɤ:
class String { // ...
String( const char* text ); // ǙǬǰǼǺǰȂǳǭǫǰǽ ǸǰȊǭǸǹǰ
// ǺǻǰǹǬǻǫǲǹǭǫǸǳǰ ǽǳǺǹǭ
};
bool operator==( const String&, const String& );
// ... ǎǯǰ-ǽǹ ǭ ǵǹǯǰ ...

if( someString == "Hello" ) { ... }
Ɉɡɧɚɤɨɦɢɜɲɢɫɶ ɫ ɩɪɢɜɟɞɟɧɧɵɦɢ ɜɵɲɟ ɨɩɪɟɞɟɥɟɧɢɹɦɢ, ɤɨɦɩɢɥɹɬɨɪ ɤɨɦɩɢɥɢɪɭɟɬ ɩɪɢɜɟ-
ɞɟɧɧɨɟ ɫɪɚɜɧɟɧɢɟ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɤɚɤ ɟɫɥɢ ɛɵ ɨɧɨ ɛɵɥɨ ɡɚɩɢɫɚɧɨ ɜ ɜɢɞɟ someString ==
String("Hello"). ɗɬɨ ɫɥɢɲɤɨɦ ɪɚɫɬɨɱɢɬɟɥɶɧɨ — ɤɨɩɢɪɨɜɚɬɶ ɫɢɦɜɨɥɵ, ɱɬɨɛɵ ɩɨɬɨɦ ɩɪɨ-
ɫɬɨ ɩɪɨɱɟɫɬɶ ɢɯ. Ɋɟɲɟɧɢɟ ɷɬɨɣ ɩɪɨɛɥɟɦɵ ɨɱɟɧɶ ɩɪɨɫɬɨɟ — ɨɩɪɟɞɟɥɢɬɶ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤ-
ɰɢɢ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ, ɧɚɩɪɢɦɟɪ:
bool operator==( const String& lhs, const String& rhs ); // #1
bool operator==( const String& lhs, const char* rhs ); // #2
bool operator==( const char* lhs, const String& rhs ); // #3
ɗɬɨ ɜɵɝɥɹɞɢɬ ɤɚɤ ɞɭɛɥɢɪɨɜɚɧɢɟ ɤɨɞɚ, ɧɨ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɷɬɨ ɜɫɟɝɨ ɥɢɲɶ “ɞɭɛɥɢɪɨɜɚɧɢɟ
ɫɢɝɧɚɬɭɪ”, ɩɨɫɤɨɥɶɤɭ ɜɫɟ ɬɪɢ ɜɚɪɢɚɧɬɚ ɨɛɵɱɧɨ ɢɫɩɨɥɶɡɭɸɬ ɨɞɧɭ ɢ ɬɭ ɠɟ ɮɭɧɤɰɢɸ. ȼɪɹɞ ɥɢ ɜɵ
ɜɩɚɞɟɬɟ ɜ ɟɪɟɫɶ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8) ɩɪɢ ɬɚɤɨɣ ɩɪɨɫɬɨɣ ɩɟ-
ɪɟɝɪɭɡɤɟ, ɬɟɦ ɛɨɥɟɟ ɱɬɨ ɷɬɨɬ ɦɟɬɨɞ ɫɥɚɛɨ ɩɪɢɦɟɧɢɦ ɩɪɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɛɢɛɥɢɨɬɟɤ, ɤɨɝɞɚ
ɬɪɭɞɧɨ ɡɚɪɚɧɟɟ ɩɪɟɞɫɤɚɡɚɬɶ, ɤɚɤɢɟ ɢɦɟɧɧɨ ɬɢɩɵ ɛɭɞɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜ ɤɨɞɟ, ɤɪɢɬɢɱɟɫɤɨɦ ɩɨ
ɨɬɧɨɲɟɧɢɸ ɤ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ.
Ссылки
[Meyers96] §21 • [Stroustrup00] §11.4, §C.6 • [Sutter00] §6
Стр. 64
30. Избегайте перегрузки &&, || и , (запятой)
Резюме
Ɇɭɞɪɨɫɬɶ — ɷɬɨ ɡɧɚɧɢɟ ɬɨɝɨ, ɤɨɝɞɚ ɧɚɞɨ ɜɨɡɞɟɪɠɚɬɶɫɹ. ȼɫɬɪɨɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ &&, || ɢ ,
(ɡɚɩɹɬɚɹ) ɬɪɚɤɬɭɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ ɫɩɟɰɢɚɥɶɧɵɦ ɨɛɪɚɡɨɦ. ɉɨɫɥɟ ɩɟɪɟɝɪɭɡɤɢ ɨɧɢ ɫɬɚɧɨɜɹɬɫɹ
ɨɛɵɱɧɵɦɢ ɮɭɧɤɰɢɹɦɢ ɫ ɜɟɫɶɦɚ ɨɬɥɢɱɧɨɣ ɫɟɦɚɧɬɢɤɨɣ (ɩɪɢ ɷɬɨɦ ɜɵ ɧɚɪɭɲɚɟɬɟ ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ 26 ɢ 31), ɚ ɷɬɨ ɩɪɹɦɨɣ ɩɭɬɶ ɤ ɬɪɭɞɧɨɨɩɪɟɞɟɥɢɦɵɦ ɨɲɢɛɤɚɦ ɢ ɧɟɧɚɞɟɠɧɨɫɬɢ. ɇɟ ɩɟɪɟɝɪɭ-
ɠɚɣɬɟ ɷɬɢ ɨɩɟɪɚɬɨɪɵ ɛɟɡ ɤɪɚɣɧɟɣ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɢ ɝɥɭɛɨɤɨɝɨ ɩɨɧɢɦɚɧɢɹ.
Ƚɥɚɜɧɚɹ ɩɪɢɱɢɧɚ ɨɬɤɚɡɚ ɨɬ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɨɜ operator&&, operator|| ɢ operator,
(ɡɚɩɹɬɚɹ) ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɜɵ ɧɟ ɢɦɟɟɬɟ ɜɨɡɦɨɠɧɨɫɬɢ ɪɟɚɥɢɡɨɜɚɬɶ ɩɨɥɧɭɸ ɫɟɦɚɧɬɢɤɭ ɜɫɬɪɨɟɧ-
ɧɵɯ ɨɩɟɪɚɬɨɪɨɜ ɜ ɷɬɢɯ ɬɪɟɯ ɫɥɭɱɚɹɯ, ɚ ɩɪɨɝɪɚɦɦɢɫɬɵ ɨɛɵɱɧɨ ɨɠɢɞɚɸɬ ɟɟ ɜɵɩɨɥɧɟɧɢɹ. ȼ ɱɚɫɬ-
ɧɨɫɬɢ, ɜɫɬɪɨɟɧɧɵɟ ɜɟɪɫɢɢ ɜɵɩɨɥɧɹɸɬ ɜɵɱɢɫɥɟɧɢɟ ɫɥɟɜɚ ɧɚɩɪɚɜɨ, ɚ ɞɥɹ ɨɩɟɪɚɬɨɪɨɜ && ɢ || ɢɫ-
ɩɨɥɶɡɭɸɬɫɹ ɫɨɤɪɚɳɟɧɧɵɟ ɜɵɱɢɫɥɟɧɢɹ.
ȼɫɬɪɨɟɧɧɵɟ ɜɟɪɫɢɢ && ɢ || ɫɧɚɱɚɥɚ ɜɵɱɢɫɥɹɸɬ ɥɟɜɭɸ ɱɚɫɬɶ ɜɵɪɚɠɟɧɢɹ, ɢ ɟɫɥɢ ɨɧɚ ɩɨɥ-
ɧɨɫɬɶɸ ɨɩɪɟɞɟɥɹɟɬ ɪɟɡɭɥɶɬɚɬ (false ɞɥɹ &&, true ɞɥɹ ||), ɬɨ ɜɵɱɢɫɥɹɬɶ ɩɪɚɜɨɟ ɜɵɪɚɠɟɧɢɟ
ɧɟɡɚɱɟɦ — ɢ ɨɧɨ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɧɟ ɛɭɞɟɬ ɜɵɱɢɫɥɹɬɶɫɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ ɦɵ ɢɫɩɨɥɶɡɭɟɦ ɷɬɭ
ɜɨɡɦɨɠɧɨɫɬɶ, ɩɨɡɜɨɥɹɹ ɤɨɪɪɟɤɬɧɨɫɬɢ ɩɪɚɜɨɝɨ ɜɵɪɚɠɟɧɢɹ ɡɚɜɢɫɟɬɶ ɨɬ ɭɫɩɟɲɧɨɝɨ ɜɵɱɢɫɥɟɧɢɹ
ɥɟɜɨɝɨ:
Employee* e = TryToGetEmployee();
if( e && e->Manager () )
// ...
Ʉɨɪɪɟɤɬɧɨɫɬɶ ɷɬɨɝɨ ɤɨɞɚ ɨɛɭɫɥɨɜɥɟɧɚ ɬɟɦ, ɱɬɨ e->Manager() ɧɟ ɛɭɞɟɬ ɜɵɱɢɫɥɹɬɶɫɹ, ɟɫ-
ɥɢ e ɢɦɟɟɬ ɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ. ɗɬɨ ɫɨɜɟɪɲɟɧɧɨ ɨɛɵɱɧɨ ɢ ɤɨɪɪɟɤɬɧɨ — ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɧɟ ɢɫ-
ɩɨɥɶɡɭɟɬɫɹ ɩɟɪɟɝɪɭɠɟɧɧɵɣ ɨɩɟɪɚɬɨɪ operator&&, ɩɨɫɤɨɥɶɤɭ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɜɵɪɚɠɟɧɢɟ,
ɜɤɥɸɱɚɸɳɟɟ &&, ɛɭɞɟɬ ɫɥɟɞɨɜɚɬɶ ɩɪɚɜɢɥɚɦ ɮɭɧɤɰɢɢ:
• ɜɵɡɨɜɵ ɮɭɧɤɰɢɣ ɜɫɟɝɞɚ ɜɵɱɢɫɥɹɸɬ ɜɫɟ ɚɪɝɭɦɟɧɬɵ ɞɨ ɜɵɩɨɥɧɟɧɢɹ ɤɨɞɚ ɮɭɧɤɰɢɢ;
• ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɣ ɧɟ ɨɩɪɟɞɟɥɟɧ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 31).
Ⱦɚɜɚɣɬɟ ɪɚɫɫɦɨɬɪɢɦ ɦɨɞɟɪɧɢɡɢɪɨɜɚɧɧɭɸ ɜɟɪɫɢɸ ɩɪɢɜɟɞɟɧɧɨɝɨ ɪɚɧɟɟ ɮɪɚɝɦɟɧɬɚ, ɤɨɬɨɪɚɹ
ɢɫɩɨɥɶɡɭɟɬ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ:
some_smart_ptr <Employee> e = TryToGetEmployee();
if( e && e->Manager () )
// ...
ɉɭɫɬɶ ɜ ɷɬɨɦ ɤɨɞɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɟɪɟɝɪɭɠɟɧɧɵɣ ɨɩɟɪɚɬɨɪ operator&& (ɩɪɟɞɨɫɬɚɜɥɟɧɧɵɣ
ɚɜɬɨɪɨɦ some_smart_ptr ɢɥɢ Employee). Ɍɨɝɞɚ ɦɵ ɩɨɥɭɱɚɟɦ ɤɨɞ, ɤɨɬɨɪɵɣ ɞɥɹ ɱɢɬɚɬɟɥɹ
ɜɵɝɥɹɞɢɬ ɫɨɜɟɪɲɟɧɧɨ ɤɨɪɪɟɤɬɧɨ, ɧɨ ɩɨɬɟɧɰɢɚɥɶɧɨ ɦɨɠɟɬ ɜɵɡɜɚɬɶ e->Manager() ɩɪɢ ɧɭɥɟ-
ɜɨɦ ɡɧɚɱɟɧɢɢ e.
ɇɟɤɨɬɨɪɵɣ ɢɧɨɣ ɤɨɞ ɦɨɠɟɬ ɧɟ ɩɪɢɜɟɫɬɢ ɤ ɚɜɚɪɢɣɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ ɩɪɨɝɪɚɦɦɵ, ɧɨ ɫɬɚɬɶ
ɧɟɤɨɪɪɟɤɬɧɵɦ ɩɨ ɞɪɭɝɨɣ ɩɪɢɱɢɧɟ — ɢɡ-ɡɚ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɩɨɪɹɞɤɚ ɜɵɱɢɫɥɟɧɢɣ ɞɜɭɯ ɜɵɪɚɠɟ-
ɧɢɣ. Ɋɟɡɭɥɶɬɚɬ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɩɥɚɱɟɜɧɵɦ. ɇɚɩɪɢɦɟɪ:
if( DisplayPrompt () && GetLine () )
// ...
ȿɫɥɢ ɨɩɟɪɚɬɨɪ operator&& ɩɟɪɟɨɩɪɟɞɟɥɟɧ ɩɨɥɶɡɨɜɚɬɟɥɟɦ, ɬɨ ɧɟɢɡɜɟɫɬɧɨ, ɤɚɤɚɹ ɢɡ ɮɭɧɤɰɢɣ —
DisplayPrompt ɢɥɢ GetLine — ɛɭɞɟɬ ɜɵɡɜɚɧɚ ɩɟɪɜɨɣ. ɉɪɨɝɪɚɦɦɚ ɜ ɪɟɡɭɥɶɬɚɬɟ ɦɨɠɟɬ ɨɠɢɞɚɬɶ
ɜɜɨɞɚ ɩɨɥɶɡɨɜɚɬɟɥɹ ɞɨ ɬɨɝɨ, ɤɚɤ ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɩɨɹɫɧɹɸɳɟɟ ɩɪɢɝɥɚɲɟɧɢɟ.
30. Избегайте перегрузки &&, || и , (запятой) 65
Стр. 65
Ʉɨɧɟɱɧɨ, ɬɚɤɨɣ ɤɨɞ ɦɨɠɟɬ ɡɚɪɚɛɨɬɚɬɶ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜɚɲɟɝɨ ɤɨɧɤɪɟɬɧɨɝɨ ɤɨɦɩɢɥɹɬɨ-
ɪɚ ɢ ɧɚɫɬɪɨɟɤ ɫɛɨɪɤɢ. ɇɨ ɷɬɨ — ɨɱɟɧɶ ɧɟɧɚɞɟɠɧɨ. Ʉɨɦɩɢɥɹɬɨɪɵ ɦɨɝɭɬ ɜɵɛɪɚɬɶ ɥɸɛɨɣ ɩɨɪɹ-
ɞɨɤ ɜɵɱɢɫɥɟɧɢɣ (ɢ ɬɚɤ ɨɧɢ ɢ ɩɨɫɬɭɩɚɸɬ), ɤɨɬɨɪɵɣ ɫɨɱɬɭɬ ɧɭɠɧɵɦ ɞɥɹ ɞɚɧɧɨɝɨ ɤɨɧɤɪɟɬɧɨɝɨ
ɜɵɡɨɜɚ, ɩɪɢɧɢɦɚɹ ɜɨ ɜɧɢɦɚɧɢɟ ɬɚɤɢɟ ɮɚɤɬɨɪɵ, ɤɚɤ ɪɚɡɦɟɪ ɝɟɧɟɪɢɪɭɟɦɨɝɨ ɤɨɞɚ, ɞɨɫɬɭɩɧɵɟ ɪɟ-
ɝɢɫɬɪɵ, ɫɥɨɠɧɨɫɬɶ ɜɵɪɚɠɟɧɢɣ ɢ ɞɪɭɝɢɟ. Ɍɚɤ ɱɬɨ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɜɵɡɨɜ ɦɨɠɟɬ ɩɪɨɹɜɥɹɬɶ ɫɟɛɹ
ɩɨ-ɪɚɡɧɨɦɭ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɜɟɪɫɢɢ ɤɨɦɩɢɥɹɬɨɪɚ, ɧɚɫɬɪɨɟɤ ɤɨɦɩɢɥɹɰɢɢ ɢ ɞɚɠɟ ɢɧɫɬɪɭɤɰɢɣ,
ɨɤɪɭɠɚɸɳɢɯ ɞɚɧɧɵɣ ɜɵɡɨɜ.
Ɍɚ ɠɟ ɧɟɧɚɞɟɠɧɨɫɬɶ ɧɚɛɥɸɞɚɟɬɫɹ ɢ ɜ ɫɥɭɱɚɟ ɨɩɟɪɚɬɨɪɚ-ɡɚɩɹɬɨɣ. Ɍɚɤ ɠɟ, ɤɚɤ ɢ ɨɩɟɪɚɬɨɪɵ
&& ɢ ||, ɜɫɬɪɨɟɧɧɵɣ ɨɩɟɪɚɬɨɪ-ɡɚɩɹɬɚɹ ɝɚɪɚɧɬɢɪɭɟɬ, ɱɬɨ ɜɵɪɚɠɟɧɢɹ ɛɭɞɭɬ ɜɵɱɢɫɥɟɧɵ ɫɥɟɜɚ
ɧɚɩɪɚɜɨ (ɜ ɨɬɥɢɱɢɟ ɨɬ && ɢ ||, ɡɞɟɫɶ ɜɫɟɝɞɚ ɜɵɱɢɫɥɹɸɬɫɹ ɨɛɚ ɜɵɪɚɠɟɧɢɹ). ɉɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ
ɨɩɟɪɚɬɨɪ-ɡɚɩɹɬɚɹ ɧɟ ɦɨɠɟɬ ɝɚɪɚɧɬɢɪɨɜɚɬɶ ɜɵɱɢɫɥɟɧɢɣ ɫɥɟɜɚ ɧɚɩɪɚɜɨ, ɱɬɨ ɨɛɵɱɧɨ ɩɪɢɜɨɞɢɬ ɤ
ɭɞɢɜɢɬɟɥɶɧɵɦ ɪɟɡɭɥɶɬɚɬɚɦ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɜ ɫɥɟɞɭɸɳɟɦ ɤɨɞɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɨɥɶɡɨɜɚɬɟɥɶ-
ɫɤɢɣ ɨɩɟɪɚɬɨɪ-ɡɚɩɹɬɚɹ, ɬɨ ɧɟɢɡɜɟɫɬɧɨ, ɩɨɥɭɱɢɬ ɥɢ ɮɭɧɤɰɢɹ g ɚɪɝɭɦɟɧɬ 0 ɢɥɢ 1:
int i = 0;
f( i++ ), g( i ); // ǜǷ. ǽǫǵǱǰ ǻǰǵǹǷǰǸǯǫȁǳȉ 31
Примеры
ɉɪɢɦɟɪ. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɛɢɛɥɢɨɬɟɤɢ ɩɪɢ ɩɨɦɨɳɢ ɩɟɪɟɝɪɭɠɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ operator,
ɞɥɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ ɢɧɢɰɢɚɥɢɡɚɰɢɣ. ɇɟɤɨɬɨɪɚɹ ɛɢɛɥɢɨɬɟɤɚ ɩɵɬɚɟɬɫɹ ɭɩɪɨɫɬɢɬɶ ɞɨɛɚɜɥɟ-
ɧɢɟ ɧɟɫɤɨɥɶɤɢɯ ɡɧɚɱɟɧɢɣ ɜ ɤɨɧɬɟɣɧɟɪ ɡɚ ɨɞɢɧ ɪɚɡ ɩɭɬɟɦ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɚ-ɡɚɩɹɬɨɣ. ɇɚ-
ɩɪɢɦɟɪ, ɞɥɹ ɞɨɛɚɜɥɟɧɢɹ ɜ vector<string> letters:
set_cont(letters) += "a", "b";
ȼɫɟ ɜ ɩɨɪɹɞɤɟ, ɩɨɤɚ ɜ ɨɞɢɧ ɩɪɟɤɪɚɫɧɵɣ ɞɟɧɶ ɩɨɥɶɡɨɜɚɬɟɥɶ ɧɟ ɧɚɩɢɲɟɬ:
set_cont(letters) += getstr(), getstr();
// ǚǹǻȊǯǹǵ Ǹǰ ǹǺǻǰǯǰǶǰǸ Ǻǻǳ ǳǼǺǹǶȇǲǹǭǫǸǳǳ
// ǺǰǻǰǮǻǾǱǰǸǸǹǮǹ ǹǺǰǻǫǽǹǻǫ ","
ȿɫɥɢ ɮɭɧɤɰɢɹ getstr ɩɨɥɭɱɚɟɬ, ɧɚɩɪɢɦɟɪ, ɜɜɨɞ ɩɨɥɶɡɨɜɚɬɟɥɹ ɢ ɨɧ ɜɜɟɞɟɬ ɫɬɪɨɤɢ "c" ɢ
"d" ɜ ɭɤɚɡɚɧɧɨɦ ɩɨɪɹɞɤɟ, ɬɨ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɫɬɪɨɤɢ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɜɧɟɫɟɧɵ ɜ ɥɸɛɨɦ
ɩɨɪɹɞɤɟ. ɗɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɫɸɪɩɪɢɡɨɦ, ɩɨɫɤɨɥɶɤɭ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜɫɬɪɨɟɧɧɨɝɨ ɨɩɟɪɚ-
ɬɨɪɚ operator, ɬɚɤɨɣ ɩɪɨɛɥɟɦɵ ɧɟ ɜɨɡɧɢɤɚɟɬ:
string s; s = getstr(), getstr(); // ǚǹǻȊǯǹǵ ǼǽǻǹǮǹ ǹǺǻǰǯǰǶǰǸ
// Ǻǻǳ ǳǼǺǹǶȇǲǹǭǫǸǳǳ
// ǭǼǽǻǹǰǸǸǹǮǹ ǹǺǰǻǫǽǹǻǫ ","
ɂɫɤɥɸɱɟɧɢɟ — ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɛɢɛɥɢɨɬɟɤɢ ɲɚɛɥɨɧɨɜ ɞɥɹ ɧɚɭɱɧɵɯ ɜɵɱɢɫɥɟɧɢɣ, ɤɨ-
ɬɨɪɵɟ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫ ɞɢɡɚɣɧɨɦ ɩɟɪɟɨɩɪɟɞɟɥɹɸɬ ɜɫɟ ɨɩɟɪɚɬɨɪɵ.
Ссылки
[Dewhurst03] §14 • [Meyers96] §7, §25 • [Murray93] §2.4.3 • [Stroustrup00] §6.2.2
Стр. 66
31. Не пишите код, который зависит от
порядка вычислений аргументов функции
Резюме
ɉɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ, ɩɨɷɬɨɦɭ ɧɢɤɨɝɞɚ ɧɟ ɩɨɥɚɝɚɣɬɟɫɶ
ɧɚ ɬɨ, ɱɬɨ ɚɪɝɭɦɟɧɬɵ ɛɭɞɭɬ ɜɵɱɢɫɥɹɬɶɫɹ ɜ ɬɨɣ ɢɥɢ ɢɧɨɣ ɨɱɟɪɟɞɧɨɫɬɢ.
ɇɚ ɧɚɱɚɥɶɧɵɯ ɷɬɚɩɚɯ ɪɚɡɜɢɬɢɹ ɹɡɵɤɚ C ɪɟɝɢɫɬɪɵ ɩɪɨɰɟɫɫɨɪɚ ɛɵɥɢ ɞɪɚɝɨɰɟɧɧɵɦ ɪɟɫɭɪɫɨɦ
ɢ ɤɨɦɩɢɥɹɬɨɪɵ ɪɟɲɚɥɢ ɬɪɭɞɧɵɟ ɡɚɞɚɱɢ ɷɮɮɟɤɬɢɜɧɨɝɨ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɫɥɨɠɧɵɯ ɜɵɪɚɠɟ-
ɧɢɹɯ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɯ ɹɡɵɤɨɜ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɩɨɡɜɨɥɢɬɶ ɤɨɦɩɢɥɹɬɨɪɭ ɝɟɧɟɪɢɪɨɜɚɬɶ ɛɨɥɟɟ
ɛɵɫɬɪɵɣ ɤɨɞ, ɫɨɡɞɚɬɟɥɢ C ɞɚɥɢ ɪɚɫɩɪɟɞɟɥɢɬɟɥɸ ɪɟɝɢɫɬɪɨɜ ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ ɫɬɟɩɟɧɶ ɫɜɨɛɨɞɵ.
ɉɪɢ ɜɵɡɨɜɟ ɮɭɧɤɰɢɢ ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɟɟ ɚɪɝɭɦɟɧɬɨɜ ɨɫɬɚɜɚɥɫɹ ɧɟɨɩɪɟɞɟɥɟɧɧɵɦ. ɗɬɚ ɚɪ-
ɝɭɦɟɧɬɚɰɢɹ, ɜɟɪɨɹɬɧɨ, ɫɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɜɚɠɧɚ ɜ ɧɚɫɬɨɹɳɟɟ ɜɪɟɦɹ, ɧɨ ɝɥɚɜɧɨɟ, ɱɬɨ ɩɨɪɹɞɨɤ
ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɣ ɜ C++ ɧɟ ɨɩɪɟɞɟɥɟɧ ɢ ɜɚɪɶɢɪɭɟɬɫɹ ɨɬ ɤɨɦɩɢɥɹɬɨɪɚ ɤ ɤɨɦɩɢ-
ɥɹɬɨɪɭ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 30).
ȼ ɫɜɹɡɢ ɫ ɷɬɢɦ ɧɟɨɛɞɭɦɚɧɧɵɟ ɞɟɣɫɬɜɢɹ ɩɪɨɝɪɚɦɦɢɫɬɚ ɦɨɝɭɬ ɩɪɢɜɟɫɬɢ ɤ ɛɨɥɶɲɢɦ ɧɟɩɪɢ-
ɹɬɧɨɫɬɹɦ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
void Transmogrify( int, int );
int count = 5;
Transmogrify( ++count, ++count ); // ǚǹǻȊǯǹǵ ǭȆȂǳǼǶǰǸǳǴ
// ǸǰǳǲǭǰǼǽǰǸ
ȼɫɟ, ɱɬɨ ɦɵ ɦɨɠɟɦ ɫɤɚɡɚɬɶ ɨɩɪɟɞɟɥɟɧɧɨɝɨ, — ɷɬɨ ɬɨ, ɱɬɨ ɩɪɢ ɜɯɨɞɟ ɜ ɬɟɥɨ ɮɭɧɤɰɢɢ
Transmogrify ɡɧɚɱɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ count ɛɭɞɟɬ ɪɚɜɧɨ 7 — ɧɨ ɦɵ ɧɟ ɦɨɠɟɦ ɫɤɚɡɚɬɶ, ɤɚɤɨɣ
ɚɪɝɭɦɟɧɬ ɛɭɞɟɬ ɪɚɜɟɧ 6, ɚ ɤɚɤɨɣ — 7. ɗɬɚ ɧɟɨɩɪɟɞɟɥɟɧɧɨɫɬɶ ɨɫɬɚɟɬɫɹ ɢ ɜ ɝɨɪɚɡɞɨ ɦɟɧɟɟ ɨɱɟ-
ɜɢɞɧɵɯ ɫɥɭɱɚɹɯ, ɬɚɤɢɯ ɤɚɤ ɮɭɧɤɰɢɢ, ɦɨɞɢɮɢɰɢɪɭɸɳɢɟ ɫɜɨɢ ɚɪɝɭɦɟɧɬɵ (ɢɥɢ ɧɟɤɨɬɨɪɨɟ ɝɥɨ-
ɛɚɥɶɧɨɟ ɫɨɫɬɨɹɧɢɟ) ɜ ɤɚɱɟɫɬɜɟ ɩɨɛɨɱɧɨɝɨ ɞɟɣɫɬɜɢɹ:
int Bump( int& x ) { return ++x; }
Transmogrify( Bump(count), Bump(count) ); // ǛǰǲǾǶȇǽǫǽ
// ǸǰǳǲǭǰǼǽǰǸ
ɋɨɝɥɚɫɧɨ ɪɟɤɨɦɟɧɞɚɰɢɢ 10, ɫɥɟɞɭɟɬ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɢɡɛɟɝɚɬɶ ɝɥɨɛɚɥɶɧɵɯ ɢ ɫɨɜɦɟɫɬɧɨ
ɢɫɩɨɥɶɡɭɟɦɵɯ ɩɟɪɟɦɟɧɧɵɯ. ɇɨ ɞɚɠɟ ɟɫɥɢ ɜɵ ɛɥɚɝɨɩɨɥɭɱɧɨ ɭɫɬɪɚɧɢɬɟ ɢɯ, ɧɟɤɨɬɨɪɵɣ ɞɪɭɝɨɣ
ɤɨɞ ɦɨɠɟɬ ɷɬɨɝɨ ɧɟ ɫɞɟɥɚɬɶ. ɇɚɩɪɢɦɟɪ, ɧɟɤɨɬɨɪɵɟ ɫɬɚɧɞɚɪɬɧɵɟ ɮɭɧɤɰɢɢ ɢɦɟɸɬ ɩɨɛɨɱɧɵɟ
ɞɟɣɫɬɜɢɹ (ɧɚɩɪɢɦɟɪ, strtok, ɚ ɬɚɤɠɟ ɪɚɡɧɵɟ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ operator<<, ɩɪɢ-
ɧɢɦɚɸɳɢɟ ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɚ ostream).
Ɋɟɰɟɩɬ ɨɱɟɧɶ ɩɪɨɫɬ — ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɟɧɨɜɚɧɧɵɟ ɨɛɴɟɤɬɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɨɛɟɫɩɟɱɢɬɶ
ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13):
int bumped = ++count;
Transmogrify( bumped, ++count ); // ǍǼǰ ǭ ǺǹǻȊǯǵǰ
Ссылки
[Alexandrescu00c] • [Cline99] §31.03-05 • [Dewhurst03] §14-15 • [Meyers96] §9-10 •
[Stroustrup00] §6.2.2, §14.4.1 • [Sutter00] §16 • [Sutter02] §20-21
31. Не пишите код, который зависит от порядка вычислений аргументов функции 67
Стр. 67
68
Стр. 68
Проектирование классов
и наследование
ɇɚɢɛɨɥɟɟ ɜɚɠɧɵɣ ɚɫɩɟɤɬ ɪɚɡɪɚɛɨɬɤɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟ-
ɧɢɹ — ɹɫɧɨ ɩɨɧɢɦɚɬɶ, ɱɬɨ ɢɦɟɧɧɨ ɜɵ ɩɵɬɚɟɬɟɫɶ ɩɨɫɬɪɨɢɬɶ.
— Ȼɶɹɪɧ ɋɬɪɚɭɫɬɪɭɩ (Bjarne Stroustrup)
Ʉɚɤɨɝɨ ɜɢɞɚ ɤɥɚɫɫɵ ɩɪɟɞɩɨɱɢɬɚɟɬ ɪɚɡɪɚɛɚɬɵɜɚɬɶ ɢ ɫɬɪɨɢɬɶ ɜɚɲɚ ɤɨɦɚɧɞɚ? ɉɨɱɟɦɭ?

ɂɧɬɟɪɟɫɧɨ, ɱɬɨ ɛɨɥɶɲɢɧɫɬɜɨ ɪɟɤɨɦɟɧɞɚɰɢɣ ɞɚɧɧɨɝɨ ɪɚɡɞɟɥɚ ɜɵɡɜɚɧɵ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ
ɜɨɩɪɨɫɚɦɢ ɡɚɜɢɫɢɦɨɫɬɟɣ. ɇɚɩɪɢɦɟɪ, ɧɚɫɥɟɞɨɜɚɧɢɟ — ɜɬɨɪɚɹ ɩɨ ɫɢɥɟ ɜɡɚɢɦɨɫɜɹɡɶ, ɤɨɬɨɪɭɸ
ɦɨɠɧɨ ɜɵɪɚɡɢɬɶ ɜ C++ (ɩɟɪɜɚɹ — ɨɬɧɨɲɟɧɢɟ ɞɪɭɠɛɵ), ɢ ɬɚɤɭɸ ɫɢɥɶɧɭɸ ɫɜɹɡɶ ɧɚɞɨ ɢɫɩɨɥɶ-
ɡɨɜɚɬɶ ɨɱɟɧɶ ɨɫɬɨɪɨɠɧɨ ɢ ɩɪɨɞɭɦɚɧɧɨ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɤɨɧɰɟɧɬɪɢɪɭɟɦ ɜɧɢɦɚɧɢɟ ɧɚ ɤɥɸɱɟɜɵɯ ɜɨɩɪɨɫɚɯ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
ɤɥɚɫɫɨɜ — ɤɚɤ ɫɞɟɥɚɬɶ ɷɬɨ ɩɪɚɜɢɥɶɧɨ, ɤɚɤ ɧɟ ɞɨɩɭɫɬɢɬɶ ɨɲɢɛɤɭ, ɢɡɛɟɠɚɬɶ ɥɨɜɭɲɟɤ, ɢ ɜ ɨɫɨ-
ɛɟɧɧɨɫɬɢ — ɤɚɤ ɭɩɪɚɜɥɹɬɶ ɡɚɜɢɫɢɦɨɫɬɹɦɢ.
ȼ ɫɥɟɞɭɸɳɟɦ ɪɚɡɞɟɥɟ ɦɵ ɨɛɪɚɬɢɦɫɹ ɤ Ȼɨɥɶɲɨɣ ɑɟɬɜɟɪɤɟ ɫɩɟɰɢɚɥɶɧɵɯ ɮɭɧɤɰɢɣ — ɤɨɧɫɬɪɭɤ-
ɬɨɪɭ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɤɨɩɢɪɭɸɳɟɦɭ ɤɨɧɫɬɪɭɤɬɨɪɭ, ɤɨɩɢɪɭɸɳɟɦɭ ɩɪɢɫɜɚɢɜɚɧɢɸ ɢ ɞɟɫɬɪɭɤɬɨɪɭ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɫɚɦɨɣ ɜɚɠɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 33 — “ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɦɢɧɢ-
ɦɚɥɶɧɵɟ ɤɥɚɫɫɵ ɦɨɧɨɥɢɬɧɵɦ”.
31. Не пишите код, который зависит от порядка вычислений аргументов функции 69
Стр. 69
32. Ясно представляйте, какой вид класса
вы создаете
Резюме
ɋɭɳɟɫɬɜɭɟɬ ɛɨɥɶɲɨɟ ɤɨɥɢɱɟɫɬɜɨ ɪɚɡɥɢɱɧɵɯ ɜɢɞɨɜ ɤɥɚɫɫɨɜ, ɢ ɫɥɟɞɭɟɬ ɡɧɚɬɶ, ɤɚɤɨɣ ɢɦɟɧɧɨ
ɤɥɚɫɫ ɜɵ ɫɨɡɞɚɟɬɟ.
Ɋɚɡɥɢɱɧɵɟ ɜɢɞɵ ɤɥɚɫɫɨɜ ɫɥɭɠɚɬ ɞɥɹ ɪɚɡɥɢɱɧɵɯ ɰɟɥɟɣ ɢ, ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɥɟɞɭɸɬ ɪɚɡɥɢɱ-
ɧɵɦ ɩɪɚɜɢɥɚɦ.
Ʉɥɚɫɫɵ-ɡɧɚɱɟɧɢɹ (ɧɚɩɪɢɦɟɪ, std::pair, std::vector) ɦɨɞɟɥɢɪɭɸɬ ɜɫɬɪɨɟɧɧɵɟ ɬɢɩɵ.
ɗɬɢ ɤɥɚɫɫɵ ɨɛɥɚɞɚɸɬ ɫɥɟɞɭɸɳɢɦɢ ɫɜɨɣɫɬɜɚɦɢ.
• ɂɦɟɸɬ ɨɬɤɪɵɬɵɟ ɞɟɫɬɪɭɤɬɨɪ, ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɢ ɩɪɢɫɜɚɢɜɚɧɢɟ ɫ ɫɟɦɚɧɬɢɤɨɣ
ɡɧɚɱɟɧɢɹ.
• ɇɟ ɢɦɟɸɬ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ (ɜɤɥɸɱɚɹ ɞɟɫɬɪɭɤɬɨɪ).
• ɉɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɚɱɟɫɬɜɟ ɤɨɧɤɪɟɬɧɵɯ ɤɥɚɫɫɨɜ, ɧɨ ɧɟ ɜ ɤɚɱɟɫɬɜɟ
ɛɚɡɨɜɵɯ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 35).
• Ɉɛɵɱɧɨ ɪɚɡɦɟɳɚɸɬɫɹ ɜ ɫɬɟɤɟ ɢɥɢ ɹɜɥɹɸɬɫɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɵɦɢ ɱɥɟɧɚɦɢ ɞɪɭɝɨɝɨ
ɤɥɚɫɫɚ.
Ȼɚɡɨɜɵɟ ɤɥɚɫɫɵ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɫɬɪɨɢɬɟɥɶɧɵɟ ɛɥɨɤɢ ɢɟɪɚɪɯɢɢ ɤɥɚɫɫɨɜ. Ȼɚɡɨɜɵɣ
ɤɥɚɫɫ ɨɛɥɚɞɚɟɬ ɫɥɟɞɭɸɳɢɦɢ ɫɜɨɣɫɬɜɚɦɢ.
• ɂɦɟɟɬ ɞɟɫɬɪɭɤɬɨɪ, ɤɨɬɨɪɵɣ ɹɜɥɹɟɬɫɹ ɥɢɛɨ ɨɬɤɪɵɬɵɦ ɢ ɜɢɪɬɭɚɥɶɧɵɦ, ɥɢɛɨ ɡɚɳɢ-
ɳɟɧɧɵɦ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50), ɚ ɬɚɤɠɟ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤ-
ɬɨɪ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɨɬɤɪɵɬɵɦɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 53).
• Ɉɩɪɟɞɟɥɹɟɬ ɢɧɬɟɪɮɟɣɫ ɩɨɫɪɟɞɫɬɜɨɦ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ.
• Ɉɛɵɱɧɨ ɨɛɴɟɤɬɵ ɬɚɤɨɝɨ ɤɥɚɫɫɚ ɫɨɡɞɚɸɬɫɹ ɞɢɧɚɦɢɱɟɫɤɢ ɜ ɤɭɱɟ ɤɚɤ ɱɚɫɬɶ ɨɛɴɟɤɬɚ ɩɪɨ-
ɢɡɜɨɞɧɨɝɨ ɤɥɚɫɫɚ ɢ ɢɫɩɨɥɶɡɭɸɬɫɹ ɩɨɫɪɟɞɫɬɜɨɦ (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ) ɭɤɚɡɚɬɟɥɟɣ.
Ƚɨɜɨɪɹ ɭɩɪɨɳɟɧɧɨ, ɤɥɚɫɫɵ ɫɜɨɣɫɬɜ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɲɚɛɥɨɧɵ, ɤɨɬɨɪɵɟ ɧɟɫɭɬ ɢɧɮɨɪ-
ɦɚɰɢɸ ɨ ɬɢɩɚɯ. Ʉɥɚɫɫ ɫɜɨɣɫɬɜ ɨɛɥɚɞɚɟɬ ɫɥɟɞɭɸɳɢɦɢ ɯɚɪɚɤɬɟɪɢɫɬɢɤɚɦɢ.
• ɋɨɞɟɪɠɢɬ ɬɨɥɶɤɨ ɨɩɟɪɚɬɨɪɵ typedef ɢ ɫɬɚɬɢɱɟɫɤɢɟ ɮɭɧɤɰɢɢ. Ʉɥɚɫɫ ɧɟ ɢɦɟɟɬ ɦɨɞɢ-
ɮɢɰɢɪɭɟɦɨɝɨ ɫɨɫɬɨɹɧɢɹ ɢɥɢ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ.
• Ɉɛɵɱɧɨ ɨɛɴɟɤɬɵ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ ɧɟ ɫɨɡɞɚɸɬɫɹ (ɤɨɧɫɬɪɭɤɬɨɪɵ ɦɨɝɭɬ ɛɵɬɶ ɡɚɛɥɨɤɢ-
ɪɨɜɚɧɵ).
Ʉɥɚɫɫɵ ɫɬɪɚɬɟɝɢɣ (ɨɛɵɱɧɨ ɲɚɛɥɨɧɵ) ɹɜɥɹɸɬɫɹ ɮɪɚɝɦɟɧɬɚɦɢ ɫɦɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ. Ʉɥɚɫɫɵ
ɫɬɪɚɬɟɝɢɣ ɨɛɥɚɞɚɸɬ ɫɥɟɞɭɸɳɢɦɢ ɫɜɨɣɫɬɜɚɦɢ.
• Ɇɨɝɭɬ ɢɦɟɬɶ ɫɨɫɬɨɹɧɢɹ ɢ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ, ɧɨ ɦɨɝɭɬ ɢ ɧɟ ɢɦɟɬɶ ɢɯ.
• Ɉɛɵɱɧɨ ɨɛɴɟɤɬɵ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ ɧɟ ɫɨɡɞɚɸɬɫɹ, ɢ ɨɧ ɜɵɫɬɭɩɚɟɬ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɨɝɨ
ɤɥɚɫɫɚ ɢɥɢ ɱɥɟɧɚ ɞɪɭɝɨɝɨ ɤɥɚɫɫɚ.
70 Проектирование классов и наследование
Стр. 70
Ʉɥɚɫɫɵ ɢɫɤɥɸɱɟɧɢɣ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɧɟɨɛɵɱɧɭɸ ɫɦɟɫɶ ɫɟɦɚɧɬɢɤɢ ɡɧɚɱɟɧɢɣ ɢ ɫɫɵɥɨɤ.
ɉɪɢ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɨɧɢ ɩɟɪɟɞɚɸɬɫɹ ɩɨ ɡɧɚɱɟɧɢɸ, ɧɨ ɞɨɥɠɧɵ ɩɟɪɟɯɜɚɬɵɜɚɬɶɫɹ ɩɨ
ɫɫɵɥɤɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 73). Ʉɥɚɫɫɵ ɢɫɤɥɸɱɟɧɢɣ ɨɛɥɚɞɚɸɬ ɫɥɟɞɭɸɳɢɦɢ ɫɜɨɣɫɬɜɚɦɢ.
• ɂɦɟɸɬ ɨɬɤɪɵɬɵɣ ɞɟɫɬɪɭɤɬɨɪ ɢ ɤɨɧɫɬɪɭɤɬɨɪɵ, ɧɟ ɝɟɧɟɪɢɪɭɸɳɢɟ ɢɫɤɥɸɱɟɧɢɣ (ɜ ɨɫɨ-
ɛɟɧɧɨɫɬɢ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ, ɝɟɧɟɪɚɰɢɹ ɢɫɤɥɸɱɟɧɢɹ ɜ ɤɨɬɨɪɨɦ ɩɪɢɜɨɞɢɬ ɤ ɡɚ-
ɜɟɪɲɟɧɢɸ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ).
• ɂɦɟɸɬ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɢ ɱɚɫɬɨ ɪɟɚɥɢɡɭɸɬ ɤɥɨɧɢɪɨɜɚɧɢɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 54).
• ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɞɟɥɚɬɶ ɢɯ ɩɪɨɢɡɜɨɞɧɵɦɢ ɨɬ std::exception.
ȼɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɤɥɚɫɫɵ ɨɛɵɱɧɨ ɩɨɞɞɟɪɠɢɜɚɸɬ ɨɬɞɟɥɶɧɵɟ ɢɞɢɨɦɵ (ɧɚɩɪɢɦɟɪ, RAII —

ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13). ȼɚɠɧɨ, ɱɬɨɛɵ ɢɯ ɤɨɪɪɟɤɬɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟ ɛɵɥɨ ɫɨɩɪɹɠɟɧɨ ɫ ɤɚ-
ɤɢɦɢ-ɥɢɛɨ ɬɪɭɞɧɨɫɬɹɦɢ ɢ ɧɚɨɛɨɪɨɬ — ɱɬɨɛɵ ɩɪɢɦɟɧɹɬɶ ɢɯ ɧɟɤɨɪɪɟɤɬɧɨ ɛɵɥɨ ɨɱɟɧɶ ɬɪɭɞɧɨ
(ɧɚɩɪɢɦɟɪ, ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 53).
Ссылки
[Abrahams01b] • [Alexandrescu00a] • [Alexandrescu00b] • [Alexandrescu01] §3 • [Meyers96] §13 •
[Stroustrup00] §8.3.2, §10.3, §14.4.6, §25.1 • [Vandevoorde03] §15
32. Ясно представляйте, какой вид класса вы создаете 71
Стр. 71
33. Предпочитайте минимальные классы
монолитным
Резюме
Ɋɚɡɞɟɥɹɣ ɢ ɜɥɚɫɬɜɭɣ: ɧɟɛɨɥɶɲɢɟ ɤɥɚɫɫɵ ɥɟɝɱɟ ɩɢɫɚɬɶ, ɬɟɫɬɢɪɨɜɚɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ. Ɉɧɢ
ɬɚɤɠɟ ɩɪɢɦɟɧɢɦɵ ɜ ɛɨɥɶɲɟɦ ɤɨɥɢɱɟɫɬɜɟ ɫɢɬɭɚɰɢɣ. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɬɚɤɢɟ ɧɟɛɨɥɶɲɢɟ ɤɥɚɫɫɵ,
ɤɨɬɨɪɵɟ ɜɨɩɥɨɳɚɸɬ ɩɪɨɫɬɵɟ ɤɨɧɰɟɩɰɢɢ, ɤɥɚɫɫɚɦ, ɩɵɬɚɸɳɢɦɫɹ ɪɟɚɥɢɡɨɜɚɬɶ ɤɚɤ ɧɟɫɤɨɥɶɤɨ
ɤɨɧɰɟɩɰɢɣ, ɬɚɤ ɢ ɫɥɨɠɧɵɟ ɤɨɧɰɟɩɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 5 ɢ 6).
Ɋɚɡɪɚɛɨɬɤɚ ɛɨɥɶɲɢɯ ɩɪɢɱɭɞɥɢɜɵɯ ɤɥɚɫɫɨɜ — ɬɢɩɢɱɧɚɹ ɨɲɢɛɤɚ ɧɨɜɢɱɤɚ ɜ ɨɛɴɟɤɬɧɨ-
ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ. ɉɟɪɫɩɟɤɬɢɜɚ ɢɦɟɬɶ ɤɥɚɫɫ, ɤɨɬɨɪɵɣ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɩɨɥɧɭɸ
ɢ ɫɥɨɠɧɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ “ɜ ɨɞɧɨɦ ɮɥɚɤɨɧɟ”, ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɨɱɟɧɶ ɩɪɢɜɥɟɤɚɬɟɥɶɧɨɣ.
Ɉɞɧɚɤɨ ɩɨɞɯɨɞ, ɫɨɫɬɨɹɳɢɣ ɜ ɪɚɡɪɚɛɨɬɤɟ ɧɟɛɨɥɶɲɢɯ, ɦɢɧɢɦɚɥɶɧɵɯ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɥɟɝɤɨ
ɤɨɦɛɢɧɢɪɨɜɚɬɶ, ɧɚ ɩɪɚɤɬɢɤɟ ɩɨ ɪɹɞɭ ɩɪɢɱɢɧ ɨɤɚɡɵɜɚɟɬɫɹ ɛɨɥɟɟ ɭɫɩɟɲɟɧ ɞɥɹ ɫɢɫɬɟɦ ɥɸɛɨɝɨ
ɪɚɡɦɟɪɚ ɢ ɫɥɨɠɧɨɫɬɢ.
• Ɇɢɧɢɦɚɥɶɧɵɣ ɤɥɚɫɫ ɜɨɩɥɨɳɚɟɬ ɨɞɧɭ ɤɨɧɰɟɩɰɢɸ ɧɚ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɦ ɭɪɨɜɧɟ ɞɟɬɚɥɢ-
ɡɚɰɢɢ. Ɇɨɧɨɥɢɬɧɵɣ ɤɥɚɫɫ ɨɛɵɱɧɨ ɜɤɥɸɱɚɟɬ ɧɟɫɤɨɥɶɤɨ ɨɬɞɟɥɶɧɵɯ ɤɨɧɰɟɩɰɢɣ, ɢ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɟ ɬɨɥɶɤɨ ɨɞɧɨɣ ɢɡ ɧɢɯ ɜɥɟɱɟɬ ɡɚ ɫɨɛɨɣ ɢɡɥɢɲɧɢɟ ɧɚɤɥɚɞɧɵɟ ɪɚɫɯɨɞɵ (ɫɦ.
ɪɟɤɨɦɟɧɞɚɰɢɢ 5 ɢ 11).
• Ɇɢɧɢɦɚɥɶɧɵɣ ɤɥɚɫɫ ɥɟɝɱɟ ɩɨɧɹɬɶ ɢ ɩɪɨɳɟ ɢɫɩɨɥɶɡɨɜɚɬɶ (ɜ ɬɨɦ ɱɢɫɥɟ ɩɨɜɬɨɪɧɨ).
• Ɇɢɧɢɦɚɥɶɧɵɣ ɤɥɚɫɫ ɩɪɨɳɟ ɜ ɭɩɨɬɪɟɛɥɟɧɢɢ. Ɇɨɧɨɥɢɬɧɵɣ ɤɥɚɫɫ ɱɚɫɬɨ ɞɨɥɠɟɧ ɢɫɩɨɥɶ-
ɡɨɜɚɬɶɫɹ ɤɚɤ ɛɨɥɶɲɨɟ ɧɟɞɟɥɢɦɨɟ ɰɟɥɨɟ. ɇɚɩɪɢɦɟɪ, ɦɨɧɨɥɢɬɧɵɣ ɤɥɚɫɫ Matrix ɦɨɠɟɬ
ɩɨɩɵɬɚɬɶɫɹ ɪɟɚɥɢɡɨɜɚɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɤɡɨɬɢɱɟɫɤɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ — ɬɚɤɭɸ ɤɚɤ
ɜɵɱɢɫɥɟɧɢɟ ɫɨɛɫɬɜɟɧɧɵɯ ɡɧɚɱɟɧɢɣ ɦɚɬɪɢɰɵ — ɞɚɠɟ ɟɫɥɢ ɛɨɥɶɲɢɧɫɬɜɭ ɩɨɥɶɡɨɜɚɬɟɥɟɣ
ɷɬɨɝɨ ɤɥɚɫɫɚ ɬɪɟɛɭɸɬɫɹ ɜɫɟɝɨ ɥɢɲɶ ɚɡɵ ɥɢɧɟɣɧɨɣ ɚɥɝɟɛɪɵ. Ʌɭɱɲɢɦ ɜɚɪɢɚɧɬɨɦ ɛɭɞɟɬ
ɪɟɚɥɢɡɚɰɢɹ ɪɚɡɥɢɱɧɵɯ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɥɚɫɬɟɣ ɜ ɜɢɞɟ ɮɭɧɤɰɢɣ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ
ɱɥɟɧɚɦɢ, ɤɨɬɨɪɵɟ ɪɚɛɨɬɚɸɬ ɫ ɦɢɧɢɦɚɥɶɧɵɦ ɬɢɩɨɦ Matrix. Ɍɨɝɞɚ ɷɬɢ ɮɭɧɤɰɢɨɧɚɥɶ-
ɧɵɟ ɨɛɥɚɫɬɢ ɦɨɝɭɬ ɛɵɬɶ ɩɪɨɬɟɫɬɢɪɨɜɚɧɵ ɢ ɢɫɩɨɥɶɡɨɜɚɧɵ ɨɬɞɟɥɶɧɨ ɬɨɥɶɤɨ ɬɟɦɢ ɩɨɥɶ-
ɡɨɜɚɬɟɥɹɦɢ, ɤɬɨ ɜ ɧɢɯ ɧɭɠɞɚɟɬɫɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44).
• Ɇɨɧɨɥɢɬɧɵɟ ɤɥɚɫɫɵ ɫɧɢɠɚɸɬ ɢɧɤɚɩɫɭɥɹɰɢɸ. ȿɫɥɢ ɤɥɚɫɫ ɢɦɟɟɬ ɦɧɨɝɨ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɤɨ-
ɬɨɪɵɟ ɧɟ ɨɛɹɡɚɧɵ ɛɵɬɶ ɱɥɟɧɚɦɢ, ɧɨ ɬɟɦ ɧɟ ɦɟɧɟɟ ɹɜɥɹɸɬɫɹ ɬɚɤɨɜɵɦɢ (ɬɚɤɢɦ ɨɛɪɚɡɨɦ ɨɛɟɫ-
ɩɟɱɢɜɚɟɬɫɹ ɢɡɥɢɲɧɹɹ ɜɢɞɢɦɨɫɬɶ ɡɚɤɪɵɬɨɣ ɪɟɚɥɢɡɚɰɢɢ), ɬɨ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ-ɞɚɧɧɵɟ ɤɥɚɫɫɚ
ɫɬɚɧɨɜɹɬɫɹ ɩɨɱɬɢ ɫɬɨɥɶ ɠɟ ɩɥɨɯɢɦɢ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɞɢɡɚɣɧɚ, ɤɚɤ ɢ ɨɬɤɪɵɬɵɟ ɩɟɪɟɦɟɧɧɵɟ.
• Ɇɨɧɨɥɢɬɧɵɟ ɤɥɚɫɫɵ ɨɛɵɱɧɨ ɹɜɥɹɸɬɫɹ ɪɟɡɭɥɶɬɚɬɨɦ ɩɨɩɵɬɨɤ ɩɪɟɞɫɤɚɡɚɬɶ ɢ ɩɪɟɞɨɫɬɚ-
ɜɢɬɶ “ɩɨɥɧɨɟ” ɪɟɲɟɧɢɟ ɧɟɤɨɬɨɪɨɣ ɩɪɨɛɥɟɦɵ; ɧɚ ɩɪɚɤɬɢɤɟ ɠɟ ɬɚɤɢɟ ɞɟɣɫɬɜɢɹ ɩɨɱɬɢ
ɧɢɤɨɝɞɚ ɧɟ ɩɪɢɜɨɞɹɬ ɤ ɭɫɩɟɲɧɨɦɭ ɪɟɡɭɥɶɬɚɬɭ.
• Ɇɨɧɨɥɢɬɧɵɟ ɤɥɚɫɫɵ ɫɥɨɠɧɟɟ ɫɞɟɥɚɬɶ ɤɨɪɪɟɤɬɧɵɦɢ ɢ ɛɟɡɨɩɚɫɧɵɦɢ ɜ ɫɜɹɡɢ ɫ ɬɟɦ, ɱɬɨ ɩɪɢ
ɢɯ ɪɚɡɪɚɛɨɬɤɟ ɡɚɱɚɫɬɭɸ ɧɚɪɭɲɚɟɬɫɹ ɩɪɢɧɰɢɩ “Ɉɞɢɧ ɨɛɴɟɤɬ — ɨɞɧɚ ɡɚɞɚɱɚ” (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɢ 5 ɢ 44).
Ссылки
[Cargill92] pp. 85-86, 152, 174-177 • [Lakos96] §0.2.1-2, §1.8, §8.1-2 • [Meyers97] §18 •
[Stroustrup00] §16.2.2, §23.4.3.2, §24.4.3 • [Sutter04] §37-40
Стр. 72
34. Предпочитайте композицию
наследованию
Резюме
ɂɡɛɟɝɚɣɬɟ “ɧɚɥɨɝɚ ɧɚ ɧɚɫɥɟɞɫɬɜɨ”: ɧɚɫɥɟɞɨɜɚɧɢɟ — ɜɬɨɪɚɹ ɩɨ ɫɢɥɟ ɩɨɫɥɟ ɨɬɧɨɲɟɧɢɹ
ɞɪɭɠɛɵ ɜɡɚɢɦɨɫɜɹɡɶ, ɤɨɬɨɪɭɸ ɦɨɠɧɨ ɜɵɪɚɡɢɬɶ ɜ C++. ɋɢɥɶɧɵɟ ɫɜɹɡɢ ɧɟɠɟɥɚɬɟɥɶɧɵ, ɢ ɢɯ
ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ ɜɟɡɞɟ, ɝɞɟ ɬɨɥɶɤɨ ɦɨɠɧɨ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɢɬɚɬɶ ɤɨɦɩɨɡɢɰɢɸ
ɧɚɫɥɟɞɨɜɚɧɢɸ, ɤɪɨɦɟ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɜɵ ɬɨɱɧɨ ɡɧɚɟɬɟ, ɱɬɨ ɞɟɥɚɟɬɟ ɢ ɤɚɤɢɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɞɚɟɬ
ɧɚɫɥɟɞɨɜɚɧɢɟ ɜ ɜɚɲɟɦ ɩɪɨɟɤɬɟ.
ɇɚɫɥɟɞɨɜɚɧɢɟɦ ɱɚɫɬɨ ɡɥɨɭɩɨɬɪɟɛɥɹɸɬ ɞɚɠɟ ɨɩɵɬɧɵɟ ɪɚɡɪɚɛɨɬɱɢɤɢ. Ƚɥɚɜɧɨɟ ɩɪɚɜɢɥɨ ɜ ɪɚɡ-
ɪɚɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ — ɫɧɢɠɟɧɢɟ ɫɜɹɡɧɨɫɬɢ. ȿɫɥɢ ɜɡɚɢɦɨɨɬɧɨɲɟɧɢɟ ɦɨɠɧɨ ɜɵ-
ɪɚɡɢɬɶ ɧɟɫɤɨɥɶɤɢɦɢ ɫɩɨɫɨɛɚɦɢ, ɢɫɩɨɥɶɡɭɣɬɟ ɫɚɦɭɸ ɫɥɚɛɭɸ ɢɡ ɜɨɡɦɨɠɧɵɯ ɜɡɚɢɦɨɫɜɹɡɟɣ.
ɂɡɜɟɫɬɧɨ, ɱɬɨ ɧɚɫɥɟɞɨɜɚɧɢɟ — ɩɪɚɤɬɢɱɟɫɤɢ ɫɚɦɨɟ ɫɢɥɶɧɨɟ ɜɡɚɢɦɨɨɬɧɨɲɟɧɢɟ, ɤɨɬɨɪɨɟ
ɦɨɠɧɨ ɜɵɪɚɡɢɬɶ ɫɪɟɞɫɬɜɚɦɢ C++; ɫɢɥɶɧɟɟ ɟɝɨ ɬɨɥɶɤɨ ɨɬɧɨɲɟɧɢɟ ɞɪɭɠɛɵ, ɢ ɩɨɥɶɡɨɜɚɬɶɫɹ ɢɦ
ɫɥɟɞɭɟɬ ɬɨɥɶɤɨ ɩɪɢ ɨɬɫɭɬɫɬɜɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɨ ɷɤɜɢɜɚɥɟɧɬɧɨɣ ɛɨɥɟɟ ɫɥɚɛɨɣ ɚɥɶɬɟɪɧɚɬɢɜɵ.
ȿɫɥɢ ɜɵ ɦɨɠɟɬɟ ɜɵɪɚɡɢɬɶ ɨɬɧɨɲɟɧɢɹ ɤɥɚɫɫɨɜ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɬɨɥɶɤɨ ɥɢɲɶ ɤɨɦɩɨɡɢɰɢɢ,
ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɬɨɬ ɫɩɨɫɨɛ.
ȼ ɞɚɧɧɨɦ ɤɨɧɬɟɤɫɬɟ “ɤɨɦɩɨɡɢɰɢɹ” ɨɡɧɚɱɚɟɬ ɩɪɨɫɬɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɤɨɬɨɪɨɝɨ ɬɢɩɚ ɜ ɜɢ-
ɞɟ ɩɟɪɟɦɟɧɧɨɣ-ɱɥɟɧɚ ɜ ɞɪɭɝɨɦ ɬɢɩɟ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɜɵ ɦɨɠɟɬɟ ɯɪɚɧɢɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɴɟɤɬ
ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɤɨɬɨɪɵɣ ɨɛɟɫɩɟɱɢɜɚɟɬ ɜɚɦ ɤɨɧɬɪɨɥɶ ɧɚɞ ɫɬɟɩɟɧɶɸ ɜɡɚɢɦɨɫɜɹɡɢ.
Ʉɨɦɩɨɡɢɰɢɹ ɢɦɟɟɬ ɜɚɠɧɵɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɧɚɞ ɧɚɫɥɟɞɨɜɚɧɢɟɦ.
• Ȼɨɥɶɲɚɹ ɝɢɛɤɨɫɬɶ ɛɟɡ ɜɥɢɹɧɢɹ ɧɚ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ: ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ-ɞɚɧɧɵɟ ɧɚɯɨɞɹɬ-
ɫɹ ɩɨɞ ɩɨɥɧɵɦ ɜɚɲɢɦ ɤɨɧɬɪɨɥɟɦ. ȼɵ ɦɨɠɟɬɟ ɯɪɚɧɢɬɶ ɢɯ ɩɨ ɡɧɚɱɟɧɢɸ, ɩɨɫɪɟɞɫɬɜɨɦ
(ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɝɨ) ɭɤɚɡɚɬɟɥɹ ɢɥɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 43), ɩɪɢ ɷɬɨɦ ɩɟɪɟɯɨɞ ɨɬ ɨɞɧɨɝɨ ɫɩɨɫɨɛɚ ɯɪɚɧɟɧɢɹ ɤ ɞɪɭɝɨɦɭ ɧɢɤɚɤ ɧɟ ɜɥɢɹɟɬ ɧɚ
ɤɨɞ ɜɵɡɵɜɚɸɳɟɣ ɮɭɧɤɰɢɢ: ɜɫɟ, ɱɬɨ ɩɪɢ ɷɬɨɦ ɦɟɧɹɟɬɫɹ, — ɷɬɨ ɪɟɚɥɢɡɚɰɢɹ ɮɭɧɤɰɢɣ-
ɱɥɟɧɨɜ ɤɥɚɫɫɚ, ɢɫɩɨɥɶɡɭɸɳɢɯ ɭɩɨɦɹɧɭɬɵɟ ɱɥɟɧɵ-ɞɚɧɧɵɟ. ȿɫɥɢ ɜɵ ɪɟɲɢɬɟ, ɱɬɨ ɜɚɦ
ɬɪɟɛɭɟɬɫɹ ɢɧɚɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ, ɜɵ ɦɨɠɟɬɟ ɥɟɝɤɨ ɢɡɦɟɧɢɬɶ ɬɢɩ ɢɥɢ ɫɩɨɫɨɛ ɯɪɚɧɟ-
ɧɢɹ ɱɥɟɧɚ ɩɪɢ ɩɨɥɧɨɣ ɫɨɯɪɚɧɧɨɫɬɢ ɨɬɤɪɵɬɨɝɨ ɢɧɬɟɪɮɟɣɫɚ. ȿɫɥɢ ɠɟ ɜɵ ɧɚɱɧɟɬɟ ɫ ɨɬ-
ɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ, ɬɨ ɫɤɨɪɟɟ ɜɫɟɝɨ ɜɵ ɧɟ ɫɦɨɠɟɬɟ ɥɟɝɤɨ ɢ ɩɪɨɫɬɨ ɢɡɦɟɧɢɬɶ ɜɚɲ
ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɜ ɫɥɭɱɚɟ ɧɟɨɛɯɨɞɢɦɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 37).
• Ȼɨɥɶɲɚɹ ɨɛɨɫɨɛɥɟɧɧɨɫɬɶ ɜ ɩɪɨɰɟɫɫɟ ɤɨɦɩɢɥɹɰɢɢ, ɭɦɟɧɶɲɟɧɢɟ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ.
ɏɪɚɧɟɧɢɟ ɨɛɴɟɤɬɚ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ (ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ — ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɝɨ ɭɤɚ-
ɡɚɬɟɥɹ), ɚ ɧɟ ɜ ɜɢɞɟ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɱɥɟɧɚ ɢɥɢ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɩɨɡɜɨɥɹɟɬ ɬɚɤɠɟ
ɫɧɢɡɢɬɶ ɡɚɜɢɫɢɦɨɫɬɢ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ, ɩɨɫɤɨɥɶɤɭ ɨɛɴɹɜɥɟɧɢɟ ɭɤɚɡɚɬɟɥɹ ɧɚ ɨɛɴɟɤɬ
ɧɟ ɬɪɟɛɭɟɬ ɩɨɥɧɨɝɨ ɨɩɪɟɞɟɥɟɧɢɹ ɤɥɚɫɫɚ ɷɬɨɝɨ ɨɛɴɟɤɬɚ. ɇɚɫɥɟɞɨɜɚɧɢɟ, ɧɚɩɪɨɬɢɜ, ɜɫɟɝɞɚ
ɬɪɟɛɭɟɬ ɜɢɞɢɦɨɫɬɢ ɩɨɥɧɨɝɨ ɨɩɪɟɞɟɥɟɧɢɹ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɦɟɬɨɞɢɤɚ
ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨɛɵ ɫɨɛɪɚɬɶ ɜɫɟ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ ɜɨɟɞɢɧɨ ɩɨɫɪɟɞɫɬɜɨɦ ɨɞɧɨɝɨ ɧɟɩɪɨ-
ɡɪɚɱɧɨɝɨ ɭɤɚɡɚɬɟɥɹ (ɢɞɢɨɦɚ Pimpl, ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 43).
• Ɇɟɧɶɲɟ ɫɬɪɚɧɧɨɫɬɟɣ. ɇɚɫɥɟɞɨɜɚɧɢɟ ɨɬ ɧɟɤɨɬɨɪɨɝɨ ɬɢɩɚ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɩɪɨɜɟɞɟɧɢɟ ɩɨ-
ɢɫɤɚ ɢɦɟɧ ɫɪɟɞɢ ɮɭɧɤɰɢɣ ɢ ɲɚɛɥɨɧɨɜ ɮɭɧɤɰɢɣ, ɨɩɪɟɞɟɥɟɧɧɵɯ ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ
ɢɦɟɧ, ɱɬɨ ɢ ɭɩɨɦɹɧɭɬɵɣ ɬɢɩ. ɗɬɨɬ ɬɨɧɤɢɣ ɦɨɦɟɧɬ ɫ ɬɪɭɞɨɦ ɩɨɞɞɚɟɬɫɹ ɨɬɥɚɞɤɟ (ɫɦ. ɬɚɤɠɟ
ɪɟɤɨɦɟɧɞɚɰɢɸ 58).
34. Предпочитайте композицию наследованию 73
Стр. 73
• Ȼɨɥɶɲɚɹ ɩɪɢɦɟɧɢɦɨɫɬɶ. ɇɟ ɜɫɟ ɤɥɚɫɫɵ ɩɪɨɟɤɬɢɪɭɸɬɫɹ ɫ ɭɱɟɬɨɦ ɬɨɝɨ, ɱɬɨ ɨɧɢ ɛɭɞɭɬ
ɜɵɫɬɭɩɚɬɶ ɜ ɪɨɥɢ ɛɚɡɨɜɵɯ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 35). Ɉɞɧɚɤɨ ɛɨɥɶɲɢɧɫɬɜɨ ɤɥɚɫɫɨɜ ɜɩɨɥ-
ɧɟ ɦɨɝɭɬ ɫɩɪɚɜɢɬɶɫɹ ɫ ɪɨɥɶɸ ɱɥɟɧɚ.
• Ȼɨɥɶɲɚɹ ɧɚɞɟɠɧɨɫɬɶ ɢ ɛɟɡɨɩɚɫɧɨɫɬɶ. Ȼɨɥɟɟ ɫɢɥɶɧɨɟ ɫɜɹɡɵɜɚɧɢɟ ɩɭɬɟɦ ɧɚɫɥɟɞɨɜɚɧɢɹ
ɡɚɬɪɭɞɧɹɟɬ ɧɚɩɢɫɚɧɢɟ ɛɟɡɨɩɚɫɧɨɝɨ ɜ ɫɦɵɫɥɟ ɨɲɢɛɨɤ ɤɨɞɚ (ɫɦ. [Sutter02] §23).
• Ɇɟɧɶɲɚɹ ɫɥɨɠɧɨɫɬɶ ɢ ɯɪɭɩɤɨɫɬɶ. ɇɚɫɥɟɞɨɜɚɧɢɟ ɩɪɢɜɨɞɢɬ ɤ ɞɨɩɨɥɧɢɬɟɥɶɧɵɦ ɭɫɥɨɠ-
ɧɟɧɢɹɦ, ɬɚɤɢɦ ɤɚɤ ɫɨɤɪɵɬɢɟ ɢɦɟɧ ɢ ɞɪɭɝɢɦ, ɜɨɡɧɢɤɚɸɳɢɦ ɩɪɢ ɜɧɟɫɟɧɢɢ ɢɡɦɟɧɟɧɢɣ
ɜ ɛɚɡɨɜɵɣ ɤɥɚɫɫ.
Ʉɨɧɟɱɧɨ, ɷɬɨ ɜɫɟ ɧɟ ɚɪɝɭɦɟɧɬɵ ɩɪɨɬɢɜ ɧɚɫɥɟɞɨɜɚɧɢɹ ɤɚɤ ɬɚɤɨɜɨɝɨ. ɇɚɫɥɟɞɨɜɚɧɢɟ ɩɪɟɞɨɫ-
ɬɚɜɥɹɟɬ ɩɪɨɝɪɚɦɦɢɫɬɭ ɛɨɥɶɲɢɟ ɜɨɡɦɨɠɧɨɫɬɢ, ɜɤɥɸɱɚɹ ɡɚɦɟɧɢɦɨɫɬɶ ɢ/ɢɥɢ ɜɨɡɦɨɠɧɨɫɬɶ ɩɟɪɟ-
ɤɪɵɬɢɹ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 36 ɩɨ 39 ɢ ɩɨɞɪɚɡɞɟɥ ɢɫɤɥɸɱɟɧɢɣ ɞɚɧɧɨɣ
ɪɟɤɨɦɟɧɞɚɰɢɢ). ɇɨ ɧɟ ɩɥɚɬɢɬɟ ɡɚ ɬɨ, ɱɬɨ ɜɚɦ ɧɟ ɧɭɠɧɨ; ɟɫɥɢ ɜɵ ɦɨɠɟɬɟ ɨɛɨɣɬɢɫɶ ɛɟɡ ɧɚɫɥɟɞɨ-
ɜɚɧɢɹ, ɜɚɦ ɧɟɡɚɱɟɦ ɦɢɪɢɬɶɫɹ ɫ ɟɝɨ ɧɟɞɨɫɬɚɬɤɚɦɢ.
ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɞɥɹ ɦɨɞɟɥɢɪɨɜɚɧɢɹ ɡɚɦɟɧɢɦɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 37).
Ⱦɚɠɟ ɟɫɥɢ ɨɬ ɜɚɫ ɧɟ ɬɪɟɛɭɟɬɫɹ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɨɬɧɨɲɟɧɢɹ ɡɚɦɟɧɢɦɨɫɬɢ ɜɵɡɵɜɚɸɳɢɦ
ɮɭɧɤɰɢɹɦ, ɜɚɦ ɦɨɠɟɬ ɩɨɧɚɞɨɛɢɬɶɫɹ ɡɚɤɪɵɬɨɟ ɢɥɢ ɡɚɳɢɳɟɧɧɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɜ ɩɟɪɟɱɢɫɥɟɧ-
ɧɵɯ ɞɚɥɟɟ ɫɢɬɭɚɰɢɹɯ (ɦɵ ɩɨɫɬɚɪɚɥɢɫɶ ɯɨɬɹ ɛɵ ɝɪɭɛɨ ɨɬɫɨɪɬɢɪɨɜɚɬɶ ɢɯ ɜ ɩɨɪɹɞɤɟ ɭɦɟɧɶɲɟɧɢɹ
ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɫɬɢ).
• ȿɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɩɟɪɟɤɪɵɬɢɟ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ.
• ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ ɞɨɫɬɭɩ ɤ ɡɚɳɢɳɟɧɧɨɦɭ ɱɥɟɧɭ.
• ȿɫɥɢ ɜɚɦ ɧɚɞɨ ɫɨɡɞɚɜɚɬɶ ɨɛɴɟɤɬ ɞɨ ɢɫɩɨɥɶɡɭɟɦɨɝɨ, ɚ ɭɧɢɱɬɨɠɚɬɶ — ɩɨɫɥɟ, ɫɞɟɥɚɣɬɟ
ɟɝɨ ɛɚɡɨɜɵɦ ɤɥɚɫɫɨɦ.
• ȿɫɥɢ ɜɚɦ ɩɪɢɯɨɞɢɬɫɹ ɡɚɛɨɬɢɬɶɫɹ ɨ ɜɢɪɬɭɚɥɶɧɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ.
• ȿɫɥɢ ɜɵ ɡɧɚɟɬɟ, ɱɬɨ ɩɨɥɭɱɢɬɟ ɜɵɝɨɞɭ ɨɬ ɨɩɬɢɦɢɡɚɰɢɢ ɩɭɫɬɨɝɨ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɢ ɱɬɨ ɜ ɜɚ-
ɲɟɦ ɫɥɭɱɚɟ ɨɧɚ ɛɭɞɟɬ ɜɵɩɨɥɧɟɧɚ ɢɫɩɨɥɶɡɭɟɦɵɦ ɜɚɦɢ ɤɨɦɩɢɥɹɬɨɪɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8).
• ȿɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɭɩɪɚɜɥɹɟɦɵɣ ɩɨɥɢɦɨɪɮɢɡɦ, ɬ.ɟ. ɨɬɧɨɲɟɧɢɟ ɡɚɦɟɧɢɦɨɫɬɢ, ɤɨɬɨɪɨɟ
ɞɨɥɠɧɨ ɛɵɬɶ ɜɢɞɢɦɨ ɬɨɥɶɤɨ ɨɩɪɟɞɟɥɟɧɧɨɦɭ ɤɨɞɭ (ɩɨɫɪɟɞɫɬɜɨɦ ɞɪɭɠɛɵ).
Ссылки
[Cargill92] pp. 49-65, 101-105 • [Cline99] §5.9-10, 8.11-12, 37.04 • [Dewhurst03] §95 •
[Lakos96] §1.7, §6.3.1 • [McConnell93] §5 • [Meyers97] §40 • [Stroustrup00] §24.2-3 •
[Sutter00] §22-24, §26-30 • [Sutter02] §23
Стр. 74
35. Избегайте наследования от классов,
которые не спроектированы для этой
цели
Резюме
Ʉɥɚɫɫɵ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ ɞɥɹ ɚɜɬɨɧɨɦɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɩɨɞɱɢɧɹɸɬɫɹ ɩɪɚɜɢɥɚɦ ɩɪɨɟɤ-
ɬɢɪɨɜɚɧɢɹ, ɨɬɥɢɱɧɵɦ ɨɬ ɩɪɚɜɢɥ ɞɥɹ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 32). ɂɫɩɨɥɶɡɨɜɚɧɢɟ
ɚɜɬɨɧɨɦɧɵɯ ɤɥɚɫɫɨɜ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɵɯ ɹɜɥɹɟɬɫɹ ɫɟɪɶɟɡɧɨɣ ɨɲɢɛɤɨɣ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɢ ɟɝɨ
ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ. Ⱦɥɹ ɞɨɛɚɜɥɟɧɢɹ ɫɩɟɰɢɮɢɱɟɫɤɨɝɨ ɩɨɜɟɞɟɧɢɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɜɦɟɫɬɨ ɮɭɧɤ-
ɰɢɣ-ɱɥɟɧɨɜ ɞɨɛɚɜɥɹɬɶ ɨɛɵɱɧɵɟ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44). Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɞɨɛɚɜɢɬɶ
ɫɨɫɬɨɹɧɢɟ, ɜɦɟɫɬɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɦɩɨɡɢɰɢɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 34).
ɂɡɛɟɝɚɣɬɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ ɤɨɧɤɪɟɬɧɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ.
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɬɚɦ, ɝɞɟ ɨɧɨ ɧɟ ɬɪɟɛɭɟɬɫɹ, ɩɨɞɪɵɜɚɟɬ ɞɨɜɟɪɢɟ ɤ ɦɨɳɢ ɨɛɴ-
ɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. ȼ C++ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɫɥɟɞɭɟɬ
ɜɵɩɨɥɧɢɬɶ ɧɟɤɨɬɨɪɵɟ ɫɩɟɰɢɮɢɱɟɫɤɢɟ ɞɟɣɫɬɜɢɹ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 32, 50 ɢ 54), ɤɨɬɨ-
ɪɵɟ ɜɟɫɶɦɚ ɫɢɥɶɧɨ ɨɬɥɢɱɚɸɬɫɹ (ɚ ɡɚɱɚɫɬɭɸ ɩɪɨɫɬɨ ɩɪɨɬɢɜɨɩɨɥɨɠɧɵ) ɨɬ ɞɟɣɫɬɜɢɣ ɩɪɢ ɪɚɡɪɚ-
ɛɨɬɤɟ ɚɜɬɨɧɨɦɧɨɝɨ ɤɥɚɫɫɚ. ɇɚɫɥɟɞɨɜɚɧɢɟ ɨɬ ɚɜɬɨɧɨɦɧɨɝɨ ɤɥɚɫɫɚ ɨɬɤɪɵɜɚɟɬ ɜɚɲ ɤɨɞ ɞɥɹ ɦɚɫ-
ɫɵ ɩɪɨɛɥɟɦ, ɩɪɢɱɟɦ ɜɚɲ ɤɨɦɩɢɥɹɬɨɪ ɜ ɫɨɫɬɨɹɧɢɢ ɡɚɦɟɬɢɬɶ ɬɨɥɶɤɨ ɢɯ ɦɚɥɭɸ ɱɚɫɬɶ.
ɇɚɱɢɧɚɸɳɢɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɡɚɱɚɫɬɭɸ ɜɵɩɨɥɧɹɸɬ ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɬ ɤɥɚɫɫɨɜ-ɡɧɚɱɟɧɢɣ, ɬɚ-
ɤɢɯ ɤɚɤ ɤɥɚɫɫ string (ɫɬɚɧɞɚɪɬɧɵɣ ɢɥɢ ɢɧɨɣ) ɩɪɨɫɬɨ ɱɬɨɛɵ “ɞɨɛɚɜɢɬɶ ɛɨɥɶɲɟ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɨɫɬɢ”. Ɉɞɧɚɤɨ ɨɩɪɟɞɟɥɟɧɢɟ ɫɜɨɛɨɞɧɨɣ ɮɭɧɤɰɢɢ (ɧɟ ɹɜɥɹɸɳɟɣɫɹ ɱɥɟɧɨɦ) ɫɭɳɟɫɬɜɟɧɧɨ
ɩɪɟɜɨɫɯɨɞɢɬ ɫɨɡɞɚɧɢɟ ɤɥɚɫɫɚ super_string ɩɨ ɫɥɟɞɭɸɳɢɦ ɩɪɢɱɢɧɚɦ.
• ɋɜɨɛɨɞɧɵɟ ɮɭɧɤɰɢɢ ɯɨɪɨɲɨ ɜɩɢɫɵɜɚɸɬɫɹ ɜ ɫɭɳɟɫɬɜɭɸɳɢɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɪɚɛɨɬɚɟɬ
ɫ ɨɛɴɟɤɬɚɦɢ string. ȿɫɥɢ ɠɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɜɵ ɩɪɟɞɨɫɬɚɜɥɹɟɬɟ ɤɥɚɫɫ super_string,
ɜɚɦ ɩɪɢɞɟɬɫɹ ɜɧɨɫɢɬɶ ɢɡɦɟɧɟɧɢɹ ɜ ɜɚɲ ɤɨɞ, ɡɚɦɟɧɹɹ ɬɢɩɵ ɢ ɫɢɝɧɚɬɭɪɵ ɮɭɧɤɰɢɣ.
• Ɏɭɧɤɰɢɢ ɢɧɬɟɪɮɟɣɫɚ, ɤɨɬɨɪɵɟ ɩɨɥɭɱɚɸɬ ɩɚɪɚɦɟɬɪɵ ɬɢɩɚ string, ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ
ɧɚɫɥɟɞɨɜɚɧɢɹ ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ ɨɞɧɨ ɢɡ ɬɪɟɯ: ɚ) ɨɬɤɚɡɚɬɶɫɹ ɨɬ ɞɨɩɨɥɧɢɬɟɥɶɧɨɣ ɮɭɧɤ-
ɰɢɨɧɚɥɶɧɨɫɬɢ super_string (ɛɟɫɩɨɥɟɡɧɨ), ɛ) ɤɨɩɢɪɨɜɚɬɶ ɫɜɨɢ ɚɪɝɭɦɟɧɬɵ ɜ ɨɛɴɟɤɬɵ
super_string (ɪɚɫɬɨɱɢɬɟɥɶɧɨ) ɢɥɢ ɜ) ɩɪɟɨɛɪɚɡɨɜɚɬɶ ɫɫɵɥɤɢ ɧɚ string ɜ ɫɫɵɥɤɢ ɧɚ
super_string (ɡɚɬɪɭɞɧɢɬɟɥɶɧɨ ɢ ɩɨɬɟɧɰɢɚɥɶɧɨ ɧɟɤɨɪɪɟɤɬɧɨ).
• Ɏɭɧɤɰɢɢ-ɱɥɟɧɵ super_string ɧɟ ɞɨɥɠɧɵ ɩɨɥɭɱɢɬɶ ɛɨɥɶɲɢɣ ɞɨɫɬɭɩ ɤ ɜɧɭɬɪɟɧɧɟɦɭ
ɭɫɬɪɨɣɫɬɜɭ ɤɥɚɫɫɚ string, ɱɟɦ ɫɜɨɛɨɞɧɵɟ ɮɭɧɤɰɢɢ, ɩɨɫɤɨɥɶɤɭ ɤɥɚɫɫ string, ɜɟɪɨɹɬ-
ɧɨ, ɧɟ ɢɦɟɟɬ ɡɚɳɢɳɟɧɧɵɯ (protected) ɱɥɟɧɨɜ (ɜɫɩɨɦɧɢɬɟ — ɷɬɨɬ ɤɥɚɫɫ ɧɟ ɩɪɟɞɧɚ-
ɡɧɚɱɚɥɫɹ ɞɥɹ ɪɚɛɨɬɵ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɨɝɨ).
• ȿɫɥɢ ɤɥɚɫɫ super_string ɫɤɪɵɜɚɟɬ ɧɟɤɨɬɨɪɵɟ ɢɡ ɮɭɧɤɰɢɣ ɤɥɚɫɫɚ string (ɚ ɩɟɪɟɨɩ-
ɪɟɞɟɥɟɧɢɟ ɧɟɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɜ ɩɪɨɢɡɜɨɞɧɨɦ ɤɥɚɫɫɟ ɧɟ ɹɜɥɹɟɬɫɹ ɩɟɪɟɤɪɵɬɢɟɦ —
ɷɬɨ ɩɪɨɫɬɨ ɫɨɤɪɵɬɢɟ), ɷɬɨ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɧɟɪɚɡɛɟɪɢɯɭ ɜ ɤɨɞɟ, ɪɚɛɨɬɚɸɳɟɦ ɫ ɨɛɴɟɤɬɚ-
ɦɢ string, ɤɨɬɨɪɵɟ ɫɨɡɞɚɸɬɫɹ ɚɜɬɨɦɚɬɢɱɟɫɤɢɦ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɢɡ ɤɥɚɫɫɚ
super_string.
ɋɥɨɜɨɦ, ɥɭɱɲɟ ɞɨɛɚɜɥɹɬɶ ɧɨɜɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɩɨɫɪɟɞɫɬɜɨɦ ɧɨɜɵɯ ɫɜɨɛɨɞɧɵɯ (ɧɟ ɹɜ-
ɥɹɸɳɢɯɫɹ ɱɥɟɧɚɦɢ) ɮɭɧɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44). ɑɬɨɛɵ ɢɡɛɟɠɚɬɶ ɩɪɨɛɥɟɦ ɩɨɢɫɤɚ ɢɦɟɧ,
ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɩɨɦɟɫɬɢɥɢ ɮɭɧɤɰɢɢ ɜ ɬɨ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɱɬɨ ɢ ɬɢɩ, ɞɥɹ ɪɚɫɲɢɪɟɧɢɹ
35. Избегайте наследования от классов, которые не спроектированы для этой цели 75
Стр. 75
ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɤɨɬɨɪɨɝɨ ɨɧɢ ɩɪɟɞɧɚɡɧɚɱɟɧɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ɇɟɤɨɬɨɪɵɟ ɩɪɨ-
ɝɪɚɦɦɢɫɬɵ ɧɟ ɥɸɛɹɬ ɫɜɨɛɨɞɧɵɟ ɮɭɧɤɰɢɢ ɢɡ-ɡɚ ɢɯ ɫɢɧɬɚɤɫɢɫɚ Fun(str) ɜɦɟɫɬɨ str.Fun(),
ɧɨ ɷɬɨ ɧɟ ɛɨɥɟɟ ɱɟɦ ɜɨɩɪɨɫ ɩɪɢɜɵɱɤɢ.
ɇɨ ɱɬɨ ɟɫɥɢ ɤɥɚɫɫ super_string ɧɚɫɥɟɞɭɟɬɫɹ ɢɡ ɤɥɚɫɫɚ string ɞɥɹ ɞɨɛɚɜɥɟɧɢɹ ɫɨɫɬɨɹɧɢɣ,
ɬɚɤɢɯ ɤɚɤ ɤɨɞɢɪɨɜɤɚ ɢɥɢ ɤɷɲɢɪɨɜɚɧɧɨɟ ɡɧɚɱɟɧɢɟ ɤɨɥɢɱɟɫɬɜɚ ɫɥɨɜ? Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɧɟ
ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɢ ɜ ɷɬɨɦ ɫɥɭɱɚɟ, ɩɨɫɤɨɥɶɤɭ ɤɥɚɫɫ string ɧɟ ɡɚɳɢɳɟɧ ɨɬ ɫɪɟɡɤɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 54), ɢ ɥɸɛɨɟ ɤɨɩɢɪɨɜɚɧɢɟ super_string ɜ string ɦɨɥɱɚ ɭɛɟɪɟɬ ɜɫɟ ɫɬɚɪɚɬɟɥɶɧɨ ɯɪɚɧɢ-
ɦɵɟ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɫɨɫɬɨɹɧɢɹ.
ɂ ɧɚɤɨɧɟɰ, ɧɚɫɥɟɞɨɜɚɧɢɟ ɤɥɚɫɫɚ ɫ ɨɬɤɪɵɬɵɦ ɧɟɜɢɪɬɭɚɥɶɧɵɦ ɞɟɫɬɪɭɤɬɨɪɨɦ ɪɢɫɤɭɟɬ ɩɨɥɭ-
ɱɢɬɶ ɷɮɮɟɤɬ ɧɟɨɩɪɟɞɟɥɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ ɩɪɢ ɭɞɚɥɟɧɢɢ ɭɤɚɡɚɬɟɥɹ ɧɚ ɨɛɴɟɤɬ ɬɢɩɚ string, ɤɨ-
ɬɨɪɵɣ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɭɤɚɡɵɜɚɟɬ ɧɚ ɨɛɴɟɤɬ ɬɢɩɚ super_string (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50). ɗɬɨ
ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ ɦɨɠɟɬ ɞɚɠɟ ɨɤɚɡɚɬɶɫɹ ɜɩɨɥɧɟ ɞɨɩɭɫɬɢɦɵɦ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜɚ-
ɲɟɝɨ ɤɨɦɩɢɥɹɬɨɪɚ ɢ ɪɚɫɩɪɟɞɟɥɢɬɟɥɹ ɩɚɦɹɬɢ, ɧɨ ɨɧɨ ɜɫɟ ɪɚɜɧɨ ɪɚɧɨ ɢɥɢ ɩɨɡɞɧɨ ɜɵɹɜɢɬɫɹ
ɜ ɜɢɞɟ ɡɚɬɚɢɜɲɢɯɫɹ ɨɲɢɛɨɤ, ɭɬɟɱɟɤ ɩɚɦɹɬɢ, ɪɚɡɪɭɲɟɧɧɨɣ ɤɭɱɢ ɢ ɤɨɲɦɚɪɨɜ ɩɟɪɟɧɨɫɚ ɧɚ ɞɪɭ-
ɝɭɸ ɩɥɚɬɮɨɪɦɭ.
Примеры
ɉɪɢɦɟɪ 1. Ʉɨɦɩɨɡɢɰɢɹ ɜɦɟɫɬɨ ɨɬɤɪɵɬɨɝɨ ɢɥɢ ɡɚɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ. ɑɬɨ ɞɟɥɚɬɶ, ɟɫɥɢ
ɜɚɦ ɧɭɠɟɧ ɬɢɩ localized_string, ɤɨɬɨɪɵɣ “ɩɨɱɬɢ ɬɚɤɨɣ ɠɟ, ɤɚɤ ɢ string, ɧɨ ɫ ɞɨɩɨɥɧɢ-
ɬɟɥɶɧɵɦɢ ɞɚɧɧɵɦɢ ɢ ɮɭɧɤɰɢɹɦɢ ɢ ɧɟɛɨɥɶɲɢɦɢ ɩɟɪɟɞɟɥɤɚɦɢ ɢɦɟɸɳɢɯɫɹ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ
string”, ɢ ɩɪɢ ɷɬɨɦ ɪɟɚɥɢɡɚɰɢɹ ɦɧɨɝɢɯ ɮɭɧɤɰɢɣ ɨɫɬɚɟɬɫɹ ɧɟɢɡɦɟɧɧɨɣ? ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɪɟɚɥɢ-
ɡɭɣɬɟ ɟɟ ɫ ɩɨɦɨɳɶɸ ɤɥɚɫɫɚ string, ɧɨ ɧɟ ɧɚɫɥɟɞɨɜɚɧɢɟɦ, ɚ ɤɨɦɛɢɧɢɪɨɜɚɧɢɟɦ (ɱɬɨ ɩɪɟɞɭɩɪɟ-
ɞɢɬ ɫɪɟɡɤɭ ɢ ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɥɢɦɨɪɮɧɨɟ ɭɞɚɥɟɧɢɟ), ɢ ɞɨɛɚɜɶɬɟ ɬɪɚɧɡɢɬɧɵɟ ɮɭɧɤɰɢɢ ɞɥɹ
ɬɨɝɨ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɜɢɞɢɦɵɦɢ ɮɭɧɤɰɢɢ ɤɥɚɫɫɚ string, ɨɫɬɚɜɲɢɟɫɹ ɧɟɢɡɦɟɧɧɵɦɢ:
class localized_string {
public:
// ... ǙǬǰǼǺǰȂȇǽǰ ǽǻǫǸǲǳǽǸȆǰ ǿǾǸǵȁǳǳ ǯǶȊ ǽǰȀ
// ǿǾǸǵȁǳǴ-ȂǶǰǸǹǭ string, ǵǹǽǹǻȆǰ ǹǼǽǫȉǽǼȊ ǸǰǳǲǷǰǸǸȆǷǳ
// (ǸǫǺǻǳǷǰǻ, ǹǺǻǰǯǰǶǳǽǰ ǿǾǸǵȁǳȉ insert, ǵǹǽǹǻǫȊ
// ǭȆǲȆǭǫǰǽ impl_.insert) ...
void clear(); // ǗǫǼǵǳǻǾǰǽ/ǺǰǻǰǹǺǻǰǯǰǶȊǰǽ clear()
bool is_in_klingon() const; // ǏǹǬǫǭǶȊǰǽ ǿǾǸǵȁǳǹǸǫǶȇǸǹǼǽȇ
private:
std::string impl_;
// ... ǏǹǺǹǶǸǳǽǰǶȇǸȆǰ ǯǫǸǸȆǰ-ȂǶǰǸȆ ...
};
Ʉɨɧɟɱɧɨ, ɩɢɫɚɬɶ ɬɪɚɧɡɢɬɧɵɟ ɮɭɧɤɰɢɢ ɞɥɹ ɜɫɟɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɤɨɬɨɪɵɟ ɜɵ ɯɨɬɢɬɟ ɫɨ-
ɯɪɚɧɢɬɶ, — ɡɚɧɹɬɢɟ ɭɬɨɦɢɬɟɥɶɧɨɟ, ɧɨ ɡɚɬɨ ɬɚɤɚɹ ɪɟɚɥɢɡɚɰɢɹ ɫɭɳɟɫɬɜɟɧɧɨ ɥɭɱɲɟ ɢ ɛɟɡɨɩɚɫɧɟɟ,
ɱɟɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɨɬɤɪɵɬɨɝɨ ɢɥɢ ɡɚɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ.
ɉɪɢɦɟɪ 2. std::unary_function. ɏɨɬɹ ɤɥɚɫɫ std::unary_function ɧɟ ɢɦɟɟɬ ɜɢɪɬɭ-
ɚɥɶɧɵɯ ɮɭɧɤɰɢɣ, ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɨɧ ɫɨɡɞɚɧ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɢ ɧɟ
ɩɪɨɬɢɜɨɪɟɱɢɬ ɪɚɫɫɦɚɬɪɢɜɚɟɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ. (Ɉɞɧɚɤɨ ɤɥɚɫɫ unary_function ɦɨɠɟɬ ɛɵɬɶ
ɭɫɨɜɟɪɲɟɧɫɬɜɨɜɚɧ ɞɨɛɚɜɥɟɧɢɟɦ ɡɚɳɢɳɟɧɧɨɝɨ ɞɟɫɬɪɭɤɬɨɪɚ — ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50.)
Ссылки
[Dewhurst03] §70, §93 • [Meyers97] §33 • [Stroustrup00] §24.2-3, §25.2
Стр. 76
36. Предпочитайте предоставление
абстрактных интерфейсов
Резюме
ȼɵ ɥɸɛɢɬɟ ɚɛɫɬɪɚɤɰɢɨɧɢɡɦ? Ⱥɛɫɬɪɚɤɬɧɵɟ ɢɧɬɟɪɮɟɣɫɵ ɩɨɦɨɝɚɸɬ ɜɚɦ ɫɨɫɪɟɞɨɬɨɱɢɬɶɫɹ ɧɚ
ɩɪɨɛɥɟɦɚɯ ɩɪɚɜɢɥɶɧɨɝɨ ɚɛɫɬɪɚɝɢɪɨɜɚɧɢɹ, ɧɟ ɜɞɚɜɚɹɫɶ ɜ ɞɟɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ ɢɥɢ ɭɩɪɚɜɥɟɧɢɹ
ɫɨɫɬɨɹɧɢɹɦɢ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɪɨɟɤɬɢɪɨɜɚɬɶ ɢɟɪɚɪɯɢɢ, ɪɟɚɥɢɡɭɸɳɢɟ ɚɛɫɬɪɚɤɬɧɵɟ ɢɧɬɟɪ-
ɮɟɣɫɵ, ɤɨɬɨɪɵɟ ɦɨɞɟɥɢɪɭɸɬ ɚɛɫɬɪɚɤɬɧɵɟ ɤɨɧɰɟɩɰɢɢ.
ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɩɪɟɞɟɥɹɬɶ ɚɛɫɬɪɚɤɬɧɵɟ ɢɧɬɟɪɮɟɣɫɵ ɢ ɜɵɩɨɥɧɹɬɶ ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɬ ɧɢɯ.
Ⱥɛɫɬɪɚɤɬɧɵɣ ɢɧɬɟɪɮɟɣɫ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɚɛɫɬɪɚɤɬɧɵɣ ɤɥɚɫɫ, ɫɨɫɬɚɜɥɟɧɧɵɣ ɩɨɥɧɨɫɬɶɸ ɢɡ
(ɱɢɫɬɨ) ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɢ ɧɟ ɨɛɥɚɞɚɸɳɢɣ ɫɨɫɬɨɹɧɢɹɦɢ (ɱɥɟɧɚɦɢ-ɞɚɧɧɵɦɢ), ɩɪɢɱɟɦ
ɨɛɵɱɧɨ ɛɟɡ ɪɟɚɥɢɡɚɰɢɢ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɨɬɫɭɬɫɬɜɢɟ ɫɨɫɬɨɹɧɢɣ ɜ ɚɛɫɬɪɚɤɬɧɨɦ
ɢɧɬɟɪɮɟɣɫɟ ɭɩɪɨɳɚɟɬ ɞɢɡɚɣɧ ɜɫɟɣ ɢɟɪɚɪɯɢɢ (ɫɦ. ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɩɪɢɦɟɪɵ ɜ [Meyers96]).
ɀɟɥɚɬɟɥɶɧɨ ɫɥɟɞɨɜɚɬɶ ɩɪɢɧɰɢɩɭ ɢɧɜɟɪɫɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ (Dependency Inversion Principle,
DIP; ɫɦ. [Martin96a] ɢ [Martin00]). Ⱦɚɧɧɵɣ ɩɪɢɧɰɢɩ ɫɨɫɬɨɢɬ ɜ ɫɥɟɞɭɸɳɟɦ.
• ȼɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɦɨɞɭɥɢ ɧɟ ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ ɨɬ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ. ɂ ɬɟ, ɢ ɞɪɭɝɢɟ
ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ ɨɬ ɚɛɫɬɪɚɤɰɢɣ.
• Ⱥɛɫɬɪɚɤɰɢɢ ɧɟ ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ ɨɬ ɞɟɬɚɥɟɣ; ɜɦɟɫɬɨ ɷɬɨɝɨ ɞɟɬɚɥɢ ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ ɨɬ
ɚɛɫɬɪɚɤɰɢɣ.
ɂɡ DIP ɫɥɟɞɭɟɬ, ɱɬɨ ɤɨɪɧɹɦɢ ɢɟɪɚɪɯɢɣ ɞɨɥɠɧɵ ɛɵɬɶ ɚɛɫɬɪɚɤɬɧɵɟ ɤɥɚɫɫɵ, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ
ɤɨɧɤɪɟɬɧɵɟ ɤɥɚɫɫɵ ɜ ɷɬɨɣ ɪɨɥɢ ɜɵɫɬɭɩɚɬɶ ɧɟ ɞɨɥɠɧɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 35). Ⱥɛɫɬɪɚɤɬɧɵɟ ɛɚ-
ɡɨɜɵɟ ɤɥɚɫɫɵ ɞɨɥɠɧɵ ɛɟɫɩɨɤɨɢɬɶɫɹ ɨɛ ɨɩɪɟɞɟɥɟɧɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ, ɧɨ ɧɟ ɨ ɟɟ ɪɟɚɥɢɡɚɰɢɢ.
ɉɪɢɧɰɢɩ ɢɧɜɟɪɫɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ ɢɦɟɟɬ ɬɪɢ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɯ ɩɪɟɢɦɭɳɟɫɬɜɚ ɩɪɢ ɩɪɨɟɤ-
ɬɢɪɨɜɚɧɢɢ.
• ɉɨɜɵɲɟɧɢɟ ɧɚɞɟɠɧɨɫɬɢ. Ɇɟɧɟɟ ɫɬɚɛɢɥɶɧɵɟ ɱɚɫɬɢ ɫɢɫɬɟɦɵ (ɪɟɚɥɢɡɚɰɢɢ) ɡɚɜɢɫɹɬ ɨɬ
ɛɨɥɟɟ ɫɬɚɛɢɥɶɧɵɯ ɱɚɫɬɟɣ (ɚɛɫɬɪɚɤɰɢɣ). ɇɚɞɟɠɧɵɣ ɞɢɡɚɣɧ — ɬɨɬ, ɜ ɤɨɬɨɪɨɦ ɜɨɡɞɟɣɫɬ-
ɜɢɟ ɢɡɦɟɧɟɧɢɣ ɨɝɪɚɧɢɱɟɧɨ. ɉɪɢ ɩɥɨɯɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɧɟɛɨɥɶɲɢɟ ɢɡɦɟɧɟɧɢɹ ɜ ɨɞ-
ɧɨɦ ɦɟɫɬɟ ɪɚɫɯɨɞɹɬɫɹ ɤɪɭɝɚɦɢ ɩɨ ɜɫɟɦɭ ɩɪɨɟɤɬɭ ɢ ɨɤɚɡɵɜɚɸɬ ɜɥɢɹɧɢɟ ɧɚ ɫɚɦɵɟ ɧɟ-
ɨɠɢɞɚɧɧɵɟ ɱɚɫɬɢ ɫɢɫɬɟɦɵ. ɂɦɟɧɧɨ ɷɬɨ ɩɪɨɢɫɯɨɞɢɬ, ɤɨɝɞɚ ɩɪɨɟɤɬ ɫɬɪɨɢɬɫɹ ɧɚ ɤɨɧ-
ɤɪɟɬɧɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ.
• ɉɨɜɵɲɟɧɢɟ ɝɢɛɤɨɫɬɢ. Ⱦɢɡɚɣɧ, ɨɫɧɨɜɚɧɧɵɣ ɧɚ ɚɛɫɬɪɚɤɬɧɵɯ ɢɧɬɟɪɮɟɣɫɚɯ, ɜ ɨɛɳɟɦ
ɫɥɭɱɚɟ ɛɨɥɟɟ ɝɢɛɨɤ. ȿɫɥɢ ɚɛɫɬɪɚɤɰɢɢ ɤɨɪɪɟɤɬɧɨ ɫɦɨɞɟɥɢɪɨɜɚɧɵ, ɬɨ ɩɪɢ ɩɨɹɜɥɟɧɢɢ ɧɨ-
ɜɵɯ ɬɪɟɛɨɜɚɧɢɣ ɥɟɝɤɨ ɪɚɡɪɚɛɨɬɚɬɶ ɧɨɜɵɟ ɪɟɚɥɢɡɚɰɢɢ. ɂ ɧɚɩɪɨɬɢɜ, ɞɢɡɚɣɧ, ɡɚɜɢɫɹɳɢɣ
ɨɬ ɦɧɨɝɢɯ ɤɨɧɤɪɟɬɧɵɯ ɞɟɬɚɥɟɣ, ɨɤɚɡɵɜɚɟɬɫɹ ɛɨɥɟɟ ɠɟɫɬɤɢɦ ɜ ɬɨɦ ɫɦɵɫɥɟ, ɱɬɨ ɧɨɜɵɟ
ɬɪɟɛɨɜɚɧɢɹ ɩɪɢɜɨɞɹɬ ɤ ɫɭɳɟɫɬɜɟɧɧɵɦ ɢɡɦɟɧɟɧɢɹɦ ɜ ɹɞɪɟ ɫɢɫɬɟɦɵ.
• ɏɨɪɨɲɚɹ ɦɨɞɭɥɶɧɨɫɬɶ. Ⱦɢɡɚɣɧ, ɨɩɢɪɚɸɳɢɣɫɹ ɧɚ ɚɛɫɬɪɚɤɰɢɢ, ɨɛɥɚɞɚɟɬ ɯɨɪɨɲɟɣ ɦɨ-
ɞɭɥɶɧɨɫɬɶɸ ɛɥɚɝɨɞɚɪɹ ɩɪɨɫɬɨɬɟ ɡɚɜɢɫɢɦɨɫɬɟɣ: ɜɵɫɨɤɨɢɡɦɟɧɹɟɦɵɟ ɱɚɫɬɢ ɡɚɜɢɫɹɬ ɨɬ
ɫɬɚɛɢɥɶɧɵɯ ɱɚɫɬɟɣ, ɧɨ ɧɟ ɧɚɨɛɨɪɨɬ. Ⱦɢɡɚɣɧ ɠɟ, ɜ ɤɨɬɨɪɨɦ ɢɧɬɟɪɮɟɣɫɵ ɩɟɪɟɦɟɲɚɧɵ ɫ
ɞɟɬɚɥɹɦɢ ɪɟɚɥɢɡɚɰɢɢ, ɩɪɢɦɟɧɢɬɶ ɜ ɤɚɱɟɫɬɜɟ ɨɬɞɟɥɶɧɨɝɨ ɦɨɞɭɥɹ ɜ ɞɪɭɝɨɣ ɫɢɫɬɟɦɟ ɨɤɚ-
ɡɵɜɚɟɬɫɹ ɨɱɟɧɶ ɫɥɨɠɧɨ.
36. Предпочитайте предоставление абстрактных интерфейсов 77
Стр. 77
Ɂɚɤɨɧ ȼɬɨɪɨɝɨ ɒɚɧɫɚ ɝɥɚɫɢɬ: “ɋɚɦɚɹ ɜɚɠɧɚɹ ɜɟɳɶ — ɢɧɬɟɪɮɟɣɫ. ȼɫɟ ɨɫɬɚɥɶɧɨɟ ɦɨɠɧɨ
ɩɨɞɩɪɚɜɢɬɶ ɢ ɩɨɡɠɟ, ɧɨ ɟɫɥɢ ɢɧɬɟɪɮɟɣɫ ɪɚɡɪɚɛɨɬɚɧ ɧɟɜɟɪɧɨ, ɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɬɚɤ, ɱɬɨ ɭ ɜɚɫ
ɭɠɟ ɧɟ ɛɭɞɟɬ ɜɬɨɪɨɝɨ ɲɚɧɫɚ ɟɝɨ ɢɫɩɪɚɜɢɬɶ” [Sutter04].
Ɉɛɵɱɧɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɨɛɟɫɩɟɱɢɬɶ ɩɨɥɢɦɨɪɮɧɨɟ ɭɞɚɥɟɧɢɟ, ɩɪɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɨɬɞɚɟɬ-
ɫɹ ɩɪɟɞɩɨɱɬɟɧɢɟ ɨɬɤɪɵɬɨɦɭ ɜɢɪɬɭɚɥɶɧɨɦɭ ɞɟɫɬɪɭɤɬɨɪɭ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50), ɟɫɥɢ ɬɨɥɶɤɨ
ɜɵ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɛɪɨɤɟɪ ɨɛɴɟɤɬɨɜ (ɧɚɩɨɞɨɛɢɟ COM ɢɥɢ CORBA), ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɚɥɶ-
ɬɟɪɧɚɬɢɜɧɵɣ ɦɟɯɚɧɢɡɦ ɭɩɪɚɜɥɟɧɢɹ ɩɚɦɹɬɶɸ.
Ȼɭɞɶɬɟ ɨɫɬɨɪɨɠɧɵ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɧɟ
ɹɜɥɹɸɬɫɹ ɚɛɫɬɪɚɤɬɧɵɦɢ ɢɧɬɟɪɮɟɣɫɚɦɢ. Ⱦɢɡɚɣɧ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɧɚɫɥɟɞɨ-
ɜɚɧɢɹ ɦɨɠɟɬ ɛɵɬɶ ɨɱɟɧɶ ɜɵɪɚɡɢɬɟɥɶɧɵɦ, ɧɨ ɨɧ ɬɪɭɞɧɟɟ ɜ ɪɚɡɪɚɛɨɬɤɟ ɢ ɛɨɥɟɟ ɩɨɞɜɟɪɠɟɧ
ɨɲɢɛɤɚɦ. ȼ ɱɚɫɬɧɨɫɬɢ, ɨɫɨɛɟɧɧɨ ɫɥɨɠɧɵɦ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ
ɫɬɚɧɨɜɢɬɫɹ ɭɩɪɚɜɥɟɧɢɟ ɫɨɫɬɨɹɧɢɹɦɢ.
Ʉɚɤ ɭɤɚɡɵɜɚɥɨɫɶ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 34, ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɬ ɧɟɤɨɬɨɪɨɝɨ ɬɢɩɚ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɢ ɤ
ɩɪɨɛɥɟɦɚɦ ɩɨɢɫɤɚ ɢɦɟɧ, ɩɨɫɤɨɥɶɤɭ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɜ ɩɨɢɫɤɟ ɭɱɚɫɬɜɭɸɬ ɮɭɧɤɰɢɢ ɢɡ ɩɪɨɫɬɪɚɧ-
ɫɬɜɚ ɢɦɟɧ ɧɚɫɥɟɞɭɟɦɨɝɨ ɬɢɩɚ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 58).
Примеры
ɉɪɢɦɟɪ. ɉɪɨɝɪɚɦɦɚ ɪɟɡɟɪɜɧɨɝɨ ɤɨɩɢɪɨɜɚɧɢɹ. ɉɪɢ ɩɪɹɦɨɦ, ɧɚɢɜɧɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɜɵ-
ɫɨɤɨɭɪɨɜɧɟɜɵɟ ɤɨɦɩɨɧɟɧɬɵ ɡɚɜɢɫɹɬ ɨɬ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɞɟɬɚɥɟɣ. ɧɚɩɪɢɦɟɪ, ɩɥɨɯɨ ɫɩɪɨɟɤɬɢ-
ɪɨɜɚɧɧɚɹ ɩɪɨɝɪɚɦɦɚ ɪɟɡɟɪɜɧɨɝɨ ɤɨɩɢɪɨɜɚɧɢɹ ɦɨɠɟɬ ɢɦɟɬɶ ɚɪɯɢɜɢɪɭɸɳɢɣ ɤɨɦɩɨɧɟɧɬ, ɤɨɬɨ-
ɪɵɣ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɡɚɜɢɫɢɬ ɨɬ ɬɢɩɨɜ ɢɥɢ ɩɨɞɩɪɨɝɪɚɦɦ ɞɥɹ ɱɬɟɧɢɹ ɫɬɪɭɤɬɭɪɵ ɤɚɬɚɥɨɝɨɜ, ɢ
ɞɪɭɝɢɯ, ɤɨɬɨɪɵɟ ɡɚɩɢɫɵɜɚɸɬ ɞɚɧɧɵɟ ɧɚ ɥɟɧɬɭ. Ⱥɞɚɩɬɚɰɢɹ ɬɚɤɨɣ ɩɪɨɝɪɚɦɦɵ ɤ ɧɨɜɨɣ ɮɚɣɥɨɜɨɣ
ɫɢɫɬɟɦɟ ɢ ɚɩɩɚɪɚɬɧɨɦɭ ɨɛɟɫɩɟɱɟɧɢɸ ɞɥɹ ɪɟɡɟɪɜɧɨɝɨ ɤɨɩɢɪɨɜɚɧɢɹ ɩɨɬɪɟɛɭɟɬ ɫɭɳɟɫɬɜɟɧɧɨɣ
ɩɟɪɟɪɚɛɨɬɤɢ ɩɪɨɟɤɬɚ.
ȿɫɥɢ ɠɟ ɥɨɝɢɤɚ ɫɢɫɬɟɦɵ ɪɟɡɟɪɜɧɨɝɨ ɤɨɩɢɪɨɜɚɧɢɹ ɩɨɫɬɪɨɟɧɚ ɧɚ ɨɫɧɨɜɟ ɬɳɚɬɟɥɶɧɨ ɫɩɪɨɟɤ-
ɬɢɪɨɜɚɧɧɵɯ ɚɛɫɬɪɚɤɰɢɣ ɮɚɣɥɨɜɨɣ ɫɢɫɬɟɦɵ ɢ ɭɫɬɪɨɣɫɬɜɚ ɪɟɡɟɪɜɧɨɝɨ ɤɨɩɢɪɨɜɚɧɢɹ, ɬɨ ɩɟɪɟɪɚ-
ɛɨɬɤɚ ɧɟ ɩɨɬɪɟɛɭɟɬɫɹ — ɞɨɫɬɚɬɨɱɧɨ ɛɭɞɟɬ ɞɨɛɚɜɢɬɶ ɜ ɫɢɫɬɟɦɭ ɧɨɜɭɸ ɪɟɚɥɢɡɚɰɢɸ ɚɛɫɬɪɚɤɬɧɨ-
ɝɨ ɢɧɬɟɪɮɟɣɫɚ. ȿɫɬɟɫɬɜɟɧɧɨɟ ɪɟɲɟɧɢɟ ɩɨɞɨɛɧɨɣ ɩɪɨɛɥɟɦɵ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɧɨɜɵɟ ɬɪɟɛɨɜɚ-
ɧɢɹ ɞɨɥɠɧɵ ɭɞɨɜɥɟɬɜɨɪɹɬɶɫɹ ɧɨɜɵɦ ɤɨɞɨɦ, ɧɨ ɫɬɚɪɵɣ ɤɨɞ ɩɪɢ ɷɬɨɦ ɢɡɦɟɧɹɬɶɫɹ ɧɟ ɞɨɥɠɟɧ.
Ɉɩɬɢɦɢɡɚɰɢɹ ɩɭɫɬɨɝɨ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɞɢɧ ɢɡ ɩɪɢɦɟɪɨɜ, ɤɨɝɞɚ ɧɚɫɥɟ-
ɞɨɜɚɧɢɟ (ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɧɟ ɨɬɤɪɵɬɨɟ) ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɫɭɝɭɛɨ ɨɩɬɢɦɢɡɚɰɢɨɧɧɵɯ ɰɟɥɟɣ (ɧɨ
ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8).
Ɇɨɠɟɬ ɩɨɤɚɡɚɬɶɫɹ, ɱɬɨ ɜ ɞɢɡɚɣɧɟ ɧɚ ɨɫɧɨɜɟ ɫɬɪɚɬɟɝɢɣ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɤɨɦɩɨɧɟɧɬɵ ɡɚɜɢ-
ɫɹɬ ɨɬ ɞɟɬɚɥɟɣ ɪɟɚɥɢɡɚɰɢɢ (ɫɬɪɚɬɟɝɢɣ). Ɉɞɧɚɤɨ ɷɬɨ ɜɫɟɝɨ ɥɢɲɶ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɫɬɚɬɢɱɟɫɤɨɝɨ
ɩɨɥɢɦɨɪɮɢɡɦɚ. Ɂɞɟɫɶ ɢɦɟɸɬɫɹ ɚɛɫɬɪɚɤɬɧɵɟ ɢɧɬɟɪɮɟɣɫɵ, ɩɪɨɫɬɨ ɨɧɢ ɧɟ ɭɤɚɡɚɧɵ ɹɜɧɨ ɩɨɫɪɟɞ-
ɫɬɜɨɦ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ.
Ссылки
[Alexandrescu01] • [Cargill92] pp. 12-15, 215-218 • [Cline99] §5.18-20, 21.13 • [Lakos96] §6.4.1 •
[Martin96a] • [Martin00] • [Meyers96] §33 • [Stroustrup00] §12.3-4, §23.4.3.2, §23.4.3.5, §24.2-3,
§25.3, §25.6 • [Sutter04] §17
Стр. 78
37. Открытое наследование означает заменимость ...
37. Открытое наследование означает

заменимость. Наследовать надо
не для повторного использования,
а чтобы быть повторно использованным
37. Открытое наследование означает заменимость ...
Резюме
Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɩɨɡɜɨɥɹɟɬ ɭɤɚɡɚɬɟɥɸ ɢɥɢ ɫɫɵɥɤɟ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɜ ɞɟɣɫɬɜɢɬɟɥɶ-
ɧɨɫɬɢ ɨɛɪɚɳɚɬɶɫɹ ɤ ɨɛɴɟɤɬɭ ɧɟɤɨɬɨɪɨɝɨ ɩɪɨɢɡɜɨɞɧɨɝɨ ɤɥɚɫɫɚ ɛɟɡ ɢɡɦɟɧɟɧɢɹ ɫɭɳɟɫɬɜɭɸɳɟɝɨ
ɤɨɞɚ ɢ ɧɚɪɭɲɟɧɢɹ ɟɝɨ ɤɨɪɪɟɤɬɧɨɫɬɢ.
ɇɟ ɩɪɢɦɟɧɹɣɬɟ ɨɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɞ
(ɧɚɯɨɞɹɳɢɣɫɹ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ); ɨɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɧɟɨɛɯɨɞɢɦɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɛɵɬɶ
ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɧɧɵɦ (ɫɭɳɟɫɬɜɭɸɳɢɦ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ ɩɨɥɢɦɨɪɮɧɨ ɢɫɩɨɥɶɡɭɟɬ ɨɛɴɟɤɬɵ
ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ).
ɇɟɫɦɨɬɪɹ ɧɚ ɞɜɚɞɰɚɬɢɥɟɬɧɸɸ ɢɫɬɨɪɢɸ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɰɟɥɶ
ɢ ɩɪɚɤɬɢɤɚ ɨɬɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɱɚɫɬɨ ɩɨɧɢɦɚɟɬɫɹ ɧɟɜɟɪɧɨ, ɢ ɦɧɨɝɢɟ ɩɪɢɦɟɧɟɧɢɹ ɧɚɫɥɟ-
ɞɨɜɚɧɢɹ ɨɤɚɡɵɜɚɸɬɫɹ ɧɟɤɨɪɪɟɤɬɧɵɦɢ.
Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫ ɩɪɢɧɰɢɩɨɦ ɩɨɞɫɬɚɧɨɜɤɢ Ʌɢɫɤɨɜ (Liskov Substi-
tution Principle [Liskov88]) ɜɫɟɝɞɚ ɞɨɥɠɧɨ ɦɨɞɟɥɢɪɨɜɚɬɶ ɨɬɧɨɲɟɧɢɟ “ɹɜɥɹɟɬɫɹ” (“ɪɚɛɨɬɚɟɬ
ɤɚɤ”): ɜɫɟ ɤɨɧɬɪɚɤɬɵ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɧɵ ɛɵɬɶ ɜɵɩɨɥɧɟɧɵ, ɞɥɹ ɱɟɝɨ ɜɫɟ ɩɟɪɟɤɪɵɬɢɹ ɜɢɪ-
ɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɧɟ ɞɨɥɠɧɵ ɬɪɟɛɨɜɚɬɶ ɛɨɥɶɲɟɝɨ ɢɥɢ ɨɛɟɳɚɬɶ ɦɟɧɶɲɟ, ɱɟɦ ɢɯ ɛɚɡɨ-
ɜɵɟ ɜɟɪɫɢɢ. Ʉɨɞ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɭɤɚɡɚɬɟɥɶ ɢɥɢ ɫɫɵɥɤɭ ɧɚ Base, ɞɨɥɠɟɧ ɤɨɪɪɟɤɬɧɨ ɜɟɫɬɢ ɫɟɛɹ
ɜ ɫɥɭɱɚɟ, ɤɨɝɞɚ ɭɤɚɡɚɬɟɥɶ ɢɥɢ ɫɫɵɥɤɚ ɭɤɚɡɵɜɚɸɬ ɧɚ ɨɛɴɟɤɬ Derived.
ɇɟɜɟɪɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɧɚɪɭɲɚɟɬ ɤɨɪɪɟɤɬɧɨɫɬɶ. Ɉɛɵɱɧɨ ɧɟɤɨɪɪɟɤɬɧɨ ɪɟɚ-
ɥɢɡɨɜɚɧɧɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɧɟ ɩɨɞɱɢɧɹɟɬɫɹ ɹɜɧɵɦ ɢɥɢ ɧɟɹɜɧɵɦ ɤɨɧɬɪɚɤɬɚɦ, ɭɫɬɚɧɨɜɥɟɧɧɵɦ
ɛɚɡɨɜɵɦ ɤɥɚɫɫɨɦ. Ɍɚɤɢɟ ɤɨɧɬɪɚɤɬɵ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɨɱɟɧɶ ɫɩɟɰɢɮɢɱɧɵɦɢ ɢ ɯɢɬɪɨɭɦɧɵɦɢ,
ɢ ɩɪɨɝɪɚɦɦɢɫɬ ɞɨɥɠɟɧ ɛɵɬɶ ɨɫɨɛɟɧɧɨ ɨɫɬɨɪɨɠɟɧ, ɤɨɝɞɚ ɢɯ ɧɟɥɶɡɹ ɜɵɪɚɡɢɬɶ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ
ɜ ɤɨɞɟ (ɧɟɤɨɬɨɪɵɟ ɲɚɛɥɨɧɵ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɨɦɨɝɚɸɬ ɭɤɚɡɚɬɶ ɜ ɤɨɞɟ ɟɝɨ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ —
ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 39).
ɇɚɢɛɨɥɟɟ ɱɚɫɬɨ ɜ ɷɬɨɣ ɫɜɹɡɢ ɭɩɨɦɢɧɚɟɬɫɹ ɫɥɟɞɭɸɳɢɣ ɩɪɢɦɟɪ. Ɋɚɫɫɦɨɬɪɢɦ ɞɜɚ ɤɥɚɫɫɚ —
Square (ɤɜɚɞɪɚɬ) ɢ Rectangle (ɩɪɹɦɨɭɝɨɥɶɧɢɤ), ɤɚɠɞɵɣ ɢɡ ɤɨɬɨɪɵɯ ɢɦɟɟɬ ɜɢɪɬɭɚɥɶɧɵɟ
ɮɭɧɤɰɢɢ ɞɥɹ ɭɫɬɚɧɨɜɤɢ ɢɯ ɜɵɫɨɬɵ ɢ ɲɢɪɢɧɵ. Ɍɨɝɞɚ Square ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɤɨɪɪɟɤɬɧɨ ɭɧɚɫ-
ɥɟɞɨɜɚɧ ɨɬ Rectangle, ɩɨɫɤɨɥɶɤɭ ɤɨɞ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɜɢɞɨɢɡɦɟɧɹɟɦɵɣ Rectangle, ɛɭɞɟɬ
ɩɨɥɚɝɚɬɶ, ɱɬɨ ɮɭɧɤɰɢɹ SetWidth ɧɟ ɢɡɦɟɧɹɟɬ ɟɝɨ ɜɵɫɨɬɭ (ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɬɨɝɨ, ɞɨɤɭɦɟɧɬɢɪɨ-
ɜɚɧ ɥɢ ɞɚɧɧɵɣ ɤɨɧɬɪɚɤɬ ɤɥɚɫɫɨɦ Rectangle ɹɜɧɨ ɢɥɢ ɧɟɬ), ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɮɭɧɤɰɢɹ
Square::SetWidth ɧɟ ɦɨɠɟɬ ɨɞɧɨɜɪɟɦɟɧɧɨ ɜɵɩɨɥɧɢɬɶ ɷɬɨɬ ɤɨɧɬɪɚɤɬ ɢ ɫɜɨɣ ɢɧɜɚɪɢɚɧɬ
“ɤɜɚɞɪɚɬɧɨɫɬɢ”. ɇɨ ɢ ɤɥɚɫɫ Rectangle ɧɟ ɦɨɠɟɬ ɤɨɪɪɟɤɬɧɨ ɧɚɫɥɟɞɨɜɚɬɶ ɤɥɚɫɫɭ Square, ɟɫ-
ɥɢ ɟɝɨ ɤɥɢɟɧɬɵ Square ɩɨɥɚɝɚɸɬ, ɧɚɩɪɢɦɟɪ, ɱɬɨ ɞɥɹ ɜɵɱɢɫɥɟɧɢɹ ɟɝɨ ɩɥɨɳɚɞɢ ɧɚɞɨ ɜɨɡɜɟɫɬɢ
ɜ ɤɜɚɞɪɚɬ ɲɢɪɢɧɭ, ɥɢɛɨ ɢɫɩɨɥɶɡɭɸɬ ɤɚɤɨɟ-ɬɨ ɢɧɨɟ ɫɜɨɣɫɬɜɨ, ɤɨɬɨɪɨɟ ɜɵɩɨɥɧɹɟɬɫɹ ɞɥɹ ɤɜɚɞ-
ɪɚɬɚ ɢ ɧɟ ɜɵɩɨɥɧɹɟɬɫɹ ɞɥɹ ɩɪɹɦɨɭɝɨɥɶɧɢɤɚ.
Ɉɩɢɫɚɧɢɟ “ɹɜɥɹɟɬɫɹ” ɞɥɹ ɨɬɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɜɟɪɧɨ ɩɨɧɹɬɵɦ ɩɪɢ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɢ ɚɧɚɥɨɝɢɣ ɢɡ ɪɟɚɥɶɧɨɝɨ ɦɢɪɚ: ɤɜɚɞɪɚɬ “ɹɜɥɹɟɬɫɹ” ɩɪɹɦɨɭɝɨɥɶɧɢɤɨɦ ɜ ɦɚɬɟɦɚɬɢɱɟ-
ɫɤɨɦ ɫɦɵɫɥɟ , ɧɨ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɩɨɜɟɞɟɧɢɹ Square ɧɟ ɹɜɥɹɟɬɫɹ Rectangle. ȼɨɬ ɩɨɱɟɦɭ ɜɦɟɫɬɨ
37. Открытое наследование означает заменимость... 79
Стр. 79
“ɹɜɥɹɟɬɫɹ” ɦɵ ɩɪɟɞɩɨɱɢɬɚɟɦ ɝɨɜɨɪɢɬɶ “ɪɚɛɨɬɚɟɬ ɤɚɤ” (ɢɥɢ, ɟɫɥɢ ɜɚɦ ɷɬɨ ɛɨɥɶɲɟ ɧɪɚɜɢɬɫɹ,
“ɢɫɩɨɥɶɡɭɟɬɫɹ ɤɚɤ”) ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɬɚɤɨɟ ɨɩɢɫɚɧɢɟ ɜɨɫɩɪɢɧɢɦɚɥɨɫɶ ɦɚɤɫɢɦɚɥɶɧɨ ɩɪɚɜɢɥɶɧɨ.
Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɫɜɹɡɚɧɨ ɫ ɩɨɜɬɨɪɧɵɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ, ɧɨ ɨɩɹɬɶ ɠɟ
ɧɟ ɬɚɤ, ɤɚɤ ɩɪɢɜɵɤɥɨ ɞɭɦɚɬɶ ɦɧɨɠɟɫɬɜɨ ɩɪɨɝɪɚɦɦɢɫɬɨɜ. Ʉɚɤ ɭɠɟ ɭɤɚɡɵɜɚɥɨɫɶ, ɰɟɥɶ ɨɬɤɪɵɬɨ-
ɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ — ɜ ɪɟɚɥɢɡɚɰɢɢ ɡɚɦɟɧɢɦɨɫɬɢ (ɫɦ. [Liskov88]). ɐɟɥɶ ɨɬɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ
ɧɟ ɜ ɬɨɦ, ɱɬɨɛɵ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɦɨɝ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɞ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɥɹ ɬɨɝɨ,
ɱɬɨɛɵ ɫ ɟɝɨ ɩɨɦɨɳɶɸ ɪɟɚɥɢɡɨɜɚɬɶ ɫɜɨɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ. Ɍɚɤɨɟ ɨɬɧɨɲɟɧɢɟ “ɪɟɚɥɢɡɨɜɚɧ
ɩɨɫɪɟɞɫɬɜɨɦ” ɜɩɨɥɧɟ ɤɨɪɪɟɤɬɧɨ, ɧɨ ɞɨɥɠɧɨ ɛɵɬɶ ɫɦɨɞɟɥɢɪɨɜɚɧɨ ɩɪɢ ɩɨɦɨɳɢ ɤɨɦɩɨɡɢɰɢɢ
ɢɥɢ, ɬɨɥɶɤɨ ɜ ɨɬɞɟɥɶɧɵɯ ɫɥɭɱɚɹɯ, ɩɪɢ ɩɨɦɨɳɢ ɡɚɤɪɵɬɨɝɨ ɢɥɢ ɡɚɳɢɳɟɧɧɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ (ɫɦ.
ȼɨɬ ɟɳɟ ɨɞɧɨ ɫɨɨɛɪɚɠɟɧɢɟ ɩɨ ɩɨɜɨɞɭ ɪɚɫɫɦɚɬɪɢɜɚɟɦɨɣ ɬɟɦɵ. ɉɪɢ ɤɨɪɪɟɤɬɧɨɫɬɢ ɢ ɰɟɥɟ-
ɫɨɨɛɪɚɡɧɨɫɬɢ ɞɢɧɚɦɢɱɟɫɤɨɝɨ ɩɨɥɢɦɨɪɮɢɡɦɚ ɤɨɦɩɨɡɢɰɢɹ “ɷɝɨɢɫɬɢɱɧɚ” ɜ ɨɬɥɢɱɢɟ ɨɬ
“ɳɟɞɪɨɝɨ” ɧɚɫɥɟɞɨɜɚɧɢɹ. ɉɨɹɫɧɢɦ ɷɬɭ ɦɵɫɥɶ.
ɇɨɜɵɣ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɱɚɫɬɧɵɣ ɫɥɭɱɚɣ ɫɭɳɟɫɬɜɭɸɳɟɣ ɛɨɥɟɟ ɨɛ-
ɳɟɣ ɚɛɫɬɪɚɤɰɢɢ. ɋɭɳɟɫɬɜɭɸɳɢɣ (ɞɢɧɚɦɢɱɟɫɤɢɣ) ɩɨɥɢɦɨɪɮɧɵɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ
Base& ɢɥɢ Base* ɩɭɬɟɦ ɜɵɡɨɜɚ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ Base, ɞɨɥɠɟɧ ɛɵɬɶ ɫɩɨɫɨɛɟɧ ɩɪɨɡɪɚɱ-
ɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɴɟɤɬɵ ɤɥɚɫɫɚ MyNewDerivedType, ɩɪɨɢɡɜɨɞɧɨɝɨ ɨɬ Base. ɇɨɜɵɣ ɩɪɨɢɡ-
ɜɨɞɧɵɣ ɬɢɩ ɞɨɛɚɜɥɹɟɬ ɧɨɜɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɤ ɫɭɳɟɫɬɜɭɸɳɟɦɭ ɤɨɞɭ, ɤɨɬɨɪɵɣ ɩɪɢ ɷɬɨɦ
ɧɟ ɞɨɥɠɟɧ ɢɡɦɟɧɹɬɶɫɹ. Ɉɞɧɚɤɨ ɧɟɫɦɨɬɪɹ ɧɚ ɧɟɢɡɦɟɧɧɨɫɬɶ ɢɦɟɸɳɟɝɨɫɹ ɤɨɞɚ, ɩɪɢ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɢ ɢɦ ɧɨɜɵɯ ɩɪɨɢɡɜɨɞɧɵɯ ɨɛɴɟɤɬɨɜ ɟɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɜɨɡɪɚɫɬɚɟɬ.
ɇɨɜɵɟ ɬɪɟɛɨɜɚɧɢɹ, ɟɫɬɟɫɬɜɟɧɧɨ, ɞɨɥɠɧɵ ɭɞɨɜɥɟɬɜɨɪɹɬɶɫɹ ɧɨɜɵɦ ɤɨɞɨɦ, ɧɨ ɨɧɢ ɧɟ ɞɨɥɠ-
ɧɵ ɬɪɟɛɨɜɚɬɶ ɜɧɟɫɟɧɢɹ ɢɡɦɟɧɟɧɢɣ ɜ ɫɭɳɟɫɬɜɭɸɳɢɣ ɤɨɞ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 36).
Ⱦɨ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɛɵɥɨ ɥɟɝɤɨ ɪɟɲɢɬɶ ɜɨɩɪɨɫ ɜɵɡɨɜɚ
ɫɬɚɪɨɝɨ ɤɨɞɚ ɧɨɜɵɦ. Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɭɩɪɨɫɬɢɥɨ ɩɪɨɡɪɚɱɧɵɣ ɢ ɛɟɡɨɩɚɫɧɵɣ ɜɵɡɨɜ ɧɨ-
ɜɨɝɨ ɤɨɞɚ ɫɬɚɪɵɦ (ɬɚɤ ɱɬɨ ɩɪɢɦɟɧɹɣɬɟ ɲɚɛɥɨɧɵ, ɩɪɟɞɨɫɬɚɜɥɹɸɳɢɟ ɜɨɡɦɨɠɧɨɫɬɢ ɫɬɚɬɢɱɟɫɤɨ-
ɝɨ ɩɨɥɢɦɨɪɮɢɡɦɚ, ɤɨɬɨɪɵɣ ɯɨɪɨɲɨ ɫɨɜɦɟɫɬɢɦ ɫ ɩɨɥɢɦɨɪɮɢɡɦɨɦ ɞɢɧɚɦɢɱɟɫɤɢɦ — ɫɦ. ɪɟɤɨ-
Ʉɥɚɫɫɵ ɫɬɪɚɬɟɝɢɣ ɞɨɛɚɜɥɹɸɬ ɧɨɜɨɟ ɩɨɜɟɞɟɧɢɟ ɩɭɬɟɦ ɨɬɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ, ɧɨ ɷɬɨ ɧɟ
ɹɜɥɹɟɬɫɹ ɧɟɜɟɪɧɵɦ ɭɩɨɬɪɟɛɥɟɧɢɟɦ ɨɬɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɞɥɹ ɦɨɞɟɥɢɪɨɜɚɧɢɹ ɨɬɧɨɲɟɧɢɹ
“ɪɟɚɥɢɡɨɜɚɧ ɩɨɫɪɟɞɫɬɜɨɦ”.
Ссылки
[Cargill92] pp. 19-20 • [Cline99] §5.13, §7.01-8.15 • [Dewhurst03] §92 • [Liskov88] •
[Meyers97] §35 • [Stroustrup00] §12.4.1, §23.4.3.1, §24.3.4 • [Sutter00] §22-24
Стр. 80
38. Практикуйте безопасное перекрытие
Резюме
Ɉɬɜɟɬɫɬɜɟɧɧɨ ɩɨɞɯɨɞɢɬɟ ɜ ɩɟɪɟɤɪɵɬɢɸ ɮɭɧɤɰɢɣ. Ʉɨɝɞɚ ɜɵ ɩɟɪɟɤɪɵɜɚɟɬɟ ɜɢɪɬɭɚɥɶɧɭɸ
ɮɭɧɤɰɢɸ, ɫɨɯɪɚɧɹɣɬɟ ɡɚɦɟɧɢɦɨɫɬɶ; ɜ ɱɚɫɬɧɨɫɬɢ, ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɩɪɟɞ- ɢ ɩɨɫɬɭɫɥɨɜɢɹ ɜ
ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ. ɇɟ ɢɡɦɟɧɹɣɬɟ ɚɪɝɭɦɟɧɬɵ ɩɨ ɭɦɨɥɱɚɧɢɸ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ. ɉɪɟɞɩɨɱɬɢ-
ɬɟɥɶɧɨ ɹɜɧɨ ɭɤɚɡɵɜɚɬɶ ɩɟɪɟɤɪɵɜɚɟɦɵɟ ɮɭɧɤɰɢɢ ɤɚɤ ɜɢɪɬɭɚɥɶɧɵɟ. ɇɟ ɡɚɛɵɜɚɣɬɟ ɨ ɫɨɤɪɵɬɢɢ
ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɮɭɧɤɰɢɣ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ.
ɏɨɬɹ ɨɛɵɱɧɨ ɩɪɨɢɡɜɨɞɧɵɟ ɤɥɚɫɫɵ ɞɨɛɚɜɥɹɸɬ ɧɨɜɵɟ ɫɨɫɬɨɹɧɢɹ (ɬ.ɟ. ɱɥɟɧɵ-ɞɚɧɧɵɟ), ɨɧɢ
ɦɨɞɟɥɢɪɭɸɬ ɩɨɞɦɧɨɠɟɫɬɜɚ (ɚ ɧɟ ɧɚɞɦɧɨɠɟɫɬɜɚ) ɫɜɨɢɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ. ɉɪɢ ɤɨɪɪɟɤɬɧɨɦ ɧɚ-
ɫɥɟɞɨɜɚɧɢɢ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɦɨɞɟɥɢɪɭɟɬ ɱɚɫɬɧɵɣ ɫɥɭɱɚɣ ɛɨɥɟɟ ɨɛɳɟɣ ɛɚɡɨɜɨɣ ɤɨɧɰɟɩɰɢɢ
ɗɬɨ ɢɦɟɟɬ ɩɪɹɦɵɟ ɫɥɟɞɫɬɜɢɹ ɞɥɹ ɤɨɪɪɟɤɬɧɨɝɨ ɩɟɪɟɤɪɵɬɢɹ ɮɭɧɤɰɢɣ. ɋɨɛɥɸɞɟɧɢɟ ɨɬɧɨɲɟ-
ɧɢɹ ɜɤɥɸɱɟɧɢɹ ɜɥɟɱɟɬ ɡɚ ɫɨɛɨɣ ɡɚɦɟɧɢɦɨɫɬɶ — ɨɩɟɪɚɰɢɢ, ɤɨɬɨɪɵɟ ɩɪɢɦɟɧɢɦɵ ɤɨ ɜɫɟɦɭ
ɦɧɨɠɟɫɬɜɭ, ɩɪɢɦɟɧɢɦɵ ɢ ɤ ɥɸɛɨɦɭ ɟɝɨ ɩɨɞɦɧɨɠɟɫɬɜɭ. ȿɫɥɢ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɝɚɪɚɧɬɢɪɭɟɬ ɜɵ-
ɩɨɥɧɟɧɢɟ ɨɩɪɟɞɟɥɟɧɧɵɯ ɩɪɟɞ- ɢ ɩɨɫɬɭɫɥɨɜɢɣ ɧɟɤɨɬɨɪɨɣ ɨɩɟɪɚɰɢɢ, ɬɨ ɢ ɥɸɛɨɣ ɩɪɨɢɡɜɨɞɧɵɣ
ɤɥɚɫɫ ɞɨɥɠɟɧ ɨɛɟɫɩɟɱɢɬɶ ɢɯ ɜɵɩɨɥɧɟɧɢɟ. ɉɟɪɟɤɪɵɬɢɟ ɦɨɠɟɬ ɩɪɟɞɴɹɜɥɹɬɶ ɦɟɧɶɲɟ ɬɪɟɛɨɜɚɧɢɣ
ɢ ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɛɨɥɶɲɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ, ɧɨ ɧɢɤɨɝɞɚ ɧɟ ɞɨɥɠɧɨ ɩɪɟɞɴɹɜɥɹɬɶ ɛɨɥɶɲɢɟ
ɬɪɟɛɨɜɚɧɢɹ ɢɥɢ ɦɟɧɶɲɟ ɨɛɟɳɚɬɶ — ɩɨɫɤɨɥɶɤɭ ɷɬɨ ɩɪɢɜɟɞɟɬ ɤ ɧɚɪɭɲɟɧɢɸ ɤɨɧɬɪɚɤɬɚ ɫ ɜɵɡɵ-
ɜɚɸɳɢɦ ɤɨɞɨɦ.
Ɉɩɪɟɞɟɥɟɧɢɟ ɜ ɩɪɨɢɡɜɨɞɧɨɦ ɤɥɚɫɫɟ ɩɟɪɟɤɪɵɬɢɹ, ɤɨɬɨɪɨɟ ɦɨɠɟɬ ɛɵɬɶ ɧɟɭɫɩɟɲɧɵɦ (ɧɚɩɪɢɦɟɪ,
ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 70), ɛɭɞɟɬ ɤɨɪɪɟɤɬɧɨ ɬɨɥɶɤɨ ɜ ɬɨɦ ɫɥɭɱɚɟ, ɤɨɝɞɚ ɜ ɛɚ-
ɡɨɜɨɦ ɤɥɚɫɫɟ ɧɟ ɨɛɴɹɜɥɟɧɨ, ɱɬɨ ɞɚɧɧɚɹ ɨɩɟɪɚɰɢɹ ɜɫɟɝɞɚ ɭɫɩɟɲɧɚ. ɇɚɩɪɢɦɟɪ, ɫɤɚɠɟɦ, ɤɥɚɫɫ
Employee ɫɨɞɟɪɠɢɬ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ GetBuilding, ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ ɤɨɬɨɪɨɣ — ɜɟɪ-
ɧɭɬɶ ɤɨɞ ɡɞɚɧɢɹ, ɜ ɤɨɬɨɪɨɦ ɪɚɛɨɬɚɟɬ ɨɛɴɟɤɬ Employee. ɇɨ ɱɬɨ ɟɫɥɢ ɦɵ ɡɚɯɨɬɢɦ ɧɚɩɢɫɚɬɶ ɩɪɨɢɡ-
ɜɨɞɧɵɣ ɤɥɚɫɫ RemoteContractor, ɤɨɬɨɪɵɣ ɩɟɪɟɤɪɵɜɚɟɬ ɮɭɧɤɰɢɸ GetBuilding, ɜ ɪɟɡɭɥɶɬɚɬɟ
ɱɟɝɨ ɨɧɚ ɦɨɠɟɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɢɥɢ ɜɨɡɜɪɚɳɚɬɶ ɧɭɥɟɜɨɣ ɤɨɞ ɡɞɚɧɢɹ? Ɍɚɤɨɟ ɩɨɜɟɞɟɧɢɟ
ɤɨɪɪɟɤɬɧɨ ɬɨɥɶɤɨ ɜ ɬɨɦ ɫɥɭɱɚɟ, ɟɫɥɢ ɜ ɞɨɤɭɦɟɧɬɚɰɢɢ ɤɥɚɫɫɚ Employee ɭɤɚɡɚɧɨ, ɱɬɨ ɮɭɧɤɰɢɹ
GetBuilding ɦɨɠɟɬ ɡɚɜɟɪɲɚɬɶɫɹ ɧɟɭɫɩɟɲɧɨ, ɢ ɜ ɤɥɚɫɫɟ RemoteContractor ɫɨɨɛɳɟɧɢɟ ɨ ɧɟ-
ɭɞɚɱɟ ɜɵɩɨɥɧɹɟɬɫɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɵɦ ɜ ɤɥɚɫɫɟ Employee ɫɩɨɫɨɛɨɦ.
ɇɢɤɨɝɞɚ ɧɟ ɢɡɦɟɧɹɣɬɟ ɚɪɝɭɦɟɧɬ ɩɨ ɭɦɨɥɱɚɧɢɸ ɩɪɢ ɩɟɪɟɤɪɵɬɢɢ. Ɉɧ ɧɟ ɹɜɥɹɟɬɫɹ ɱɚɫɬɶɸ ɫɢɝ-
ɧɚɬɭɪɵ ɮɭɧɤɰɢɢ, ɢ ɤɥɢɟɧɬɫɤɢɣ ɤɨɞ ɛɭɞɟɬ ɧɟɜɨɥɶɧɨ ɩɟɪɟɞɚɜɚɬɶ ɪɚɡɥɢɱɧɵɟ ɚɪɝɭɦɟɧɬɵ ɜ ɮɭɧɤɰɢɸ,
ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɨɝɨ, ɤɚɤɨɣ ɭɡɟɥ ɢɟɪɚɪɯɢɢ ɨɛɪɚɳɚɟɬɫɹ ɤ ɧɟɣ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɩɪɢɦɟɪ:
class Base {
// ...
virtual void Foo(int x = 0);
};
class Derived : public Base {
// ...
virtual void Foo(int x = 1); // ǖǾȂȃǰ ǽǫǵ Ǹǰ ǯǰǶǫǽȇ...
};
Derived *pD = new Derived;
pD->Foo(); // ǍȆǲǹǭ pD->Foo(1)
Base *pB = pD;
pB->Foo(); // ǍȆǲǹǭ pB->Foo(0)
38. Практикуйте безопасное перекрытие 81
Стр. 81
ɍ ɧɟɤɨɬɨɪɵɯ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɭɞɢɜɥɟɧɢɟ, ɱɬɨ ɨɞɧɚ ɢ ɬɚ ɠɟ ɮɭɧɤɰɢɹ-ɱɥɟɧ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ
ɨɛɴɟɤɬɚ ɩɨɥɭɱɚɟɬ ɪɚɡɧɵɟ ɚɪɝɭɦɟɧɬɵ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɫɬɚɬɢɱɟɫɤɨɝɨ ɬɢɩɚ, ɩɨɫɪɟɞɫɬɜɨɦ ɤɨɬɨ-
ɪɨɝɨ ɤ ɧɟɣ ɜɵɩɨɥɧɹɟɬɫɹ ɨɛɪɚɳɟɧɢɟ.
ɀɟɥɚɬɟɥɶɧɨ ɞɨɛɚɜɥɹɬɶ ɤɥɸɱɟɜɨɟ ɫɥɨɜɨ virtual ɩɪɢ ɩɟɪɟɤɪɵɬɢɢ ɮɭɧɤɰɢɣ, ɧɟɫɦɨɬɪɹ ɧɚ
ɟɝɨ ɢɡɛɵɬɨɱɧɨɫɬɶ — ɷɬɨ ɫɞɟɥɚɟɬ ɤɨɞ ɛɨɥɟɟ ɭɞɨɛɧɵɦ ɞɥɹ ɱɬɟɧɢɹ ɢ ɩɨɧɢɦɚɧɢɹ.
ɇɟ ɡɚɛɵɜɚɣɬɟ ɨ ɬɨɦ, ɱɬɨ ɩɟɪɟɤɪɵɬɢɟ ɦɨɠɟɬ ɫɤɪɵɜɚɬɶ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤɰɢɢ ɢɡ ɛɚɡɨɜɨɝɨ
ɤɥɚɫɫɚ, ɧɚɩɪɢɦɟɪ:
class Base{ // ...
virtual void Foo( int );
virtual void Foo( int, int );
void Foo( int, int, int );
};
class Derived : public Base { // ...

virtual void Foo( int ); // ǚǰǻǰǵǻȆǭǫǰǽ Base::Foo(int),
// ǼǵǻȆǭǫȊ ǹǼǽǫǶȇǸȆǰ ǿǾǸǵȁǳǳ
};
Derived d;
d.Foo( 1 ); // ǍǼǰ ǭ ǺǹǻȊǯǵǰ
d.Foo( 1, 2 ); // ǙȃǳǬǵǫ
d.Foo( 1, 2, 3 ); // ǙȃǳǬǵǫ
ȿɫɥɢ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤɰɢɢ ɢɡ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɧɵ ɛɵɬɶ ɜɢɞɢɦɵ, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ
ɨɛɴɹɜɥɟɧɢɟɦ using ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɬɨɪɧɨ ɨɛɴɹɜɢɬɶ ɢɯ ɜ ɩɪɨɢɡɜɨɞɧɨɦ ɤɥɚɫɫɟ:
class Derived : public Base { // ...
virtual void Foo( int ); // ǚǰǻǰǵǻȆǽǳǰ Base::Foo(int)
using Base::Foo; // ǍǸǹǼǳǽ ǭǼǰ ǺǻǹȂǳǰ ǺǰǻǰǮǻǾǲǵǳ
// Base::Foo ǭ ǹǬǶǫǼǽȇ ǭǳǯǳǷǹǼǽǳ
};
Примеры
ɉɪɢɦɟɪ: Ostrich (ɋɬɪɚɭɫ). ȿɫɥɢ ɤɥɚɫɫ Bird (ɉɬɢɰɚ) ɨɩɪɟɞɟɥɹɟɬ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ
Fly ɢ ɜɵ ɩɨɪɨɠɞɚɟɬɟ ɧɨɜɵɣ ɤɥɚɫɫ Ostrich (ɢɡɜɟɫɬɧɵɣ ɤɚɤ ɩɬɢɰɚ, ɤɨɬɨɪɚɹ ɧɟ ɥɟɬɚɟɬ) ɢɡ
ɤɥɚɫɫɚ Bird, ɬɨ ɤɚɤ ɜɵ ɪɟɚɥɢɡɭɟɬɟ Ostrich::Fly? Ɉɬɜɟɬ ɫɬɚɧɞɚɪɬɧɵɣ — “ɩɨ ɨɛɫɬɨɹɬɟɥɶɫɬ-
ɜɚɦ”. ȿɫɥɢ Bird::Fly ɝɚɪɚɧɬɢɪɭɟɬ ɭɫɩɟɲɧɨɫɬɶ (ɬ.ɟ. ɨɛɟɫɩɟɱɢɜɚɟɬ ɝɚɪɚɧɬɢɸ ɛɟɫɫɛɨɣɧɨɫɬɢ;
ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71), ɩɨɫɤɨɥɶɤɭ ɫɩɨɫɨɛɧɨɫɬɶ ɥɟɬɚɬɶ ɟɫɬɶ ɧɟɨɬɴɟɦɥɟɦɨɣ ɱɚɫɬɶɸ ɦɨɞɟɥɢ
Bird, ɬɨ ɤɥɚɫɫ Ostrich ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɚɞɟɤɜɚɬɧɨɣ ɪɟɚɥɢɡɚɰɢɟɣ ɬɚɤɨɣ ɦɨɞɟɥɢ.
Ссылки
[Dewhurst03] §73-74, §78-79 • [Sutter00] §21 • [Keffer95] p. 18
Стр. 82
39. Виртуальные функции стоит делать
неоткрытыми, а открытые —
невиртуальными
Резюме
ȼ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ ɫ ɜɵɫɨɤɨɣ ɫɬɨɢɦɨɫɬɶɸ ɢɡɦɟɧɟɧɢɣ (ɜ ɱɚɫɬɧɨɫɬɢ, ɜ ɛɢɛɥɢɨɬɟɤɚɯ) ɥɭɱɲɟ
ɞɟɥɚɬɶ ɨɬɤɪɵɬɵɟ ɮɭɧɤɰɢɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ. ȼɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɥɭɱɲɟ ɞɟɥɚɬɶ ɡɚɤɪɵɬɵɦɢ,
ɢɥɢ ɡɚɳɢɳɟɧɧɵɦɢ — ɟɫɥɢ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɞɨɥɠɟɧ ɢɦɟɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɜɵɡɵɜɚɬɶ ɢɯ ɛɚɡɨ-
ɜɵɟ ɜɟɪɫɢɢ (ɷɬɨɬ ɫɨɜɟɬ ɧɟ ɨɬɧɨɫɢɬɫɹ ɤ ɞɟɫɬɪɭɤɬɨɪɚɦ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50).
Ȼɨɥɶɲɢɧɫɬɜɨ ɢɡ ɧɚɫ ɧɚ ɫɨɛɫɬɜɟɧɧɨɦ ɝɨɪɶɤɨɦ ɨɩɵɬɟ ɜɵɭɱɢɥɨ ɩɪɚɜɢɥɨ, ɱɬɨ ɱɥɟɧɵ ɤɥɚɫɫɚ
ɞɨɥɠɧɵ ɛɵɬɶ ɡɚɤɪɵɬɵɦɢ, ɟɫɥɢ ɬɨɥɶɤɨ ɦɵ ɧɟ ɯɨɬɢɦ ɫɩɟɰɢɚɥɶɧɨ ɨɛɟɫɩɟɱɢɬɶ ɞɨɫɬɭɩ ɤ ɧɢɦ ɫɨ
ɫɬɨɪɨɧɵ ɜɧɟɲɧɟɝɨ ɤɨɞɚ. ɗɬɨ ɩɪɨɫɬɨ ɩɪɚɜɢɥɨ ɯɨɪɨɲɟɝɨ ɬɨɧɚ ɨɛɵɱɧɨɣ ɢɧɤɚɩɫɭɥɹɰɢɢ. ȼ ɨɫ-
ɧɨɜɧɨɦ ɷɬɨ ɩɪɚɜɢɥɨ ɩɪɢɦɟɧɢɦɨ ɤ ɱɥɟɧɚɦ-ɞɚɧɧɵɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41), ɧɨ ɟɝɨ ɦɨɠɧɨ ɫ ɬɟɦ
ɠɟ ɭɫɩɟɯɨɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɥɸɛɵɯ ɱɥɟɧɨɜ ɤɥɚɫɫɚ, ɜɤɥɸɱɚɹ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ.
ȼ ɱɚɫɬɧɨɫɬɢ, ɜ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɵɯ ɢɟɪɚɪɯɢɹɯ, ɜɧɟɫɟɧɢɟ ɢɡɦɟɧɟɧɢɣ ɜ ɤɨɬɨɪɵɟ ɨɛ-
ɯɨɞɢɬɫɹ ɞɨɫɬɚɬɨɱɧɨ ɞɨɪɨɝɨ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɚ ɩɨɥɧɚɹ ɚɛɫɬɪɚɤɰɢɹ: ɥɭɱɲɟ ɞɟɥɚɬɶ ɨɬɤɪɵɬɵɟ
ɮɭɧɤɰɢɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ, ɚ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ — ɡɚɤɪɵɬɵɦɢ (ɢɥɢ ɡɚɳɢɳɟɧɧɵɦɢ, ɟɫɥɢ
ɩɪɨɢɡɜɨɞɧɵɟ ɤɥɚɫɫɵ ɞɨɥɠɧɵ ɢɦɟɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɜɵɡɵɜɚɬɶ ɛɚɡɨɜɵɟ ɜɟɪɫɢɢ). ɗɬɨ — ɲɚɛɥɨɧ
ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Nonvirtual Interface (NVI). (ɗɬɨɬ ɲɚɛɥɨɧ ɩɨɯɨɠ ɧɚ ɞɪɭɝɢɟ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɧɚ
Template Method [Gamma95], ɧɨ ɢɦɟɟɬ ɞɪɭɝɭɸ ɦɨɬɢɜɚɰɢɸ ɢ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ.)
Ɉɬɤɪɵɬɚɹ ɜɢɪɬɭɚɥɶɧɚɹ ɮɭɧɤɰɢɹ ɩɨ ɫɜɨɟɣ ɩɪɢɪɨɞɟ ɪɟɲɚɟɬ ɞɜɟ ɪɚɡɥɢɱɧɵɟ ɩɚɪɚɥɥɟɥɶɧɵɟ ɡɚɞɚɱɢ.
• Ɉɧɚ ɨɩɪɟɞɟɥɹɟɬ ɢɧɬɟɪɮɟɣɫ. Ȼɭɞɭɱɢ ɨɬɤɪɵɬɨɣ, ɬɚɤɚɹ ɮɭɧɤɰɢɹ ɹɜɥɹɟɬɫɹ ɧɟɩɨɫɪɟɞɫɬ-
ɜɟɧɧɨɣ ɱɚɫɬɶɸ ɢɧɬɟɪɮɟɣɫɚ ɤɥɚɫɫɚ, ɩɪɟɞɨɫɬɚɜɥɟɧɧɨɝɨ ɜɧɟɲɧɟɦɭ ɦɢɪɭ.
• Ɉɧɚ ɨɩɪɟɞɟɥɹɟɬ ɞɟɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ. Ȼɭɞɭɱɢ ɜɢɪɬɭɚɥɶɧɨɣ, ɮɭɧɤɰɢɹ ɩɪɟɞɨɫɬɚɜɥɹɟɬ
ɩɪɨɢɡɜɨɞɧɨɦɭ ɤɥɚɫɫɭ ɜɨɡɦɨɠɧɨɫɬɶ ɡɚɦɟɧɢɬɶ ɛɚɡɨɜɭɸ ɪɟɚɥɢɡɚɰɢɸ ɷɬɨɣ ɮɭɧɤɰɢɢ (ɟɫɥɢ
ɬɚɤɨɜɚɹ ɢɦɟɟɬɫɹ), ɜ ɱɟɦ ɢ ɫɨɫɬɨɢɬ ɰɟɥɶ ɧɚɫɬɪɨɣɤɢ.
ȼ ɫɜɹɡɢ ɫ ɫɭɳɟɫɬɜɟɧɧɵɦ ɪɚɡɥɢɱɢɟɦ ɰɟɥɟɣ ɷɬɢɯ ɞɜɭɯ ɡɚɞɚɱ, ɨɧɢ ɦɨɝɭɬ ɤɨɧɮɥɢɤɬɨɜɚɬɶ ɞɪɭɝ
ɫ ɞɪɭɝɨɦ (ɢ ɡɚɱɚɫɬɭɸ ɬɚɤ ɢ ɩɪɨɢɫɯɨɞɢɬ), ɬɚɤ ɱɬɨ ɨɞɧɚ ɮɭɧɤɰɢɹ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɜ ɩɨɥɧɨɣ ɦɟɪɟ
ɪɟɲɢɬɶ ɨɞɧɨɜɪɟɦɟɧɧɨ ɞɜɟ ɡɚɞɚɱɢ. Ɍɨ, ɱɬɨ ɩɟɪɟɞ ɨɬɤɪɵɬɨɣ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɟɣ ɫɬɚɜɹɬɫɹ
ɞɜɟ ɫɭɳɟɫɬɜɟɧɧɨ ɪɚɡɥɢɱɧɵɟ ɡɚɞɚɱɢ, ɹɜɥɹɟɬɫɹ ɩɪɢɡɧɚɤɨɦ ɧɟɞɨɫɬɚɬɨɱɧɨ ɯɨɪɨɲɟɝɨ ɪɚɡɞɟɥɟɧɢɹ
ɡɨɧ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɢ ɢ ɩɨ ɫɭɬɢ ɧɚɪɭɲɟɧɢɹ ɪɟɤɨɦɟɧɞɚɰɢɣ 5 ɢ 11, ɬɚɤ ɱɬɨ ɧɚɦ ɫɥɟɞɭɟɬ ɪɚɫɫɦɨɬ-
ɪɟɬɶ ɢɧɨɣ ɩɨɞɯɨɞ ɤ ɩɪɨɟɤɬɢɪɨɜɚɧɢɸ.
ɉɭɬɟɦ ɪɚɡɞɟɥɟɧɢɹ ɨɬɤɪɵɬɵɯ ɮɭɧɤɰɢɣ ɨɬ ɜɢɪɬɭɚɥɶɧɵɯ ɦɵ ɞɨɫɬɢɝɚɟɦ ɫɥɟɞɭɸɳɢɯ ɡɧɚɱɢ-
ɬɟɥɶɧɵɯ ɩɪɟɢɦɭɳɟɫɬɜ.
• Ʉɚɠɞɵɣ ɢɧɬɟɪɮɟɣɫ ɦɨɠɟɬ ɩɪɢɨɛɪɟɫɬɢ ɫɜɨɣ ɟɫɬɟɫɬɜɟɧɧɵɣ ɜɢɞ. Ʉɨɝɞɚ ɦɵ ɪɚɡɞɟɥɹɟɦ
ɨɬɤɪɵɬɵɣ ɢɧɬɟɪɮɟɣɫ ɨɬ ɢɧɬɟɪɮɟɣɫɚ ɧɚɫɬɪɨɣɤɢ, ɤɚɠɞɵɣ ɢɡ ɧɢɯ ɦɨɠɟɬ ɥɟɝɤɨ ɩɪɢɨɛɪɟ-
ɫɬɢ ɬɨɬ ɜɢɞ, ɤɨɬɨɪɵɣ ɞɥɹ ɧɟɝɨ ɧɚɢɛɨɥɟɟ ɟɫɬɟɫɬɜɟɧɟɧ, ɧɟ ɩɵɬɚɹɫɶ ɧɚɣɬɢ ɤɨɦɩɪɨɦɢɫɫ,
ɤɨɬɨɪɵɣ ɡɚɫɬɚɜɢɬ ɢɯ ɜɵɝɥɹɞɟɬɶ ɢɞɟɧɬɢɱɧɨ. Ɂɚɱɚɫɬɭɸ ɷɬɢ ɞɜɚ ɢɧɬɟɪɮɟɣɫɚ ɬɪɟɛɭɸɬ ɪɚɡ-
ɥɢɱɧɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɮɭɧɤɰɢɣ ɢ/ɢɥɢ ɪɚɡɥɢɱɧɵɯ ɩɚɪɚɦɟɬɪɨɜ; ɧɚɩɪɢɦɟɪ, ɜɧɟɲɧɹɹ ɜɵɡɵ-
ɜɚɸɳɚɹ ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɜɵɩɨɥɧɢɬɶ ɜɵɡɨɜ ɨɞɧɨɣ ɨɬɤɪɵɬɨɣ ɮɭɧɤɰɢɢ Process, ɤɨɬɨɪɚɹ
ɜɵɩɨɥɧɹɟɬ ɥɨɝɢɱɟɫɤɭɸ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɪɚɡɪɚɛɨɬɱɢɤ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ
ɦɨɠɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɩɟɪɟɤɪɵɬɶ ɬɨɥɶɤɨ ɧɟɤɨɬɨɪɵɟ ɱɚɫɬɢ ɷɬɨɣ ɪɚɛɨɬɵ, ɱɬɨ ɟɫɬɟɫɬɜɟɧɧɵɦ
39. Виртуальные функции стоит делать неоткрытыми, а открытые — невиртуальными 83
Стр. 83
ɨɛɪɚɡɨɦ ɦɨɞɟɥɢɪɭɟɬɫɹ ɩɭɬɟɦ ɧɟɡɚɜɢɫɢɦɨ ɩɟɪɟɤɪɵɜɚɟɦɵɯ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ
(ɧɚɩɪɢɦɟɪ, DoProcessPhase1, DoProcessPhase2), ɬɚɤ ɱɬɨ ɩɪɨɢɡɜɨɞɧɨɦɭ ɤɥɚɫɫɭ
ɧɟɬ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɩɟɪɟɤɪɵɜɚɬɶ ɢɯ ɜɫɟ (ɬɨɱɧɟɟ ɝɨɜɨɪɹ, ɞɚɧɧɵɣ ɩɪɢɦɟɪ ɦɨɠɧɨ ɪɚɫ-
ɫɦɚɬɪɢɜɚɬɶ ɤɚɤ ɩɪɢɦɟɧɟɧɢɟ ɲɚɛɥɨɧɚ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Template Method).
• ɍɩɪɚɜɥɟɧɢɟ ɛɚɡɨɜɵɦ ɤɥɚɫɫɨɦ. Ɍɟɩɟɪɶ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɧɚɯɨɞɢɬɫɹ ɩɨɞ ɩɨɥɧɵɦ ɤɨɧɬɪɨɥɟɦ
ɫɜɨɟɝɨ ɢɧɬɟɪɮɟɣɫɚ ɢ ɫɬɪɚɬɟɝɢɢ ɢ ɦɨɠɟɬ ɨɛɟɫɩɟɱɢɬɶ ɩɨɫɬ- ɢ ɩɪɟɞɭɫɥɨɜɢɹ ɢɧɬɟɪɮɟɣɫɚ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 14 ɢ 68), ɩɪɢɱɟɦ ɜɵɩɨɥɧɢɬɶ ɜɫɸ ɷɬɭ ɪɚɛɨɬɭ ɜ ɨɞɧɨɦ ɭɞɨɛɧɨɦ ɩɨ-
ɜɬɨɪɧɨ ɢɫɩɨɥɶɡɭɟɦɨɦ ɦɟɫɬɟ — ɧɟɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ ɢɧɬɟɪɮɟɣɫɚ. Ɍɚɤɨɟ
“ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɟ ɪɚɡɥɨɠɟɧɢɟ” ɨɛɟɫɩɟɱɢɜɚɟɬ ɥɭɱɲɢɣ ɞɢɡɚɣɧ ɤɥɚɫɫɚ.
• Ȼɚɡɨɜɵɣ ɤɥɚɫɫ ɛɨɥɟɟ ɭɫɬɨɣɱɢɜ ɤ ɢɡɦɟɧɟɧɢɹɦ. Ɇɵ ɦɨɠɟɦ ɩɨɡɠɟ ɢɡɦɟɧɢɬɶ ɧɚɲɟ ɦɧɟɧɢɟ
ɢ ɞɨɛɚɜɢɬɶ ɧɟɤɨɬɨɪɭɸ ɩɪɨɜɟɪɤɭ ɩɨɫɬ- ɢɥɢ ɩɪɟɞɭɫɥɨɜɢɣ, ɢɥɢ ɪɚɡɞɟɥɢɬɶ ɜɵɩɨɥɧɟɧɢɟ ɪɚ-
ɛɨɬɵ ɧɚ ɛɨɥɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ ɲɚɝɨɜ ɢɥɢ ɩɟɪɟɞɟɥɚɬɶ ɟɟ, ɪɟɚɥɢɡɨɜɚɬɶ ɛɨɥɟɟ ɩɨɥɧɨɟ ɪɚɡ-
ɞɟɥɟɧɢɟ ɢɧɬɟɪɮɟɣɫɚ ɢ ɪɟɚɥɢɡɚɰɢɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 43), ɢɥɢ ɜɧɟɫɬɢ ɢɧɵɟ ɢɡɦɟɧɟɧɢɹ ɜ ɛɚɡɨɜɵɣ ɤɥɚɫɫ, ɢ ɜɫɟ ɷɬɨ ɧɢɤɚɤ ɧɟ ɩɨɜɥɢɹɟɬ ɧɚ
ɤɨɞ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɞɚɧɧɵɣ ɤɥɚɫɫ ɢɥɢ ɧɚɫɥɟɞɭɸɳɢɣ ɟɝɨ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɝɨɪɚɡɞɨ ɩɪɨɳɟ
ɧɚɱɚɬɶ ɪɚɛɨɬɭ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɹ NVI (ɞɚɠɟ ɟɫɥɢ ɨɬɤɪɵɬɵɟ ɮɭɧɤɰɢɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ
ɨɞɧɨɫɬɪɨɱɧɵɟ ɜɵɡɨɜɵ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɯ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ), ɚ ɭɠɟ ɩɨɡɠɟ ɞɨɛɚɜ-
ɥɹɬɶ ɜɫɟ ɩɪɨɜɟɪɤɢ ɢ ɢɧɫɬɪɭɦɟɧɬɚɥɶɧɵɟ ɫɪɟɞɫɬɜɚ, ɩɨɫɤɨɥɶɤɭ ɷɬɚ ɪɚɛɨɬɚ ɧɢɤɚɤ ɧɟ ɩɨ-
ɜɥɢɹɟɬ ɧɚ ɤɨɞ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɢɥɢ ɧɚɫɥɟɞɭɸɳɢɣ ɞɚɧɧɵɣ ɤɥɚɫɫ. ɋɢɬɭɚɰɢɹ ɨɤɚɠɟɬɫɹ
ɫɭɳɟɫɬɜɟɧɧɨ ɫɥɨɠɧɟɟ, ɟɫɥɢ ɧɚɱɚɬɶ ɫ ɨɬɤɪɵɬɵɯ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɢ ɩɨɡɠɟ ɢɡɦɟ-
ɧɹɬɶ ɢɯ, ɱɬɨ ɧɟɢɡɛɟɠɧɨ ɩɪɢɜɟɞɟɬ ɤ ɢɡɦɟɧɟɧɢɹɦ ɥɢɛɨ ɜ ɤɨɞɟ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɞɚɧ-
ɧɵɣ ɤɥɚɫɫ, ɥɢɛɨ ɜ ɧɚɫɥɟɞɭɸɳɟɦ ɟɝɨ.
ɋɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 54.
NVI ɧɟ ɩɪɢɦɟɧɢɦ ɤ ɞɟɫɬɪɭɤɬɨɪɚɦ ɜ ɫɜɹɡɢ ɫɨ ɫɩɟɰɢɚɥɶɧɵɦ ɩɨɪɹɞɤɨɦ ɢɯ ɜɵɩɨɥɧɟɧɢɹ (ɫɦ. ɪɟ-
ɤɨɦɟɧɞɚɰɢɸ 50).
NVI ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɧɟ ɩɨɞɞɟɪɠɢɜɚɟɬ ɤɨɜɚɪɢɚɧɬɧɵɟ ɜɨɡɜɪɚɳɚɟɦɵɟ ɬɢɩɵ. ȿɫɥɢ ɜɚɦ ɬɪɟɛɭ-
ɟɬɫɹ ɤɨɜɚɪɢɚɧɬɧɨɫɬɶ, ɜɢɞɢɦɚɹ ɜɵɡɵɜɚɸɳɟɦɭ ɤɨɞɭ ɛɟɡ ɢɫɩɨɥɶɡɨɜɚɧɢɹ dynamic_cast (ɫɦ. ɬɚɤɠɟ
ɪɟɤɨɦɟɧɞɚɰɢɸ 93), ɩɪɨɳɟ ɫɞɟɥɚɬɶ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ ɨɬɤɪɵɬɨɣ.
Ссылки
[Allison98] §10 • [Dewhurst03] §72 • [Gamma95] • [Keffer95 pp. 6-7] • [Koenig97] §11 •
[Sutter00] §19, §23 • [Sutter04] §18
Стр. 84
40. Избегайте возможностей неявного
преобразования типов
Резюме
ɇɟ ɜɫɟ ɢɡɦɟɧɟɧɢɹ ɩɪɨɝɪɟɫɫɢɜɧɵ: ɧɟɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɡɚɱɚɫɬɭɸ ɩɪɢɧɨɫɹɬ ɛɨɥɶɲɟ ɜɪɟ-
ɞɚ, ɱɟɦ ɩɨɥɶɡɵ. Ⱦɜɚɠɞɵ ɩɨɞɭɦɚɣɬɟ ɩɟɪɟɞ ɬɟɦ, ɤɚɤ ɩɪɟɞɨɫɬɚɜɢɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɧɟɹɜɧɨɝɨ ɩɪɟ-
ɨɛɪɚɡɨɜɚɧɢɹ ɤ ɬɢɩɭ ɢ ɢɡ ɬɢɩɚ, ɤɨɬɨɪɵɣ ɜɵ ɨɩɪɟɞɟɥɹɟɬɟ, ɢ ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɹɜɧɵɟ
ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ (ɢɫɩɨɥɶɡɭɣɬɟ ɤɨɧɫɬɪɭɤɬɨɪɵ, ɨɛɴɹɜɥɟɧɧɵɟ ɤɚɤ explicit, ɢ ɢɦɟɧɨɜɚɧɧɵɟ
ɮɭɧɤɰɢɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ).
ɇɟɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɢɦɟɸɬ ɞɜɟ ɨɫɧɨɜɧɵɟ ɩɪɨɛɥɟɦɵ.
• Ɉɧɢ ɦɨɝɭɬ ɩɪɨɹɜɢɬɶɫɹ ɜ ɫɚɦɵɯ ɧɟɨɠɢɞɚɧɧɵɯ ɦɟɫɬɚɯ.
• Ɉɧɢ ɧɟ ɜɫɟɝɞɚ ɯɨɪɨɲɨ ɫɨɝɥɚɫɭɸɬɫɹ ɫ ɨɫɬɚɥɶɧɵɦɢ ɱɚɫɬɹɦɢ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
ɇɟɹɜɧɨ ɩɪɟɨɛɪɚɡɭɸɳɢɟ ɤɨɧɫɬɪɭɤɬɨɪɵ (ɤɨɧɫɬɪɭɤɬɨɪɵ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɛɵɬɶ ɜɵɡɜɚɧɵ ɫ ɨɞ-
ɧɢɦ ɚɪɝɭɦɟɧɬɨɦ ɢ ɧɟ ɨɛɴɹɜɥɟɧɵ ɤɚɤ explicit) ɩɥɨɯɨ ɜɡɚɢɦɨɞɟɣɫɬɜɭɸɬ ɫ ɩɟɪɟɝɪɭɡɤɨɣ ɢ ɩɪɢ-
ɜɨɞɹɬ ɤ ɫɨɡɞɚɧɢɸ ɧɟɜɢɞɢɦɵɯ ɜɪɟɦɟɧɧɵɯ ɨɛɴɟɤɬɨɜ. ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ, ɨɩɪɟɞɟɥɟɧɧɵɟ ɤɚɤ
ɮɭɧɤɰɢɢ-ɱɥɟɧɵ ɜɢɞɚ operator T (ɝɞɟ T — ɬɢɩ), ɧɢɱɭɬɶ ɧɟ ɥɭɱɲɟ — ɨɧɢ ɩɥɨɯɨ ɜɡɚɢɦɨɞɟɣ-
ɫɬɜɭɸɬ ɫ ɧɟɹɜɧɵɦɢ ɤɨɧɫɬɪɭɤɬɨɪɚɦɢ ɢ ɩɨɡɜɨɥɹɸɬ ɛɟɡ ɨɲɢɛɨɤ ɫɤɨɦɩɢɥɢɪɨɜɚɬɶ ɪɚɡɧɨɨɛɪɚɡɧɵɟ
ɛɟɫɫɦɵɫɥɟɧɧɵɟ ɮɪɚɝɦɟɧɬɵ ɤɨɞɚ (ɩɪɢɦɟɪɨɜ ɱɟɝɨ ɧɟɫɬɶ ɱɢɫɥɚ — ɫɦ. ɩɪɢɜɟɞɟɧɧɵɟ ɜ ɤɨɧɰɟ ɪɟ-
ɤɨɦɟɧɞɚɰɢɢ ɫɫɵɥɤɢ; ɦɵ ɩɪɢɜɟɞɟɦ ɡɞɟɫɶ ɬɨɥɶɤɨ ɩɚɪɭ ɢɡ ɧɢɯ).
ȼ C++ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ ɬɢɩɨɜ ɦɨɠɟɬ ɜɤɥɸɱɚɬɶ ɧɟ ɛɨɥɟɟ ɨɞɧɨɝɨ ɩɨɥɶ-
ɡɨɜɚɬɟɥɶɫɤɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ. Ɉɞɧɚɤɨ ɤɨɝɞɚ ɜ ɷɬɭ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɞɨɛɚɜɥɹɸɬɫɹ ɜɫɬɪɨɟɧ-
ɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ, ɫɢɬɭɚɰɢɹ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɩɪɟɞɟɥɶɧɨ ɡɚɩɭɬɚɧɧɨɣ. Ɋɟɲɟɧɢɟ ɡɞɟɫɶ ɩɪɨ-
ɫɬɨɟ ɢ ɫɨɫɬɨɢɬ ɜ ɫɥɟɞɭɸɳɟɦ.
• ɉɨ ɭɦɨɥɱɚɧɢɸ ɢɫɩɨɥɶɡɭɣɬɟ explicit ɜ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɫ ɨɞɧɢɦ ɚɪɝɭɦɟɧɬɨɦ (ɫɦ. ɪɟ-
ɤɨɦɟɧɞɚɰɢɸ 54):
class Widget { // ...
explicit Widget(unsigned int widgetizationFactor);
explicit Widget(const char* name, const Widget* other = 0);
};
• ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ ɬɢɩɨɜ ɢɦɟɧɨɜɚɧɧɵɟ ɮɭɧɤɰɢɢ, ɚ ɧɟ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ
ɨɩɟɪɚɬɨɪɵ:
class String { // ...
const char* as_char_pointer () const; // Ǎ ǽǻǫǯǳȁǳȊȀ c_str
};
ɋɦ. ɬɚɤɠɟ ɨɛɫɭɠɞɟɧɢɟ ɤɨɩɢɪɭɸɳɢɯ ɤɨɧɫɬɪɭɤɬɨɪɨɜ, ɨɛɴɹɜɥɟɧɧɵɯ ɤɚɤ explicit, ɜ ɪɟɤɨ-
ɦɟɧɞɚɰɢɢ 54.
Примеры
ɉɪɢɦɟɪ 1. ɉɟɪɟɝɪɭɡɤɚ. ɉɭɫɬɶ ɭ ɧɚɫ ɟɫɬɶ, ɧɚɩɪɢɦɟɪ, Widget::Widget(unsigned int),
ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧ ɧɟɹɜɧɨ, ɢ ɮɭɧɤɰɢɹ Display, ɩɟɪɟɝɪɭɠɟɧɧɚɹ ɞɥɹ Widget
ɢ double. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɫɸɪɩɪɢɡ ɩɪɢ ɪɚɡɪɟɲɟɧɢɢ ɩɟɪɟɝɪɭɡɤɢ:
40. Избегайте возможностей неявного преобразования типов 85
Стр. 85
void Display(double); // ǍȆǭǹǯ double
void Display(const Widget&); // ǍȆǭǹǯ Widget
Display(5); // ǎǷ! ǜǹǲǯǫǸǳǰ ǳ ǭȆǭǹǯ Widget
ɉɪɢɦɟɪ 2. Ɋɚɛɨɬɚɸɳɢɟ ɨɲɢɛɤɢ. Ⱦɨɩɭɫɬɢɦ, ɜɵ ɫɧɚɛɞɢɥɢ ɤɥɚɫɫ String ɨɩɟɪɚɬɨɪɨɦ
operator const char*:
class String {
// ...
public:
operator const char*(); // ǎǻǾǼǽǸǹǰ ǻǰȃǰǸǳǰ...
};
ȼ ɪɟɡɭɥɶɬɚɬɟ ɷɬɨɝɨ ɫɬɚɧɨɜɹɬɫɹ ɤɨɦɩɢɥɢɪɭɟɦɵɦɢ ɦɚɫɫɚ ɝɥɭɩɨɫɬɟɣ ɢ ɨɩɟɱɚɬɨɤ. ɉɭɫɬɶ s1 ɢ s2 —
ɨɛɴɟɤɬɵ ɬɢɩɚ String. ȼɫɟ ɩɪɢɜɟɞɟɧɧɵɟ ɧɢɠɟ ɫɬɪɨɤɢ ɤɨɦɩɢɥɢɪɭɸɬɫɹ:
int x = s1 - s2; // ǘǰǹǺǻǰǯǰǶǰǸǸǹǰ ǺǹǭǰǯǰǸǳǰ
const char* p = s1 - 5; // ǘǰǹǺǻǰǯǰǶǰǸǸǹǰ ǺǹǭǰǯǰǸǳǰ
p = s1 + '0'; // ǏǰǶǫǰǽ Ǹǰ ǽǹ, Ȃǽǹ ǭȆ ǹǱǳǯǫǰǽǰ
if( s1 == "0" ) { ... } // ǏǰǶǫǰǽ Ǹǰ ǽǹ, Ȃǽǹ ǭȆ ǹǱǳǯǫǰǽǰ
ɂɦɟɧɧɨ ɩɨ ɷɬɨɣ ɩɪɢɱɢɧɟ ɜ ɫɬɚɧɞɚɪɬɧɨɦ ɤɥɚɫɫɟ string ɨɬɫɭɬɫɬɜɭɟɬ operator const char*.
ɉɪɢ ɧɟɱɚɫɬɨɦ ɢ ɨɫɬɨɪɨɠɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɧɟɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɦɨɝɭɬ ɫɞɟɥɚɬɶ
ɤɨɞ ɛɨɥɟɟ ɤɨɪɨɬɤɢɦ ɢ ɢɧɬɭɢɬɢɜɧɨ ɛɨɥɟɟ ɩɨɧɹɬɧɵɦ. ɋɬɚɧɞɚɪɬɧɵɣ ɤɥɚɫɫ std::string ɨɩɪɟ-
ɞɟɥɹɟɬ ɧɟɹɜɧɵɣ ɤɨɧɫɬɪɭɤɬɨɪ, ɤɨɬɨɪɵɣ ɩɨɥɭɱɚɟɬ ɨɞɢɧ ɚɪɝɭɦɟɧɬ ɬɢɩɚ const char*. Ɍɚɤɨɟ
ɪɟɲɟɧɢɟ ɨɬɥɢɱɧɨ ɪɚɛɨɬɚɟɬ, ɩɨɫɤɨɥɶɤɭ ɩɪɨɟɤɬɢɪɨɜɳɢɤɢ ɤɥɚɫɫɚ ɩɪɢɧɹɥɢ ɨɩɪɟɞɟɥɟɧɧɵɟ ɦɟɪɵ
ɩɪɟɞɨɫɬɨɪɨɠɧɨɫɬɢ.
• ɇɟ ɢɦɟɟɬɫɹ ɚɜɬɨɦɚɬɢɱɟɫɤɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ std::string ɜ const char*; ɬɚɤɨɟ
ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜɵɩɨɥɧɹɸɬɫɹ ɩɪɢ ɩɨɦɨɳɢ ɞɜɭɯ ɢɦɟɧɨɜɚɧɧɵɯ ɮɭɧɤɰɢɣ —
c_str ɢ data.
• ȼɫɟ ɨɩɟɪɚɬɨɪɵ ɫɪɚɜɧɟɧɢɣ, ɨɩɪɟɞɟɥɟɧɧɵɟ ɞɥɹ std::string (ɧɚɩɪɢɦɟɪ, ==, !=, <), ɩɟ-
ɪɟɝɪɭɠɟɧɵ ɞɥɹ ɫɪɚɜɧɟɧɢɹ const char* ɢ std::string ɜ ɥɸɛɨɦ ɩɨɪɹɞɤɟ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 29). ɗɬɨ ɩɨɡɜɨɥɹɟɬ ɢɡɛɟɠɚɬɶ ɫɨɡɞɚɧɢɹ ɫɤɪɵɬɵɯ ɜɪɟɦɟɧɧɵɯ ɩɟɪɟɦɟɧɧɵɯ.
ɇɨ ɢ ɩɪɢ ɷɬɨɦ ɜɨɡɧɢɤɚɸɬ ɨɩɪɟɞɟɥɟɧɧɵɟ ɧɟɩɪɢɹɬɧɨɫɬɢ, ɫɜɹɡɚɧɧɵɟ ɫ ɩɟɪɟɝɪɭɡɤɨɣ ɮɭɧɤɰɢɣ.
void Display( int );
void Display( std::string );
Display( NULL ); // ǍȆǲǹǭ Display(int)
ɗɬɨɬ ɪɟɡɭɥɶɬɚɬ ɞɥɹ ɧɟɤɨɬɨɪɵɯ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɫɸɪɩɪɢɡɨɦ. (Ʉɫɬɚɬɢ, ɟɫɥɢ ɛɵ ɜɵɩɨɥɧɹɥɫɹ ɜɵ-
ɡɨɜ Display(std::string), ɤɨɞ ɛɵ ɨɛɥɚɞɚɥ ɧɟɨɩɪɟɞɟɥɟɧɧɵɦ ɩɨɜɟɞɟɧɢɟɦ, ɩɨɫɤɨɥɶɤɭ ɫɨɡ-
ɞɚɧɢɟ std::string ɢɡ ɧɭɥɟɜɨɝɨ ɭɤɚɡɚɬɟɥɹ ɧɟɤɨɪɪɟɤɬɧɨ, ɧɨ ɤɨɧɫɬɪɭɤɬɨɪ ɷɬɨɝɨ ɤɥɚɫɫɚ ɧɟ ɨɛɹ-
ɡɚɧ ɩɪɨɜɟɪɹɬɶ ɩɟɪɟɞɚɜɚɟɦɨɟ ɟɦɭ ɡɧɚɱɟɧɢɟ ɧɚ ɪɚɜɟɧɫɬɜɨ ɧɭɥɸ.)
Ссылки
[Dewhurst03] §36-37 • [Lakos96] §9.3.1 • [Meyers96] §5 • [Murray93] §2.4 • [Sutter00] §6, §20, §39
Стр. 86
41. Делайте данные@члены закрытыми (кроме
случая агрегатов в стиле структур C)
Резюме
Ⱦɚɧɧɵɟ-ɱɥɟɧɵ ɞɨɥɠɧɵ ɛɵɬɶ ɡɚɤɪɵɬɵ. Ɍɨɥɶɤɨ ɜ ɫɥɭɱɚɟ ɩɪɨɫɬɟɣɲɢɯ ɬɢɩɨɜ ɜ ɫɬɢɥɟ ɫɬɪɭɤ-
ɬɭɪ ɹɡɵɤɚ C, ɨɛɴɟɞɢɧɹɸɳɢɯ ɜ ɟɞɢɧɨɟ ɰɟɥɨɟ ɧɚɛɨɪ ɡɧɚɱɟɧɢɣ, ɧɟ ɩɪɟɬɟɧɞɭɸɳɢɯ ɧɚ ɢɧɤɚɩɫɭɥɹ-
ɰɢɸ ɢ ɧɟ ɨɛɟɫɩɟɱɢɜɚɸɳɢɯ ɩɨɜɟɞɟɧɢɟ, ɞɟɥɚɣɬɟ ɜɫɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɨɬɤɪɵɬɵɦɢ. ɂɡɛɟɝɚɣɬɟ
ɫɦɟɲɢɜɚɧɢɹ ɨɬɤɪɵɬɵɯ ɢ ɡɚɤɪɵɬɵɯ ɞɚɧɧɵɯ, ɱɬɨ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟɝɞɚ ɝɨɜɨɪɢɬ ɨ ɛɟɫɬɨɥɤɨɜɨɦ
ɞɢɡɚɣɧɟ.
ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ ɹɜɥɹɟɬɫɹ ɤɥɸɱɨɦ ɤ ɤɚɱɟɫɬɜɟɧɧɨɣ ɪɚɡɪɚɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫ-
ɩɟɱɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). ɀɟɥɚɬɟɥɶɧɨ ɞɟɥɚɬɶ ɜɫɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɡɚɤɪɵɬɵɦɢ; ɡɚɤɪɵɬɵɟ
ɞɚɧɧɵɟ — ɥɭɱɲɟɟ ɫɪɟɞɫɬɜɨ ɞɥɹ ɫɨɯɪɚɧɟɧɢɹ ɢɧɜɚɪɢɚɧɬɚ ɤɥɚɫɫɚ, ɜ ɬɨɦ ɱɢɫɥɟ ɩɪɢ ɜɨɡɦɨɠɧɵɯ
ɜɧɨɫɢɦɵɯ ɢɡɦɟɧɟɧɢɹɯ.
Ɉɬɤɪɵɬɵɟ ɞɚɧɧɵɟ — ɩɥɨɯɚɹ ɢɞɟɹ, ɟɫɥɢ ɤɥɚɫɫ ɦɨɞɟɥɢɪɭɟɬ ɧɟɤɨɬɨɪɭɸ ɚɛɫɬɪɚɤɰɢɸ ɢ, ɫɥɟ-
ɞɨɜɚɬɟɥɶɧɨ, ɞɨɥɠɟɧ ɩɨɞɞɟɪɠɢɜɚɬɶ ɢɧɜɚɪɢɚɧɬɵ. ɇɚɥɢɱɢɟ ɨɬɤɪɵɬɵɯ ɞɚɧɧɵɯ ɨɡɧɚɱɚɟɬ, ɱɬɨ
ɱɚɫɬɶ ɫɨɫɬɨɹɧɢɹ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɦɨɠɟɬ ɢɡɦɟɧɹɬɶɫɹ ɧɟɤɨɧɬɪɨɥɢɪɭɟɦɨ, ɧɟɩɪɟɞɫɤɚɡɭɟɦɨ ɢ ɚɫɢɧ-
ɯɪɨɧɧɨ ɫ ɨɫɬɚɥɶɧɨɣ ɱɚɫɬɶɸ ɫɨɫɬɨɹɧɢɹ. ɗɬɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɚɛɫɬɪɚɤɰɢɹ ɪɚɡɞɟɥɹɟɬ ɨɬɜɟɬɫɬɜɟɧ-
ɧɨɫɬɶ ɡɚ ɩɨɞɞɟɪɠɚɧɢɟ ɨɞɧɨɝɨ ɢɥɢ ɧɟɫɤɨɥɶɤɢɯ ɢɧɜɚɪɢɚɧɬɨɜ ɫ ɧɟɨɝɪɚɧɢɱɟɧɧɵɦ ɦɧɨɠɟɫɬɜɨɦ
ɤɨɞɚ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɷɬɭ ɚɛɫɬɪɚɤɰɢɸ, ɢ ɫɨɜɟɪɲɟɧɧɨ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɬɚɤɨɟ ɩɨɥɨɠɟɧɢɟ ɞɟɥ
ɩɪɨɫɬɨ ɧɟɞɨɩɭɫɬɢɦɨ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɤɨɪɪɟɤɬɧɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
Ɂɚɳɢɳɟɧɧɵɟ ɞɚɧɧɵɟ ɨɛɥɚɞɚɸɬ ɜɫɟɦɢ ɧɟɞɨɫɬɚɬɤɚɦɢ ɨɬɤɪɵɬɵɯ ɞɚɧɧɵɯ, ɩɨɫɤɨɥɶɤɭ ɧɚɥɢɱɢɟ
ɡɚɳɢɳɟɧɧɵɯ ɞɚɧɧɵɯ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɚɛɫɬɪɚɤɰɢɹ ɪɚɡɞɟɥɹɟɬ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɩɨɞɞɟɪɠɚɧɢɟ
ɨɞɧɨɝɨ ɢɥɢ ɧɟɫɤɨɥɶɤɢɯ ɢɧɜɚɪɢɚɧɬɨɜ ɫ ɧɟɨɝɪɚɧɢɱɟɧɧɵɦ ɦɧɨɠɟɫɬɜɨɦ ɤɨɞɚ — ɬɟɩɟɪɶ ɷɬɨ ɤɨɞ
ɫɭɳɟɫɬɜɭɸɳɢɯ ɢ ɛɭɞɭɳɢɯ ɩɪɨɢɡɜɨɞɧɵɯ ɤɥɚɫɫɨɜ. Ȼɨɥɟɟ ɬɨɝɨ, ɥɸɛɨɣ ɤɨɞ ɦɨɠɟɬ ɱɢɬɚɬɶ ɢ ɦɨ-
ɞɢɮɢɰɢɪɨɜɚɬɶ ɡɚɳɢɳɟɧɧɵɟ ɞɚɧɧɵɟ ɬɚɤ ɠɟ ɥɟɝɤɨ, ɤɚɤ ɢ ɨɬɤɪɵɬɵɟ — ɩɪɨɫɬɨ ɫɨɡɞɚɜ ɩɪɨɢɡɜɨɞ-
ɧɵɣ ɤɥɚɫɫ ɢ ɢɫɩɨɥɶɡɭɹ ɟɝɨ ɞɥɹ ɞɨɫɬɭɩɚ ɤ ɞɚɧɧɵɦ.
ɋɦɟɲɢɜɚɧɢɟ ɨɬɤɪɵɬɵɯ ɢ ɡɚɤɪɵɬɵɯ ɞɚɧɧɵɯ-ɱɥɟɧɨɜ ɜ ɨɞɧɨɦ ɢ ɬɨɦ ɠɟ ɤɥɚɫɫɟ ɹɜɥɹɟɬɫɹ ɧɟ-
ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɦ ɢ ɩɨɩɪɨɫɬɭ ɡɚɩɭɬɵɜɚɟɬ ɩɨɥɶɡɨɜɚɬɟɥɟɣ. Ɂɚɤɪɵɬɵɟ ɞɚɧɧɵɟ ɞɟɦɨɧɫɬɪɢɪɭɸɬ,
ɱɬɨ ɭ ɜɚɫ ɟɫɬɶ ɧɟɤɨɬɨɪɵɟ ɢɧɜɚɪɢɚɧɬɵ ɢ ɧɟɱɬɨ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɨɟ ɞɥɹ ɢɯ ɩɨɞɞɟɪɠɚɧɢɹ. ɋɦɟɲɢ-
ɜɚɧɢɟ ɢɯ ɫ ɨɬɤɪɵɬɵɦɢ ɞɚɧɧɵɦɢ-ɱɥɟɧɚɦɢ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɩɪɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɬɚɤ ɨɤɨɧɱɚɬɟɥɶɧɨ
ɢ ɧɟ ɪɟɲɟɧɨ, ɞɨɥɠɟɧ ɥɢ ɤɥɚɫɫ ɩɪɟɞɫɬɚɜɥɹɬɶ ɧɟɤɨɬɨɪɭɸ ɚɛɫɬɪɚɤɰɢɸ ɢɥɢ ɧɟɬ.
ɇɟ ɡɚɤɪɵɬɵɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɩɨɱɬɢ ɜɫɟɝɞɚ ɯɭɠɟ ɞɚɠɟ ɩɪɨɫɬɟɣɲɢɯ ɮɭɧɤɰɢɣ ɞɥɹ ɩɨɥɭɱɟɧɢɹ
ɢ ɭɫɬɚɧɨɜɤɢ ɡɧɚɱɟɧɢɣ, ɩɨɫɤɨɥɶɤɭ ɩɨɫɥɟɞɧɢɟ ɨɛɟɫɩɟɱɢɜɚɸɬ ɭɫɬɨɣɱɢɜɨɫɬɶ ɤɨɞɚ ɤ ɜɨɡɦɨɠɧɵɦ
ɜɧɟɫɟɧɢɹɦ ɢɡɦɟɧɟɧɢɣ.
ɉɨɞɭɦɚɣɬɟ ɨ ɫɨɤɪɵɬɢɢ ɡɚɤɪɵɬɵɯ ɱɥɟɧɨɜ ɤɥɚɫɫɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɫɦ. ɪɟ-
Примеры
ɉɪɢɦɟɪ 1. Ʉɨɪɪɟɤɬɧɚɹ ɢɧɤɚɩɫɭɥɹɰɢɹ. Ȼɨɥɶɲɢɧɫɬɜɨ ɤɥɚɫɫɨɜ (ɧɚɩɪɢɦɟɪ, Matrix, File,
Date, BankAccount, Security) ɞɨɥɠɧɵ ɡɚɤɪɵɜɚɬɶ ɜɫɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɢ ɨɬɤɪɵɜɚɬɶ ɫɨɨɬɜɟɬ-
ɫɬɜɭɸɳɢɟ ɢɧɬɟɪɮɟɣɫɵ. ɉɨɡɜɨɥɟɧɢɟ ɜɵɡɵɜɚɸɳɟɦɭ ɤɨɞɭ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɪɚɛɨɬɚɬɶ ɫ ɜɧɭɬɪɟɧ-
ɧɢɦɢ ɞɚɧɧɵɦɢ ɤɥɚɫɫɚ ɪɚɛɨɬɚɟɬ ɩɪɨɬɢɜ ɩɪɟɞɫɬɚɜɥɟɧɧɨɣ ɢɦ ɚɛɫɬɪɚɤɰɢɢ ɢ ɩɨɞɞɟɪɠɢɜɚɟɦɵɯ ɢɦ
ɢɧɜɚɪɢɚɧɬɨɜ.
41. Делайте данныечлены закрытыми (кроме случая агрегатов в стиле структур C) 87
Стр. 87
Ⱥɝɪɟɝɚɬ Node, ɲɢɪɨɤɨ ɢɫɩɨɥɶɡɭɟɦɵɣ ɜ ɪɟɚɥɢɡɚɰɢɢ ɤɥɚɫɫɚ List, ɨɛɵɱɧɨ ɫɨɞɟɪɠɢɬ ɧɟɤɨ-
ɬɨɪɵɟ ɞɚɧɧɵɟ ɢ ɞɜɚ ɭɤɚɡɚɬɟɥɹ ɧɚ Node: next_ ɢ prev_. Ⱦɚɧɧɵɟ-ɱɥɟɧɵ Node ɧɟ ɞɨɥɠɧɵ ɛɵɬɶ
ɫɤɪɵɬɵ ɨɬ List. Ɉɞɧɚɤɨ ɧɟ ɡɚɛɭɞɶɬɟ ɪɚɫɫɦɨɬɪɟɬɶ ɟɳɟ ɩɪɢɦɟɪ 3.
ɉɪɢɦɟɪ 2. TreeNode. Ɋɚɫɫɦɨɬɪɢɦ ɤɨɧɬɟɣɧɟɪ Tree<T>, ɪɟɚɥɢɡɨɜɚɧɧɵɣ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
TreeNode<T>, ɚɝɪɟɝɚɬɚ, ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɜ Tree, ɤɨɬɨɪɵɣ ɯɪɚɧɢɬ ɭɤɚɡɚɬɟɥɢ ɧɚ ɩɪɟɞɵɞɭɳɢɣ,
ɫɥɟɞɭɸɳɢɣ ɢ ɪɨɞɢɬɟɥɶɫɤɢɣ ɭɡɥɵ ɢ ɫɚɦ ɨɛɴɟɤɬ T. ȼɫɟ ɱɥɟɧɵ TreeNode ɦɨɝɭɬ ɛɵɬɶ ɨɬɤɪɵɬɵ-
ɦɢ, ɩɨɫɤɨɥɶɤɭ ɢɯ ɧɟ ɧɚɞɨ ɫɤɪɵɜɚɬɶ ɨɬ ɤɥɚɫɫɚ Tree, ɤɨɬɨɪɵɣ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɦɚɧɢɩɭɥɢɪɭɟɬ
ɢɦɢ. Ɉɞɧɚɤɨ ɤɥɚɫɫ Tree ɞɨɥɠɟɧ ɩɨɥɧɨɫɬɶɸ ɫɤɪɵɜɚɬɶ ɤɥɚɫɫ TreeNode (ɧɚɩɪɢɦɟɪ, ɤɚɤ ɜɥɨ-
ɠɟɧɧɵɣ ɡɚɤɪɵɬɵɣ ɤɥɚɫɫ ɢɥɢ ɤɚɤ ɨɩɪɟɞɟɥɟɧɧɵɣ ɬɨɥɶɤɨ ɜ ɮɚɣɥɟ ɪɟɚɥɢɡɚɰɢɢ ɤɥɚɫɫɚ Tree), ɩɨ-
ɫɤɨɥɶɤɭ ɷɬɨ — ɞɟɬɚɥɢ ɜɧɭɬɪɟɧɧɟ ɪɟɚɥɢɡɚɰɢɢ ɤɥɚɫɫɚ Tree, ɨɬ ɤɨɬɨɪɵɯ ɧɟ ɞɨɥɠɟɧ ɡɚɜɢɫɟɬɶ ɢ ɫ
ɤɨɬɨɪɵɦɢ ɧɟ ɞɨɥɠɟɧ ɢɦɟɬɶ ɞɟɥɚ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ. ɂ ɧɚɤɨɧɟɰ, Tree ɧɟ ɫɤɪɵɜɚɟɬ ɫɨɞɟɪɠɚ-
ɳɢɟɫɹ ɜ ɤɨɧɬɟɣɧɟɪɟ ɨɛɴɟɤɬɵ T, ɩɨɫɤɨɥɶɤɭ ɡɚ ɧɢɯ ɨɬɜɟɱɚɟɬ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ; ɤɨɧɬɟɣɧɟɪɵ ɢɫ-
ɩɨɥɶɡɭɸɬ ɚɛɫɬɪɚɤɰɢɸ ɢɬɟɪɚɬɨɪɨɜ ɞɥɹ ɩɪɟɞɨɫɬɚɜɥɟɧɢɹ ɞɨɫɬɭɩɚ ɤ ɫɨɞɟɪɠɚɳɢɦɫɹ ɨɛɴɟɤɬɚɦ,
ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɜɧɭɬɪɟɧɧɹɹ ɫɬɪɭɤɬɭɪɚ ɤɨɧɬɟɣɧɟɪɚ ɨɫɬɚɟɬɫɹ ɫɤɪɵɬɨɣ.
ɉɪɢɦɟɪ 3. Ɏɭɧɤɰɢɢ ɩɨɥɭɱɟɧɢɹ ɢ ɭɫɬɚɧɨɜɤɢ ɡɧɚɱɟɧɢɣ. ȿɫɥɢ ɧɟ ɢɦɟɟɬɫɹ ɥɭɱɲɟɣ ɩɪɟɞɦɟɬɧɨɣ
ɚɛɫɬɪɚɤɰɢɢ, ɨɬɤɪɵɬɵɟ ɢ ɡɚɳɢɳɟɧɧɵɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ (ɧɚɩɪɢɦɟɪ, color) ɦɨɝɭɬ, ɤɚɤ ɦɢɧɢɦɭɦ,
ɛɵɬɶ ɫɞɟɥɚɧɵ ɡɚɤɪɵɬɵɦɢ ɢ ɫɤɪɵɬɵ ɡɚ ɮɭɧɤɰɢɹɦɢ ɩɨɥɭɱɟɧɢɹ ɢ ɭɫɬɚɧɨɜɤɢ ɡɧɚɱɟɧɢɣ
(ɧɚɩɪɢɦɟɪ, GetColor, SetColor); Ɍɟɦ ɫɚɦɵɦ ɨɛɟɫɩɟɱɢɜɚɟɬɫɹ ɦɢɧɢɦɚɥɶɧɵɣ ɭɪɨɜɟɧɶ ɚɛɫɬ-
ɪɚɤɰɢɢ ɢ ɭɫɬɨɣɱɢɜɨɫɬɶ ɤ ɢɡɦɟɧɟɧɢɹɦ.
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɮɭɧɤɰɢɣ ɩɨɜɵɲɚɟɬ ɭɪɨɜɟɧɶ ɨɛɳɟɧɢɹ ɩɨ ɩɨɜɨɞɭ “ɰɜɟɬɚ” ɨɬ ɤɨɧɤɪɟɬɧɨɝɨ
ɫɨɫɬɨɹɧɢɹ ɞɨ ɚɛɫɬɪɚɤɬɧɨɝɨ, ɤɨɬɨɪɨɟ ɦɵ ɦɨɠɟɦ ɪɟɚɥɢɡɨɜɚɬɶ ɬɟɦ ɫɩɨɫɨɛɨɦ, ɤɨɬɨɪɵɣ ɫɨɱɬɟɦ
ɧɚɢɛɨɥɟɟ ɩɪɢɟɦɥɟɦɵɦ. Ɇɵ ɦɨɠɟɦ ɢɡɦɟɧɢɬɶ ɜɧɭɬɪɟɧɧɟɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ ɰɜɟɬɚ, ɞɨɛɚɜɢɬɶ ɤɨɞ
ɞɥɹ ɨɛɧɨɜɥɟɧɢɹ ɞɢɫɩɥɟɹ ɩɪɢ ɢɡɦɟɧɟɧɢɢ ɰɜɟɬɚ, ɞɨɛɚɜɢɬɶ ɤɚɤɢɟ-ɬɨ ɢɧɫɬɪɭɦɟɧɬɚɥɶɧɵɟ ɫɪɟɞɫɬɜɚ
ɢɥɢ ɜɧɟɫɬɢ ɟɳɟ ɤɚɤɢɟ-ɬɨ ɢɡɦɟɧɟɧɢɹ — ɢ ɜɫɟ ɷɬɨ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɢɡɦɟɧɟɧɢɣ ɜ ɜɵɡɵɜɚɸɳɟɦ
ɤɨɞɟ. ȼ ɯɭɞɲɟɦ ɫɥɭɱɚɟ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɩɨɬɪɟɛɭɟɬɫɹ ɩɟɪɟɤɨɦɩɢɥɢɪɨɜɚɬɶ (ɬ.ɟ. ɦɵ ɫɨɯɪɚɧɹɟɦ
ɫɨɜɦɟɫɬɢɦɨɫɬɶ ɧɚ ɭɪɨɜɧɟ ɢɫɯɨɞɧɵɯ ɬɟɤɫɬɨɜ); ɜ ɥɭɱɲɟɦ — ɧɟ ɩɨɬɪɟɛɭɟɬɫɹ ɧɢ ɩɟɪɟɤɨɦɩɢɥɹ-
ɰɢɹ, ɧɢ ɞɚɠɟ ɩɟɪɟɤɨɦɩɨɧɨɜɤɚ (ɟɫɥɢ ɢɡɦɟɧɟɧɢɹ ɫɨɯɪɚɧɹɸɬ ɛɢɧɚɪɧɭɸ ɫɨɜɦɟɫɬɢɦɨɫɬɶ). ɇɢ ɫɨ-
ɜɦɟɫɬɢɦɨɫɬɶ ɧɚ ɭɪɨɜɧɟ ɢɫɯɨɞɧɵɯ ɬɟɤɫɬɨɜ, ɧɢ ɛɢɧɚɪɧɚɹ ɫɨɜɦɟɫɬɢɦɨɫɬɶ ɩɪɢ ɜɧɟɫɟɧɢɢ ɬɚɤɢɯ
ɢɡɦɟɧɟɧɢɣ ɧɟɜɨɡɦɨɠɧɵ, ɟɫɥɢ ɢɫɯɨɞɧɵɣ ɞɢɡɚɣɧ ɫɨɞɟɪɠɢɬ ɨɬɤɪɵɬɵɣ ɱɥɟɧ color, ɫ ɤɨɬɨɪɵɦ
ɬɟɫɧɨ ɫɜɹɡɚɧ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ.
Ɏɭɧɤɰɢɢ ɩɨɥɭɱɟɧɢɹ ɢ ɭɫɬɚɧɨɜɤɢ ɡɧɚɱɟɧɢɣ ɩɨɥɟɡɧɵ, ɧɨ ɞɢɡɚɣɧ ɤɥɚɫɫɚ, ɫɨɫɬɨɹɳɟɝɨ ɩɪɚɤɬɢ-
ɱɟɫɤɢ ɢɡ ɨɞɧɢɯ ɬɚɤɢɯ ɮɭɧɤɰɢɣ, ɨɫɬɚɜɥɹɟɬ ɠɟɥɚɬɶ ɥɭɱɲɟɝɨ. ɉɨɞɭɦɚɣɬɟ ɧɚɞ ɬɟɦ, ɬɪɟɛɭɟɬɫɹ ɥɢ
ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɨɛɟɫɩɟɱɟɧɢɟ ɚɛɫɬɪɚɤɰɢɢ ɢɥɢ ɞɨɫɬɚɬɨɱɧɨ ɨɝɪɚɧɢɱɢɬɶɫɹ ɩɪɨɫɬɨɣ ɫɬɪɭɤɬɭɪɨɣ.
Ⱥɝɪɟɝɚɬɵ ɡɧɚɱɟɧɢɣ (ɢɡɜɟɫɬɧɵɟ ɤɚɤ ɫɬɪɭɤɬɭɪɵ ɜ ɫɬɢɥɟ C) ɩɪɨɫɬɨ ɯɪɚɧɹɬ ɜɦɟɫɬɟ ɧɚɛɨɪ ɪɚɡɥɢɱ-
ɧɵɯ ɞɚɧɧɵɯ, ɧɨ ɩɪɢ ɷɬɨɦ ɧɟ ɨɛɟɫɩɟɱɢɜɚɸɬ ɧɢ ɢɯ ɩɨɜɟɞɟɧɢɟ, ɧɢ ɞɟɥɚɸɬ ɩɨɩɵɬɨɤ ɦɨɞɟɥɢɪɨɜɚɧɢɹ
ɚɛɫɬɪɚɤɰɢɣ ɢɥɢ ɩɨɞɞɟɪɠɚɧɢɹ ɢɧɜɚɪɢɚɧɬɨɜ. Ɍɚɤɢɟ ɚɝɪɟɝɚɬɵ ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ
ɛɵɬɶ ɚɛɫɬɪɚɤɰɢɹɦɢ. ȼɫɟ ɢɯ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɞɨɥɠɧɵ ɛɵɬɶ ɨɬɤɪɵɬɵɦɢ, ɩɨɫɤɨɥɶɤɭ ɷɬɢ ɞɚɧɧɵɟ-
ɱɥɟɧɵ ɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɢɧɬɟɪɮɟɣɫ. ɇɚɩɪɢɦɟɪ, ɲɚɛɥɨɧ ɤɥɚɫɫɚ std::pair<T,U> ɢɫɩɨɥɶɡɭ-
ɟɬɫɹ ɫɬɚɧɞɚɪɬɧɵɦɢ ɤɨɧɬɟɣɧɟɪɚɦɢ ɞɥɹ ɨɛɴɟɞɢɧɟɧɢɹ ɞɜɭɯ ɧɟɫɜɹɡɚɧɧɵɯ ɷɥɟɦɟɧɬɨɜ ɬɢɩɨɜ T ɢ U,
ɢ ɩɪɢ ɷɬɨɦ pair ɫɚɦ ɩɨ ɫɟɛɟ ɧɟ ɩɪɢɜɧɨɫɢɬ ɧɢ ɩɨɜɟɞɟɧɢɹ, ɧɢ ɤɚɤɢɯ-ɥɢɛɨ ɢɧɜɚɪɢɚɧɬɨɜ.
Ссылки
[Dewhurst03] §80 • [Henricson97] pg. 105 • [Koenig97] §4 • [Lakos96] §2.2 • [Meyers97] §20 •
[Murray93] §2.3 • [Stroustrup00] §10.2.8, §15.3.1.1, §24.4.2-3 • [SuttHysl04a]
Стр. 88
42. Не допускайте вмешательства
во внутренние дела
Резюме
ɂɡɛɟɝɚɣɬɟ ɜɨɡɜɪɚɬɚ ɞɟɫɤɪɢɩɬɨɪɨɜ ɜɧɭɬɪɟɧɧɢɯ ɞɚɧɧɵɯ, ɭɩɪɚɜɥɹɟɦɵɯ ɜɚɲɢɦ ɤɥɚɫɫɨɦ, ɱɬɨ-
ɛɵ ɤɥɢɟɧɬɵ ɧɟ ɦɨɝɥɢ ɧɟɤɨɧɬɪɨɥɢɪɭɟɦɨ ɢɡɦɟɧɹɬɶ ɫɨɫɬɨɹɧɢɟ ɜɚɲɟɝɨ ɨɛɴɟɤɬɚ, ɤɚɤ ɫɜɨɟɝɨ ɫɨɛ-
ɫɬɜɟɧɧɨɝɨ.
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
class Socket {
public:
// ... ǕǹǸǼǽǻǾǵǽǹǻ, ǵǹǽǹǻȆǴ ǹǽǵǻȆǭǫǰǽ handle_,
// ǯǰǼǽǻǾǵǽǹǻ, ǵǹǽǹǻȆǴ ǲǫǵǻȆǭǫǰǽ handle_, ǳ ǽ.ǯ. ...
int GetHandle() const { return handle_; } // ǚǶǹȀǹ!
private:
int handle_; // ǏǰǼǵǻǳǺǽǹǻ ǹǺǰǻǫȁǳǹǸǸǹǴ ǼǳǼǽǰǷȆ
};
ɋɨɤɪɵɬɢɟ ɞɚɧɧɵɯ — ɦɨɳɧɵɣ ɢɧɫɬɪɭɦɟɧɬ ɚɛɫɬɪɚɤɰɢɢ ɢ ɦɨɞɭɥɶɧɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 11
ɢ 41). Ɉɞɧɚɤɨ ɫɨɤɪɵɬɢɟ ɞɚɧɧɵɯ ɩɪɢ ɨɞɧɨɜɪɟɦɟɧɧɨɦ ɨɛɟɫɩɟɱɟɧɢɢ ɞɨɫɬɭɩɚ ɤ ɢɯ ɞɟɫɤɪɢɩɬɨɪɚɦ
ɨɛɪɟɱɟɧɨ ɧɚ ɩɪɨɜɚɥ, ɩɨɬɨɦɭ ɱɬɨ ɷɬɨ ɬɨ ɠɟ, ɱɬɨ ɢ ɡɚɤɪɵɬɶ ɫɜɨɸ ɤɜɚɪɬɢɪɭ ɧɚ ɡɚɦɨɤ ɢ ɩɨɥɨɠɢɬɶ
ɤɥɸɱ ɩɨɞ ɤɨɜɪɢɤ ɭ ɜɯɨɞɚ ɢɥɢ ɩɪɨɫɬɨ ɨɫɬɚɜɢɬɶ ɟɝɨ ɜ ɡɚɦɤɟ. ȼɨɬ ɩɨɱɟɦɭ ɷɬɨ ɬɚɤ.
• ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɤɥɢɟɧɬ ɢɦɟɟɬ ɞɜɟ ɜɨɡɦɨɠɧɨɫɬɢ ɪɟɚɥɢɡɚɰɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ. Ɉɧ
ɦɨɠɟɬ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɚɛɫɬɪɚɤɰɢɟɣ ɜɚɲɟɝɨ ɤɥɚɫɫɚ (Socket) ɥɢɛɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ
ɪɚɛɨɬɚɬɶ ɫ ɪɟɚɥɢɡɚɰɢɟɣ, ɧɚ ɤɨɬɨɪɨɣ ɨɫɧɨɜɚɧ ɜɚɲ ɤɥɚɫɫ (ɞɟɫɤɪɢɩɬɨɪ ɫɨɤɟɬɚ ɜ ɫɬɢɥɟ C).
ȼ ɩɨɫɥɟɞɧɟɦ ɫɥɭɱɚɟ ɨɛɴɟɤɬ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟ ɨɫɜɟɞɨɦɥɟɧ ɨɛ ɢɡɦɟɧɟɧɢɹɯ, ɩɪɨɢɫɯɨɞɹɳɢɯ
ɫ ɪɟɫɭɪɫɨɦ, ɤɨɬɨɪɵɦ ɨɧ, ɤɚɤ ɟɦɭ ɤɚɠɟɬɫɹ, ɜɥɚɞɟɟɬ. Ɍɟɩɟɪɶ ɤɥɚɫɫ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɧɚɞɟɠ-
ɧɨ ɨɛɨɝɚɬɢɬɶ ɢɥɢ ɭɫɨɜɟɪɲɟɧɫɬɜɨɜɚɬɶ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ (ɧɚɩɪɢɦɟɪ, ɨɛɟɫɩɟɱɢɬɶ ɩɪɨ-
ɤɫɢ, ɠɭɪɧɚɥɢɡɚɰɢɸ, ɫɛɨɪ ɫɬɚɬɢɫɬɢɤɢ ɢ ɬ.ɩ.), ɩɨɫɤɨɥɶɤɭ ɤɥɢɟɧɬɵ ɦɨɝɭɬ ɩɪɨɫɬɨ ɨɛɨɣɬɢ
ɷɬɢ ɜɨɡɦɨɠɧɨɫɬɢ ɪɟɚɥɢɡɚɰɢɢ, ɤɚɤ ɢ ɥɸɛɵɟ ɞɪɭɝɢɟ ɢɧɜɚɪɢɚɧɬɵ, ɤɨɬɨɪɵɟ ɜɵ, ɤɚɤ ɜɵ ɩɨ-
ɥɚɝɚɟɬɟ, ɞɨɛɚɜɢɥɢ ɜ ɜɚɲ ɤɥɚɫɫ. ɗɬɨ ɞɟɥɚɟɬ ɧɟɜɨɡɦɨɠɧɨɣ, ɜ ɱɚɫɬɧɨɫɬɢ, ɤɨɪɪɟɤɬɧɭɸ ɨɛ-
ɪɚɛɨɬɤɭ ɜɨɡɧɢɤɚɸɳɢɯ ɨɲɢɛɨɤ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 70).
• Ʉɥɚɫɫ ɧɟ ɦɨɠɟɬ ɢɡɦɟɧɹɬɶ ɜɧɭɬɪɟɧɧɸɸ ɪɟɚɥɢɡɚɰɢɸ ɫɜɨɟɣ ɚɛɫɬɪɚɤɰɢɢ, ɩɨɫɤɨɥɶɤɭ ɨɬ
ɧɟɟ ɡɚɜɢɫɹɬ ɤɥɢɟɧɬɵ. ȿɫɥɢ ɜ ɛɭɞɭɳɟɦ ɤɥɚɫɫ Socket ɛɭɞɟɬ ɨɛɧɨɜɥɟɧ ɞɥɹ ɩɨɞɞɟɪɠɤɢ
ɞɪɭɝɨɝɨ ɩɪɨɬɨɤɨɥɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɞɪɭɝɢɯ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɩɪɢɦɢɬɢɜɨɜ, ɜɵɡɵɜɚɸ-
ɳɢɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɩɨ-ɩɪɟɠɧɟɦɭ ɩɨɥɭɱɚɬɶ ɞɨɫɬɭɩ ɤ ɞɟɫɤɪɢɩɬɨɪɭ handle_ ɢ ɪɚ-
ɛɨɬɚɬɶ ɫ ɧɢɦ, ɨɤɚɠɟɬɫɹ ɧɟɤɨɪɪɟɤɬɧɵɦ.
• Ʉɥɚɫɫ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɨɛɟɫɩɟɱɢɬɶ ɜɵɩɨɥɧɟɧɢɟ ɟɝɨ ɢɧɜɚɪɢɚɧɬɨɜ, ɩɨɫɤɨɥɶɤɭ ɜɵɡɵɜɚɸ-
ɳɢɣ ɤɨɞ ɦɨɠɟɬ ɢɡɦɟɧɢɬɶ ɫɨɫɬɨɹɧɢɟ ɛɟɡ ɜɟɞɨɦɚ ɤɥɚɫɫɚ. ɇɚɩɪɢɦɟɪ, ɤɬɨ-ɬɨ ɦɨɠɟɬ ɡɚ-
ɤɪɵɬɶ ɞɟɫɤɪɢɩɬɨɪ, ɢɫɩɨɥɶɡɭɟɦɵɣ ɨɛɴɟɤɬɨɦ Socket, ɦɢɧɭɹ ɜɵɡɨɜ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ
Socket, ɚ ɷɬɨ ɩɪɢɜɟɞɟɬ ɤ ɬɨɦɭ, ɱɬɨ ɨɛɴɟɤɬ ɫɬɚɧɟɬ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦ.
• Ʉɨɞ ɤɥɢɟɧɬɚ ɦɨɠɟɬ ɯɪɚɧɢɬɶ ɞɟɫɤɪɢɩɬɨɪɵ, ɜɨɡɜɪɚɳɚɟɦɵɟ ɜɚɲɢɦ ɤɥɚɫɫɨɦ, ɢ ɩɵɬɚɬɶɫɹ
ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɯ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɤɨɞ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɫɞɟɥɚɟɬ ɢɯ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦɢ.
Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɨɲɢɛɤɚ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɞɟɣɫɬɜɢɟ const ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟɝɥɭɛɨ-
ɤɨɟ ɢ ɧɟ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɟɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15). ɇɚɩɪɢɦɟɪ,
Socket::GetHandle — ɤɨɧɫɬɚɧɬɧɵɣ ɱɥɟɧ; ɩɨɤɚ ɦɵ ɪɚɫɫɦɚɬɪɢɜɚɟɦ ɫɢɬɭɚɰɢɸ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ
42. Не допускайте вмешательства во внутренние дела 89
Стр. 89
ɤɨɦɩɢɥɹɬɨɪɚ, ɜɨɡɜɪɚɬ handle_ ɫɨɯɪɚɧɹɟɬ ɤɨɧɫɬɚɧɬɧɨɫɬɶ ɨɛɴɟɤɬɚ. Ɉɞɧɚɤɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɵɣ
ɜɵɡɨɜ ɮɭɧɤɰɢɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɡɧɚɱɟɧɢɹ handle_ ɜɩɨɥɧɟ ɦɨɠɟɬ
ɢɡɦɟɧɹɬɶ ɞɚɧɧɵɟ, ɤ ɤɨɬɨɪɵɦ ɤɨɫɜɟɧɧɨ ɨɛɪɚɳɚɟɬɫɹ handle_.
ɉɪɢɜɟɞɟɧɧɵɣ ɞɚɥɟɟ ɩɪɢɦɟɪ ɨɱɟɧɶ ɩɪɨɫɬ, ɯɨɬɹ ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ ɫɢɬɭɚɰɢɹ ɧɟɫɤɨɥɶɤɨ ɥɭɱ-
ɲɟ — ɦɵ ɦɨɠɟɦ ɫɧɢɡɢɬɶ ɜɟɪɨɹɬɧɨɫɬɶ ɫɥɭɱɚɣɧɨɝɨ ɧɟɜɟɪɧɨɝɨ ɭɩɨɬɪɟɛɥɟɧɢɹ ɜɨɡɜɪɚɳɚɟɦɨɝɨ
ɡɧɚɱɟɧɢɹ, ɨɩɢɫɚɜ ɟɝɨ ɬɢɩ ɤɚɤ const:
class String {
char* buffer_;
public:
char* GetBuffer() const { return buffer_; }
// ǚǶǹȀǹ: ǼǶǰǯǾǰǽ ǭǹǲǭǻǫȄǫǽȇ const char*
// ...
};
ɏɨɬɹ ɮɭɧɤɰɢɹ GetBuffer ɤɨɧɫɬɚɧɬɧɚɹ, ɬɟɯɧɢɱɟɫɤɢ ɷɬɨɬ ɤɨɞ ɜɩɨɥɧɟ ɤɨɪɪɟɤɬɟɧ. ɉɨɧɹɬɧɨ, ɱɬɨ
ɤɥɢɟɧɬ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɬɭ ɮɭɧɤɰɢɸ GetBuffer ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɢɡɦɟɧɢɬɶ ɨɛɴɟɤɬ String
ɦɧɨɠɟɫɬɜɨɦ ɪɚɡɧɵɯ ɫɩɨɫɨɛɨɜ, ɧɟ ɩɪɢɛɟɝɚɹ ɤ ɹɜɧɨɦɭ ɩɪɟɨɛɪɚɡɨɜɚɧɢɸ ɬɢɩɨɜ. ɇɚɩɪɢɦɟɪ,
strcpy(s.GetBuffer(),"Very Long String...") — ɜɩɨɥɧɟ ɡɚɤɨɧɧɵɣ ɤɨɞ; ɥɸɛɨɣ ɤɨɦɩɢ-
ɥɹɬɨɪ ɩɪɨɩɭɫɬɢɬ ɟɝɨ ɛɟɡ ɤɚɤɢɯ ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɡɚɦɟɱɚɧɢɣ. ȿɫɥɢ ɛɵ ɦɵ ɨɛɴɹɜɢɥɢ ɜɨɡɜɪɚɳɚɟɦɵɣ ɬɢɩ
ɤɚɤ const char*, ɬɨ ɩɪɟɞɫɬɚɜɥɟɧɧɵɣ ɤɨɞ ɜɵɡɜɚɥ ɛɵ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɨɲɢɛɤɭ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹ-
ɰɢɢ, ɬɚɤ ɱɬɨ ɫɥɭɱɚɣɧɨ ɩɨɫɬɭɩɢɬɶ ɫɬɨɥɶ ɨɩɚɫɧɨ ɛɵɥɨ ɛɵ ɩɪɨɫɬɨ ɧɟɜɨɡɦɨɠɧɨ — ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ
ɞɨɥɠɟɧ ɛɵɥ ɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɹɜɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 92 ɢ 95).
ɇɨ ɞɚɠɟ ɜɨɡɜɪɚɬ ɭɤɚɡɚɬɟɥɟɣ ɧɚ const ɧɟ ɭɫɬɪɚɧɹɟɬ ɜɨɡɦɨɠɧɨɫɬɢ ɫɥɭɱɚɣɧɨɝɨ ɧɟɤɨɪɪɟɤɬ-
ɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɩɨɫɤɨɥɶɤɭ ɢɦɟɟɬɫɹ ɟɳɟ ɨɞɧɚ ɩɪɨɛɥɟɦɚ, ɫɜɹɡɚɧɧɚɹ ɫ ɤɨɪɪɟɤɬɧɨɫɬɶɸ ɜɧɭɬ-
ɪɟɧɧɢɯ ɞɚɧɧɵɯ ɤɥɚɫɫɚ. ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɜɵɲɟ ɩɪɢɦɟɪɟ ɫ ɤɥɚɫɫɨɦ String, ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ
ɦɨɠɟɬ ɫɨɯɪɚɧɢɬɶ ɡɧɚɱɟɧɢɟ, ɜɨɡɜɪɚɳɚɟɦɨɟ ɮɭɧɤɰɢɟɣ GetBuffer, ɚ ɡɚɬɟɦ ɜɵɩɨɥɧɢɬɶ ɨɩɟɪɚ-
ɰɢɢ, ɤɨɬɨɪɵɟ ɩɪɢɜɟɞɭɬ ɤ ɪɨɫɬɭ (ɢ ɩɟɪɟɦɟɳɟɧɢɸ) ɛɭɮɟɪɚ String, ɱɬɨ ɜ ɪɟɡɭɥɶɬɚɬɟ ɦɨɠɟɬ
ɩɪɢɜɟɫɬɢ ɤ ɢɫɩɨɥɶɡɨɜɚɧɢɸ ɫɨɯɪɚɧɟɧɧɨɝɨ, ɧɨ ɛɨɥɟɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɨɝɨ ɭɤɚɡɚɬɟɥɹ ɧɚ ɧɟɫɭɳɟ-
ɫɬɜɭɸɳɢɣ ɜ ɞɚɧɧɵɣ ɦɨɦɟɧɬ ɛɭɮɟɪ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɟɫɥɢ ɜɵ ɫɱɢɬɚɟɬɟ, ɱɬɨ ɭ ɜɚɫ ɟɫɬɶ ɩɪɢɱɢɧɵ
ɞɥɹ ɨɛɟɫɩɟɱɟɧɢɹ ɬɚɤɨɝɨ ɞɨɫɬɭɩɚ ɤɨ ɜɧɭɬɪɟɧɧɟɦɭ ɫɨɫɬɨɹɧɢɸ, ɜɵ ɞɨɥɠɧɵ ɞɟɬɚɥɶɧɨ ɞɨɤɭɦɟɧɬɢ-
ɪɨɜɚɬɶ, ɤɚɤ ɞɨɥɝɨ ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ ɨɫɬɚɟɬɫɹ ɤɨɪɪɟɤɬɧɵɦ ɢ ɤɚɤɢɟ ɨɩɟɪɚɰɢɢ ɞɟɥɚɸɬ ɟɝɨ
ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦ (ɫɪɚɜɧɢɬɟ ɫ ɝɚɪɚɧɬɢɹɦɢ ɤɨɪɪɟɤɬɧɨɫɬɢ ɹɜɧɵɯ ɢɬɟɪɚɬɨɪɨɜ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛ-
ɥɢɨɬɟɤɢ; ɫɦ. [C++03]).
ɂɧɨɝɞɚ ɤɥɚɫɫɵ ɨɛɹɡɚɧɵ ɩɪɟɞɨɫɬɚɜɢɬɶ ɞɨɫɬɭɩ ɤɨ ɜɧɭɬɪɟɧɧɢɦ ɞɟɫɤɪɢɩɬɨɪɚɦ ɩɨ ɩɪɢɱɢɧɚɦ,
ɫɜɹɡɚɧɧɵɦ ɫ ɫɨɜɦɟɫɬɢɦɨɫɬɶɸ, ɧɚɩɪɢɦɟɪ, ɞɥɹ ɢɧɬɟɪɮɟɣɫɚ ɫɨ ɫɬɚɪɵɦ ɤɨɞɨɦ ɢɥɢ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɢ ɞɪɭɝɢɯ ɫɢɫɬɟɦ. ɇɚɩɪɢɦɟɪ, std::basic_string ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɞɨɫɬɭɩ ɤ ɫɜɨɟɦɭ ɜɧɭɬɪɟɧ-
ɧɟɦɭ ɞɟɫɤɪɢɩɬɨɪɭ ɩɨɫɪɟɞɫɬɜɨɦ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ data ɢ c_str ɞɥɹ ɫɨɜɦɟɫɬɢɦɨɫɬɢ ɫ ɮɭɧɤɰɢɹ-
ɦɢ, ɤɨɬɨɪɵɟ ɪɚɛɨɬɚɸɬ ɫ ɭɤɚɡɚɬɟɥɹɦɢ C — ɧɨ ɧɟ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɯɪɚɧɢɬɶ ɷɬɢ ɭɤɚɡɚɬɟɥɢ ɢ ɩɵɬɚɬɶ-
ɫɹ ɜɵɩɨɥɧɹɬɶ ɡɚɩɢɫɶ ɫ ɢɯ ɩɨɦɨɳɶɸ! Ɍɚɤɢɟ ɮɭɧɤɰɢɢ ɞɨɫɬɭɩɚ “ɱɟɪɟɡ ɡɚɞɧɸɸ ɞɜɟɪɶ” ɜɫɟɝɞɚ ɹɜɥɹ-
ɸɬɫɹ ɡɥɨɦ ɢ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɨɱɟɧɶ ɪɟɞɤɨ ɢ ɨɱɟɧɶ ɨɫɬɨɪɨɠɧɨ, ɚ ɭɫɥɨɜɢɹ ɤɨɪɪɟɤɬɧɨɫɬɢ
ɜɨɡɜɪɚɳɚɟɦɵɯ ɢɦɢ ɞɟɫɤɪɢɩɬɨɪɨɜ ɞɨɥɠɧɵ ɛɵɬɶ ɬɨɱɧɨ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɵ.
Ссылки
[C++03] §23 • [Dewhurst03] §80 • [Meyers97] #29 • [Saks99] • [Stroustrup00] §7.3 • [Sutter02] §9
Стр. 90
43. Разумно пользуйтесь идиомой Pimpl
Резюме
C++ ɞɟɥɚɟɬ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ ɧɟɞɨɫɬɭɩɧɵɦɢ, ɧɨ ɧɟ ɧɟɜɢɞɢɦɵɦɢ. Ɍɚɦ, ɝɞɟ ɷɬɨ ɨɩɪɚɜɞɵɜɚɟɬ-
ɫɹ ɩɨɥɭɱɚɟɦɵɦɢ ɩɪɟɢɦɭɳɟɫɬɜɚɦɢ, ɫɥɟɞɭɟɬ ɩɨɞɭɦɚɬɶ ɨɛ ɢɫɬɢɧɧɨɣ ɧɟɜɢɞɢɦɨɫɬɢ, ɞɨɫɬɢɝɚɟɦɨɣ
ɩɪɢɦɟɧɟɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɭɤɚɡɚɬɟɥɹ ɧɚ ɪɟɚɥɢɡɚɰɢɸ) ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɛɪɚɧɞɦɚɭɷɪɨɜ ɤɨɦɩɢ-
ɥɹɬɨɪɚ ɢ ɩɨɜɵɲɟɧɢɹ ɫɨɤɪɵɬɢɹ ɢɧɮɨɪɦɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 11 ɢ 41).
Ʉɨɝɞɚ ɢɦɟɟɬ ɫɦɵɫɥ ɫɨɡɞɚɬɶ “ɛɪɚɧɞɦɚɭɷɪ ɤɨɦɩɢɥɹɬɨɪɚ”, ɤɨɬɨɪɵɣ ɩɨɥɧɨɫɬɶɸ ɢɡɨɥɢɪɭɟɬ
ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɨɬ ɡɚɤɪɵɬɵɯ ɱɚɫɬɟɣ ɤɥɚɫɫɚ, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɢɞɢɨɦɨɣ Pimpl (ɭɤɚɡɚɬɟɥɹ ɧɚ
ɪɟɚɥɢɡɚɰɢɸ): ɫɤɪɨɣɬɟ ɢɯ ɡɚ ɧɟɩɪɨɡɪɚɱɧɵɦ ɭɤɚɡɚɬɟɥɟɦ (ɭɤɚɡɚɬɟɥɶ (ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɨɞɯɨɞɹ-
ɳɢɣ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ) ɧɚ ɨɛɴɹɜɥɟɧɧɵɣ, ɧɨ ɩɨɤɚ ɧɟ ɨɩɪɟɞɟɥɟɧɧɵɣ ɤɥɚɫɫ). ɇɚɩɪɢɦɟɪ:
class Map {
// ...
private:
struct Impl;
shared_ptr <Impl> pimpl_;
};
Ⱦɚɸɳɢɣ ɧɚɡɜɚɧɢɟ ɢɞɢɨɦɟ ɭɤɚɡɚɬɟɥɶ ɞɨɥɠɟɧ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɞɥɹ ɯɪɚɧɟɧɢɹ ɜɫɟɯ ɡɚɤɪɵɬɵɯ
ɱɥɟɧɨɜ, ɤɚɤ ɞɚɧɧɵɯ, ɬɚɤ ɢ ɡɚɤɪɵɬɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ. ɗɬɨ ɩɨɡɜɨɥɹɟɬ ɜɚɦ ɜɧɨɫɢɬɶ ɩɪɨɢɡɜɨɥɶ-
ɧɵɟ ɢɡɦɟɧɟɧɢɹ ɜ ɡɚɤɪɵɬɵɟ ɞɟɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ ɜɚɲɢɯ ɤɥɚɫɫɨɜ ɛɟɡ ɤɚɤɨɣ ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɪɟɤɨɦ-
ɩɢɥɹɰɢɢ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ. ɋɜɨɛɨɞɚ ɢ ɧɟɡɚɜɢɫɢɦɨɫɬɶ — ɜɨɬ ɨɬɥɢɱɢɬɟɥɶɧɵɟ ɱɟɪɬɵ ɪɚɫɫɦɚɬ-
ɪɢɜɚɟɦɨɣ ɢɞɢɨɦɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41).
ɉɪɢɦɟɱɚɧɢɟ: ɨɛɴɹɜɥɹɣɬɟ ɭɤɚɡɚɬɟɥɶ ɧɚ ɡɚɤɪɵɬɭɸ ɪɟɚɥɢɡɚɰɢɸ, ɤɚɤ ɩɨɤɚɡɚɧɨ — ɫ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɟɦ ɞɜɭɯ ɨɛɴɹɜɥɟɧɢɣ. ȿɫɥɢ ɜɵ ɫɤɨɦɛɢɧɢɪɭɟɬɟ ɞɜɟ ɫɬɪɨɤɢ ɫ ɩɪɟɞɜɚɪɢɬɟɥɶɧɵɦ ɨɛɴɹɜɥɟɧɢɟɦ
ɬɢɩɚ ɢ ɭɤɚɡɚɬɟɥɹ ɧɚ ɧɟɝɨ ɜ ɨɞɧɭ ɢɧɫɬɪɭɤɰɢɸ struct Impl*pimpl;, ɷɬɨ ɛɭɞɟɬ ɜɩɨɥɧɟ ɡɚɤɨɧ-
ɧɨ, ɧɨ ɢɡɦɟɧɢɬ ɫɦɵɫɥ ɨɛɴɹɜɥɟɧɢɹ: ɜ ɷɬɨɦ ɫɥɭɱɚɟ Impl ɧɚɯɨɞɢɬɫɹ ɜ ɨɯɜɚɬɵɜɚɸɳɟɦ ɩɪɨɫɬɪɚɧ-
ɫɬɜɟ ɢɦɟɧ ɢ ɧɟ ɹɜɥɹɟɬɫɹ ɜɥɨɠɟɧɧɵɦ ɬɢɩɨɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ.
ɂɦɟɟɬɫɹ ɤɚɤ ɦɢɧɢɦɭɦ ɬɪɢ ɩɪɢɱɢɧɵ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ Pimpl, ɢ ɜɫɟ ɨɧɢ ɜɵɬɟɤɚɸɬ ɢɡ ɪɚɡ-
ɥɢɱɢɹ ɦɟɠɞɭ ɞɨɫɬɭɩɧɨɫɬɶɸ (ɜ ɫɨɫɬɨɹɧɢɢ ɥɢ ɜɵ ɜɵɡɜɚɬɶ ɢɥɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɟɤɨɬɨɪɵɣ ɨɛɴɟɤɬ)
ɢ ɜɢɞɢɦɨɫɬɶɸ (ɜɢɞɢɦ ɥɢ ɷɬɨɬ ɨɛɴɟɤɬ ɞɥɹ ɜɚɫ ɢ, ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɡɚɜɢɫɢɬɟ ɥɢ ɜɵ ɨɬ ɟɝɨ ɨɩɪɟɞɟ-
ɥɟɧɢɹ) ɜ C++. ȼ ɱɚɫɬɧɨɫɬɢ, ɜɫɟ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ ɤɥɚɫɫɚ ɧɟɞɨɫɬɭɩɧɵ ɧɢɤɨɦɭ, ɤɪɨɦɟ ɮɭɧɤɰɢɣ-
ɱɥɟɧɨɜ ɢ ɞɪɭɡɟɣ, ɧɨ ɡɚɬɨ ɜɢɞɢɦɵ ɜɫɟɦ — ɥɸɛɨɦɭ ɤɨɞɭ, ɤɨɬɨɪɨɦɭ ɜɢɞɢɦɨ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ.
ɉɟɪɜɨɟ ɫɥɟɞɫɬɜɢɟ ɷɬɨɝɨ — ɩɨɬɟɧɰɢɚɥɶɧɨ ɛɨɥɶɲɟɟ ɜɪɟɦɹ ɫɛɨɪɤɢ ɩɪɢɥɨɠɟɧɢɹ ɢɡ-ɡɚ ɨɛɪɚ-
ɛɨɬɤɢ ɢɡɥɢɲɧɢɯ ɨɩɪɟɞɟɥɟɧɢɣ ɬɢɩɨɜ. Ⱦɥɹ ɡɚɤɪɵɬɵɯ ɞɚɧɧɵɯ-ɱɥɟɧɨɜ, ɯɪɚɧɹɳɢɯɫɹ ɩɨ ɡɧɚɱɟɧɢɸ,
ɢ ɩɚɪɚɦɟɬɪɨɜ ɡɚɤɪɵɬɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɩɟɪɟɞɚɜɚɟɦɵɯ ɩɨ ɡɧɚɱɟɧɢɸ ɢɥɢ ɢɫɩɨɥɶɡɭɟɦɵɯ ɜ ɜɢ-
ɞɢɦɨɣ ɪɟɚɥɢɡɚɰɢɢ ɮɭɧɤɰɢɣ, ɬɢɩɵ ɞɨɥɠɧɵ ɛɵɬɶ ɨɩɪɟɞɟɥɟɧɵ, ɞɚɠɟ ɟɫɥɢ ɨɧɢ ɧɢɤɨɝɞɚ ɧɟ ɩɨ-
ɬɪɟɛɭɸɬɫɹ ɜ ɞɚɧɧɨɣ ɟɞɢɧɢɰɟ ɤɨɦɩɢɥɹɰɢɢ. ɗɬɨ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɭɜɟɥɢɱɟɧɢɸ ɜɪɟɦɟɧɢ ɫɛɨɪ-
ɤɢ, ɧɚɩɪɢɦɟɪ:
class C {
// ...
private:
AComplicatedType act_;
};
Ɂɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ, ɫɨɞɟɪɠɚɳɢɣ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ C, ɞɨɥɠɟɧ ɬɚɤɠɟ ɜɤɥɸɱɚɬɶ ɡɚɝɨɥɨ-
ɜɨɱɧɵɣ ɮɚɣɥ, ɫɨɞɟɪɠɚɳɢɣ ɨɩɪɟɞɟɥɟɧɢɟ AComplicatedType, ɤɨɬɨɪɵɣ ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ ɬɪɚɧ-
ɡɢɬɢɜɧɨ ɜɤɥɸɱɚɟɬ ɜɫɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɩɨɬɪɟɛɨɜɚɬɶɫɹ ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ
43. Разумно пользуйтесь идиомой Pimpl 91
Стр. 91
AComplicatedType, ɢ ɬ.ɞ. ȿɫɥɢ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɢɦɟɸɬ ɛɨɥɶɲɢɟ ɪɚɡɦɟɪɵ, ɜɪɟɦɹ ɤɨɦ-
ɩɢɥɹɰɢɢ ɦɨɠɟɬ ɫɭɳɟɫɬɜɟɧɧɨ ɭɜɟɥɢɱɢɬɶɫɹ.
ȼɬɨɪɨɟ ɫɥɟɞɫɬɜɢɟ — ɫɨɡɞɚɧɢɟ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɟɣ ɢ ɫɨɤɪɵɬɢɟ ɢɦɟɧ ɞɥɹ ɤɨɞɚ, ɤɨɬɨɪɵɣ ɩɵ-
ɬɚɟɬɫɹ ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ. ɇɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɡɚɤɪɵɬɚɹ ɮɭɧɤɰɢɹ-ɱɥɟɧ ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧɚ
ɤɨɞɨɦ ɜɧɟ ɟɟ ɤɥɚɫɫɚ ɢ ɟɝɨ ɞɪɭɡɟɣ, ɨɧɚ ɬɟɦ ɧɟ ɦɟɧɟɟ ɭɱɚɫɬɜɭɟɬ ɜ ɩɨɢɫɤɟ ɢɦɟɧ ɢ ɪɚɡɪɟɲɟɧɢɢ ɩɟ-
ɪɟɝɪɭɡɤɢ ɢ ɬɟɦ ɫɚɦɵɦ ɦɨɠɟɬ ɫɞɟɥɚɬɶ ɜɵɡɨɜ ɧɟɨɞɧɨɡɧɚɱɧɵɦ ɢɥɢ ɧɟɤɨɪɪɟɤɬɧɵɦ. ɉɟɪɟɞ ɜɵ-
ɩɨɥɧɟɧɢɟɦ ɩɪɨɜɟɪɤɢ ɞɨɫɬɭɩɧɨɫɬɢ C++ ɜɵɩɨɥɧɹɟɬ ɩɨɢɫɤ ɢɦɟɧ ɢ ɪɚɡɪɟɲɟɧɢɟ ɩɟɪɟɝɪɭɡɤɢ. ɂɡ-ɡɚ
ɷɬɨɝɨ ɜɢɞɢɦɨɫɬɶ ɢɦɟɟɬ ɛɨɥɟɟ ɜɵɫɨɤɢɣ ɩɪɢɨɪɢɬɟɬ:
int Twice( int ); // 1
class Calc {
public:
string Twice( string ); // 2
private:
char* Twice( char* ); // 3
int Test() {
return Twice( 21 ); // A: ǹȃǳǬǵǫ, ǿǾǸǵȁǳǳ 2 ǳ 3 Ǹǰ
// ǺǹǯȀǹǯȊǽ (ǷǹǮǶǫ ǬȆ ǺǹǯǹǴǽǳ ǿǾǸǵȁǳȊ 1, Ǹǹ
// ǰǰ ǸǰǶȇǲȊ ǻǫǼǼǷǫǽǻǳǭǫǽȇ, ǽǫǵ ǹǸǫ ǼǵǻȆǽǫ ǹǽ
} // ǯǫǸǸǹǮǹ ǵǹǯǫ)
};
Calc c;
c.Twice( "Hello" ); // ǌ: ǹȃǳǬǵǫ, ǿǾǸǵȁǳȊ 3
// ǸǰǯǹǼǽǾǺǸǫ (ǷǹǮǶǫ ǬȆ ǳǼǺǹǶȇǲǹǭǫǽȇǼȊ
// ǿǾǸǵȁǳȊ 2, Ǹǹ ǹǸǫ Ǹǰ ǻǫǼǼǷǫǽǻǳǭǫǰǽǼȊ, ǽǫǵ
// ǵǫǵ Ǿ ǿǾǸǵȁǳǳ 3 ǶǾȂȃǰǰ ǼǹǹǽǭǰǽǼǽǭǳǰ
// ǫǻǮǾǷǰǸǽǾ)
ȼ ɫɬɪɨɤɟ A ɨɛɯɨɞɧɨɣ ɩɭɬɶ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨɛɵ ɹɜɧɨ ɤɜɚɥɢɮɢɰɢɪɨɜɚɬɶ ɜɵɡɨɜ ɤɚɤ
::Twice(21) ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɡɚɫɬɚɜɢɬɶ ɩɨɢɫɤ ɢɦɟɧ ɜɵɛɪɚɬɶ ɝɥɨɛɚɥɶɧɭɸ ɮɭɧɤɰɢɸ. ȼ ɫɬɪɨɤɟ Ȼ
ɨɛɯɨɞɧɨɣ ɩɭɬɶ ɫɨɫɬɨɢɬ ɜ ɞɨɛɚɜɥɟɧɢɢ ɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɚ c.Twice(string("Hello"))
ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɡɚɫɬɚɜɢɬɶ ɪɚɡɪɟɲɟɧɢɟ ɩɟɪɟɝɪɭɡɤɢ ɜɵɛɪɚɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ ɮɭɧɤɰɢɸ. ɇɟɤɨɬɨɪɵɟ
ɢɡ ɬɚɤɢɯ ɩɪɨɛɥɟɦ, ɫɜɹɡɚɧɧɵɯ ɫ ɜɵɡɨɜɚɦɢ, ɦɨɠɧɨ ɪɟɲɢɬɶ ɢ ɛɟɡ ɩɪɢɦɟɧɟɧɢɹ ɢɞɢɨɦɵ Pimpl, ɧɚɩɪɢ-
ɦɟɪ, ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɹ ɡɚɤɪɵɬɵɟ ɩɟɪɟɝɪɭɡɤɢ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ, ɧɨ ɧɟ ɞɥɹ ɜɫɟɯ ɩɪɨɛɥɟɦ, ɪɚɡɪɟ-
ɲɢɦɵɯ ɩɪɢ ɩɨɦɨɳɢ ɢɞɢɨɦɵ Pimpl, ɦɨɠɧɨ ɧɚɣɬɢ ɬɚɤɢɟ ɨɛɯɨɞɧɵɟ ɩɭɬɢ.
Ɍɪɟɬɶɟ ɫɥɟɞɫɬɜɢɟ ɜɥɢɹɟɬ ɧɚ ɨɛɪɚɛɨɬɤɭ ɨɲɢɛɨɤ ɢ ɛɟɡɨɩɚɫɧɨɫɬɶ. Ɋɚɫɫɦɨɬɪɢɦ ɩɪɢɦɟɪ Widget
Ɍɨɦɚ Ʉɚɪɝɢɥɥɚ (Tom Cargill):
class Widget { // …
public:
Widget& operator=( const Widget& );
private:
T1 t1_;
T2 t2_;
};
Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɦɵ ɧɟ ɦɨɠɟɦ ɧɚɩɢɫɚɬɶ ɨɩɟɪɚɬɨɪ operator=, ɤɨɬɨɪɵɣ ɨɛɟɫɩɟɱɢɜɚɟɬ
ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ (ɢɥɢ ɯɨɬɹ ɛɵ ɛɚɡɨɜɭɸ ɝɚɪɚɧɬɢɸ), ɟɫɥɢ ɨɩɟɪɚɰɢɢ T1 ɢɥɢ T2 ɦɨɝɭɬ ɞɚɜɚɬɶ
ɧɟɨɛɪɚɬɢɦɵɟ ɫɛɨɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71). ɏɨɪɨɲɢɟ ɧɨɜɨɫɬɢ, ɨɞɧɚɤɨ, ɫɨɫɬɨɹɬ ɜ ɬɨɦ, ɱɬɨ ɩɪɢ-
ɜɟɞɟɧɧɚɹ ɞɚɥɟɟ ɩɪɨɫɬɚɹ ɬɪɚɧɫɮɨɪɦɚɰɢɹ ɜɫɟɝɞɚ ɨɛɟɫɩɟɱɢɜɚɟɬ, ɤɚɤ ɦɢɧɢɦɭɦ, ɛɚɡɨɜɭɸ ɝɚɪɚɧɬɢɸ
ɞɥɹ ɛɟɡɨɩɚɫɧɨɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɢ ɤɚɤ ɩɪɚɜɢɥɨ — ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ, ɟɫɥɢ ɧɟɨɛɯɨɞɢɦɵɟ ɨɩɟ-
ɪɚɰɢɢ T1 ɢ T2 (ɚ ɢɦɟɧɧɨ — ɤɨɧɫɬɪɭɤɬɨɪɵ ɢ ɞɟɫɬɪɭɤɬɨɪɵ) ɧɟ ɢɦɟɸɬ ɩɨɛɨɱɧɵɯ ɷɮɮɟɤɬɨɜ. Ⱦɥɹ
ɷɬɨɝɨ ɫɥɟɞɭɟɬ ɯɪɚɧɢɬɶ ɨɛɴɟɤɬɵ ɧɟ ɩɨ ɡɧɚɱɟɧɢɸ, ɚ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɟɣ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ
ɫɩɪɹɬɚɧɧɵɦɢ ɡɚ ɟɞɢɧɫɬɜɟɧɧɵɦ ɭɤɚɡɚɬɟɥɟɦ ɧɚ ɪɟɚɥɢɡɚɰɢɸ:
Стр. 92
class Widget { // …
public:
Widget& operator=( const Widget& );
private:
struct Impl;
shared_ptr<Impl> pimpl_;
};
Widget& Widget::operator=( const Widget& ) {
shared_ptr<Impl> temp( new Impl( /*…*/ ) );
// ǓǲǷǰǸȊǰǷ temp->t1_ ǳ temp->t2_; ǰǼǶǳ ǵǫǵǫȊ-ǽǹ ǳǲ
// ǹǺǰǻǫȁǳǴ ǯǫǰǽ ǼǬǹǴ, ǮǰǸǰǻǳǻǾǰǷ ǳǼǵǶȉȂǰǸǳǰ, ǭ
// ǺǻǹǽǳǭǸǹǷ ǼǶǾȂǫǰ — ǺǻǳǸǳǷǫǰǷ ǭǸǰǼǰǸǸȆǰ ǳǲǷǰǸǰǸǳȊ:
pimpl_ = temp;
return *this;
}
ȼ ɬɨ ɜɪɟɦɹ ɤɚɤ ɜɵ ɩɨɥɭɱɚɟɬɟ ɜɫɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɞɨɩɨɥɧɢɬɟɥɶɧɨɝɨ ɭɪɨɜɧɹ ɤɨɫɜɟɧɧɨɫɬɢ,
ɩɪɨɛɥɟɦɚ ɫɨɫɬɨɢɬ ɬɨɥɶɤɨ ɜ ɭɜɟɥɢɱɟɧɢɢ ɫɥɨɠɧɨɫɬɢ ɤɨɞɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 6 ɢ 8).
Ссылки
[Coplien92] §5.5 • [Dewhurst03] §8 • [Lakos96] §6.4.2 • [Meyers97] §34 • [Murray93] §3.3 •
[Stroustrup94] §2.10, §24.4.2 • [Sutter00] §23, §26-30 • [Sutter02] §18, §22 • [Sutter04] §16-17
43. Разумно пользуйтесь идиомой Pimpl 93
Стр. 93
44. Предпочитайте функции, которые
не являются ни членами, ни друзьями
Резюме
Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɞɟɥɚɬɶ ɮɭɧɤɰɢɢ ɧɟ ɱɥɟɧɚɦɢ ɢ ɧɟ ɞɪɭɡɶɹɦɢ ɤɥɚɫɫɨɜ.
Ɏɭɧɤɰɢɢ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ ɢɥɢ ɞɪɭɡɶɹɦɢ ɤɥɚɫɫɨɜ, ɩɨɜɵɲɚɸɬ ɫɬɟɩɟɧɶ ɢɧɤɚɩɫɭɥɹ-
ɰɢɢ ɩɭɬɟɦ ɫɧɢɠɟɧɢɹ ɡɚɜɢɫɢɦɨɫɬɟɣ: ɬɟɥɨ ɬɚɤɨɣ ɮɭɧɤɰɢɢ ɧɟ ɦɨɠɟɬ ɡɚɜɢɫɟɬɶ ɨɬ ɡɚɤɪɵɬɵɯ ɢ ɡɚ-
ɳɢɳɟɧɧɵɯ ɱɥɟɧɨɜ ɤɥɚɫɫɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). Ɉɧɢ ɬɚɤɠɟ ɪɚɡɪɭɲɚɸɬ ɦɨɧɨɥɢɬɧɨɫɬɶ ɤɥɚɫ-
ɫɨɜ, ɫɧɢɠɚɹ ɫɜɹɡɧɨɫɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 33), ɢ ɩɨɜɵɲɚɸɬ ɫɬɟɩɟɧɶ ɨɛɨɛɳɟɧɧɨɫɬɢ, ɬɚɤ ɤɚɤ
ɫɥɨɠɧɨ ɩɢɫɚɬɶ ɲɚɛɥɨɧɵ, ɤɨɬɨɪɵɟ ɧɟ ɡɧɚɸɬ, ɹɜɥɹɟɬɫɹ ɥɢ ɢɧɬɟɪɟɫɭɸɳɚɹ ɧɚɫ ɨɩɟɪɚɰɢɹ ɱɥɟɧɨɦ
ɞɚɧɧɨɝɨ ɬɢɩɚ ɢɥɢ ɧɟɬ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 67).
Ⱦɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɬɨɝɨ, ɞɨɥɠɧɚ ɥɢ ɮɭɧɤɰɢɹ ɛɵɬɶ ɪɟɚɥɢɡɨɜɚɧɚ ɤɚɤ ɱɥɟɧ ɢ/ɢɥɢ ɞɪɭɝ ɤɥɚɫɫɚ,
ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɫɥɟɞɭɸɳɢɦ ɚɥɝɨɪɢɬɦɨɦ:
// ǐǼǶǳ Ǿ ǭǫǼ Ǹǰǽ ǭȆǬǹǻǫ — ǯǰǶǫǴǽǰ ǿǾǸǵȁǳȉ ȂǶǰǸǹǷ.
ǐǼǶǳ ǿǾǸǵȁǳȊ ǺǻǰǯǼǽǫǭǶȊǰǽ ǼǹǬǹǴ ǹǯǳǸ ǳǲ ǹǺǰǻǫǽǹǻǹǭ =, ->,
[] ǳǶǳ (), ǵǹǽǹǻȆǰ ǯǹǶǱǸȆ ǬȆǽȇ ȂǶǰǸǫǷǳ,
ǽǹ
ǯǰǶǫǴǽǰ ǯǫǸǸǾȉ ǿǾǸǵȁǳȉ ȂǶǰǸǹǷ ǵǶǫǼǼǫ.
// ǐǼǶǳ ǿǾǸǵȁǳȊ ǷǹǱǰǽ ǬȆǽȇ Ǹǰ ȂǶǰǸǹǷ ǳ Ǹǰ ǯǻǾǮǹǷ ǶǳǬǹ
// ǳǷǰȉǽǼȊ ǹǺǻǰǯǰǶǰǸǸȆǰ ǺǻǰǳǷǾȄǰǼǽǭǫ ǹǽ ǽǹǮǹ, ȂǽǹǬȆ ǼǯǰǶǫǽȇ
// ǰǰ Ǹǰ ȂǶǰǸǹǷ ǳ ǯǻǾǮǹǷ
ǳǸǫȂǰ ǰǼǶǳ 1. ǿǾǸǵȁǳȊ ǽǻǰǬǾǰǽ ǶǰǭȆǴ ǫǻǮǾǷǰǸǽ ǳǸǹǮǹ ǽǳǺǫ
(ǵǫǵ, ǸǫǺǻǳǷǰǻ, ǭ ǼǶǾȂǫǰ ǹǺǰǻǫǽǹǻǹǭ >> ǳǶǳ <<)
ǳǶǳ 2. ǽǻǰǬǾǰǽ ǺǻǰǹǬǻǫǲǹǭǫǸǳȊ ǽǳǺǹǭ ǯǶȊ ǶǰǭǹǮǹ ǫǻǮǾǷǰǸǽǫ,
ǳǶǳ 3. ǷǹǱǰǽ ǬȆǽȇ ǻǰǫǶǳǲǹǭǫǸǫ Ǽ ǳǼǺǹǶȇǲǹǭǫǸǳǰǷ ǽǹǶȇǵǹ
ǹǽǵǻȆǽǹǮǹ ǳǸǽǰǻǿǰǴǼǫ ǵǶǫǼǼǫ
ǽǹ
ǼǯǰǶǫǴǽǰ ǰǰ Ǹǰ ȂǶǰǸǹǷ ǵǶǫǼǼǫ (ǳ, Ǻǻǳ ǸǰǹǬȀǹǯǳǷǹǼǽǳ,
ǭ ǼǶǾȂǫȊȀ 1 ǳ 2 - ǯǻǾǮǹǷ)
ǐǼǶǳ ǿǾǸǵȁǳȊ ǽǻǰǬǾǰǽ ǭǳǻǽǾǫǶȇǸǹǮǹ ǺǹǭǰǯǰǸǳȊ,
ǽǹ
ǯǹǬǫǭȇǽǰ ǭǳǻǽǾǫǶȇǸǾȉ ǿǾǸǵȁǳȉ-ȂǶǰǸ ǯǶȊ ǹǬǰǼǺǰȂǰǸǳȊ
ǭǳǻǽǾǫǶȇǸǹǮǹ ǺǹǭǰǯǰǸǳȊ, ǳ ǻǰǫǶǳǲǾǴǽǰ ǿǾǸǵȁǳȉ-Ǹǰ ȂǶǰǸ
Ǽ ǳǼǺǹǶȇǲǹǭǫǸǳǰǷ ȈǽǹǴ ǭǳǻǽǾǫǶȇǸǹǴ ǿǾǸǵȁǳǳ.
ǳǸǫȂǰ
ǼǯǰǶǫǴǽǰ ǰǰ ǿǾǸǵȁǳǰǴ-ȂǶǰǸǹǷ.
Примеры
ɉɪɢɦɟɪ. basic_string. ɋɬɚɧɞɚɪɬɧɵɣ ɤɥɚɫɫ basic_string ɱɟɪɟɫɱɭɪ ɦɨɧɨɥɢɬɟɧ ɢ ɢɦɟ-
ɟɬ 103 ɮɭɧɤɰɢɢ-ɱɥɟɧɚ, ɢɡ ɤɨɬɨɪɵɯ 71 ɛɟɡ ɩɨɬɟɪɢ ɷɮɮɟɤɬɢɜɧɨɫɬɢ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɮɭɧɤɰɢɹɦɢ,
ɧɟ ɹɜɥɹɸɳɢɦɢɫɹ ɧɢ ɱɥɟɧɚɦɢ, ɧɢ ɞɪɭɡɶɹɦɢ ɤɥɚɫɫɚ. Ɇɧɨɝɢɟ ɢɡ ɧɢɯ ɞɭɛɥɢɪɭɸɬ ɮɭɧɤɰɢɨɧɚɥɶ-
ɧɨɫɬɶ, ɭɠɟ ɢɦɟɸɳɭɸɫɹ ɜ ɤɚɱɟɫɬɜɟ ɚɥɝɨɪɢɬɦɚ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ, ɥɢɛɨ ɩɪɟɞɫɬɚɜɥɹɸɬ
ɫɨɛɨɣ ɚɥɝɨɪɢɬɦɵ, ɤɨɬɨɪɵɟ ɦɨɝɥɢ ɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɛɨɥɟɟ ɲɢɪɨɤɨ, ɟɫɥɢ ɛɵ ɧɟ ɛɵɥɢ ɫɩɪɹɬɚ-
ɧɵ ɜ ɤɥɚɫɫɟ basic_string. (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 5 ɢ 32, ɚ ɬɚɤɠɟ [Sutter04].)
Ссылки
[Lakos96] §3.6.1, §9.1.2 • [McConnell93] §5.1-4 • [Murray93] §2.6 • [Meyers00] • [Stroustrup00]
§10.3.2, §11.3.2, §11.3.5, §11.5.2, §21.2.3.1 • [Sutter00] §20 • [Sutter04] §37-40
Стр. 94
45. new и delete всегда должны
разрабатываться вместе
Резюме
Ʉɚɠɞɚɹ ɩɟɪɟɝɪɭɡɤɚ void* operator new(parms) ɜ ɤɥɚɫɫɟ ɞɨɥɠɧɚ ɫɨɩɪɨɜɨɠɞɚɬɶɫɹ ɫɨɨɬɜɟɬ-
ɫɬɜɭɸɳɟɣ ɩɟɪɟɝɪɭɡɤɨɣ ɨɩɟɪɚɬɨɪɚ void operator delete(void*, parms), ɝɞɟ parms — ɫɩɢ-
ɫɨɤ ɬɢɩɨɜ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɩɚɪɚɦɟɬɪɨɜ (ɩɟɪɜɵɣ ɢɡ ɤɨɬɨɪɵɯ ɜɫɟɝɞɚ std::size_t). Ɍɨ ɠɟ ɨɬɧɨɫɢɬ-
ɫɹ ɢ ɤ ɨɩɟɪɚɬɨɪɚɦ ɞɥɹ ɦɚɫɫɢɜɨɜ new[] ɢ delete[].
Ɉɛɵɱɧɨ ɪɟɞɤɨ ɬɪɟɛɭɟɬɫɹ ɨɛɟɫɩɟɱɢɬɶ ɧɚɥɢɱɢɟ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɨɩɟɪɚɬɨɪɨɜ new ɢɥɢ
delete, ɧɨ ɟɫɥɢ ɜɫɟ ɠɟ ɬɪɟɛɭɟɬɫɹ ɨɞɢɧ ɢɡ ɧɢɯ — ɬɨ ɨɛɵɱɧɨ ɬɪɟɛɭɸɬɫɹ ɨɧɢ ɨɛɚ. ȿɫɥɢ ɜɵ ɨɩ-
ɪɟɞɟɥɹɟɬɟ ɫɩɟɰɢɮɢɱɧɵɣ ɞɥɹ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ ɨɩɟɪɚɬɨɪ T::operator new, ɤɨɬɨɪɵɣ ɜɵɩɨɥɧɹ-
ɟɬ ɧɟɤɨɬɨɪɨɟ ɫɩɟɰɢɚɥɶɧɨɟ ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ, ɬɨ, ɜɟɪɨɹɬɧɟɟ ɜɫɟɝɨ, ɜɵ ɞɨɥɠɧɵ ɨɩɪɟɞɟɥɢɬɶ
ɢ ɫɩɟɰɢɮɢɱɧɵɣ ɞɥɹ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ ɨɩɟɪɚɬɨɪ T::operator delete, ɤɨɬɨɪɵɣ ɜɵɩɨɥɧɹɟɬ ɫɨ-
ɨɬɜɟɬɫɬɜɭɸɳɟɟ ɨɫɜɨɛɨɠɞɟɧɢɟ ɜɵɞɟɥɟɧɧɨɣ ɩɚɦɹɬɢ.
ɉɨɹɜɥɟɧɢɟ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɫɜɹɡɚɧɨ ɫ ɨɞɧɨɣ ɬɨɧɤɨɣ ɩɪɨɛɥɟɦɨɣ: ɞɟɥɨ ɜ ɬɨɦ, ɱɬɨ ɤɨɦ-
ɩɢɥɹɬɨɪ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɩɟɪɟɝɪɭɠɟɧɧɵɣ ɨɩɟɪɚɬɨɪ T::operator delete ɞɚɠɟ ɟɫɥɢ ɜɵ ɧɢɤɨ-
ɝɞɚ ɹɜɧɨ ɟɝɨ ɧɟ ɜɵɡɵɜɚɟɬɟ. ȼɨɬ ɩɨɱɟɦɭ ɜɵ ɜɫɟɝɞɚ ɞɨɥɠɧɵ ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɨɩɟɪɚɬɨɪɵ new
ɢ delete (ɚ ɬɚɤɠɟ ɨɩɟɪɚɬɨɪɵ new[] ɢ delete[]) ɩɚɪɚɦɢ.
ɉɭɫɬɶ ɜɵ ɨɩɪɟɞɟɥɢɥɢ ɤɥɚɫɫ ɫ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɦ ɜɵɞɟɥɟɧɢɟɦ ɩɚɦɹɬɢ:
class T {
// ...
static void* operator new(std::size_t);
static void* operator new(std::size_t, CustomAllocator&);
static void operator delete(void*, std::size_t);
};
ȼɵ ɜɜɨɞɢɬɟ ɩɪɨɫɬɨɣ ɩɪɨɬɨɤɨɥ ɞɥɹ ɜɵɞɟɥɟɧɢɹ ɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ.
• ȼɵɡɵɜɚɸɳɢɣ ɤɨɞ ɦɨɠɟɬ ɜɵɞɟɥɹɬɶ ɨɛɴɟɤɬɵ ɬɢɩɚ T ɥɢɛɨ ɩɪɢ ɩɨɦɨɳɢ ɪɚɫɩɪɟɞɟɥɢɬɟɥɹ
ɩɨ ɭɦɨɥɱɚɧɢɸ (ɢɫɩɨɥɶɡɭɹ ɜɵɡɨɜ new T), ɥɢɛɨ ɩɪɢ ɩɨɦɨɳɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɪɚɫɩɪɟ-
ɞɟɥɢɬɟɥɹ (ɜɵɡɨɜ new(alloc) T, ɝɞɟ alloc — ɨɛɴɟɤɬ ɬɢɩɚ CustomAllocator).
• ȿɞɢɧɫɬɜɟɧɧɵɣ ɨɩɟɪɚɬɨɪ delete, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɢɫɩɨɥɶɡɨɜɚɧ ɜɵɡɵɜɚɸɳɢɦ ɤɨ-
ɞɨɦ — ɨɩɟɪɚɬɨɪ ɩɨ ɭɦɨɥɱɚɧɢɸ operator delete(size_t), ɬɚɤ ɱɬɨ, ɤɨɧɟɱɧɨ, ɜɵ
ɞɨɥɠɧɵ ɪɟɚɥɢɡɨɜɚɬɶ ɟɝɨ ɬɚɤ, ɱɬɨɛɵ ɨɧ ɤɨɪɪɟɤɬɧɨ ɨɫɜɨɛɨɠɞɚɥ ɩɚɦɹɬɶ, ɜɵɞɟɥɟɧɧɭɸ
ɥɸɛɵɦ ɫɩɨɫɨɛɨɦ.
ɉɨɤɚ ɜɫɟ ɜ ɩɨɪɹɞɤɟ.
Ɉɞɧɚɤɨ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɫɤɪɵɬɨ ɜɵɡɜɚɬɶ ɞɪɭɝɭɸ ɩɟɪɟɝɪɭɡɤɭ ɨɩɟɪɚɬɨɪɚ delete, ɚ ɢɦɟɧɧɨ
T::operator delete(size_t, CustomAllocator&). ɗɬɨ ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɢɧɫɬɪɭɤɰɢɹ
T* p = new(alloc) T;
ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɪɚɡɜɨɪɚɱɢɜɚɟɬɫɹ ɜ ɧɟɱɬɨ ɧɚɩɨɞɨɛɢɟ
// ǜǮǰǸǰǻǳǻǹǭǫǸǸȆǴ ǵǹǷǺǳǶȊǽǹǻǹǷ ǵǹǯ ǯǶȊ
// ǳǸǼǽǻǾǵȁǳǳ T* p = new(alloc) T;
//
void* __compilerTemp = T::operator new(sizeof (T), alloc);
T* p;
45. new и delete всегда должны разрабатываться вместе 95
Стр. 95
try {
p = new (__compilerTemp ) T; // ǜǹǲǯǫǸǳǰ ǹǬȅǰǵǽǫ T Ǻǹ
// ǫǯǻǰǼǾ __compilerTemp
}
catch(…) { // ǜǬǹǴ ǭ ǵǹǸǼǽǻǾǵǽǹǻǰ...
T::operator delete (__compilerTemp , sizeof (T), alloc);
throw;
}
ɂɬɚɤ, ɤɨɦɩɢɥɹɬɨɪ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɜɫɬɚɜɥɹɟɬ ɤɨɞ ɜɵɡɨɜɚ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɨɩɟɪɚɬɨɪɚ
T::operator delete ɞɥɹ ɩɟɪɟɝɪɭɠɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ T::operator new, ɱɬɨ ɫɨɜɟɪɲɟɧɧɨ
ɥɨɝɢɱɧɨ, ɟɫɥɢ ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ ɩɪɨɲɥɨ ɭɫɩɟɲɧɨ, ɧɨ ɩɪɨɢɡɨɲɟɥ ɫɛɨɣ ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ. “ɋɨɨɬ-
ɜɟɬɫɬɜɭɸɳɚɹ” ɫɢɝɧɚɬɭɪɚ ɨɩɟɪɚɬɨɪɚ delete ɢɦɟɟɬ ɜɢɞ void operator delete(void*,
ǺǫǻǫǷǰǽǻȆ_ǹǺǰǻǫǽǹǻǫ_new).
Ɍɟɩɟɪɶ ɩɟɪɟɣɞɟɦ ɤ ɫɚɦɨɦɭ ɢɧɬɟɪɟɫɧɨɦɭ. ɋɬɚɧɞɚɪɬ C++ ([C++03] §5.3.4(17)) ɝɥɚɫɢɬ, ɱɬɨ
ɩɪɢɜɟɞɟɧɧɵɣ ɜɵɲɟ ɤɨɞ ɛɭɞɟɬ ɝɟɧɟɪɢɪɨɜɚɬɶɫɹ ɬɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɪɟɚɥɶɧɨ ɫɭɳɟɫɬɜɭɟɬ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ ɩɟɪɟɝɪɭɡɤɚ ɨɩɟɪɚɬɨɪɚ delete. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɤɨɞ ɜɨɨɛɳɟ ɧɟ ɛɭɞɟɬ
ɜɵɡɵɜɚɬɶ ɧɢɤɚɤɨɝɨ ɨɩɟɪɚɬɨɪɚ delete ɩɪɢ ɫɛɨɟ ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ. Ⱦɪɭɝɢɦɢ ɫɥɨɜɚɦɢ, ɩɪɢ ɫɛɨɹɯ
ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ ɦɵ ɩɨɥɭɱɢɦ ɭɬɟɱɤɭ ɩɚɦɹɬɢ. ɂɡ ɲɟɫɬɢ ɩɪɨɜɟɪɟɧɧɵɯ ɧɚɦɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ
ɤɨɦɩɢɥɹɬɨɪɨɜ ɬɨɥɶɤɨ ɞɜɚ ɜɵɜɨɞɢɥɢ ɩɪɟɞɭɩɪɟɠɞɟɧɢɟ ɜ ɬɚɤɨɣ ɫɢɬɭɚɰɢɢ. ȼɨɬ ɩɨɱɟɦɭ ɤɚɠɞɵɣ
ɩɟɪɟɝɪɭɠɟɧɧɵɣ ɨɩɟɪɚɬɨɪ void* operator new(parms) ɞɨɥɠɟɧ ɫɨɩɪɨɜɨɠɞɚɬɶɫɹ ɫɨɨɬɜɟɬ-
ɫɬɜɭɸɳɟɣ ɩɟɪɟɝɪɭɡɤɨɣ void operator delete(void*, parms).
Ɋɚɡɦɟɳɚɸɳɢɣ ɨɩɟɪɚɬɨɪ new
void* T::operator new(size_t, void* p) { return p; }
ɧɟ ɬɪɟɛɭɟɬ ɧɚɥɢɱɢɹ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɨɩɟɪɚɬɨɪɚ delete, ɩɨɫɤɨɥɶɤɭ ɪɟɚɥɶɧɨɝɨ ɜɵɞɟɥɟɧɢɹ ɩɚ-
ɦɹɬɢ ɩɪɢ ɷɬɨɦ ɧɟ ɩɪɨɢɫɯɨɞɢɬ. ȼɫɟ ɩɪɨɬɟɫɬɢɪɨɜɚɧɧɵɟ ɧɚɦɢ ɤɨɦɩɢɥɹɬɨɪɵ ɧɟ ɜɵɞɚɜɚɥɢ ɧɢɤɚɤɢɯ
ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ ɩɨ ɩɨɜɨɞɭ ɨɬɫɭɬɫɬɜɢɹ ɨɩɟɪɚɬɨɪɚ void T::operator delete(void*,
size_t, void*).
Ссылки
[C++03] §5.3.4 • [Stroustrup00] §6.2.6.2, §15.6 • [Sutter00] §36
Стр. 96
46. При наличии пользовательского new...
46. При наличии пользовательского new

следует предоставлять все стандартные
типы этого оператора
46. При наличии пользовательского new...
Резюме
ȿɫɥɢ ɤɥɚɫɫ ɨɩɪɟɞɟɥɹɟɬ ɥɸɛɭɸ ɩɟɪɟɝɪɭɡɤɭ ɨɩɟɪɚɬɨɪɚ new, ɨɧ ɞɨɥɠɟɧ ɩɟɪɟɝɪɭɡɢɬɶ ɜɫɟ ɬɪɢ
ɫɬɚɧɞɚɪɬɧɵɯ ɬɢɩɚ ɷɬɨɝɨ ɨɩɟɪɚɬɨɪɚ — ɨɛɵɱɧɵɣ new, ɪɚɡɦɟɳɚɸɳɢɣ ɢ ɧɟ ɝɟɧɟɪɢɪɭɸɳɢɣ ɢɫ-
ɤɥɸɱɟɧɢɣ. ȿɫɥɢ ɷɬɨɝɨ ɧɟ ɫɞɟɥɚɬɶ, ɬɨ ɷɬɢ ɨɩɟɪɚɬɨɪɵ ɨɤɚɠɭɬɫɹ ɫɤɪɵɬɵɦɢ ɢ ɧɟɞɨɫɬɭɩɧɵɦɢ
ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ.
Ɉɛɵɱɧɨ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɟ ɨɩɟɪɚɬɨɪɵ new ɢ delete ɧɭɠɧɵ ɨɱɟɧɶ ɪɟɞɤɨ, ɧɨ ɟɫɥɢ ɨɧɢ ɜɫɟ ɠɟ
ɨɤɚɡɵɜɚɸɬɫɹ ɧɟɨɛɯɨɞɢɦɵ, ɬɨ ɜɪɹɞ ɥɢ ɜɵ ɡɚɯɨɬɢɬɟ, ɱɬɨɛɵ ɨɧɢ ɫɤɪɵɜɚɥɢ ɜɫɬɪɨɟɧɧɵɟ ɫɢɝɧɚɬɭɪɵ.
ȼ C++, ɩɨɫɥɟ ɬɨɝɨ ɤɚɤ ɜɵ ɨɩɪɟɞɟɥɢɬɟ ɢɦɹ ɜ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ (ɧɚɩɪɢɦɟɪ, ɜ ɨɛɥɚɫɬɢ ɜɢ-
ɞɢɦɨɫɬɢ ɤɥɚɫɫɚ), ɜɫɟ ɬɚɤɢɟ ɠɟ ɢɦɟɧɚ ɜ ɨɯɜɚɬɵɜɚɸɳɢɯ ɨɛɥɚɫɬɹɯ ɜɢɞɢɦɨɫɬɢ ɨɤɚɠɭɬɫɹ ɫɤɪɵɬɵ
(ɧɚɩɪɢɦɟɪ, ɜ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ ɢɥɢ ɨɯɜɚɬɵɜɚɸɳɢɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ), ɬɚɤ ɱɬɨ ɩɟɪɟɝɪɭɡɤɚ
ɧɢɤɨɝɞɚ ɧɟ ɪɚɛɨɬɚɟɬ ɱɟɪɟɡ ɝɪɚɧɢɰɵ ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ. Ʉɨɝɞɚ ɪɟɱɶ ɢɞɟɬ ɨɛ ɢɦɟɧɢ ɨɩɟɪɚɬɨɪɚ
new, ɧɟɨɛɯɨɞɢɦɨ ɛɵɬɶ ɨɫɨɛɟɧɧɨ ɨɫɬɨɪɨɠɧɵɦ ɢ ɜɧɢɦɚɬɟɥɶɧɵɦ, ɱɬɨɛɵ ɧɟ ɭɫɥɨɠɧɹɬɶ ɠɢɡɧɶ
ɫɟɛɟ ɢ ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ.
ɉɭɫɬɶ ɜɵ ɨɩɪɟɞɟɥɢɥɢ ɫɥɟɞɭɸɳɢɣ ɨɩɟɪɚɬɨɪ new, ɫɩɟɰɢɮɢɱɧɵɣ ɞɥɹ ɤɥɚɫɫɚ:
class C {
// ...
// ǜǵǻȆǭǫǰǽ ǽǻǳ ǼǽǫǸǯǫǻǽǸȆȀ ǭǳǯǫ ǹǺǰǻǫǽǹǻǫ new

static void* operator new(size_t, MemoryPool&);
};
Ɍɟɩɟɪɶ, ɟɫɥɢ ɤɬɨ-ɬɨ ɩɨɩɵɬɚɟɬɫɹ ɧɚɩɢɫɚɬɶ ɜɵɪɚɠɟɧɢɟ ɫ ɨɛɵɱɧɵɦ ɫɬɚɧɞɚɪɬɧɵɦ new C,
ɤɨɦɩɢɥɹɬɨɪ ɫɨɨɛɳɢɬ ɨ ɬɨɦ, ɱɬɨ ɨɧ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɧɚɣɬɢ ɨɛɵɱɧɵɣ ɫɬɚɪɵɣ ɨɩɟɪɚɬɨɪ new.
Ɉɛɴɹɜɥɟɧɢɟ ɩɟɪɟɝɪɭɡɤɢ C::operator new ɫ ɩɚɪɚɦɟɬɪɨɦ ɬɢɩɚ MemoryPool ɫɤɪɵɜɚɟɬ ɜɫɟ
ɨɫɬɚɥɶɧɵɟ ɩɟɪɟɝɪɭɡɤɢ, ɜɤɥɸɱɚɹ ɡɧɚɤɨɦɵɟ ɜɫɬɪɨɟɧɧɵɟ ɝɥɨɛɚɥɶɧɵɟ ɜɟɪɫɢɢ, ɤɨɬɨɪɵɟ ɜɫɟ ɦɵ
ɡɧɚɟɦ ɢ ɥɸɛɢɦ:
void* operator new(std::size_t); // ǙǬȆȂǸȆǴ
void* operator new(std::size_t,
std::nothrow_t) throw(); // ǘǰ ǮǰǸǰǻǳǻǾȉȄǳǴ ǳǼǵǶȉȂǰǸǳǴ
void* operator new(std::size_t,
void*); // ǛǫǲǷǰȄǫȉȄǳǴ
ȼ ɤɚɱɟɫɬɜɟ ɞɪɭɝɨɝɨ ɜɚɪɢɚɧɬɚ ɫɨɛɵɬɢɣ ɩɪɟɞɩɨɥɨɠɢɦ, ɱɬɨ ɜɚɲ ɤɥɚɫɫ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɧɟɤɨɬɨ-
ɪɭɸ ɫɩɟɰɢɮɢɱɧɭɸ ɞɥɹ ɞɚɧɧɨɝɨ ɤɥɚɫɫɚ ɜɟɪɫɢɸ ɨɩɟɪɚɬɨɪɚ new — ɨɞɧɭ ɢɡ ɬɪɟɯ. ȼ ɬɚɤɨɦ ɫɥɭɱɚɟ
ɷɬɨ ɨɛɴɹɜɥɟɧɢɟ ɬɚɤɠɟ ɫɤɪɨɟɬ ɨɫɬɚɥɶɧɵɟ ɞɜɟ ɜɟɪɫɢɢ:
class C {
// ...
// ǜǵǻȆǭǫǰǽ ǯǭǰ ǯǻǾǮǳǰ ǼǽǫǸǯǫǻǽǸȆǰ ǭǰǻǼǳǳ ǹǺǰǻǫǽǹǻǫ new
static void* operator new(size_t, void*);
};
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ, ɱɬɨɛɵ ɭ ɤɥɚɫɫɚ C ɜ ɟɝɨ ɨɛɥɚɫɬɶ ɜɢɞɢɦɨɫɬɢ ɛɵɥɢ ɹɜɧɨ ɜɧɟɫɟɧɵ ɜɫɟ ɬɪɢ
ɫɬɚɧɞɚɪɬɧɵɟ ɜɟɪɫɢɢ ɨɩɟɪɚɬɨɪɚ new. Ɉɛɵɱɧɨ ɜɫɟ ɨɧɢ ɞɨɥɠɧɵ ɢɦɟɬɶ ɨɞɧɭ ɢ ɬɭ ɠɟ ɜɢɞɢɦɨɫɬɶ.
(ȼɢɞɢɦɨɫɬɶ ɞɥɹ ɨɬɞɟɥɶɧɵɯ ɜɟɪɫɢɣ ɦɨɠɟɬ ɛɵɬɶ ɫɞɟɥɚɧɚ ɡɚɤɪɵɬɨɣ, ɟɫɥɢ ɜɵ ɯɨɬɢɬɟ ɹɜɧɨ ɡɚɩɪɟɬɢɬɶ
46. При наличии пользовательского new... 97
Стр. 97
ɨɞɢɧ ɢɡ ɜɚɪɢɚɧɬɨɜ ɨɩɟɪɚɬɨɪɚ new, ɨɞɧɚɤɨ ɰɟɥɶ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ — ɧɚɩɨɦɧɢɬɶ, ɱɬɨɛɵ ɜɵ
ɧɟ ɫɤɪɵɥɢ ɷɬɢ ɜɟɪɫɢɢ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨ.)
Ɂɚɦɟɬɢɦ, ɱɬɨ ɜɵ ɞɨɥɠɧɵ ɜɫɟɝɞɚ ɢɡɛɟɝɚɬɶ ɫɨɤɪɵɬɢɹ ɪɚɡɦɟɳɚɸɳɟɝɨ new, ɩɨɫɤɨɥɶɤɭ ɨɧ ɢɧ-
ɬɟɧɫɢɜɧɨ ɢɫɩɨɥɶɡɭɟɬɫɹ ɤɨɧɬɟɣɧɟɪɚɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ.
ȼɫɟ, ɱɬɨ ɨɫɬɚɥɨɫɶ ɭɩɨɦɹɧɭɬɶ, — ɷɬɨ ɬɨ, ɱɬɨ ɜɧɟɫɟɧɢɟ ɨɩɟɪɚɬɨɪɚ new ɜ ɨɛɥɚɫɬɶ ɜɢɞɢɦɨɫɬɢ
ɦɨɠɟɬ ɛɵɬɶ ɫɞɟɥɚɧɨ ɞɜɭɦɹ ɪɚɡɥɢɱɧɵɦɢ ɫɩɨɫɨɛɚɦɢ ɜ ɞɜɭɯ ɪɚɡɧɵɯ ɫɢɬɭɚɰɢɹɯ. ȿɫɥɢ ɛɚɡɨɜɵɣ
ɤɥɚɫɫ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɬɚɤɠɟ ɨɩɪɟɞɟɥɹɟɬ ɨɩɟɪɚɬɨɪ new, ɜɫɟ, ɱɬɨ ɜɚɦ ɧɚɞɨ, — “ɪɚɫɤɪɵɬɶ” ɨɩɟɪɚ-
ɬɨɪ new:
class C : public B { // ...
public:
using B::operator new;
};
ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ, ɟɫɥɢ ɧɟ ɢɦɟɟɬɫɹ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɢɥɢ ɜ ɧɟɦ ɧɟ ɨɩɪɟɞɟɥɟɧ ɨɩɟɪɚɬɨɪ
new, ɜɵ ɞɨɥɠɧɵ ɧɚɩɢɫɚɬɶ ɤɨɪɨɬɤɭɸ ɩɟɪɟɫɵɥɚɸɳɭɸ ɮɭɧɤɰɢɸ (ɩɨɫɤɨɥɶɤɭ ɧɟɥɶɡɹ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ using ɞɥɹ ɜɧɟɫɟɧɢɹ ɢɦɟɧ ɢɡ ɝɥɨɛɚɥɶɧɨɣ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ):
class C { // ...
public:
static void* operator new(std::size_t s) {
return ::operator new(s);
}
static void* operator new(std::size_t s,
std::nothrow_t nt) throw() {
return ::operator new(s, nt);
}
static void* operator new(std::size_t s, void* p) {

return ::operator new(s, p);
}
};
Ɋɚɫɫɦɨɬɪɟɧɧɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɩɪɢɦɟɧɢɦɚ ɬɚɤɠɟ ɤ ɜɟɪɫɢɹɦ ɨɩɟɪɚɬɨɪɨɜ ɞɥɹ ɦɚɫɫɢɜɨɜ —
operator new[].
ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɚ ɜɟɪɫɢɢ new(nothrow) ɜ ɜɚɲɟɦ ɤɨɞɟ, ɧɨ ɬɟɦ ɧɟ ɦɟɧɟɟ ɨɛɟɫɩɟɱɶɬɟ ɢ ɟɟ,
ɱɬɨɛɵ ɩɨɥɶɡɨɜɚɬɟɥɢ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɧɟ ɨɤɚɡɚɥɢɫɶ ɜ ɤɚɤɨɣ-ɬɨ ɦɨɦɟɧɬ ɧɟɩɪɢɹɬɧɨ ɭɞɢɜɥɟɧɵ.
Ссылки
[Dewhurst03] §60 • [Sutter04] §22-23
Стр. 98
Конструкторы, деструкторы
и копирование
ȿɫɥɢ ɫɬɚɧɞɚɪɬ ɩɪɢɜɟɥ ɜɚɫ ɤ ɨɛɪɵɜɭ, ɷɬɨ ɟɳɟ ɧɟ ɡɧɚɱɢɬ, ɱɬɨ ɜɵ
ɞɨɥɠɧɵ ɩɪɵɝɧɭɬɶ ɫ ɧɟɝɨ.
— ɇɨɪɦɚɧ Ⱦɚɣɦɨɧɞ (Norman Diamond)
Ɉ Ȼɨɥɶɲɨɣ ɑɟɬɜɟɪɤɟ ɫɩɟɰɢɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɛɵɥɨ ɫɤɚɡɚɧɨ ɞɨɫɬɚɬɨɱɧɨ, ɱɬɨɛɵ ɜɵ ɧɟ ɭɞɢɜ-

ɥɹɥɢɫɶ ɬɨɦɭ, ɱɬɨ ɢɦ ɩɨɫɜɹɳɟɧ ɨɬɞɟɥɶɧɵɣ ɪɚɡɞɟɥ. Ɂɞɟɫɶ ɫɨɛɪɚɧɵ ɡɧɚɧɢɹ ɢ ɩɪɚɤɬɢɤɚ, ɫɜɹɡɚɧ-
ɧɵɟ ɫ ɤɨɧɫɬɪɭɤɬɨɪɚɦɢ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɤɨɩɢɪɭɸɳɢɦɢ ɤɨɧɫɬɪɭɤɬɨɪɚɦɢ, ɤɨɩɢɪɭɸɳɢɦ ɩɪɢɫɜɚɢ-
ɜɚɧɢɟɦ ɢ ɞɟɫɬɪɭɤɬɨɪɚɦɢ.
Ɉɞɧɚ ɢɡ ɩɪɢɱɢɧ, ɩɨ ɤɨɬɨɪɵɦ ɩɪɢ ɪɚɛɨɬɟ ɫ ɷɬɢɦɢ ɮɭɧɤɰɢɹɦɢ ɫɥɟɞɭɟɬ ɛɵɬɶ ɨɫɨɛɟɧɧɨ ɜɧɢ-
ɦɚɬɟɥɶɧɵɦɢ, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɟɫɥɢ ɜɵ ɞɚɞɢɬɟ ɤɨɦɩɢɥɹɬɨɪɭ ɯɨɬɹ ɛɵ ɩɨɥɲɚɧɫɚ — ɨɧ ɬɭɬ
ɠɟ ɧɚɩɢɲɟɬ ɷɬɢ ɮɭɧɤɰɢɢ ɡɚ ɜɚɫ. ȿɳɟ ɨɞɧɚ ɩɪɢɱɢɧɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ C++ ɩɨ ɭɦɨɥɱɚɧɢɸ
ɪɚɫɫɦɚɬɪɢɜɚɟɬ ɤɥɚɫɫɵ ɤɚɤ ɬɢɩɵ-ɡɧɚɱɟɧɢɹ, ɧɨ ɞɚɥɟɤɨ ɧɟ ɜɫɟ ɬɢɩɵ ɢɦɟɧɧɨ ɬɚɤɨɜɵ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 32). ɇɚɞɨ ɨɬɱɟɬɥɢɜɨ ɩɨɧɢɦɚɬɶ, ɤɨɝɞɚ ɫɥɟɞɭɟɬ ɩɢɫɚɬɶ (ɢɥɢ ɡɚɩɪɟɳɚɬɶ) ɷɬɢ ɫɩɟɰɢ-
ɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɹɜɧɨ, ɢ ɫɥɟɞɨɜɚɬɶ ɩɪɚɜɢɥɚɦ ɢ ɪɟɤɨɦɟɧɞɚɰɢɹɦ ɢɡ ɷɬɨɝɨ ɪɚɡɞɟɥɚ — ɷɬɨ ɩɨɦɨ-
ɠɟɬ ɜɚɦ ɜ ɧɚɩɢɫɚɧɢɢ ɤɨɪɪɟɤɬɧɨɝɨ, ɪɚɫɲɢɪɹɟɦɨɝɨ ɢ ɛɟɡɨɩɚɫɧɨɝɨ ɤɨɞɚ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 51 — “Ⱦɟɫɬɪɭɤɬɨɪɵ, ɮɭɧɤ-
ɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɢ ɨɛɦɟɧɚ ɧɟ ɨɲɢɛɚɸɬɫɹ”.
99
Стр. 99
47. Определяйте и инициализируйте
переменные@члены в одном порядке
Резюме
ɉɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɜɫɟɝɞɚ ɢɧɢɰɢɚɥɢɡɢɪɭɸɬɫɹ ɜ ɬɨɦ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɢ ɨɛɴɹɜɥɟɧɵ ɩɪɢ
ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ; ɩɨɪɹɞɨɤ ɢɯ ɭɩɨɦɢɧɚɧɢɹ ɜ ɫɩɢɫɤɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɝɧɨɪɢɪɭɟɬ-
ɫɹ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜ ɤɨɞɟ ɤɨɧɫɬɪɭɤɬɨɪɚ ɭɤɚɡɚɧ ɬɨɬ ɠɟ ɩɨɪɹɞɨɤ, ɱɬɨ ɢ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ.
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
class Employee {
string email_, firstName_, lastName_;
public:
Employee( const char* firstName, const char* lastName )
: firstName_(firstName), lastName_(lastName)
, email_(firstName_+"."+lastName_+"@acme.com") {}
};
ɗɬɨɬ ɤɨɞ ɫɨɞɟɪɠɢɬ ɨɲɢɛɤɭ, ɫɬɨɥɶ ɠɟ ɧɟɩɪɢɹɬɧɭɸ, ɫɤɨɥɶ ɢ ɬɪɭɞɧɨ ɨɛɧɚɪɭɠɢɜɚɟɦɭɸ. ɉɨ-
ɫɤɨɥɶɤɭ ɱɥɟɧ email_ ɨɛɴɹɜɥɟɧ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ ɞɨ first_ ɢ last_, ɨɧ ɛɭɞɟɬ ɢɧɢɰɢɚ-
ɥɢɡɢɪɨɜɚɧ ɩɟɪɜɵɦ ɢ ɛɭɞɟɬ ɩɵɬɚɬɶɫɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɳɟ ɧɟ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɩɨɥɹ. Ȼɨɥɟɟ
ɬɨɝɨ, ɟɫɥɢ ɨɩɪɟɞɟɥɟɧɢɟ ɤɨɧɫɬɪɭɤɬɨɪɚ ɧɚɯɨɞɢɬɫɹ ɜ ɨɬɞɟɥɶɧɨɦ ɮɚɣɥɟ, ɬɨ ɜɵɹɜɢɬɶ ɬɚɤɨɟ ɭɞɚɥɟɧ-
ɧɨɟ ɜɥɢɹɧɢɟ ɩɨɪɹɞɤɚ ɨɛɴɹɜɥɟɧɢɹ ɩɟɪɟɦɟɧɧɵɯ-ɱɥɟɧɨɜ ɤɥɚɫɫɚ ɧɚ ɤɨɪɪɟɤɬɧɨɫɬɶ ɤɨɧɫɬɪɭɤɬɨɪɚ
ɨɤɚɠɟɬɫɹ ɟɳɟ ɬɪɭɞɧɟɟ.
ɗɬɚ ɨɫɨɛɟɧɧɨɫɬɶ ɹɡɵɤɚ ɨɛɭɫɥɨɜɥɟɧɚ ɧɟɨɛɯɨɞɢɦɨɫɬɶɸ ɝɚɪɚɧɬɢɪɨɜɚɬɶ ɟɞɢɧɵɣ ɩɨɪɹɞɨɤ
ɭɧɢɱɬɨɠɟɧɢɹ ɱɥɟɧɨɜ; ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɞɟɫɬɪɭɤɬɨɪ ɛɵɥ ɛɵ ɞɨɥɠɟɧ ɭɧɢɱɬɨɠɚɬɶ ɨɛɴɟɤɬɵ ɜ
ɪɚɡɧɨɦ ɩɨɪɹɞɤɟ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɨɝɨ, ɜ ɤɚɤɨɦ ɢɦɟɧɧɨ ɩɨɪɹɞɤɟ ɤɨɧɫɬɪɭɤɬɨɪ ɫɨɡɞɚɜɚɥ ɢɯ.
ɇɚɤɥɚɞɧɵɟ ɪɚɫɯɨɞɵ, ɧɟɨɛɯɨɞɢɦɵɟ ɞɥɹ ɪɟɲɟɧɢɹ ɷɬɨɣ ɩɪɨɛɥɟɦɵ, ɩɪɢɡɧɚɧɵ ɧɟɩɪɢɟɦɥɟɦɵɦɢ.
Ɋɟɲɟɧɢɟ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨɛɵ ɜɫɟɝɞɚ ɩɢɫɚɬɶ ɢɧɢɰɢɚɥɢɡɚɬɨɪɵ ɱɥɟɧɨɜ ɜ ɬɨɦ ɠɟ ɩɨɪɹɞ-
ɤɟ, ɜ ɤɨɬɨɪɨɦ ɷɬɢ ɱɥɟɧɵ ɨɛɴɹɜɥɟɧɵ ɜ ɤɥɚɫɫɟ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɫɪɚɡɭ ɫɬɚɧɨɜɹɬɫɹ ɨɱɟɜɢɞɧɵɦɢ ɜɫɟ
ɧɟɤɨɪɪɟɤɬɧɵɟ ɡɚɜɢɫɢɦɨɫɬɢ ɦɟɠɞɭ ɱɥɟɧɚɦɢ. ȿɳɟ ɥɭɱɲɟ ɩɨɥɧɨɫɬɶɸ ɢɡɛɟɝɚɬɶ ɡɚɜɢɫɢɦɨɫɬɢ
ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɨɞɧɨɝɨ ɱɥɟɧɚ ɨɬ ɞɪɭɝɢɯ.
Ɇɧɨɝɢɟ ɤɨɦɩɢɥɹɬɨɪɵ (ɧɨ ɧɟ ɜɫɟ) ɜɵɞɚɸɬ ɩɪɟɞɭɩɪɟɠɞɟɧɢɟ ɩɪɢ ɧɚɪɭɲɟɧɢɢ ɷɬɨɝɨ ɩɪɚɜɢɥɚ.
Ссылки
[Cline99] §22.03-11 • [Dewhurst03] §52-53 • [Koenig97] §4 • [Lakos96] §10.3.5 • [Meyers97]
§13 • [Murray93] §2.1.3 • [Sutter00] §47
100 Конструкторы, деструкторы и копирование
Стр. 100
48. В конструкторах предпочитайте
инициализацию присваиванию
Резюме
ȼ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɜɦɟɫɬɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɞɥɹ ɭɫɬɚɧɨɜɤɢ ɡɧɚ-
ɱɟɧɢɣ ɩɟɪɟɦɟɧɧɵɯ-ɱɥɟɧɨɜ ɩɪɟɞɨɯɪɚɧɹɟɬ ɨɬ ɧɟɧɭɠɧɨɣ ɪɚɛɨɬɵ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɪɢ ɬɨɦ
ɠɟ ɨɛɴɟɦɟ ɜɜɨɞɢɦɨɝɨ ɢɫɯɨɞɧɨɝɨ ɬɟɤɫɬɚ.
Ʉɨɧɫɬɪɭɤɬɨɪɵ ɝɟɧɟɪɢɪɭɸɬ ɫɤɪɵɬɵɣ ɤɨɞ ɢɧɢɰɢɚɥɢɡɚɰɢɢ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
class A {
string s1_, s2_;
public:
A() { s1_ = "Hello, "; s2_ = "world"; }
};
ȼ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɣ ɤɨɞ ɤɨɧɫɬɪɭɤɬɨɪɚ ɜɵɝɥɹɞɢɬ ɬɚɤ, ɤɚɤ ɟɫɥɢ ɛɵ ɜɵ ɧɚ-
ɩɢɫɚɥɢ:
A() : s1_(), s2_() { s1_ = "Hello, "; s2_ = "world"; }
Ɍɨ ɟɫɬɶ ɨɛɴɟɤɬɵ, ɧɟ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɜɚɦɢ ɹɜɧɨ, ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɢɧɢɰɢɚɥɢɡɢɪɭɸɬɫɹ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɯ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɩɨɫɥɟ ɱɟɝɨ ɜɵɩɨɥɧɹɟɬɫɹ ɩɪɢɫɜɚɢɜɚɧɢɟ
ɡɧɚɱɟɧɢɣ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɯ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ. ɑɚɳɟ ɜɫɟɝɨ ɨɩɟɪɚɬɨɪɵ ɩɪɢɫɜɚɢɜɚ-
ɧɢɹ ɧɟɬɪɢɜɢɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ ɜɵɩɨɥɧɹɸɬ ɧɟɦɧɨɝɨ ɛɨɥɶɲɟ ɪɚɛɨɬɵ, ɱɟɦ ɤɨɧɫɬɪɭɤɬɨɪɵ, ɩɨ-
ɫɤɨɥɶɤɭ ɪɚɛɨɬɚɸɬ ɫ ɭɠɟ ɫɨɡɞɚɧɧɵɦɢ ɨɛɴɟɤɬɚɦɢ.
Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɩɟɪɟɦɟɧɧɵɯ-ɱɥɟɧɨɜ ɜ ɫɩɢɫɤɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɞɚɟɬ ɤɨɞ,
ɥɭɱɲɟ ɜɵɪɚɠɚɸɳɢɣ ɜɚɲɢ ɧɚɦɟɪɟɧɢɹ ɢ ɨɛɵɱɧɨ ɛɨɥɟɟ ɛɵɫɬɪɵɣ ɢ ɦɟɧɶɲɟɝɨ ɪɚɡɦɟɪɚ:
A() : s1_("Hello , "), s2_("world ") { }
ɗɬɚ ɦɟɬɨɞɢɤɚ ɧɟ ɹɜɥɹɟɬɫɹ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɟɣ; ɷɬɨ — ɢɡɛɟɠɚɧɢɟ ɩɪɟɠɞɟɜɪɟ-
ɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).
ȼɫɟɝɞɚ ɜɵɩɨɥɧɹɣɬɟ ɡɚɯɜɚɬ ɧɟɭɩɪɚɜɥɹɟɦɨɝɨ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ ɨɩɟɪɚ-
ɬɨɪɨɦ new, ɪɟɡɭɥɶɬɚɬ ɤɨɬɨɪɨɝɨ ɧɟ ɩɟɪɟɞɚɟɬɫɹ ɧɟɦɟɞɥɟɧɧɨ ɤɨɧɫɬɪɭɤɬɨɪɭ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɝɨ
ɭɤɚɡɚɬɟɥɹ) ɜ ɬɟɥɟ ɤɨɧɫɬɪɭɤɬɨɪɚ, ɚ ɧɟ ɜ ɫɩɢɫɤɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ (ɫɦ. [Sutter02]). Ʉɨɧɟɱɧɨ, ɥɭɱɲɟ
ɜɫɟɝɨ ɜɨɨɛɳɟ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɚɤɢɯ ɧɟɛɟɡɨɩɚɫɧɵɯ ɢ ɧɟ ɢɦɟɸɳɢɯ ɜɥɚɞɟɥɶɰɚ ɪɟɫɭɪɫɨɜ (ɫɦ. ɪɟ-
Ссылки
[Dewhurst03] §51, §59 • [Keffer95] pp.13-14 • [Meyers97] §12 • [Murray93] §2.1.31 • [Sutter00]
§8, §47 • [Sutter02] §18
48. В конструкторах предпочитайте инициализацию присваиванию 101
Стр. 101
49. Избегайте вызовов виртуальных функций
в конструкторах и деструкторах
Резюме
ȼɧɭɬɪɢ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɢ ɞɟɫɬɪɭɤɬɨɪɨɜ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɬɟɪɹɸɬ ɜɢɪɬɭɚɥɶɧɨɫɬɶ. ɏɭɠɟ
ɬɨɝɨ — ɜɫɟ ɩɪɹɦɵɟ ɢɥɢ ɤɨɫɜɟɧɧɵɟ ɜɵɡɨɜɵ ɧɟɪɟɚɥɢɡɨɜɚɧɧɵɯ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɢɡ
ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪɚ ɩɪɢɜɨɞɹɬ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ. ȿɫɥɢ ɜɚɲ ɞɢɡɚɣɧ
ɬɪɟɛɭɟɬ ɜɢɪɬɭɚɥɶɧɨɣ ɩɟɪɟɞɚɱɢ ɜ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪɚ ɛɚɡɨɜɨ-
ɝɨ ɤɥɚɫɫɚ, ɫɥɟɞɭɟɬ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɧɨɣ ɦɟɬɨɞɢɤɨɣ, ɧɚɩɪɢɦɟɪ, ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪɚɦɢ.
ȼ C++ ɩɨɥɧɵɣ ɨɛɴɟɤɬ ɤɨɧɫɬɪɭɢɪɭɟɬɫɹ ɩɨ ɨɞɧɨɦɭ ɛɚɡɨɜɨɦɭ ɤɥɚɫɫɭ ɡɚ ɪɚɡ.
ɉɭɫɬɶ ɭ ɧɚɫ ɟɫɬɶ ɛɚɡɨɜɵɣ ɤɥɚɫɫ B ɢ ɤɥɚɫɫ D, ɩɪɨɢɡɜɨɞɧɵɣ ɨɬ B. ɉɪɢ ɫɨɡɞɚɧɢɢ ɨɛɴɟɤɬɚ D,
ɤɨɝɞɚ ɜɵɩɨɥɧɹɟɬɫɹ ɤɨɧɫɬɪɭɤɬɨɪ B, ɞɢɧɚɦɢɱɟɫɤɢɦ ɬɢɩɨɦ ɫɨɡɞɚɜɚɟɦɨɝɨ ɨɛɴɟɤɬɚ ɹɜɥɹɟɬɫɹ B.
ȼ ɱɚɫɬɧɨɫɬɢ, ɜɵɡɨɜ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ B::Fun ɩɪɢɜɟɞɟɬ ɤ ɜɵɩɨɥɧɟɧɢɸ ɮɭɧɤɰɢɢ Fun, ɨɩ-
ɪɟɞɟɥɟɧɧɨɣ ɜ ɤɥɚɫɫɟ B, ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɬɨɝɨ, ɩɟɪɟɤɪɵɜɚɟɬ ɟɟ ɤɥɚɫɫ D ɢɥɢ ɧɟɬ. ɂ ɷɬɨ ɯɨɪɨɲɨ,
ɩɨɫɤɨɥɶɤɭ ɜɵɡɨɜ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ D ɜ ɬɨɬ ɦɨɦɟɧɬ, ɤɨɝɞɚ ɱɥɟɧɵ ɨɛɴɟɤɬɚ D ɟɳɟ ɧɟ ɢɧɢɰɢɚɥɢɡɢ-
ɪɨɜɚɧɵ, ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɯɚɨɫɭ. Ɍɨɥɶɤɨ ɩɨɫɥɟ ɡɚɜɟɪɲɟɧɢɹ ɜɵɩɨɥɧɟɧɢɹ ɤɨɧɫɬɪɭɤɬɨɪɚ B ɜɵ-
ɩɨɥɧɹɟɬɫɹ ɬɟɥɨ ɤɨɧɫɬɪɭɤɬɨɪɚ D ɢ ɨɛɴɟɤɬ ɩɪɢɨɛɪɟɬɚɟɬ ɬɢɩ D. ȼ ɤɚɱɟɫɬɜɟ ɷɦɩɢɪɢɱɟɫɤɨɝɨ ɩɪɚɜɢɥɚ
ɫɥɟɞɭɟɬ ɩɨɦɧɢɬɶ, ɱɬɨ ɜ ɩɪɨɰɟɫɫɟ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɹ B ɧɟɬ ɧɢɤɚɤɨɝɨ ɫɩɨɫɨɛɚ ɨɩɪɟɞɟɥɢɬɶ, ɹɜɥɹɟɬɫɹ
ɥɢ B ɨɬɞɟɥɶɧɵɦ ɨɛɴɟɤɬɨɦ ɢɥɢ ɛɚɡɨɜɨɣ ɱɚɫɬɶɸ ɧɟɤɨɬɨɪɨɝɨ ɢɧɨɝɨ ɩɪɨɢɡɜɨɞɧɨɝɨ ɨɛɴɟɤɬɚ.
Ʉɪɨɦɟ ɬɨɝɨ, ɫɥɟɞɭɟɬ ɩɨɦɧɢɬɶ, ɱɬɨ ɜɵɡɨɜ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɚ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ, ɧɟ
ɢɦɟɸɳɟɣ ɨɩɪɟɞɟɥɟɧɢɹ, ɩɪɢɜɨɞɢɬ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ.
ɋ ɞɪɭɝɨɣ ɫɬɨɪɨɧɵ, ɜ ɧɟɤɨɬɨɪɵɯ ɫɥɭɱɚɹɯ ɞɢɡɚɣɧ ɬɪɟɛɭɟɬ ɢɫɩɨɥɶɡɨɜɚɧɢɹ “ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪɚ”,
ɬ.ɟ. ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɚɹ ɞɨɥɠɧɚ ɛɵɬɶ ɜɵɡɜɚɧɚ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɩɨɥɧɵɣ ɨɛɴɟɤɬ ɨɤɚɡɵ-
ɜɚɟɬɫɹ ɫɤɨɧɫɬɪɭɢɪɨɜɚɧ. ɇɟɤɨɬɨɪɵɟ ɦɟɬɨɞɢɤɢ, ɩɪɢɦɟɧɹɟɦɵɟ ɞɥɹ ɪɟɲɟɧɢɹ ɷɬɨɣ ɡɚɞɚɱɢ, ɨɩɢɫɚɧɵ
ɜ ɩɪɢɜɨɞɢɦɵɯ ɧɢɠɟ ɫɫɵɥɤɚɯ. ȼɨɬ (ɞɚɥɟɤɨ ɧɟ ɢɫɱɟɪɩɵɜɚɸɳɢɣ) ɫɩɢɫɨɤ ɜɨɡɦɨɠɧɵɯ ɪɟɲɟɧɢɣ.
• ɉɟɪɟɤɥɚɞɵɜɚɧɢɟ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɢ. Ɇɨɠɧɨ ɩɪɨɫɬɨ ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɧɟɨɛɯɨɞɢɦɨɫɬɶ
ɜɵɡɨɜɚ ɜ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɦ ɤɨɞɟ ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪɚ ɩɨɫɥɟ ɫɨɡɞɚɧɢɹ ɨɛɴɟɤɬɚ.
• Ɉɬɥɨɠɟɧɧɚɹ ɩɨɫɬɢɧɢɰɢɚɥɢɡɚɰɢɹ. Ɇɨɠɧɨ ɜɵɩɨɥɧɹɬɶ ɩɨɫɬɢɧɢɰɢɚɥɢɡɚɰɢɸ ɩɪɢ ɩɟɪɜɨɦ
ɜɵɡɨɜɟ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ, ɞɥɹ ɱɟɝɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ ɮɥɚɝ ɬɢɩɚ bool, ɤɨɬɨ-
ɪɵɣ ɩɨɤɚɡɵɜɚɟɬ, ɛɵɥ ɭɠɟ ɜɵɡɜɚɧ ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪ ɢɥɢ ɧɟɬ.
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɫɟɦɚɧɬɢɤɢ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. ɉɪɚɜɢɥɚ ɹɡɵɤɚ ɬɪɟɛɭɸɬ, ɱɬɨɛɵ ɤɨɧɫɬɪɭɤ-
ɬɨɪ ɧɚɢɛɨɥɟɟ ɩɪɨɢɡɜɨɞɧɨɝɨ ɤɥɚɫɫɚ ɨɩɪɟɞɟɥɹɥ, ɤɚɤɨɣ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ
ɛɭɞɟɬ ɜɵɡɜɚɧ. ȼɵ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɬɨ ɩɪɚɜɢɥɨ ɜ ɫɜɨɢɯ ɰɟɥɹɯ (ɫɦ. [Taligent94]).
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɮɭɧɤɰɢɢ-ɮɚɛɪɢɤɢ. Ɍɚɤɢɦ ɫɩɨɫɨɛɨɦ ɜɵ ɦɨɠɟɬɟ ɥɟɝɤɨ ɨɛɟɫɩɟɱɢɬɶ ɩɪɢ-
ɧɭɞɢɬɟɥɶɧɵɣ ɜɵɡɨɜ ɮɭɧɤɰɢɢ-ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪɚ (ɫɦ. ɩɪɢɦɟɪɵ ɤ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ).
ɇɢ ɨɞɧɚ ɢɡ ɦɟɬɨɞɢɤ ɩɨɫɬɤɨɧɫɬɪɭɢɪɨɜɚɧɢɹ ɧɟ ɹɜɥɹɟɬɫɹ ɢɞɟɚɥɶɧɨɣ. ɇɚɢɯɭɞɲɟɟ, ɱɬɨ ɦɨɠɧɨ
ɫɞɟɥɚɬɶ, — ɷɬɨ ɩɨɬɪɟɛɨɜɚɬɶ, ɱɬɨɛɵ ɩɨɥɶɡɨɜɚɬɟɥɶ ɤɥɚɫɫɚ ɜɪɭɱɧɭɸ ɜɵɡɵɜɚɥ ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪ.
Ɉɞɧɚɤɨ ɞɚɠɟ ɧɚɢɥɭɱɲɢɟ ɫɩɨɫɨɛɵ ɪɟɲɟɧɢɹ ɞɚɧɧɨɣ ɡɚɞɚɱɢ ɬɪɟɛɭɸɬ ɨɬɥɢɱɧɨɝɨ ɨɬ ɨɛɵɱɧɨɝɨ
ɫɢɧɬɚɤɫɢɫɚ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɹ ɨɛɴɟɤɬɚ (ɱɬɨ ɥɟɝɤɨ ɩɪɨɜɟɪɹɟɬɫɹ ɜ ɩɪɨɰɟɫɫɟ ɤɨɦɩɢɥɹɰɢɢ) ɢ/ɢɥɢ
ɫɨɬɪɭɞɧɢɱɟɫɬɜɚ ɫ ɚɜɬɨɪɚɦɢ ɩɪɨɢɡɜɨɞɧɵɯ ɤɥɚɫɫɨɜ (ɱɬɨ ɧɟɜɨɡɦɨɠɧɨ ɩɪɨɜɟɪɢɬɶ ɜ ɩɪɨɰɟɫɫɟ
ɤɨɦɩɢɥɹɰɢɢ).
Стр. 102
Примеры
ɉɪɢɦɟɪ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɮɭɧɤɰɢɢ-ɮɚɛɪɢɤɢ ɞɥɹ ɩɪɢɧɭɞɢɬɟɥɶɧɨɝɨ ɜɵɡɨɜɚ ɩɨɫɬɤɨɧɫɬɪɭɤɬɨ-
ɪɚ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
class B { // ǕǹǻǰǸȇ ǳǰǻǫǻȀǳǳ
protected:
B() { /* ... */ }
virtual void PostInitialize() // ǍȆǲȆǭǫǰǽǼȊ ǼǻǫǲǾ
{ /* ... */ } // ǺǹǼǶǰ ǵǹǸǼǽǻǾǳǻǹǭǫǸǳȊ
public:
template<class T>
static shared_ptr<T> Create() // ǓǸǽǰǻǿǰǴǼ ǯǶȊ
{ // ǼǹǲǯǫǸǳȊ ǹǬȅǰǵǽǹǭ
shared_ptr<T> p( new T );
p->PostInitialize();
return p;
}
};
class D : public B { /* ... */ }; // ǘǰǵǹǽǹǻȆǴ ǺǻǹǳǲǭǹǯǸȆǴ

// ǵǶǫǼǼ
shared_ptr<D> p = D::Create<D>(); // ǜǹǲǯǫǸǳǰ ǹǬȅǰǵǽǫ D

ɗɬɨɬ ɧɟ ɜɩɨɥɧɟ ɧɚɞɟɠɧɵɣ ɞɢɡɚɣɧ ɨɫɧɨɜɚɧ ɧɚ ɪɹɞɟ ɤɨɦɩɪɨɦɢɫɫɨɜ.
• ɉɪɨɢɡɜɨɞɧɵɟ ɤɥɚɫɫɵ, ɬɚɤɢɟ ɤɚɤ D, ɧɟ ɞɨɥɠɧɵ ɢɦɟɬɶ ɨɬɤɪɵɬɵɯ ɤɨɧɫɬɪɭɤɬɨɪɨɜ. ȼ ɩɪɨ-
ɬɢɜɧɨɦ ɫɥɭɱɚɟ ɩɨɥɶɡɨɜɚɬɟɥɢ D ɫɦɨɝɭɬ ɫɨɡɞɚɜɚɬɶ ɨɛɴɟɤɬɵ D, ɞɥɹ ɤɨɬɨɪɵɯ ɧɟ ɛɭɞɟɬ ɜɵ-
ɡɵɜɚɬɶɫɹ ɮɭɧɤɰɢɹ PostInitialize.
• ɋɨɡɞɚɧɢɟ ɨɛɴɟɤɬɚ ɢɫɩɨɥɶɡɭɟɬ ɨɩɟɪɚɬɨɪ new, ɤɨɬɨɪɵɣ, ɨɞɧɚɤɨ, ɦɨɠɟɬ ɛɵɬɶ ɩɟɪɟɤɪɵɬ
ɤɥɚɫɫɨɦ B (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 45 ɢ 46).
• Ʉɥɚɫɫ D ɨɛɹɡɚɬɟɥɶɧɨ ɞɨɥɠɟɧ ɨɩɪɟɞɟɥɢɬɶ ɤɨɧɫɬɪɭɤɬɨɪ ɫ ɬɟɦɢ ɠɟ ɩɚɪɚɦɟɬɪɚɦɢ, ɱɬɨ ɢ ɭ
ɤɨɧɫɬɪɭɤɬɨɪɚ ɤɥɚɫɫɚ B. ɋɦɹɝɱɢɬɶ ɩɪɨɛɥɟɦɭ ɦɨɠɟɬ ɧɚɥɢɱɢɟ ɧɟɫɤɨɥɶɤɢɯ ɩɟɪɟɝɪɭɡɨɤ
ɮɭɧɤɰɢɢ Create; ɷɬɢ ɩɟɪɟɝɪɭɡɤɢ ɦɨɝɭɬ ɞɚɠɟ ɛɵɬɶ ɲɚɛɥɨɧɚɦɢ.
• ȿɫɥɢ ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɬɪɟɛɨɜɚɧɢɹ ɭɞɨɜɥɟɬɜɨɪɟɧɵ, ɞɚɧɧɵɣ ɞɢɡɚɣɧ ɝɚɪɚɧɬɢɪɭɟɬ, ɱɬɨ
ɮɭɧɤɰɢɹ PostInitialize ɛɭɞɟɬ ɜɵɡɜɚɧɚ ɞɥɹ ɥɸɛɨɝɨ ɩɨɥɧɨɫɬɶɸ ɫɤɨɧɫɬɪɭɢɪɨɜɚɧɧɨɝɨ
ɨɛɴɟɤɬɚ ɤɥɚɫɫɚ, ɩɪɨɢɡɜɨɞɧɨɝɨ ɨɬ B. Ɏɭɧɤɰɢɹ PostInitialize ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ ɞɨɥɠɧɚ
ɛɵɬɶ ɜɢɪɬɭɚɥɶɧɨɣ; ɨɞɧɚɤɨ ɨɧɚ ɦɨɠɟɬ ɫɜɨɛɨɞɧɨ ɜɵɡɵɜɚɬɶ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ.
Ссылки
[Alexandrescu01] §3 • [Boost] • [Dewhurst03] §75 • [Meyers97] §46 • [Stroustrup00] §15.4.3 •
[Taligent94]
49. Избегайте вызовов виртуальных функций в конструкторах и деструкторах 103
Стр. 103
50. Делайте деструкторы базовых классов открытыми и виртуальными...
50. Делайте деструкторы базовых классов

открытыми и виртуальными либо
защищенными и невиртуальными
50. Делайте деструкторы базовых классов открытыми и виртуальными...
Резюме
ɍɞɚɥɹɬɶ ɢɥɢ ɧɟ ɭɞɚɥɹɬɶ — ɜɨɬ ɜ ɱɟɦ ɜɨɩɪɨɫ! ȿɫɥɢ ɫɥɟɞɭɟɬ ɨɛɟɫɩɟɱɢɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɭɞɚɥɟɧɢɹ
ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ, ɬɨ ɞɟɫɬɪɭɤɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɟɧ ɛɵɬɶ ɨɬɤɪɵɬɵɦ
ɢ ɜɢɪɬɭɚɥɶɧɵɦ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɨɧ ɞɨɥɠɟɧ ɛɵɬɶ ɡɚɳɢɳɟɧɧɵɦ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦ.
ɗɬɨ ɩɪɨɫɬɨɟ ɩɪɚɜɢɥɨ ɢɥɥɸɫɬɪɢɪɭɟɬ ɞɨɫɬɚɬɨɱɧɨ ɬɨɧɤɢɣ ɜɨɩɪɨɫ ɢ ɨɬɪɚɠɚɟɬ ɫɨɜɪɟɦɟɧɧɨɟ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɢ ɩɪɢɧɰɢɩɨɜ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
Ⱦɥɹ ɞɚɧɧɨɝɨ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ Base ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɦɨɠɟɬ ɩɵɬɚɬɶɫɹ ɭɞɚɥɹɬɶ ɩɪɨɢɡɜɨɞ-
ɧɵɟ ɨɬ ɧɟɝɨ ɨɛɴɟɤɬɵ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɟɣ ɧɚ Base. ȿɫɥɢ ɞɟɫɬɪɭɤɬɨɪ Base ɨɬɤɪɵɬɵɣ ɢ ɧɟ-
ɜɢɪɬɭɚɥɶɧɵɣ (ɫɜɨɣɫɬɜɚ ɩɨ ɭɦɨɥɱɚɧɢɸ), ɨɧ ɦɨɠɟɬ ɛɵɬɶ ɫɥɭɱɚɣɧɨ ɜɵɡɜɚɧ ɞɥɹ ɭɤɚɡɚɬɟɥɹ, ɤɨɬɨ-
ɪɵɣ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɭɤɚɡɵɜɚɟɬ ɧɚ ɩɪɨɢɡɜɨɞɧɵɣ ɨɛɴɟɤɬ, ɢ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɦɵ ɩɨɥɭɱɢɦ ɧɟ-
ɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ. Ɍɚɤɨɟ ɫɨɫɬɨɹɧɢɟ ɞɟɥ ɩɪɢɜɟɥɨ ɤ ɬɨɦɭ, ɱɬɨ ɜ ɫɬɚɪɵɯ ɫɬɚɧɞɚɪɬɚɯ ɤɨɞɢ-
ɪɨɜɚɧɢɹ ɬɪɟɛɨɜɚɥɨɫɶ ɞɟɥɚɬɶ ɞɟɫɬɪɭɤɬɨɪɵ ɜɫɟɯ ɛɟɡ ɢɫɤɥɸɱɟɧɢɹ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ
ɜɢɪɬɭɚɥɶɧɵɦɢ. Ɉɞɧɚɤɨ ɷɬɨ ɭɠɟ ɩɟɪɟɛɨɪ (ɞɚɠɟ ɟɫɥɢ ɷɬɨ ɢ ɨɩɪɚɜɞɚɧɨ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ); ɜɦɟɫɬɨ
ɷɬɨɝɨ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɚɜɢɥɨ, ɫɨɝɥɚɫɧɨ ɤɨɬɨɪɨɦɭ ɞɟɫɬɪɭɤɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɟɧ
ɛɵɬɶ ɜɢɪɬɭɚɥɶɧɵɦ ɬɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɨɧ ɨɬɤɪɵɬɵɣ.
ɇɚɩɢɫɚɧɢɟ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɩɪɟɞɟɥɟɧɢɟ ɚɛɫɬɪɚɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ ɫ 35 ɩɨ 37). ȼɫɩɨɦɧɢɦ, ɱɬɨ ɞɥɹ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ, ɭɱɚɫɬɜɭɸɳɟɣ ɜ ɚɛɫɬɪɚɤɰɢɢ, ɜɵ
ɞɨɥɠɧɵ ɪɟɲɢɬɶ:
• ɞɨɥɠɧɚ ɥɢ ɨɧɚ ɜɟɫɬɢ ɫɟɛɹ ɜɢɪɬɭɚɥɶɧɨ ɢɥɢ ɧɟɬ;
• ɞɨɥɠɧɚ ɥɢ ɨɧɚ ɛɵɬɶ ɨɬɤɪɵɬɨ ɞɨɫɬɭɩɧɚ ɜɫɟɦɭ ɜɵɡɵɜɚɸɳɟɦɭ ɤɨɞɭ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ
ɧɚ Base ɢɥɢ ɨɧɚ ɞɨɥɠɧɚ ɩɪɟɞɫɬɚɜɥɹɬɶ ɫɨɛɨɣ ɫɤɪɵɬɭɸ ɜɧɭɬɪɟɧɧɸɸ ɞɟɬɚɥɶ ɪɟɚɥɢɡɚɰɢɢ.
Ʉɚɤ ɨɩɢɫɚɧɨ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 39, ɞɥɹ ɨɛɵɱɧɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɫɥɟɞɭɟɬ ɫɞɟɥɚɬɶ ɜɵɛɨɪ
ɦɟɠɞɭ ɜɨɡɦɨɠɧɨɫɬɶɸ ɢɯ ɜɵɡɨɜɚ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ Base* ɧɟɜɢɪɬɭɚɥɶɧɨ (ɧɨ, ɜɨɡɦɨɠɧɨ, ɫ
ɜɢɪɬɭɚɥɶɧɵɦ ɩɨɜɟɞɟɧɢɟɦ, ɟɫɥɢ ɷɬɢ ɮɭɧɤɰɢɢ ɜɵɡɵɜɚɸɬ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ, ɤɚɤ, ɧɚɩɪɢɦɟɪ,
ɜ ɲɚɛɥɨɧɚɯ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ NVI ɢɥɢ Template Method), ɜɢɪɬɭɚɥɶɧɨ ɥɢɛɨ ɧɟɜɨɡɦɨɠɧɨɫɬɶɸ
ɬɚɤɨɝɨ ɜɵɡɨɜɚ ɜɨɨɛɳɟ. ɒɚɛɥɨɧ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ NVI ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɦɟɬɨɞɢɤɭ, ɤɨɬɨɪɚɹ
ɩɨɡɜɨɥɹɟɬ ɨɛɨɣɬɢɫɶ ɛɟɡ ɨɬɤɪɵɬɵɯ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ.
Ⱦɟɫɬɪɭɤɰɢɹ ɦɨɠɟɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ ɩɪɨɫɬɨ ɨɞɧɚ ɢɡ ɨɩɟɪɚɰɢɣ, ɯɨɬɹ ɢ ɫɨ ɫɩɟɰɢɚɥɶɧɨɣ
ɫɟɦɚɧɬɢɤɨɣ, ɤɨɬɨɪɚɹ ɞɟɥɚɟɬ ɧɟɜɢɪɬɭɚɥɶɧɵɟ ɜɵɡɨɜɵ ɨɩɚɫɧɵɦɢ ɢɥɢ ɨɲɢɛɨɱɧɵɦɢ. ɋɥɟɞɨɜɚ-
ɬɟɥɶɧɨ, ɞɥɹ ɞɟɫɬɪɭɤɬɨɪɚ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɜɵɛɨɪ ɫɭɠɚɟɬɫɹ ɞɨ ɜɢɪɬɭɚɥɶɧɨɝɨ ɜɵɡɨɜɚ ɱɟɪɟɡ ɭɤɚɡɚ-
ɬɟɥɶ Base* ɢɥɢ ɧɟɜɨɡɦɨɠɧɨɫɬɢ ɜɵɡɨɜɚ ɜɨɨɛɳɟ; ɜɵɛɨɪ ɧɟɜɢɪɬɭɚɥɶɧɨɝɨ ɜɵɡɨɜɚ ɜ ɞɚɧɧɨɦ ɫɥɭ-
ɱɚɟ ɧɟɩɪɢɦɟɧɢɦ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɞɟɫɬɪɭɤɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɜɢɪɬɭɚɥɟɧ, ɟɫɥɢ ɨɧ ɦɨɠɟɬ ɛɵɬɶ
ɜɵɡɜɚɧ (ɬ.ɟ. ɨɬɤɪɵɬ), ɢ ɧɟɜɢɪɬɭɚɥɟɧ ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɲɚɛɥɨɧ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ NVI ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɩɪɢɦɟɧɟɧ ɤ ɞɟɫɬɪɭɤɬɨɪɭ, ɩɨ-
ɫɤɨɥɶɤɭ ɤɨɧɫɬɪɭɤɬɨɪɵ ɢ ɞɟɫɬɪɭɤɬɨɪɵ ɧɟ ɦɨɝɭɬ ɨɫɭɳɟɫɬɜɥɹɬɶ ɝɥɭɛɨɤɢɟ ɜɢɪɬɭɚɥɶɧɵɟ ɜɵɡɨɜɵ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 39 ɢ 55).
ȼɵɜɨɞ: ɜɫɟɝɞɚ ɹɜɧɨ ɩɢɲɢɬɟ ɞɟɫɬɪɭɤɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ, ɩɨɫɤɨɥɶɤɭ ɧɟɹɜɧɨ ɫɝɟɧɟɪɢɪɨɜɚɧ-
ɧɵɣ ɞɟɫɬɪɭɤɬɨɪ ɹɜɥɹɟɬɫɹ ɨɬɤɪɵɬɵɦ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦ.
Стр. 104
Примеры
Ʉɥɢɟɧɬɫɤɢɣ ɤɨɞ ɞɨɥɠɟɧ ɥɢɛɨ ɛɵɬɶ ɫɩɨɫɨɛɟɧ ɩɨɥɢɦɨɪɮɧɨ ɭɞɚɥɹɬɶ ɨɛɴɟɤɬɵ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚ-
ɡɚɬɟɥɹ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ, ɥɢɛɨ ɧɟ ɞɨɥɠɟɧ ɷɬɨɝɨ ɞɟɥɚɬɶ. Ʉɚɠɞɵɣ ɜɵɛɨɪ ɨɩɪɟɞɟɥɹɟɬ ɫɜɨɣ ɞɢɡɚɣɧ.
• ɉɪɢɦɟɪ 1. Ȼɚɡɨɜɵɟ ɤɥɚɫɫɵ ɫ ɩɨɥɢɦɨɪɮɧɵɦ ɭɞɚɥɟɧɢɟɦ. ȿɫɥɢ ɞɨɥɠɧɨ ɛɵɬɶ ɪɚɡɪɟɲɟɧɨ
ɩɨɥɢɦɨɪɮɧɨɟ ɭɞɚɥɟɧɢɟ, ɬɨ ɞɟɫɬɪɭɤɬɨɪ ɞɨɥɠɟɧ ɛɵɬɶ ɨɬɤɪɵɬɵɦ (ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ
ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɧɟ ɫɦɨɠɟɬ ɤ ɧɟɦɭ ɨɛɪɚɬɢɬɶɫɹ) ɢ ɞɨɥɠɟɧ ɛɵɬɶ ɜɢɪɬɭɚɥɶɧɵɦ (ɜ ɩɪɨ-
ɬɢɜɧɨɦ ɫɥɭɱɚɟ ɟɝɨ ɜɵɡɨɜ ɩɪɢɜɟɞɟɬ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ).
• ɉɪɢɦɟɪ 2. Ȼɚɡɨɜɵɟ ɤɥɚɫɫɵ ɛɟɡ ɩɨɥɢɦɨɪɮɧɨɝɨ ɭɞɚɥɟɧɢɹ. ȿɫɥɢ ɩɨɥɢɦɨɪɮɧɨɟ ɭɞɚɥɟɧɢɟ
ɧɟ ɞɨɥɠɧɨ ɛɵɬɶ ɪɚɡɪɟɲɟɧɨ, ɞɟɫɬɪɭɤɬɨɪ ɞɨɥɠɟɧ ɧɟ ɛɵɬɶ ɨɬɤɪɵɬɵɦ (ɱɬɨɛɵ ɜɵɡɵɜɚɸ-
ɳɢɣ ɤɨɞ ɧɟ ɦɨɝ ɤ ɧɟɦɭ ɨɛɪɚɬɢɬɶɫɹ) ɢ ɧɟ ɞɨɥɠɟɧ ɛɵɬɶ ɜɢɪɬɭɚɥɶɧɵɦ (ɩɨɬɨɦɭ ɱɬɨ ɜɢɪɬɭ-
ɚɥɶɧɨɫɬɶ ɟɦɭ ɧɟ ɧɭɠɧɚ).
Ʉɥɚɫɫɵ ɫɬɪɚɬɟɝɢɣ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɸɬɫɹ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɵɯ ɞɥɹ ɭɞɨɛɫɬɜɚ, ɚ ɧɟ ɞɥɹ ɨɛɟɫɩɟ-
ɱɟɧɢɹ ɩɨɥɢɦɨɪɮɧɨɝɨ ɩɨɜɟɞɟɧɢɹ. ɂɯ ɞɟɫɬɪɭɤɬɨɪɵ ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɞɟɥɚɬɶ ɡɚɳɢɳɟɧɧɵɦɢ ɢ ɧɟ-
ɜɢɪɬɭɚɥɶɧɵɦɢ.
ɇɟɤɨɬɨɪɵɟ ɤɨɦɩɨɧɟɧɬɧɵɟ ɚɪɯɢɬɟɤɬɭɪɵ (ɧɚɩɪɢɦɟɪ, COM ɢɥɢ CORBA) ɧɟ ɢɫɩɨɥɶɡɭɸɬ
ɫɬɚɧɞɚɪɬɧɵɣ ɦɟɯɚɧɢɡɦ ɭɞɚɥɟɧɢɹ ɢ ɩɪɢɦɟɧɹɸɬ ɞɥɹ ɷɬɨɝɨ ɪɚɡɥɢɱɧɵɟ ɫɨɛɫɬɜɟɧɧɵɟ ɩɪɨɬɨɤɨɥɵ
ɨɫɜɨɛɨɠɞɟɧɢɹ ɨɛɴɟɤɬɨɜ. ɋɥɟɞɭɣɬɟ ɲɚɛɥɨɧɚɦ ɢ ɢɞɢɨɦɚɦ ɷɬɢɯ ɚɪɯɢɬɟɤɬɭɪ ɢ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ
ɨɛɪɚɡɨɦ ɚɞɚɩɬɢɪɭɣɬɟ ɞɚɧɧɭɸ ɪɟɤɨɦɟɧɞɚɰɢɸ.
Ɋɚɫɫɦɨɬɪɢɦ ɬɚɤɠɟ ɟɳɟ ɨɞɢɧ ɪɟɞɤɢɣ ɫɥɭɱɚɣ.
• B ɨɞɧɨɜɪɟɦɟɧɧɨ ɹɜɥɹɟɬɫɹ ɤɚɤ ɛɚɡɨɜɵɦ ɤɥɚɫɫɨɦ, ɬɚɤ ɢ ɤɨɧɤɪɟɬɧɵɦ ɤɥɚɫɫɨɦ, ɞɥɹ ɤɨɬɨ-
ɪɨɝɨ ɦɨɝɭɬ ɫɨɡɞɚɜɚɬɶɫɹ ɨɛɴɟɤɬɵ (ɬɚɤ ɱɬɨ ɞɟɫɬɪɭɤɬɨɪ ɷɬɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɟɧ ɛɵɬɶ ɨɬɤɪɵ-
ɬɵɦ, ɱɬɨɛɵ ɛɵɥɨ ɦɨɠɧɨ ɫɨɡɞɚɜɚɬɶ ɢ ɭɧɢɱɬɨɠɚɬɶ ɨɛɴɟɤɬɵ ɞɚɧɧɨɝɨ ɬɢɩɚ).
• ɍ B ɧɟɬ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ, ɢ ɨɧ ɧɟ ɩɪɟɞɧɚɡɧɚɱɚɟɬɫɹ ɞɥɹ ɩɨɥɢɦɨɪɮɧɨɝɨ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɹ (ɬɚɤ ɱɬɨ ɯɨɬɹ ɞɟɫɬɪɭɤɬɨɪ ɢ ɨɬɤɪɵɬ, ɨɧ ɧɟ ɨɛɹɡɚɧ ɛɵɬɶ ɜɢɪɬɭɚɥɶɧɵɦ).
Ɍɨɝɞɚ ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɞɟɫɬɪɭɤɬɨɪ ɨɤɚɡɵɜɚɟɬɫɹ ɨɬɤɪɵɬɵɦ, ɢɦɟɟɬɫɹ ɨɝɪɨɦɧɵɣ ɫɨɛɥɚɡɧ
ɧɟ ɞɟɥɚɬɶ ɟɝɨ ɜɢɪɬɭɚɥɶɧɵɦ, ɩɨɫɤɨɥɶɤɭ ɬɚɤɚɹ ɩɟɪɜɚɹ ɜɢɪɬɭɚɥɶɧɚɹ ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ
ɤ ɢɡɥɢɲɧɢɦ ɪɚɫɯɨɞɚɦ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɢɡ-ɡɚ ɞɨɛɚɜɥɟɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ, ɤɨɬɨɪɚɹ ɧɚɦ
ɫɨɜɫɟɦ ɧɟ ɧɭɠɧɚ.
ȼ ɷɬɨɦ ɪɟɞɤɨɦ ɫɥɭɱɚɟ ɜɵ ɦɨɠɟɬɟ ɫɞɟɥɚɬɶ ɤɨɧɫɬɪɭɤɬɨɪ ɨɬɤɪɵɬɵɦ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦ, ɧɨ ɱɟɬɤɨ
ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɩɪɨɢɡɜɨɞɧɵɟ ɨɛɴɟɤɬɵ ɧɟ ɦɨɝɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɩɨɥɢɦɨɪɮɧɨ ɜ ɤɚɱɟɫɬɜɟ
ɨɛɴɟɤɬɨɜ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. ɂɦɟɧɧɨ ɷɬɨ ɛɵɥɨ ɫɞɟɥɚɧɨ ɜ ɫɥɭɱɚɟ ɤɥɚɫɫɚ std::unary_function.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ, ɨɞɧɚɤɨ, ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ ɤɨɧɤɪɟɬɧɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 35). ɇɚɩɪɢɦɟɪ, unary_function ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɧɚɛɨɪ ɨɩɪɟɞɟɥɟɧɢɣ typedef, ɤɨ-
ɬɨɪɵɣ ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɫɨɡɞɚɧɢɹ ɨɛɴɟɤɬɨɜ ɞɚɧɧɨɝɨ ɬɢɩɚ. ȼ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɛɟɫɫɦɵɫ-
ɥɟɧɧɨ ɞɚɜɚɬɶ ɟɦɭ ɨɬɤɪɵɬɵɣ ɞɟɫɬɪɭɤɬɨɪ; ɥɭɱɲɟ ɛɵɥɨ ɛɵ ɩɨɫɥɟɞɨɜɚɬɶ ɫɨɜɟɬɭ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧ-
ɞɚɰɢɢ ɢ ɫɞɟɥɚɬɶ ɟɝɨ ɞɟɫɬɪɭɤɬɨɪ ɡɚɳɢɳɟɧɧɵɦ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦ.
Ссылки
[Cargill92] pp. 77-79, 207 • [Cline99] §21.06, 21.12-13 • [Henricson97] pp. 110-114 • [Koenig97]
Chapters 4, 11 • [Meyers97] §14 • [Stroustrup00] §12.4.2 • [Sutter02] §27 • [Sutter04] §18
50. Делайте деструкторы базовых классов открытыми и виртуальными... 105
Стр. 105
51. Деструкторы, функции освобождения
ресурсов и обмена не ошибаются
Резюме
ȼɫɟ ɡɚɩɭɫɤɢ ɷɬɢɯ ɮɭɧɤɰɢɣ ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɩɟɲɧɵɦɢ. ɇɢɤɨɝɞɚ ɧɟ ɩɨɡɜɨɥɹɣɬɟ ɨɲɢɛɤɟ ɜɵɣ-
ɬɢ ɡɚ ɩɪɟɞɟɥɵ ɞɟɫɬɪɭɤɬɨɪɚ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, ɨɩɟɪɚɬɨɪɚ delete)
ɢɥɢ ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ. ȼ ɱɚɫɬɧɨɫɬɢ, ɬɢɩɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɤɨɬɨɪɵɯ ɦɨɝɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟ-
ɧɢɹ, ɤɚɬɟɝɨɪɢɱɟɫɤɢ ɡɚɩɪɟɳɟɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɨ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɨɣ C++.
ɉɟɪɟɱɢɫɥɟɧɧɵɟ ɮɭɧɤɰɢɢ ɧɟ ɞɨɥɠɧɵ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɣ, ɬɚɤ ɤɚɤ ɨɧɢ ɹɜɥɹɸɬɫɹ
ɤɥɸɱɟɜɵɦɢ ɞɥɹ ɞɜɭɯ ɝɥɚɜɧɵɯ ɨɩɟɪɚɰɢɣ ɬɪɚɧɡɚɤɰɢɨɧɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ — ɨɬɤɚɬɚ ɩɪɢ
ɜɨɡɧɢɤɧɨɜɟɧɢɢ ɩɪɨɛɥɟɦ ɜ ɩɪɨɰɟɫɫɟ ɪɚɛɨɬɵ ɢ ɩɪɢɧɹɬɢɹ ɪɟɡɭɥɶɬɚɬɚ ɪɚɛɨɬɵ, ɟɫɥɢ ɩɪɨɛɥɟɦ ɧɟ
ɜɨɡɧɢɤɥɨ. ȿɫɥɢ ɧɟɬ ɫɩɨɫɨɛɚ ɛɟɡɨɩɚɫɧɨɝɨ ɜɨɡɜɪɚɬɚ ɜ ɩɪɟɞɵɞɭɳɟɟ ɫɨɫɬɨɹɧɢɟ ɩɪɢ ɩɨɦɨɳɢ ɨɩɟ-
ɪɚɰɢɣ, ɧɟ ɝɟɧɟɪɢɪɭɸɳɢɯ ɢɫɤɥɸɱɟɧɢɹ, ɬɨ ɧɟɜɨɡɦɨɠɧɨ ɪɟɚɥɢɡɨɜɚɬɶ ɛɟɫɫɛɨɣɧɵɣ ɨɬɤɚɬ; ɨɬɫɭɬ-
ɫɬɜɢɟ ɜɨɡɦɨɠɧɨɫɬɢ ɛɟɡɨɩɚɫɧɨɝɨ ɫɨɯɪɚɧɟɧɢɹ ɢɡɦɟɧɟɧɢɹ ɫɨɫɬɨɹɧɢɹ ɩɪɢ ɩɨɦɨɳɢ ɨɩɟɪɚɰɢɢ, ɧɟ
ɝɟɧɟɪɢɪɭɸɳɟɣ ɢɫɤɥɸɱɟɧɢɹ, ɞɟɥɚɟɬ ɧɟɜɨɡɦɨɠɧɨɣ ɪɟɚɥɢɡɚɰɢɸ ɛɟɫɫɛɨɣɧɨɝɨ ɩɪɢɧɹɬɢɹ ɪɟɡɭɥɶ-
ɬɚɬɚ ɪɚɛɨɬɵ.
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɟ ɫɨɜɟɬɵ ɢ ɬɪɟɛɨɜɚɧɢɹ, ɧɚɣɞɟɧɧɵɟ ɜ ɋɬɚɧɞɚɪɬɟ C++.
ȿɫɥɢ ɞɟɫɬɪɭɤɬɨɪ, ɜɵɡɜɚɧɧɵɣ ɜ ɩɪɨɰɟɫɫɟ ɫɜɟɪɬɤɢ ɫɬɟɤɚ, ɜɵɯɨɞɢɬ ɫ ɢɫɤɥɸɱɟɧɢɟɦ, ɜɵɡɵɜɚ-
ɟɬɫɹ ɮɭɧɤɰɢɹ terminate (15.5.1). ɉɨɷɬɨɦɭ ɞɟɫɬɪɭɤɬɨɪɵ ɞɨɥɠɧɵ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ ɩɟɪɟ-
ɯɜɚɬɵɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɢ ɧɟ ɩɨɡɜɨɥɹɬɶ ɢɦ ɪɚɫɩɪɨɫɬɪɚɧɢɬɶɫɹ ɡɚ ɩɪɟɞɟɥɵ ɞɟɫɬɪɭɤɬɨ-
ɪɚ. — [C++03] §15.2(3)
ȼ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɟ C++ ɧɟ ɨɩɪɟɞɟɥɟɧ ɧɢ ɨɞɢɧ ɞɟɫɬɪɭɤɬɨɪ [ɜɤɥɸɱɚɹ ɞɟɫɬɪɭɤɬɨ-
ɪɵ ɥɸɛɨɝɨ ɬɢɩɚ, ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɞɥɹ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ ɲɚɛɥɨɧɚ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ],
ɝɟɧɟɪɢɪɭɸɳɢɣ ɢɫɤɥɸɱɟɧɢɟ. — [C++03] §17.4.4.8(3)
Ⱦɟɫɬɪɭɤɬɨɪɵ ɹɜɥɹɸɬɫɹ ɫɩɟɰɢɚɥɶɧɵɦɢ ɮɭɧɤɰɢɹɦɢ, ɢ ɤɨɦɩɢɥɹɬɨɪ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɜɵɡɵɜɚɟɬ
ɢɯ ɜ ɪɚɡɥɢɱɧɵɯ ɤɨɧɬɟɤɫɬɚɯ. ȿɫɥɢ ɜɵ ɩɢɲɟɬɟ ɤɥɚɫɫ — ɧɚɡɨɜɟɦ ɟɝɨ, ɤ ɩɪɢɦɟɪɭ, Nefarious2 —
ɞɟɫɬɪɭɤɬɨɪ ɤɨɬɨɪɨɝɨ ɦɨɠɟɬ ɞɚɜɚɬɶ ɫɛɨɣ (ɨɛɵɱɧɨ ɩɨɫɪɟɞɫɬɜɨɦ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɹ; ɫɦ. ɪɟ-
ɤɨɦɟɧɞɚɰɢɸ 72), ɬɨ ɜɵ ɫɬɨɥɤɧɟɬɟɫɶ ɫ ɬɚɤɢɦɢ ɩɨɫɥɟɞɫɬɜɢɹɦɢ.
• Ɉɛɴɟɤɬɵ Nefarious ɬɪɭɞɧɨ ɛɟɡɨɩɚɫɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɨɛɵɱɧɵɯ ɮɭɧɤɰɢɹɯ. ȼɵ ɧɟ
ɦɨɠɟɬɟ ɧɚɞɟɠɧɨ ɢɧɫɬɚɧɰɢɪɨɜɚɬɶ ɚɜɬɨɦɚɬɢɱɟɫɤɢɟ ɨɛɴɟɤɬɵ Nefarious ɜ ɨɛɥɚɫɬɢ ɜɢ-
ɞɢɦɨɫɬɢ, ɟɫɥɢ ɜɨɡɦɨɠɟɧ ɜɵɯɨɞ ɢɡ ɷɬɨɣ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɩɨɫɪɟɞɫɬɜɨɦ ɢɫɤɥɸɱɟɧɢɹ.
ȿɫɥɢ ɷɬɨ ɩɪɨɢɡɨɣɞɟɬ, ɞɟɫɬɪɭɤɬɨɪ Nefarious (ɜɵɡɵɜɚɟɦɵɣ ɚɜɬɨɦɚɬɢɱɟɫɤɢ) ɦɨɠɟɬ ɩɨ-
ɩɵɬɚɬɶɫɹ ɫɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ, ɤɨɬɨɪɨɟ ɩɪɢɜɟɞɟɬ ɤ ɧɟɨɠɢɞɚɧɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ
ɜɫɟɣ ɩɪɨɝɪɚɦɦɵ ɩɨɫɪɟɞɫɬɜɨɦ ɜɵɡɨɜɚ Ɍɟɪɦɢɧɚɬɨɪɚ —std::terminate (ɫɦ. ɬɚɤɠɟ ɪɟ-
• Ɍɪɭɞɧɨ ɛɟɡɨɩɚɫɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɥɚɫɫɵ ɫ ɱɥɟɧɚɦɢ ɢɥɢ ɛɚɡɨɜɵɦɢ ɤɥɚɫɫɚɦɢ Nefarious.
ɉɥɨɯɨɟ ɩɨɜɟɞɟɧɢɟ ɤɥɚɫɫɚ Nefarious ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ ɧɚ ɜɫɟ ɤɥɚɫɫɵ, ɞɥɹ ɤɨɬɨɪɵɯ ɨɧ
ɹɜɥɹɟɬɫɹ ɛɚɡɨɜɵɦ ɢɥɢ ɭ ɤɨɬɨɪɵɯ ɢɦɟɸɬɫɹ ɱɥɟɧɵ ɷɬɨɝɨ ɬɢɩɚ.
2
Nefarious — ɧɟɱɟɫɬɢɜɵɣ, ɝɧɭɫɧɵɣ (ɚɧɝɥ.). — ɉɪɢɦ. ɩɟɪɟɜ.
Стр. 106
• ȼɵ ɧɟ ɦɨɠɟɬɟ ɧɚɞɟɠɧɨ ɫɨɡɞɚɜɚɬɶ ɝɥɨɛɚɥɶɧɵɟ ɥɢɛɨ ɫɬɚɬɢɱɟɫɤɢɟ ɨɛɴɟɤɬɵ Nefari-
ous. ɂɫɤɥɸɱɟɧɢɟ, ɤɨɬɨɪɨɟ ɦɨɠɟɬ ɛɵɬɶ ɫɝɟɧɟɪɢɪɨɜɚɧɨ ɢɯ ɞɟɫɬɪɭɤɬɨɪɚɦɢ, ɧɟɜɨɡɦɨɠɧɨ
ɩɟɪɟɯɜɚɬɢɬɶ.
• ȼɵ ɧɟ ɦɨɠɟɬɟ ɧɚɞɟɠɧɨ ɫɨɡɞɚɜɚɬɶ ɦɚɫɫɢɜɵ ɨɛɴɟɤɬɨɜ Nefarious. Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ,
ɦɚɫɫɢɜɵ ɩɪɢ ɧɚɥɢɱɢɢ ɞɟɫɬɪɭɤɬɨɪɨɜ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ, ɨɛɥɚ-
ɞɚɸɬ ɧɟɨɩɪɟɞɟɥɟɧɧɵɦ ɩɨɜɟɞɟɧɢɟɦ, ɩɨɫɤɨɥɶɤɭ ɜ ɷɬɨɣ ɫɢɬɭɚɰɢɢ ɩɪɨɫɬɨ ɧɟɜɨɡɦɨɠɧɨ
ɩɪɢɞɭɦɚɬɶ ɫɩɨɫɨɛ ɪɚɡɭɦɧɨɝɨ ɨɬɤɚɬɚ. (ɉɨɞɭɦɚɣɬɟ ɫɚɦɢ: ɤɚɤɨɣ ɢɦɟɧɧɨ ɤɨɞ ɞɨɥɠɟɧ ɫɝɟ-
ɧɟɪɢɪɨɜɚɬɶ ɤɨɦɩɢɥɹɬɨɪ ɞɥɹ ɫɨɡɞɚɧɢɹ ɦɚɫɫɢɜɚ ɢɡ ɞɟɫɹɬɢ ɨɛɴɟɤɬɨɜ Nefarious, ɟɫɥɢ ɭ
ɱɟɬɜɟɪɬɨɝɨ ɨɛɴɟɤɬɚ ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ ɩɪɨɢɫɯɨɞɢɬ ɝɟɧɟɪɚɰɢɹ ɢɫɤɥɸɱɟɧɢɹ, ɚ ɩɪɢ ɨɬɤɚɬɟ,
ɤɨɝɞɚ ɜɵɡɵɜɚɸɬɫɹ ɞɟɫɬɪɭɤɬɨɪɵ ɭɠɟ ɫɤɨɧɫɬɪɭɢɪɨɜɚɧɧɵɯ ɨɛɴɟɤɬɨɜ, ɨɞɢɧ ɢɥɢ ɧɟɫɤɨɥɶɤɨ
ɞɟɫɬɪɭɤɬɨɪɨɜ ɝɟɧɟɪɢɪɭɸɬ ɢɫɤɥɸɱɟɧɢɹ? ɍɞɨɜɥɟɬɜɨɪɢɬɟɥɶɧɨɝɨ ɨɬɜɟɬɚ ɜ ɷɬɨɣ ɫɢɬɭɚɰɢɢ
ɩɪɨɫɬɨ ɧɟɬ.)
• ȼɵ ɧɟ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɴɟɤɬɵ Nefarious ɜ ɫɬɚɧɞɚɪɬɧɵɯ ɤɨɧɬɟɣɧɟɪɚɯ.
Ɉɛɴɟɤɬɵ Nefarious ɧɟɥɶɡɹ ɯɪɚɧɢɬɶ ɜ ɫɬɚɧɞɚɪɬɧɵɯ ɤɨɧɬɟɣɧɟɪɚɯ ɢɥɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɯ
ɫ ɤɚɤɢɦɢ-ɬɨ ɞɪɭɝɢɦɢ ɱɚɫɬɹɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ. ɋɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ ɡɚ-
ɩɪɟɳɚɟɬ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɞɟɫɬɪɭɤɬɨɪɨɜ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ.
Ɏɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ, ɜɤɥɸɱɚɹ ɫɩɟɰɢɚɥɶɧɵɦ ɨɛɪɚɡɨɦ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚ-
ɬɨɪɵ operator delete ɢ operator delete[], ɩɨɩɚɞɚɸɬ ɜ ɬɭ ɠɟ ɤɚɬɟɝɨɪɢɸ, ɩɨɫɤɨɥɶɤɭ
ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ ɨɧɢ ɬɚɤɠɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɜ ɩɪɨɰɟɫɫɟ “ɡɚɱɢɫɬɤɢ”, ɜ ɱɚɫɬɧɨɫɬɢ, ɜ ɩɪɨɰɟɫɫɟ ɨɛ-
ɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ.
ɉɨɦɢɦɨ ɞɟɫɬɪɭɤɬɨɪɨɜ ɢ ɮɭɧɤɰɢɣ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɟ ɛɟɡɨɩɚɫɧɵɟ
ɦɟɬɨɞɢɤɢ ɨɫɧɨɜɚɧɵ ɧɚ ɬɨɦ, ɱɬɨ ɨɩɟɪɚɰɢɢ ɨɛɦɟɧɚ ɧɟ ɝɟɧɟɪɢɪɭɸɬ ɢɫɤɥɸɱɟɧɢɣ. ȼ ɞɚɧɧɨɦ ɫɥɭ-
ɱɚɟ ɷɬɨ ɫɜɹɡɚɧɨ ɧɟ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɯ ɜ ɪɟɚɥɢɡɚɰɢɹɯ ɨɬɤɚɬɚ, ɚ ɫ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɜ ɝɚɪɚɧ-
ɬɢɪɨɜɚɧɧɨɦ ɩɪɢɧɹɬɢɢ ɪɟɡɭɥɶɬɚɬɨɜ ɪɚɛɨɬɵ. ɇɚɩɪɢɦɟɪ, ɜɨɬ ɢɞɢɨɦɚɬɢɱɟɫɤɚɹ ɪɟɚɥɢɡɚɰɢɹ ɨɩɟɪɚ-
ɬɨɪɚ operator= ɞɥɹ ɧɟɤɨɬɨɪɨɝɨ ɬɢɩɚ T, ɤɨɬɨɪɵɣ ɨɫɧɨɜɚɧ ɧɚ ɜɵɩɨɥɧɟɧɢɢ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧ-
ɫɬɪɭɤɬɨɪɚ, ɡɚ ɤɨɬɨɪɵɦ ɫɥɟɞɭɟɬ ɜɵɡɨɜ ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ, ɧɟ ɝɟɧɟɪɢɪɭɸɳɟɣ ɢɫɤɥɸɱɟɧɢɣ:
T& T::operator=( const T& other ) {
T temp( other );
Swap( temp );
}
(ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 56)
Ʉ ɫɱɚɫɬɶɸ, ɨɛɥɚɫɬɶ ɜɢɞɢɦɨɫɬɢ ɫɛɨɹ ɩɪɢ ɨɫɜɨɛɨɠɞɟɧɢɢ ɪɟɫɭɪɫɚ ɢɦɟɟɬ ɨɩɪɟɞɟɥɟɧɧɨ ɦɟɧɶ-
ɲɢɣ ɪɚɡɦɟɪ. ȿɫɥɢ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɢɫɤɥɸɱɟɧɢɹ, ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɪɚɫ-
ɫɦɚɬɪɢɜɚɟɦɵɟ ɮɭɧɤɰɢɢ ɨɛɪɚɛɚɬɵɜɚɸɬ ɜɫɟ ɜɨɡɦɨɠɧɵɟ ɢɫɤɥɸɱɟɧɢɹ ɢ ɩɪɨɱɢɟ ɨɲɢɛɤɢ, ɤɨɬɨɪɵɟ
ɦɨɝɭɬ ɜɨɡɧɢɤɧɭɬɶ ɩɪɢ ɪɚɛɨɬɟ ɮɭɧɤɰɢɣ. (ȼ ɫɥɭɱɚɟ ɢɫɤɥɸɱɟɧɢɣ ɩɪɨɫɬɨ ɨɛɟɪɧɢɬɟ ɜɫɟ, ɱɬɨ ɞɟɥɚ-
ɟɬ ɜɚɲ ɞɟɫɬɪɭɤɬɨɪ, ɜ ɛɥɨɤ try/catch(...).) ɗɬɨ ɱɪɟɡɜɵɱɚɣɧɨ ɜɚɠɧɨ, ɩɨɫɤɨɥɶɤɭ ɞɟɫɬɪɭɤɬɨɪ
ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧ ɜ ɤɪɢɡɢɫɧɨɣ ɫɢɬɭɚɰɢɢ, ɬɚɤɨɣ ɤɚɤ ɫɛɨɣ ɩɪɢ ɜɵɞɟɥɟɧɢɢ ɫɢɫɬɟɦɧɨɝɨ ɪɟɫɭɪɫɚ
(ɧɚɩɪɢɦɟɪ, ɩɚɦɹɬɢ, ɮɚɣɥɨɜ, ɛɥɨɤɢɪɨɜɨɤ, ɩɨɪɬɨɜ, ɨɤɨɧ ɢɥɢ ɞɪɭɝɢɯ ɫɢɫɬɟɦɧɵɯ ɨɛɴɟɤɬɨɜ).
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜ ɤɚɱɟɫɬɜɟ ɦɟɯɚɧɢɡɦɚ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢɫɤɥɸɱɟɧɢɣ ɫɥɟɞɭɟɬ ɞɨɤɭ-
ɦɟɧɬɢɪɨɜɚɬɶ ɬɚɤɨɟ ɩɨɜɟɞɟɧɢɟ, ɨɛɴɹɜɥɹɹ ɬɚɤɢɟ ɮɭɧɤɰɢɢ ɫ ɡɚɤɨɦɦɟɧɬɢɪɨɜɚɧɧɨɣ ɩɭɫɬɨɣ ɫɩɟɰɢ-
ɮɢɤɚɰɢɟɣ ɢɫɤɥɸɱɟɧɢɣ /* throw() */ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 75).
Ссылки
[C++03] §15.2(3), §17.4.4.8(3) • [Meyers96] §11 • [Stroustrup00] §14.4.7, §E.2-4 • [Sutter00]
§8, §16 • [Sutter02] §18-19
51. Деструкторы, функции освобождения ресурсов и обмена не ошибаются 107
Стр. 107
52. Копируйте и ликвидируйте согласованно
Резюме
ȿɫɥɢ ɜɵ ɨɩɪɟɞɟɥɢɥɢ ɨɞɧɭ ɢɡ ɫɥɟɞɭɸɳɟɝɨ ɫɩɢɫɤɚ ɮɭɧɤɰɢɣ — ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ,
ɨɩɟɪɚɬɨɪ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪ — ɜɟɪɨɹɬɧɨ, ɜɚɦ ɩɨɬɪɟɛɭɟɬɫɹ ɨɩɪɟɞɟ-
ɥɢɬɶ ɢ ɨɛɟ ɨɫɬɚɜɲɢɟɫɹ ɮɭɧɤɰɢɢ (ɢɥɢ ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ ɨɞɧɭ ɢɡ ɧɢɯ).
ȿɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɨɩɪɟɞɟɥɢɬɶ ɨɞɧɭ ɢɡ ɬɪɟɯ ɩɟɪɟɱɢɫɥɟɧɧɵɣ ɮɭɧɤɰɢɣ, ɷɬɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ
ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɧɟɱɬɨ ɛɨɥɶɲɟɟ, ɱɟɦ ɩɨɜɟɞɟɧɢɟ ɷɬɨɣ ɮɭɧɤɰɢɢ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɚ ɜɫɟ ɷɬɢ ɮɭɧɤɰɢɢ
ɚɫɢɦɦɟɬɪɢɱɧɨ ɜɡɚɢɦɨɫɜɹɡɚɧɵ.
• ȿɫɥɢ ɜɵ ɩɢɲɟɬɟ ɢɥɢ ɡɚɩɪɟɳɚɟɬɟ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɢɥɢ ɨɩɟɪɚɬɨɪ ɤɨɩɢɪɭɸɳɟɝɨ
ɩɪɢɫɜɚɢɜɚɧɢɹ, ɬɨ, ɜɟɪɨɹɬɧɨ, ɜɵ ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ ɬɨ ɠɟ ɫɚɦɨɟ ɢ ɞɥɹ ɞɪɭɝɨɣ ɮɭɧɤɰɢɢ ɢɡ
ɷɬɨɣ ɩɚɪɵ. ȿɫɥɢ ɨɞɧɚ ɮɭɧɤɰɢɹ ɜɵɩɨɥɧɹɟɬ ɧɟɤɨɬɨɪɭɸ “ɫɩɟɰɢɚɥɶɧɭɸ” ɪɚɛɨɬɭ, ɜɟɪɨɹɬɧɨ,
ɞɪɭɝɚɹ ɞɨɥɠɧɚ ɞɟɥɚɬɶ ɱɬɨ-ɬɨ ɚɧɚɥɨɝɢɱɧɨɟ, ɬɚɤ ɤɚɤ ɷɬɢ ɞɜɟ ɮɭɧɤɰɢɢ ɞɨɥɠɧɵ ɢɦɟɬɶ ɨɞɢɧɚ-
ɤɨɜɨɟ ɞɟɣɫɬɜɢɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 53, ɤɨɬɨɪɚɹ ɩɨɹɫɧɹɟɬ ɷɬɨɬ ɩɭɧɤɬ).
• ȿɫɥɢ ɜɵ ɹɜɧɨ ɩɢɲɟɬɟ ɤɨɩɢɪɭɸɳɢɟ ɮɭɧɤɰɢɢ, ɜɟɪɨɹɬɧɨ, ɜɚɦ ɧɚɞɨ ɹɜɧɨ ɧɚɩɢɫɚɬɶ ɢ ɞɟ-
ɫɬɪɭɤɬɨɪ. ȿɫɥɢ “ɫɩɟɰɢɚɥɶɧɚɹ” ɪɚɛɨɬɚ ɜ ɤɨɩɢɪɭɸɳɟɦ ɤɨɧɫɬɪɭɤɬɨɪɟ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɜɵ-
ɞɟɥɟɧɢɢ ɢɥɢ ɞɭɛɥɢɪɨɜɚɧɢɢ ɧɟɤɨɬɨɪɨɝɨ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, ɩɚɦɹɬɢ, ɮɚɣɥɚ, ɫɨɤɟɬɚ), ɬɨ
ɜɵ ɞɨɥɠɧɵ ɨɫɜɨɛɨɞɢɬɶ ɷɬɨɬ ɪɟɫɭɪɫ ɜ ɞɟɫɬɪɭɤɬɨɪɟ.
• ȿɫɥɢ ɜɵ ɹɜɧɨ ɩɢɲɟɬɟ ɞɟɫɬɪɭɤɬɨɪ, ɜɟɪɨɹɬɧɨ, ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɹɜɧɨ ɧɚɩɢɫɚɬɶ (ɢɥɢ ɹɜɧɨ
ɡɚɩɪɟɬɢɬɶ) ɤɨɩɢɪɨɜɚɧɢɟ. ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ ɧɟɬɪɢɜɢɚɥɶɧɵɣ ɞɟɫɬɪɭɤɬɨɪ, ɷɬɨ ɡɚɱɚɫɬɭɸ
ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɜɪɭɱɧɭɸ ɨɫɜɨɛɨɞɢɬɶ ɪɟɫɭɪɫ, ɯɪɚɧɹɳɢɣɫɹ ɨɛɴɟɤɬɨɦ.
ȿɫɥɢ ɬɚɤ, ɜɟɪɨɹɬɧɨ, ɞɥɹ ɷɬɨɝɨ ɪɟɫɭɪɫɚ ɬɪɟɛɭɟɬɫɹ ɚɤɤɭɪɚɬɧɨɟ ɞɭɛɥɢɪɨɜɚɧɢɟ, ɬɚɤ ɱɬɨ ɜɚɦ
ɫɥɟɞɭɟɬ ɭɞɟɥɢɬɶ ɜɧɢɦɚɧɢɟ ɫɩɨɫɨɛɭ ɤɨɩɢɪɨɜɚɧɢɹ ɢ ɩɪɢɫɜɚɢɜɚɧɢɹ ɨɛɴɟɤɬɨɜ, ɥɢɛɨ ɩɨɥ-
ɧɨɫɬɶɸ ɡɚɩɪɟɬɢɬɶ ɬɚɤɨɜɨɟ.
ȼɨ ɦɧɨɝɢɯ ɫɥɭɱɚɹɯ ɯɪɚɧɟɧɢɟ ɤɨɪɪɟɤɬɧɨ ɢɧɤɚɩɫɭɥɢɪɨɜɚɧɧɨɝɨ ɪɟɫɭɪɫɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
ɢɞɢɨɦɵ RAII ɩɨɡɜɨɥɹɟɬ ɩɨɥɧɨɫɬɶɸ ɢɡɛɟɠɚɬɶ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨɣ ɪɚɡɪɚɛɨɬɤɢ ɭɤɚɡɚɧɧɵɯ ɨɩɟɪɚ-
ɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13).
ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɫɩɟɰɢɚɥɶɧɵɟ ɱɥɟɧɵ, ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɟ ɤɨɦɩɢɥɹɬɨɪɨɦ. Ɍɨɥɶɤɨ ɨɧɢ ɦɨɝɭɬ
ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ “ɬɪɢɜɢɚɥɶɧɵɟ”, ɢ ɤɚɤ ɦɢɧɢɦɭɦ ɨɞɢɧ ɤɪɭɩɧɵɣ ɩɪɨɢɡɜɨɞɢɬɟɥɶ STL ɢɫ-
ɩɨɥɶɡɭɟɬ ɨɩɬɢɦɢɡɚɰɢɸ ɞɥɹ ɤɥɚɫɫɨɜ ɫ ɬɪɢɜɢɚɥɶɧɵɦɢ ɫɩɟɰɢɚɥɶɧɵɦɢ ɮɭɧɤɰɢɹɦɢ. ɉɨɯɨɠɟ,
ɜɫɤɨɪɟ ɷɬɨ ɫɬɚɧɟɬ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɹɜɥɟɧɢɟɦ.
Ʉɨɝɞɚ ɥɸɛɚɹ ɢɡ ɫɩɟɰɢɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɨɛɴɹɜɥɟɧɚ ɬɨɥɶɤɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɟɟ ɡɚ-
ɤɪɵɬɨɣ ɢɥɢ ɜɢɪɬɭɚɥɶɧɨɣ, ɧɨ ɛɟɡ ɫɩɟɰɢɚɥɶɧɨɣ ɫɟɦɚɧɬɢɤɢ, ɷɬɨ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɧɟɨɛɯɨɞɢɦɨɫɬɢ
ɧɚɥɢɱɢɹ ɨɫɬɚɥɶɧɵɯ ɮɭɧɤɰɢɣ.
ȼ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɤɥɚɫɫɵ, ɢɦɟɸɳɢɟ ɱɥɟɧɵ ɫɬɪɚɧɧɵɯ ɬɢɩɨɜ (ɧɚɩɪɢɦɟɪ, ɫɫɵɥɤɢ, std::auto_
ptr), ɹɜɥɹɸɬɫɹ ɢɫɤɥɸɱɟɧɢɹɦɢ, ɩɨɫɤɨɥɶɤɭ ɨɧɢ ɢɦɟɸɬ ɧɟɨɛɵɱɧɭɸ ɫɟɦɚɧɬɢɤɭ ɤɨɩɢɪɨɜɚɧɢɹ. ȼ ɤɥɚɫ-
ɫɟ, ɯɪɚɧɹɳɟɦ ɫɫɵɥɤɭ ɢɥɢ auto_ptr, ɜɚɦ, ɜɟɪɨɹɬɧɨ, ɩɨɬɪɟɛɭɟɬɫɹ ɧɚɩɢɫɚɬɶ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤ-
ɬɨɪ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɧɨ ɞɟɫɬɪɭɤɬɨɪ ɩɨ ɭɦɨɥɱɚɧɢɸ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ ɤɨɪɪɟɤɬɧɨ. (Ɂɚɦɟɬɢɦ,
ɱɬɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɱɥɟɧɚ, ɹɜɥɹɸɳɟɝɨɫɹ ɫɫɵɥɤɨɣ ɢɥɢ auto_ptr, ɩɨɱɬɢ ɜɫɟɝɞɚ ɨɲɢɛɨɱɧɨ).
Ссылки
[Cline99] §30.01-14 • [Koenig97] §4 • [Stroustrup00] §5.5, §10.4 • [SuttHysl04b]
Стр. 108
53. Явно разрешайте или запрещайте
копирование
Резюме
Ʉɨɩɢɪɭɣɬɟ ɫɨ ɡɧɚɧɢɟɦ ɞɟɥɚ: ɬɳɚɬɟɥɶɧɨ ɜɵɛɢɪɚɣɬɟ ɦɟɠɞɭ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɯ
ɤɨɦɩɢɥɹɬɨɪɨɦ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢ ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɧɚɩɢɫɚɧɢɟɦ ɫɨɛɫɬɜɟɧɧɵɯ
ɜɟɪɫɢɣ ɢɥɢ ɹɜɧɵɦ ɡɚɩɪɟɳɟɧɢɟɦ ɨɛɨɢɯ, ɟɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɧɟ ɞɨɥɠɧɨ ɛɵɬɶ ɪɚɡɪɟɲɟɧɨ.
Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɨɣ ɨɲɢɛɤɨɣ (ɢ ɧɟ ɬɨɥɶɤɨ ɫɪɟɞɢ ɧɨɜɢɱɤɨɜ) ɹɜɥɹɟɬɫɹ ɢɝɧɨɪɢɪɨɜɚɧɢɟ ɫɟɦɚɧ-
ɬɢɤɢ ɤɨɩɢɪɨɜɚɧɢɹ ɢ ɩɪɢɫɜɚɢɜɚɧɢɹ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ. ɗɬɨ ɯɚɪɚɤɬɟɪɧɨ ɞɥɹ ɦɚɥɟɧɶɤɢɯ
ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɯ ɤɥɚɫɫɨɜ, ɬɚɤɢɯ ɤɚɤ ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ ɞɥɹ ɩɨɞɞɟɪɠɤɢ ɢɞɢɨɦɵ RAII (ɫɦ. ɪɟ-
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲ ɤɥɚɫɫ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɨɫɦɵɫɥɟɧɧɨɟ ɤɨɩɢɪɨɜɚɧɢɟ (ɢɥɢ ɧɟ ɩɪɟɞɨɫɬɚɜɥɹɟɬ
ɟɝɨ ɜɨɜɫɟ). ȼɨɬ ɜɨɡɦɨɠɧɵɟ ɜɚɪɢɚɧɬɵ.
• əɜɧɨɟ ɡɚɩɪɟɳɟɧɢɟ ɨɛɟɢɯ ɮɭɧɤɰɢɣ. ȿɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɞɥɹ ɜɚɲɟɝɨ ɬɢɩɚ ɥɢɲɟɧɨ ɫɦɵɫɥɚ,
ɡɚɩɪɟɬɢɬɟ ɤɚɤ ɤɨɩɢɪɭɸɳɟɟ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɟ, ɬɚɤ ɢ ɤɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ, ɨɛɴɹ-
ɜɢɜ ɢɯ ɤɚɤ ɡɚɤɪɵɬɵɟ ɧɟɪɟɚɥɢɡɨɜɚɧɧɵɟ ɮɭɧɤɰɢɢ:
class T { // ...
private: // ǏǰǶǫǰǷ T ǸǰǵǹǺǳǻǾǰǷȆǷ
T( const T& ); // ǟǾǸǵȁǳȊ Ǹǰ ǻǰǫǶǳǲǹǭǫǸǫ
T& operator=( const T& ); // ǟǾǸǵȁǳȊ Ǹǰ ǻǰǫǶǳǲǹǭǫǸǫ
};
• əɜɧɨɟ ɧɚɩɢɫɚɧɢɟ ɨɛɟɢɯ ɮɭɧɤɰɢɣ. ȿɫɥɢ ɞɥɹ ɨɛɴɟɤɬɨɜ T ɩɪɟɞɭɫɦɨɬɪɟɧɵ ɤɨɩɢɪɨɜɚɧɢɟ ɢ
ɤɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ, ɧɨ ɤɨɪɪɟɤɬɧɨɟ ɤɨɩɢɪɭɸɳɟɟ ɩɨɜɟɞɟɧɢɟ ɨɬɥɢɱɚɟɬɫɹ ɨɬ ɩɨ-
ɜɟɞɟɧɢɹ ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ ɜɟɪɫɢɣ, ɬɨ ɫɥɟɞɭɟɬ ɹɜɧɨ ɧɚɩɢɫɚɬɶ ɨɛɟ ɮɭɧɤ-
ɰɢɢ ɢ ɫɞɟɥɚɬɶ ɢɯ ɧɟ ɡɚɤɪɵɬɵɦɢ.
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ ɜɟɪɫɢɣ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɫ ɹɜɧɵɦ
ɤɨɦɦɟɧɬɚɪɢɟɦ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ, ɟɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɢɦɟɟɬ ɫɦɵɫɥ ɢ ɩɨɜɟɞɟɧɢɟ ɩɨ
ɭɦɨɥɱɚɧɢɸ ɤɨɪɪɟɤɬɧɨ, ɷɬɢ ɮɭɧɤɰɢɢ ɦɨɠɧɨ ɧɟ ɨɛɴɹɜɥɹɬɶ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɢ ɩɨɡɜɨɥɢɬɶ
ɤɨɦɩɢɥɹɬɨɪɭ ɫɚɦɨɦɭ ɫɝɟɧɟɪɢɪɨɜɚɬɶ ɢɯ. ɋɥɟɞɭɟɬ ɹɜɧɨ ɤɨɦɦɟɧɬɢɪɨɜɚɬɶ ɤɨɪɪɟɤɬɧɨɫɬɶ
ɩɨɜɟɞɟɧɢɹ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɱɬɨɛɵ ɱɢɬɚɬɟɥɢ ɜɚɲɟɝɨ ɤɨɞɚ ɡɧɚɥɢ, ɱɬɨ ɜɵ ɩɪɟɞɧɚɦɟɪɟɧɧɨ
ɧɟ ɨɛɴɹɜɢɥɢ ɞɚɧɧɵɟ ɮɭɧɤɰɢɢ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɡɚɩɪɟɳɟɧɢɟ ɤɨɩɢɪɨɜɚɧɢɹ ɢ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɜɵ ɧɟ
ɦɨɠɟɬɟ ɩɨɦɟɫɬɢɬɶ ɨɛɴɟɤɬɵ T ɜ ɫɬɚɧɞɚɪɬɧɵɟ ɤɨɧɬɟɣɧɟɪɵ. ɗɬɨ ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ ɩɥɨɯɨ; ɨɱɟɧɶ
ɦɨɠɟɬ ɛɵɬɶ, ɱɬɨ ɜɵ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɧɟ ɡɚɯɨɬɢɬɟ ɯɪɚɧɢɬɶ ɬɚɤɢɟ ɨɛɴɟɤɬɵ ɜ ɤɨɧɬɟɣɧɟɪɚɯ. (Ɍɟɦ
ɧɟ ɦɟɧɟɟ, ɜɵ ɜɫɟ ɪɚɜɧɨ ɦɨɠɟɬɟ ɩɨɦɟɫɬɢɬɶ ɷɬɢ ɨɛɴɟɤɬɵ ɜ ɤɨɧɬɟɣɧɟɪ, ɟɫɥɢ ɛɭɞɟɬɟ ɯɪɚɧɢɬɶ ɢɯ
ɩɨɫɪɟɞɫɬɜɨɦ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ ɭɤɚɡɚɬɟɥɟɣ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 79).
ȼɵɜɨɞ: ɛɭɞɶɬɟ ɜɧɢɦɚɬɟɥɶɧɵ ɩɪɢ ɪɚɛɨɬɟ ɫ ɷɬɢɦɢ ɞɜɭɦɹ ɨɩɟɪɚɰɢɹɦɢ, ɬɚɤ ɤɚɤ ɤɨɦɩɢɥɹɬɨɪ
ɢɦɟɟɬ ɬɟɧɞɟɧɰɢɸ ɤ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨɣ ɢɯ ɝɟɧɟɪɚɰɢɢ, ɚ ɷɬɢ ɫɝɟɧɟɪɢɪɨɜɚɧɧɵɟ ɜɟɪɫɢɢ ɡɚɱɚɫɬɭɸ
ɧɟɛɟɡɨɩɚɫɧɵ ɞɥɹ ɬɢɩɨɜ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ ɡɧɚɱɟɧɢɹɦɢ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 32).
Ссылки
[Dewhurst03] §88 • [Meyers97] §11 • [Stroustrup00] §11.2.2
53. Явно разрешайте или запрещайте копирование 109
Стр. 109
54. Избегайте срезки...
54. Избегайте срезки. Подумайте

об использовании в базовом классе
клонирования вместо копирования
54. Избегайте срезки...
Резюме
ɋɪɟɡɤɚ ɨɛɴɟɤɬɨɜ ɩɪɨɢɫɯɨɞɢɬ ɚɜɬɨɦɚɬɢɱɟɫɤɢ, ɧɟɜɢɞɢɦɨ ɢ ɦɨɠɟɬ ɩɪɢɜɨɞɢɬɶ ɤ ɩɨɥɧɨɦɭ ɪɚɡ-
ɪɭɲɟɧɢɸ ɱɭɞɟɫɧɨɝɨ ɩɨɥɢɦɨɪɮɧɨɝɨ ɞɢɡɚɣɧɚ. ɉɨɞɭɦɚɣɬɟ ɨ ɩɨɥɧɨɦ ɡɚɩɪɟɬɟ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧ-
ɫɬɪɭɤɬɨɪɚ ɢ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɜ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ. ȼɦɟɫɬɨ ɧɢɯ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ Clone, ɟɫɥɢ ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɧɟɨɛɯɨɞɢɦɨ ɩɨɥɭɱɚɬɶ
ɩɨɥɢɦɨɪɮɧɵɟ (ɩɨɥɧɵɟ, ɝɥɭɛɨɤɢɟ) ɤɨɩɢɢ.
Ʉɨɝɞɚ ɜɵ ɫɬɪɨɢɬɟ ɢɟɪɚɪɯɢɸ ɤɥɚɫɫɨɜ, ɨɛɵɱɧɨ ɨɧɚ ɩɪɟɞɧɚɡɧɚɱɟɧɚ ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɩɨɥɢ-
ɦɨɪɮɧɨɝɨ ɩɨɜɟɞɟɧɢɹ. ȼɵ ɯɨɬɢɬɟ, ɱɬɨɛɵ ɨɛɴɟɤɬɵ, ɛɭɞɭɱɢ ɫɨɡɞɚɧɧɵɦɢ, ɫɨɯɪɚɧɹɥɢ ɫɜɨɣ ɬɢɩ ɢ
ɢɞɟɧɬɢɱɧɨɫɬɶ. ɗɬɚ ɰɟɥɶ ɜɫɬɭɩɚɟɬ ɜ ɤɨɧɮɥɢɤɬ ɫ ɨɛɵɱɧɨɣ ɫɟɦɚɧɬɢɤɨɣ ɤɨɩɢɪɨɜɚɧɢɹ ɨɛɴɟɤɬɨɜ ɜ
C++, ɩɨɫɤɨɥɶɤɭ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɧɟ ɹɜɥɹɟɬɫɹ ɜɢɪɬɭɚɥɶɧɵɦ ɢ ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɫɞɟɥɚɧ
ɬɚɤɨɜɵɦ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɩɪɢɦɟɪ:
class B { /* ... */ };
class D : public B { /* ... */ };

// ǙǺ! ǚǹǶǾȂǰǸǳǰ ǹǬȅǰǵǽǫ Ǻǹ ǲǸǫȂǰǸǳȉ
void Transmogrify( B obj );
void Transubstantiate( B& obj ) { // ǍǼǰ ǸǹǻǷǫǶȇǸǹ -
// ǺǰǻǰǯǫȂǫ Ǻǹ ǼǼȆǶǵǰ
Transmogrify( obj ); // ǚǶǹȀǹ! ǜǻǰǲǵǫ ǹǬȅǰǵǽǫ!
// ...
}
D d;
Transubstantiate( d );
ɉɪɨɝɪɚɦɦɢɫɬ ɧɚɦɟɪɟɧ ɪɚɛɨɬɚɬɶ ɫ ɨɛɴɟɤɬɚɦɢ B ɢ ɩɪɨɢɡɜɨɞɧɵɯ ɤɥɚɫɫɨɜ ɩɨɥɢɦɨɪɮɧɨ. Ɉɞɧɚ-
ɤɨ, ɩɨ ɨɲɢɛɤɟ (ɢɥɢ ɭɫɬɚɥɨɫɬɢ — ɤ ɬɨɦɭ ɠɟ ɢ ɤɨɮɟ ɡɚɤɨɧɱɢɥɫɹ…) ɩɪɨɝɪɚɦɦɢɫɬ ɢɥɢ ɩɪɨɫɬɨ ɡɚ-
ɛɵɥ ɧɚɩɢɫɚɬɶ & ɜ ɫɢɝɧɚɬɭɪɟ Transmogrify, ɢɥɢ ɫɨɛɢɪɚɥɫɹ ɫɨɡɞɚɬɶ ɤɨɩɢɸ, ɧɨ ɫɞɟɥɚɥ ɷɬɨ ɧɟ-
ɜɟɪɧɨ. Ʉɨɞ ɤɨɦɩɢɥɢɪɭɟɬɫɹ ɛɟɡ ɨɲɢɛɨɤ, ɧɨ ɤɨɝɞɚ ɮɭɧɤɰɢɹ Transmogrify ɜɵɡɵɜɚɟɬɫɹ ɫ ɩɟɪɟ-
ɞɚɱɟɣ ɟɣ ɨɛɴɟɤɬɚ D, ɨɧ ɦɭɬɢɪɭɟɬ ɜ ɨɛɴɟɤɬ B. ɗɬɨ ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɩɟɪɟɞɚɱɚ ɩɨ ɡɧɚɱɟɧɢɸ
ɩɪɢɜɨɞɢɬ ɤ ɜɵɡɨɜɭ B::B(const B&), ɬ.ɟ. ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ B, ɩɚɪɚɦɟɬɪ ɤɨɬɨɪɨɝɨ
const B& ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɩɪɟɨɛɪɚɡɨɜɚɧɧɭɸ ɫɫɵɥɤɭ ɧɚ d. ɑɬɨ ɩɪɢɜɨɞɢɬ ɤ
ɩɨɥɧɨɣ ɩɨɬɟɪɟ ɞɢɧɚɦɢɱɟɫɤɨɝɨ, ɩɨɥɢɦɨɪɮɧɨɝɨ ɩɨɜɟɞɟɧɢɹ, ɢɡ-ɡɚ ɤɨɬɨɪɨɝɨ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɢ
ɢɫɩɨɥɶɡɭɟɬɫɹ ɧɚɫɥɟɞɨɜɚɧɢɟ.
ȿɫɥɢ, ɤɚɤ ɚɜɬɨɪ ɤɥɚɫɫɚ B, ɜɵ ɯɨɬɢɬɟ ɪɚɡɪɟɲɢɬɶ ɫɪɟɡɤɭ, ɧɨ ɧɟ ɯɨɬɢɬɟ, ɱɬɨɛɵ ɨɧɚ ɦɨɝɥɚ ɩɪɨɢɫ-
ɯɨɞɢɬɶ ɩɨ ɨɲɢɛɤɟ, ɞɥɹ ɬɚɤɨɝɨ ɫɥɭɱɚɹ ɫɭɳɟɫɬɜɭɟɬ ɨɞɢɧ ɜɚɪɢɚɧɬ ɞɟɣɫɬɜɢɣ, ɨ ɤɨɬɨɪɨɦ ɦɵ ɭɩɨɦɹ-
ɧɟɦ ɞɥɹ ɩɨɥɧɨɬɵ ɢɡɥɨɠɟɧɢɹ, ɧɨ ɧɟ ɪɟɤɨɦɟɧɞɭɟɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɝɨ ɜ ɤɨɞɟ, ɤ ɤɨɬɨɪɨɦɭ ɩɪɟɞɴɹɜɥɹ-
ɟɬɫɹ ɬɪɟɛɨɜɚɧɢɟ ɩɟɪɟɧɨɫɢɦɨɫɬɢ: ɜɵ ɦɨɠɟɬɟ ɨɛɴɹɜɢɬɶ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ B ɤɚɤ
explicit. ɗɬɨ ɦɨɠɟɬ ɩɨɦɨɱɶ ɢɡɛɟɠɚɬɶ ɧɟɹɜɧɨɣ ɫɪɟɡɤɢ, ɧɨ ɤɪɨɦɟ ɷɬɨɝɨ ɡɚɩɪɟɳɚɟɬ ɜɫɟ ɩɟɪɟɞɚɱɢ
ɩɚɪɚɦɟɬɪɨɜ ɞɚɧɧɨɝɨ ɬɢɩɚ ɩɨ ɡɧɚɱɟɧɢɸ (ɱɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜɩɨɥɧɟ ɩɪɢɟɦɥɟɦɵɦ ɞɥɹ ɛɚɡɨɜɵɯ
ɤɥɚɫɫɨɜ, ɨɛɴɟɤɬɵ ɤɨɬɨɪɵɯ ɜɫɟ ɪɚɜɧɨ ɧɟ ɞɨɥɠɧɵ ɫɨɡɞɚɜɚɬɶɫɹ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 35).
Стр. 110
// ǙǬȅȊǭǶȊǰǷ ǵǹǺǳǻǾȉȄǳǴ ǵǹǸǼǽǻǾǵǽǹǻ ǵǫǵ explicit (Ǿ ǯǫǸǸǹǮǹ
// ǻǰȃǰǸǳȊ ǳǷǰǰǽǼȊ ǺǹǬǹȂǸǹǰ ǯǰǴǼǽǭǳǰ, ǽǫǵ Ȃǽǹ ǽǻǰǬǾǰǽǼȊ
// ǾǶǾȂȃǰǸǳǰ ȈǽǹǮǹ Ƿǰǽǹǯǫ)
class B { // ...
public:
explicit B( const B& rhs );
};
class D : public B { /* ... */ };
ȼɵɡɵɜɚɸɳɢɣ ɤɨɞ ɜɫɟ ɪɚɜɧɨ ɜ ɫɨɫɬɨɹɧɢɢ ɜɵɩɨɥɧɢɬɶ ɫɪɟɡɤɭ, ɟɫɥɢ ɷɬɨ ɧɟɨɛɯɨɞɢɦɨ, ɧɨ ɞɨɥ-
ɠɟɧ ɞɟɥɚɬɶ ɷɬɨ ɹɜɧɨ:
void Transmogrify( B obj ); // ǝǰǺǰǻȇ Ȉǽǫ ǿǾǸǵȁǳȊ ǭǹǹǬȄǰ Ǹǰ
// ǷǹǱǰǽ ǬȆǽȇ ǭȆǲǭǫǸǫ (!)
void Transmogrify2(const B& obj) // ǓǯǳǹǷǫ ǯǶȊ ǸǫǷǰǻǰǸǳȊ ǭ
{ // ǶȉǬǹǷ ǼǶǾȂǫǰ ǺǹǶǾȂǳǽȇ
B b( obj ); // ǺǫǻǫǷǰǽǻ obj Ǻǹ ǲǸǫȂǰǸǳȉ
// ... // (Ǽ ǭǹǲǷǹǱǸǹǴ ǼǻǰǲǵǹǴ)
}
B b; // ǌǫǲǹǭȆǰ ǵǶǫǼǼȆ Ǹǰ ǯǹǶǱǸȆ ǬȆǽȇ ǵǹǸǵǻǰǽǸȆǷǳ
D d; // (ǼǷ. ǻǰǵǹǷǰǸǯǫȁǳȉ 35), Ǹǹ ǯǹǺǾǼǽǳǷ Ȉǽǹ
Transmogrify(b); // ǏǹǶǱǸǫ ǬȆǽȇ ǹȃǳǬǵǫ (ǼǷ. ǺǻǳǷǰȂǫǸǳǰ)
Transmogrify(d); // ǏǹǶǱǸǫ ǬȆǽȇ ǹȃǳǬǵǫ (ǼǷ. ǺǻǳǷǰȂǫǸǳǰ)
Transmogrify2(d); // ǍǼǰ ǭ ǺǹǻȊǯǵǰ
ɉɪɢɦɟɱɚɧɢɟ: ɧɚ ɦɨɦɟɧɬ ɧɚɩɢɫɚɧɢɹ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɧɟɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪɵ ɨɲɢ-
ɛɨɱɧɨ ɞɨɩɭɫɤɚɥɢ ɨɞɢɧ ɢɥɢ ɨɛɚ ɩɪɢɜɟɞɟɧɧɵɯ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ Transmogrify. ɗɬɚ ɢɞɢɨɦɚ
ɜɩɨɥɧɟ ɫɬɚɧɞɚɪɬɧɚ, ɧɨ (ɩɨɤɚ ɱɬɨ) ɧɟ ɩɨɥɧɨɫɬɶɸ ɩɟɪɟɧɨɫɢɦɚ.
ɂɦɟɟɬɫɹ ɥɭɱɲɢɣ ɫɩɨɫɨɛ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ ɫɪɟɡɤɢ, ɫ ɛɨɥɟɟ ɜɵɫɨɤɨɣ ɫɬɟɩɟɧɶɸ ɩɟɪɟɧɨɫɢɦɨɫɬɢ.
ɉɭɫɬɶ, ɧɚɩɪɢɦɟɪ, ɮɭɧɤɰɢɹ ɧɚɩɨɞɨɛɢɟ Transmogrify ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɯɨɱɟɬ ɩɨɥɭɱɢɬɶ ɩɨɥ-
ɧɭɸ ɝɥɭɛɨɤɭɸ ɤɨɩɢɸ ɛɟɡ ɢɧɮɨɪɦɚɰɢɢ ɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨɦ ɩɪɨɢɡɜɨɞɧɨɦ ɬɢɩɟ ɩɟɪɟɞɚɧɧɨɝɨ ɨɛɴɟɤ-
ɬɚ. Ȼɨɥɟɟ ɨɛɳɟɟ ɢɞɢɨɦɚɬɢɱɟɫɤɨɟ ɪɟɲɟɧɢɟ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤ-
ɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɡɚɳɢɳɟɧɧɵɦ (ɱɬɨɛɵ ɮɭɧɤɰɢɹ ɧɚɩɨɞɨɛɢɟ Transmogrify ɧɟ ɦɨɝɥɚ ɫɥɭɱɚɣ-
ɧɨ ɟɝɨ ɜɵɡɜɚɬɶ), ɚ ɜɦɟɫɬɨ ɧɟɝɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɟɣ Clone:
// ǏǹǬǫǭǶǰǸǳǰ ǿǾǸǵȁǳǳ Clone (ǾǱǰ ǶǾȂȃǰ, Ǹǹ ǭǼǰ ǰȄǰ ǽǻǰǬǾǰǽǼȊ
// ǾǼǹǭǰǻȃǰǸǼǽǭǹǭǫǸǳǰ)
class B { // ...
public:
virtual B* Clone() const = 0;
protected:
B( const B& );
};
class D : public B { // ...

public:
virtual D* Clone() const { return new D(*this); }
protected:
D( const D& rhs ) : B( rhs ) { /* ... */ }
};
Ɍɟɩɟɪɶ ɩɨɩɵɬɤɚ ɫɪɟɡɤɢ ɛɭɞɟɬ (ɩɟɪɟɧɨɫɢɦɨ) ɝɟɧɟɪɢɪɨɜɚɬɶ ɨɲɢɛɤɭ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ,
ɚ ɨɛɴɹɜɥɟɧɢɟ ɮɭɧɤɰɢɢ Clone ɤɚɤ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɨɣ ɡɚɫɬɚɜɥɹɟɬ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɵɣ ɩɪɨɢɡɜɨɞ-
ɧɵɣ ɤɥɚɫɫ ɩɟɪɟɤɪɵɬɶ ɟɟ. Ʉ ɫɨɠɚɥɟɧɢɸ, ɫ ɞɚɧɧɵɦ ɪɟɲɟɧɢɟɦ ɜɫɟ ɟɳɟ ɫɜɹɡɚɧɵ ɞɜɟ ɩɪɨɛɥɟɦɵ,
ɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɨɛɧɚɪɭɠɢɬɶ: ɜ ɤɥɚɫɫɟ, ɩɪɨɢɡɜɨɞɧɨɦ ɨɬ ɩɪɨɢɡɜɨɞɧɨɝɨ,
ɮɭɧɤɰɢɹ Clone ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɧɟɩɟɪɟɤɪɵɬɨɣ, ɚ ɩɟɪɟɤɪɵɬɢɟ Clone ɦɨɠɟɬ ɪɟɚɥɢɡɨɜɚɬɶ ɟɟ
ɧɟɤɨɪɪɟɤɬɧɨ, ɬɚɤ ɱɬɨ ɤɨɩɢɹ ɛɭɞɟɬ ɧɟ ɬɨɝɨ ɠɟ ɬɢɩɚ, ɱɬɨ ɢ ɨɪɢɝɢɧɚɥ. Ɏɭɧɤɰɢɹ Clone ɞɨɥɠɧɚ
ɫɥɟɞɨɜɚɬɶ ɲɚɛɥɨɧɭ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Nonvirtual Interface (NVI; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 39), ɤɨɬɨɪɵɣ
54. Избегайте срезки... 111
Стр. 111
ɪɚɡɞɟɥɹɟɬ ɨɬɤɪɵɬɭɸ ɢ ɜɢɪɬɭɚɥɶɧɭɸ ɩɪɢɪɨɞɵ Clone ɢ ɩɨɡɜɨɥɹɟɬ ɜɚɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɪɹɞ ɜɚɠ-
ɧɵɯ ɩɪɨɜɟɪɨɤ:
class B { // ...
public:
B* Clone() const { // ǘǰǭǳǻǽǾǫǶȇǸǫȊ ǿǾǸǵȁǳȊ
B* p = DoClone();
assert (typeid (*p) == typeid (*this) &&
"DoClone incorrectly overridden ");
return p; // ǚǻǹǭǰǻǵǫ ǽǳǺǫ, ǭǹǲǭǻǫȄǫǰǷǹǮǹ DoClone
}
protected:
B( const B& );
private:
virtual B* DoClone () const = 0;
};
Ɏɭɧɤɰɢɹ Clone ɬɟɩɟɪɶ ɹɜɥɹɟɬɫɹ ɧɟɜɢɪɬɭɚɥɶɧɵɦ ɢɧɬɟɪɮɟɣɫɨɦ, ɢɫɩɨɥɶɡɭɟɦɵɦ ɜɵɡɵɜɚɸ-
ɳɢɦ ɤɨɞɨɦ. ɉɪɨɢɡɜɨɞɧɵɟ ɤɥɚɫɫɵ ɞɨɥɠɧɵ ɩɟɪɟɤɪɵɬɶ ɮɭɧɤɰɢɸ DoClone. Ⱦɨɩɨɥɧɢɬɟɥɶɧɚɹ
ɩɪɨɜɟɪɤɚ ɨɛɧɚɪɭɠɢɬ ɜɫɟ ɤɨɩɢɢ, ɤɨɬɨɪɵɟ ɢɦɟɸɬ ɬɢɩ, ɨɬɥɢɱɧɵɣ ɨɬ ɨɪɢɝɢɧɚɥɚ, ɬɟɦ ɫɚɦɵɦ ɨɩɨ-
ɜɟɳɚɹ, ɱɬɨ ɜ ɧɟɤɨɬɨɪɨɦ ɩɪɨɢɡɜɨɞɧɨɦ ɤɥɚɫɫɟ ɧɟ ɩɟɪɟɤɪɵɬɚ ɮɭɧɤɰɢɹ DoClone; ɜ ɤɨɧɰɟ ɤɨɧɰɨɜ,
ɡɚɞɚɱɚ assert ɫɨɫɬɨɢɬ ɢɦɟɧɧɨ ɜ ɨɛɧɚɪɭɠɟɧɢɢ ɢ ɫɨɨɛɳɟɧɢɢ ɨ ɬɚɤɢɯ ɩɪɨɝɪɚɦɦɧɵɯ ɨɲɢɛɤɚɯ
ɇɟɤɨɬɨɪɵɟ ɩɪɨɟɤɬɧɵɟ ɪɟɲɟɧɢɹ ɦɨɝɭɬ ɬɪɟɛɨɜɚɬɶ, ɱɬɨɛɵ ɤɨɩɢɪɭɸɳɢɟ ɤɨɧɫɬɪɭɤɬɨɪɵ ɛɚɡɨ-
ɜɵɯ ɤɥɚɫɫɨɜ ɨɫɬɚɜɚɥɢɫɶ ɨɬɤɪɵɬɵɦɢ (ɧɚɩɪɢɦɟɪ, ɤɨɝɞɚ ɱɚɫɬɶ ɜɚɲɟɣ ɢɟɪɚɪɯɢɢ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨ-
ɛɨɣ ɛɢɛɥɢɨɬɟɤɭ ɫɬɨɪɨɧɧɟɝɨ ɩɪɨɢɡɜɨɞɢɬɟɥɹ). ȼ ɬɚɤɨɦ ɫɥɭɱɚɟ ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɩɟɪɟɞɚɱɭ
ɩɨɫɪɟɞɫɬɜɨɦ (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɝɨ) ɭɤɚɡɚɬɟɥɹ ɩɟɪɟɞɚɱɟ ɩɨ ɫɫɵɥɤɟ; ɤɚɤ ɩɨɤɚɡɚɧɨ ɜ ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ 25, ɩɟɪɟɞɚɱɚ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ ɫɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɩɨɞɜɟɪɠɟɧɚ ɫɪɟɡɤɟ ɢ ɧɟɠɟɥɚ-
ɬɟɥɶɧɨɦɭ ɫɨɡɞɚɧɢɸ ɜɪɟɦɟɧɧɵɯ ɨɛɴɟɤɬɨɜ.
Ссылки
[Dewhurst03] §30, §76, §94 • [Meyers96] §13 • [Meyers97] §22 • [Stroustrup94] §11.4.4 •
[Stroustrup00] §12.2.3
Стр. 112
55. Предпочитайте канонический вид
присваивания
Резюме
ɉɪɢ ɪɟɚɥɢɡɚɰɢɢ ɨɩɟɪɚɬɨɪɚ operator= ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ —
ɧɟɜɢɪɬɭɚɥɶɧɵɣ ɫ ɨɩɪɟɞɟɥɟɧɧɨɣ ɫɢɝɧɚɬɭɪɨɣ.
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɨɛɴɹɜɥɹɬɶ ɤɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ ɞɥɹ ɬɢɩɚ T ɫ ɨɞɧɨɣ ɢɡ ɫɥɟɞɭɸɳɢɯ
ɫɢɝɧɚɬɭɪ (ɫɦ. [Stroustrup00] ɢ [Alexandrescu03a]):
T& operator=( const T& ); // ǕǶǫǼǼǳȂǰǼǵǳǴ ǭǳǯ
T& operator=( T ); // ǚǹǽǰǸȁǳǫǶȇǸǹ ǹǺǽǳǷǳǲǳǻǹǭǫǸǸȆǴ
// ǭǳǯ (ǼǷ. ǻǰǵǹǷǰǸǯǫȁǳȉ 27)
ȼɬɨɪɨɣ ɜɚɪɢɚɧɬ ɢɦɟɟɬ ɫɦɵɫɥ ɢɫɩɨɥɶɡɨɜɚɬɶ, ɟɫɥɢ ɜɚɦ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɬɪɟɛɭɟɬɫɹ ɤɨɩɢɹ ɚɪ-
ɝɭɦɟɧɬɚ ɜ ɬɟɥɟ ɜɚɲɟɝɨ ɨɩɟɪɚɬɨɪɚ, ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɢɞɢɨɦɵ, ɨɫɧɨɜɚɧɧɨɣ ɧɚ
ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 56).
ɂɡɛɟɝɚɣɬɟ ɞɟɥɚɬɶ ɥɸɛɨɣ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ ɜɢɪɬɭɚɥɶɧɵɦ (ɫɦ. [Meyers96] §33 ɢ
[Sutter04] §19). ȿɫɥɢ ɜɵ ɩɨɥɚɝɚɟɬɟ, ɱɬɨ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɜɢɪɬɭɚɥɶɧɨɟ ɩɨɜɟɞɟɧɢɟ ɩɪɢɫɜɚɢɜɚɧɢɹ,
ɨɛɪɚɬɢɬɟɫɶ ɫɧɚɱɚɥɚ ɤ ɭɤɚɡɚɧɧɨɣ ɥɢɬɟɪɚɬɭɪɟ. ȿɫɥɢ ɢ ɩɨɫɥɟ ɷɬɨɝɨ ɜɵ ɫɬɨɢɬɟ ɧɚ ɫɜɨɟɦ, ɬɨ ɥɭɱɲɟ
ɢɫɩɨɥɶɡɨɜɚɬɶ ɜɢɪɬɭɚɥɶɧɭɸ ɢɦɟɧɨɜɚɧɧɭɸ ɮɭɧɤɰɢɸ, ɚ ɧɟ ɨɩɟɪɚɬɨɪ (ɧɚɩɪɢɦɟɪ, virtual void
Assign(const T&);).
ɇɟ ɜɨɡɜɪɚɳɚɣɬɟ const T&. ɏɨɬɹ ɷɬɨɬ ɬɢɩ ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɡɧɚɱɟɧɢɹ ɢɦɟɟɬ ɬɨ ɩɪɟɢɦɭɳɟɫɬ-
ɜɨ, ɱɬɨ ɡɚɳɢɳɚɟɬ ɨɬ ɫɬɪɚɧɧɵɯ ɩɪɢɫɜɚɢɜɚɧɢɣ ɧɚɩɨɞɨɛɢɟ (a=b)=c, ɝɥɚɜɧɵɦ ɟɝɨ ɧɟɞɨɫɬɚɬɤɨɦ
ɹɜɥɹɟɬɫɹ ɬɨ, ɱɬɨ ɜɵ ɧɟ ɫɦɨɠɟɬɟ ɩɨɦɟɫɬɢɬɶ ɨɛɴɟɤɬɵ ɬɢɩɚ T ɜ ɤɨɧɬɟɣɧɟɪɵ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨ-
ɬɟɤɢ; ɷɬɢ ɤɨɧɬɟɣɧɟɪɵ ɬɪɟɛɭɸɬ, ɱɬɨɛɵ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ ɜɨɡɜɪɚɳɚɥ ɬɢɩ T&.
ȼɫɟɝɞɚ ɞɟɥɚɣɬɟ ɤɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ ɛɟɡɨɩɚɫɧɵɦ ɜ ɫɦɵɫɥɟ ɢɫɤɥɸɱɟɧɢɣ, ɩɪɢɱɟɦ
ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɚ ɫɬɪɨɝɚɹ ɝɚɪɚɧɬɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71).
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ ɛɟɡɨɩɚɫɟɧ ɜ ɫɦɵɫɥɟ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ.
ɂɡɛɟɝɚɣɬɟ ɧɚɩɢɫɚɧɢɹ ɨɩɟɪɚɬɨɪɚ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɤɨɬɨɪɵɣ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ
ɩɨɥɚɝɚɟɬɫɹ ɧɚ ɩɪɨɜɟɪɤɭ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ; ɡɚɱɚɫɬɭɸ ɷɬɨ ɝɨɜɨɪɢɬ ɨ ɧɟɞɨɫɬɚɬɨɱɧɨɣ ɛɟɡɨ-
ɩɚɫɧɨɫɬɢ ɜ ɫɦɵɫɥɟ ɢɫɤɥɸɱɟɧɢɣ. ȿɫɥɢ ɜɵ ɩɢɲɟɬɟ ɤɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
ɢɞɢɨɦɵ ɨɛɦɟɧɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 56), ɬɨ ɜɵ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɨɛɟɫɩɟɱɢɜɚɟɬɟ ɤɚɤ ɫɬɪɨɝɭɸ ɛɟɡɨ-
ɩɚɫɧɨɫɬɶ ɜ ɫɦɵɫɥɟ ɢɫɤɥɸɱɟɧɢɣ, ɬɚɤ ɢ ɛɟɡɨɩɚɫɧɨɫɬɶ ɜ ɫɦɵɫɥɟ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ. ȿɫɥɢ
ɩɪɢɫɜɚɢɜɚɧɢɟ ɫɚɦɨɦɭ ɫɟɛɟ ɱɚɫɬɨ ɜɫɬɪɟɱɚɟɬɫɹ ɜ ɩɪɨɝɪɚɦɦɟ ɢɡ-ɡɚ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɫɫɵɥɨɱɧɵɯ ɫɢɧɨ-
ɧɢɦɨɜ ɢɥɢ ɩɨ ɤɚɤɢɦ-ɬɨ ɢɧɵɦ ɩɪɢɱɢɧɚɦ, ɩɪɨɜɟɪɤɚ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶɫɹ ɜ ɤɚɱɟɫɬɜɟ ɫɪɟɞɫɬɜɚ ɨɩɬɢɦɢɡɚɰɢɢ ɜɨ ɢɡɛɟɠɚɧɢɟ ɥɢɲɧɟɣ ɪɚɛɨɬɵ.
əɜɧɨ ɜɵɡɵɜɚɣɬɟ ɜɫɟ ɨɩɟɪɚɬɨɪɵ ɩɪɢɫɜɚɢɜɚɧɢɹ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ ɢ ɜɫɟɯ ɞɚɧɧɵɯ-ɱɥɟɧɨɜ
([Meyers97] §16); ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɱɬɨ ɢɞɢɨɦɚ ɨɛɦɟɧɚ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɡɚɛɨɬɢɬɫɹ ɨɛɨ ɜɫɟɯ
ɷɬɢɯ ɜɟɳɚɯ. ȼɨɡɜɪɚɳɚɣɬɟ ɢɡ ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ ɡɧɚɱɟɧɢɟ *this ([Meyers97] §15).
Ссылки
[Alexandrescu03a] • [Cargill92] pp41-42, 95 • [Cline99] §24.01-12 • [Koenig97] §4 •
[Meyers96] §33 • [Meyers97] §17 • [Murray93] §2.2.1 • [Stroustrup00] §10.4.4.1, §10.4.6.3 •
[Sutter00] §13, §38, §41 • [Sutter04] §19
55. Предпочитайте канонический вид присваивания 113
Стр. 113
56. Обеспечьте бессбойную функцию обмена
Резюме
Ɉɛɵɱɧɨ ɢɦɟɟɬ ɫɦɵɫɥ ɩɪɟɞɨɫɬɚɜɢɬɶ ɞɥɹ ɤɥɚɫɫɚ ɮɭɧɤɰɢɸ swap ɜ ɰɟɥɹɯ ɷɮɮɟɤɬɢɜɧɨɝɨ
ɢ ɛɟɫɫɛɨɣɧɨɝɨ ɨɛɦɟɧɚ ɜɧɭɬɪɟɧɧɟɝɨ ɫɨɞɟɪɠɢɦɨɝɨ ɨɛɴɟɤɬɚ ɫ ɜɧɭɬɪɟɧɧɢɦ ɫɨɞɟɪɠɢɦɵɦ ɞɪɭɝɨɝɨ
ɨɛɴɟɤɬɚ. Ɍɚɤɚɹ ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɩɪɢɝɨɞɢɬɶɫɹ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɪɹɞɚ ɢɞɢɨɦ, ɨɬ ɩɪɨɫɬɨɝɨ ɩɟɪɟɦɟ-
ɳɟɧɢɹ ɨɛɴɟɤɬɨɜ ɞɨ ɪɟɚɥɢɡɚɰɢɢ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɥɟɝɤɨ ɨɛɟɫɩɟɱɢɜɚɸɳɟɝɨ ɮɭɧɤɰɢɸ ɩɪɢɧɹɬɢɹ ɪɟ-
ɡɭɥɶɬɚɬɨɜ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɝɢɦɢ ɝɚɪɚɧɬɢɹɦɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɞɥɹ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ (ɫɦ. ɬɚɤɠɟ
Ɉɛɵɱɧɨ ɮɭɧɤɰɢɹ swap ɜɵɝɥɹɞɢɬ ɩɪɢɦɟɪɧɨ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ (ɡɞɟɫɶ U — ɧɟɤɨɬɨɪɵɣ
ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ ɬɢɩ):
class T { // ...
public:
void swap( T& rhs ) {
member1_.swap( rhs.member1_ );
std::swap( member2_, rhs.member2_ );
}
private:
U member1_;
int member2_;
};
Ⱦɥɹ ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ ɢ ɫɬɚɧɞɚɪɬɧɵɯ ɤɨɧɬɟɣɧɟɪɨɜ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ std::swap.
Ⱦɪɭɝɢɟ ɤɥɚɫɫɵ ɦɨɝɭɬ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɨɛɦɟɧ ɜ ɜɢɞɟ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɫ ɪɚɡɥɢɱɧɵɦɢ ɢɦɟɧɚɦɢ.
Ɋɚɫɫɦɨɬɪɢɦ ɢɫɩɨɥɶɡɨɜɚɧɢɟ swap ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɩɨɫɪɟɞɫɬ-
ɜɨɦ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ. ɉɪɢɜɟɞɟɧɧɚɹ ɞɚɥɟɟ ɪɟɚɥɢɡɚɰɢɹ ɨɩɟɪɚɬɨɪɚ operator= ɨɛɟɫ-
ɩɟɱɢɜɚɟɬ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71), ɯɨɬɹ ɢ ɰɟɧɨɣ ɫɨɡɞɚɧɢɹ ɞɨɩɨɥɧɢɬɟɥɶɧɨɝɨ
ɨɛɴɟɤɬɚ, ɱɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɧɟɩɪɢɟɦɥɟɦɵɦ, ɟɫɥɢ ɢɦɟɟɬɫɹ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵɣ ɫɩɨɫɨɛ ɜɵ-
ɩɨɥɧɟɧɢɹ ɛɟɡɨɩɚɫɧɨɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɨɛɴɟɤɬɨɜ ɬɢɩɚ T:
T& T::operator=(const T& other) { // ǍǫǻǳǫǸǽ 1 (ǽǻǫǯǳȁǳǹǸǸȆǴ)
T temp( other );
swap( temp );
return *this;
}
T& T::operator=(T
T temp) { // ǍǫǻǳǫǸǽ 2 (ǼǷ. ǻǰǵǹǷǰǸǯǫȁǳȉ 27)
swap( temp ); // ǙǬǻǫǽǳǽǰ ǭǸǳǷǫǸǳǰ Ǹǫ ǺǰǻǰǯǫȂǾ
return *this; // temp Ǻǹ ǲǸǫȂǰǸǳȉ
}
ɇɨ ɱɬɨ ɟɫɥɢ ɬɢɩ U ɧɟ ɢɦɟɟɬ ɛɟɫɫɛɨɣɧɨɣ ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ, ɤɚɤ ɜ ɫɥɭɱɚɟ ɦɧɨɝɢɯ ɫɭɳɟɫɬ-
ɜɭɸɳɢɯ ɤɥɚɫɫɨɜ, ɧɨ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɩɨɞɞɟɪɠɤɚ ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ ɞɥɹ ɬɢɩɚ T? ɇɟ ɜɫɟ ɩɨɬɟɪɹɧɨ.
• ȿɫɥɢ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɢ ɨɩɟɪɚɬɨɪ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ U ɧɟ ɞɚɸɬ ɫɛɨ-
ɟɜ, ɬɨ ɫ ɨɛɴɟɤɬɚɦɢ ɬɢɩɚ U ɜɩɨɥɧɟ ɫɩɪɚɜɢɬɫɹ std::swap.
• ȿɫɥɢ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ U ɦɨɠɟɬ ɞɚɜɚɬɶ ɫɛɨɣ, ɜɵ ɦɨɠɟɬɟ ɯɪɚɧɢɬɶ
(ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ) ɭɤɚɡɚɬɟɥɶ ɧɚ U ɜɦɟɫɬɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɱɥɟɧɚ. ɍɤɚɡɚɬɟɥɢ ɥɟɝɤɨ
ɨɛɦɟɧɢɜɚɸɬɫɹ. ɋɥɟɞɫɬɜɢɟɦ ɢɯ ɩɪɢɦɟɧɟɧɢɹ ɹɜɥɹɸɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɪɚɫɯɨɞɵ ɧɚ ɨɞɧɨ
ɞɢɧɚɦɢɱɟɫɤɨɟ ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ ɢ ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ ɤɨɫɜɟɧɧɨɫɬɶ ɩɪɢ ɨɛɪɚɳɟɧɢɢ, ɧɨ
ɟɫɥɢ ɜɵ ɯɪɚɧɢɬɟ ɜɫɟ ɬɚɤɢɟ ɱɥɟɧɵ ɜ ɟɞɢɧɨɦ Pimpl-ɨɛɴɟɤɬɟ, ɬɨ ɞɥɹ ɜɫɟɯ ɡɚɤɪɵɬɵɯ ɱɥɟɧɨɜ
ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɪɚɫɯɨɞɵ ɜɵ ɩɨɧɟɫɟɬɟ ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 43).
Стр. 114
ɇɢɤɨɝɞɚ ɧɟ ɩɨɥɶɡɭɣɬɟɫɶ ɬɪɸɤɨɦ ɪɟɚɥɢɡɚɰɢɢ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɩɨɫɪɟɞɫɬɜɨɦ ɤɨ-
ɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɜɵɡɨɜɚ ɞɟɫɬɪɭɤɬɨɪɚ
ɢ ɪɚɡɦɟɳɚɸɳɟɝɨ new, ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɬɚɤɨɣ ɬɪɸɤ ɪɟɝɭɥɹɪɧɨ “ɜɫɩɥɵɜɚɟɬ” ɜ ɮɨɪɭɦɚɯ, ɩɨ-
ɫɜɹɳɟɧɧɵɯ C++ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 99). Ɍɚɤ ɱɬɨ ɧɢɤɨɝɞɚ ɧɟ ɩɢɲɢɬɟ:
T& T::operator=( const T& rhs ) { // ǚǶǹȀǹ: ǫǸǽǳ-ǳǯǳǹǷǫ
if( this != &rhs ) {
this->~T(); // ǚǶǹȀǫȊ Ƿǰǽǹǯǳǵǫ!
new (this) T( rhs ); // (ǼǷ. [Sutter00] §41)
}
return *this;
}
ȿɫɥɢ ɨɛɴɟɤɬɵ ɜɚɲɟɝɨ ɬɢɩɚ ɦɨɠɧɨ ɨɛɦɟɧɹɬɶ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵɦ ɫɩɨɫɨɛɨɦ, ɱɟɦ ɝɪɭɛɨɟ
ɩɪɢɫɜɚɢɜɚɧɢɟ, ɠɟɥɚɬɟɥɶɧɨ ɩɪɟɞɨɫɬɚɜɢɬɶ ɮɭɧɤɰɢɸ ɨɛɦɟɧɚ, ɧɟ ɹɜɥɹɸɳɭɸɫɹ ɱɥɟɧɨɦ, ɜ ɬɨɦ ɠɟ
ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɝɞɟ ɧɚɯɨɞɢɬɫɹ ɢ ɜɚɲ ɬɢɩ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). Ʉɪɨɦɟ ɬɨɝɨ, ɩɨɞɭɦɚɣɬɟ
ɨ ɫɩɟɰɢɚɥɢɡɚɰɢɢ std::swap ɞɥɹ ɜɚɲɢɯ ɫɨɛɫɬɜɟɧɧɵɯ ɧɟɲɚɛɥɨɧɧɵɯ ɬɢɩɨɜ:
namespace std {
template<> void swap( MyType & lhs, MyType & rhs) {
lhs.s
swap( rhs ); // ǏǶȊ ǹǬȅǰǵǽǹǭ MyType ǳǼǺǹǶȇǲǾǰǽǼȊ
} // MyType::swap
}
ɋɬɚɧɞɚɪɬ ɧɟ ɩɨɡɜɨɥɹɟɬ ɜɚɦ ɫɞɟɥɚɬɶ ɷɬɨ, ɟɫɥɢ MyType ɫɚɦ ɹɜɥɹɟɬɫɹ ɲɚɛɥɨɧɧɵɦ ɤɥɚɫɫɨɦ.
Ʉ ɫɱɚɫɬɶɸ, ɢɦɟɬɶ ɬɚɤɭɸ ɫɩɟɰɢɚɥɢɡɚɰɢɸ ɯɨɪɨɲɨ, ɧɨ ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ; ɨɫɧɨɜɧɚɹ ɦɟɬɨɞɢɤɚ ɫɨɫɬɨɢɬ
ɜ ɨɛɟɫɩɟɱɟɧɢɢ ɮɭɧɤɰɢɢ swap, ɷɮɮɟɤɬɢɜɧɨ ɪɚɛɨɬɚɸɳɟɣ ɫ ɞɚɧɧɵɦ ɬɢɩɨɦ, ɜ ɜɢɞɟ ɮɭɧɤɰɢɢ, ɧɟ ɹɜ-
ɥɹɸɳɟɣɫɹ ɱɥɟɧɨɦ ɤɥɚɫɫɚ, ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɜ ɤɨɬɨɪɨɦ ɧɚɯɨɞɢɬɫɹ ɢ ɜɚɲ ɬɢɩ.
Ɉɛɦɟɧ ɜɚɠɟɧ ɞɥɹ ɤɥɚɫɫɨɜ ɫ ɫɟɦɚɧɬɢɤɨɣ ɡɧɚɱɟɧɢɹ. ɋɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɜɚɠɧɚ ɨɧɚ ɞɥɹ ɛɚɡɨ-
ɜɵɯ ɤɥɚɫɫɨɜ, ɩɨɫɤɨɥɶɤɭ ɷɬɢ ɤɥɚɫɫɵ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɟɣ
Ссылки
[C++03] §17.4.3.1(1) • [Stroustrup00] §E.3.3 • [Sutter00] §12-13, §41
56. Обеспечьте бессбойную функцию обмена 115
Стр. 115
Стр. 116
Пространства имен и модули
ɋɢɫɬɟɦɵ ɢɦɟɸɬ ɩɨɞɫɢɫɬɟɦɵ, ɤɨɬɨɪɵɟ ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ ɫɨɫɬɨɹɬ
ɢɡ ɩɨɞɫɢɫɬɟɦ ɢ ɬɚɤ ɞɨ ɛɟɫɤɨɧɟɱɧɨɫɬɢ — ɢɦɟɧɧɨ ɩɨɷɬɨɦɭ ɦɵ
ɜɫɟɝɞɚ ɞɜɢɠɟɦɫɹ ɫɜɟɪɯɭ ɜɧɢɡ.
ɉɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ — ɨɱɟɧɶ ɜɚɠɧɵɣ ɢɧɫɬɪɭɦɟɧɬ ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɢɦɟɧɚɦɢ ɢ ɫɧɢɠɟɧɢɹ

ɤɨɥɢɱɟɫɬɜɚ ɤɨɥɥɢɡɢɣ ɢɦɟɧ. Ɍɨ ɠɟ ɨɬɧɨɫɢɬɫɹ ɢ ɤ ɦɨɞɭɥɹɦ, ɤɨɬɨɪɵɟ, ɩɨɦɢɦɨ ɷɬɨɝɨ, ɩɪɟɞɫɬɚɜ-
ɥɹɸɬ ɫɨɛɨɣ ɢɧɫɬɪɭɦɟɧɬɚɪɢɣ ɞɥɹ ɪɚɛɨɬɵ ɫ ɜɟɪɫɢɹɦɢ. Ɇɵ ɨɩɪɟɞɟɥɢɦ ɦɨɞɭɥɶ ɤɚɤ ɨɬɞɟɥɶɧɵɣ
ɤɨɦɩɨɧɟɧɬ ɩɪɨɝɪɚɦɦɵ, ɫɨɞɟɪɠɚɳɢɣ ɬɟɫɧɨ ɫɜɹɡɚɧɧɵɟ ɦɟɠɞɭ ɫɨɛɨɣ ɟɟ ɷɥɟɦɟɧɬɵ (ɫɦ. ɪɟɤɨɦɟɧ-
ɞɚɰɢɸ 5) ɢ ɩɨɞɞɟɪɠɢɜɚɟɦɵɣ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɩɪɨɝɪɚɦɦɢɫɬɨɦ ɢɥɢ ɝɪɭɩɩɨɣ; ɨɛɵɱɧɨ ɦɨɞɭɥɶ
ɜɫɟɝɞɚ ɤɨɦɩɢɥɢɪɭɟɬɫɹ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɤɨɦɩɢɥɹɬɨɪɨɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɞɧɢɯ ɢ ɬɟɯ ɠɟ ɨɩ-
ɰɢɣ. Ɇɨɞɭɥɢ ɢɦɟɸɬɫɹ ɧɚ ɪɚɡɧɵɯ ɭɪɨɜɧɹɯ ɞɟɬɚɥɢɡɚɰɢɢ ɜ ɲɢɪɨɤɨɦ ɞɢɚɩɚɡɨɧɟ ɪɚɡɦɟɪɨɜ. ɋ ɨɞ-
ɧɨɣ ɫɬɨɪɨɧɵ, ɦɨɞɭɥɶ ɦɨɠɟɬ ɛɵɬɶ ɦɢɧɢɦɚɥɶɧɨɝɨ ɪɚɡɦɟɪɚ, ɩɪɟɞɫɬɚɜɥɹɹ ɫɨɛɨɣ ɨɬɞɟɥɶɧɵɣ ɨɛɴ-
ɟɤɬɧɵɣ ɮɚɣɥ, ɫɨɞɟɪɠɚɳɢɣ ɬɨɥɶɤɨ ɨɞɢɧ ɤɥɚɫɫ; ɫ ɞɪɭɝɨɣ ɫɬɨɪɨɧɵ, ɨɧ ɦɨɠɟɬ ɛɵɬɶ, ɧɚɩɪɢɦɟɪ,
ɨɬɞɟɥɶɧɨɣ ɞɢɧɚɦɢɱɟɫɤɨɣ ɛɢɛɥɢɨɬɟɤɨɣ, ɝɟɧɟɪɢɪɭɟɦɨɣ ɢɡ ɦɧɨɠɟɫɬɜɚ ɢɫɯɨɞɧɵɯ ɮɚɣɥɨɜ, ɫɨɞɟɪ-
ɠɢɦɨɟ ɤɨɬɨɪɵɯ ɨɛɪɚɡɭɟɬ ɩɨɞɫɢɫɬɟɦɭ ɜɧɭɬɪɢ ɩɪɢɥɨɠɟɧɢɹ ɛɨɥɶɲɟɝɨ ɪɚɡɦɟɪɚ ɢɥɢ ɜɵɩɭɫɤɚɟɬɫɹ
ɨɬɞɟɥɶɧɨ. Ɇɨɞɭɥɶ ɦɨɠɟɬ ɞɚɠɟ ɩɪɟɞɫɬɚɜɥɹɬɶ ɫɨɛɨɣ ɨɝɪɨɦɧɭɸ ɛɢɛɥɢɨɬɟɤɭ, ɫɨɫɬɨɹɳɭɸ ɢɡ
ɦɧɨɠɟɫɬɜɚ ɧɟɛɨɥɶɲɢɯ ɦɨɞɭɥɟɣ (ɫɬɚɬɢɱɟɫɤɢɯ ɢɥɢ ɞɢɧɚɦɢɱɟɫɤɢɯ ɛɢɛɥɢɨɬɟɤ), ɫɨɞɟɪɠɚɳɢɯ ɬɵ-
ɫɹɱɢ ɪɚɡɧɵɯ ɬɢɩɨɜ. ɇɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɬɚɤɢɟ ɛɢɛɥɢɨɬɟɤɢ ɜ ɫɬɚɧɞɚɪɬɟ C++ ɧɟ ɭɩɨɦɢɧɚɸɬɫɹ,
ɩɪɨɝɪɚɦɦɢɫɬɵ ɩɨɫɬɨɹɧɧɨ ɫɨɡɞɚɸɬ ɢ ɢɫɩɨɥɶɡɭɸɬ ɛɢɛɥɢɨɬɟɤɢ, ɢ ɯɨɪɨɲɨ ɩɪɨɞɭɦɚɧɧɚɹ ɦɨɞɭɥɹ-
ɪɢɡɚɰɢɹ ɹɜɥɹɟɬɫɹ ɮɭɧɞɚɦɟɧɬɚɥɶɧɨɣ ɱɚɫɬɶɸ ɭɫɩɟɲɧɨɝɨ ɭɩɪɚɜɥɟɧɢɹ ɡɚɜɢɫɢɦɨɫɬɹɦɢ (ɫɦ., ɧɚ-
ɩɪɢɦɟɪ, ɪɟɤɨɦɟɧɞɚɰɢɸ 11).
Ɍɪɭɞɧɨ ɩɪɟɞɫɬɚɜɢɬɶ ɫɟɛɟ ɩɪɨɝɪɚɦɦɭ ɡɧɚɱɢɬɟɥɶɧɨɝɨ ɪɚɡɦɟɪɚ, ɤɨɬɨɪɚɹ ɧɟ ɢɫɩɨɥɶɡɭɟɬ ɤɚɤ
ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ, ɬɚɤ ɢ ɦɨɞɭɥɢ. ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɪɚɫɫɦɨɬɪɢɦ ɨɫɧɨɜɧɵɟ ɪɟɤɨɦɟɧɞɚɰɢɢ ɩɨ
ɢɫɩɨɥɶɡɨɜɚɧɢɸ ɞɜɭɯ ɷɬɢɯ ɜɡɚɢɦɨɫɜɹɡɚɧɧɵɯ ɢɧɫɬɪɭɦɟɧɬɨɜ, ɧɚɪɹɞɭ ɫ ɢɯ ɜɡɚɢɦɨɞɟɣɫɬɜɢɟɦ
ɫ ɞɪɭɝɢɦɢ ɱɚɫɬɹɦɢ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɢ ɫɪɟɞɵ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ. ɗɬɢ ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ ɩɨɦɨɝɭɬ ɜɚɦ ɧɚɢɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɬɚɤɢɦ ɦɨɳɧɵɦ ɢɧɫɬɪɭɦɟɧɬɚɪɢɟɦ
ɢ ɢɡɛɟɠɚɬɶ ɜɨɡɦɨɠɧɵɯ ɧɟɩɪɢɹɬɧɨɫɬɟɣ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 58 — “ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɮɭɧɤ-
ɰɢɢ ɜ ɪɚɡɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ, ɟɫɥɢ ɬɨɥɶɤɨ ɨɧɢ ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɜɦɟɫɬɧɨɣ ɪɚɛɨɬɵ”.
56. Обеспечьте бессбойную функцию обмена 117
Стр. 117
57. Храните типы и их свободный интерфейс
в одном пространстве имен
Резюме
Ɏɭɧɤɰɢɢ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ ɢ ɪɚɡɪɚɛɨɬɚɧɧɵɟ ɤɚɤ ɱɚɫɬɶ ɢɧɬɟɪɮɟɣɫɚ ɤɥɚɫɫɚ X (ɜ ɨɫɨ-
ɛɟɧɧɨɫɬɢ ɨɩɟɪɚɬɨɪɵ ɢ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɮɭɧɤɰɢɢ), ɞɨɥɠɧɵ ɛɵɬɶ ɨɩɪɟɞɟɥɟɧɵ ɜ ɬɨɦ ɠɟ ɩɪɨ-
ɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ ɢ X, ɱɬɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɢɯ ɤɨɪɪɟɤɬɧɵɣ ɜɵɡɨɜ.
Ɉɬɤɪɵɬɵɣ ɢɧɬɟɪɮɟɣɫ ɤɥɚɫɫɚ ɨɛɪɚɡɭɸɬ ɧɟ ɬɨɥɶɤɨ ɨɬɤɪɵɬɵɟ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ, ɧɨ ɢ ɮɭɧɤɰɢɢ,
ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ. ɉɪɢɧɰɢɩ ɂɧɬɟɪɮɟɣɫɚ ɝɥɚɫɢɬ: ɞɥɹ ɤɥɚɫɫɚ X ɜɫɟ ɮɭɧɤɰɢɢ (ɜɤɥɸɱɚɹ
ɮɭɧɤɰɢɢ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ), ɤɨɬɨɪɵɟ “ɭɩɨɦɢɧɚɸɬ X” ɢ “ɩɨɫɬɚɜɥɹɸɬɫɹ ɜɦɟɫɬɟ ɫ X”
ɜ ɨɞɧɨɦ ɢ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɹɜɥɹɸɬɫɹ ɥɨɝɢɱɟɫɤɨɣ ɱɚɫɬɶɸ X, ɩɨɫɤɨɥɶɤɭ ɨɛɪɚɡɭɸɬ
ɱɚɫɬɶ ɢɧɬɟɪɮɟɣɫɚ X (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44 ɢ [Sutter00]).
əɡɵɤ C++ ɫɩɪɨɟɤɬɢɪɨɜɚɧ ɫ ɹɜɧɵɦ ɭɱɟɬɨɦ ɉɪɢɧɰɢɩɚ ɂɧɬɟɪɮɟɣɫɚ. ɉɪɢɱɢɧɚ, ɩɨ ɤɨɬɨɪɨɣ
ɜ ɹɡɵɤ ɞɨɛɚɜɥɟɧ ɩɨɢɫɤ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ (argument-dependent lookup — ADL), ɢɡɜɟɫɬ-
ɧɵɣ ɬɚɤɠɟ ɤɚɤ ɩɨɢɫɤ Ʉɺɧɢɝɚ, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨɛɵ ɨɛɟɫɩɟɱɢɬɶ ɤɨɞɭ, ɢɫɩɨɥɶɡɭɸɳɟɦɭ
ɨɛɴɟɤɬ x ɬɢɩɚ X, ɜɨɡɦɨɠɧɨɫɬɶ ɪɚɛɨɬɚɬɶ ɫ ɱɚɫɬɶɸ ɟɝɨ ɢɧɬɟɪɮɟɣɫɚ, ɫɨɫɬɨɹɳɟɣ ɢɡ ɮɭɧɤɰɢɣ, ɧɟ
ɹɜɥɹɸɳɢɯɫɹ ɱɥɟɧɚɦɢ (ɧɚɩɪɢɦɟɪ, ɢɧɫɬɪɭɤɰɢɹ cout << x ɢɫɩɨɥɶɡɭɟɬ ɨɩɟɪɚɬɨɪ operator<<,
ɤɨɬɨɪɵɣ ɧɟ ɹɜɥɹɟɬɫɹ ɱɥɟɧɨɦ ɤɥɚɫɫɚ X) ɬɚɤ ɠɟ ɥɟɝɤɨ, ɤɚɤ ɢ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ (ɧɚɩɪɢɦɟɪ, ɜɵɡɨɜ
x.f() ɧɟ ɬɪɟɛɭɟɬ ɜɵɩɨɥɧɟɧɢɹ ɫɩɟɰɢɚɥɶɧɨɝɨ ɩɨɢɫɤɚ, ɩɨɫɤɨɥɶɤɭ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɩɨɢɫɤ f ɜɵɩɨɥ-
ɧɹɟɬɫɹ ɜ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ X). ADL ɨɛɟɫɩɟɱɢɜɚɟɬ ɞɥɹ ɫɜɨɛɨɞɧɵɯ ɮɭɧɤɰɢɣ, ɤɨɬɨɪɵɟ ɩɨɥɭɱɚ-
ɸɬ ɨɛɴɟɤɬ X ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɚ ɢ ɩɨɫɬɚɜɥɹɸɬɫɹ ɜɦɟɫɬɟ ɫ ɨɩɪɟɞɟɥɟɧɢɟɦ X, ɬɭ ɠɟ ɩɪɨɫɬɨɬɭ
ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɱɬɨ ɢ ɞɥɹ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɢɧɬɟɪɮɟɣɫɚ X. Ɉɞɧɢɦ ɢɡ ɝɥɚɜɧɵɯ ɦɨɬɢɜɨɜ ɩɪɢɧɹ-
ɬɢɹ ADL ɛɵɥ, ɜ ɱɚɫɬɧɨɫɬɢ, ɤɥɚɫɫ std::string (ɫɦ. [Sutter00]).
Ɋɚɫɫɦɨɬɪɢɦ ɤɥɚɫɫ X, ɨɩɪɟɞɟɥɟɧɧɵɣ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ N:
class X {
public:
void f();
};
X operator+( const X&, const X& );
ȼ ɜɵɡɵɜɚɸɳɟɣ ɮɭɧɤɰɢɢ ɨɛɵɱɧɨ ɩɢɲɟɬɫɹ ɤɨɞ ɧɚɩɨɞɨɛɢɟ x3 = x1+x2, ɝɞɟ x1, x2 ɢ x3 —
ɨɛɴɟɤɬɵ ɬɢɩɚ X. ȿɫɥɢ ɨɩɟɪɚɬɨɪ operator+ ɨɛɴɹɜɥɟɧ ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ ɢ X,
ɧɢɤɚɤɢɯ ɩɪɨɛɥɟɦ ɧɟ ɜɨɡɧɢɤɚɟɬ, ɢ ɬɚɤɨɣ ɤɨɞ ɨɬɥɢɱɧɨ ɪɚɛɨɬɚɟɬ, ɩɨɫɤɨɥɶɤɭ ɨɩɟɪɚɬɨɪ
operator+ ɛɭɞɟɬ ɥɟɝɤɨ ɧɚɣɞɟɧ ɫ ɩɨɦɨɳɶɸ ADL.
ȿɫɥɢ ɠɟ ɨɩɟɪɚɬɨɪ operator+ ɧɟ ɨɛɴɹɜɥɟɧ ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ ɢ X, ɜɵɡɵ-
ɜɚɸɳɢɣ ɤɨɞ ɪɚɛɨɬɚɬɶ ɧɟ ɛɭɞɟɬ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɢɦɟɟɬɫɹ ɞɜɚ ɫɩɨɫɨɛɚ ɡɚɫɬɚɜɢɬɶ ɟɝɨ ɡɚɪɚɛɨɬɚɬɶ.
ɉɟɪɜɵɣ ɫɨɫɬɨɢɬ ɜ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɹɜɧɨ ɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ
x3 = N::operator+( x1, x2 );
Ƚɪɭɫɬɧɚɹ ɤɚɪɬɢɧɚ — ɧɟɜɨɡɦɨɠɧɨɫɬɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɫɬɟɫɬɜɟɧɧɵɣ ɫɢɧɬɚɤɫɢɫ ɨɩɟɪɚɬɨɪɚ, ɤɨɬɨ-
ɪɵɣ, ɫɨɛɫɬɜɟɧɧɨ, ɢ ɛɵɥ ɝɥɚɜɧɨɣ ɰɟɥɶɸ ɜɜɟɞɟɧɢɹ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɨɜ ɜ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨ-
ɜɚɧɢɹ. Ⱦɪɭɝɨɣ ɫɩɨɫɨɛ ɡɚɫɬɚɜɢɬɶ ɪɚɛɨɬɚɬɶ ɩɪɢɜɟɞɟɧɧɵɣ ɪɚɧɟɟ ɤɨɞ — ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɧɫɬɪɭɤ-
ɰɢɸ using:
using N::operator+;
// ǳǶǳ: using namespace N;
x3 = x1 + x2;
118 Пространства имен и модули
Стр. 118
ɉɪɢɦɟɧɟɧɢɟ using — ɫɨɜɟɪɲɟɧɧɨ ɧɨɪɦɚɥɶɧɚɹ ɢ ɩɪɢɟɦɥɟɦɚɹ ɜɟɳɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 59),
ɧɨ ɜɫɟ ɩɪɨɛɥɟɦɵ ɪɟɲɚɸɬɫɹ ɝɨɪɚɡɞɨ ɩɪɨɳɟ, ɟɫɥɢ ɚɜɬɨɪ X ɢɡɧɚɱɚɥɶɧɨ ɩɨɫɬɭɩɚɟɬ ɤɨɪɪɟɤɬɧɨ
ɢ ɩɨɦɟɳɚɟɬ ɨɩɟɪɚɬɨɪ operator+, ɪɚɛɨɬɚɸɳɢɣ ɫ ɨɛɴɟɤɬɚɦɢ X, ɜ ɬɨ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ,
ɝɞɟ ɧɚɯɨɞɢɬɫɹ X.
“Ɉɛɨɪɨɬɧɚɹ ɫɬɨɪɨɧɚ” ɷɬɨɝɨ ɜɨɩɪɨɫɚ ɪɚɫɫɦɚɬɪɢɜɚɟɬɫɹ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 58.
Примеры
ɉɪɢɦɟɪ 1. Ɉɩɟɪɚɬɨɪɵ. Ɉɩɟɪɚɬɨɪɵ ɪɚɛɨɬɵ ɫ ɩɨɬɨɤɚɦɢ operator<< ɢ operator>> ɞɥɹ
ɨɛɴɟɤɬɨɜ ɧɟɤɨɬɨɪɨɝɨ ɤɥɚɫɫɚ X, ɜɟɪɨɹɬɧɨ, ɨɬɧɨɫɹɬɫɹ ɤ ɧɚɢɛɨɥɟɟ ɹɪɤɢɦ ɩɪɢɦɟɪɚɦ ɮɭɧɤɰɢɣ, ɤɨɬɨ-
ɪɵɟ ɜɩɨɥɧɟ ɨɱɟɜɢɞɧɨ ɹɜɥɹɸɬɫɹ ɱɚɫɬɶɸ ɢɧɬɟɪɮɟɣɫɚ ɤɥɚɫɫɚ X, ɧɨ ɩɪɢ ɷɬɨɦ ɜɫɟɝɞɚ ɩɪɟɞɫɬɚɜɥɹɸɬ
ɫɨɛɨɣ ɫɜɨɛɨɞɧɵɟ ɮɭɧɤɰɢɢ (ɷɬɨ ɨɛɹɡɚɬɟɥɶɧɨɟ ɭɫɥɨɜɢɟ, ɩɨɫɤɨɥɶɤɭ ɥɟɜɵɣ ɚɪɝɭɦɟɧɬ ɷɬɢɯ ɨɩɟɪɚɬɨ-
ɪɨɜ — ɩɨɬɨɤ, ɚ ɧɟ ɨɛɴɟɤɬ X). Ɍɚ ɠɟ ɚɪɝɭɦɟɧɬɚɰɢɹ ɩɪɢɦɟɧɢɦɚ ɢ ɤ ɞɪɭɝɢɦ ɨɩɟɪɚɬɨɪɚɦ, ɧɟ ɹɜɥɹɸ-
ɳɢɦɫɹ ɱɥɟɧɚɦɢ X. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲɢ ɨɩɟɪɚɬɨɪɵ ɧɚɯɨɞɹɬɫɹ ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ
ɢ ɤɥɚɫɫ, ɫ ɤɨɬɨɪɵɦ ɨɧɢ ɪɚɛɨɬɚɸɬ. ȿɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɜɵɛɨɪɚ, ɥɭɱɲɟ ɞɟɥɚɬɶ ɨɩɟɪɚɬɨɪɵ
ɢ ɜɫɟ ɩɪɨɱɢɟ ɮɭɧɤɰɢɢ ɧɟ ɱɥɟɧɚɦɢ ɢ ɧɟ ɞɪɭɡɶɹɦɢ ɤɥɚɫɫɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44).
ɉɪɢɦɟɪ 2. ɉɪɨɱɢɟ ɮɭɧɤɰɢɢ. ȿɫɥɢ ɚɜɬɨɪ X ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɢɦɟɧɨɜɚɧɧɵɟ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɟ
ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɩɨɥɭɱɚɸɬ ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɨɜ ɨɛɴɟɤɬɵ X, ɨɧɢ ɞɨɥɠɧɵ ɧɚɯɨɞɢɬɶɫɹ ɜ ɬɨɦ
ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ ɢ X. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɨɛɴɟɤ-
ɬɵ X, ɛɭɞɟɬ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɪɚɛɨɬɚɬɶ ɫ ɷɬɢɦɢ ɢɦɟɧɨɜɚɧɧɵɦɢ ɮɭɧɤɰɢɹɦɢ ɛɟɡ ɹɜɧɨɣ ɤɜɚɥɢɮɢɤɚ-
ɰɢɢ ɢɯ ɢɦɟɧ ɢɥɢ ɩɪɢɦɟɧɟɧɢɹ ɢɧɫɬɪɭɤɰɢɢ using.
Ссылки
[Stroustrup00] §8.2, §10.3.2, §11.2.4 • [Sutter00] §31-34
57. Храните типы и их свободный интерфейс в одном пространстве имен 119
Стр. 119
58.Храните типы и функции вразныхпространствахимен...
58. Храните типы и функции в разных

пространствах имен, если только они
не предназначены для совместной работы
58.Храните типы и функции вразныхпространствахимен...
Резюме
Ɉɛɟɪɟɝɚɣɬɟ ɜɚɲɢ ɬɢɩɵ ɨɬ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɝɨ ɩɨɢɫɤɚ, ɡɚɜɢɫɹɳɟɝɨ ɨɬ ɚɪɝɭɦɟɧɬɨɜ
(argument-dependent lookup — ADL, ɢɡɜɟɫɬɧɵɣ ɬɚɤɠɟ ɤɚɤ ɩɨɢɫɤ Ʉɺɧɢɝɚ); ɨɞɧɚɤɨ ɩɪɟɞɧɚɦɟ-
ɪɟɧɧɵɣ ɩɨɢɫɤ ɞɨɥɠɟɧ ɡɚɜɟɪɲɚɬɶɫɹ ɭɫɩɟɲɧɨ. ɗɬɨɝɨ ɦɨɠɧɨ ɞɨɛɢɬɶɫɹ ɩɭɬɟɦ ɪɚɡɦɟɳɟɧɢɹ ɬɢɩɨɜ
ɜ ɫɜɨɢɯ ɫɨɛɫɬɜɟɧɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ (ɜɦɟɫɬɟ ɫ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɫɜɹɡɚɧɧɵɦɢ ɫ ɧɢɦɢ ɫɜɨ-
ɛɨɞɧɵɦɢ ɮɭɧɤɰɢɹɦɢ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ɂɡɛɟɝɚɣɬɟ ɩɨɦɟɳɟɧɢɹ ɬɢɩɨɜ ɜ ɬɟ ɠɟ ɩɪɨɫɬɪɚɧ-
ɫɬɜɚ ɢɦɟɧ, ɱɬɨ ɢ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɢɥɢ ɨɩɟɪɚɬɨɪɨɜ).
ɋɥɟɞɭɹ ɞɚɧɧɨɦɭ ɫɨɜɟɬɭ, ɜɵ ɫɦɨɠɟɬɟ ɢɡɛɟɠɚɬɶ ɬɪɭɞɧɨ ɨɛɧɚɪɭɠɢɜɚɟɦɵɯ ɨɲɢɛɨɤ ɜ ɜɚɲɟɦ
ɤɨɞɟ ɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɪɚɡɛɢɪɚɬɶɫɹ ɫ ɨɱɟɧɶ ɬɨɧɤɢɦɢ ɦɨɦɟɧɬɚɦɢ ɹɡɵɤɚ, ɫ ɤɨɬɨɪɵɦɢ ɜɵ ɩɪɨɫɬɨ
ɧɟ ɞɨɥɠɧɵ ɫɬɚɥɤɢɜɚɬɶɫɹ.
ȼɨɬ ɪɟɚɥɶɧɵɣ ɩɪɢɦɟɪ, ɤɨɬɨɪɵɣ ɛɵɥ ɨɩɭɛɥɢɤɨɜɚɧ ɜ ɝɪɭɩɩɟ ɧɨɜɨɫɬɟɣ:
#include <vector>
namespace N {
struct X { };
template<typename T>
int* operator+(T , unsigned) {/* ǘǰǵǹǽǹǻȆǰ ǯǰǴǼǽǭǳȊ */}
}
int main() {
std::vector<N::X> v(5);
v[0];
}
ɂɧɫɬɪɭɤɰɢɹ v[0]; ɤɨɦɩɢɥɢɪɭɟɬɫɹ ɜ ɧɟɤɨɬɨɪɵɯ ɪɟɚɥɢɡɚɰɢɹɯ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ, ɧɨ
ɧɟ ɜɨ ɜɫɟɯ. ɉɨɩɪɨɛɭɟɦ ɤɪɚɬɤɨ ɩɟɪɟɫɤɚɡɚɬɶ ɷɬɭ ɞɥɢɧɧɭɸ ɢɫɬɨɪɢɸ. Ɉɱɟɧɶ ɬɨɧɤɚɹ ɩɪɨɛɥɟɦɚ ɫɜɹ-
ɡɚɧɚ ɫ ɬɟɦ, ɱɬɨ ɜɧɭɬɪɢ ɛɨɥɶɲɢɧɫɬɜɚ ɪɟɚɥɢɡɚɰɢɣ vector<T>::operator[] ɫɩɪɹɬɚɧ ɤɨɞ ɧɚ-
ɩɨɞɨɛɢɟ v.begin()+n, ɢ ɩɨɢɫɤ ɢɦɟɧ ɞɥɹ ɮɭɧɤɰɢɢ operator+ ɦɨɠɟɬ ɞɨɫɬɢɱɶ ɩɪɨɫɬɪɚɧɫɬɜɚ
ɢɦɟɧ (ɜ ɧɚɲɟɦ ɫɥɭɱɚɟ N) ɬɢɩɚ, ɞɥɹ ɤɨɬɨɪɨɝɨ ɢɧɫɬɚɧɰɢɪɨɜɚɧ ɜɟɤɬɨɪ (ɜ ɧɚɲɟɦ ɫɥɭɱɚɟ X). Ⱦɨɫ-
ɬɢɝɧɟɬ ɥɢ ɩɨɢɫɤ ɷɬɨɝɨ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢɥɢ ɧɟɬ — ɡɚɜɢɫɢɬ ɨɬ ɬɨɝɨ, ɤɚɤ ɨɩɪɟɞɟɥɟɧ
vector<T>::iterator ɜ ɞɚɧɧɨɣ ɜɟɪɫɢɢ ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ. Ɉɞɧɚɤɨ ɟɫɥɢ
ɩɨɢɫɤ ɞɨɫɬɢɝɚɟɬ N, ɬɨ ɡɞɟɫɶ ɨɧ ɧɚɯɨɞɢɬ N::operator+. ɇɚɤɨɧɟɰ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɢɫɩɨɥɶ-
ɡɭɟɦɵɯ ɬɢɩɨɜ, ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɩɪɨɫɬɨ ɩɨɫɱɢɬɚɬɶ, ɱɬɨ ɞɥɹ vector<T>::iterator ɨɩɟɪɚ-
ɬɨɪ N::operator+ ɢɦɟɟɬ ɥɭɱɲɟɟ ɫɨɨɬɜɟɬɫɬɜɢɟ, ɱɟɦ ɨɩɟɪɚɬɨɪ std::operator+ ɢɡ ɪɟɚɥɢɡɚ-
ɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ (ɤɨɬɨɪɵɣ ɢ ɞɨɥɠɟɧ ɛɵɥ ɛɵɬɶ ɜɵɡɜɚɧ). (Ɉɞɢɧ ɢɡ ɫɩɨɫɨɛɨɜ ɢɡɛɟ-
ɠɚɬɶ ɬɚɤɨɣ ɧɟɩɪɢɹɬɧɨɫɬɢ ɜ ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ — ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɞ
v.begin()+n ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨ ɨɧ ɜɧɨɫɢɬ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɭɸ ɬɨɱɤɭ ɧɚɫɬɪɨɣɤɢ: ɥɢɛɨ ɧɚɞɨ
ɢɡɦɟɧɢɬɶ ɤɨɞ ɬɚɤ, ɱɬɨɛɵ ɬɢɩ v.begin() ɧɢɤɚɤɢɦ ɨɛɪɚɡɨɦ ɧɟ ɡɚɜɢɫɟɥ ɨɬ ɩɚɪɚɦɟɬɪɚ ɲɚɛɥɨɧɚ,
ɥɢɛɨ ɜɵɡɨɜ operator+ ɫɥɟɞɭɟɬ ɩɟɪɟɩɢɫɚɬɶ ɫ ɭɤɚɡɚɧɢɟɦ ɩɨɥɧɨɝɨ ɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɨɝɨ ɢɦɟɧɢ.
ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 65.)
Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɜɪɹɞ ɥɢ ɜɚɦ ɭɞɚɫɬɫɹ ɜɵɹɜɢɬɶ ɢɫɬɢɧɧɭɸ ɩɪɢɱɢɧɭ ɜɵɜɨɞɢɦɨɝɨ ɫɨɨɛɳɟɧɢɹ ɨɛ
ɨɲɢɛɤɟ. ȿɫɥɢ ɜɚɦ, ɤɨɧɟɱɧɨ, ɩɨɜɟɡɟɬ ɢ ɜɵ ɩɨɥɭɱɢɬɟ ɷɬɨ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɲɢɛɤɟ, ɬɚɤ ɤɚɤ ɜ ɫɥɭɱɚɟ
ɧɟɜɟɡɟɧɢɹ ɜɵɛɪɚɧɧɵɣ ɨɩɟɪɚɬɨɪ N::operator+ ɨɤɚɠɟɬɫɹ, ɤ ɧɟɫɱɚɫɬɶɸ, ɜɩɨɥɧɟ ɩɨɞɯɨɞɹɳɢɦ
Стр. 120
ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɤɨɦɩɢɥɹɬɨɪɚ, ɢ ɩɪɨɝɪɚɦɦɚ ɫɤɨɦɩɢɥɢɪɭɟɬɫɹ ɭɫɩɟɲɧɨ, ɧɨ ɜɨɬ ɪɟɡɭɥɶɬɚɬɵ ɟɟ ɪɚɛɨ-
ɬɵ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɫɨɜɟɪɲɟɧɧɨ ɧɟɨɠɢɞɚɧɧɵɦɢ…
ȼɵ ɞɭɦɚɟɬɟ, ɱɬɨ ɜɚɦ ɧɟ ɩɪɢɯɨɞɢɥɨɫɶ ɫ ɷɬɢɦ ɫɬɚɥɤɢɜɚɬɶɫɹ? ɉɨɩɪɨɛɭɣɬɟ ɜɫɩɨɦɧɢɬɶ, ɛɵɜɚɥɨ
ɥɢ ɬɚɤɨɟ ɜ ɜɚɲɟɣ ɩɪɚɤɬɢɤɟ, ɱɬɨ ɜɚɲ ɤɨɞ, ɧɚɩɪɢɦɟɪ, ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟ-
ɤɢ ɩɪɢɜɨɞɢɥ ɤ ɭɞɢɜɢɬɟɥɶɧɵɦ ɢ ɧɟɩɨɧɹɬɧɵɦ ɨɲɢɛɤɚɦ ɤɨɦɩɢɥɹɰɢɢ? Ⱥ ɩɨɫɥɟ ɬɨɝɨ ɤɚɤ ɜɵ ɫɥɟɝ-
ɤɚ ɦɟɧɹɥɢ ɜɚɲ ɤɨɞ, ɩɨɪɨɣ ɩɪɨɫɬɨ ɦɟɧɹɹ ɦɟɫɬɚɦɢ ɨɬɞɟɥɶɧɵɟ ɤɭɫɤɢ ɤɨɞɚ, ɜɫɟ ɜɞɪɭɝ ɧɚɱɢɧɚɥɨ
ɪɚɛɨɬɚɬɶ ɢ ɭ ɜɚɫ ɨɫɬɚɜɚɥɨɫɶ ɬɨɥɶɤɨ ɧɟɛɨɥɶɲɨɟ ɧɟɞɨɭɦɟɧɢɟ ɩɨ ɩɨɜɨɞɭ ɝɥɭɩɨɝɨ ɤɨɦɩɢɥɹɬɨɪɚ,
ɤɨɬɨɪɵɣ ɡɚɩɭɬɚɥɫɹ ɜ ɬɪɟɯ ɫɬɪɨɤɚɯ? ɉɪɚɤɬɢɱɟɫɤɢ ɜɫɟ ɦɵ ɩɨɩɚɞɚɥɢ ɜ ɩɨɞɨɛɧɵɟ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ
ɩɪɢɱɢɧɨɣ ɧɟɩɪɢɹɬɧɨɫɬɟɣ ɫɬɚɧɨɜɢɥɚɫɶ ɪɚɫɫɦɚɬɪɢɜɚɟɦɚɹ ɩɪɨɛɥɟɦɚ, ɬ.ɟ. ɤɨɝɞɚ ADL ɧɚɯɨɞɢɥ
ɢɦɟɧɚ ɢɡ ɧɟɩɨɞɯɨɞɹɳɟɝɨ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɩɪɨɫɬɨ ɩɨɬɨɦɭ, ɱɬɨ ɬɢɩɵ ɢɡ ɷɬɢɯ ɩɪɨɫɬɪɚɧɫɬɜ
ɢɦɟɧ ɢɫɩɨɥɶɡɨɜɚɥɢɫɶ ɩɨɛɥɢɡɨɫɬɢ ɞɪɭɝ ɨɬ ɞɪɭɝɚ.
ɗɬɚ ɩɪɨɛɥɟɦɚ ɜɨɡɧɢɤɚɟɬ ɧɟ ɬɨɥɶɤɨ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ. ȼ C++ ɫ ɧɟɣ
ɦɨɠɧɨ ɫɬɨɥɤɧɭɬɶɫɹ (ɢ ɷɬɨ ɱɚɫɬɨ ɩɪɨɢɫɯɨɞɢɬ ɧɚ ɩɪɚɤɬɢɤɟ) ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɬɢɩɨɜ, ɨɩɪɟɞɟɥɟɧ-
ɧɵɯ ɜ ɬɟɯ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ, ɱɬɨ ɢ ɮɭɧɤɰɢɢ (ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɢɥɢ ɨɩɟɪɚ-
ɬɨɪɵ), ɧɟ ɫɜɹɡɚɧɧɵɟ ɫ ɞɚɧɧɵɦɢ ɬɢɩɚɦɢ. ɉɨɫɬɚɪɚɣɬɟɫɶ ɧɟ ɩɨɩɚɞɚɬɶɫɹ ɜ ɷɬɭ ɥɨɜɭɲɤɭ.
Ɉɫɧɨɜɧɨɣ ɜɵɜɨɞ — ɜɚɦ ɧɟ ɧɚɞɨ ɡɧɚɬɶ ɜɫɟ ɷɬɢ ɬɨɧɤɨɫɬɢ. ɉɪɨɫɬɟɣɲɢɣ ɩɭɬɶ ɢɡɛɟɠɚɬɶ ɷɬɨɣ
ɤɚɬɟɝɨɪɢɢ ɩɪɨɛɥɟɦ — ɷɬɨ ɜɨɨɛɳɟ ɢɡɛɟɝɚɬɶ ɪɚɡɦɟɳɟɧɢɹ ɫɜɨɛɨɞɧɵɯ ɮɭɧɤɰɢɣ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ
ɱɚɫɬɶɸ ɢɧɬɟɪɮɟɣɫɚ ɬɢɩɚ X, ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɝɞɟ ɧɚɯɨɞɢɬɫɹ X, ɢ ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɧɢ-
ɤɨɝɞɚ ɧɟ ɩɨɦɟɳɚɬɶ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɢɥɢ ɨɩɟɪɚɬɨɪɨɜ ɜ ɬɨ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɱɬɨ ɢ ɩɨɥɶ-
ɡɨɜɚɬɟɥɶɫɤɢɣ ɬɢɩ.
ɉɪɢɦɟɱɚɧɢɟ. Ⱦɚ, ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɩɨɦɟɳɚɟɬ ɚɥɝɨɪɢɬɦɵ ɢ ɞɪɭɝɢɟ ɲɚɛɥɨɧɵ
ɮɭɧɤɰɢɣ, ɬɚɤɢɯ ɤɚɤ copy ɢɥɢ distance, ɜ ɬɨ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɱɬɨ ɢ ɦɧɨɠɟɫɬɜɨ ɬɢɩɨɜ,
ɬɚɤɢɯ ɤɚɤ pair ɢɥɢ vector. ȼɫɟ ɨɧɢ ɧɚɯɨɞɹɬɫɹ ɜ ɨɞɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ. ɗɬɨ ɧɟɭɞɚɱɧɨɟ
ɪɟɲɟɧɢɟ, ɤɨɬɨɪɨɟ ɜɵɡɵɜɚɟɬ ɨɩɢɫɚɧɧɵɟ ɜɟɫɶɦɚ ɬɨɧɤɢɟ ɢ ɬɪɭɞɧɨ ɥɨɤɚɥɢɡɭɟɦɵɟ ɩɪɨɛɥɟɦɵ.
Ʉ ɫɱɚɫɬɶɸ, ɬɟɩɟɪɶ ɭ ɧɚɫ ɛɨɥɶɲɟ ɨɩɵɬɚ ɢ ɦɵ ɡɧɚɟɦ, ɤɚɤ ɫɥɟɞɭɟɬ ɩɨɫɬɭɩɚɬɶ. ɇɟ ɞɟɥɚɣɬɟ ɬɚɤ, ɤɚɤ
ɫɞɟɥɚɧɨ ɜ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɟ.
“Ɉɛɨɪɨɬɧɚɹ ɫɬɨɪɨɧɚ” ɷɬɨɝɨ ɜɨɩɪɨɫɚ ɪɚɫɫɦɚɬɪɢɜɚɟɬɫɹ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 57.
Ссылки
[Stroustrup00] §10.3.2, §11.2.4 • [Sutter00] §34 • [Sutter02] §39-40
58. Храните типы и функции в разных пространствах имен... 121
Стр. 121
59. Не используйте using для пространств имен в заголовочных файлах...
59. Не используйте using для пространств

имен в заголовочных файлах или перед
директивой #include
59. Не используйте using для пространств имен в заголовочных файлах...
Резюме
Ⱦɢɪɟɤɬɢɜɚ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɫɨɡɞɚɧɚ ɞɥɹ ɜɚɲɟɝɨ ɭɞɨɛɫɬɜɚ, ɚ ɧɟ ɞɥɹ ɝɨɥɨɜɧɨɣ
ɛɨɥɢ ɞɪɭɝɢɯ. ɇɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɨɛɴɹɜɥɟɧɢɹ ɢɥɢ ɞɢɪɟɤɬɢɜɵ using ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ
#include.
ȼɵɜɨɞ: ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɞɢɪɟɤɬɢɜɵ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɢɥɢ using-ɨɛɴɹɜɥɟɧɢɹ
ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ. ȼɦɟɫɬɨ ɷɬɨɝɨ ɩɨɥɧɨɫɬɶɸ ɤɜɚɥɢɮɢɰɢɪɭɣɬɟ ɜɫɟ ɢɦɟɧɚ. (ȼɬɨɪɨɟ ɩɪɚɜɢ-
ɥɨ ɫɥɟɞɭɟɬ ɢɡ ɩɟɪɜɨɝɨ, ɩɨɫɤɨɥɶɤɭ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɟ ɦɨɝɭɬ ɡɧɚɬɶ, ɤɚɤɢɟ ɞɪɭɝɢɟ ɞɢɪɟɤɬɢ-
ɜɵ #include ɦɨɝɭɬ ɩɨɹɜɢɬɶɫɹ ɜ ɬɟɤɫɬɟ ɩɨɫɥɟ ɧɢɯ.)
ȼɤɪɚɬɰɟ: ɜɵ ɦɨɠɟɬɟ ɢ ɞɨɥɠɧɵ ɫɜɨɛɨɞɧɨ ɢ ɛɟɡ ɨɝɪɚɧɢɱɟɧɢɣ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɴɹɜɥɟɧɢɹ
ɢ ɞɢɪɟɤɬɢɜɵ using ɜ ɫɜɨɢɯ ɮɚɣɥɚɯ ɪɟɚɥɢɡɚɰɢɢ ɩɨɫɥɟ ɞɢɪɟɤɬɢɜ #include. ɇɟɫɦɨɬɪɹ ɧɚ ɩɨ-
ɜɬɨɪɹɸɳɢɟɫɹ ɡɚɹɜɥɟɧɢɹ ɢɯ ɩɪɨɬɢɜɧɢɤɨɜ, ɨɛɴɹɜɥɟɧɢɹ ɢ ɞɢɪɟɤɬɢɜɵ using ɧɟ ɹɜɥɹɸɬɫɹ ɡɥɨɦ ɢ
ɧɟ ɩɪɨɬɢɜɨɪɟɱɚɬ ɰɟɥɢ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ. Ɉɧɢ ɩɪɨɫɬɨ ɞɟɥɚɸɬ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɛɨɥɟɟ ɭɞɨɛ-
ɧɵɦɢ ɜ ɢɫɩɨɥɶɡɨɜɚɧɢɢ.
ɉɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɩɪɟɞɫɬɚɜɥɹɸɬ ɦɨɳɧɨɟ ɫɪɟɞɫɬɜɨ ɞɥɹ ɭɫɬɪɚɧɟɧɢɹ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɢ
ɢɦɟɧ. ȼ ɛɨɥɶɲɢɧɫɬɜɟ ɫɥɭɱɚɟɜ ɪɚɡɥɢɱɧɵɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɜɵɛɢɪɚɸɬ ɪɚɡɥɢɱɧɵɟ ɢɦɟɧɚ ɞɥɹ ɫɜɨ-
ɢɯ ɬɢɩɨɜ ɢ ɮɭɧɤɰɢɣ, ɧɨ ɜ ɬɨɦ ɪɟɞɤɨɦ ɫɥɭɱɚɟ, ɤɨɝɞɚ ɨɧɢ ɜɵɛɪɚɥɢ ɨɞɢɧɚɤɨɜɵɟ ɢɦɟɧɚ, ɢ ɨɧɢ
ɞɨɥɠɧɵ ɜɦɟɫɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜ ɧɟɤɨɬɨɪɨɦ ɤɨɞɟ, ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɩɨɡɜɨɥɹɸɬ ɢɡɛɟɠɚɬɶ
ɤɨɥɥɢɡɢɣ. Ⱦɥɹ ɷɬɨɝɨ ɞɨɫɬɚɬɨɱɧɨ, ɱɬɨɛɵ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɹɜɧɨ ɤɜɚɥɢɮɢɰɢɪɨɜɚɥ ɢɦɹ, ɭɤɚɡɚɜ,
ɢɦɹ ɢɡ ɤɚɤɨɝɨ ɢɦɟɧɧɨ ɩɪɨɫɬɪɚɧɫɬɜɚ ɞɨɥɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜ ɬɨɦ ɢɥɢ ɢɧɨɦ ɫɥɭɱɚɟ. Ɉɞɧɚɤɨ
ɜ ɩɨɞɚɜɥɹɸɳɟɦ ɛɨɥɶɲɢɧɫɬɜɟ ɫɥɭɱɚɟɜ ɧɢɤɚɤɨɣ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɢ ɢɦɟɧ ɧɟ ɧɚɛɥɸɞɚɟɬɫɹ. ɉɨ-
ɷɬɨɦɭ ɜɩɨɥɧɟ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɢɪɟɤɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using, ɤɨɬɨɪɵɟ ɫɭɳɟɫɬɜɟɧɧɨ ɨɛ-
ɥɟɝɱɚɸɬ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ, ɫɧɢɠɚɹ ɤɨɥɢɱɟɫɬɜɨ ɜɜɨɞɢɦɨɝɨ ɤɨɞɚ (ɩɪɨɝɪɚɦɦɢɫɬɭ
ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɞɢɪɟɤɬɢɜ ɢ ɨɛɴɹɜɥɟɧɢɣ using ɧɟ ɬɪɟɛɭɟɬɫɹ ɜɫɹɤɢɣ ɪɚɡ ɹɜɧɨɟ ɭɩɨɦɢɧɚɧɢɟ
ɬɨɝɨ, ɤ ɤɚɤɨɦɭ ɩɪɨɫɬɪɚɧɫɬɜɭ ɢɦɟɧ ɩɪɢɧɚɞɥɟɠɢɬ ɬɨ ɢɥɢ ɢɧɨɟ ɢɦɹ). ȼ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɤɨɥɥɢɡɢɣ
ɢɦɟɧ ɞɢɪɟɤɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using ɧɟ ɩɪɟɩɹɬɫɬɜɭɸɬ ɭɤɚɡɚɧɢɸ ɩɨɥɧɨɫɬɶɸ ɤɜɚɥɢɮɢɰɢɪɨ-
ɜɚɧɧɵɯ ɢɦɟɧ ɞɥɹ ɪɚɡɪɟɲɟɧɢɹ ɪɟɚɥɶɧɨ ɜɨɡɧɢɤɲɟɣ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɢ.
Ɉɞɧɚɤɨ ɞɢɪɟɤɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɬɨɥɶɤɨ ɞɥɹ ɜɚɲɟɝɨ ɭɞɨɛɫɬɜɚ ɢ ɜɵ
ɧɟ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɯ ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɜɥɢɹɥɢ ɧɚ ɤɚɤɨɣ-ɬɨ ɞɪɭɝɨɣ ɤɨɞ. ȼ ɱɚɫɬɧɨɫɬɢ, ɢɯ
ɧɟɥɶɡɹ ɭɩɨɬɪɟɛɥɹɬɶ ɝɞɟ ɩɨɩɚɥɨ, ɝɞɟ ɡɚ ɧɢɦɢ ɦɨɠɟɬ ɫɥɟɞɨɜɚɬɶ ɟɳɟ ɤɚɤɨɣ-ɬɨ ɫɬɨɪɨɧɧɢɣ ɤɨɞ.
ȼ ɱɚɫɬɧɨɫɬɢ, ɢɯ ɧɟ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ (ɤɨɬɨɪɵɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ
ɜɤɥɸɱɟɧɢɹ ɜ ɧɟɨɝɪɚɧɢɱɟɧɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɮɚɣɥɨɜ ɪɟɚɥɢɡɚɰɢɢ — ɜɵ ɧɟ ɞɨɥɠɧɵ ɜɧɨɫɢɬɶ ɩɭɬɚ-
ɧɢɰɭ ɜ ɡɧɚɱɟɧɢɟ ɤɨɞɚ ɜ ɷɬɢɯ ɮɚɣɥɚɯ) ɢɥɢ ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ #include (ɬɟɦ ɫɚɦɵɦ ɜɵ ɩɨ ɫɭɬɢ
ɜɧɨɫɢɬɟ ɢɯ ɜ ɬɟɤɫɬ ɷɬɢɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ).
Ȼɨɥɶɲɢɧɫɬɜɨ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɢɧɬɭɢɬɢɜɧɨ ɩɨɧɢɦɚɸɬ, ɩɨɱɟɦɭ ɞɢɪɟɤɬɢɜɚ using (ɧɚɩɪɢɦɟɪ,
using namespace A;) ɜɵɡɵɜɚɟɬ ɡɚɝɪɹɡɧɟɧɢɟ ɜ ɫɥɭɱɚɟ ɜɨɡɞɟɣɫɬɜɢɹ ɧɚ ɤɨɞ, ɫɥɟɞɭɸɳɢɣ ɡɚ
ɧɟɣ ɢ ɧɟ ɨɫɜɟɞɨɦɥɟɧɧɵɣ ɨ ɧɚɥɢɱɢɢ ɷɬɨɣ ɞɢɪɟɤɬɢɜɵ: ɩɨɫɤɨɥɶɤɭ ɷɬɚ ɞɢɪɟɤɬɢɜɚ ɩɨɥɧɨɫɬɶɸ ɢɦ-
ɩɨɪɬɢɪɭɟɬ ɨɞɧɨ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ ɜ ɞɪɭɝɨɟ, ɜɤɥɸɱɚɹ ɞɚɠɟ ɬɟ ɢɦɟɧɚ, ɤɨɬɨɪɵɟ ɞɨ ɫɢɯ ɩɨɪ ɧɟ
ɛɵɥɢ ɜɢɞɧɵ, ɩɨɧɹɬɧɨ, ɱɬɨ ɷɬɨ ɦɨɠɟɬ ɥɟɝɤɨ ɢɡɦɟɧɢɬɶ ɫɦɵɫɥ ɫɥɟɞɭɸɳɟɝɨ ɡɚ ɞɢɪɟɤɬɢɜɨɣ ɤɨɞɚ.
Стр. 122
ɇɨ ɜɨɬ ɨɞɧɚ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɨɲɢɛɤɚ: ɦɧɨɝɢɟ ɫɱɢɬɚɸɬ, ɱɬɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɨɛɴɹɜɥɟɧɢɹ
using ɧɚ ɭɪɨɜɧɟ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ (ɧɚɩɪɢɦɟɪ, using N::Widget;) ɜɩɨɥɧɟ ɛɟɡɨɩɚɫɧɨ. Ɉɞ-
ɧɚɤɨ ɷɬɨ ɧɟ ɬɚɤ. Ɍɚɤɢɟ ɨɛɴɹɜɥɟɧɢɹ, ɤɚɤ ɦɢɧɢɦɭɦ, ɨɩɚɫɧɵ, ɩɪɢɱɟɦ ɛɨɥɟɟ ɬɨɧɤɢɦ ɢ ɯɢɬɪɵɦ
ɫɩɨɫɨɛɨɦ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ:
// ǟǻǫǮǷǰǸǽ 1
namespace A {
int f(double);
}
namespace B {
using A::f;
void g();
}
namespace A {
int f(int);
}
void B::g() {
f(1); // ǕǫǵǫȊ ǺǰǻǰǮǻǾǲǵǫ ǬǾǯǰǽ ǭȆǲǭǫǸǫ?
}
Ɂɞɟɫɶ ɨɩɚɫɧɨɫɬɶ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɨɛɴɹɜɥɟɧɢɟ using ɢɫɩɨɥɶɡɭɟɬ ɬɟɤɭɳɢɣ ɫɩɢɫɨɤ
ɢɦɟɧ f ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ A ɜ ɬɨɬ ɦɨɦɟɧɬ, ɤɨɝɞɚ ɷɬɨ ɨɛɴɹɜɥɟɧɢɟ ɜɫɬɪɟɱɚɟɬɫɹ. Ɍɚɤɢɦ ɨɛɪɚ-
ɡɨɦ, ɤɚɤɚɹ ɢɦɟɧɧɨ ɩɟɪɟɝɪɭɡɤɚ ɛɭɞɟɬ ɜɢɞɢɦɚ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ B, ɡɚɜɢɫɢɬ ɨɬ ɬɨɝɨ, ɝɞɟ
ɢɦɟɧɧɨ ɧɚɯɨɞɢɬɫɹ ɩɪɢɜɟɞɟɧɧɵɣ ɤɨɞ ɮɪɚɝɦɟɧɬɨɜ ɢ ɜ ɤɚɤɨɦ ɩɨɪɹɞɤɟ ɨɧ ɫɤɨɦɛɢɧɢɪɨɜɚɧ. (Ɂɞɟɫɶ
ɞɨɥɠɟɧ ɪɚɡɞɚɬɶɫɹ ɩɪɟɞɭɩɪɟɠɞɚɸɳɢɣ ɪɟɜ ɜɚɲɟɣ ɜɧɭɬɪɟɧɧɟɣ ɫɢɪɟɧɵ — “Ɂɚɜɢɫɢɦɨɫɬɶ ɨɬ ɩɨ-
ɪɹɞɤɚ ɟɫɬɶ ɡɥɨ!”) ȼɬɨɪɚɹ ɩɟɪɟɝɪɭɡɤɚ, f(int), ɜ ɛɨɥɶɲɟɣ ɫɬɟɩɟɧɢ ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɜɵɡɨɜɭ f(1),
ɧɨ f(int) ɛɭɞɟɬ ɧɟɜɢɞɢɦɚ ɞɥɹ B::g, ɟɫɥɢ ɟɟ ɨɛɴɹɜɥɟɧɢɟ ɨɤɚɠɟɬɫɹ ɩɨɫɥɟ ɨɛɴɹɜɥɟɧɢɹ using.
Ɋɚɫɫɦɨɬɪɢɦ ɞɜɚ ɱɚɫɬɧɵɯ ɫɥɭɱɚɹ. ɉɭɫɬɶ ɮɪɚɝɦɟɧɬɵ 1, 2 ɢ 3 ɧɚɯɨɞɹɬɫɹ ɜ ɬɪɟɯ ɪɚɡɥɢɱɧɵɯ ɡɚ-
ɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ s1.h, s2.h ɢ s3.h, ɚ ɮɪɚɝɦɟɧɬ 4 — ɜ ɮɚɣɥɟ ɪɟɚɥɢɡɚɰɢɢ s4.cpp, ɤɨɬɨ-
ɪɵɣ ɜɤɥɸɱɚɟɬ ɭɤɚɡɚɧɧɵɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ. Ɍɨɝɞɚ ɫɟɦɚɧɬɢɤɚ B::g ɡɚɜɢɫɢɬ ɨɬ ɩɨɪɹɞɤɚ, ɜ
ɤɨɬɨɪɨɦ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɜɤɥɸɱɟɧɵ ɜ s4.cpp! ȼ ɱɚɫɬɧɨɫɬɢ:
• ɟɫɥɢ s3.h ɢɞɟɬ ɩɟɪɟɞ s2.h, ɬɨ B::g ɛɭɞɟɬ ɜɵɡɵɜɚɬɶ A::f(int);
• ɢɧɚɱɟ ɟɫɥɢ s1.h ɢɞɟɬ ɩɟɪɟɞ s2.h, ɬɨ B::g ɛɭɞɟɬ ɜɵɡɵɜɚɬɶ A::f(double);
• ɢɧɚɱɟ B::g ɧɟ ɛɭɞɟɬ ɤɨɦɩɢɥɢɪɨɜɚɬɶɫɹ ɜɨɜɫɟ.
ȼ ɨɩɢɫɚɧɧɨɣ ɫɢɬɭɚɰɢɢ ɢɦɟɟɬɫɹ ɨɞɢɧ ɜɩɨɥɧɟ ɨɩɪɟɞɟɥɟɧɧɵɣ ɩɨɪɹɞɨɤ, ɩɪɢ ɤɨɬɨɪɨɦ ɜɫɟ ɪɚ-
ɛɨɬɚɟɬ ɬɚɤ, ɤɚɤ ɞɨɥɠɧɨ.
Ⱦɚɜɚɣɬɟ ɬɟɩɟɪɶ ɪɚɫɫɦɨɬɪɢɦ ɫɢɬɭɚɰɢɸ, ɤɨɝɞɚ ɮɪɚɝɦɟɧɬɵ 1, 2, 3 ɢ 4 ɧɚɯɨɞɹɬɫɹ ɜ ɱɟɬɵɪɟɯ
ɪɚɡɥɢɱɧɵɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ s1.h, s2.h, s3.h ɢ s4.h. Ɍɟɩɟɪɶ ɜɫɟ ɫɬɚɧɨɜɢɬɫɹ ɫɭɳɟɫɬ-
ɜɟɧɧɨ ɯɭɠɟ: ɫɟɦɚɧɬɢɤɚ B::g ɡɚɜɢɫɢɬ ɨɬ ɩɨɪɹɞɤɚ ɜɤɥɸɱɟɧɢɹ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ ɧɟ ɬɨɥɶɤɨ
ɜ s4.h, ɧɨ ɢ ɜ ɥɸɛɨɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɜɤɥɸɱɚɟɬ s4.h! ȼ ɱɚɫɬɧɨɫɬɢ, ɮɚɣɥ ɪɟɚɥɢɡɚɰɢɢ
client_code.cpp ɦɨɠɟɬ ɩɵɬɚɬɶɫɹ ɜɤɥɸɱɢɬɶ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɜ ɥɸɛɨɦ ɩɨɪɹɞɤɟ:
• ɟɫɥɢ s3.h ɢɞɟɬ ɩɟɪɟɞ s2.h, ɬɨ B::g ɛɭɞɟɬ ɜɵɡɵɜɚɬɶ A::f(int);
• ɢɧɚɱɟ ɟɫɥɢ s1.h ɢɞɟɬ ɩɟɪɟɞ s2.h, ɬɨ B::g ɛɭɞɟɬ ɜɵɡɵɜɚɬɶ A::f(double);
• ɢɧɚɱɟ B::g ɧɟ ɛɭɞɟɬ ɤɨɦɩɢɥɢɪɨɜɚɬɶɫɹ ɜɨɜɫɟ.
ɋɢɬɭɚɰɢɹ ɫɬɚɥɚ ɯɭɠɟ ɩɨɬɨɦɭ, ɱɬɨ ɞɜɚ ɮɚɣɥɚ ɪɟɚɥɢɡɚɰɢɢ ɦɨɝɭɬ ɜɤɥɸɱɚɬɶ ɡɚɝɨɥɨɜɨɱɧɵɟ
ɮɚɣɥɵ ɜ ɪɚɡɧɨɦ ɩɨɪɹɞɤɟ. ɑɬɨ ɩɪɨɢɡɨɣɞɟɬ, ɟɫɥɢ client_code_1.cpp ɜɤɥɸɱɚɟɬ s1.h, s2.h
ɢ s4.h ɜ ɭɤɚɡɚɧɧɨɦ ɩɨɪɹɞɤɟ, ɚ client_code_2.cpp ɜɤɥɸɱɚɟɬ ɜ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɦ ɩɨɪɹɞɤɟ
59. Не используйте using для пространств имен в заголовочных файлах... 123
Стр. 123
s3.h, s2.h ɢ s4.h? Ɍɨɝɞɚ B::g ɧɚɪɭɲɚɟɬ ɩɪɚɜɢɥɨ ɨɞɧɨɝɨ ɨɩɪɟɞɟɥɟɧɢɹ (one definition rule —
ODR), ɩɨɫɤɨɥɶɤɭ ɢɦɟɸɬɫɹ ɞɜɟ ɧɟɫɨɝɥɚɫɭɸɳɢɟɫɹ ɧɟɫɨɜɦɟɫɬɢɦɵɟ ɪɟɚɥɢɡɚɰɢɢ, ɤɨɬɨɪɵɟ ɧɟ ɦɨ-
ɝɭɬ ɛɵɬɶ ɜɟɪɧɵɦɢ ɨɞɧɨɜɪɟɦɟɧɧɨ: ɨɞɧɚ ɢɡ ɧɢɯ ɩɵɬɚɟɬɫɹ ɜɵɡɜɚɬɶ A::f(int), ɚ ɜɬɨɪɚɹ —
A::f(double).
ɉɨɷɬɨɦɭ ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɞɢɪɟɤɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ
ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ ɥɢɛɨ ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ #include ɜ ɮɚɣɥɟ ɪɟɚɥɢɡɚɰɢɢ. ȼ ɫɥɭɱɚɟ ɧɚ-
ɪɭɲɟɧɢɹ ɷɬɨɝɨ ɩɪɚɜɢɥɚ ɜɵ ɧɟɫɟɬɟ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɜɨɡɦɨɠɧɨɟ ɢɡɦɟɧɟɧɢɟ ɫɦɵɫɥɚ ɫɥɟɞɭɸ-
ɳɟɝɨ ɡɚ using ɤɨɞɚ, ɧɚɩɪɢɦɟɪ, ɜɫɥɟɞɫɬɜɢɟ ɡɚɝɪɹɡɧɟɧɢɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢɥɢ ɧɟɩɨɥɧɨɝɨ
ɫɩɢɫɤɚ ɢɦɩɨɪɬɢɪɭɟɦɵɯ ɢɦɟɧ. (Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ “ɞɢɪɟɤɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using ɞɥɹ
ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ”. ɍɤɚɡɚɧɧɨɟ ɩɪɚɜɢɥɨ ɧɟɩɪɢɦɟɧɢɦɨ ɩɪɢ ɨɩɢɫɚɧɢɢ ɱɥɟɧɚ ɤɥɚɫɫɚ ɫ ɩɨɦɨɳɶɸ
ɨɛɴɹɜɥɟɧɢɹ using ɞɥɹ ɜɧɟɫɟɧɢɹ, ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ, ɢɦɟɧ ɢɡ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ.)
ȼɨ ɜɫɟɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ, ɤɚɤ ɢ ɜ ɮɚɣɥɚɯ ɪɟɚɥɢɡɚɰɢɢ ɞɨ ɩɨɫɥɟɞɧɟɣ ɞɢɪɟɤɬɢɜɵ
#include, ɜɫɟɝɞɚ ɢɫɩɨɥɶɡɭɣɬɟ ɹɜɧɵɟ ɩɨɥɧɨɫɬɶɸ ɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɵɟ ɢɦɟɧɚ. ȼ ɮɚɣɥɚɯ ɪɟɚ-
ɥɢɡɚɰɢɢ ɩɨɫɥɟ ɜɫɟɯ ɞɢɪɟɤɬɢɜ #include ɜɵ ɦɨɠɟɬɟ ɢ ɞɨɥɠɧɵ ɫɜɨɛɨɞɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɢɪɟɤ-
ɬɢɜɵ ɢ ɨɛɴɹɜɥɟɧɢɹ using. ɗɬɨ ɜɟɪɧɵɣ ɫɩɨɫɨɛ ɫɨɱɟɬɚɧɢɹ ɤɪɚɬɤɨɫɬɢ ɤɨɞɚ ɫ ɦɨɞɭɥɶɧɨɫɬɶɸ.
ɉɟɪɟɧɟɫɟɧɢɟ ɛɨɥɶɲɨɝɨ ɩɪɨɟɤɬɚ ɫɨ ɫɬɚɪɨɣ ɞɨ-ANSI/ISO ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨ-
ɬɟɤɢ (ɜɫɟ ɢɦɟɧɚ ɤɨɬɨɪɨɣ ɧɚɯɨɞɹɬɫɹ ɜ ɝɥɨɛɚɥɶɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ) ɤ ɢɫɩɨɥɶɡɨɜɚɧɢɸ ɧɨɜɨɣ
(ɝɞɟ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟ ɢɦɟɧɚ ɧɚɯɨɞɹɬɫɹ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ std) ɦɨɠɟɬ ɡɚɫɬɚɜɢɬɶ ɜɚɫ ɚɤɤɭ-
ɪɚɬɧɨ ɪɚɡɦɟɫɬɢɬɶ ɞɢɪɟɤɬɢɜɭ using ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ. ɗɬɨɬ ɫɩɨɫɨɛ ɨɩɢɫɚɧ ɜ [Sutter02].
Ссылки
[Stroustrup00] §9.2.1 • [Sutter02] §39-40
Стр. 124
60. Избегайте выделения и освобождения
памяти в разных модулях
Резюме
Ɂɨɥɨɬɨɟ ɩɪɚɜɢɥɨ ɩɪɨɝɪɚɦɦɢɫɬɚ — ɩɨɥɨɠɢ, ɝɞɟ ɜɡɹɥ. ȼɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ ɜ ɨɞɧɨɦ ɦɨɞɭɥɟ,
ɚ ɨɫɜɨɛɨɠɞɟɧɢɟ ɜ ɞɪɭɝɨɦ ɞɟɥɚɟɬ ɩɪɨɝɪɚɦɦɭ ɛɨɥɟɟ ɯɪɭɩɤɨɣ, ɫɨɡɞɚɜɚɹ ɬɨɧɤɭɸ ɞɚɥɶɧɸɸ ɡɚɜɢ-
ɫɢɦɨɫɬɶ ɦɟɠɞɭ ɷɬɢɦɢ ɦɨɞɭɥɹɦɢ. Ɍɚɤɢɟ ɦɨɞɭɥɢ ɞɨɥɠɧɵ ɛɵɬɶ ɤɨɦɩɢɥɢɪɭɟɦɵ ɨɞɧɨɣ ɢ ɬɨɣ ɠɟ
ɜɟɪɫɢɟɣ ɤɨɦɩɢɥɹɬɨɪɚ ɫ ɨɞɧɢɦɢ ɢ ɬɟɦɢ ɠɟ ɮɥɚɝɚɦɢ (ɜ ɱɚɫɬɧɨɫɬɢ, ɨɬɥɚɞɨɱɧɵɟ ɜɟɪɫɢɢ ɢ ɜɟɪɫɢɢ
NDEBUG) ɢ ɫ ɨɞɧɨɣ ɢ ɬɨɣ ɠɟ ɪɟɚɥɢɡɚɰɢɟɣ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ; ɤɪɨɦɟ ɬɨɝɨ, ɫ ɩɪɚɤɬɢɱɟ-
ɫɤɨɣ ɬɨɱɤɢ ɡɪɟɧɢɹ ɥɭɱɲɟ, ɱɬɨɛɵ ɦɨɞɭɥɶ, ɜɵɞɟɥɹɸɳɢɣ ɩɚɦɹɬɶ, ɨɫɬɚɜɚɥɫɹ ɡɚɝɪɭɠɟɧ ɩɪɢ ɟɟ ɨɫ-
ɜɨɛɨɠɞɟɧɢɢ.
Ɋɚɡɪɚɛɨɬɱɢɤɢ ɛɢɛɥɢɨɬɟɤ ɯɨɬɹɬ ɭɥɭɱɲɢɬɶ ɢɯ ɤɚɱɟɫɬɜɨ, ɢ, ɤɚɤ ɩɪɹɦɨɟ ɫɥɟɞɫɬɜɢɟ, ɜɧɭɬɪɟɧ-
ɧɢɟ ɫɬɪɭɤɬɭɪɵ ɞɚɧɧɵɯ ɢ ɚɥɝɨɪɢɬɦɵ, ɢɫɩɨɥɶɡɭɟɦɵɟ ɫɬɚɧɞɚɪɬɧɵɦɢ ɪɚɫɩɪɟɞɟɥɢɬɟɥɹɦɢ ɩɚɦɹɬɢ,
ɦɨɝɭɬ ɫɭɳɟɫɬɜɟɧɧɨ ɪɚɡɥɢɱɚɬɶɫɹ ɜ ɪɚɡɧɵɯ ɜɟɪɫɢɹɯ. Ȼɨɥɟɟ ɬɨɝɨ, ɤ ɡɧɚɱɢɬɟɥɶɧɵɦ ɢɡɦɟɧɟɧɢɹɦ ɜɨ
ɜɧɭɬɪɟɧɧɟɣ ɪɚɛɨɬɟ ɪɚɫɩɪɟɞɟɥɢɬɟɥɟɣ ɩɚɦɹɬɢ ɦɨɝɭɬ ɩɪɢɜɨɞɢɬɶ ɞɚɠɟ ɪɚɡɥɢɱɧɵɟ ɨɩɰɢɢ ɤɨɦɩɢ-
ɥɹɬɨɪɚ (ɧɚɩɪɢɦɟɪ, ɜɤɥɸɱɟɧɢɟ ɢɥɢ ɨɬɤɥɸɱɟɧɢɟ ɨɬɥɚɞɨɱɧɵɯ ɜɨɡɦɨɠɧɨɫɬɟɣ).
ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɨ ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ (ɬ.ɟ. ɨɩɟɪɚɬɨɪɟ ::operator delete ɢɥɢ
ɮɭɧɤɰɢɢ std::free) ɩɪɢ ɩɟɪɟɫɟɱɟɧɢɢ ɝɪɚɧɢɰ ɦɨɞɭɥɟɣ ɩɪɚɤɬɢɱɟɫɤɢ ɧɟɥɶɡɹ ɫɬɪɨɢɬɶ ɤɚɤɢɟ-ɥɢɛɨ
ɩɪɟɞɩɨɥɨɠɟɧɢɹ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɩɪɢ ɩɟɪɟɫɟɱɟɧɢɢ ɝɪɚɧɢɰ ɦɨɞɭɥɟɣ, ɩɪɢ ɤɨɬɨɪɨɦ ɜɵ ɧɟ ɦɨɠɟɬɟ ɝɚ-
ɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɨɧɢ ɛɭɞɭɬ ɫɤɨɦɩɢɥɢɪɨɜɚɧɵ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɤɨɦɩɢɥɹɬɨɪɨɦ C++ ɫ ɨɞɧɢɦɢ ɢ ɬɟ-
ɦɢ ɠɟ ɨɩɰɢɹɦɢ. Ʉɨɧɟɱɧɨ, ɱɚɫɬɨ ɷɬɢ ɦɨɞɭɥɢ ɧɚɯɨɞɹɬɫɹ ɜ ɨɞɧɨɦ ɢ ɬɨɦ ɠɟ ɮɚɣɥɟ ɩɪɨɟɤɬɚ ɢ ɤɨɦɩɢ-
ɥɢɪɭɸɬɫɹ ɫ ɨɞɧɢɦɢ ɢ ɬɟɦɢ ɠɟ ɨɩɰɢɹɦɢ, ɧɨ ɤɨɦɮɨɪɬ ɱɚɫɬɨ ɩɪɢɜɨɞɢɬ ɤ ɡɚɛɵɜɱɢɜɨɫɬɢ. ȼ ɨɫɨɛɟɧ-
ɧɨɫɬɢ ɜɵɫɨɤɚ ɰɟɧɚ ɬɚɤɨɣ ɡɚɛɵɜɱɢɜɨɫɬɢ ɩɪɢ ɩɟɪɟɯɨɞɟ ɤ ɞɢɧɚɦɢɱɟɫɤɢ ɫɜɹɡɵɜɚɟɦɵɦ ɛɢɛɥɢɨɬɟɤɚɦ,
ɪɚɫɩɪɟɞɟɥɟɧɢɢ ɛɨɥɶɲɨɝɨ ɩɪɨɟɤɬɚ ɦɟɠɞɭ ɧɟɫɤɨɥɶɤɢɦɢ ɝɪɭɩɩɚɦɢ ɢɥɢ ɩɪɢ ɡɚɦɟɧɟ ɦɨɞɭɥɟɣ “ɧɚ ɯɨ-
ɞɭ” — ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɜɵ ɞɨɥɠɧɵ ɭɞɟɥɢɬɶ ɦɚɤɫɢɦɭɦ ɜɧɢɦɚɧɢɹ ɬɨɦɭ, ɱɬɨɛɵ ɜɵɞɟɥɟɧɢɟ ɢ ɨɫɜɨɛɨ-
ɠɞɟɧɢɟ ɩɚɦɹɬɢ ɜɵɩɨɥɧɹɥɨɫɶ ɜ ɩɪɟɞɟɥɚɯ ɨɞɧɨɝɨ ɦɨɞɭɥɹ ɢɥɢ ɩɨɞɫɢɫɬɟɦɵ.
ɏɨɪɨɲɢɦ ɦɟɬɨɞɨɦ ɨɛɟɫɩɟɱɟɧɢɹ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɣ ɮɭɧɤɰɢɟɣ ɹɜɥɹɟɬɫɹ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ shared_ptr (ɫɦ. [C++TR104]). ɂɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ ɭɤɚɡɚɬɟɥɶ shared_ptr ɫɨ
ɫɱɟɬɱɢɤɨɦ ɫɫɵɥɨɤ ɦɨɠɟɬ ɡɚɯɜɚɬɢɬɶ ɫɜɨɣ “ɭɞɚɥɢɬɟɥɶ” ɜ ɩɪɨɰɟɫɫɟ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɹ.
“ɍɞɚɥɢɬɟɥɶ” — ɷɬɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ (ɢɥɢ ɨɛɵɱɧɵɣ ɭɤɚɡɚɬɟɥɶ ɧɚ ɮɭɧɤɰɢɸ), ɤɨɬɨɪɵɣ
ɜɵɩɨɥɧɹɟɬ ɨɫɜɨɛɨɠɞɟɧɢɟ ɩɚɦɹɬɢ. ɉɨɫɤɨɥɶɤɭ ɭɩɨɦɹɧɭɬɵɣ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, ɢɥɢ ɭɤɚɡɚ-
ɬɟɥɶ ɧɚ ɮɭɧɤɰɢɸ, ɹɜɥɹɟɬɫɹ ɱɚɫɬɶɸ ɫɨɫɬɨɹɧɢɹ ɨɛɴɟɤɬɚ shared_ptr, ɦɨɞɭɥɶ, ɜɵɞɟɥɢɜɲɢɣ ɩɚ-
ɦɹɬɶ ɨɛɴɟɤɬɭ, ɦɨɠɟɬ ɨɞɧɨɜɪɟɦɟɧɧɨ ɨɩɪɟɞɟɥɢɬɶ ɮɭɧɤɰɢɸ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ, ɢ ɷɬɚ ɮɭɧɤɰɢɹ
ɛɭɞɟɬ ɤɨɪɪɟɤɬɧɨ ɜɵɡɜɚɧɚ, ɞɚɠɟ ɟɫɥɢ ɬɨɱɤɚ ɨɫɜɨɛɨɠɞɟɧɢɹ ɧɚɯɨɞɢɬɫɹ ɝɞɟ-ɬɨ ɜ ɞɪɭɝɨɦ ɦɨɞɭɥɟ —
ɜɟɪɨɹɬɧɨ, ɨɬɧɨɫɢɬɟɥɶɧɨ ɧɟɛɨɥɶɲɨɣ ɰɟɧɨɣ (ɤɨɪɪɟɤɬɧɨɫɬɶ ɜɚɠɧɟɟ ɰɟɧɵ; ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ 5, 6 ɢ 8). Ʉɨɧɟɱɧɨ, ɢɫɯɨɞɧɵɣ ɦɨɞɭɥɶ ɩɪɢ ɷɬɨɦ ɞɨɥɠɟɧ ɨɫɬɚɜɚɬɶɫɹ ɡɚɝɪɭɠɟɧɧɵɦ.
Ссылки
[C++TR104]
60. Избегайте выделения и освобождения памяти в разных модулях 125
Стр. 125
61. Не определяйте в заголовочном файле
объекты со связыванием
Резюме
Ɉɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ, ɜɤɥɸɱɚɹ ɩɟɪɟɦɟɧɧɵɟ ɢɥɢ ɮɭɧɤɰɢɢ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ,
ɨɛɥɚɞɚɸɬ ɜɵɞɟɥɟɧɧɨɣ ɞɥɹ ɧɢɯ ɩɚɦɹɬɶɸ. Ɉɩɪɟɞɟɥɟɧɢɟ ɬɚɤɢɯ ɨɛɴɟɤɬɨɜ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ
ɩɪɢɜɨɞɢɬ ɥɢɛɨ ɤ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ ɤɨɦɩɨɧɨɜɤɢ, ɥɢɛɨ ɤ ɛɟɫɩɨɥɟɡɧɨɦɭ ɪɚɫɯɨɞɭ ɩɚɦɹɬɢ. ɉɨɦɟ-
ɳɚɣɬɟ ɜɫɟ ɨɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ ɜ ɮɚɣɥɵ ɪɟɚɥɢɡɚɰɢɢ.
Ʉɨɝɞɚ ɦɵ ɧɚɱɢɧɚɟɦ ɢɫɩɨɥɶɡɨɜɚɬɶ C++, ɬɨ ɜɫɟ ɞɨɫɬɚɬɨɱɧɨ ɛɵɫɬɪɨ ɭɹɫɧɹɟɦ, ɱɬɨ ɡɚɝɨɥɨɜɨɱ-
ɧɵɣ ɮɚɣɥ ɧɚɩɨɞɨɛɢɟ
// ǓǲǬǰǮǫǴǽǰ ǹǺǻǰǯǰǶǰǸǳȊ ǹǬȅǰǵǽǹǭ Ǽ ǭǸǰȃǸǳǷ
// ǼǭȊǲȆǭǫǸǳǰǷ ǭ ǲǫǮǹǶǹǭǹȂǸǹǷ ǿǫǴǶǰ
int fudgeFactor;
string hello("Hello, world!");
void foo() { /* ... */ }
ɛɭɞɭɱɢ ɜɤɥɸɱɟɧ ɛɨɥɶɲɟ ɱɟɦ ɜ ɨɞɢɧ ɢɫɯɨɞɧɵɣ ɮɚɣɥ, ɜɟɞɟɬ ɩɪɢ ɤɨɦɩɢɥɹɰɢɢ ɤ ɨɲɢɛɤɚɦ ɞɭɛɥɢɪɨ-
ɜɚɧɢɹ ɫɢɦɜɨɥɨɜ ɜɨ ɜɪɟɦɹ ɤɨɦɩɨɧɨɜɤɢ. ɉɪɢɱɢɧɚ ɩɪɨɫɬɚ: ɤɚɠɞɵɣ ɢɫɯɨɞɧɵɣ ɮɚɣɥ ɜ ɞɟɣɫɬɜɢɬɟɥɶ-
ɧɨɫɬɢ ɨɩɪɟɞɟɥɹɟɬ ɢ ɜɵɞɟɥɹɟɬ ɩɪɨɫɬɪɚɧɫɬɜɨ ɞɥɹ fudgeFactor, hello ɢ ɬɟɥɚ foo, ɢ ɤɨɝɞɚ ɩɪɢ-
ɯɨɞɢɬ ɜɪɟɦɹ ɫɛɨɪɤɢ (ɤɨɦɩɨɧɨɜɤɢ, ɢɥɢ ɫɜɹɡɵɜɚɧɢɹ), ɤɨɦɩɨɧɨɜɳɢɤ ɫɬɚɥɤɢɜɚɟɬɫɹ ɫ ɧɚɥɢɱɢɟɦ ɧɟ-
ɫɤɨɥɶɤɢɯ ɨɛɴɟɤɬɨɜ, ɤɨɬɨɪɵɟ ɧɨɫɹɬ ɨɞɧɨ ɢ ɬɨ ɠɟ ɢɦɹ ɢ ɛɨɪɸɬɫɹ ɦɟɠɞɭ ɫɨɛɨɣ ɡɚ ɜɢɞɢɦɨɫɬɶ.
Ɋɟɲɟɧɢɟ ɩɪɨɛɥɟɦɵ ɩɪɨɫɬɨɟ — ɜ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɧɚɞɨ ɩɨɦɟɫɬɢɬɶ ɬɨɥɶɤɨ ɨɛɴɹɜɥɟɧɢɹ:
extern int fudgeFactor;
extern string hello;
void foo(); // Ǎ ǼǶǾȂǫǰ ǹǬȅȊǭǶǰǸǳȊ ǿǾǸǵȁǳǳ "extern"
// ȊǭǶȊǰǽǼȊ ǸǰǹǬȊǲǫǽǰǶȇǸȆǷ
Ɋɟɚɥɶɧɵɟ ɠɟ ɨɛɴɹɜɥɟɧɢɹ ɪɚɫɩɨɥɚɝɚɸɬɫɹ ɜ ɨɞɧɨɦ ɮɚɣɥɟ ɪɟɚɥɢɡɚɰɢɢ:
int fudgeFactor;
void foo() { /* … */ }
ɇɟ ɨɩɪɟɞɟɥɹɣɬɟ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɢ ɫɬɚɬɢɱɟɫɤɢɟ ɨɛɴɟɤɬɵ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ,
ɧɚɩɪɢɦɟɪ:
// ǓǲǬǰǮǫǴǽǰ ǹǺǻǰǯǰǶǰǸǳȊ ǹǬȅǰǵǽǹǭ Ǽǹ ǼǽǫǽǳȂǰǼǵǳǷ
// ǼǭȊǲȆǭǫǸǳǰǷ ǭ ǲǫǮǹǶǹǭǹȂǸǹǷ ǿǫǴǶǰ
static int fudgeFactor;
static string hello("Hello, world!");
static void foo() { /* ... */ }
Ɍɚɤɨɟ ɧɟɤɨɪɪɟɤɬɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɥɸɱɟɜɨɝɨ ɫɥɨɜɚ static ɛɨɥɟɟ ɨɩɚɫɧɨ, ɱɟɦ ɩɪɨɫɬɨɟ ɨɩ-
ɪɟɞɟɥɟɧɢɟ ɝɥɨɛɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ. ȼ ɫɥɭɱɚɟ ɝɥɨɛɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ, ɩɨ
ɤɪɚɣɧɟɣ ɦɟɪɟ, ɤɨɦɩɨɧɨɜɳɢɤ ɜ ɫɨɫɬɨɹɧɢɢ ɨɛɧɚɪɭɠɢɬɶ ɧɚɥɢɱɢɟ ɞɭɛɥɟɣ. ɇɨ ɫɬɚɬɢɱɟɫɤɢɟ ɞɚɧɧɵɟ
ɢ ɮɭɧɤɰɢɢ ɦɨɝɭɬ ɞɭɛɥɢɪɨɜɚɬɶɫɹ ɧɚ ɡɚɤɨɧɧɵɯ ɨɫɧɨɜɚɧɢɹɯ, ɩɨɫɤɨɥɶɤɭ ɤɨɦɩɢɥɹɬɨɪ ɞɟɥɚɟɬ ɡɚ-
ɤɪɵɬɭɸ ɤɨɩɢɸ ɞɥɹ ɤɚɠɞɨɝɨ ɢɫɯɨɞɧɨɝɨ ɮɚɣɥɚ. Ɍɚɤ ɱɬɨ ɟɫɥɢ ɜɵ ɨɩɪɟɞɟɥɢɬɟ ɫɬɚɬɢɱɟɫɤɢɟ ɞɚɧ-
ɧɵɟ ɢ ɫɬɚɬɢɱɟɫɤɢɟ ɮɭɧɤɰɢɢ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɢ ɜɤɥɸɱɢɬɟ ɟɝɨ ɜ 50 ɮɚɣɥɨɜ, ɬɨ ɬɟɥɚ ɮɭɧɤ-
ɰɢɣ ɢ ɩɪɨɫɬɪɚɧɫɬɜɨ ɞɥɹ ɞɚɧɧɵɯ ɜ ɜɵɯɨɞɧɨɦ ɢɫɩɨɥɧɹɟɦɨɦ ɮɚɣɥɟ ɛɭɞɭɬ ɞɭɛɥɢɪɨɜɚɧɵ 50 ɪɚɡ
(ɬɨɥɶɤɨ ɟɫɥɢ ɭ ɜɚɫ ɧɟ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɧ ɨɱɟɧɶ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ ɤɨɦɩɨɧɨɜɳɢɤ, ɤɨɬɨɪɵɣ
ɫɦɨɠɟɬ ɪɚɫɩɨɡɧɚɬɶ 50 ɨɞɢɧɚɤɨɜɵɯ ɬɟɥ ɮɭɧɤɰɢɣ ɢ ɧɚɥɢɱɢɟ ɨɞɢɧɚɤɨɜɵɯ ɤɨɧɫɬɚɧɬɧɵɯ ɞɚɧɧɵɯ,
Стр. 126
ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɛɟɡɨɩɚɫɧɨ ɨɛɴɟɞɢɧɢɬɶ). ɂɡɥɢɲɧɟ ɝɨɜɨɪɢɬɶ, ɱɬɨ ɝɥɨɛɚɥɶɧɵɟ ɞɚɧɧɵɟ (ɬɚɤɢɟ
ɤɚɤ ɫɬɚɬɢɱɟɫɤɢɟ fudgeFactor) ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟ ɹɜɥɹɸɬɫɹ ɝɥɨɛɚɥɶɧɵɦɢ ɨɛɴɟɤɬɚɦɢ, ɩɨ-
ɫɤɨɥɶɤɭ ɤɚɠɞɵɣ ɢɫɯɨɞɧɵɣ ɮɚɣɥ ɪɚɛɨɬɚɟɬ ɫɨ ɫɜɨɟɣ ɤɨɩɢɟɣ ɬɚɤɢɯ ɞɚɧɧɵɯ, ɧɟɡɚɜɢɫɢɦɨɣ ɨɬ ɜɫɟɯ
ɨɫɬɚɥɶɧɵɯ ɤɨɩɢɣ ɜ ɩɪɨɝɪɚɦɦɟ.
ɇɟ ɩɵɬɚɣɬɟɫɶ ɨɛɨɣɬɢ ɷɬɭ ɫɢɬɭɚɰɢɸ ɩɪɢ ɩɨɦɨɳɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɛɟɡɵɦɹɧɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜ
ɢɦɟɧ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ, ɩɨɫɤɨɥɶɤɭ ɪɟɡɭɥɶɬɚɬ ɛɭɞɟɬ ɧɢɱɭɬɶ ɧɟ ɥɭɱɲɟ:
// Ǎ ǲǫǮǹǶǹǭǹȂǸǹǷ ǿǫǴǶǰ Ȉǽǹ Ǻǻǳǭǹǯǳǽ ǵ ǽǹǷǾ Ǳǰ
// ȈǿǿǰǵǽǾ, Ȃǽǹ ǳ ǳǼǺǹǶȇǲǹǭǫǸǳǰ static
namespace {
int fudgeFactor;
void foo() { /* ... */ }
}
ȼ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ ɦɨɝɭɬ ɧɚɯɨɞɢɬɶɫɹ ɫɥɟɞɭɸɳɢɟ ɨɛɴɟɤɬɵ ɫ ɜɧɟɲɧɢɦ ɫɜɹɡɵɜɚɧɢɟɦ.
• ȼɫɬɪɚɢɜɚɟɦɵɟ ɮɭɧɤɰɢɢ. Ɉɧɢ ɢɦɟɸɬ ɜɧɟɲɧɟɟ ɫɜɹɡɵɜɚɧɢɟ, ɧɨ ɤɨɦɩɨɧɨɜɳɢɤ ɝɚɪɚɧɬɢ-
ɪɨɜɚɧɧɨ ɧɟ ɨɬɜɟɪɝɚɟɬ ɦɧɨɝɨɤɪɚɬɧɵɟ ɤɨɩɢɢ. ȼɨ ɜɫɟɦ ɨɫɬɚɥɶɧɨɦ ɨɧɢ ɜɟɞɭɬ ɫɟɛɹ ɬɚɤ ɠɟ,
ɤɚɤ ɢ ɨɛɵɱɧɵɟ ɮɭɧɤɰɢɢ. ȼ ɱɚɫɬɧɨɫɬɢ, ɚɞɪɟɫ ɜɫɬɪɚɢɜɚɟɦɨɣ ɮɭɧɤɰɢɢ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ
ɛɭɞɟɬ ɟɞɢɧɫɬɜɟɧɧɵɦ ɜ ɩɪɟɞɟɥɚɯ ɩɪɨɝɪɚɦɦɵ.
• ɒɚɛɥɨɧɵ ɮɭɧɤɰɢɣ. Ⱥɧɚɥɨɝɢɱɧɨ ɜɫɬɪɚɢɜɚɟɦɵɦ ɮɭɧɤɰɢɹɦ, ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ ɜɟɞɭɬ ɫɟɛɹ
ɬɚɤ ɠɟ, ɤɚɤ ɢ ɨɛɵɱɧɵɟ ɮɭɧɤɰɢɢ, ɫ ɬɟɦ ɨɬɥɢɱɢɟɦ, ɱɬɨ ɢɯ ɞɭɛɥɢɤɚɬɵ ɩɪɢɟɦɥɟɦɵ
(ɢ ɞɨɥɠɧɵ ɛɵɬɶ ɢɞɟɧɬɢɱɧɵ). ɋɚɦɨ ɫɨɛɨɣ ɪɚɡɭɦɟɟɬɫɹ, ɯɨɪɨɲɢɣ ɤɨɦɩɢɥɹɬɨɪ ɭɫɬɪɚɧɢɬ
ɢɡɥɢɲɧɢɟ ɤɨɩɢɢ.
• ɋɬɚɬɢɱɟɫɤɢɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɲɚɛɥɨɧɨɜ ɤɥɚɫɫɨɜ. Ɉɧɢ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɨɫɨɛɟɧɧɨ ɫɥɨɠ-
ɧɵɦɢ ɞɥɹ ɤɨɦɩɨɧɨɜɳɢɤɚ, ɧɨ ɷɬɨ ɭɠɟ ɧɟ ɜɚɲɚ ɩɪɨɛɥɟɦɚ — ɜɵ ɩɪɨɫɬɨ ɨɩɪɟɞɟɥɹɟɬɟ ɢɯ
ɜ ɫɜɨɟɦ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɢ ɩɪɟɞɨɫɬɚɜɥɹɟɬɟ ɫɞɟɥɚɬɶ ɜɫɟ ɨɫɬɚɥɶɧɨɟ ɤɨɦɩɢɥɹɬɨɪɭ
ɢ ɤɨɦɩɨɧɨɜɳɢɤɭ.
Ʉɪɨɦɟ ɬɨɝɨ, ɦɟɬɨɞɢɤɚ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɝɥɨɛɚɥɶɧɵɯ ɞɚɧɧɵɯ, ɢɡɜɟɫɬɧɚɹ ɤɚɤ “ɋɱɟɬɱɢɤɢ ɒɜɚɪ-
ɰɚ” (“Schwarz counters”), ɩɪɟɞɩɢɫɵɜɚɟɬ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɫɬɚɬɢɱɟɫɤɢɯ ɞɚɧ-
ɧɵɯ (ɢɥɢ ɛɟɡɵɦɹɧɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ). Ⱦɠɟɪɪɢ ɒɜɚɪɰ (Jerry Schwarz) ɢɫɩɨɥɶɡɨɜɚɥ ɷɬɭ ɦɟɬɨ-
ɞɢɤɭ ɞɥɹ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɵɯ ɩɨɬɨɤɨɜ ɜɜɨɞɚ-ɜɵɜɨɞɚ cin, cout, cerr ɢ clog, ɱɬɨ
ɢ ɫɞɟɥɚɥɨ ɟɟ ɞɨɫɬɚɬɨɱɧɨ ɩɨɩɭɥɹɪɧɨɣ.
Ссылки
[Dewhurst03] §55 • [Ellis90] §3.3 • [Stroustrup00] §9.2, §9.4.1
61. Не определяйте в заголовочном файле объекты со связыванием 127
Стр. 127
62. Не позволяйте исключениям пересекать
границы модулей
Резюме
ɇɟ ɛɪɨɫɚɣɬɟ ɤɚɦɧɢ ɜ ɫɨɫɟɞɫɤɢɣ ɨɝɨɪɨɞ — ɩɨɫɤɨɥɶɤɭ ɧɟɬ ɩɨɜɫɟɦɟɫɬɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɝɨ
ɛɢɧɚɪɧɨɝɨ ɫɬɚɧɞɚɪɬɚ ɞɥɹ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ C++, ɧɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟɤɚɬɶ
ɪɚɫɩɪɨɫɬɪɚɧɹɬɶɫɹ ɦɟɠɞɭ ɞɜɭɦɹ ɱɚɫɬɹɦɢ ɤɨɞɚ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɤɨɧɬɪɨɥɢɪɨɜɚɬɶ,
ɤɚɤɢɦ ɤɨɦɩɢɥɹɬɨɪɨɦ ɢ ɫ ɤɚɤɢɦɢ ɨɩɰɢɹɦɢ ɫɤɨɦɩɢɥɢɪɨɜɚɧɵ ɨɛɟ ɷɬɢ ɱɚɫɬɢ ɤɨɞɚ. ȼ ɩɪɨɬɢɜɧɨɦ
ɫɥɭɱɚɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ, ɱɬɨ ɦɨɞɭɥɢ ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɬ ɫɨɜɦɟɫɬɢɦɵɟ ɪɟɚɥɢɡɚɰɢɢ ɪɚɫɩɪɨɫɬɪɚ-
ɧɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ. Ɉɛɵɱɧɨ ɷɬɨ ɩɪɚɜɢɥɨ ɫɜɨɞɢɬɫɹ ɤ ɫɥɟɞɭɸɳɟɦɭ: ɧɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ
ɩɟɪɟɫɟɤɚɬɶ ɝɪɚɧɢɰɵ ɦɨɞɭɥɟɣ/ɩɨɞɫɢɫɬɟɦ.
ɋɬɚɧɞɚɪɬ C++ ɧɟ ɨɩɪɟɞɟɥɹɟɬ ɫɩɨɫɨɛ ɪɟɚɥɢɡɚɰɢɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ, ɢ ɧɟ ɢɦɟ-
ɟɬɫɹ ɧɢɤɚɤɨɝɨ ɫɬɚɧɞɚɪɬɚ ɞɟ-ɮɚɤɬɨ, ɩɪɢɡɧɚɧɧɨɝɨ ɛɨɥɶɲɢɧɫɬɜɨɦ ɫɢɫɬɟɦ. Ɇɟɯɚɧɢɤɚ ɪɚɫɩɪɨ-
ɫɬɪɚɧɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ ɜɚɪɶɢɪɭɟɬɫɹ ɧɟ ɬɨɥɶɤɨ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ
ɢ ɤɨɦɩɢɥɹɬɨɪɚ, ɧɨ ɢ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɨɩɰɢɣ ɤɨɦɩɢɥɹɰɢɢ, ɢɫɩɨɥɶɡɨɜɚɧɧɵɯ ɞɥɹ ɤɨɦɩɢɥɹɰɢɢ
ɞɚɧɧɨɝɨ ɦɨɞɭɥɹ ɞɚɧɧɵɦ ɤɨɦɩɢɥɹɬɨɪɨɦ ɜ ɞɚɧɧɨɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɟ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɩɪɢ-
ɥɨɠɟɧɢɟ ɞɨɥɠɧɨ ɩɪɟɞɨɬɜɪɚɳɚɬɶ ɧɟɫɨɜɦɟɫɬɢɦɨɫɬɶ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɩɭɬɟɦ ɷɤɪɚɧɢɪɨɜɚ-
ɧɢɹ ɝɪɚɧɢɰ ɤɚɠɞɨɝɨ ɢɡ ɫɜɨɢɯ ɨɫɧɨɜɧɵɯ ɦɨɞɭɥɟɣ, ɩɨɞ ɤɨɬɨɪɵɦɢ ɩɨɞɪɚɡɭɦɟɜɚɸɬɫɹ ɱɚɫɬɢ ɩɪɢ-
ɥɨɠɟɧɢɹ, ɞɥɹ ɤɨɬɨɪɵɯ ɪɚɡɪɚɛɨɬɱɢɤ ɦɨɠɟɬ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɞɥɹ ɢɯ ɤɨɦɩɢɥɹɰɢɢ ɢɫɩɨɥɶɡɨɜɚɧ
ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɤɨɦɩɢɥɹɬɨɪ ɢ ɨɞɧɢ ɢ ɬɟ ɠɟ ɨɩɰɢɢ ɤɨɦɩɢɥɹɰɢɢ.
Ʉɚɤ ɦɢɧɢɦɭɦ, ɜɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɞɨɥɠɧɨ ɨɛɟɫɩɟɱɢɬɶ ɧɚɥɢɱɢɟ ɡɚɝɥɭɲɟɤ catch(...) ɜ ɩɟ-
ɪɟɱɢɫɥɟɧɧɵɯ ɧɢɠɟ ɦɟɫɬɚɯ, ɛɨɥɶɲɢɧɫɬɜɨ ɢɡ ɤɨɬɨɪɵɯ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɫɜɹɡɚɧɵ ɫ ɦɨɞɭɥɹɦɢ.
• ȼɨɤɪɭɝ main. ɉɟɪɟɯɜɚɬɵɜɚɣɬɟ ɢ ɡɚɩɢɫɵɜɚɣɬɟ ɜɫɟ ɢɫɤɥɸɱɟɧɢɹ, ɤɨɬɨɪɵɟ ɢɧɚɱɟ ɨɤɚɡɚ-
ɥɢɫɶ ɛɵ ɧɟɩɟɪɟɯɜɚɱɟɧɧɵɦɢ ɢ ɤɨɬɨɪɵɟ ɩɪɢɜɨɞɹɬ ɤ ɧɟɦɟɞɥɟɧɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ ɪɚɛɨɬɵ
ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ.
• ȼɨɤɪɭɝ ɮɭɧɤɰɢɣ ɨɛɪɚɬɧɨɝɨ ɜɵɡɨɜɚ ɢɡ ɤɨɞɚ, ɤɨɬɨɪɵɣ ɧɚɯɨɞɢɬɫɹ ɜɧɟ ɜɚɲɟɝɨ ɤɨɧɬɪɨɥɹ.
Ɉɩɟɪɚɰɢɨɧɧɵɟ ɫɢɫɬɟɦɵ ɢ ɛɢɛɥɢɨɬɟɤɢ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɸɬ ɫɯɟɦɭ, ɩɪɢ ɤɨɬɨɪɨɣ ɜɵ ɩɟɪɟ-
ɞɚɟɬɟ ɭɤɚɡɚɬɟɥɶ ɧɚ ɮɭɧɤɰɢɸ, ɤɨɬɨɪɚɹ ɛɭɞɟɬ ɜɵɡɜɚɧɚ ɩɨɡɠɟ (ɧɚɩɪɢɦɟɪ, ɩɪɢ ɧɟɤɨɬɨɪɨɦ
ɚɫɢɧɯɪɨɧɧɨɦ ɫɨɛɵɬɢɢ). ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɪɚɫɩɪɨɫɬɪɚɧɢɬɶɫɹ ɡɚ ɩɪɟɞɟɥɵ ɜɚ-
ɲɟɣ ɮɭɧɤɰɢɢ ɨɛɪɚɬɧɨɝɨ ɜɵɡɨɜɚ, ɩɨɫɤɨɥɶɤɭ ɜɩɨɥɧɟ ɜɨɡɦɨɠɧɨ, ɱɬɨ ɤɨɞ, ɜɵɡɵɜɚɸɳɢɣ
ɜɚɲɭ ɮɭɧɤɰɢɸ, ɢɫɩɨɥɶɡɭɟɬ ɢɧɨɣ ɦɟɯɚɧɢɡɦ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ. Ʉɫɬɚɬɢ ɝɨɜɨɪɹ, ɨɧ
ɦɨɠɟɬ ɜɨɨɛɳɟ ɛɵɬɶ ɧɚɩɢɫɚɧ ɧɟ ɧɚ C++.
• ȼɨɤɪɭɝ ɝɪɚɧɢɰ ɩɨɬɨɤɚ. ȼ ɤɨɧɟɱɧɨɦ ɢɬɨɝɟ ɩɨɬɨɤ ɜɵɩɨɥɧɟɧɢɹ ɫɨɡɞɚɟɬɫɹ ɜɧɭɬɪɢ ɨɩɟɪɚ-
ɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲɚ ɮɭɧɤɰɢɹ, ɩɪɟɞɫɬɚɜɥɹɸɳɚɹ ɩɨɬɨɤ, ɧɟ ɩɪɟɩɨɞɧɟ-
ɫɟɬ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɟ ɫɸɪɩɪɢɡ ɜ ɜɢɞɟ ɢɫɤɥɸɱɟɧɢɹ.
• ȼɨɤɪɭɝ ɝɪɚɧɢɰ ɢɧɬɟɪɮɟɣɫɚ ɦɨɞɭɥɹ. ȼɚɲɚ ɩɨɞɫɢɫɬɟɦɚ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɨɤɪɭɠɚɸɳɟɦɭ
ɦɢɪɭ ɧɟɤɨɬɨɪɵɣ ɨɬɤɪɵɬɵɣ ɢɧɬɟɪɮɟɣɫ. ȿɫɥɢ ɩɨɞɫɢɫɬɟɦɚ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɬɞɟɥɶ-
ɧɭɸ ɛɢɛɥɢɨɬɟɤɭ, ɥɭɱɲɟ, ɱɬɨɛɵ ɢɫɤɥɸɱɟɧɢɹ ɨɫɬɚɜɚɥɢɫɶ ɜ ɟɟ ɝɪɚɧɢɰɚɯ, ɚ ɞɥɹ ɫɨɨɛɳɟɧɢɹ
ɨɛ ɨɲɢɛɤɚɯ ɢɫɩɨɥɶɡɨɜɚɥɢɫɶ ɫɬɚɪɵɟ ɞɨɛɪɵɟ ɤɨɞɵ ɨɲɢɛɨɤ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 72).
• ȼɧɭɬɪɢ ɞɟɫɬɪɭɤɬɨɪɨɜ. Ⱦɟɫɬɪɭɤɬɨɪɵ ɧɟ ɞɨɥɠɧɵ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɣ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 51). Ⱦɟɫɬɪɭɤɬɨɪɵ, ɤɨɬɨɪɵɟ ɜɵɡɵɜɚɸɬ ɮɭɧɤɰɢɢ, ɫɩɨɫɨɛɧɵɟ ɝɟɧɟɪɢɪɨɜɚɬɶ
ɢɫɤɥɸɱɟɧɢɹ, ɞɨɥɠɧɵ ɡɚɳɢɬɢɬɶɫɹ ɨɬ ɜɨɡɦɨɠɧɨɣ ɭɬɟɱɤɢ ɷɬɢɯ ɢɫɤɥɸɱɟɧɢɣ.
Стр. 128
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɤɚɠɞɵɣ ɦɨɞɭɥɶ ɫɨɝɥɚɫɨɜɚɧɧɨ ɢɫɩɨɥɶɡɭɟɬ ɨɞɧɭ ɢ ɬɭ ɠɟ ɜɧɭɬɪɟɧɧɸɸ ɫɬɪɚ-
ɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ (ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ — ɢɫɤɥɸɱɟɧɢɹ C++; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 72)
ɢ ɟɞɢɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɜ ɢɧɬɟɪɮɟɣɫɟ (ɧɚɩɪɢɦɟɪ, ɤɨɞɵ ɨɲɢɛɨɤ ɞɥɹ API ɧɚ
ɹɡɵɤɟ C); ɨɛɟ ɷɬɢ ɫɬɪɚɬɟɝɢɢ ɦɨɝɭɬ ɛɵɬɶ ɨɞɢɧɚɤɨɜɵ, ɧɨ ɨɛɵɱɧɨ ɷɬɨ ɧɟ ɬɚɤ. ɋɬɪɚɬɟɝɢɢ ɨɛɪɚɛɨɬ-
ɤɢ ɨɲɢɛɨɤ ɦɨɝɭɬ ɢɡɦɟɧɹɬɶɫɹ ɬɨɥɶɤɨ ɧɚ ɝɪɚɧɢɰɚɯ ɦɨɞɭɥɹ. Ɉɩɪɟɞɟɥɢɬɟ, ɤɚɤ ɩɪɨɢɫɯɨɞɢɬ ɫɜɹɡɵ-
ɜɚɧɢɟ ɫɬɪɚɬɟɝɢɣ ɦɟɠɞɭ ɦɨɞɭɥɹɦɢ (ɧɚɩɪɢɦɟɪ, ɤɚɤ ɩɪɨɢɫɯɨɞɢɬ ɜɡɚɢɦɨɞɟɣɫɬɜɢɟ ɫ COM ɢɥɢ
CORBA, ɢɥɢ ɱɬɨ ɜɫɟɝɞɚ ɫɥɟɞɭɟɬ ɩɟɪɟɯɜɚɬɵɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɧɚ ɝɪɚɧɢɰɟ ɫ API ɧɚ ɹɡɵɤɟ C).
ɏɨɪɨɲɢɦ ɪɟɲɟɧɢɟɦ ɛɭɞɟɬ ɨɩɪɟɞɟɥɢɬɶ ɰɟɧɬɪɚɥɶɧɵɟ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɜɵɩɨɥɧɹɸɬ ɩɪɟɨɛɪɚ-
ɡɨɜɚɧɢɹ ɦɟɠɞɭ ɢɫɤɥɸɱɟɧɢɹɦɢ ɢ ɤɨɞɚɦɢ ɨɲɢɛɨɤ, ɜɨɡɜɪɚɳɚɟɦɵɯ ɩɨɞɫɢɫɬɟɦɨɣ. Ɍɚɤ ɜɵ ɫɦɨɠɟ-
ɬɟ ɥɟɝɤɨ ɬɪɚɧɫɥɢɪɨɜɚɬɶ ɜɯɨɞɹɳɢɟ ɨɲɢɛɤɢ ɨɬ ɞɪɭɝɢɯ ɦɨɞɭɥɟɣ ɜ ɢɫɩɨɥɶɡɭɟɦɵɟ ɜɧɭɬɪɟɧɧɢɟ ɢɫ-
ɤɥɸɱɟɧɢɹ ɢ ɬɟɦ ɫɚɦɵɦ ɭɩɪɨɫɬɢɬɶ ɢɧɬɟɝɪɚɰɢɸ.
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɞɜɭɯ ɫɬɪɚɬɟɝɢɣ ɜɦɟɫɬɨ ɨɞɧɨɣ ɜɵɝɥɹɞɢɬ ɢɡɛɵɬɨɱɧɵɦ, ɢ ɜɵ ɦɨɠɟɬɟ ɩɨɞ-
ɞɚɬɶɫɹ ɫɨɛɥɚɡɧɭ ɨɬɤɚɡɚɬɶɫɹ ɨɬ ɢɫɤɥɸɱɟɧɢɣ ɢ ɜɟɡɞɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɨɥɶɤɨ ɫɬɚɪɵɟ ɞɨɛɪɵɟ ɤɨɞɵ
ɨɲɢɛɨɤ. ɇɨ ɧɟ ɡɚɛɵɜɚɣɬɟ, ɱɬɨ ɨɛɪɚɛɨɬɤɚ ɢɫɤɥɸɱɟɧɢɣ ɢɦɟɟɬ ɞɨɫɬɨɢɧɫɬɜɚ ɩɪɨɫɬɨɬɵ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɹ ɢ ɧɚɞɟɠɧɨɫɬɢ, ɟɫɬɟɫɬɜɟɧɧɚ ɞɥɹ C++ ɢ ɱɬɨ ɢɡɛɟɠɚɬɶ ɟɟ ɜ ɧɟɬɪɢɜɢɚɥɶɧɵɯ ɩɪɨɝɪɚɦɦɚɯ ɧɚ
C++ ɧɟɜɨɡɦɨɠɧɨ (ɩɪɨɫɬɨ ɩɨɬɨɦɭ, ɱɬɨ ɫɬɚɧɞɚɪɬɧɵɣ ɹɡɵɤ ɢ ɛɢɛɥɢɨɬɟɤɚ ɝɟɧɟɪɢɪɭɸɬ ɢɫɤɥɸɱɟ-
ɧɢɹ), ɬɚɤ ɱɬɨ ɜɚɦ ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɬɚɦ, ɝɞɟ ɷɬɨ ɬɨɥɶɤɨ ɜɨɡɦɨɠ-
ɧɨ. Ⱦɨɩɨɥɧɢɬɟɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɜɵ ɧɚɣɞɟɬɟ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 72.
ɇɟɛɨɥɶɲɨɟ ɩɪɟɞɨɫɬɟɪɟɠɟɧɢɟ. ɇɟɤɨɬɨɪɵɟ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ ɢɫɩɨɥɶɡɭɸɬ ɦɟɯɚɧɢɡɦ ɢɫ-
ɤɥɸɱɟɧɢɣ C++ ɩɪɢ ɨɛɪɚɛɨɬɤɟ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɫɢɫɬɟɦɧɵɯ ɨɲɢɛɨɤ, ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɪɚɡɵɦɟɧɨɜɚɧɢɟ
ɧɭɥɟɜɨɝɨ ɭɤɚɡɚɬɟɥɹ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɢɧɫɬɪɭɤɰɢɹ catch(...) ɦɨɠɟɬ ɩɟɪɟɯɜɚɬɢɬɶ ɛɨɥɶɲɟ ɢɫɤɥɸ-
ɱɟɧɢɣ, ɱɟɦ ɜɵ ɨɠɢɞɚɟɬɟ, ɬɚɤ ɱɬɨ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜ ɧɟɨɩɪɟɞɟɥɟɧɧɨɣ ɫɢɬɭɚɰɢɢ ɩɪɢ
ɜɵɩɨɥɧɟɧɢɢ ɩɟɪɟɯɜɚɬɚ catch(...). Ɉɛɪɚɬɢɬɟɫɶ ɤ ɞɨɤɭɦɟɧɬɚɰɢɢ ɩɨ ɜɚɲɟɣ ɫɢɫɬɟɦɟ ɢ ɥɢɛɨ ɩɪɢɝɨ-
ɬɨɜɶɬɟɫɶ ɤ ɨɛɪɚɛɨɬɤɟ ɬɚɤɢɯ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɢɫɤɥɸɱɟɧɢɣ ɧɚɢɛɨɥɟɟ ɪɚɡɭɦɧɵɦ ɫɩɨɫɨɛɨɦ, ɤɨɬɨɪɵɣ
ɫɦɨɠɟɬɟ ɩɪɢɞɭɦɚɬɶ, ɥɢɛɨ ɢɫɩɨɥɶɡɭɣɬɟ ɜ ɧɚɱɚɥɟ ɜɚɲɟɝɨ ɩɪɢɥɨɠɟɧɢɹ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɫɢɫɬɟɦɧɵɟ
ɜɵɡɨɜɵ ɞɥɹ ɨɬɤɥɸɱɟɧɢɹ ɬɚɤɨɝɨ ɩɨɜɟɞɟɧɢɹ. Ɂɚɦɟɧɚ catch(...) ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶɸ ɩɟɪɟɯɜɚɬɨɜ
catch(E1&){/*...*/} catch(E2&){/*...*/} … catch(En&){/*...*/} ɞɥɹ ɜɫɟɯ ɢɡɜɟɫɬ-
ɧɵɯ ɬɢɩɨɜ ɛɚɡɨɜɵɯ ɢɫɤɥɸɱɟɧɢɣ Ei ɦɚɫɲɬɚɛɢɪɭɟɦɵɦ ɪɟɲɟɧɢɟɦ ɧɟ ɹɜɥɹɟɬɫɹ, ɩɨɫɤɨɥɶɤɭ ɜɚɦ ɩɪɢ-
ɞɟɬɫɹ ɨɛɧɨɜɥɹɬɶ ɷɬɨɬ ɫɩɢɫɨɤ ɩɪɢ ɞɨɛɚɜɥɟɧɢɢ ɧɨɜɵɯ ɛɢɛɥɢɨɬɟɤ (ɢɫɩɨɥɶɡɭɸɳɢɯ ɫɨɛɫɬɜɟɧɧɵɟ ɢɟɪɚɪ-
ɯɢɢ ɢɫɤɥɸɱɟɧɢɣ) ɜ ɜɚɲɟ ɩɪɢɥɨɠɟɧɢɟ.
ɂɫɩɨɥɶɡɨɜɚɧɢɟ catch(...) ɜ ɞɪɭɝɢɯ, ɧɟ ɩɟɪɟɱɢɫɥɟɧɧɵɯ ɜ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɦɟɫɬɚɯ
ɡɚɱɚɫɬɭɸ ɹɜɥɹɟɬɫɹ ɩɪɢɡɧɚɤɨɦ ɩɥɨɯɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɩɨɫɤɨɥɶɤɭ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɜɵ ɯɨɬɢɬɟ
ɩɟɪɟɯɜɚɬɢɬɶ ɚɛɫɨɥɸɬɧɨ ɜɫɟ ɢɫɤɥɸɱɟɧɢɹ ɛɟɡ ɨɛɹɡɚɬɟɥɶɧɨɝɨ ɡɧɚɧɢɹ ɨ ɬɨɦ, ɤɚɤ ɫɥɟɞɭɟɬ ɨɛɪɚɛɚ-
ɬɵɜɚɬɶ ɤɨɧɤɪɟɬɧɵɟ ɢɫɤɥɸɱɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 74). ȼ ɯɨɪɨɲɟɣ ɩɪɨɝɪɚɦɦɟ ɧɟ ɬɚɤ ɦɧɨɝɨ
ɩɟɪɟɯɜɚɬɨɜ ɜɫɟɯ ɢɫɤɥɸɱɟɧɢɣ, ɞɚ ɢ ɜɨɨɛɳɟ ɢɧɫɬɪɭɤɰɢɣ try/catch; ɜ ɢɞɟɚɥɟ ɨɲɢɛɤɢ ɪɚɫɩɪɨ-
ɫɬɪɚɧɹɸɬɫɹ ɱɟɪɟɡ ɜɟɫɶ ɦɨɞɭɥɶ, ɬɪɚɧɫɥɢɪɭɸɬɫɹ ɧɚ ɟɝɨ ɝɪɚɧɢɰɟ (ɧɟɢɡɛɟɠɧɨɟ ɡɥɨ) ɢ ɨɛɪɚɛɚɬɵ-
ɜɚɸɬɫɹ ɜ ɫɬɪɚɬɟɝɢɱɟɫɤɢ ɪɚɡɦɟɳɟɧɧɵɯ ɦɟɫɬɚɯ.
Ссылки
[Stroustrup00] §3.7.2, §14.7 • [Sutter00] §8-17 • [Sutter02] §17-23 • [Sutter04] §11-13
62. Не позволяйте исключениям пересекать границы модулей 129
Стр. 129
63. Используйте достаточно переносимые
типы в интерфейсах модулей
Резюме
ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɬɢɩɚɦ ɩɨɹɜɥɹɬɶɫɹ ɜɨ ɜɧɟɲɧɟɦ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ ɭɜɟ-
ɪɟɧɵ ɜ ɬɨɦ, ɱɬɨ ɜɫɟ ɩɨɥɶɡɨɜɚɬɟɥɢ ɫɦɨɝɭɬ ɤɨɪɪɟɤɬɧɨ ɢɯ ɩɨɧɹɬɶ ɢ ɪɚɛɨɬɚɬɶ ɫ ɧɢɦɢ. ɂɫɩɨɥɶɡɭɣ-
ɬɟ ɧɚɢɜɵɫɲɢɣ ɭɪɨɜɟɧɶ ɚɛɫɬɪɚɤɰɢɢ, ɤɨɬɨɪɵɣ ɜ ɫɨɫɬɨɹɧɢɢ ɩɨɧɹɬɶ ɤɥɢɟɧɬɫɤɢɣ ɤɨɞ.
ɑɟɦ ɛɨɥɟɟ ɲɢɪɨɤɨ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ ɜɚɲɚ ɛɢɛɥɢɨɬɟɤɚ, ɬɟɦ ɦɟɧɶɲɟ ɜɚɲ ɤɨɧɬɪɨɥɶ ɧɚɞ ɫɪɟ-
ɞɚɦɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɢɫɩɨɥɶɡɭɟɦɵɦɢ ɜɚɲɢɦɢ ɤɥɢɟɧɬɚɦɢ, ɢ ɬɟɦ ɦɟɧɶɲɟ ɦɧɨɠɟɫɬɜɨ ɬɢ-
ɩɨɜ, ɤɨɬɨɪɵɟ ɜɚɲɚ ɛɢɛɥɢɨɬɟɤɚ ɦɨɠɟɬ ɧɚɞɟɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɫɜɨɟɦ ɜɧɟɲɧɟɦ ɢɧɬɟɪɮɟɣɫɟ.
ȼɡɚɢɦɨɞɟɣɫɬɜɢɟ ɦɟɠɞɭ ɦɨɞɭɥɹɦɢ ɜɤɥɸɱɚɟɬ ɨɛɦɟɧ ɛɢɧɚɪɧɵɦɢ ɞɚɧɧɵɦɢ. ɍɜɵ, C++ ɧɟ ɨɩɪɟ-
ɞɟɥɹɟɬ ɫɬɚɧɞɚɪɬɧɵɟ ɛɢɧɚɪɧɵɟ ɢɧɬɟɪɮɟɣɫɵ; ɲɢɪɨɤɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɟ ɛɢɛɥɢɨɬɟɤɢ ɞɥɹ ɜɡɚɢ-
ɦɨɞɟɣɫɬɜɢɹ ɫɨ ɜɧɟɲɧɢɦ ɦɢɪɨɦ ɦɨɝɭɬ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɬɚɤɢɟ ɜɫɬɪɨɟɧɧɵɟ ɬɢɩɵ, ɤɚɤ int ɢ char.
Ⱦɚɠɟ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɬɢɩ ɧɚ ɨɞɧɨɦ ɢ ɬɨɦ ɠɟ ɤɨɦɩɢɥɹɬɨɪɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɛɢɧɚɪɧɨ ɧɟɫɨɜɦɟɫ-
ɬɢɦɵɦ ɩɪɢ ɤɨɦɩɢɥɹɰɢɢ ɫ ɪɚɡɧɵɦɢ ɨɩɰɢɹɦɢ.
Ɉɛɵɱɧɨ ɥɢɛɨ ɜɵ ɩɨɥɧɨɫɬɶɸ ɤɨɧɬɪɨɥɢɪɭɟɬɟ ɤɨɦɩɢɥɹɬɨɪ ɢ ɨɩɰɢɢ ɤɨɦɩɢɥɹɰɢɢ, ɢɫɩɨɥɶɡɭɟɦɵɟ
ɞɥɹ ɫɛɨɪɤɢ ɦɨɞɭɥɹ ɢ ɟɝɨ ɤɥɢɟɧɬɨɜ (ɢ ɬɨɝɞɚ ɜɵ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɥɸɛɨɣ ɬɢɩ), ɥɢɛɨ ɜɵ ɧɟ ɢɦɟɟɬɟ
ɬɚɤɨɣ ɜɨɡɦɨɠɧɨɫɬɢ ɢ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɨɥɶɤɨ ɬɢɩɵ, ɩɪɟɞɨɫɬɚɜɥɹɟɦɵɟ ɜɵɱɢɫɥɢɬɟɥɶɧɨɣ ɩɥɚɬ-
ɮɨɪɦɨɣ, ɢɥɢ ɜɫɬɪɨɟɧɧɵɟ ɬɢɩɵ C++ (ɧɨ ɞɚɠɟ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɫɥɟɞɭɟɬ ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɪɚɡɦɟɪ
ɢ ɩɪɟɞɫɬɚɜɥɟɧɢɟ ɩɨɫɥɟɞɧɢɯ). ȼ ɱɚɫɬɧɨɫɬɢ, ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ ɬɢɩɵ ɫɬɚɧɞɚɪɬɧɨɣ
ɛɢɛɥɢɨɬɟɤɢ ɦɨɠɧɨ ɬɨɥɶɤɨ ɜ ɬɨɦ ɫɥɭɱɚɟ, ɟɫɥɢ ɜɫɟ ɞɪɭɝɢɟ ɦɨɞɭɥɢ, ɢɫɩɨɥɶɡɭɸɳɢɟ ɞɚɧɧɵɣ, ɛɭɞɭɬ
ɤɨɦɩɢɥɢɪɨɜɚɬɶɫɹ ɜ ɬɨ ɠɟ ɜɪɟɦɹ ɢ ɫ ɬɟɦɢ ɠɟ ɢɫɯɨɞɧɵɦɢ ɮɚɣɥɚɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ.
Ɍɪɟɛɭɟɬɫɹ ɧɚɣɬɢ ɨɩɪɟɞɟɥɟɧɧɵɣ ɤɨɦɩɪɨɦɢɫɫ ɦɟɠɞɭ ɩɪɨɛɥɟɦɚɦɢ ɢɫɩɨɥɶɡɭɟɦɵɯ ɬɢɩɨɜ, ɤɨ-
ɬɨɪɵɟ ɦɨɝɭɬ ɧɟ ɛɵɬɶ ɤɨɪɪɟɤɬɧɨ ɜɨɫɩɪɢɧɹɬɵ ɜɫɟɦɢ ɤɥɢɟɧɬɚɦɢ, ɢ ɩɪɨɛɥɟɦɚɦɢ ɢɫɩɨɥɶɡɨɜɚɧɢɹ
ɧɢɡɤɨɝɨ ɭɪɨɜɧɹ ɚɛɫɬɪɚɤɰɢɢ. Ⱥɛɫɬɪɚɤɰɢɹ ɜɚɠɧɚ; ɟɫɥɢ ɧɟɤɨɬɨɪɵɟ ɤɥɢɟɧɬɵ ɩɨɧɢɦɚɸɬ ɬɨɥɶɤɨ
ɧɢɡɤɨɭɪɨɜɧɟɜɵɟ ɬɢɩɵ ɢ ɜɵ ɨɝɪɚɧɢɱɟɧɵ ɜ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɷɬɢɦɢ ɬɢɩɚɦɢ, ɬɨ, ɜɨɡɦɨɠɧɨ, ɫɥɟɞɭɟɬ
ɩɨɞɭɦɚɬɶ ɨ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɨɩɟɪɚɰɢɹɯ, ɪɚɛɨɬɚɸɳɢɯ ɫ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɦɢ ɬɢɩɚɦɢ. Ɋɚɫɫɦɨɬ-
ɪɢɦ ɮɭɧɤɰɢɸ SummarizeFile, ɤɨɬɨɪɚɹ ɩɨɥɭɱɚɟɬ ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɚ ɮɚɣɥ. ɂɦɟɟɬɫɹ ɬɪɢ
ɜɚɪɢɚɧɬɚ ɞɟɣɫɬɜɢɣ — ɩɟɪɟɞɚɬɶ ɭɤɚɡɚɬɟɥɶ char* ɧɚ ɫɬɪɨɤɭ ɜ ɫɬɢɥɟ C ɫ ɢɦɟɧɟɦ ɮɚɣɥɚ; ɩɟɪɟ-
ɞɚɬɶ string ɫ ɢɦɟɧɟɦ ɮɚɣɥɚ ɢ ɩɟɪɟɞɚɬɶ ɨɛɴɟɤɬ istream ɢɥɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ ɨɛɴɟɤɬ File.
Ʉɚɠɞɵɣ ɢɡ ɷɬɢɯ ɜɚɪɢɚɧɬɨɜ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɜɨɣ ɭɪɨɜɟɧɶ ɤɨɦɩɪɨɦɢɫɫɚ.
• ȼɚɪɢɚɧɬ 1. char*. Ɉɱɟɜɢɞɧɨ, ɱɬɨ ɬɢɩ char* ɞɨɫɬɭɩɟɧ ɧɚɢɛɨɥɟɟ ɲɢɪɨɤɨɦɭ ɤɪɭɝɭ ɤɥɢ-
ɟɧɬɨɜ. Ʉ ɫɨɠɚɥɟɧɢɸ, ɷɬɨ ɬɚɤɠɟ ɧɚɢɛɨɥɟɟ ɧɢɡɤɨɭɪɨɜɧɟɜɵɣ ɜɚɪɢɚɧɬ; ɜ ɱɚɫɬɧɨɫɬɢ, ɨɧ ɛɨ-
ɥɟɟ ɩɪɨɛɥɟɦɚɬɢɱɟɧ (ɧɚɩɪɢɦɟɪ, ɜɵɡɵɜɚɸɳɢɣ ɢ ɜɵɡɵɜɚɟɦɵɣ ɤɨɞ ɞɨɥɠɧɵ ɹɜɧɨ ɪɟɲɢɬɶ,
ɤɬɨ ɢɦɟɧɧɨ ɜɵɞɟɥɹɟɬ ɩɚɦɹɬɶ ɞɥɹ ɫɬɪɨɤɢ ɢ ɤɬɨ ɟɟ ɨɫɜɨɛɨɠɞɚɟɬ), ɛɨɥɟɟ ɩɨɞɜɟɪɠɟɧ
ɨɲɢɛɤɚɦ (ɧɚɩɪɢɦɟɪ, ɮɚɣɥ ɦɨɠɟɬ ɧɟ ɫɭɳɟɫɬɜɨɜɚɬɶ), ɢ ɦɟɧɟɟ ɛɟɡɨɩɚɫɟɧ (ɧɚɩɪɢɦɟɪ, ɦɨ-
ɠɟɬ ɨɤɚɡɚɬɶɫɹ ɩɨɞɜɟɪɠɟɧ ɤɥɚɫɫɢɱɟɫɤɨɣ ɚɬɚɤɟ, ɨɫɧɨɜɚɧɧɨɣ ɧɚ ɩɟɪɟɩɨɥɧɟɧɢɢ ɛɭɮɟɪɚ).
• ȼɚɪɢɚɧɬ 2. string. Ɍɢɩ string ɞɨɫɬɭɩɟɧ ɦɟɧɶɲɟɦɭ ɤɪɭɝɭ ɤɥɢɟɧɬɨɜ, ɨɝɪɚɧɢɱɟɧɧɨɦɭ
ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ C++ ɢ ɤɨɦɩɢɥɹɰɢɟɣ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɬɨɣ ɠɟ ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ
ɛɢɛɥɢɨɬɟɤɢ, ɬɨɝɨ ɠɟ ɤɨɦɩɢɥɹɬɨɪɚ ɢ ɫɨɜɦɟɫɬɢɦɵɯ ɧɚɫɬɪɨɟɤ ɤɨɦɩɢɥɹɬɨɪɚ. ȼɡɚɦɟɧ ɦɵ ɩɨ-
ɥɭɱɚɟɦ ɦɟɧɟɟ ɩɪɨɛɥɟɦɚɬɢɱɧɵɣ (ɧɚɞɨ ɦɟɧɶɲɟ ɛɟɫɩɨɤɨɢɬɶɫɹ ɨɛ ɭɩɪɚɜɥɟɧɢɢ ɩɚɦɹɬɶɸ; ɨɞ-
ɧɚɤɨ ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 60) ɢ ɛɨɥɟɟ ɛɟɡɨɩɚɫɧɵɣ ɤɨɞ (ɧɚɩɪɢɦɟɪ, ɬɢɩ string ɭɜɟɥɢɱɢɜɚɟɬ
ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɫɜɨɣ ɛɭɮɟɪ ɢ ɧɟ ɬɚɤ ɩɨɞɜɟɪɠɟɧ ɚɬɚɤɚɦ ɧɚ ɨɫɧɨɜɟ ɩɟɪɟɩɨɥɧɟɧɢɹ ɛɭ-
ɮɟɪɚ). ɇɨ ɢ ɷɬɨɬ ɜɚɪɢɚɧɬ ɨɬɧɨɫɢɬɟɥɶɧɨ ɧɢɡɤɨɭɪɨɜɧɟɜɵɣ, ɚ ɩɨɬɨɦɭ ɬɚɤ ɠɟ ɨɬɤɪɵɬɵɣ ɞɥɹ
ɨɲɢɛɨɤ, ɤɚɤ ɢ ɩɪɟɞɵɞɭɳɢɣ (ɧɚɩɪɢɦɟɪ, ɭɤɚɡɚɧɧɵɣ ɮɚɣɥ ɦɨɠɟɬ ɢ ɧɟ ɫɭɳɟɫɬɜɨɜɚɬɶ).
Стр. 130
• ȼɚɪɢɚɧɬ 3. istream ɢɥɢ File. ȿɫɥɢ ɭɠ ɜɵ ɩɟɪɟɯɨɞɢɬɟ ɤ ɬɢɩɚɦ, ɹɜɥɹɸɳɢɦɫɹ ɤɥɚɫɫɚ-
ɦɢ, ɬ.ɟ. ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɬɪɟɛɭɟɬɫɹ, ɱɬɨɛɵ ɤɥɢɟɧɬ ɢɫɩɨɥɶɡɨɜɚɥ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ
C++, ɩɪɢɱɟɦ ɬɨɬ ɠɟ ɤɨɦɩɢɥɹɬɨɪ ɫ ɬɟɦɢ ɠɟ ɨɩɰɢɹɦɢ ɤɨɦɩɢɥɹɰɢɢ, ɬɨ ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ
ɩɪɟɢɦɭɳɟɫɬɜɚɦɢ ɚɛɫɬɪɚɤɰɢɢ: ɤɥɚɫɫ istream (ɢɥɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ ɤɥɚɫɫ File,
ɩɪɟɞɫɬɚɜɥɹɸɳɢɣ ɫɨɛɨɣ ɨɛɨɥɨɱɤɭ ɜɨɤɪɭɝ istream, ɩɨɡɜɨɥɹɸɳɭɸ ɭɫɬɪɚɧɢɬɶ ɡɚɜɢɫɢ-
ɦɨɫɬɶ ɨɬ ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ) ɩɨɜɵɲɚɟɬ ɭɪɨɜɟɧɶ ɚɛɫɬɪɚɤɰɢɢ ɢ ɞɟɥɚɟɬ
API ɫɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɩɪɨɛɥɟɦɚɬɢɱɧɵɦ. Ɏɭɧɤɰɢɹ ɩɨɥɭɱɚɟɬ ɨɛɴɟɤɬ ɬɢɩɚ File ɢɥɢ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɜɯɨɞɧɨɣ ɩɨɬɨɤ, ɨɧɚ ɧɟ ɞɨɥɠɧɚ ɡɚɛɨɬɢɬɶɫɹ ɨɛ ɭɩɪɚɜɥɟɧɢɢ ɩɚɦɹɬɶɸ
ɞɥɹ ɫɬɪɨɤ, ɫɨɞɟɪɠɚɳɢɯ ɢɦɹ ɮɚɣɥɚ, ɢ ɡɚɳɢɳɟɧɚ ɨɬ ɦɧɨɠɟɫɬɜɚ ɨɲɢɛɨɤ, ɤɨɬɨɪɵɟ ɜɩɨɥɧɟ
ɜɨɡɦɨɠɧɵ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɩɟɪɜɵɯ ɞɜɭɯ ɜɚɪɢɚɧɬɨɜ. Ɉɫɬɚɟɬɫɹ ɬɨɥɶɤɨ ɜɵɩɨɥɧɢɬɶ ɧɟ-
ɫɤɨɥɶɤɨ ɩɪɨɜɟɪɨɤ: ɮɚɣɥ ɞɨɥɠɟɧ ɛɵɬɶ ɨɬɤɪɵɬ, ɚ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ ɢɦɟɬɶ ɜɟɪɧɵɣ ɮɨɪɦɚɬ,
ɧɨ, ɜ ɩɪɢɧɰɢɩɟ, ɷɬɢɦ ɢ ɨɝɪɚɧɢɱɢɜɚɟɬɫɹ ɫɩɢɫɨɤ ɧɟɩɪɢɹɬɧɨɫɬɟɣ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɩɪɨ-
ɢɡɨɣɬɢ ɜ ɞɚɧɧɨɦ ɜɚɪɢɚɧɬɟ.
Ⱦɚɠɟ ɟɫɥɢ ɜɵ ɩɪɟɞɩɨɱɬɟɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜɨ ɜɧɟɲɧɟɦ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ ɧɢɡɤɨɭɪɨɜɧɟ-
ɜɨɣ ɚɛɫɬɪɚɤɰɢɟɣ, ɜɫɟɝɞɚ ɢɫɩɨɥɶɡɭɣɬɟ ɜɨ ɜɧɭɬɪɟɧɧɟɣ ɪɟɚɥɢɡɚɰɢɢ ɚɛɫɬɪɚɤɰɢɢ ɦɚɤɫɢɦɚɥɶɧɨ ɜɵ-
ɫɨɤɨɝɨ ɭɪɨɜɧɹ ɢ ɩɪɟɨɛɪɚɡɭɣɬɟ ɢɯ ɜ ɧɢɡɤɨɭɪɨɜɧɟɜɵɟ ɚɛɫɬɪɚɤɰɢɢ ɧɚ ɝɪɚɧɢɰɚɯ ɦɨɞɭɥɹ. ɇɚɩɪɢ-
ɦɟɪ, ɟɫɥɢ ɭ ɜɚɫ ɢɦɟɸɬɫɹ ɤɥɢɟɧɬɵ, ɧɟ ɢɫɩɨɥɶɡɭɸɳɢɟ C++, ɜɵ ɦɨɠɟɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɧɟɩɪɨ-
ɡɪɚɱɧɵɦ ɭɤɚɡɚɬɟɥɟɦ void* ɢɥɢ ɞɟɫɤɪɢɩɬɨɪɨɦ ɬɢɩɚ int ɞɥɹ ɪɚɛɨɬɵ ɫ ɤɥɢɟɧɬɨɦ, ɧɨ ɜɨ ɜɧɭɬ-
ɪɟɧɧɟɣ ɪɟɚɥɢɡɚɰɢɢ ɢɫɩɨɥɶɡɭɣɬɟ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɨɛɴɟɤɬɵ. ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ ɦɟɠɞɭ ɷɬɢɦɢ
ɨɛɴɟɤɬɚɦɢ ɢ ɜɵɛɪɚɧɧɵɦɢ ɧɢɡɤɨɭɪɨɜɧɟɜɵɦɢ ɬɢɩɚɦɢ ɜɵɩɨɥɧɹɣɬɟ ɬɨɥɶɤɨ ɜ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ.
Примеры
ɉɪɢɦɟɪ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ std::string ɜ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ. ɉɭɫɬɶ ɦɵ ɯɨɬɢɦ, ɱɬɨɛɵ ɦɨ-
ɞɭɥɶ ɩɪɟɞɨɫɬɚɜɥɹɥ ɫɥɟɞɭɸɳɭɸ ɮɭɧɤɰɢɸ API:
std::string Translate( const std::string& );
Ⱦɥɹ ɛɢɛɥɢɨɬɟɤ, ɢɫɩɨɥɶɡɭɟɦɵɯ ɜɧɭɬɪɢ ɨɞɧɨɣ ɤɨɦɚɧɞɵ ɤɨɦɩɚɧɢɢ, ɷɬɨ ɨɛɵɱɧɨ ɧɟɩɥɨɯɨɟ ɪɟɲɟ-
ɧɢɟ. ɇɨ ɟɫɥɢ ɜɵ ɩɥɚɧɢɪɭɟɬɟ ɞɢɧɚɦɢɱɟɫɤɢ ɤɨɦɩɨɧɨɜɚɬɶ ɞɚɧɧɵɣ ɦɨɞɭɥɶ ɫ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ,
ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɢɧɭɸ ɪɟɚɥɢɡɚɰɢɸ std::string (ɧɚɩɪɢɦɟɪ, ɢɧɨɟ ɪɚɡɦɟɳɟɧɢɟ ɜ ɩɚɦɹɬɢ), ɬɨ
ɢɡ-ɡɚ ɬɚɤɨɝɨ ɧɟɫɨɨɬɜɟɬɫɬɜɢɹ ɦɨɝɭɬ ɫɥɭɱɢɬɶɫɹ ɪɚɡɧɵɟ ɫɬɪɚɧɧɵɟ ɢ ɧɟɩɪɢɹɬɧɵɟ ɜɟɳɢ.
Ɇɵ ɜɫɬɪɟɱɚɥɢɫɶ ɫ ɪɚɡɪɚɛɨɬɱɢɤɚɦɢ, ɤɨɬɨɪɵɟ ɩɵɬɚɥɢɫɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɨɛɫɬɜɟɧɧɵɣ ɤɥɚɫɫ-
ɨɛɨɥɨɱɤɭ CustomString ɞɥɹ ɨɛɴɟɤɬɨɜ std::string, ɧɨ ɜ ɪɟɡɭɥɶɬɚɬɟ ɨɧɢ ɫɬɚɥɤɢɜɚɥɢɫɶ ɫ
ɬɨɣ ɠɟ ɩɪɨɛɥɟɦɨɣ, ɩɨɫɤɨɥɶɤɭ ɧɟ ɢɦɟɥɢ ɩɨɥɧɨɝɨ ɤɨɧɬɪɨɥɹ ɧɚɞ ɩɪɨɰɟɫɫɨɦ ɫɛɨɪɤɢ ɜɫɟɯ ɤɥɢɟɧɬ-
ɫɤɢɯ ɩɪɢɥɨɠɟɧɢɣ.
Ɉɞɧɨ ɢɡ ɪɟɲɟɧɢɣ ɫɨɫɬɨɢɬ ɜ ɩɟɪɟɯɨɞɟ ɤ ɩɟɪɟɧɨɫɢɦɵɦ (ɜɟɪɨɹɬɧɨ, ɜɫɬɪɨɟɧɧɵɦ) ɬɢɩɚɦ, ɤɚɤ
ɜɦɟɫɬɨ ɮɭɧɤɰɢɢ ɫ ɚɪɝɭɦɟɧɬɨɦ string, ɬɚɤ ɢ ɜ ɞɨɩɨɥɧɟɧɢɟ ɤ ɧɟɣ. Ɍɚɤɨɣ ɧɨɜɨɣ ɮɭɧɤɰɢɟɣ ɦɨ-
ɠɟɬ ɛɵɬɶ ɮɭɧɤɰɢɹ
void Translate( const char* src, char* dest, size_t destSize );
ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɧɢɡɤɨɭɪɨɜɧɟɜɨɣ ɚɛɫɬɪɚɤɰɢɢ ɛɨɥɟɟ ɩɟɪɟɧɨɫɢɦɨ, ɧɨ ɜɫɟɝɞɚ ɞɨɛɚɜɥɹɟɬ ɫɥɨɠ-
ɧɨɫɬɢ; ɡɞɟɫɶ, ɧɚɩɪɢɦɟɪ, ɤɚɤ ɜɵɡɵɜɚɸɳɢɣ, ɬɚɤ ɢ ɜɵɡɵɜɚɟɦɵɣ ɤɨɞ ɞɨɥɠɧɵ ɹɜɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɨɛɪɟɡɤɭ ɫɬɪɨɤɢ, ɟɫɥɢ ɪɚɡɦɟɪɚ ɛɭɮɟɪɚ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɞɨɫɬɚɬɨɱɧɨ. (Ɂɚɦɟɬɢɦ, ɱɬɨ ɞɚɧɧɚɹ ɜɟɪɫɢɹ
ɢɫɩɨɥɶɡɭɟɬ ɛɭɮɟɪ, ɜɵɞɟɥɹɟɦɵɣ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ, ɞɥɹ ɬɨɝɨ ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɥɨɜɭɲɤɢ, ɫɜɹ-
ɡɚɧɧɨɣ ɫ ɜɵɞɟɥɟɧɢɟɦ ɢ ɨɫɜɨɛɨɠɞɟɧɢɟɦ ɩɚɦɹɬɢ ɜ ɪɚɡɧɵɯ ɦɨɞɭɥɹɯ — ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 60.)
Ссылки
[McConnell93] §6 • [Meyers01] §15
63. Используйте достаточно переносимые типы в интерфейсах модулей 131
Стр. 131
Стр. 132
Шаблоны и обобщенность
Ɇɟɫɬɨ ɞɥɹ ɜɚɲɟɣ ɰɢɬɚɬɵ.
— Ȼɶɹɪɧ ɋɬɪɚɭɫɬɪɭɩ (Bjarne Stroustrup),
[Stroustrup00] §13
Ⱥɧɚɥɨɝɢɱɧɨ: ɦɟɫɬɨ ɞɥɹ ɜɚɲɟɝɨ ɜɜɟɞɟɧɢɹ.

ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 64 — “Ɋɚɡɭɦɧɨ ɫɨɱɟɬɚɣɬɟ
ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ”.
63. Используйте достаточно переносимые типы в интерфейсах модулей 133
Стр. 133
64. Разумно сочетайте статический
и динамический полиморфизм
Резюме
ɋɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɨɩɨɥɧɹɸɬ ɞɪɭɝ ɞɪɭɝɚ. ɋɥɟɞɭɟɬ ɹɫɧɨ ɩɪɟɞ-
ɫɬɚɜɥɹɬɶ ɫɟɛɟ ɢɯ ɩɪɟɢɦɭɳɟɫɬɜɚ ɢ ɧɟɞɨɫɬɚɬɤɢ, ɱɬɨɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɠɞɵɣ ɢɡ ɧɢɯ ɬɚɦ, ɝɞɟ ɨɧ
ɞɚɟɬ ɧɚɢɥɭɱɲɢɟ ɪɟɡɭɥɶɬɚɬɵ, ɢ ɫɨɱɟɬɚɬɶ ɢɯ ɬɚɤ, ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɥɭɱɲɟɟ ɢɡ ɨɛɨɢɯ ɦɢɪɨɜ.
Ⱦɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɩɪɟɞɫɬɚɟɬ ɩɟɪɟɞ ɧɚɦɢ ɜ ɮɨɪɦɟ ɤɥɚɫɫɨɜ ɫ ɜɢɪɬɭɚɥɶɧɵɦɢ
ɮɭɧɤɰɢɹɦɢ ɢ ɨɛɴɟɤɬɨɜ, ɪɚɛɨɬɚ ɫ ɤɨɬɨɪɵɦɢ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɤɨɫɜɟɧɧɨ — ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɢ ɢɥɢ
ɫɫɵɥɤɢ. ɋɬɚɬɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɜɤɥɸɱɚɟɬ ɲɚɛɥɨɧɵ ɤɥɚɫɫɨɜ ɢ ɮɭɧɤɰɢɣ.
ɉɨɥɢɦɨɪɮɢɡɦ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɞɚɧɧɨɟ ɡɧɚɱɟɧɢɟ ɦɨɠɟɬ ɢɦɟɬɶ ɧɟɫɤɨɥɶɤɨ ɬɢɩɨɜ, ɚ ɞɚɧɧɚɹ
ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɩɪɢɧɢɦɚɬɶ ɚɪɝɭɦɟɧɬɵ ɬɢɩɨɜ, ɨɬɥɢɱɚɸɳɢɯɫɹ ɨɬ ɬɨɱɧɵɯ ɬɢɩɨɜ ɟɟ ɩɚɪɚɦɟɬɪɨɜ.
“ɉɨɥɢɦɨɪɮɢɡɦ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɫɩɨɫɨɛ ɩɨɥɭɱɢɬɶ ɧɟɦɧɨɝɨ ɫɜɨɛɨɞɵ ɞɢɧɚɦɢɱɟɫɤɨɣ ɩɪɨɜɟɪ-
ɤɢ ɬɢɩɨɜ, ɧɟ ɬɟɪɹɹ ɩɪɟɢɦɭɳɟɫɬɜ ɫɬɚɬɢɱɟɫɤɨɣ ɩɪɨɜɟɪɤɢ” — [Webber03].
ɋɢɥɚ ɩɨɥɢɦɨɪɮɢɡɦɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɮɪɚɝɦɟɧɬ ɤɨɞɚ ɦɨɠɟɬ ɪɚɛɨɬɚɬɶ ɫ ɪɚɡ-
ɧɵɦɢ ɬɢɩɚɦɢ, ɞɚɠɟ ɫ ɬɟɦɢ, ɤɨɬɨɪɵɟ ɧɟ ɛɵɥɢ ɢɡɜɟɫɬɧɵ ɜ ɦɨɦɟɧɬ ɧɚɩɢɫɚɧɢɹ ɷɬɨɝɨ ɤɨɞɚ. Ɍɚɤɚɹ
“ɩɪɢɦɟɧɢɦɨɫɬɶ ɡɚɞɧɢɦ ɱɢɫɥɨɦ” ɹɜɥɹɟɬɫɹ ɤɪɚɟɭɝɨɥɶɧɵɦ ɤɚɦɧɟɦ ɩɨɥɢɦɨɪɮɢɡɦɚ, ɩɨɫɤɨɥɶɤɭ ɫɭ-
ɳɟɫɬɜɟɧɧɨ ɭɜɟɥɢɱɢɜɚɟɬ ɩɪɢɝɨɞɧɨɫɬɶ ɢ ɜɨɡɦɨɠɧɨɫɬɶ ɩɨɜɬɨɪɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɤɨɞɚ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 37). (ȼ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɷɬɨɦɭ ɦɨɧɨɦɨɪɮɧɵɣ ɤɨɞ ɪɚɛɨɬɚɟɬ ɬɨɥɶɤɨ ɫɨ ɫɬɪɨɝɨ ɤɨɧ-
ɤɪɟɬɧɵɦɢ ɬɢɩɚɦɢ, ɬɟɦɢ, ɞɥɹ ɪɚɛɨɬɵ ɫ ɤɨɬɨɪɵɦɢ ɨɧ ɢɡɧɚɱɚɥɶɧɨ ɫɨɡɞɚɜɚɥɫɹ.)
Ⱦɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɩɨɡɜɨɥɹɟɬ ɡɧɚɱɟɧɢɸ ɢɦɟɬɶ ɧɟɫɤɨɥɶɤɨ ɬɢɩɨɜ ɩɨɫɪɟɞɫɬɜɨɦ ɨɬ-
ɤɪɵɬɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ. ɇɚɩɪɢɦɟɪ, Derived*p ɦɨɠɧɨ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɤɚɤ ɭɤɚɡɚɬɟɥɶ ɧɟ ɬɨɥɶɤɨ
ɧɚ Derived, ɧɨ ɢ ɧɚ ɨɛɴɟɤɬ ɥɸɛɨɝɨ ɬɢɩɚ Base, ɤɨɬɨɪɵɣ ɩɪɹɦɨ ɢɥɢ ɤɨɫɜɟɧɧɨ ɹɜɥɹɟɬɫɹ ɛɚɡɨ-
ɜɵɦ ɞɥɹ Derived (ɫɜɨɣɫɬɜɨ ɤɚɬɟɝɨɪɢɡɚɰɢɢ). Ⱦɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɢɡɜɟɫɬɟɧ ɬɚɤɠɟ ɤɚɤ
ɜɤɥɸɱɚɸɳɢɣ ɩɨɥɢɦɨɪɮɢɡɦ, ɩɨɫɤɨɥɶɤɭ ɦɧɨɠɟɫɬɜɨ, ɦɨɞɟɥɢɪɭɟɦɨɟ Base, ɜɤɥɸɱɚɟɬ ɫɩɟɰɢɚɥɢ-
ɡɚɰɢɢ, ɦɨɞɟɥɢɪɭɟɦɵɟ Derived.
Ȼɥɚɝɨɞɚɪɹ ɫɜɨɢɦ ɯɚɪɚɤɬɟɪɢɫɬɢɤɚɦ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɜ C++ ɧɚɢɥɭɱɲɢɦ ɨɛɪɚ-
ɡɨɦ ɩɨɞɯɨɞɢɬ ɞɥɹ ɪɟɲɟɧɢɹ ɫɥɟɞɭɸɳɢɯ ɡɚɞɚɱ.
• ȿɞɢɧɨɨɛɪɚɡɧɚɹ ɪɚɛɨɬɚ, ɨɫɧɨɜɚɧɧɚɹ ɧɚ ɨɬɧɨɲɟɧɢɢ ɧɚɞɦɧɨɠɟɫɬɜɨ/ɩɨɞɦɧɨɠɟɫɬɜɨ. Ɋɚɛɨɬɚ
ɫ ɪɚɡɥɢɱɧɵɦɢ ɤɥɚɫɫɚɦɢ, ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɦɢ ɨɬɧɨɲɟɧɢɸ ɧɚɞɦɧɨɠɟɫɬɜɨ/ɩɨɞɦɧɨɠɟɫɬɜɨ
(ɛɚɡɨɜɵɣ/ɩɪɨɢɡɜɨɞɧɵɣ), ɦɨɠɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɟɞɢɧɨɨɛɪɚɡɧɨ. Ɏɭɧɤɰɢɹ, ɪɚɛɨɬɚɸɳɚɹ ɫ ɨɛɴɟɤ-
ɬɨɦ Employee (ɋɥɭɠɚɳɢɣ), ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ ɢ ɫ ɨɛɴɟɤɬɚɦɢ Secretary (ɋɟɤɪɟɬɚɪɶ).
• ɋɬɚɬɢɱɟɫɤɚɹ ɩɪɨɜɟɪɤɚ ɬɢɩɨɜ. ȼ C++ ɜɫɟ ɬɢɩɵ ɩɪɨɜɟɪɹɸɬɫɹ ɫɬɚɬɢɱɟɫɤɢ.
• Ⱦɢɧɚɦɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ ɢ ɪɚɡɞɟɥɶɧɚɹ ɤɨɦɩɢɥɹɰɢɹ. Ʉɨɞ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɢɟɪɚɪɯɢɸ
ɤɥɚɫɫɨɜ, ɦɨɠɟɬ ɤɨɦɩɢɥɢɪɨɜɚɬɶɫɹ ɨɬɞɟɥɶɧɨ ɨɬ ɷɬɨɣ ɢɟɪɚɪɯɢɢ. ɗɬɨ ɫɬɚɧɨɜɢɬɫɹ ɜɨɡɦɨɠɧɵɦ
ɛɥɚɝɨɞɚɪɹ ɤɨɫɜɟɧɧɨɫɬɢ, ɨɛɟɫɩɟɱɢɜɚɟɦɨɣ ɭɤɚɡɚɬɟɥɹɦɢ (ɤɚɤ ɧɚ ɨɛɴɟɤɬɵ, ɬɚɤ ɢ ɧɚ ɮɭɧɤɰɢɢ).
• Ȼɢɧɚɪɧɚɹ ɫɨɝɥɚɫɨɜɚɧɧɨɫɬɶ. Ɇɨɞɭɥɢ ɦɨɝɭɬ ɤɨɦɩɨɧɨɜɚɬɶɫɹ ɤɚɤ ɫɬɚɬɢɱɟɫɤɢ, ɬɚɤ ɢ ɞɢɧɚ-
ɦɢɱɟɫɤɢ, ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɫɯɟɦɵ ɜɢɪɬɭɚɥɶɧɵɯ ɬɚɛɥɢɰ ɩɨɞɱɢɧɹɸɬɫɹ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ
ɩɪɚɜɢɥɚɦ.
ɋɬɚɬɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɩɨɫɪɟɞɫɬɜɨɦ ɲɚɛɥɨɧɨɜ ɬɚɤɠɟ ɩɨɡɜɨɥɹɟɬ ɡɧɚɱɟɧɢɸ ɢɦɟɬɶ ɧɟ-
ɫɤɨɥɶɤɨ ɬɢɩɨɜ. ȼɧɭɬɪɢ ɲɚɛɥɨɧɚ
template<class T> void f( T t ) { /* ... */ }
t ɦɨɠɟɬ ɢɦɟɬɶ ɥɸɛɨɣ ɬɢɩ, ɤɨɬɨɪɵɣ ɦɨɠɧɨ ɩɨɞɫɬɚɜɢɬɶ ɜ f ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɤɨɦɩɢɥɢɪɭɟɦɨɝɨ
ɤɨɞɚ. ɗɬɨ ɧɚɡɵɜɚɟɬɫɹ “ɧɟɹɜɧɵɦ ɢɧɬɟɪɮɟɣɫɨɦ” ɜ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɹɜɧɨɦɭ ɢɧɬɟɪɮɟɣɫɭ
134 Шаблоны и обобщенность
Стр. 134
ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ ɞɨɫɬɢɝɚɟɬɫɹ ɬɚ ɠɟ ɰɟɥɶ ɩɨɥɢɦɨɪɮɢɡɦɚ — ɧɚɩɢɫɚɧɢɟ ɤɨɞɚ, ɤɨ-
ɬɨɪɵɣ ɪɚɛɨɬɚɟɬ ɫ ɪɚɡɧɵɦɢ ɬɢɩɚɦɢ — ɧɨ ɫɨɜɟɪɲɟɧɧɨ ɢɧɵɦ ɩɭɬɟɦ.
ɋɬɚɬɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɧɚɢɥɭɱɲɢɦ ɨɛɪɚɡɨɦ ɩɨɞɯɨɞɢɬ ɞɥɹ ɪɟɲɟɧɢɹ ɫɥɟɞɭɸɳɢɯ ɡɚɞɚɱ.
• ȿɞɢɧɨɨɛɪɚɡɧɚɹ ɪɚɛɨɬɚ, ɨɫɧɨɜɚɧɧɚɹ ɧɚ ɫɢɧɬɚɤɫɢɱɟɫɤɨɦ ɢ ɫɟɦɚɧɬɢɱɟɫɤɨɦ ɢɧɬɟɪɮɟɣɫɟ.
Ɋɚɛɨɬɚ ɫ ɬɢɩɚɦɢ, ɤɨɬɨɪɵɟ ɩɨɞɱɢɧɹɸɬɫɹ ɫɢɧɬɚɤɫɢɱɟɫɤɨɦɭ ɢ ɫɟɦɚɧɬɢɱɟɫɤɨɦɭ ɢɧɬɟɪɮɟɣ-
ɫɭ, ɦɨɠɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɟɞɢɧɨɨɛɪɚɡɧɨ. ɂɧɬɟɪɮɟɣɫɵ ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ ɩɪɟɞɫɬɚɜɥɹɸɬ
ɫɢɧɬɚɤɫɢɱɟɫɤɭɸ ɫɭɳɧɨɫɬɶ ɢ ɧɟ ɨɫɧɨɜɚɧɵ ɧɚ ɫɢɝɧɚɬɭɪɚɯ, ɬɚɤ ɱɬɨ ɞɨɩɭɫɬɢɦɚ ɩɨɞɫɬɚɧɨɜ-
ɤɚ ɥɸɛɨɝɨ ɬɢɩɚ, ɤɨɬɨɪɵɣ ɭɞɨɜɥɟɬɜɨɪɹɟɬ ɞɚɧɧɨɦɭ ɫɢɧɬɚɤɫɢɫɭ. ɇɚɩɪɢɦɟɪ, ɩɭɫɬɶ ɞɚɧɚ
ɢɧɫɬɪɭɤɰɢɹ int i = p->f(5);. ȿɫɥɢ p — ɭɤɚɡɚɬɟɥɶ ɧɚ ɤɥɚɫɫ Base, ɷɬɚ ɢɧɫɬɪɭɤɰɢɹ
ɜɵɡɵɜɚɟɬ ɨɩɪɟɞɟɥɟɧɧɭɸ ɮɭɧɤɰɢɸ ɢɧɬɟɪɮɟɣɫɚ, ɜɟɪɨɹɬɧɨ, virtual int f(int). ɇɨ
ɟɫɥɢ p ɢɦɟɟɬ ɨɛɨɛɳɟɧɧɵɣ ɬɢɩ, ɬɨ ɷɬɨɬ ɜɵɡɨɜ ɦɨɠɟɬ ɛɵɬɶ ɫɜɹɡɚɧ ɫɨ ɦɧɨɠɟɫɬɜɨɦ ɪɚɡ-
ɥɢɱɧɵɯ ɜɟɳɟɣ, ɜɤɥɸɱɚɹ, ɧɚɩɪɢɦɟɪ, ɜɵɡɨɜ ɩɟɪɟɝɪɭɠɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ operator->,
ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ ɬɢɩ, ɜ ɤɨɬɨɪɨɦ ɨɩɪɟɞɟɥɟɧɚ ɮɭɧɤɰɢɹ X f(double), ɝɞɟ X — ɬɢɩ,
ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧ ɜ int.
• ɋɬɚɬɢɱɟɫɤɚɹ ɩɪɨɜɟɪɤɚ ɬɢɩɨɜ. ȼɫɟ ɬɢɩɵ ɩɪɨɜɟɪɹɸɬɫɹ ɫɬɚɬɢɱɟɫɤɢ.
• ɋɬɚɬɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ (ɦɟɲɚɟɬ ɪɚɡɞɟɥɶɧɨɣ ɤɨɦɩɢɥɹɰɢɢ). ȼɫɟ ɬɢɩɵ ɫɜɹɡɵɜɚɸɬɫɹ
ɫɬɚɬɢɱɟɫɤɢ.
• ɗɮɮɟɤɬɢɜɧɨɫɬɶ. ȼɵɱɢɫɥɟɧɢɹ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ ɢ ɫɬɚɬɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ ɩɨɡɜɨɥɹ-
ɸɬ ɞɨɫɬɢɱɶ ɨɩɬɢɦɢɡɚɰɢɢ ɢ ɷɮɮɟɤɬɢɜɧɨɫɬɢ, ɧɟɞɨɫɬɭɩɧɵɯ ɩɪɢ ɞɢɧɚɦɢɱɟɫɤɨɦ ɫɜɹɡɵɜɚɧɢɢ.
Ɉɩɪɟɞɟɥɢɬɟ ɜɚɲɢ ɩɪɢɨɪɢɬɟɬɵ ɢ ɢɫɩɨɥɶɡɭɣɬɟ ɤɚɠɞɵɣ ɜɢɞ ɩɨɥɢɦɨɪɮɢɡɦɚ ɬɚɦ, ɝɞɟ ɩɪɨɹɜ-
ɥɹɸɬɫɹ ɟɝɨ ɫɢɥɶɧɵɟ ɫɬɨɪɨɧɵ.
ɋɥɟɞɭɟɬ ɫɨɱɟɬɚɬɶ ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɩɪɟ-
ɢɦɭɳɟɫɬɜɚ ɨɛɨɢɯ ɜɢɞɨɜ ɩɨɥɢɦɨɪɮɢɡɦɚ, ɚ ɧɟ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɤɨɦɛɢɧɢɪɨɜɚɬɶ ɢɯ ɧɟɞɨɫɬɚɬɤɢ.
• ɋɬɚɬɢɤɚ ɩɨɦɨɝɚɟɬ ɞɢɧɚɦɢɤɟ. ɂɫɩɨɥɶɡɭɣɬɟ ɫɬɚɬɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ
ɞɢɧɚɦɢɱɟɫɤɢ ɩɨɥɢɦɨɪɮɧɵɯ ɢɧɬɟɪɮɟɣɫɨɜ. ɇɚɩɪɢɦɟɪ, ɭ ɜɚɫ ɦɨɠɟɬ ɛɵɬɶ ɚɛɫɬɪɚɤɬɧɵɣ
ɛɚɡɨɜɵɣ ɤɥɚɫɫ Command, ɢ ɜɵ ɨɩɪɟɞɟɥɹɟɬɟ ɪɚɡɥɢɱɧɵɟ ɪɟɚɥɢɡɚɰɢɢ ɜ ɜɢɞɟ ɲɚɛɥɨɧɚ
template</* ... */> class ConcreteCommand: public Command
ȼ ɤɚɱɟɫɬɜɟ ɩɪɢɦɟɪɨɜ ɦɨɠɧɨ ɩɪɢɜɟɫɬɢ ɪɟɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Com-
mand ɢ Visitor (ɫɦ. [Alexandrescu01] ɢ [Sutter04]).
• Ⱦɢɧɚɦɢɤɚ ɩɨɦɨɝɚɟɬ ɫɬɚɬɢɤɟ. Ɉɛɨɛɳɟɧɧɵɣ, ɭɞɨɛɧɵɣ, ɫɬɚɬɢɱɟɫɤɢ ɫɜɹɡɵɜɚɟɦɵɣ ɢɧ-
ɬɟɪɮɟɣɫ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜɧɭɬɪɟɧɧɸɸ ɞɢɧɚɦɢɱɟɫɤɭɸ ɞɢɫɩɟɬɱɟɪɢɡɚɰɢɸ, ɱɬɨ ɩɨ-
ɡɜɨɥɹɟɬ ɨɛɟɫɩɟɱɢɬɶ ɨɞɢɧɚɤɨɜɭɸ ɫɯɟɦɭ ɪɚɡɦɟɳɟɧɢɹ ɨɛɴɟɤɬɨɜ. ɏɨɪɨɲɢɦɢ ɩɪɢɦɟɪɚɦɢ
ɦɨɝɭɬ ɫɥɭɠɢɬɶ ɪɟɚɥɢɡɚɰɢɢ ɪɚɡɦɟɱɟɧɧɵɯ ɨɛɴɟɞɢɧɟɧɢɣ (ɫɦ. [Alexandrescu02b] ɢ [Boost])
ɢ ɩɚɪɚɦɟɬɪ Deleter ɭ tr1::shared_ptr (ɫɦ. [C++TR104]).
• ɉɪɨɱɢɟ ɫɨɱɟɬɚɧɢɹ. ɉɥɨɯɢɦ ɹɜɥɹɟɬɫɹ ɫɨɱɟɬɚɧɢɟ, ɩɪɢ ɤɨɬɨɪɨɦ ɤɨɦɛɢɧɢɪɭɸɬɫɹ ɫɥɚɛɵɟ
ɫɬɨɪɨɧɵ ɨɛɨɢɯ ɜɢɞɨɜ ɩɨɥɢɦɨɪɮɢɡɦɚ ɢ ɪɟɡɭɥɶɬɚɬ ɩɨɥɭɱɚɟɬɫɹ ɯɭɠɟ, ɱɟɦ ɩɪɢ ɢɯ ɨɬɞɟɥɶɧɨɦ
ɢɫɩɨɥɶɡɨɜɚɧɢɢ. ɉɪɚɜɢɥɶɧɨɟ ɫɨɱɟɬɚɧɢɟ ɞɨɥɠɧɨ ɤɨɦɛɢɧɢɪɨɜɚɬɶ ɥɭɱɲɟɟ ɨɬ ɨɛɨɢɯ ɜɢɞɨɜ
ɩɨɥɢɦɨɪɮɢɡɦɚ. ɇɚɩɪɢɦɟɪ, ɧɟ ɩɨɦɟɳɚɣɬɟ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɜ ɲɚɛɥɨɧ ɤɥɚɫɫɚ, ɟɫɥɢ
ɬɨɥɶɤɨ ɜɵ ɧɟ ɯɨɬɢɬɟ, ɱɬɨɛɵ ɤɚɠɞɵɣ ɪɚɡ ɢɧɫɬɚɧɰɢɪɨɜɚɥɢɫɶ ɜɫɟ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ
(ɜ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɧɟɜɢɪɬɭɚɥɶɧɵɦ ɮɭɧɤɰɢɹɦ ɲɚɛɥɨɧɧɵɯ ɬɢɩɨɜ). ȼ ɪɟɡɭɥɶɬɚɬɟ ɜɵ
ɦɨɠɟɬɟ ɩɨɥɭɱɢɬɶ ɚɫɬɪɨɧɨɦɢɱɟɫɤɢɣ ɪɚɡɦɟɪ ɤɨɞɚ ɢ ɱɪɟɡɦɟɪɧɨ ɨɝɪɚɧɢɱɢɬɶ ɜɚɲ ɨɛɨɛɳɟɧ-
ɧɵɣ ɬɢɩ, ɢɧɫɬɚɧɰɢɪɭɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ, ɤɨɬɨɪɚɹ ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ.
Ссылки
[Alexandrescu01] §10 • [Alexandrescu02b] • [C++TR104] • [Gamma95] • [Musser01] §1.2-3, §17 •
[Stroustrup00] §24.4.1 • [Sutter00] §3 • [Sutter02] §1 • [Sutter04] §17, §35 • [Vandevoorde03] §14 •
[Webber03] §8.6
64. Разумно сочетайте статический и динамический полиморфизм 135
Стр. 135
65. Выполняйте настройку явно
и преднамеренно
Резюме
ɉɪɢ ɪɚɡɪɚɛɨɬɤɟ ɲɚɛɥɨɧɚ ɬɨɱɤɢ ɧɚɫɬɪɨɣɤɢ ɞɨɥɠɧɵ ɛɵɬɶ ɧɚɩɢɫɚɧɵ ɤɨɪɪɟɤɬɧɨ, ɫ ɨɫɨɛɨɣ
ɬɳɚɬɟɥɶɧɨɫɬɶɸ, ɚ ɬɚɤɠɟ ɹɫɧɨ ɩɪɨɤɨɦɦɟɧɬɢɪɨɜɚɧɵ. ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɲɚɛɥɨɧɚ ɧɟɨɛɯɨɞɢɦɨ
ɱɟɬɤɨ ɡɧɚɬɶ, ɤɚɤ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɧɚɫɬɪɨɢɬɶ ɲɚɛɥɨɧ ɞɥɹ ɪɚɛɨɬɵ ɫ ɜɚɲɢɦ ɬɢɩɨɦ, ɢ ɜɵɩɨɥɧɢɬɶ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɥɨɜɭɲɤɚ ɩɪɢ ɧɚɩɢɫɚɧɢɢ ɛɢɛɥɢɨɬɟɤ ɲɚɛɥɨɧɨɜ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɧɚɥɢɱɢɢ
ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɵɯ ɬɨɱɟɤ ɧɚɫɬɪɨɣɤɢ, ɬ.ɟ. ɬɨɱɟɤ ɜ ɜɚɲɟɦ ɲɚɛɥɨɧɟ, ɝɞɟ ɦɨɠɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɩɨ-
ɢɫɤ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɤɨɞɚ ɢ ɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ, ɧɨ ɩɪɢ ɧɚɩɢɫɚɧɢɢ ɬɚɤɢɟ ɞɟɣɫɬɜɢɹ ɜɚɦɢ ɧɟ
ɩɨɞɪɚɡɭɦɟɜɚɥɢɫɶ. ɉɨɩɚɫɬɶ ɜ ɬɚɤɭɸ ɥɨɜɭɲɤɭ ɨɱɟɧɶ ɥɟɝɤɨ — ɞɨɫɬɚɬɨɱɧɨ ɩɪɨɫɬɨ ɜɵɡɜɚɬɶ ɞɪɭ-
ɝɭɸ ɮɭɧɤɰɢɸ ɢɥɢ ɨɩɟɪɚɬɨɪ ɨɛɵɱɧɵɦ ɩɭɬɟɦ (ɛɟɡ ɩɨɥɧɨɣ ɟɝɨ ɤɜɚɥɢɮɢɤɚɰɢɢ), ɢ ɟɫɥɢ ɨɤɚɠɟɬɫɹ,
ɱɬɨ ɨɞɢɧ ɢɡ ɟɝɨ ɚɪɝɭɦɟɧɬɨɜ ɢɦɟɟɬ ɬɢɩ ɩɚɪɚɦɟɬɪɚ ɲɚɛɥɨɧɚ (ɢɥɢ ɫɜɹɡɚɧɧɵɣ ɫ ɧɢɦ), ɬɨ ɛɭɞɟɬ
ɧɚɱɚɬ ɩɨɢɫɤ ɬɚɤɨɝɨ ɤɨɞɚ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ. ɉɪɢɦɟɪɨɜ ɬɨɦɭ ɦɧɨɠɟɫɬɜɨ; ɜ ɱɚɫɬɧɨɫɬɢ,
ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 58.
ɉɨɷɬɨɦɭ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɚɤɢɟ ɬɨɱɤɢ ɩɪɟɞɧɚɦɟɪɟɧɧɨ. ɋɥɟɞɭɟɬ ɡɧɚɬɶ ɬɪɢ ɨɫɧɨɜɧɵɯ
ɩɭɬɢ ɨɛɟɫɩɟɱɟɧɢɹ ɬɨɱɟɤ ɧɚɫɬɪɨɣɤɢ ɜ ɲɚɛɥɨɧɟ, ɪɟɲɢɬɶ, ɤɚɤɨɣ ɢɦɟɧɧɨ ɫɩɨɫɨɛ ɜɵ ɯɨɬɢɬɟ ɢɫ-
ɩɨɥɶɡɨɜɚɬɶ ɜ ɞɚɧɧɨɦ ɦɟɫɬɟ ɲɚɛɥɨɧɚ, ɢ ɤɨɪɪɟɤɬɧɨ ɟɝɨ ɡɚɤɨɞɢɪɨɜɚɬɶ. Ɂɚɬɟɦ ɩɪɨɜɟɪɶɬɟ, ɧɟ ɨɫɬɚ-
ɥɨɫɶ ɥɢ ɜ ɜɚɲɟɦ ɤɨɞɟ ɫɥɭɱɚɣɧɵɯ ɬɨɱɟɤ ɧɚɫɬɪɨɣɤɢ ɬɚɦ, ɝɞɟ ɜɵ ɧɟ ɩɪɟɞɩɨɥɚɝɚɥɢ ɢɯ ɧɚɥɢɱɢɟ.
ɉɟɪɜɵɣ ɫɩɨɫɨɛ ɫɨɡɞɚɧɢɹ ɬɨɱɤɢ ɧɚɫɬɪɨɣɤɢ — ɨɛɵɱɧɵɣ “ɧɟɹɜɧɵɣ ɢɧɬɟɪɮɟɣɫ” (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 64), ɤɨɝɞɚ ɜɚɲ ɲɚɛɥɨɧ ɩɪɨɫɬɨ ɪɚɫɫɱɢɬɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɬɢɩ ɢɦɟɟɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ
ɱɥɟɧ ɫ ɞɚɧɧɵɦ ɢɦɟɧɟɦ:
// ǍǫǻǳǫǸǽ 1. ǜǹǲǯǫǸǳǰ ǽǹȂǵǳ ǸǫǼǽǻǹǴǵǳ ǺǾǽǰǷ ǽǻǰǬǹǭǫǸǳȊ ǹǽ
// ǽǳǺǫ T "foo-ǼǹǭǷǰǼǽǳǷǹǼǽǳ", ǽ.ǰ. ǸǫǶǳȂǳȊ ǿǾǸǵȁǳǳ-ȂǶǰǸǫ Ǽ
// ǯǫǸǸȆǷ ǳǷǰǸǰǷ, ǼǳǮǸǫǽǾǻǹǴ ǳ ǼǰǷǫǸǽǳǵǹǴ
void Sample1( T t ) {
t.foo(); // foo - ǽǹȂǵǫ ǸǫǼǽǻǹǴǵǳ
typename T::value_type x; // ǐȄǰ ǹǯǳǸ ǺǻǳǷǰǻ: ǼǹǲǯǫǸǳǰ
} // ǽǹȂǵǳ ǸǫǼǽǻǹǴǵǳ ǯǶȊ ǺǹǳǼǵǫ
// ǽǳǺǫ (ǹǬȆȂǸǹ ǼǹǲǯǫǰǽǼȊ ǺǹǼǻǰǯǼǽǭǹǷ typedef)
Ⱦɥɹ ɪɟɚɥɢɡɚɰɢɢ ɩɟɪɜɨɝɨ ɜɚɪɢɚɧɬɚ ɚɜɬɨɪ Sample1 ɞɨɥɠɟɧ ɜɵɩɨɥɧɢɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
• ȼɵɡɜɚɬɶ ɮɭɧɤɰɢɸ ɤɚɤ ɱɥɟɧ. ɉɪɨɫɬɨ ɢɫɩɨɥɶɡɭɣɬɟ ɟɫɬɟɫɬɜɟɧɧɵɣ ɫɢɧɬɚɤɫɢɫ ɜɵɡɨɜɚ
ɮɭɧɤɰɢɢ-ɱɥɟɧɚ.
• Ⱦɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɬɨɱɤɭ ɧɚɫɬɪɨɣɤɢ. Ɍɢɩ ɞɨɥɠɟɧ ɨɛɟɫɩɟɱɢɬɶ ɞɨɫɬɭɩɧɭɸ ɮɭɧɤɰɢɸ-
ɱɥɟɧ foo, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧɚ ɫ ɞɚɧɧɵɦɢ ɚɪɝɭɦɟɧɬɚɦɢ (ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ —
ɛɟɡ ɚɪɝɭɦɟɧɬɨɜ).
ȼɬɨɪɨɣ ɜɚɪɢɚɧɬ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɦɟɬɨɞɚ “ɧɟɹɜɧɨɝɨ ɢɧɬɟɪɮɟɣɫɚ”, ɧɨ
ɫ ɮɭɧɤɰɢɹɦɢ, ɧɟ ɹɜɥɹɸɳɢɦɢɫɹ ɱɥɟɧɚɦɢ, ɩɨɢɫɤ ɤɨɬɨɪɵɯ ɜɵɩɨɥɧɹɟɬɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ADL3
(ɬ.ɟ. ɨɠɢɞɚɟɬɫɹ, ɱɬɨ ɞɚɧɧɚɹ ɮɭɧɤɰɢɹ ɧɚɯɨɞɢɬɫɹ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɬɢɩɚ, ɞɥɹ ɤɨɬɨɪɨɝɨ ɜɵɩɨɥ-
ɧɹɟɬɫɹ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɟ ɲɚɛɥɨɧɚ). ɂɦɟɧɧɨ ɷɬɚ ɫɢɬɭɚɰɢɹ ɢ ɹɜɢɥɚɫɶ ɨɫɧɨɜɧɨɣ ɩɨɛɭɞɢɬɟɥɶɧɨɣ
3
ɉɨɢɫɤ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ (ɫɦ. ɫɬɪ. 118). — ɉɪɢɦ. ɩɟɪɟɜ.
Стр. 136
ɩɪɢɱɢɧɨɣ ɞɥɹ ɜɜɟɞɟɧɢɹ ADL (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ȼɚɲ ɲɚɛɥɨɧ ɪɚɫɫɱɢɬɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɞɥɹ
ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɬɢɩɚ ɢɦɟɟɬɫɹ ɩɨɞɯɨɞɹɳɚɹ ɮɭɧɤɰɢɹ ɫ ɡɚɞɚɧɧɵɦ ɢɦɟɧɟɦ:
// ǍǫǻǳǫǸǽ 2: ǜǹǲǯǫǸǳǰ ǽǹȂǵǳ ǸǫǼǽǻǹǴǵǳ ǺǾǽǰǷ ǽǻǰǬǹǭǫǸǳȊ ǹǽ
// ǽǳǺǫ T "foo-ǼǹǭǷǰǼǽǳǷǹǼǽǳ", ǽ.ǰ. ǸǫǶǳȂǳȊ ǿǾǸǵȁǳǳ, Ǹǰ
// ȊǭǶȊȉȄǰǴǼȊ ȂǶǰǸǹǷ Ǽ ǯǫǸǸȆǷ ǳǷǰǸǰǷ, ǼǳǮǸǫǽǾǻǹǴ ǳ
// ǼǰǷǫǸǽǳǵǹǴ, ǺǹǳǼǵ ǵǹǽǹǻǹǴ ǭȆǺǹǶǸȊǰǽǼȊ ǺǹǼǻǰǯǼǽǭǹǷ ADL.
// (Ǩǽǹ ǰǯǳǸǼǽǭǰǸǸȆǴ ǭǫǻǳǫǸǽ, Ǻǻǳ ǵǹǽǹǻǹǷ Ǹǰ ǽǻǰǬǾǰǽǼȊ ǺǹǳǼǵ
// ǼǫǷǹǮǹ ǽǳǺǫ T.)
foo( t ); // foo - ǽǹȂǵǫ ǸǫǼǽǻǹǴǵǳ
cout << t; // ǐȄǰ ǹǯǳǸ ǺǻǳǷǰǻ - operator<< Ǽ ǲǫǺǳǼȇȉ ǭ
} // ǭǳǯǰ ǹǺǰǻǫǽǹǻǫ ǺǻǰǯǼǽǫǭǶȊǰǽ ǼǹǬǹǴ ǽǫǵǾȉ Ǳǰ
// ǽǹȂǵǾ ǸǫǼǽǻǹǴǵǳ
Ⱦɥɹ ɪɟɚɥɢɡɚɰɢɢ ɜɚɪɢɚɧɬɚ 2 ɚɜɬɨɪ Sample2 ɞɨɥɠɟɧ ɜɵɩɨɥɧɢɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
• ȼɵɡɜɚɬɶ ɮɭɧɤɰɢɸ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɧɟɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɨɝɨ ɢɦɟɧɢ (ɜɤɥɸɱɚɹ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟ ɟɫɬɟɫɬɜɟɧɧɨɝɨ ɫɢɧɬɚɤɫɢɫɚ ɜ ɫɥɭɱɚɟ ɨɩɟɪɚɬɨɪɨɜ) ɢ ɭɛɟɞɢɬɶɫɹ, ɱɬɨ ɲɚɛɥɨɧ ɧɟ ɢɦɟɟɬ
ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɫ ɬɟɦ ɠɟ ɢɦɟɧɟɦ. ȼ ɫɥɭɱɚɟ ɲɚɛɥɨɧɨɜ ɨɱɟɧɶ ɜɚɠɧɨ, ɱɬɨɛɵ ɜɵɡɨɜ ɮɭɧɤɰɢɢ
ɛɵɥ ɧɟ ɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɵɦ (ɧɚɩɪɢɦɟɪ, ɧɟ ɫɥɟɞɭɟɬ ɩɢɫɚɬɶ SomeNamespace::foo(t))
ɢ ɱɬɨɛɵ ɭ ɲɚɛɥɨɧɚ ɧɟ ɛɵɥɨ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɫ ɬɟɦ ɠɟ ɢɦɟɧɟɦ, ɩɨɫɤɨɥɶɤɭ ɜ ɨɛɨɢɯ ɷɬɢɯ ɫɥɭɱɚ-
ɹɯ ɩɨɢɫɤ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ, ɜɵɩɨɥɧɹɬɶɫɹ ɧɟ ɛɭɞɟɬ, ɱɬɨ ɩɪɟɞɨɬɜɪɚɬɢɬ ɩɨɢɫɤ ɢɦɟɧɢ
ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɜ ɤɨɬɨɪɨɦ ɧɚɯɨɞɢɬɫɹ ɬɢɩ T.
• Ⱦɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɬɨɱɤɭ ɧɚɫɬɪɨɣɤɢ. Ɍɢɩ ɞɨɥɠɟɧ ɨɛɟɫɩɟɱɢɬɶ ɧɚɥɢɱɢɟ ɮɭɧɤɰɢɢ, ɧɟ ɹɜ-
ɥɹɸɳɟɣɫɹ ɱɥɟɧɨɦ, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧɚ ɫ ɞɚɧɧɵɦɢ ɚɪɝɭɦɟɧɬɚɦɢ.
ȼɚɪɢɚɧɬɵ 1 ɢ 2 ɢɦɟɸɬ ɨɞɢɧɚɤɨɜɵɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɢ ɩɪɢɦɟɧɢɦɨɫɬɶ: ɩɨɥɶɡɨɜɚɬɟɥɶ ɦɨɠɟɬ
ɨɞɢɧ ɪɚɡ ɧɚɩɢɫɚɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ ɮɭɧɤɰɢɸ ɧɚɫɬɪɨɣɤɢ ɞɥɹ ɫɜɨɟɝɨ ɬɢɩɚ ɢ ɪɚɡɦɟɫɬɢɬɶ ɟɟ ɬɚɦ,
ɝɞɟ ɟɟ ɫɦɨɝɭɬ ɧɚɣɬɢ ɢ ɲɚɛɥɨɧɵ ɞɪɭɝɢɯ ɛɢɛɥɢɨɬɟɤ. Ɍɟɦ ɫɚɦɵɦ ɩɨɥɶɡɨɜɚɬɟɥɶ ɢɡɛɟɝɚɟɬ ɧɟɨɛɯɨɞɢ-
ɦɨɫɬɢ ɩɢɫɚɬɶ ɦɧɨɠɟɫɬɜɨ ɦɟɥɤɢɯ ɚɞɚɩɬɟɪɨɜ ɞɥɹ ɤɚɠɞɨɣ ɛɢɛɥɢɨɬɟɤɢ ɨɬɞɟɥɶɧɨ. ɇɟɞɨɫɬɚɬɨɤ ɠɟ ɡɚ-
ɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɚɹ ɫɟɦɚɧɬɢɤɚ ɞɨɥɠɧɚ ɛɵɬɶ ɞɨɫɬɚɬɨɱɧɨ ɲɢɪɨɤɨ ɩɪɢɦɟɧɢɦɚ
ɢ ɢɦɟɬɶ ɫɦɵɫɥ ɞɥɹ ɜɫɟɯ ɬɚɤɨɝɨ ɪɨɞɚ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɩɪɢɦɟɧɟɧɢɣ (ɡɚɦɟɬɢɦ, ɱɬɨ ɜ ɱɚɫɬɧɨɫɬɢ ɜ ɷɬɭ
ɤɚɬɟɝɨɪɢɸ ɩɨɩɚɞɚɸɬ ɨɩɟɪɚɬɨɪɵ, ɱɬɨ ɹɜɥɹɟɬɫɹ ɟɳɟ ɨɞɧɨɣ ɩɪɢɱɢɧɨɣ ɞɥɹ ɪɟɤɨɦɟɧɞɚɰɢɢ 26).
Ɍɪɟɬɢɣ ɜɚɪɢɚɧɬ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɫɩɟɰɢɚɥɢɡɚɰɢɢ, ɤɨɝɞɚ ɜɚɲ ɲɚɛɥɨɧ ɩɨɥɚɝɚɟɬ-
ɫɹ ɧɚ ɬɨ, ɱɬɨ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ ɬɢɩ ɫɩɟɰɢɚɥɢɡɢɪɭɟɬ (ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ) ɧɟɤɨɬɨɪɵɣ ɢɧɨɣ
ɩɪɟɞɨɫɬɚɜɥɟɧɧɵɣ ɜɚɦɢ ɲɚɛɥɨɧ ɤɥɚɫɫɚ.
// ǍǫǻǳǫǸǽ 3: ǜǹǲǯǫǸǳǰ ǽǹȂǵǳ ǸǫǼǽǻǹǴǵǳ ǺǾǽǰǷ ǽǻǰǬǹǭǫǸǳȊ ǹǽ
// ǽǳǺǫ T "foo-ǼǹǭǷǰǼǽǳǷǹǼǽǳ" ǺǾǽǰǷ ǼǺǰȁǳǫǶǳǲǫȁǳǳ ȃǫǬǶǹǸǫ
// SampleTraits<> Ǽ ǺǻǰǯǹǼǽǫǭǶǰǸǳǰǷ (ǹǬȆȂǸǹ ǼǽǫǽǳȂǰǼǵǹǴ)
// ǿǾǸǵȁǳǳ Ǽ ǯǫǸǸȆǷ ǳǷǰǸǰǷ, ǼǳǮǸǫǽǾǻǹǴ ǳ ǼǰǷǫǸǽǳǵǹǴ.
S3Traits <T>::foo( t ); // S3Traits<>::foo -
// ǽǹȂǵǫ ǸǫǼǽǻǹǴǵǳ
typename S3Traits <T>::value_type x; // ǏǻǾǮǹǴ ǺǻǳǷǰǻ -
} // ǽǹȂǵǫ ǸǫǼǽǻǹǴǵǳ ǯǶȊ ǺǹǳǼǵǫ ǽǳǺǫ (ǹǬȆȂǸǹ
// ǼǹǲǯǫǰǽǼȊ ǺǹǼǻǰǯǼǽǭǹǷ typedef)
ȼ ɷɬɨɦ ɜɚɪɢɚɧɬɟ ɩɨɥɶɡɨɜɚɬɟɥɶ ɩɢɲɟɬ ɚɞɚɩɬɟɪ, ɤɨɬɨɪɵɣ ɝɚɪɚɧɬɢɪɭɟɬ ɢɡɨɥɢɪɨɜɚɧɧɨɫɬɶ ɤɨɞɚ
ɧɚɫɬɪɨɣɤɢ ɞɥɹ ɞɚɧɧɨɣ ɛɢɛɥɢɨɬɟɤɢ ɜ ɩɪɟɞɟɥɚɯ ɷɬɨɣ ɛɢɛɥɢɨɬɟɤɢ. ɋɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɧɟɞɨɫɬɚɬɨɤ
ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɷɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɫɥɢɲɤɨɦ ɝɪɨɦɨɡɞɤɢɦ ɪɟɲɟɧɢɟɦ; ɟɫɥɢ ɧɟɫɤɨɥɶɤɨ
ɛɢɛɥɢɨɬɟɤ ɲɚɛɥɨɧɨɜ ɬɪɟɛɭɸɬ ɨɞɧɭ ɢ ɬɭ ɠɟ ɨɛɳɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ, ɩɨɥɶɡɨɜɚɬɟɥɶ ɞɨɥɠɟɧ
ɛɭɞɟɬ ɩɢɫɚɬɶ ɧɟɫɤɨɥɶɤɨ ɚɞɚɩɬɟɪɨɜ, ɩɨ ɨɞɧɨɦɭ ɞɥɹ ɤɚɠɞɨɣ ɛɢɛɥɢɨɬɟɤɢ.
Ⱦɥɹ ɪɟɚɥɢɡɚɰɢɢ ɷɬɨɣ ɜɟɪɫɢɢ ɚɜɬɨɪ Sample3 ɞɨɥɠɟɧ ɜɵɩɨɥɧɢɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
65. Выполняйте настройку явно и преднамеренно 137
Стр. 137
• ɉɪɟɞɨɫɬɚɜɢɬɶ ɲɚɛɥɨɧ ɤɥɚɫɫɚ ɩɨ ɭɦɨɥɱɚɧɢɸ ɜ ɫɨɛɫɬɜɟɧɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɲɚɛɥɨ-
ɧɚ. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ, ɤɨɬɨɪɵɟ ɧɟɥɶɡɹ ɱɚɫɬɢɱɧɨ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɬɶ ɢ ɤɨ-
ɬɨɪɵɟ ɩɪɢɜɨɞɹɬ ɤ ɩɟɪɟɝɪɭɡɤɚɦ ɢ ɡɚɜɢɫɢɦɨɫɬɹɦ ɨɬ ɩɨɪɹɞɤɚ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 66).
• Ⱦɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɬɨɱɤɭ ɧɚɫɬɪɨɣɤɢ. ɉɨɥɶɡɨɜɚɬɟɥɶ ɞɨɥɠɟɧ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɬɶ
S3Traits ɞɥɹ ɫɜɨɟɝɨ ɫɨɛɫɬɜɟɧɧɨɝɨ ɬɢɩɚ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɛɢɛɥɢɨɬɟɤɢ ɲɚɛɥɨɧɨɜ,
ɢ ɞɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɜɫɟ ɱɥɟɧɵ S3Traits (ɧɚɩɪɢɦɟɪ, foo) ɢ ɢɯ ɫɟɦɚɧɬɢɤɭ.
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɥɸɛɨɝɨ ɢɡ ɩɟɪɟɱɢɫɥɟɧɧɵɯ ɜɚɪɢɚɧɬɨɜ ɫɥɟɞɭɟɬ ɬɚɤɠɟ ɱɟɬɤɨ ɞɨɤɭɦɟɧɬɢɪɨ-
ɜɚɬɶ ɫɟɦɚɧɬɢɤɭ, ɬɪɟɛɭɟɦɭɸ ɨɬ foo, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɜɫɟ ɫɭɳɟɫɬɜɟɧɧɵɟ ɞɟɣɫɬɜɢɹ (ɩɨɫɬɭɫɥɨɜɢɹ),
ɤɨɬɨɪɵɟ ɞɨɥɠɧɚ ɝɚɪɚɧɬɢɪɨɜɚɬɶ ɷɬɚ ɮɭɧɤɰɢɹ, ɢ ɫɟɦɚɧɬɢɤɭ ɫɛɨɟɜ (ɱɬɨ ɢɦɟɧɧɨ ɩɪɨɢɫɯɨɞɢɬ ɩɪɢ
ɫɛɨɟ ɢ ɤɚɤɢɦ ɨɛɪɚɡɨɦ ɞɨɥɠɧɨ ɨɫɭɳɟɫɬɜɥɹɬɶɫɹ ɨɩɨɜɟɳɟɧɢɟ ɨɛ ɨɲɢɛɤɚɯ).
ȿɫɥɢ ɬɨɱɤɚ ɧɚɫɬɪɨɣɤɢ ɞɨɥɠɧɚ ɞɟɣɫɬɜɨɜɚɬɶ ɢ ɞɥɹ ɜɫɬɪɨɟɧɧɵɯ ɬɢɩɨɜ, ɢɫɩɨɥɶɡɭɣɬɟ ɜɚɪɢɚɧ-
ɬɵ 2 ɢ 3.
ȼɚɪɢɚɧɬɵ 1 ɢ 2 ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɞɥɹ ɬɟɯ ɨɛɳɢɯ ɨɩɟɪɚɰɢɣ, ɤɨɬɨɪɵɟ ɹɜɥɹɸɬɫɹ ɩɪɟɞɨɫ-
ɬɚɜɥɹɟɦɵɦɢ ɬɢɩɨɦ ɫɟɪɜɢɫɚɦɢ. Ⱦɥɹ ɩɪɢɧɹɬɢɹ ɞɚɧɧɨɝɨ ɪɟɲɟɧɢɹ ɩɨɩɪɨɛɭɣɬɟ ɨɬɜɟɬɢɬɶ ɧɚ ɫɥɟ-
ɞɭɸɳɢɟ ɜɨɩɪɨɫɵ: ɦɨɝɭɬ ɥɢ ɞɪɭɝɢɟ ɛɢɛɥɢɨɬɟɤɢ ɲɚɛɥɨɧɨɜ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɚɧɧɭɸ ɜɨɡɦɨɠɧɨɫɬɶ?
ɹɜɥɹɟɬɫɹ ɥɢ ɪɚɫɫɦɚɬɪɢɜɚɟɦɚɹ ɫɟɦɚɧɬɢɤɚ ɩɪɢɟɦɥɟɦɨɣ ɞɥɹ ɞɚɧɧɨɝɨ ɢɦɟɧɢ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ? ȿɫ-
ɥɢ ɜɵ ɩɨɥɨɠɢɬɟɥɶɧɨ ɨɬɜɟɬɢɥɢ ɧɚ ɷɬɢ ɜɨɩɪɨɫɵ, ɬɨ, ɜɟɪɨɹɬɧɨ, ɜɚɦ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɫɥɟɞɭɟɬ ɩɪɟɞ-
ɩɨɱɟɫɬɶ ɨɞɢɧ ɢɡ ɷɬɢɯ ɜɚɪɢɚɧɬɨɜ.
ȼɚɪɢɚɧɬ 3 ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɦɟɧɟɟ ɨɛɳɢɯ ɨɩɟɪɚɰɢɣ, ɫɦɵɫɥ ɤɨɬɨɪɵɯ ɦɨɠɟɬ ɜɚɪɶɢ-
ɪɨɜɚɬɶɫɹ. ȼ ɬɚɤɨɦ ɫɥɭɱɚɟ ɜ ɞɪɭɝɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɤɨɥɥɢɡɢɣ ɜɵ ɫɦɨɠɟɬɟ
ɩɪɢɞɚɬɶ ɬɨɦɭ ɠɟ ɢɦɟɧɢ ɢɧɨɣ ɫɦɵɫɥ.
ɒɚɛɥɨɧ, ɜ ɤɨɬɨɪɨɦ ɢɦɟɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɬɨɱɟɤ ɧɚɫɬɪɨɣɤɢ, ɞɥɹ ɤɚɠɞɨɣ ɢɡ ɧɢɯ ɦɨɠɟɬ ɜɵ-
ɛɪɚɬɶ ɫɜɨɸ ɫɬɪɚɬɟɝɢɸ, ɜ ɧɚɢɛɨɥɶɲɟɣ ɦɟɪɟ ɩɪɢɟɦɥɟɦɭɸ ɜ ɞɚɧɧɨɦ ɦɟɫɬɟ. Ƚɥɚɜɧɨɟ, ɱɬɨ ɜɵ
ɞɨɥɠɧɵ ɨɫɨɡɧɚɧɧɨ, ɫ ɩɨɧɢɦɚɧɢɟɦ ɜɵɛɢɪɚɬɶ ɫɬɪɚɬɟɝɢɸ ɞɥɹ ɤɚɠɞɨɣ ɬɨɱɤɢ ɧɚɫɬɪɨɣɤɢ, ɞɨɤɭ-
ɦɟɧɬɢɪɨɜɚɬɶ ɬɪɟɛɨɜɚɧɢɹ ɤ ɧɚɫɬɪɨɣɤɟ (ɜɤɥɸɱɚɹ ɨɠɢɞɚɟɦɵɟ ɩɨɫɬɭɫɥɨɜɢɹ ɢ ɫɟɦɚɧɬɢɤɭ ɨɲɢɛɨɤ)
ɢ ɤɨɪɪɟɤɬɧɨ ɪɟɚɥɢɡɨɜɚɬɶ ɜɵɛɪɚɧɧɭɸ ɜɚɦɢ ɫɬɪɚɬɟɝɢɸ.
Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɵɯ ɬɨɱɟɤ ɧɚɫɬɪɨɣɤɢ, ɫɥɟɞɭɟɬ ɩɪɢɞɟɪɠɢɜɚɬɶɫɹ
ɫɥɟɞɭɸɳɢɯ ɩɪɚɜɢɥ.
• Ɋɚɡɦɟɳɚɣɬɟ ɜɫɟ ɢɫɩɨɥɶɡɭɟɦɵɟ ɜɚɲɢɦ ɲɚɛɥɨɧɨɦ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɮɭɧɤɰɢɢ ɜ ɢɯ ɫɨɛ-
ɫɬɜɟɧɧɨɦ ɜɥɨɠɟɧɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɢ ɜɵɡɵɜɚɣɬɟ ɢɯ ɩɨɫɪɟɞɫɬɜɨɦ ɩɨɥɧɨɫɬɶɸ
ɤɜɚɥɢɮɢɰɢɪɨɜɚɧɧɵɯ ɢɦɟɧ ɞɥɹ ɡɚɩɪɟɬɚ ADL. ȿɫɥɢ ɜɵ ɜɵɡɵɜɚɟɬɟ ɜɚɲɭ ɜɫɩɨɦɨɝɚɬɟɥɶ-
ɧɭɸ ɮɭɧɤɰɢɸ ɢ ɩɟɪɟɞɚɟɬɟ ɟɣ ɨɛɴɟɤɬ ɬɢɩɚ ɩɚɪɚɦɟɬɪɚ ɲɚɛɥɨɧɚ, ɢ ɷɬɨɬ ɜɵɡɨɜ ɧɟ ɞɨɥɠɟɧ
ɛɵɬɶ ɬɨɱɤɨɣ ɧɚɫɬɪɨɣɤɢ (ɬ.ɟ. ɜɵ ɜɫɟɝɞɚ ɧɚɦɟɪɟɧɵ ɜɵɡɵɜɚɬɶ ɜɚɲɭ ɜɫɩɨɦɨɝɚɬɟɥɶɧɭɸ
ɮɭɧɤɰɢɸ, ɚ ɧɟ ɧɟɤɨɬɨɪɭɸ ɢɧɭɸ), ɬɨ ɥɭɱɲɟ ɩɨɦɟɫɬɢɬɶ ɷɬɭ ɜɫɩɨɦɨɝɚɬɟɥɶɧɭɸ ɮɭɧɤɰɢɸ
ɜɨ ɜɥɨɠɟɧɧɨɟ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ ɢ ɹɜɧɨ ɡɚɩɪɟɬɢɬɶ ADL, ɩɨɥɧɨɫɬɶɸ ɤɜɚɥɢɮɢɰɢɪɨɜɚɜ
ɢɦɹ ɜɵɡɵɜɚɟɦɨɣ ɮɭɧɤɰɢɢ ɢɥɢ ɜɡɹɜ ɟɝɨ ɜ ɫɤɨɛɤɢ:
S4Helpers ::bar( t ); // ǒǫǺǻǰǽ ADL: bar Ǹǰ ȊǭǶȊǰǽǼȊ
// ǽǹȂǵǹǴ ǸǫǼǽǻǹǴǵǳ
(bar)( t ); // ǋǶȇǽǰǻǸǫǽǳǭǸȆǴ ǼǺǹǼǹǬ
}
• ɂɡɛɟɝɚɣɬɟ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɡɚɜɢɫɢɦɵɯ ɢɦɟɧ. Ƚɨɜɨɪɹ ɧɟɮɨɪɦɚɥɶɧɨ, ɡɚɜɢɫɢɦɨɟ ɢɦɹ — ɷɬɨ
ɢɦɹ, ɤɨɬɨɪɨɟ ɤɚɤɢɦ-ɬɨ ɨɛɪɚɡɨɦ ɭɩɨɦɢɧɚɟɬ ɩɚɪɚɦɟɬɪ ɲɚɛɥɨɧɚ. Ɇɧɨɝɢɟ ɤɨɦɩɢɥɹɬɨɪɵ ɧɟ
ɩɨɞɞɟɪɠɢɜɚɸɬ “ɞɜɭɯɮɚɡɧɵɣ ɩɨɢɫɤ” ɞɥɹ ɡɚɜɢɫɢɦɵɯ ɢɦɟɧ ɢɡ ɫɬɚɧɞɚɪɬɚ C++, ɚ ɷɬɨ ɨɡɧɚɱɚ-
ɟɬ, ɱɬɨ ɤɨɞ ɲɚɛɥɨɧɚ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɡɚɜɢɫɢɦɵɟ ɢɦɟɧɚ, ɛɭɞɟɬ ɜɟɫɬɢ ɫɟɛɹ ɩɨ-ɪɚɡɧɨɦɭ ɧɚ
ɪɚɡɧɵɯ ɤɨɦɩɢɥɹɬɨɪɚɯ, ɟɫɥɢ ɬɨɥɶɤɨ ɧɟ ɩɪɢɧɹɬɶ ɦɟɪɵ ɞɥɹ ɩɨɥɧɨɣ ɨɩɪɟɞɟɥɟɧɧɨɫɬɢ ɩɪɢ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɢ ɡɚɜɢɫɢɦɵɯ ɢɦɟɧ. ȼ ɱɚɫɬɧɨɫɬɢ, ɨɫɨɛɨɝɨ ɜɧɢɦɚɧɢɹ ɬɪɟɛɭɟɬ ɧɚɥɢɱɢɟ ɡɚɜɢɫɢ-
ɦɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ, ɤɨɝɞɚ ɲɚɛɥɨɧ ɤɥɚɫɫɚ ɧɚɫɥɟɞɭɟɬɫɹ ɨɬ ɨɞɧɨɝɨ ɢɡ ɩɚɪɚɦɟɬɪɨɜ ɷɬɨɝɨ
Стр. 138
ɲɚɛɥɨɧɚ (ɧɚɩɪɢɦɟɪ, T ɜ ɫɥɭɱɚɟ template<typename T>class C:T{};) ɢɥɢ ɨɬ ɬɢɩɚ,
ɤɨɬɨɪɵɣ ɩɨɫɬɪɨɟɧ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɞɧɨɝɨ ɢɡ ɩɚɪɚɦɟɬɪɨɜ ɲɚɛɥɨɧɚ (ɧɚɩɪɢɦɟɪ, X<T>
ɜ ɫɥɭɱɚɟ template<typename T>class C:X<T>{};).
Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɩɪɢ ɨɛɪɚɳɟɧɢɢ ɤ ɥɸɛɨɦɭ ɱɥɟɧɭ ɡɚɜɢɫɢɦɨɝɨ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɧɟɨɛɯɨ-
ɞɢɦɨ ɜɫɟɝɞɚ ɹɜɧɨ ɤɜɚɥɢɮɢɰɢɪɨɜɚɬɶ ɢɦɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɦɟɧɢ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɢɥɢ
ɩɪɢ ɩɨɦɨɳɢ this->. ɗɬɨɬ ɫɩɨɫɨɛ ɦɨɠɧɨ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɩɪɨɫɬɨ ɤɚɤ ɧɟɤɭɸ ɦɚɝɢɸ, ɤɨ-
ɬɨɪɚɹ ɡɚɫɬɚɜɥɹɟɬ ɜɫɟ ɤɨɦɩɢɥɹɬɨɪɵ ɞɟɥɚɬɶ ɢɦɟɧɧɨ ɬɨ, ɱɬɨ ɜɵ ɨɬ ɧɢɯ ɯɨɬɢɬɟ.
class C : X<T> {
typename X<T>::SomeType s; // ǓǼǺǹǶȇǲǹǭǫǸǳǰ ǭǶǹǱǰǸǸǹǮǹ
// ǽǳǺǫ (ǳǶǳ ǼǳǸǹǸǳǷǫ
// typedef) ǳǲ ǬǫǲǹǭǹǮǹ
// ǵǶǫǼǼǫ
public:
void f() {
X<T>::baz(); // ǍȆǲǹǭ ǿǾǸǵȁǳǳ-ȂǶǰǸǫ
// ǬǫǲǹǭǹǮǹ ǵǶǫǼǼǫ
this->baz(); // ǋǶȇǽǰǻǸǫǽǳǭǸȆǴ ǼǺǹǼǹǬ
}
};
ɋɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɜ ɨɫɧɨɜɧɨɦ ɨɬɞɚɟɬ ɩɪɟɞɩɨɱɬɟɧɢɟ ɜɚɪɢɚɧɬɭ 2 (ɧɚɩɪɢɦɟɪ,
ostream_iterator ɢɳɟɬ ɨɩɟɪɚɬɨɪ operator<<, ɚ accumulate ɢɳɟɬ ɨɩɟɪɚɬɨɪ operator+
ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɜɚɲɟɝɨ ɬɢɩɚ). ȼ ɧɟɤɨɬɨɪɵɯ ɦɟɫɬɚɯ ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ ɢɫɩɨɥɶɡɭɟɬ
ɬɚɤɠɟ ɜɚɪɢɚɧɬ 3 (ɧɚɩɪɢɦɟɪ, iterator_traits, char_traits) ɜ ɨɫɧɨɜɧɨɦ ɩɨɬɨɦɭ, ɱɬɨ ɷɬɢ
ɤɥɚɫɫɵ ɫɜɨɣɫɬɜ ɞɨɥɠɧɵ ɛɵɬɶ ɫɩɟɰɢɚɥɢɡɢɪɭɟɦɵ ɞɥɹ ɜɫɬɪɨɟɧɧɵɯ ɬɢɩɨɜ.
Ɂɚɦɟɬɢɦ, ɱɬɨ, ɤ ɫɨɠɚɥɟɧɢɸ, ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɧɟ ɜɫɟɝɞɚ ɱɟɬɤɨ ɨɩɪɟɞɟɥɹɟɬ ɬɨɱ-
ɤɢ ɧɚɫɬɪɨɣɤɢ ɧɟɤɨɬɨɪɵɯ ɚɥɝɨɪɢɬɦɨɜ. ɇɚɩɪɢɦɟɪ, ɨɧɚ ɹɫɧɨ ɝɨɜɨɪɢɬ ɨ ɬɨɦ, ɱɬɨ ɬɪɟɯɩɚɪɚɦɟɬɪɢ-
ɱɟɫɤɚɹ ɜɟɪɫɢɹ accumulate ɞɨɥɠɧɚ ɜɵɡɵɜɚɬɶ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɣ ɨɩɟɪɚɬɨɪ operator+ ɫ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɟɦ ɜɬɨɪɨɝɨ ɜɚɪɢɚɧɬɚ. Ɉɞɧɚɤɨ ɨɧɚ ɧɟ ɝɨɜɨɪɢɬ, ɞɨɥɠɟɧ ɥɢ ɚɥɝɨɪɢɬɦ sort ɜɵɡɵɜɚɬɶ
ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɭɸ ɮɭɧɤɰɢɸ swap (ɨɛɟɫɩɟɱɢɜɚɹ ɬɚɤɢɦ ɨɛɪɚɡɨɦ ɩɪɟɞɧɚɦɟɪɟɧɧɭɸ ɬɨɱɤɭ ɧɚ-
ɫɬɪɨɣɤɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɜɚɪɢɚɧɬɚ 2), ɦɨɠɟɬ ɥɢ ɨɧ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɭɸ ɮɭɧɤ-
ɰɢɸ swap, ɢ ɜɵɡɵɜɚɟɬ ɥɢ ɨɧ ɮɭɧɤɰɢɸ swap ɜɨɨɛɳɟ; ɧɚ ɫɟɝɨɞɧɹɲɧɢɣ ɞɟɧɶ ɧɟɤɨɬɨɪɵɟ ɪɟɚɥɢ-
ɡɚɰɢɢ sort ɢɫɩɨɥɶɡɭɸɬ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɭɸ ɮɭɧɤɰɢɸ swap, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɞɪɭɝɢɟ ɪɟɚɥɢɡɚɰɢɢ
ɷɬɨɝɨ ɧɟ ɞɟɥɚɸɬ. ȼɚɠɧɨɫɬɶ ɪɚɫɫɦɚɬɪɢɜɚɟɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɛɵɥɚ ɨɫɨɡɧɚɧɚ ɫɨɜɫɟɦ ɧɟɞɚɜɧɨ, ɢ
ɫɟɣɱɚɫ ɤɨɦɢɬɟɬ ɩɨ ɫɬɚɧɞɚɪɬɢɡɚɰɢɢ ɢɫɩɪɚɜɥɹɟɬ ɫɢɬɭɚɰɢɸ, ɭɫɬɪɚɧɹɹ ɬɚɤɢɟ ɧɟɱɟɬɤɨɫɬɢ ɢɡ ɫɬɚɧ-
ɞɚɪɬɚ. ɇɟ ɩɨɜɬɨɪɹɣɬɟ ɬɚɤɢɟ ɨɲɢɛɤɢ. (ɋɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 66.)
Ссылки
[Stroustrup00] §8.2, §10.3.2, §11.2.4 • [Sutter00] §31-34 • [Sutter04d]
65. Выполняйте настройку явно и преднамеренно 139
Стр. 139
66. Не специализируйте шаблоны функций
Резюме
ɉɪɢ ɪɚɫɲɢɪɟɧɢɢ ɧɟɤɨɬɨɪɨɝɨ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ (ɜɤɥɸɱɚɹ std::swap) ɢɡɛɟɝɚɣɬɟ ɩɨɩɵɬɨɤ
ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ. ȼɦɟɫɬɨ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɣɬɟ ɩɟɪɟɝɪɭɡɤɭ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɭɸ
ɫɥɟɞɭɟɬ ɩɨɦɟɫɬɢɬɶ ɜ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ ɬɢɩɚ(ɨɜ), ɞɥɹ ɤɨɬɨɪɵɯ ɪɚɡɪɚɛɨɬɚɧɚ ɞɚɧɧɚɹ ɩɟɪɟɝɪɭɡɤɚ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ɉɪɢ ɧɚɩɢɫɚɧɢɢ ɫɨɛɫɬɜɟɧɧɨɝɨ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ ɬɚɤɠɟ ɢɡɛɟɝɚɣɬɟ ɟɝɨ
ɫɩɟɰɢɚɥɢɡɚɰɢɢ.
ɒɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɜɩɨɥɧɟ ɦɨɠɧɨ ɩɟɪɟɝɪɭɠɚɬɶ. Ɋɚɡɪɟɲɟɧɢɟ ɩɟɪɟɝɪɭɡɤɢ ɪɚɫɫɦɚɬɪɢɜɚɟɬ ɜɫɟ
ɩɟɪɜɢɱɧɵɟ ɲɚɛɥɨɧɵ ɢ ɪɚɛɨɬɚɟɬ ɢɦɟɧɧɨ ɬɚɤ, ɤɚɤ ɜɵ ɢ ɨɠɢɞɚɟɬɟ, ɢɫɯɨɞɹ ɢɡ ɜɚɲɟɝɨ ɨɩɵɬɚ ɪɚ-
ɛɨɬɵ ɫ ɩɟɪɟɝɪɭɡɤɨɣ ɨɛɵɱɧɵɯ ɮɭɧɤɰɢɣ C++: ɩɪɨɫɦɚɬɪɢɜɚɸɬɫɹ ɜɫɟ ɜɢɞɢɦɵɟ ɲɚɛɥɨɧɵ ɢ ɜɵɛɢ-
ɪɚɟɬɫɹ ɲɚɛɥɨɧ ɫ ɧɚɢɥɭɱɲɢɦ ɫɨɨɬɜɟɬɫɬɜɢɟɦ.
Ʉ ɫɨɠɚɥɟɧɢɸ, ɜ ɫɥɭɱɚɟ ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ ɜɫɟ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɫɥɨɠɧɟɟ
ɩɨ ɞɜɭɦ ɨɫɧɨɜɧɵɦ ɩɪɢɱɢɧɚɦ.
• ɋɩɟɰɢɚɥɢɡɢɪɨɜɚɬɶ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɦɨɠɧɨ ɬɨɥɶɤɨ ɩɨɥɧɨɫɬɶɸ, ɧɨ ɧɟ ɱɚɫɬɢɱɧɨ. Ʉɨɞ,
ɤɨɬɨɪɵɣ ɜɵɝɥɹɞɢɬ ɤɚɤ ɱɚɫɬɢɱɧɚɹ ɫɩɟɰɢɚɥɢɡɚɰɢɹ, ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɩɟɪɟɝɪɭɡɤɭ.
• ɋɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ ɧɢɤɨɝɞɚ ɧɟ ɭɱɚɫɬɜɭɸɬ ɜ ɩɟɪɟɝɪɭɡɤɟ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ,
ɥɸɛɚɹ ɧɚɩɢɫɚɧɧɚɹ ɜɚɦɢ ɫɩɟɰɢɚɥɢɡɚɰɢɹ ɧɢɤɚɤ ɧɟ ɩɨɜɥɢɹɟɬ ɧɚ ɪɟɡɭɥɶɬɚɬ ɪɚɡɪɟɲɟɧɢɹ ɩɟ-
ɪɟɝɪɭɡɤɢ ɢ ɜɵɛɨɪ ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɲɚɛɥɨɧɚ. ɗɬɨ ɩɪɨɬɢɜɨɪɟɱɢɬ ɢɧɬɭɢɬɢɜɧɨ ɨɠɢɞɚɟɦɨɦɭ
ɩɨɜɟɞɟɧɢɸ ɪɚɡɪɟɲɟɧɢɹ ɩɟɪɟɝɪɭɡɤɢ. ɇɨ, ɜ ɤɨɧɰɟ ɤɨɧɰɨɜ, ɟɫɥɢ ɜɵ ɧɚɩɢɲɟɬɟ ɧɟɲɚɛɥɨɧ-
ɧɭɸ ɮɭɧɤɰɢɸ ɫ ɢɞɟɧɬɢɱɧɨɣ ɫɢɝɧɚɬɭɪɨɣ ɜɦɟɫɬɨ ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ, ɬɨ
ɩɪɢ ɪɚɡɪɟɲɟɧɢɢ ɩɟɪɟɝɪɭɡɤɢ ɛɭɞɟɬ ɜɵɛɪɚɧɚ ɢɦɟɧɧɨ ɧɟɲɚɛɥɨɧɧɚɹ ɮɭɧɤɰɢɹ, ɤɚɤ ɢɦɟɸ-
ɳɚɹ ɩɪɟɢɦɭɳɟɫɬɜɨ ɩɟɪɟɞ ɲɚɛɥɨɧɨɦ.
ȿɫɥɢ ɜɵ ɩɢɲɟɬɟ ɲɚɛɥɨɧ ɮɭɧɤɰɢɢ, ɬɨ ɥɭɱɲɟ ɩɢɫɚɬɶ ɟɝɨ ɤɚɤ ɟɞɢɧɵɣ ɲɚɛɥɨɧ, ɤɨɬɨɪɵɣ ɧɢ-
ɤɨɝɞɚ ɧɟ ɛɭɞɟɬ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧ ɢɥɢ ɩɟɪɟɝɪɭɠɟɧ, ɢ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɲɚɛɥɨɧ ɮɭɧɤɰɢɢ ɱɟɪɟɡ
ɲɚɛɥɨɧ ɤɥɚɫɫɚ. ɗɬɨ ɢ ɟɫɬɶ ɬɨɬ ɩɪɟɫɥɨɜɭɬɵɣ ɞɨɩɨɥɧɢɬɟɥɶɧɵɣ ɭɪɨɜɟɧɶ ɤɨɫɜɟɧɧɨɫɬɢ, ɤɨɬɨɪɵɣ
ɩɨɡɜɨɥɹɟɬ ɨɛɨɣɬɢ ɨɝɪɚɧɢɱɟɧɢɹ ɢ ɦɢɧɨɜɚɬɶ “ɬɟɦɧɵɟ ɭɝɥɵ” ɲɚɛɥɨɧɨɜ ɮɭɧɤɰɢɣ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ
ɩɪɨɝɪɚɦɦɢɫɬ, ɢɫɩɨɥɶɡɭɸɳɢɣ ɜɚɲ ɲɚɛɥɨɧ, ɫɦɨɠɟɬ ɱɚɫɬɢɱɧɨ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɬɶ ɲɚɛɥɨɧ ɤɥɚɫ-
ɫɚ. Ɍɟɦ ɫɚɦɵɦ ɪɟɲɚɟɬɫɹ ɤɚɤ ɩɪɨɛɥɟɦɚ ɩɨ ɩɨɜɨɞɭ ɬɨɝɨ, ɱɬɨ ɲɚɛɥɨɧ ɮɭɧɤɰɢɢ ɧɟ ɦɨɠɟɬ ɛɵɬɶ
ɱɚɫɬɢɱɧɨ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧ, ɬɚɤ ɢ ɩɨ ɩɨɜɨɞɭ ɬɨɝɨ, ɱɬɨ ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ ɧɟ
ɭɱɚɫɬɜɭɸɬ ɜ ɩɟɪɟɝɪɭɡɤɟ.
ȿɫɥɢ ɜɵ ɪɚɛɨɬɚɟɬɟ ɫ ɤɚɤɢɦ-ɬɨ ɢɧɵɦ ɫɬɚɪɵɦ ɲɚɛɥɨɧɨɦ ɮɭɧɤɰɢɢ, ɜ ɤɨɬɨɪɨɦ ɧɟ ɢɫɩɨɥɶɡɨ-
ɜɚɧɚ ɨɩɢɫɚɧɧɚɹ ɦɟɬɨɞɢɤɚ (ɬ.ɟ. ɫ ɲɚɛɥɨɧɨɦ ɮɭɧɤɰɢɢ, ɧɟ ɪɟɚɥɢɡɨɜɚɧɧɨɦ ɩɨɫɪɟɞɫɬɜɨɦ ɲɚɛɥɨɧɚ
ɤɥɚɫɫɚ), ɢ ɯɨɬɢɬɟ ɧɚɩɢɫɚɬɶ ɫɨɛɫɬɜɟɧɧɭɸ ɜɟɪɫɢɸ ɞɥɹ ɱɚɫɬɧɨɝɨ ɫɥɭɱɚɹ, ɤɨɬɨɪɚɹ ɞɨɥɠɧɚ ɩɪɢɧɢ-
ɦɚɬɶ ɭɱɚɫɬɢɟ ɜ ɩɟɪɟɝɪɭɡɤɟ, — ɞɟɥɚɣɬɟ ɟɟ ɧɟ ɫɩɟɰɢɚɥɢɡɚɰɢɟɣ, ɚ ɨɛɵɱɧɨɣ ɧɟɲɚɛɥɨɧɧɨɣ ɮɭɧɤ-
ɰɢɟɣ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 57 ɢ 58).
Примеры
ɉɪɢɦɟɪ. std::swap. Ȼɚɡɨɜɵɣ ɲɚɛɥɨɧ swap ɨɛɦɟɧɢɜɚɟɬ ɞɜɚ ɡɧɚɱɟɧɢɹ a ɢ b ɩɭɬɟɦ ɫɨɡɞɚ-
ɧɢɹ ɤɨɩɢɢ temp ɡɧɚɱɟɧɢɹ a, ɢ ɩɪɢɫɜɚɢɜɚɧɢɣ a = b ɢ b = temp. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɪɚɫɲɢɪɢɬɶ
ɞɚɧɧɵɣ ɲɚɛɥɨɧ ɞɥɹ ɜɚɲɢɯ ɫɨɛɫɬɜɟɧɧɵɯ ɬɢɩɨɜ? ɉɭɫɬɶ, ɧɚɩɪɢɦɟɪ, ɭ ɜɚɫ ɟɫɬɶ ɜɚɲ ɫɨɛɫɬɜɟɧɧɵɣ
ɬɢɩ Widget ɜ ɜɚɲɟɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ N:
Стр. 140
namespace N {
class Widget { /* ... */ };
}
ɉɪɟɞɩɨɥɨɠɢɦ, ɱɬɨ ɢɦɟɟɬɫɹ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵɣ ɩɭɬɶ ɨɛɦɟɧɚ ɞɜɭɯ ɨɛɴɟɤɬɨɜ Widget. ɑɬɨ ɜɵ
ɞɨɥɠɧɵ ɫɞɟɥɚɬɶ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɨɧ ɢɫɩɨɥɶɡɨɜɚɥɫɹ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɨɣ, — ɩɟɪɟɝɪɭɡɢɬɶ
swap (ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɝɞɟ ɧɚɯɨɞɢɬɫɹ Widget; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57) ɢɥɢ ɧɟɩɨ-
ɫɪɟɞɫɬɜɟɧɧɨ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɬɶ std::swap? ɋɬɚɧɞɚɪɬ ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ ɧɟɜɪɚɡɭɦɢɬɟɥɟɧ, ɢ ɧɚ
ɩɪɚɤɬɢɤɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɪɚɡɧɵɟ ɦɟɬɨɞɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 65). ɋɟɝɨɞɧɹ ɪɹɞ ɪɟɚɥɢɡɚɰɢɣ ɤɨɪ-
ɪɟɤɬɧɨ ɪɟɲɚɸɬ ɷɬɨɬ ɜɨɩɪɨɫ, ɩɪɟɞɨɫɬɚɜɥɹɹ ɩɟɪɟɝɪɭɠɟɧɧɭɸ ɮɭɧɤɰɢɸ ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ
ɢɦɟɧ, ɝɞɟ ɧɚɯɨɞɢɬɫɹ Widget. Ⱦɥɹ ɩɪɟɞɫɬɚɜɥɟɧɧɨɝɨ ɜɵɲɟ ɧɟɲɚɛɥɨɧɧɨɝɨ ɤɥɚɫɫɚ Widget ɷɬɨ
ɜɵɝɥɹɞɢɬ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
namespace N {
void swap( Widget&, Widget& );
}
Ɂɚɦɟɬɢɦ, ɱɬɨ ɟɫɥɢ Widget ɹɜɥɹɟɬɫɹ ɲɚɛɥɨɧɨɦ
namespace N {
template<typename T> class Widget { /* ... */ };
}
ɬɨ ɫɩɟɰɢɚɥɢɡɚɰɢɹ std::swap ɩɨɩɪɨɫɬɭ ɧɟɜɨɡɦɨɠɧɚ, ɬɚɤ ɤɚɤ ɱɚɫɬɢɱɧɨɣ ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛ-
ɥɨɧɚ ɮɭɧɤɰɢɢ ɧɟ ɫɭɳɟɫɬɜɭɟɬ. Ʌɭɱɲɟɟ, ɱɬɨ ɜɵ ɦɨɠɟɬɟ ɫɞɟɥɚɬɶ, — ɷɬɨ ɞɨɛɚɜɢɬɶ ɩɟɪɟɝɪɭɡɤɭ
ɮɭɧɤɰɢɢ
namespace ??? {
template<typename T> void swap(Widget<T>&, Widget<T>&);
}
ɗɬɨ ɩɪɨɛɥɟɦɚɬɢɱɧɨɟ ɪɟɲɟɧɢɟ, ɩɨɫɤɨɥɶɤɭ ɟɫɥɢ ɜɵ ɩɨɦɟɳɚɟɬɟ ɷɬɭ ɮɭɧɤɰɢɸ ɜ ɩɪɨɫɬɪɚɧɫɬɜɨ
ɢɦɟɧ, ɜ ɤɨɬɨɪɨɦ ɧɚɯɨɞɢɬɫɹ Widget, ɬɨ ɦɧɨɝɢɟ ɪɟɚɥɢɡɚɰɢɢ ɩɪɨɫɬɨ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɧɚɣɬɢ ɟɟ, ɧɨ
ɩɪɢ ɷɬɨɦ ɫɬɚɧɞɚɪɬ ɡɚɩɪɟɳɚɟɬ ɪɚɫɩɨɥɚɝɚɬɶ ɞɚɧɧɭɸ ɮɭɧɤɰɢɸ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ std. ɗɬɚ
ɩɪɨɛɥɟɦɚ ɧɢɤɨɝɞɚ ɛɵ ɧɟ ɜɨɡɧɢɤɥɚ, ɟɫɥɢ ɛɵ ɫɬɚɧɞɚɪɬ ɥɢɛɨ ɭɤɚɡɵɜɚɥ, ɱɬɨ ɩɟɪɟɝɪɭɡɤɢ ɧɚɞɨ ɢɫ-
ɤɚɬɶ ɢ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɬɢɩɚ ɲɚɛɥɨɧɚ, ɥɢɛɨ ɩɨɡɜɨɥɹɥ ɩɨɦɟɳɚɬɶ ɩɟɪɟɝɪɭɠɚɟɦɵɟ ɮɭɧɤɰɢɢ
ɜ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ std, ɢɥɢ (ɜɨɡɜɪɚɳɚɹɫɶ ɤ ɨɫɧɨɜɧɨɦɭ ɜɨɩɪɨɫɭ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ)
ɩɪɹɦɨ ɭɤɚɡɵɜɚɥ, ɱɬɨ swap ɞɨɥɠɧɚ ɪɟɚɥɢɡɨɜɵɜɚɬɶɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɲɚɛɥɨɧɚ ɤɥɚɫɫɚ, ɤɨɬɨ-
ɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɱɚɫɬɢɱɧɨ ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧ.
Ссылки
[Austern99] §A.1.4 • [Sutter04] §7 • [Vandevoorde03] §12
66. Не специализируйте шаблоны функций 141
Стр. 141
67. Пишите максимально обобщенный код
Резюме
ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɧɚɢɛɨɥɟɟ ɨɛɨɛɳɟɧɧɵɟ ɢ ɚɛɫɬɪɚɤɬɧɵɟ
ɫɪɟɞɫɬɜɚ.
Ʉɨɝɞɚ ɜɵ ɩɢɲɟɬɟ ɬɨɬ ɢɥɢ ɢɧɨɣ ɤɨɞ, ɢɫɩɨɥɶɡɭɣɬɟ ɧɚɢɛɨɥɟɟ ɚɛɫɬɪɚɤɬɧɵɟ ɫɪɟɞɫɬɜɚ, ɩɨɡɜɨ-
ɥɹɸɳɢɟ ɪɟɲɢɬɶ ɩɨɫɬɚɜɥɟɧɧɭɸ ɡɚɞɚɱɭ. ȼɫɟɝɞɚ ɞɭɦɚɣɬɟ ɧɚɞ ɬɟɦ, ɤɚɤɢɟ ɨɩɟɪɚɰɢɢ ɧɚɤɥɚɞɵɜɚɸɬ
ɦɟɧɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ ɬɪɟɛɨɜɚɧɢɣ ɤ ɢɧɬɟɪɮɟɣɫɚɦ, ɫ ɤɨɬɨɪɵɦɢ ɨɧɢ ɪɚɛɨɬɚɸɬ. Ɍɚɤɚɹ ɩɪɢɜɵɱɤɚ
ɫɞɟɥɚɟɬ ɜɚɲ ɤɨɞ ɛɨɥɟɟ ɨɛɨɛɳɟɧɧɵɦ, ɚ ɫɥɟɞɨɜɚɬɟɥɶɧɨ, ɜ ɛɨɥɶɲɟɣ ɫɬɟɩɟɧɢ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶ-
ɡɭɟɦɵɦ ɢ ɛɨɥɟɟ ɩɪɢɫɩɨɫɨɛɥɟɧɧɵɦ ɤɨ ɜɧɟɫɟɧɢɸ ɢɡɦɟɧɟɧɢɣ ɜ ɟɝɨ ɨɤɪɭɠɟɧɢɟ.
ɂ ɧɚɩɪɨɬɢɜ, ɤɨɞ, ɧɟɨɩɪɚɜɞɚɧɧɨ ɩɪɢɜɹɡɚɧɧɵɣ ɤ ɞɟɬɚɥɹɦ, ɨɤɚɡɵɜɚɟɬɫɹ ɱɪɟɡɦɟɪɧɨ “ɠɟɫɬɤɢɦ”
ɢ ɧɟɫɩɨɫɨɛɧɵɦ ɤ ɩɨɜɬɨɪɧɨɦɭ ɢɫɩɨɥɶɡɨɜɚɧɢɸ.
• ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɫɪɚɜɧɟɧɢɹ ɢɬɟɪɚɬɨɪɨɜ != ɜɦɟɫɬɨ <. Ɉɩɟɪɚɬɨɪ != ɛɨɥɟɟ ɨɛɳɢɣ ɢ ɩɪɢ-
ɦɟɧɢɦ ɤ ɛɨɥɶɲɟɦɭ ɤɥɚɫɫɭ ɨɛɴɟɤɬɨɜ; ɨɩɟɪɚɬɨɪ < ɬɪɟɛɭɟɬ ɭɩɨɪɹɞɨɱɟɧɢɹ ɢ ɦɨɠɟɬ ɛɵɬɶ ɪɟɚ-
ɥɢɡɨɜɚɧ ɬɨɥɶɤɨ ɢɬɟɪɚɬɨɪɚɦɢ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ. ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɨɩɟɪɚɬɨɪɚ !=
ɜɚɲ ɤɨɞ ɩɪɨɳɟ ɩɟɪɟɧɨɫɢɬɫɹ ɞɥɹ ɪɚɛɨɬɵ ɫ ɞɪɭɝɢɦɢ ɬɢɩɚɦɢ ɢɬɟɪɚɬɨɪɨɜ, ɬɚɤɢɦɢ ɤɚɤ ɨɞɧɨ-
ɢ ɞɜɭɧɚɩɪɚɜɥɟɧɧɵɟ ɢɬɟɪɚɬɨɪɵ.
• Ʌɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɬɟɪɚɬɨɪɵ, ɚ ɧɟ ɢɧɞɟɤɫɵ. Ɇɧɨɝɢɟ ɤɨɧɬɟɣɧɟɪɵ ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɬ
ɢɧɞɟɤɫɧɵɣ ɞɨɫɬɭɩ; ɧɚɩɪɢɦɟɪ, ɤɨɧɬɟɣɧɟɪ list ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɷɮɮɟɤɬɢɜɧɨ ɪɟɚɥɢɡɨɜɚɬɶ
ɟɝɨ. Ɉɞɧɚɤɨ ɜɫɟ ɤɨɧɬɟɣɧɟɪɵ ɩɨɞɞɟɪɠɢɜɚɸɬ ɢɬɟɪɚɬɨɪɵ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɢɬɟɪɚɬɨɪɵ ɨɛɟɫ-
ɩɟɱɢɜɚɸɬ ɛɨɥɶɲɭɸ ɨɛɨɛɳɟɧɧɨɫɬɶ ɤɨɞɚ, ɢ ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɨɧɢ ɦɨɝɭɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ
ɫɨɜɦɟɫɬɧɨ ɫ ɢɧɞɟɤɫɧɵɦ ɞɨɫɬɭɩɨɦ.
• ɂɫɩɨɥɶɡɭɣɬɟ empty() ɜɦɟɫɬɨ size() == 0. “ɉɭɫɬ/ɧɟ ɩɭɫɬ” — ɛɨɥɟɟ ɩɪɢɦɢɬɢɜɧɚɹ ɤɨɧ-
ɰɟɩɰɢɹ, ɱɟɦ “ɬɨɱɧɵɣ ɪɚɡɦɟɪ”. ɇɚɩɪɢɦɟɪ, ɜɵ ɦɨɠɟɬɟ ɧɟ ɡɧɚɬɶ ɪɚɡɦɟɪ ɩɨɬɨɤɚ, ɧɨ ɜɫɟɝɞɚ ɦɨ-
ɠɟɬɟ ɫɤɚɡɚɬɶ ɨ ɬɨɦ, ɩɭɫɬ ɨɧ ɢɥɢ ɧɟɬ; ɬɨ ɠɟ ɫɚɦɨɟ ɫɩɪɚɜɟɞɥɢɜɨ ɢ ɞɥɹ ɜɯɨɞɧɵɯ ɢɬɟɪɚɬɨɪɨɜ.
ɇɟɤɨɬɨɪɵɟ ɤɨɧɬɟɣɧɟɪɵ, ɬɚɤɢɟ ɤɚɤ list, ɪɟɚɥɢɡɭɸɬ empty ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɨ, ɱɟɦ size.
• ɂɫɩɨɥɶɡɭɣɬɟ ɧɚɢɜɵɫɲɢɣ ɤɥɚɫɫ ɢɟɪɚɪɯɢɢ, ɩɪɟɞɨɫɬɚɜɥɹɸɳɢɣ ɧɟɨɛɯɨɞɢɦɭɸ ɜɚɦ ɮɭɧɤ-
ɰɢɨɧɚɥɶɧɨɫɬɶ. ɉɪɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɞɢɧɚɦɢɱɟɫɤɢɯ ɩɨɥɢɦɨɪɮɧɵɯ
ɤɥɚɫɫɨɜ ɧɟ ɫɥɟɞɭɟɬ ɞɟɥɚɬɶ ɤɨɞ ɡɚɜɢɫɢɦɵɦ ɨɬ ɧɟɧɭɠɧɵɯ ɜɚɦ ɞɟɬɚɥɟɣ ɢ ɩɪɢɜɹɡɵɜɚɬɶɫɹ
ɤ ɨɩɪɟɞɟɥɟɧɧɵɦ ɩɪɨɢɡɜɨɞɧɵɦ ɤɥɚɫɫɚɦ.
• Ȼɭɞɶɬɟ ɤɨɪɪɟɤɬɧɵ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ const (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15). ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬ-
ɪɨɜ const& ɧɚɤɥɚɞɵɜɚɟɬ ɦɟɧɶɲɟ ɨɝɪɚɧɢɱɟɧɢɣ ɧɚ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ, ɩɨɫɤɨɥɶɤɭ const&
ɨɯɜɚɬɵɜɚɟɬ ɤɚɤ ɤɨɧɫɬɚɧɬɧɵɟ, ɬɚɤ ɢ ɧɟɤɨɧɫɬɚɧɬɧɵɟ ɨɛɴɟɤɬɵ.
ȼ ɧɟɤɨɬɨɪɵɯ ɫɥɭɱɚɹɯ ɩɪɢɦɟɧɟɧɢɟ ɢɧɞɟɤɫɨɜ ɜɦɟɫɬɨ ɢɬɟɪɚɬɨɪɨɜ ɩɨɡɜɨɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ
ɥɭɱɲɟ ɨɩɬɢɦɢɡɢɪɨɜɚɬɶ ɤɨɞ. Ɉɞɧɚɤɨ ɩɟɪɟɞ ɬɟɦ ɤɚɤ ɪɟɲɢɬɶɫɹ ɧɚ ɬɚɤɨɣ ɲɚɝ, ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ
ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɜ ɧɟɦ ɧɭɠɞɚɟɬɟɫɶ ɢ ɱɬɨ ɜɚɲ ɤɨɦɩɢɥɹɬɨɪ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɩɪɢ ɷɬɨɦ ɥɭɱɲɟ ɨɩɬɢ-
ɦɢɡɢɪɭɟɬ ɜɚɲ ɤɨɞ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8).
Ссылки
[Koenig97] §12.7, §17-18 • [Meyers01] §4 • [Stroustrup00] §13, §17.1.1 • [Sutter04] §1, §5, §34
Стр. 142
Обработка ошибок и исключения
Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ — ɫɥɨɠɧɚɹ ɡɚɞɚɱɚ, ɩɪɢ ɪɟɲɟɧɢɢ ɤɨɬɨɪɨɣ
ɩɪɨɝɪɚɦɦɢɫɬɭ ɬɪɟɛɭɟɬɫɹ ɜɫɹ ɩɨɦɨɳɶ, ɤɨɬɨɪɚɹ ɬɨɥɶɤɨ
ɦɨɠɟɬ ɛɵɬɶ ɩɪɟɞɨɫɬɚɜɥɟɧɚ.
[Stroustrup94] §16.2
ɂɦɟɟɬɫɹ ɬɪɢ ɫɩɨɫɨɛɚ ɧɚɩɢɫɚɬɶ ɩɪɨɝɪɚɦɦɭ ɛɟɡ ɨɲɢɛɨɤ;

ɧɨ ɪɚɛɨɬɚɟɬ ɬɨɥɶɤɨ ɬɪɟɬɢɣ ɫɩɨɫɨɛ.
ȼɨɩɪɨɫ ɧɟ ɜ ɬɨɦ, ɛɭɞɟɦ ɥɢ ɦɵ ɞɟɥɚɬɶ ɩɪɨɝɪɚɦɦɧɵɟ ɨɲɢɛɤɢ. ȼɨɩɪɨɫ ɜ ɬɨɦ, ɛɭɞɟɦ ɥɢ ɦɵ

ɱɬɨ-ɥɢɛɨ ɩɪɟɞɩɪɢɧɢɦɚɬɶ, ɱɬɨɛɵ ɩɨɡɜɨɥɢɬɶ ɤɨɦɩɢɥɹɬɨɪɭ ɢ ɞɪɭɝɢɦ ɢɫɩɨɥɶɡɭɟɦɵɦ ɢɧɫɬɪɭɦɟɧ-
ɬɚɦ ɢɯ ɨɛɧɚɪɭɠɢɬɶ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɵ ɞɨɛɵɬɵɟ ɬɪɭɞɨɦ ɦɧɨɠɟɫɬɜɚ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɡɧɚɧɢɹ
ɢ ɧɚɢɥɭɱɲɢɟ ɩɪɚɤɬɢɱɟɫɤɢɟ ɩɨɞɯɨɞɵ, ɧɟɤɨɬɨɪɵɟ ɢɡ ɤɨɬɨɪɵɯ ɫɬɨɢɥɢ ɦɧɨɝɢɯ ɥɟɬ ɪɚɛɨɬɵ. ɋɥɟɞɭɣ-
ɬɟ ɩɪɢɜɟɞɟɧɧɵɦ ɩɪɚɜɢɥɚɦ ɢ ɪɟɤɨɦɟɧɞɚɰɢɹɦ. Ʉɨɝɞɚ ɦɵ ɩɢɲɟɦ ɫɥɨɠɧɭɸ, ɧɚɞɟɠɧɭɸ ɢ ɛɟɡɨɩɚɫ-
ɧɭɸ ɩɪɨɝɪɚɦɦɭ — ɧɚɦ ɬɪɟɛɭɟɬɫɹ ɜɫɹ ɩɨɦɨɳɶ, ɤɨɬɨɪɭɸ ɦɵ ɬɨɥɶɤɨ ɜ ɫɨɫɬɨɹɧɢɢ ɩɨɥɭɱɢɬɶ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 69 — “Ɉɩɪɟɞɟɥɢɬɟ ɪɚɡɭɦ-
ɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɟɣ ɫɥɟɞɭɣɬɟ”.
Стр. 143
68. Широко применяйте assert для документирования внутренних допущений ...
68. Широко применяйте assert

для документирования внутренних
допущений и инвариантов
68. Широко применяйте assert для документирования внутренних допущений ...
Резюме
ɂɫɩɨɥɶɡɭɣɬɟ assert ɢɥɢ ɟɝɨ ɷɤɜɢɜɚɥɟɧɬ ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ ɜɧɭɬɪɟɧɧɢɯ ɞɨɩɭɳɟɧɢɣ
ɜ ɦɨɞɭɥɟ (ɬ.ɟ. ɬɚɦ, ɝɞɟ ɜɵɡɵɜɚɟɦɵɣ ɢ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɩɨɞɞɟɪɠɢɜɚɸɬɫɹ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɩɪɨ-
ɝɪɚɦɦɢɫɬɨɦ ɢɥɢ ɤɨɦɚɧɞɨɣ), ɤɨɬɨɪɵɟ ɞɨɥɠɧɵ ɜɫɟɝɞɚ ɜɵɩɨɥɧɹɬɶɫɹ (ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɨɧɢ
ɹɜɥɹɸɬɫɹ ɫɥɟɞɫɬɜɢɟɦ ɩɪɨɝɪɚɦɦɧɨɣ ɨɲɢɛɤɢ; ɧɚɩɪɢɦɟɪ, ɧɚɪɭɲɟɧɢɟ ɩɨɫɬɭɫɥɨɜɢɣ ɮɭɧɤɰɢɢ, ɨɛ-
ɧɚɪɭɠɟɧɧɨɟ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ). (ɋɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 70.) ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟ assert ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɩɨɛɨɱɧɵɦ ɞɟɣɫɬɜɢɹɦ.
Ɉɱɟɧɶ ɬɪɭɞɧɨ ɧɚɣɬɢ ɨɲɢɛɤɭ ɜ ɫɜɨɟɦ ɤɨɞɟ, ɤɨɝɞɚ ɜɵ ɢɳɟɬɟ ɟɟ;
ɧɨ ɜɨ ɫɬɨ ɤɪɚɬ ɬɪɭɞɧɟɟ ɧɚɣɬɢ ɟɟ, ɟɫɥɢ ɜɵ ɫɱɢɬɚɟɬɟ,
ɱɬɨ ɟɟ ɬɚɦ ɧɟɬ.
— ɋɬɢɜ Ɇɚɤ-Ʉɨɧɧɟɥɥ (Steve McConnell)
Ɍɪɭɞɧɨ ɩɟɪɟɨɰɟɧɢɬɶ ɜɫɸ ɦɨɳɶ assert. ɗɬɨɬ ɦɚɤɪɨɫ ɢ ɟɝɨ ɚɥɶɬɟɪɧɚɬɢɜɵ, ɬɚɤɢɟ ɤɚɤ ɲɚɛ-
ɥɨɧɵ ɩɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ (ɢɥɢ, ɱɬɨ ɧɟɫɤɨɥɶɤɨ ɯɭɠɟ, ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ), ɩɪɟɞ-
ɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɧɟɨɰɟɧɢɦɵɣ ɢɧɫɬɪɭɦɟɧɬɚɪɢɣ ɞɥɹ ɨɛɧɚɪɭɠɟɧɢɹ ɢ ɨɬɥɚɞɤɢ ɩɪɨɝɪɚɦɦɧɵɯ ɨɲɢ-
ɛɨɤ ɩɪɢ ɪɚɛɨɬɟ ɧɚɞ ɩɪɨɟɤɬɚɦɢ. ɋɪɟɞɢ ɩɪɨɱɢɯ ɢɧɫɬɪɭɦɟɧɬɨɜ ɭ ɧɢɯ, ɩɨɠɚɥɭɣ, ɧɚɢɥɭɱɲɟɟ ɨɬ-
ɧɨɲɟɧɢɟ ɫɥɨɠɧɨɫɬɶ/ɷɮɮɟɤɬɢɜɧɨɫɬɶ.
Ɋɚɫɫɦɚɬɪɢɜɚɟɦɵɟ ɩɪɨɜɟɪɤɢ ɨɛɵɱɧɨ ɝɟɧɟɪɢɪɭɸɬ ɤɨɞ ɬɨɥɶɤɨ ɜ ɪɟɠɢɦɟ ɨɬɥɚɞɤɢ (ɤɨɝɞɚ ɧɟ
ɨɩɪɟɞɟɥɟɧ ɦɚɤɪɨɫ NDEBUG), ɬɚɤ ɱɬɨ ɨɬ ɧɢɯ ɦɨɠɧɨ ɨɫɜɨɛɨɞɢɬɶɫɹ ɩɪɢ ɫɛɨɪɤɟ ɨɤɨɧɱɚɬɟɥɶɧɨɣ
ɜɟɪɫɢɢ ɩɪɨɝɪɚɦɦɵ. ɒɢɪɨɤɨ ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɨɜɟɪɤɢ ɜ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦɚɯ, ɧɨ ɧɢɤɨɝɞɚ ɧɟ ɩɢɲɢ-
ɬɟ ɜɵɪɚɠɟɧɢɣ ɜ assert, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɢɦɟɬɶ ɩɨɛɨɱɧɨɟ ɞɟɣɫɬɜɢɟ. ɉɪɢ ɩɨɫɬɪɨɟɧɢɢ ɨɤɨɧɱɚ-
ɬɟɥɶɧɨɣ ɜɟɪɫɢɢ, ɤɨɝɞɚ ɛɭɞɟɬ ɨɩɪɟɞɟɥɟɧ ɦɚɤɪɨɫ NDEBUG, ɩɪɨɜɟɪɤɢ ɧɟ ɛɭɞɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɧɢ-
ɤɚɤɨɝɨ ɤɨɞɚ:
assert ( ++i < limit ); // ǚǶǹȀǹ: i ǾǭǰǶǳȂǳǭǫǰǽǼȊ ǽǹǶȇǵǹ ǭ
// ǹǽǶǫǯǹȂǸǹǷ ǻǰǱǳǷǰ
ɋɨɝɥɚɫɧɨ ɬɟɨɪɢɢ ɢɧɮɨɪɦɚɰɢɢ, ɤɨɥɢɱɟɫɬɜɨ ɢɧɮɨɪɦɚɰɢɢ, ɡɚɤɥɸɱɚɸɳɟɟɫɹ ɜ ɫɨɛɵɬɢɢ, ɨɛ-
ɪɚɬɧɨ ɩɪɨɩɨɪɰɢɨɧɚɥɶɧɨ ɜɟɪɨɹɬɧɨɫɬɢ ɞɚɧɧɨɝɨ ɫɨɛɵɬɢɹ. Ɍɨ ɟɫɬɶ ɱɟɦ ɦɟɧɟɟ ɜɟɪɨɹɬɧɨ, ɱɬɨ ɤɚ-
ɤɚɹ-ɬɨ ɩɪɨɜɟɪɤɚ ɫɪɚɛɨɬɚɟɬ, ɬɟɦ ɛɨɥɶɲɟ ɢɧɮɨɪɦɚɰɢɢ ɜɵ ɩɨɥɭɱɢɬɟ, ɤɨɝɞɚ ɨɧɚ ɫɪɚɛɨɬɚɟɬ.
ɂɡɛɟɝɚɣɬɟ ɩɪɢɦɟɧɟɧɢɹ assert(false), ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ assert(!"ǳǸǿǹǻǷǫȁǳǹǸǸǹǰ
ǼǹǹǬȄǰǸǳǰ"). Ȼɨɥɶɲɢɧɫɬɜɨ ɤɨɦɩɢɥɹɬɨɪɨɜ ɜɫɬɚɜɹɬ ɫɬɪɨɤɭ ɜ ɜɵɜɨɞ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɟ. ɉɨɞɭ-
ɦɚɣɬɟ ɬɚɤɠɟ ɨ ɞɨɛɚɜɥɟɧɢɢ &&"ǳǸǿǹǻǷǫȁǳǹǸǸǹǰ ǼǹǹǬȄǰǸǳǰ" ɤ ɛɨɥɟɟ ɫɥɨɠɧɵɦ ɩɪɨɜɟɪɤɚɦ ɜɦɟ-
ɫɬɨ ɤɨɦɦɟɧɬɚɪɢɹ.
Ɋɚɫɫɦɨɬɪɢɦ ɨɩɪɟɞɟɥɟɧɢɟ ɜɚɲɟɝɨ ɫɨɛɫɬɜɟɧɧɨɝɨ assert. ɋɬɚɧɞɚɪɬɧɵɣ ɦɚɤɪɨɫ assert
ɩɪɨɫɬɨ ɛɟɫɰɟɪɟɦɨɧɧɨ ɡɚɜɟɪɲɚɟɬ ɜɚɲɭ ɩɪɨɝɪɚɦɦɭ ɫ ɜɵɜɨɞɨɦ ɫɨɨɛɳɟɧɢɹ ɜ ɫɬɚɧɞɚɪɬɧɵɣ ɩɨɬɨɤ
ɜɵɜɨɞɚ. ȼɚɲɚ ɫɪɟɞɚ, ɜɟɪɨɹɬɧɨ, ɨɛɥɚɞɚɟɬ ɪɚɫɲɢɪɟɧɧɵɦɢ ɜɨɡɦɨɠɧɨɫɬɹɦɢ ɨɬɥɚɞɤɢ; ɩɭɫɬɶ, ɧɚ-
ɩɪɢɦɟɪ, ɨɧɚ ɜ ɫɨɫɬɨɹɧɢɢ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɡɚɩɭɫɬɢɬɶ ɢɧɬɟɪɚɤɬɢɜɧɵɣ ɨɬɥɚɞɱɢɤ. ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɜɵ
ɦɨɠɟɬɟ ɨɩɪɟɞɟɥɢɬɶ ɫɨɛɫɬɜɟɧɧɵɣ ɦɚɤɪɨɫ MYASSERT ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɝɨ. Ɇɨɠɟɬ ɬɚɤɠɟ ɨɤɚ-
ɡɚɬɶɫɹ ɩɨɥɟɡɧɵɦ ɨɫɬɚɜɢɬɶ ɛɨɥɶɲɢɧɫɬɜɨ ɩɪɨɜɟɪɨɤ ɞɚɠɟ ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ ɜɟɪɫɢɢ ɩɪɨɝɪɚɦɦɵ
(ɥɭɱɲɟ ɧɟ ɨɬɤɥɸɱɚɬɶ ɩɪɨɜɟɪɤɢ ɩɨ ɫɨɨɛɪɚɠɟɧɢɹɦ ɷɮɮɟɤɬɢɜɧɨɫɬɢ, ɩɨɤɚ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɷɬɨɝɨ
144 Обработка ошибок и исключения
Стр. 144
ɨɬɤɥɸɱɟɧɢɹ ɧɟ ɛɭɞɟɬ ɬɨɱɧɨ ɞɨɤɚɡɚɧɚ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8), ɬɚɤ ɱɬɨ ɫɭɳɟɫɬɜɟɧɧɵɟ ɩɪɟɢɦɭɳɟ-
ɫɬɜɚ ɦɨɠɟɬ ɩɪɟɞɨɫɬɚɜɢɬɶ ɧɚɥɢɱɢɟ ɪɚɡɥɢɱɧɵɯ “ɭɪɨɜɧɟɣ ɩɪɨɜɟɪɤɢ”, ɧɟɤɨɬɨɪɵɟ ɢɡ ɤɨɬɨɪɵɯ ɦɨ-
ɝɭɬ ɨɫɬɚɜɚɬɶɫɹ ɚɤɬɢɜɧɵɦɢ ɢ ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ ɜɟɪɫɢɢ ɩɪɨɝɪɚɦɦɵ.
ɉɪɨɜɟɪɤɢ ɡɚɱɚɫɬɭɸ ɫɜɹɡɚɧɵ ɫ ɭɫɥɨɜɢɹɦɢ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ ɛɵɥɨ ɛɵ ɩɪɨɬɟɫɬɢɪɨɜɚɬɶ ɜɨ
ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ, ɟɫɥɢ ɛɵ ɹɡɵɤ ɛɵɥ ɞɨɫɬɚɬɨɱɧɨ ɜɵɪɚɡɢɬɟɥɟɧ ɞɥɹ ɷɬɨɝɨ. ɇɚɩɪɢɦɟɪ, ɜɚɲ ɩɪɨ-
ɟɤɬ ɦɨɠɟɬ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɬɨ, ɱɬɨ ɤɚɠɞɵɣ ɨɛɴɟɤɬ ɤɥɚɫɫɚ Employee ɢɦɟɟɬ ɧɟɧɭɥɟɜɨɣ ɢɞɟɧɬɢ-
ɮɢɤɚɬɨɪ id_. ȼ ɢɞɟɚɥɟ ɤɨɦɩɢɥɹɬɨɪ ɦɨɝ ɛɵ ɚɧɚɥɢɡɢɪɨɜɚɬɶ ɤɨɧɫɬɪɭɤɬɨɪ Employee ɢ ɟɝɨ ɱɥɟ-
ɧɵ ɢ ɞɨɤɚɡɚɬɶ ɩɪɢ ɩɨɦɨɳɢ ɫɬɚɬɢɱɟɫɤɨɝɨ ɚɧɚɥɢɡɚ, ɱɬɨ ɭɤɚɡɚɧɧɨɟ ɭɫɥɨɜɢɟ ɜɫɟɝɞɚ ɜɵɩɨɥɧɹɟɬɫɹ.
ȼ ɪɟɚɥɶɧɨɣ ɫɢɬɭɚɰɢɢ ɜɵ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ assert(id_!=0) ɜ ɪɟɚɥɢɡɚɰɢɢ Employee:
unsigned int Employee::GetID() {
assert (id_!=0 && " Employee ID ǯǹǶǱǰǸ ǬȆǽȇ ǸǰǸǾǶǰǭȆǷ") ;
return id_;
}
ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ assert ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɢ 70 ɢ 72). ɇɚɩɪɢɦɟɪ, ɧɟ ɫɥɟɞɭɟɬ ɩɪɢɦɟɧɹɬɶ assert, ɱɬɨɛɵ ɭɛɟɞɢɬɶɫɹ ɜ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɟ
malloc, ɭɫɩɟɲɧɨɦ ɫɨɡɞɚɧɢɢ ɨɤɧɚ ɢɥɢ ɡɚɩɭɫɤɟ ɩɨɬɨɤɚ ɩɪɨɝɪɚɦɦɵ. Ɉɞɧɚɤɨ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ assert, ɱɬɨɛɵ ɭɛɟɞɢɬɶɫɹ, ɱɬɨ API ɪɚɛɨɬɚɟɬ ɬɚɤ, ɤɚɤ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɨ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ
ɜɵ ɜɵɡɵɜɚɟɬɟ ɧɟɤɨɬɨɪɭɸ ɮɭɧɤɰɢɸ API, ɜ ɞɨɤɭɦɟɧɬɚɰɢɢ ɧɚ ɤɨɬɨɪɭɸ ɫɤɚɡɚɧɨ, ɱɬɨ ɨɧɚ ɜɫɟɝɞɚ
ɜɨɡɜɪɚɳɚɟɬ ɩɨɥɨɠɢɬɟɥɶɧɨɟ ɡɧɚɱɟɧɢɟ, ɧɨ ɜɵ ɩɨɞɨɡɪɟɜɚɟɬɟ ɧɚɥɢɱɢɟ ɜ ɧɟɣ ɨɲɢɛɤɢ — ɩɨɫɥɟ ɜɵ-
ɡɨɜɚ ɷɬɨɣ ɮɭɧɤɰɢɢ ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ assert ɞɥɹ ɩɪɨɜɟɪɤɢ ɜɵɩɨɥɧɟɧɢɹ ɩɨɫɬɭɫɥɨɜɢɹ.
ɇɟ ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɜɦɟɫɬɨ ɩɪɨɜɟɪɨɤ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ, ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɢɦɟɧɧɨ
ɞɥɹ ɷɬɨɣ ɰɟɥɢ ɛɵɥ ɪɚɡɪɚɛɨɬɚɧ ɫɬɚɧɞɚɪɬɧɵɣ ɤɥɚɫɫ std::logic_error. Ƚɥɚɜɧɵɣ ɧɟɞɨɫɬɚɬɨɤ
ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɢɫɤɥɸɱɟɧɢɣ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨ ɩɪɨɝɪɚɦɦɧɵɯ ɨɲɢɛɤɚɯ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɩɪɢ
ɷɬɨɦ ɧɟ ɬɪɟɛɭɟɬɫɹ ɫɜɟɪɬɤɚ ɫɬɟɤɚ — ɠɟɥɚɬɟɥɶɧɨ ɜɵɡɜɚɬɶ ɨɬɥɚɞɱɢɤ ɢɦɟɧɧɨ ɜ ɬɨɣ ɫɬɪɨɤɟ, ɝɞɟ
ɨɛɧɚɪɭɠɟɧɨ ɧɚɪɭɲɟɧɢɟ, ɫ ɩɨɥɧɵɦ ɫɨɯɪɚɧɟɧɢɟɦ ɫɨɫɬɨɹɧɢɹ ɩɪɨɝɪɚɦɦɵ.
Ɋɟɡɸɦɢɪɭɹ: ɢɦɟɸɬɫɹ ɨɲɢɛɤɢ, ɨ ɤɨɬɨɪɵɯ ɜɵ ɡɧɚɟɬɟ, ɱɬɨ ɨɧɢ ɦɨɝɭɬ ɩɪɨɢɡɨɣɬɢ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɢ ɫ 69 ɩɨ 75). ȼɫɟ ɨɫɬɚɥɶɧɵɟ ɨɲɢɛɤɢ ɩɪɨɢɡɨɣɬɢ ɧɟ ɞɨɥɠɧɵ, ɢ ɟɫɥɢ ɷɬɨ ɜɫɟ ɠɟ ɫɥɭɱɚ-
ɟɬɫɹ — ɬɨ ɷɬɨ ɨɲɢɛɤɚ ɩɪɨɝɪɚɦɦɢɫɬɚ. Ⱦɥɹ ɬɚɤɢɯ ɨɲɢɛɨɤ ɢɦɟɟɬɫɹ assert.
Примеры
ɉɪɢɦɟɪ. ɉɪɨɜɟɪɤɚ ɛɚɡɨɜɵɯ ɞɨɩɭɳɟɧɢɣ. ȼɫɟ ɦɵ ɫɬɚɥɤɢɜɚɥɢɫɶ ɫ ɫɢɬɭɚɰɢɹɦɢ, ɤɨɝɞɚ ɩɪɨɢɫ-
ɯɨɞɢɥɨ ɱɬɨ-ɬɨ, ɱɬɨ “ɧɭ ɧɢɤɚɤ ɧɟ ɦɨɠɟɬ ɩɪɨɢɡɨɣɬɢ”. ɇɨ ɱɚɫɬɨ ɞɚɠɟ ɫɨɛɫɬɜɟɧɧɵɣ ɨɩɵɬ ɦɚɥɨ
ɱɟɦɭ ɭɱɢɬ, ɢ ɱɟɪɟɡ ɧɟɤɨɬɨɪɨɟ ɜɪɟɦɹ ɨɩɹɬɶ ɧɚɱɢɧɚɟɬɫɹ — “ɷɬɨ ɡɧɚɱɟɧɢɟ ɦɨɠɟɬ ɛɵɬɶ ɬɨɥɶɤɨ
ɩɨɥɨɠɢɬɟɥɶɧɵɦ!”, “ɫɨɜɟɪɲɟɧɧɨ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɷɬɨɬ ɭɤɚɡɚɬɟɥɶ ɧɟ ɧɭɥɟɜɨɣ!”… Ɋɚɡɪɚɛɨɬɤɚ ɩɪɨ-
ɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ — ɪɚɛɨɬɚ ɫɥɨɠɧɚɹ, ɢ ɜ ɩɪɨɝɪɚɦɦɟ, ɜ ɤɨɬɨɪɭɸ ɜɧɨɫɹɬɫɹ ɢɡɦɟɧɟɧɢɹ,
ɦɨɠɟɬ ɩɪɨɢɡɨɣɬɢ ɜɫɟ, ɱɬɨ ɭɝɨɞɧɨ. ɉɪɨɜɟɪɤɢ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɭɛɟɞɢɬɶɫɹ ɜ
ɫɩɪɚɜɟɞɥɢɜɨɫɬɢ ɜɚɲɢɯ ɩɪɟɞɩɨɥɨɠɟɧɢɣ. ɇɟ ɫɬɟɫɧɹɣɬɟɫɶ ɩɪɨɜɟɪɹɬɶ ɬɚɜɬɨɥɨɝɢɢ, ɤɨɬɨɪɵɟ ɧɟ ɜ
ɫɨɫɬɨɹɧɢɢ ɨɛɟɫɩɟɱɢɬɶ ɫɢɫɬɟɦɚ:
string Date::DayOfWeek() const {
// ǚǻǹǭǰǻǵǫ ǳǸǭǫǻǳǫǸǽǹǭ
assert ( day_ > 0 && day_ <= 31 );
assert ( month_ > 0 && month_ <= 12 );
// ...
}
Ссылки
[Abrahams01b] • [Alexandrescu03b] • [Alexandrescu03c] • [Allison98] §13 • [Cargill92] pp. 34-35 •
[Cline99] §10.01-10 • [Dewhurst03] §28 • [Keffer95] pp. 24-25 • [Lakos96] §2.6, §10.2.1 •
[McConnell93] §5.6 • [Stroustrup00] §24.3.7, §E.2, §E.3.5, §E.6 • [Sutter00] §47
68. Широко применяйте assert для документирования внутренних допущений... 145
Стр. 145
69. Определите разумную стратегию
обработки ошибок и строго ей следуйте
Резюме
ȿɳɟ ɧɚ ɪɚɧɧɟɣ ɫɬɚɞɢɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɪɚɡɪɚɛɨɬɚɣɬɟ ɩɪɚɤɬɢɱɧɭɸ, ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɭɸ ɢ ɪɚ-
ɡɭɦɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɫɥɟɞɭɣɬɟ ɟɣ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲɚ ɫɬɪɚɬɟɝɢɹ
ɜɤɥɸɱɚɟɬ ɫɥɟɞɭɸɳɟɟ.
• ɂɞɟɧɬɢɮɢɤɚɰɢɹ: ɤɚɤɢɟ ɭɫɥɨɜɢɹ ɹɜɥɹɸɬɫɹ ɨɲɢɛɤɨɣ.
• ɋɬɪɨɝɨɫɬɶ: ɧɚɫɤɨɥɶɤɨ ɜɚɠɧɚ ɤɚɠɞɚɹ ɨɲɢɛɤɚ.
• Ɉɛɧɚɪɭɠɟɧɢɟ: ɤɚɤɨɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɡɚ ɨɛɧɚɪɭɠɟɧɢɟ ɨɲɢɛɤɢ.
• Ɋɚɫɩɪɨɫɬɪɚɧɟɧɢɟ: ɤɚɤɨɣ ɦɟɯɚɧɢɡɦ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɨɩɢɫɚɧɢɹ ɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɹ ɭɜɟ-
ɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɟ ɜ ɤɚɠɞɨɦ ɦɨɞɭɥɟ.
• Ɉɛɪɚɛɨɬɤɚ: ɤɚɤɨɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɡɚ ɜɵɩɨɥɧɟɧɢɟ ɞɟɣɫɬɜɢɣ, ɫɜɹɡɚɧɧɵɯ ɫ ɨɲɢɛɤɨɣ.
• ɍɜɟɞɨɦɥɟɧɢɟ: ɤɚɤɢɦ ɨɛɪɚɡɨɦ ɢɧɮɨɪɦɚɰɢɹ ɨɛ ɨɲɢɛɤɟ ɜɧɨɫɢɬɫɹ ɜ ɠɭɪɧɚɥɶɧɵɣ ɮɚɣɥ ɢɥɢ
ɩɪɨɢɡɜɨɞɢɬɫɹ ɭɜɟɞɨɦɥɟɧɢɟ ɩɨɥɶɡɨɜɚɬɟɥɹ ɩɪɨɝɪɚɦɦɵ.
ɂɡɦɟɧɹɣɬɟ ɦɟɯɚɧɢɡɦɵ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɬɨɥɶɤɨ ɜ ɩɪɟɞɟɥɚɯ ɝɪɚɧɢɰ ɦɨɞɭɥɹ.
ȼ ɷɬɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɦɵ ɪɚɫɫɦɚɬɪɢɜɚɟɦ ɨɲɢɛɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, ɜɨɡɧɢɤɧɨɜɟɧɢɟ ɤɨ-
ɬɨɪɵɯ ɧɟ ɫɜɹɡɚɧɨ ɫ ɧɟɜɟɪɧɵɦ ɤɨɞɢɪɨɜɚɧɢɟɦ (ɬɚɤɢɦ ɨɲɢɛɤɚɦ ɩɨɫɜɹɳɟɧɚ ɪɟɤɨɦɟɧɞɚɰɢɹ 68).
Ɉɩɪɟɞɟɥɢɬɟ ɫɬɪɚɬɟɝɢɸ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɢ ɢɯ ɨɛɪɚɛɨɬɤɢ ɞɥɹ ɜɚɲɟɝɨ ɩɪɢɥɨɠɟɧɢɹ
ɢ ɞɥɹ ɤɚɠɞɨɝɨ ɦɨɞɭɥɹ ɢɥɢ ɩɨɞɫɢɫɬɟɦɵ, ɢ ɫɬɪɨɝɨ ɫɥɟɞɭɣɬɟ ɟɣ. ɋɬɪɚɬɟɝɢɹ ɞɨɥɠɧɚ ɜɤɥɸɱɚɬɶ,
ɤɚɤ ɦɢɧɢɦɭɦ, ɫɥɟɞɭɸɳɢɟ ɩɭɧɤɬɵ.
ȼɟɡɞɟ.
• Ɉɩɪɟɞɟɥɟɧɢɟ ɨɲɢɛɨɤ. Ⱦɥɹ ɤɚɠɞɨɣ ɫɭɳɧɨɫɬɢ (ɧɚɩɪɢɦɟɪ, ɞɥɹ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ, ɤɥɚɫɫɚ,
ɦɨɞɭɥɹ) ɞɨɤɭɦɟɧɬɢɪɭɣɬɟ ɜɧɭɬɪɟɧɧɢɟ ɢ ɜɧɟɲɧɢɟ ɢɧɜɚɪɢɚɧɬɵ.
Ⱦɥɹ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ.
• Ɉɩɪɟɞɟɥɟɧɢɟ ɨɲɢɛɨɤ. Ⱦɥɹ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ ɞɨɤɭɦɟɧɬɢɪɭɣɬɟ ɟɟ ɩɪɟɞ- ɢ ɩɨɫɬɭɫɥɨɜɢɹ,
ɢɧɜɚɪɢɚɧɬɵ, ɡɚ ɤɨɬɨɪɵɟ ɨɧɚ ɨɬɜɟɱɚɟɬ, ɢ ɝɚɪɚɧɬɢɢ ɛɟɡɨɩɚɫɧɨɫɬɢ, ɤɨɬɨɪɵɟ ɨɧɚ ɩɨɞɞɟɪ-
ɠɢɜɚɟɬ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 70 ɢ 71). Ɂɚɦɟɬɢɦ, ɱɬɨ ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟ-
ɧɢɹ ɪɟɫɭɪɫɨɜ ɞɨɥɠɧɵ ɜɫɟɝɞɚ ɩɨɞɞɟɪɠɢɜɚɬɶ ɝɚɪɚɧɬɢɸ ɛɟɫɫɛɨɣɧɨɫɬɢ, ɩɨɫɤɨɥɶɤɭ ɜ ɩɪɨ-
ɬɢɜɧɨɦ ɫɥɭɱɚɟ ɱɚɫɬɨ ɧɟɜɨɡɦɨɠɧɨ ɧɚɞɟɠɧɨ ɢ ɛɟɡɨɩɚɫɧɨ ɜɵɩɨɥɧɢɬɶ ɨɫɜɨɛɨɠɞɟɧɢɟ ɡɚ-
ɯɜɚɱɟɧɧɵɯ ɪɟɫɭɪɫɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 51).
Ⱦɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ (ɫɦ. ɨɩɪɟɞɟɥɟɧɢɟ “ɨɲɢɛɤɢ” ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 70).
• ɋɟɪɶɟɡɧɨɫɬɶ ɨɲɢɛɤɢ ɢ ɤɚɬɟɝɨɪɢɡɚɰɢɹ. Ⱦɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ ɨɩɪɟɞɟɥɢɬɟ ɭɪɨɜɟɧɶ ɫɟɪɶ-
ɟɡɧɨɫɬɢ. ɀɟɥɚɬɟɥɶɧɨ ɩɪɟɞɨɫɬɚɜɢɬɶ ɫɩɨɫɨɛ ɬɨɧɤɨɣ ɧɚɫɬɪɨɣɤɢ ɞɢɚɝɧɨɫɬɢɤɢ ɞɥɹ ɨɩɪɟɞɟ-
ɥɟɧɧɵɯ ɤɚɬɟɝɨɪɢɣ ɢ ɭɪɨɜɧɟɣ ɨɲɢɛɨɤ.
• Ɉɛɧɚɪɭɠɟɧɢɟ ɨɲɢɛɨɤ. Ⱦɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ ɞɨɤɭɦɟɧɬɢɪɭɣɬɟ, ɤɚɤɨɣ ɢɦɟɧɧɨ ɤɨɞ ɨɬɜɟ-
ɱɚɟɬ ɡɚ ɟɟ ɨɛɧɚɪɭɠɟɧɢɟ, ɫɥɟɞɭɹ ɫɨɜɟɬɚɦ ɪɟɤɨɦɟɧɞɚɰɢɢ 70.
• Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ. Ⱦɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ ɨɩɪɟɞɟɥɢɬɟ ɤɨɞ, ɤɨɬɨɪɵɣ ɨɬɜɟɱɚɟɬ ɡɚ ɟɟ ɨɛ-
ɪɚɛɨɬɤɭ, ɫɥɟɞɭɹ ɫɨɜɟɬɚɦ ɪɟɤɨɦɟɧɞɚɰɢɢ 74.
Стр. 146
• ɍɜɟɞɨɦɥɟɧɢɟ ɨɛ ɨɲɢɛɤɚɯ. Ⱦɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ ɨɩɪɟɞɟɥɢɬɟ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɦɟɬɨɞ
ɭɜɟɞɨɦɥɟɧɢɹ. ɋɸɞɚ ɜɯɨɞɹɬ ɡɚɩɢɫɶ ɧɚ ɞɢɫɤ ɜ ɠɭɪɧɚɥɶɧɵɣ ɮɚɣɥ, ɪɚɫɩɟɱɚɬɤɚ ɢɥɢ ɞɚɠɟ
ɨɬɩɪɚɜɤɚ SMS ɧɚ ɦɨɛɢɥɶɧɵɣ ɬɟɥɟɮɨɧ ɚɞɦɢɧɢɫɬɪɚɬɨɪɚ.
Ⱦɥɹ ɤɚɠɞɨɝɨ ɦɨɞɭɥɹ.
• ɉɟɪɟɞɚɱɚ ɨɲɢɛɤɢ. Ⱦɥɹ ɤɚɠɞɨɝɨ ɦɨɞɭɥɹ (ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ: ɞɥɹ ɤɚɠɞɨɝɨ ɦɨɞɭɥɹ, ɚ ɧɟ
ɞɥɹ ɤɚɠɞɨɣ ɨɲɢɛɤɢ) ɨɩɪɟɞɟɥɢɬɟ ɦɟɯɚɧɢɡɦ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɞɥɹ ɩɟɪɟɞɚ-
ɱɢ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɨɲɢɛɤɟ (ɧɚɩɪɢɦɟɪ, ɢɫɤɥɸɱɟɧɢɹ C++, ɢɫɤɥɸɱɟɧɢɹ COM, ɢɫɤɥɸɱɟ-
ɧɢɹ CORBA, ɤɨɞɵ ɜɨɡɜɪɚɬɚ).
Ɇɵ ɭɠɟ ɩɨɞɱɟɪɤɢɜɚɥɢ, ɱɬɨ ɫɬɪɚɬɟɝɢɹ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɦɨɠɟɬ ɢɡɦɟɧɹɬɶɫɹ ɬɨɥɶɤɨ ɧɚ ɝɪɚ-
ɧɢɰɚɯ ɦɨɞɭɥɟɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 62 ɢ 63). Ʉɚɠɞɵɣ ɦɨɞɭɥɶ ɞɨɥɠɟɧ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨ ɢɫɩɨɥɶ-
ɡɨɜɚɬɶ ɟɞɢɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɜɧɭɬɪɢ ɦɨɞɭɥɹ (ɧɚɩɪɢɦɟɪ, ɦɨɞɭɥɢ, ɧɚɩɢɫɚɧɧɵɟ
ɧɚ C++, ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 72), ɢ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨ ɩɨɥɶ-
ɡɨɜɚɬɶɫɹ ɟɞɢɧɨɣ, ɯɨɬɹ, ɜɨɡɦɨɠɧɨ, ɢɧɨɣ ɫɬɪɚɬɟɝɢɟɣ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɞɥɹ ɫɜɨɟɝɨ ɢɧɬɟɪɮɟɣɫɚ
(ɧɚɩɪɢɦɟɪ, ɦɨɞɭɥɶ ɦɨɠɟɬ ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɨɛɵɱɧɵɣ API ɧɚ ɹɡɵɤɟ C, ɱɬɨɛɵ ɨɛɟɫɩɟɱɢɬɶ ɜɨɡ-
ɦɨɠɧɨɫɬɶ ɟɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɤɨɞɨɦ, ɧɚɩɢɫɚɧɧɨɦ ɧɚ ɪɚɡɧɵɯ ɹɡɵɤɚɯ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ; ɢɥɢ
ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɨɥɨɱɤɭ COM ɢ, ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ, ɢɫɤɥɸɱɟɧɢɹ COM).
ȼɫɟ ɮɭɧɤɰɢɢ, ɹɜɥɹɸɳɢɟɫɹ ɬɨɱɤɚɦɢ ɜɯɨɞɚ ɜ ɦɨɞɭɥɶ, ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɨɬɜɟɱɚɸɬ ɡɚ ɩɪɟɨɛ-
ɪɚɡɨɜɚɧɢɟ ɦɟɠɞɭ ɜɧɭɬɪɟɧɧɟɣ ɢ ɜɧɟɲɧɟɣ ɫɬɪɚɬɟɝɢɹɦɢ, ɟɫɥɢ ɨɧɢ ɪɚɡɥɢɱɧɵ. ɇɚɩɪɢɦɟɪ, ɜ ɦɨɞɭ-
ɥɟ, ɤɨɬɨɪɵɣ ɜɧɭɬɪɟɧɧɟ ɢɫɩɨɥɶɡɭɟɬ ɢɫɤɥɸɱɟɧɢɹ C++, ɧɨ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɢɧɬɟɪɮɟɣɫ ɜ ɫɬɢɥɟ C
API, ɜɫɟ ɮɭɧɤɰɢɢ ɢɧɬɟɪɮɟɣɫɚ ɞɨɥɠɧɵ ɫɨɞɟɪɠɚɬɶ ɩɟɪɟɯɜɚɬ catch(...) ɜɫɟɯ ɢɫɤɥɸɱɟɧɢɣ
ɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶ ɢɯ ɜ ɤɨɞɵ ɨɲɢɛɨɤ.
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɜ ɱɚɫɬɧɨɫɬɢ, ɧɚ ɬɨ, ɱɬɨ ɮɭɧɤɰɢɢ ɨɛɪɚɬɧɨɝɨ ɜɵɡɨɜɚ ɢ ɮɭɧɤɰɢɢ ɩɨɬɨɤɨɜ
ɩɨ ɨɩɪɟɞɟɥɟɧɢɸ ɹɜɥɹɸɬɫɹ (ɢɥɢ ɦɨɝɭɬ ɛɵɬɶ) ɝɪɚɧɢɰɚɦɢ ɦɨɞɭɥɹ. Ɍɟɥɨ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ ɨɛɪɚɬ-
ɧɨɝɨ ɜɵɡɨɜɚ ɢɥɢ ɮɭɧɤɰɢɢ ɩɨɬɨɤɚ ɞɨɥɠɧɨ ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶ ɜɧɭɬɪɟɧɧɢɣ ɦɟɯɚɧɢɡɦ ɨɲɢɛɨɤ
ɜ ɦɟɯɚɧɢɡɦ, ɢɫɩɨɥɶɡɭɸɳɢɣɫɹ ɫɬɪɚɬɟɝɢɟɣ ɢɧɬɟɪɮɟɣɫɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 62).
Ссылки
[Abrahams01b] • [Allison98] §13 • [McConnell93] §5.6 • [Stroustrup94] §16.2, §E.2 • [Stroustrup00]
§14.9, §19.3.1 • [Sutter04b]
69. Определите разумную стратегию обработки ошибок и строго ей следуйте 147
Стр. 147
70. Отличайте ошибки от ситуаций,
не являющихся ошибками
Резюме
Ɏɭɧɤɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɛɨɢ ɫɥɟɞɭɟɬ ɪɚɫɫɦɚɬɪɢ-
ɜɚɬɶ ɥɢɛɨ ɤɚɤ ɨɲɢɛɤɢ, ɥɢɛɨ ɤɚɤ ɲɬɚɬɧɵɟ ɫɢɬɭɚɰɢɢ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɢɯ ɜɥɢɹɧɢɹ ɧɚ ɮɭɧɤɰɢɢ.
ȼ ɮɭɧɤɰɢɢ f ɫɛɨɣ ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ ɬɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɨɧ ɧɚɪɭɲɚɟɬ ɨɞɧɨ ɢɡ ɩɪɟɞɭ-
ɫɥɨɜɢɣ f, ɧɟ ɩɨɡɜɨɥɹɟɬ ɜɵɩɨɥɧɢɬɶ ɩɪɟɞɭɫɥɨɜɢɟ ɜɵɡɵɜɚɟɦɨɣ ɟɸ ɮɭɧɤɰɢɢ, ɩɪɟɩɹɬɫɬɜɭɟɬ ɞɨɫ-
ɬɢɠɟɧɢɸ ɫɨɛɫɬɜɟɧɧɵɯ ɩɨɫɬɭɫɥɨɜɢɣ f ɢɥɢ ɫɨɯɪɚɧɟɧɢɸ ɢɧɜɚɪɢɚɧɬɚ, ɡɚ ɩɨɞɞɟɪɠɤɭ ɤɨɬɨɪɨɝɨ
ɨɬɜɟɱɚɟɬ ɮɭɧɤɰɢɹ f.
ȼ ɱɚɫɬɧɨɫɬɢ, ɜ ɷɬɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɦɵ ɢɫɤɥɸɱɚɟɦ ɜɧɭɬɪɟɧɧɢɟ ɩɪɨɝɪɚɦɦɧɵɟ ɨɲɢɛɤɢ (ɬ.ɟ. ɬɟ,
ɝɞɟ ɡɚ ɜɵɡɵɜɚɸɳɢɣ ɢ ɜɵɡɵɜɚɟɦɵɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɱɟɥɨɜɟɤ ɢɥɢ ɤɨɦɚɧɞɚ, ɧɚɩɪɢɦɟɪ,
ɜ ɩɪɟɞɟɥɚɯ ɨɞɧɨɝɨ ɦɨɞɭɥɹ). Ɉɧɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɨɬɞɟɥɶɧɭɸ ɤɚɬɟɝɨɪɢɸ ɨɲɢɛɨɤ, ɞɥɹ ɪɚɛɨɬɵ
ɫ ɤɨɬɨɪɨɣ ɢɫɩɨɥɶɡɭɟɬɫɹ ɬɚɤɨɟ ɫɪɟɞɫɬɜɨ, ɤɚɤ ɩɪɨɜɟɪɤɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68).
Ɉɱɟɧɶ ɜɚɠɧɨ ɱɟɬɤɨ ɪɚɡɥɢɱɚɬɶ ɨɲɢɛɤɢ ɢ ɫɢɬɭɚɰɢɢ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɨɲɢɛɤɚɦɢ ɜ ɩɥɚɧɟ ɢɯ
ɜɥɢɹɧɢɹ ɧɚ ɪɚɛɨɬɭ ɮɭɧɤɰɢɣ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɜ ɰɟɥɹɯ ɨɩɪɟɞɟɥɟɧɢɹ ɝɚɪɚɧɬɢɣ ɛɟɡɨɩɚɫɧɨɫɬɢ (ɫɦ. ɪɟ-
ɤɨɦɟɧɞɚɰɢɸ 71). Ʉɥɸɱɟɜɵɦɢ ɫɥɨɜɚɦɢ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɹɜɥɹɸɬɫɹ ɩɪɟɞɭɫɥɨɜɢɟ, ɩɨɫɬɭɫɥɨ-
ɜɢɟ ɢ ɢɧɜɚɪɢɚɧɬ.
Ɏɭɧɤɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɛɚɡɨɜɭɸ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ, ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɬɨɝɨ, ɩɪɨɝɪɚɦɦɢ-
ɪɭɟɬɟ ɥɢ ɜɵ ɧɚ C++ ɜ ɫɬɪɭɤɬɭɪɧɨɦ, ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɦ ɢɥɢ ɨɛɨɛɳɟɧɧɨɦ ɫɬɢɥɟ.
Ɏɭɧɤɰɢɹ ɞɟɥɚɟɬ ɨɩɪɟɞɟɥɟɧɧɵɟ ɩɪɟɞɩɨɥɨɠɟɧɢɹ ɨ ɧɚɱɚɥɶɧɨɦ ɫɨɫɬɨɹɧɢɢ (ɩɪɟɞɭɫɥɨɜɢɹ, ɡɚ ɜɵ-
ɩɨɥɧɟɧɢɟ ɤɨɬɨɪɵɯ ɧɟɫɟɬ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ, ɚ ɡɚ ɩɪɨɜɟɪɤɭ — ɜɵɡɵɜɚɟɦɵɣ)
ɢ ɜɵɩɨɥɧɹɟɬ ɨɞɧɨ ɢɥɢ ɧɟɫɤɨɥɶɤɨ ɞɟɣɫɬɜɢɣ (ɞɨɤɭɦɟɧɬɢɪɭɟɦɵɯ, ɤɚɤ ɪɟɡɭɥɶɬɚɬ ɜɵɩɨɥɧɟɧɢɹ
ɮɭɧɤɰɢɢ, ɢɥɢ ɟɟ ɩɨɫɬɭɫɥɨɜɢɹ, ɡɚ ɜɵɩɨɥɧɟɧɢɟ ɤɨɬɨɪɵɯ ɧɟɫɟɬ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɞɚɧɧɚɹ ɮɭɧɤ-
ɰɢɹ). Ɏɭɧɤɰɢɹ ɦɨɠɟɬ (ɧɚɪɹɞɭ ɫ ɞɪɭɝɢɦɢ ɮɭɧɤɰɢɹɦɢ) ɧɟɫɬɢ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɩɨɞɞɟɪɠɚɧɢɟ
ɨɞɧɨɝɨ ɢɥɢ ɧɟɫɤɨɥɶɤɢɯ ɢɧɜɚɪɢɚɧɬɨɜ. ȼ ɱɚɫɬɧɨɫɬɢ, ɧɟ ɡɚɤɪɵɬɚɹ ɧɟɤɨɧɫɬɚɧɬɧɚɹ ɮɭɧɤɰɢɹ-ɱɥɟɧ
ɩɨ ɨɩɪɟɞɟɥɟɧɢɸ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ ɧɚɞ ɨɛɴɟɤɬɨɦ, ɢ ɞɨɥɠɧɚ ɩɟɪɟɜɟɫɬɢ ɨɛɴ-
ɟɤɬ ɢɡ ɨɞɧɨɝɨ ɤɨɪɪɟɤɬɧɨɝɨ, ɫɨɯɪɚɧɹɸɳɟɝɨ ɢɧɜɚɪɢɚɧɬ ɫɨɫɬɨɹɧɢɹ ɜ ɞɪɭɝɨɟ. ȼɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟ-
ɧɢɹ ɬɟɥɚ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɢɧɜɚɪɢɚɧɬ ɨɛɴɟɤɬɚ ɦɨɠɟɬ (ɢ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟɝɞɚ ɞɨɥɠɟɧ) ɧɚɪɭɲɚɬɶ-
ɫɹ, ɢ ɷɬɨ ɜɩɨɥɧɟ ɧɨɪɦɚɥɶɧɚɹ ɫɢɬɭɚɰɢɹ, ɥɢɲɶ ɛɵ ɩɨ ɨɤɨɧɱɚɧɢɢ ɪɚɛɨɬɵ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɢɧɜɚɪɢ-
ɚɧɬ ɜɧɨɜɶ ɜɵɩɨɥɧɹɥɫɹ. Ɏɭɧɤɰɢɢ ɛɨɥɟɟ ɜɵɫɨɤɨɝɨ ɭɪɨɜɧɹ ɨɛɴɟɞɢɧɹɸɬ ɮɭɧɤɰɢɢ ɛɨɥɟɟ ɧɢɡɤɨɝɨ
ɭɪɨɜɧɹ ɜ ɛɨɥɶɲɢɟ ɟɞɢɧɢɰɵ ɪɚɛɨɬɵ.
Ɉɲɢɛɤɨɣ ɹɜɥɹɟɬɫɹ ɥɸɛɨɣ ɫɛɨɣ, ɤɨɬɨɪɵɣ ɧɟ ɞɚɟɬ ɮɭɧɤɰɢɢ ɭɫɩɟɲɧɨ ɡɚɜɟɪɲɢɬɶɫɹ. ɂɦɟɟɬɫɹ
ɬɪɢ ɜɢɞɚ ɨɲɢɛɨɤ.
• ɇɚɪɭɲɟɧɢɟ ɢɥɢ ɧɟɜɨɡɦɨɠɧɨɫɬɶ ɞɨɫɬɢɠɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɹ. Ɏɭɧɤɰɢɹ ɨɛɧɚɪɭɠɢɜɚɟɬ ɧɚ-
ɪɭɲɟɧɢɟ ɨɞɧɨɝɨ ɢɡ ɫɜɨɢɯ ɫɨɛɫɬɜɟɧɧɵɯ ɩɪɟɞɭɫɥɨɜɢɣ (ɧɚɩɪɢɦɟɪ, ɨɝɪɚɧɢɱɟɧɢɹ, ɧɚɤɥɚɞɵ-
ɜɚɟɦɨɝɨ ɧɚ ɩɚɪɚɦɟɬɪ ɢɥɢ ɫɨɫɬɨɹɧɢɟ) ɢɥɢ ɫɬɚɥɤɢɜɚɟɬɫɹ ɫ ɭɫɥɨɜɢɟɦ, ɤɨɬɨɪɨɟ ɧɟ ɩɨɡɜɨɥɹ-
ɟɬ ɞɨɫɬɢɱɶ ɜɵɩɨɥɧɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɹ ɞɥɹ ɧɟɤɨɬɨɪɨɣ ɞɪɭɝɨɣ ɧɟɨɬɴɟɦɥɟɦɨɣ ɮɭɧɤɰɢɢ,
ɤɨɬɨɪɚɹ ɞɨɥɠɧɚ ɛɵɬɶ ɜɵɡɜɚɧɚ.
• ɇɟɫɩɨɫɨɛɧɨɫɬɶ ɞɨɫɬɢɱɶ ɩɨɫɬɭɫɥɨɜɢɹ. Ɏɭɧɤɰɢɹ ɫɬɚɥɤɢɜɚɟɬɫɹ ɫ ɫɢɬɭɚɰɢɟɣ, ɤɨɬɨɪɚɹ ɧɟ ɩɨ-
ɡɜɨɥɹɟɬ ɟɣ ɜɵɩɨɥɧɢɬɶ ɨɞɧɨ ɢɡ ɟɟ ɫɨɛɫɬɜɟɧɧɵɯ ɩɨɫɬɭɫɥɨɜɢɣ. ȿɫɥɢ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ, ɩɨɥɭɱɟɧɢɟ ɤɨɪɪɟɤɬɧɨɝɨ ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɡɧɚɱɟɧɢɹ ɹɜɥɹɟɬɫɹ ɟɟ ɩɨɫɬɭɫɥɨɜɢɟɦ.
Стр. 148
• ɇɟɫɩɨɫɨɛɧɨɫɬɶ ɜɨɫɫɬɚɧɨɜɥɟɧɢɹ ɢɧɜɚɪɢɚɧɬɚ. Ɏɭɧɤɰɢɹ ɫɬɚɥɤɢɜɚɟɬɫɹ ɫ ɫɢɬɭɚɰɢɟɣ, ɤɨ-
ɬɨɪɚɹ ɧɟ ɩɨɡɜɨɥɹɟɬ ɟɣ ɜɨɫɫɬɚɧɨɜɢɬɶ ɢɧɜɚɪɢɚɧɬ, ɡɚ ɩɨɞɞɟɪɠɤɭ ɤɨɬɨɪɨɝɨ ɨɧɚ ɨɬɜɟɱɚɟɬ.
ɗɬɨ ɱɚɫɬɧɵɣ ɫɥɭɱɚɣ ɩɨɫɬɭɫɥɨɜɢɹ, ɤɨɬɨɪɵɣ ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɨɬɧɨɫɢɬɫɹ ɤ ɮɭɧɤɰɢɹɦ-
ɱɥɟɧɚɦ. ȼɚɠɧɟɣɲɢɦ ɩɨɫɬɭɫɥɨɜɢɟɦ ɜɫɟɯ ɧɟ ɡɚɤɪɵɬɵɯ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɹɜɥɹɟɬɫɹ ɜɨɫɫɬɚ-
ɧɨɜɥɟɧɢɟ ɢɧɜɚɪɢɚɧɬɚ ɤɥɚɫɫɚ (ɫɦ. [Stroustrup00] §E.2.)
ȼɫɟ ɩɪɨɱɢɟ ɫɢɬɭɚɰɢɢ ɨɲɢɛɤɚɦɢ ɧɟ ɹɜɥɹɸɬɫɹ, ɢ, ɫɥɟɞɨɜɚɬɟɥɶɧɨ, ɭɜɟɞɨɦɥɹɬɶ ɨ ɧɢɯ, ɤɚɤ ɨɛ
ɨɲɢɛɤɚɯ, ɧɟ ɬɪɟɛɭɟɬɫɹ (ɫɦ. ɩɪɢɦɟɪɵ ɤ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ).
Ʉɨɞ, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɨɲɢɛɤɭ, ɨɬɜɟɱɚɟɬ ɡɚ ɟɟ ɨɛɧɚɪɭɠɟɧɢɟ ɢ ɭɜɟɞɨɦɥɟɧɢɟ ɨ ɧɟɣ. ȼ ɱɚɫɬ-
ɧɨɫɬɢ, ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɞɨɥɠɟɧ ɨɛɧɚɪɭɠɢɬɶ ɢ ɭɜɟɞɨɦɢɬɶ ɨ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɨɧ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɜɵ-
ɩɨɥɧɢɬɶ ɩɪɟɞɭɫɥɨɜɢɹ ɜɵɡɵɜɚɟɦɨɣ ɮɭɧɤɰɢɢ (ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɟɫɥɢ ɞɥɹ ɜɵɡɵɜɚɟɦɨɣ ɮɭɧɤɰɢɢ ɞɨɤɭ-
ɦɟɧɬɢɪɨɜɚɧɨ ɨɬɫɭɬɫɬɜɢɟ ɩɪɨɜɟɪɨɤ ɫ ɟɟ ɫɬɨɪɨɧɵ; ɬɚɤ, ɧɚɩɪɢɦɟɪ, ɨɩɟɪɚɬɨɪ vector::operator[]
ɧɟ ɨɛɹɡɚɧ ɜɵɩɨɥɧɹɬɶ ɩɪɨɜɟɪɤɭ ɩɨɩɚɞɚɧɢɹ ɚɪɝɭɦɟɧɬɚ ɜ ɤɨɪɪɟɤɬɧɵɣ ɢɧɬɟɪɜɚɥ ɡɧɚɱɟɧɢɣ). Ɉɞɧɚɤɨ ɩɨ-
ɫɤɨɥɶɤɭ ɜɵɡɵɜɚɟɦɚɹ ɮɭɧɤɰɢɹ ɧɟ ɦɨɠɟɬ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɤɨɪɪɟɤɬɧɨɫɬɶ ɪɚɛɨɬɵ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ,
ɠɟɥɚɬɟɥɶɧɨ, ɱɬɨɛɵ ɨɧɚ ɜɵɩɨɥɧɹɥɚ ɫɨɛɫɬɜɟɧɧɵɟ ɩɪɨɜɟɪɤɢ ɩɪɟɞɭɫɥɨɜɢɣ ɢ ɭɜɟɞɨɦɥɹɥɚ ɨɛ ɨɛɧɚɪɭ-
ɠɟɧɧɵɯ ɧɚɪɭɲɟɧɢɹɯ, ɝɟɧɟɪɢɪɭɹ ɨɲɢɛɤɭ (ɢɥɢ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɹɜɥɹɟɬɫɹ ɜɧɭɬɪɟɧɧɟɣ ɞɥɹ (ɬ.ɟ. ɜɵɡɵ-
ɜɚɟɦɨɣ ɬɨɥɶɤɨ ɜ ɩɪɟɞɟɥɚɯ) ɦɨɞɭɥɹ, ɬɨ ɧɚɪɭɲɟɧɢɟ ɩɪɟɞɭɫɥɨɜɢɣ ɩɨ ɨɩɪɟɞɟɥɟɧɢɸ ɹɜɥɹɟɬɫɹ ɩɪɨ-
ɝɪɚɦɦɧɨɣ ɨɲɢɛɤɨɣ ɢ ɞɨɥɠɧɨ ɨɛɪɚɛɚɬɵɜɚɬɶɫɹ ɩɪɢ ɩɨɦɨɳɢ assert (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68)).
Ⱦɨɛɚɜɢɦ ɩɚɪɭ ɫɥɨɜ ɨɛ ɨɩɪɟɞɟɥɟɧɢɢ ɩɪɟɞɭɫɥɨɜɢɣ ɮɭɧɤɰɢɣ. ɍɫɥɨɜɢɟ ɹɜɥɹɟɬɫɹ ɩɪɟɞɭɫɥɨɜɢ-
ɟɦ ɮɭɧɤɰɢɢ f ɬɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɢɦɟɸɬɫɹ ɨɫɧɨɜɚɧɢɹ ɨɠɢɞɚɬɶ, ɱɬɨ ɜɟɫɶ ɜɵɡɵɜɚɸɳɢɣ
ɤɨɞ ɩɪɨɜɟɪɹɟɬ ɜɵɩɨɥɧɟɧɢɟ ɞɚɧɧɨɝɨ ɭɫɥɨɜɢɹ ɩɟɪɟɞ ɜɵɡɨɜɨɦ ɮɭɧɤɰɢɢ f. ɇɚɩɪɢɦɟɪ, ɛɵɥɨ ɛɵ
ɧɟɜɟɪɧɨ ɩɨɥɚɝɚɬɶ ɩɪɟɞɭɫɥɨɜɢɟɦ ɧɟɱɬɨ, ɱɬɨ ɦɨɠɟɬ ɛɵɬɶ ɩɪɨɜɟɪɟɧɨ ɬɨɥɶɤɨ ɩɭɬɟɦ ɜɵɩɨɥɧɟɧɢɹ
ɫɭɳɟɫɬɜɟɧɧɨɣ ɪɚɛɨɬɵ ɫɚɦɨɣ ɮɭɧɤɰɢɟɣ, ɥɢɛɨ ɩɭɬɟɦ ɞɨɫɬɭɩɚ ɤ ɡɚɤɪɵɬɨɣ ɢɧɮɨɪɦɚɰɢɢ. Ɍɚɤɚɹ
ɪɚɛɨɬɚ ɞɨɥɠɧɚ ɜɵɩɨɥɧɹɬɶɫɹ ɜ ɮɭɧɤɰɢɢ ɢ ɧɟ ɞɭɛɥɢɪɨɜɚɬɶɫɹ ɜɵɡɵɜɚɸɳɢɦ ɟɟ ɤɨɞɨɦ.
ɇɚɩɪɢɦɟɪ, ɮɭɧɤɰɢɹ, ɤɨɬɨɪɚɹ ɩɨɥɭɱɚɟɬ ɨɛɴɟɤɬ string, ɫɨɞɟɪɠɚɳɢɣ ɢɦɹ ɮɚɣɥɚ, ɨɛɵɱɧɨ ɧɟ
ɞɨɥɠɧɚ ɞɟɥɚɬɶ ɭɫɥɨɜɢɟ ɫɭɳɟɫɬɜɨɜɚɧɢɹ ɮɚɣɥɚ ɩɪɟɞɭɫɥɨɜɢɟɦ, ɩɨɫɤɨɥɶɤɭ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɧɟ ɜ
ɫɨɫɬɨɹɧɢɢ ɧɚɞɟɠɧɨ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɞɚɧɧɵɣ ɮɚɣɥ ɫɭɳɟɫɬɜɭɟɬ, ɧɟ ɢɫɩɨɥɶɡɭɹ ɛɥɨɤɢɪɨɜɤɢ ɮɚɣ-
ɥɚ (ɩɪɢ ɩɪɨɜɟɪɤɟ ɫɭɳɟɫɬɜɨɜɚɧɢɹ ɮɚɣɥɚ ɛɟɡ ɛɥɨɤɢɪɨɜɤɢ ɞɪɭɝɨɣ ɩɨɥɶɡɨɜɚɬɟɥɶ ɢɥɢ ɩɪɨɰɟɫɫ ɦɨɝɭɬ
ɭɞɚɥɢɬɶ ɢɥɢ ɩɟɪɟɢɦɟɧɨɜɚɬɶ ɷɬɨɬ ɮɚɣɥ ɜ ɩɪɨɦɟɠɭɬɤɟ ɦɟɠɞɭ ɩɪɨɜɟɪɤɨɣ ɫɭɳɟɫɬɜɨɜɚɧɢɹ ɮɚɣɥɚ ɜɵ-
ɡɵɜɚɸɳɢɦ ɤɨɞɨɦ ɢ ɩɨɩɵɬɤɨɣ ɨɬɤɪɵɬɢɹ ɜɵɡɵɜɚɟɦɵɦ ɤɨɞɨɦ). ȿɞɢɧɫɬɜɟɧɧɵɣ ɤɨɪɪɟɤɬɧɵɣ ɫɩɨɫɨɛ
ɫɞɟɥɚɬɶ ɫɭɳɟɫɬɜɨɜɚɧɢɟ ɮɚɣɥɚ ɩɪɟɞɭɫɥɨɜɢɟɦ — ɷɬɨ ɩɨɬɪɟɛɨɜɚɬɶ, ɱɬɨɛɵ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɨɬ-
ɤɪɵɥ ɟɝɨ, ɚ ɩɚɪɚɦɟɬɪɨɦ ɮɭɧɤɰɢɢ ɫɞɟɥɚɬɶ ifstream ɢɥɢ ɟɝɨ ɷɤɜɢɜɚɥɟɧɬ (ɱɬɨ ɤ ɬɨɦɭ ɠɟ ɛɟɡɨɩɚɫ-
ɧɟɟ, ɩɨɫɤɨɥɶɤɭ ɪɚɛɨɬɚ ɩɪɢ ɷɬɨɦ ɜɵɩɨɥɧɹɟɬɫɹ ɧɚ ɛɨɥɟɟ ɜɵɫɨɤɨɦ ɭɪɨɜɧɟ ɚɛɫɬɪɚɤɰɢɢ; ɫɦ. ɪɟɤɨɦɟɧ-
ɞɚɰɢɸ 63), ɚ ɧɟ ɩɪɨɫɬɨɟ ɢɦɹ ɮɚɣɥɚ ɜ ɜɢɞɟ ɨɛɴɟɤɬɚ string. Ɇɧɨɝɢɟ ɩɪɟɞɭɫɥɨɜɢɹ ɬɚɤɢɦ ɨɛɪɚɡɨɦ
ɦɨɝɭɬ ɛɵɬɶ ɡɚɦɟɧɟɧɵ ɛɨɥɟɟ ɫɬɪɨɝɢɦ ɬɢɩɢɡɢɪɨɜɚɧɢɟɦ, ɤɨɬɨɪɨɟ ɩɪɟɜɪɚɬɢɬ ɨɲɢɛɤɢ ɜɪɟɦɟɧɢ ɜɵ-
ɩɨɥɧɟɧɢɹ ɜ ɨɲɢɛɤɢ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 14).
Примеры
ɉɪɢɦɟɪ 1. std::string::insert (ɨɲɢɛɤɚ ɩɪɟɞɭɫɥɨɜɢɹ). ɉɪɢ ɩɨɩɵɬɤɟ ɜɫɬɚɜɢɬɶ ɧɨɜɵɣ
ɫɢɦɜɨɥ ɜ ɨɛɴɟɤɬ string ɜ ɨɩɪɟɞɟɥɟɧɧɨɣ ɩɨɡɢɰɢɢ pos, ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɞɨɥɠɟɧ ɩɪɨɜɟɪɢɬɶ
ɤɨɪɪɟɤɬɧɨɫɬɶ ɡɧɚɱɟɧɢɹ pos, ɤɨɬɨɪɨɟ ɧɟ ɞɨɥɠɧɨ ɧɚɪɭɲɚɬɶ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɵɟ ɬɪɟɛɨɜɚɧɢɹ
ɤ ɞɚɧɧɨɦɭ ɩɚɪɚɦɟɬɪɭ; ɧɚɩɪɢɦɟɪ, ɱɬɨɛɵ ɧɟ ɜɵɩɨɥɧɹɥɨɫɶ ɫɨɨɬɧɨɲɟɧɢɟ pos > size(). Ɏɭɧɤ-
ɰɢɹ insert ɧɟ ɦɨɠɟɬ ɭɫɩɟɲɧɨ ɜɵɩɨɥɧɢɬɶ ɫɜɨɸ ɪɚɛɨɬɭ, ɟɫɥɢ ɞɥɹ ɧɟɟ ɧɟ ɛɭɞɭɬ ɫɨɡɞɚɧɵ ɤɨɪ-
ɪɟɤɬɧɵɟ ɧɚɱɚɥɶɧɵɟ ɭɫɥɨɜɢɹ.
ɉɪɢɦɟɪ 2. std::string::append (ɨɲɢɛɤɚ ɩɨɫɬɭɫɥɨɜɢɹ). ɉɪɢ ɞɨɛɚɜɥɟɧɢɢ ɫɢɦɜɨɥɚ
ɤ ɨɛɴɟɤɬɭ string ɫɛɨɣ ɩɪɢ ɜɵɞɟɥɟɧɢɢ ɧɨɜɨɝɨ ɛɭɮɟɪɚ, ɟɫɥɢ ɡɚɩɨɥɧɟɧ ɫɭɳɟɫɬɜɭɸɳɢɣ, ɧɟ ɩɨ-
ɡɜɨɥɢɬ ɮɭɧɤɰɢɢ ɜɵɩɨɥɧɢɬɶ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɵɟ ɞɟɣɫɬɜɢɹ ɢ ɩɨɥɭɱɢɬɶ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɵɟ ɠɟ
ɩɨɫɬɭɫɥɨɜɢɹ, ɬɚɤ ɱɬɨ ɬɚɤɨɣ ɫɛɨɣ ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ.
70. Отличайте ошибки от ситуаций, не являющихся ошибками 149
Стр. 149
ɉɪɢɦɟɪ 3. ɇɟɜɨɡɦɨɠɧɨɫɬɶ ɩɨɥɭɱɟɧɢɹ ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɡɧɚɱɟɧɢɹ (ɨɲɢɛɤɚ ɩɨɫɬɭɫɥɨɜɢɹ).
ɉɨɥɭɱɟɧɢɟ ɤɨɪɪɟɤɬɧɨɝɨ ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɨɛɴɟɤɬɚ ɹɜɥɹɟɬɫɹ ɩɨɫɬɭɫɥɨɜɢɟɦ ɞɥɹ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɚɹ
ɜɨɡɜɪɚɳɚɟɬ ɡɧɚɱɟɧɢɟ. ȿɫɥɢ ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ ɧɟ ɦɨɠɟɬ ɛɵɬɶ ɤɨɪɪɟɤɬɧɨ ɫɨɡɞɚɧɨ
(ɧɚɩɪɢɦɟɪ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ double, ɧɨ ɡɧɚɱɟɧɢɟ double ɫ ɬɪɟɛɭɟɦɵɦɢ ɦɚɬɟɦɚɬɢ-
ɱɟɫɤɢɦɢ ɫɜɨɣɫɬɜɚɦɢ ɧɟ ɫɭɳɟɫɬɜɭɟɬ), ɬɨ ɷɬɨ ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ.
ɉɪɢɦɟɪ 4. std::string::find_first_of (ɧɟ ɨɲɢɛɤɚ ɜ ɤɨɧɬɟɤɫɬɟ string). ɉɪɢ ɩɨ-
ɢɫɤɟ ɫɢɦɜɨɥɚ ɜ ɨɛɴɟɤɬɟ string, ɧɟɜɨɡɦɨɠɧɨɫɬɶ ɧɚɣɬɢ ɢɫɤɨɦɵɣ ɫɢɦɜɨɥ — ɜɩɨɥɧɟ ɡɚɤɨɧɧɵɣ
ɢɬɨɝ ɩɨɢɫɤɚ, ɨɲɢɛɤɨɣ ɧɟ ɹɜɥɹɸɳɢɣɫɹ. Ʉɚɤ ɦɢɧɢɦɭɦ, ɷɬɨ ɧɟ ɨɲɢɛɤɚ ɩɪɢ ɪɚɛɨɬɟ ɫ ɤɥɚɫɫɨɦ
string ɨɛɳɟɝɨ ɧɚɡɧɚɱɟɧɢɹ. ȿɫɥɢ ɜɥɚɞɟɥɟɰ ɞɚɧɧɨɣ ɫɬɪɨɤɢ ɩɪɟɞɩɨɥɚɝɚɟɬ, ɱɬɨ ɫɢɦɜɨɥ ɞɨɥɠɟɧ
ɧɚɥɢɱɟɫɬɜɨɜɚɬɶ ɜ ɫɬɪɨɤɟ, ɢ ɟɝɨ ɨɬɫɭɬɫɬɜɢɟ, ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ
ɫ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɦ ɢɧɜɚɪɢɚɧɬɨɦ, ɬɨ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɣ ɜɵɡɵɜɚɟɦɵɣ ɤɨɞ ɞɨɥɠɟɧ ɫɨɨɬɜɟɬɫɬ-
ɜɭɸɳɢɦ ɨɛɪɚɡɨɦ ɭɜɟɞɨɦɢɬɶ ɨɛ ɨɲɢɛɤɟ ɢɧɜɚɪɢɚɧɬɚ.
ɉɪɢɦɟɪ 5. Ɋɚɡɥɢɱɧɵɟ ɭɫɥɨɜɢɹ ɨɲɢɛɨɤ ɜ ɨɞɧɨɣ ɮɭɧɤɰɢɢ. ɇɟɫɦɨɬɪɹ ɧɚ ɭɜɟɥɢɱɢɜɚɸɳɭɸɫɹ ɧɚ-
ɞɟɠɧɨɫɬɶ ɞɢɫɤɨɜɵɯ ɧɨɫɢɬɟɥɟɣ, ɡɚɩɢɫɶ ɧɚ ɞɢɫɤ ɬɪɚɞɢɰɢɨɧɧɨ ɫɨɩɪɨɜɨɠɞɚɟɬɫɹ ɨɠɢɞɚɧɢɟɦ ɨɲɢ-
ɛɨɤ. ȿɫɥɢ ɜɵ ɪɚɡɪɚɛɚɬɵɜɚɟɬɟ ɤɥɚɫɫ File, ɜ ɨɞɧɨɣ-ɟɞɢɧɫɬɜɟɧɧɨɣ ɮɭɧɤɰɢɢ File::Write(const
char*buffer, size_t size), ɤɨɬɨɪɚɹ ɬɪɟɛɭɟɬ, ɱɬɨɛɵ ɮɚɣɥ ɛɵɥ ɨɬɤɪɵɬ ɞɥɹ ɡɚɩɢɫɢ, ɚ ɭɤɚɡɚ-
ɬɟɥɶ buffer ɢɦɟɥ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɜɵ ɦɨɠɟɬɟ ɩɪɟɞɩɪɢɧɢɦɚɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
• ȿɫɥɢ buffer ɪɚɜɟɧ NULL: ɫɨɨɛɳɢɬɶ ɨɛ ɨɲɢɛɤɟ ɧɚɪɭɲɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɹ.
• ȿɫɥɢ ɮɚɣɥ ɨɬɤɪɵɬ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ: ɫɨɨɛɳɢɬɶ ɨɛ ɨɲɢɛɤɟ ɧɚɪɭɲɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɹ.
• ȿɫɥɢ ɡɚɩɢɫɶ ɜɵɩɨɥɧɟɧɚ ɧɟɭɫɩɟɲɧɨ: ɫɨɨɛɳɢɬɶ ɨɛ ɨɲɢɛɤɟ ɧɚɪɭɲɟɧɢɹ ɩɨɫɬɭɫɥɨɜɢɹ, ɩɨ-
ɫɤɨɥɶɤɭ ɮɭɧɤɰɢɹ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɜɵɩɨɥɧɢɬɶ ɫɜɨɸ ɪɚɛɨɬɭ.
ɉɪɢɦɟɪ 6. Ɋɚɡɥɢɱɧɵɣ ɫɬɚɬɭɫ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɭɫɥɨɜɢɹ. Ɉɞɧɨ ɢ ɬɨ ɠɟ ɭɫɥɨɜɢɟ ɦɨɠɟɬ
ɛɵɬɶ ɤɨɪɪɟɤɬɧɵɦ ɩɪɟɞɭɫɥɨɜɢɟɦ ɞɥɹ ɨɞɧɨɣ ɮɭɧɤɰɢɢ ɢ ɧɟ ɛɵɬɶ ɬɚɤɨɜɵɦ ɞɥɹ ɞɪɭɝɨɣ. ȼɵɛɨɪ ɡɚ-
ɜɢɫɢɬ ɨɬ ɚɜɬɨɪɚ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɣ ɨɩɪɟɞɟɥɹɟɬ ɫɟɦɚɧɬɢɤɭ ɢɧɬɟɪɮɟɣɫɚ. ȼ ɱɚɫɬɧɨɫɬɢ,
std::vector ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɞɜɚ ɩɭɬɢ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɢɧɞɟɤɫɢɪɨɜɚɧɧɨɝɨ ɞɨɫɬɭɩɚ: ɨɩɟɪɚɬɨɪ
operator[], ɤɨɬɨɪɵɣ ɧɟ ɜɵɩɨɥɧɹɟɬ ɩɪɨɜɟɪɨɤ ɜɵɯɨɞɚ ɡɚ ɩɪɟɞɟɥɵ ɞɢɚɩɚɡɨɧɚ, ɢ ɮɭɧɤɰɢɸ at,
ɤɨɬɨɪɚɹ ɬɚɤɭɸ ɩɪɨɜɟɪɤɭ ɜɵɩɨɥɧɹɟɬ. ɂ ɨɩɟɪɚɬɨɪ operator[], ɢ ɮɭɧɤɰɢɹ at ɬɪɟɛɭɸɬ ɜɵɩɨɥ-
ɧɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɹ, ɫɨɫɬɨɹɳɟɝɨ ɜ ɬɨɦ, ɱɬɨ ɚɪɝɭɦɟɧɬ ɧɟ ɞɨɥɠɟɧ ɜɵɯɨɞɢɬɶ ɡɚ ɩɪɟɞɟɥɵ ɞɢɚɩɚɡɨ-
ɧɚ. ɉɨɫɤɨɥɶɤɭ ɨɬ ɨɩɟɪɚɬɨɪɚ operator[] ɧɟ ɬɪɟɛɭɟɬɫɹ ɩɪɨɜɟɪɤɚ ɟɝɨ ɚɪɝɭɦɟɧɬɚ, ɞɨɥɠɧɨ ɛɵɬɶ
ɱɟɬɤɨ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɨ, ɱɬɨ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɡɚ ɬɨ, ɱɬɨɛɵ ɚɪɝɭɦɟɧɬ ɨɩɟɪɚɬɨɪɚ ɧɚ-
ɯɨɞɢɥɫɹ ɜ ɞɨɩɭɫɬɢɦɨɦ ɞɢɚɩɚɡɨɧɟ ɡɧɚɱɟɧɢɣ; ɩɨɧɹɬɧɨ, ɱɬɨ ɞɚɧɧɚɹ ɮɭɧɤɰɢɹ ɧɟɛɟɡɨɩɚɫɧɚ. Ɏɭɧɤ-
ɰɢɹ ɠɟ at ɜ ɬɨɣ ɠɟ ɫɢɬɭɚɰɢɢ ɜɩɨɥɧɟ ɛɟɡɨɩɚɫɧɚ, ɩɨɫɤɨɥɶɤɭ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɨ, ɱɬɨ ɨɧɚ ɩɪɨɜɟ-
ɪɹɟɬ ɩɪɢɧɚɞɥɟɠɧɨɫɬɶ ɫɜɨɟɝɨ ɚɪɝɭɦɟɧɬɚ ɤ ɞɨɩɭɫɬɢɦɨɦɭ ɞɢɚɩɚɡɨɧɭ ɡɧɚɱɟɧɢɣ, ɢ ɟɫɥɢ ɚɪɝɭɦɟɧɬ
ɜɵɯɨɞɢɬ ɡɚ ɩɪɟɞɟɥɵ ɞɨɩɭɫɬɢɦɨɝɨ ɞɢɚɩɚɡɨɧɚ ɡɧɚɱɟɧɢɣ, ɬɨ ɨɧɚ ɫɨɨɛɳɚɟɬ ɨɛ ɨɲɢɛɤɟ (ɩɭɬɟɦ ɝɟ-
ɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɹ std::out_of_range).
Ссылки
[Abrahams01b] • [Meyer00] • [Stroustrup00] §8.3.3, §14.1, §14.5 • [Sutter04b]
Стр. 150
71. Проектируйте и пишите безопасный
в отношении ошибок код
Резюме
ȼ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ ɨɛɟɫɩɟɱɢɜɚɣɬɟ ɧɚɢɛɨɥɟɟ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɛɟɡɨɩɚɫɧɨɫɬɢ, ɤɚɤɨɣ ɬɨɥɶɤɨ
ɦɨɠɧɨ ɞɨɛɢɬɶɫɹ ɛɟɡ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɡɚɬɪɚɬ ɫɨ ɫɬɨɪɨɧɵ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ, ɧɟ ɬɪɟɛɭɸɳɟɝɨ ɬɚ-
ɤɨɝɨ ɭɪɨɜɧɹ ɝɚɪɚɧɬɢɢ. ȼɫɟɝɞɚ ɨɛɟɫɩɟɱɢɜɚɣɬɟ, ɤɚɤ ɦɢɧɢɦɭɦ, ɛɚɡɨɜɭɸ ɝɚɪɚɧɬɢɸ ɛɟɡɨɩɚɫɧɨɫɬɢ.
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɩɪɢ ɥɸɛɵɯ ɨɲɢɛɤɚɯ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɜɫɟɝɞɚ ɨɫɬɚɟɬɫɹ ɜ ɤɨɪɪɟɤɬɧɨɦ ɫɨ-
ɫɬɨɹɧɢɢ (ɜ ɷɬɨɦ ɢ ɡɚɤɥɸɱɚɟɬɫɹ ɛɚɡɨɜɚɹ ɝɚɪɚɧɬɢɹ). Ɉɫɬɟɪɟɝɚɣɬɟɫɶ ɨɲɢɛɨɤ, ɧɚɪɭɲɚɸɳɢɯ ɢɧɜɚ-
ɪɢɚɧɬ (ɜɤɥɸɱɚɹ ɭɬɟɱɤɢ, ɧɨ ɧɟ ɨɝɪɚɧɢɱɢɜɚɹɫɶ ɢɦɢ).
ɀɟɥɚɬɟɥɶɧɨ ɞɨɩɨɥɧɢɬɟɥɶɧɨ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɤɨɧɟɱɧɨɟ ɫɨɫɬɨɹɧɢɟ ɥɢɛɨ ɹɜɥɹɟɬɫɹ ɢɫɯɨɞ-
ɧɵɦ ɫɨɫɬɨɹɧɢɟɦ (ɜ ɪɟɡɭɥɶɬɚɬɟ ɨɬɤɚɬɚ ɩɨɫɥɟ ɩɪɨɢɫɲɟɞɲɟɣ ɨɲɢɛɤɢ), ɥɢɛɨ ɤɨɪɪɟɤɬɧɨ ɜɵɱɢɫ-
ɥɟɧɧɵɦ ɰɟɥɟɜɵɦ ɫɨɫɬɨɹɧɢɟɦ (ɟɫɥɢ ɨɲɢɛɨɤ ɧɟ ɛɵɥɨ). ɗɬɨ — ɫɬɪɨɝɚɹ ɝɚɪɚɧɬɢɹ ɛɟɡɨɩɚɫɧɨɫɬɢ.
ȿɳɟ ɥɭɱɲɟ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɫɛɨɣ ɜ ɩɪɨɰɟɫɫɟ ɨɩɟɪɚɰɢɢ ɧɟɜɨɡɦɨɠɟɧ. ɏɨɬɹ ɞɥɹ ɛɨɥɶɲɢɧ-
ɫɬɜɚ ɮɭɧɤɰɢɣ ɷɬɨ ɧɟɜɨɡɦɨɠɧɨ, ɬɚɤɭɸ ɝɚɪɚɧɬɢɸ ɫɥɟɞɭɟɬ ɨɛɟɫɩɟɱɢɬɶ ɞɥɹ ɬɚɤɢɯ ɮɭɧɤɰɢɣ, ɤɚɤ
ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ. Ⱦɚɧɧɚɹ ɝɚɪɚɧɬɢɹ — ɝɚɪɚɧɬɢɹ ɛɟɫɫɛɨɣɧɨɫɬɢ.
Ȼɚɡɨɜɚɹ, ɫɬɪɨɝɚɹ ɝɚɪɚɧɬɢɢ ɢ ɝɚɪɚɧɬɢɹ ɛɟɫɫɛɨɣɧɨɫɬɢ (ɢɡɜɟɫɬɧɚɹ ɬɚɤɠɟ ɤɚɤ ɝɚɪɚɧɬɢɹ ɨɬɫɭɬ-
ɫɬɜɢɹ ɢɫɤɥɸɱɟɧɢɣ) ɜɩɟɪɜɵɟ ɛɵɥɢ ɨɩɢɫɚɧɵ ɜ [Abrahams96] ɢ ɩɨɥɭɱɢɥɢ ɲɢɪɨɤɭɸ ɢɡɜɟɫɬɧɨɫɬɶ
ɛɥɚɝɨɞɚɪɹ ɩɭɛɥɢɤɚɰɢɹɦ [GotW], [Stroustrup00, §E.2] ɢ [Sutter00], ɩɨɫɜɹɳɟɧɧɵɦ ɜɨɩɪɨɫɚɦ
ɛɟɡɨɩɚɫɧɨɫɬɢ ɢɫɤɥɸɱɟɧɢɣ. ɗɬɢ ɝɚɪɚɧɬɢɢ ɩɪɢɦɟɧɢɦɵ ɤ ɨɛɪɚɛɨɬɤɟ ɥɸɛɵɯ ɨɲɢɛɨɤ, ɧɟɡɚɜɢɫɢɦɨ
ɨɬ ɤɨɧɤɪɟɬɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɧɨɝɨ ɦɟɬɨɞɚ, ɬɚɤ ɱɬɨ ɦɵ ɦɨɠɟɦ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɦɢ ɩɪɢ ɨɩɢɫɚ-
ɧɢɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ. Ƚɚɪɚɧɬɢɹ ɛɟɫɫɛɨɣɧɨɫɬɢ ɹɜɥɹɟɬɫɹ ɫɬɪɨ-
ɝɢɦ ɩɨɞɦɧɨɠɟɫɬɜɨɦ ɫɬɪɨɝɨɣ ɝɚɪɚɧɬɢɢ, ɚ ɫɬɪɨɝɚɹ ɝɚɪɚɧɬɢɹ, ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ, ɹɜɥɹɟɬɫɹ ɫɬɪɨɝɢɦ
ɩɨɞɦɧɨɠɟɫɬɜɨɦ ɛɚɡɨɜɨɣ ɝɚɪɚɧɬɢɢ.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɤɚɠɞɚɹ ɮɭɧɤɰɢɹ ɞɨɥɠɧɚ ɨɛɟɫɩɟɱɢɜɚɬɶ ɧɚɢɛɨɥɟɟ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ, ɤɨɬɨɪɭɸ
ɨɧɚ ɜ ɫɨɫɬɨɹɧɢɢ ɨɛɟɫɩɟɱɢɬɶ ɛɟɡ ɢɡɥɢɲɧɢɯ ɡɚɬɪɚɬ ɞɥɹ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ, ɤɨɬɨɪɨɦɭ ɧɟ ɬɪɟɛɭɟɬɫɹ
ɬɚɤɚɹ ɫɬɟɩɟɧɶ ɝɚɪɚɧɬɢɢ. Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɫɥɟɞɭɟɬ ɞɨɩɨɥɧɢɬɟɥɶɧɨ ɨɛɟɫɩɟɱɢɬɶ ɞɨɫɬɚɬɨɱɧɭɸ
ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɬɪɟɛɭɸɳɢɣ ɛɨɥɟɟ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɤɨɞ ɦɨɝ ɩɨɥɭɱɢɬɶ ɟɟ
(ɫɦ. ɜ ɩɪɢɦɟɪɚɯ ɤ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɫɥɭɱɚɣ vector::insert).
ȼ ɢɞɟɚɥɟ ɫɥɟɞɭɟɬ ɩɢɫɚɬɶ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɜɫɟɝɞɚ ɭɫɩɟɲɧɨ ɜɵɩɨɥɧɹɸɬɫɹ ɢ, ɬɚɤɢɦ ɨɛɪɚ-
ɡɨɦ, ɦɨɝɭɬ ɨɛɟɫɩɟɱɢɬɶ ɝɚɪɚɧɬɢɸ ɛɟɫɫɛɨɣɧɨɫɬɢ. ɇɟɤɨɬɨɪɵɟ ɮɭɧɤɰɢɢ ɞɨɥɠɧɵ ɜɫɟɝɞɚ ɨɛɟɫɩɟ-
ɱɢɜɚɬɶ ɬɚɤɭɸ ɝɚɪɚɧɬɢɸ, ɜ ɱɚɫɬɧɨɫɬɢ, ɞɟɫɬɪɭɤɬɨɪɵ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɢ ɮɭɧɤ-
ɰɢɢ ɨɛɦɟɧɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 51).
Ɉɞɧɚɤɨ ɜ ɛɨɥɶɲɢɧɫɬɜɟ ɮɭɧɤɰɢɣ ɦɨɝɭɬ ɩɪɨɢɡɨɣɬɢ ɫɛɨɢ. ȿɫɥɢ ɨɲɢɛɤɚ ɜɨɡɦɨɠɧɚ, ɧɚɢɛɨɥɟɟ
ɛɟɡɨɩɚɫɧɵɦ ɛɭɞɟɬ ɝɚɪɚɧɬɢɪɨɜɚɬɶ ɬɪɚɧɡɚɤɰɢɨɧɧɨɟ ɩɨɜɟɞɟɧɢɟ ɮɭɧɤɰɢɢ: ɥɢɛɨ ɮɭɧɤɰɢɹ ɜɵɩɨɥ-
ɧɹɟɬɫɹ ɭɫɩɟɲɧɨ ɢ ɩɪɨɝɪɚɦɦɚ ɩɟɪɟɯɨɞɢɬ ɢɡ ɧɚɱɚɥɶɧɨɝɨ ɤɨɪɪɟɤɬɧɨɝɨ ɫɨɫɬɨɹɧɢɹ ɜ ɤɨɪɪɟɤɬɧɨɟ
ɰɟɥɟɜɨɟ ɫɨɫɬɨɹɧɢɟ, ɥɢɛɨ — ɜ ɫɥɭɱɚɟ ɫɛɨɹ — ɩɪɨɝɪɚɦɦɚ ɨɫɬɚɟɬɫɹ ɜ ɬɨɦ ɠɟ ɫɨɫɬɨɹɧɢɢ, ɜ ɤɨɬɨ-
ɪɨɦ ɧɚɯɨɞɢɥɚɫɶ ɩɟɪɟɞ ɜɵɡɨɜɨɦ ɮɭɧɤɰɢɢ, ɬ.ɟ. ɜɢɞɢɦɵɟ ɫɨɫɬɨɹɧɢɹ ɜɫɟɯ ɨɛɴɟɤɬɨɜ ɩɨɫɥɟ ɫɛɨɣ-
ɧɨɝɨ ɜɵɡɨɜɚ ɨɤɚɡɵɜɚɸɬɫɹ ɬɟɦɢ ɠɟ, ɱɬɨ ɢ ɞɨ ɧɟɝɨ (ɧɚɩɪɢɦɟɪ, ɡɧɚɱɟɧɢɟ ɝɥɨɛɚɥɶɧɨɣ ɰɟɥɨɣ ɩɟ-
ɪɟɦɟɧɧɨɣ ɧɟ ɦɨɠɟɬ ɢɡɦɟɧɢɬɶɫɹ ɫ 42 ɧɚ 43), ɢ ɥɸɛɨɟ ɞɟɣɫɬɜɢɟ, ɤɨɬɨɪɨɟ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɦɨɝ
ɩɪɟɞɩɪɢɧɹɬɶ ɞɨ ɫɛɨɣɧɨɝɨ ɜɵɡɨɜɚ, ɞɨɥɠɧɨ ɨɫɬɚɬɶɫɹ ɜɨɡɦɨɠɧɵɦ (ɫ ɬɟɦ ɠɟ ɫɦɵɫɥɨɦ) ɢ ɩɨɫɥɟ
ɫɛɨɣɧɨɝɨ ɜɵɡɨɜɚ (ɧɚɩɪɢɦɟɪ, ɧɢ ɨɞɢɧ ɢɬɟɪɚɬɨɪ ɤɨɧɬɟɣɧɟɪɚ ɧɟ ɞɨɥɠɟɧ ɫɬɚɬɶ ɧɟɞɟɣɫɬɜɢɬɟɥɶ-
ɧɵɦ; ɩɪɢɦɟɧɟɧɢɟ ɨɩɟɪɚɬɨɪɚ ++ ɤ ɭɩɨɦɹɧɭɬɨɣ ɝɥɨɛɚɥɶɧɨɣ ɰɟɥɨɣ ɩɟɪɟɦɟɧɧɨɣ ɞɚɫɬ ɡɧɚɱɟɧɢɟ
43, ɚ ɧɟ 44). Ɍɚɤɚɹ ɝɚɪɚɧɬɢɹ ɛɟɡɨɩɚɫɧɨɫɬɢ ɧɚɡɵɜɚɟɬɫɹ ɫɬɪɨɝɨɣ.
71. Проектируйте и пишите безопасный в отношении ошибок код 151
Стр. 151
ɇɚɤɨɧɟɰ, ɟɫɥɢ ɨɛɟɫɩɟɱɢɬɶ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɨɤɚɡɵɜɚɟɬɫɹ ɫɥɢɲɤɨɦ ɫɥɨɠɧɨ ɢɥɢ ɢɡɥɢɲɧɟ
ɞɨɪɨɝɨ, ɫɥɟɞɭɟɬ ɨɛɟɫɩɟɱɢɬɶ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɛɚɡɨɜɭɸ ɝɚɪɚɧɬɢɸ: ɮɭɧɤɰɢɹ ɥɢɛɨ ɜɵɩɨɥɧɹɟɬɫɹ
ɭɫɩɟɲɧɨ ɢ ɞɨɫɬɢɝɚɟɬ ɰɟɥɟɜɨɝɨ ɫɨɫɬɨɹɧɢɹ, ɥɢɛɨ ɨɧɚ ɧɟɭɫɩɟɲɧɚ ɢ ɨɫɬɚɜɥɹɟɬ ɩɪɨɝɪɚɦɦɭ ɜ ɫɨ-
ɫɬɨɹɧɢɢ ɤɨɪɪɟɤɬɧɨɦ (ɫɨɯɪɚɧɹɹ ɢɧɜɚɪɢɚɧɬɵ, ɡɚ ɤɨɬɨɪɵɟ ɨɬɜɟɱɚɟɬ ɞɚɧɧɚɹ ɮɭɧɤɰɢɹ), ɧɨ ɧɟ
ɩɪɟɞɫɤɚɡɭɟɦɨɦ (ɷɬɨ ɦɨɠɟɬ ɛɵɬɶ ɢɫɯɨɞɧɨɟ ɫɨɫɬɨɹɧɢɟ, ɧɨ ɦɨɠɟɬ ɢ ɧɟ ɛɵɬɶ ɬɚɤɨɜɵɦ; ɧɟɤɨɬɨɪɵɟ
ɢɡ ɩɨɫɬɭɫɥɨɜɢɣ ɦɨɝɭɬ ɛɵɬɶ ɧɟ ɜɵɩɨɥɧɟɧɵ; ɨɞɧɚɤɨ ɜɫɟ ɢɧɜɚɪɢɚɧɬɵ ɞɨɥɠɧɵ ɛɵɬɶ ɜɨɫɫɬɚɧɨɜɥɟ-
ɧɵ). ȼɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɞɨɥɠɧɨ ɛɵɬɶ ɫɩɪɨɟɤɬɢɪɨɜɚɧɨ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ ɫɭɦɟɬɶ ɫɨɨɬɜɟɬ-
ɫɬɜɭɸɳɢɦ ɨɛɪɚɡɨɦ ɨɛɪɚɛɨɬɚɬɶ ɬɚɤɨɣ ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɮɭɧɤɰɢɢ.
ȼɨɬ ɢ ɜɫɟ; ɛɨɥɟɟ ɧɢɡɤɨɝɨ ɭɪɨɜɧɹ ɝɚɪɚɧɬɢɢ ɧɟ ɫɭɳɟɫɬɜɭɟɬ. Ɏɭɧɤɰɢɹ, ɤɨɬɨɪɚɹ ɧɟ ɞɚɟɬ ɞɚɠɟ ɛɚ-
ɡɨɜɨɣ ɝɚɪɚɧɬɢɢ — ɷɬɨ ɩɪɨɫɬɨ ɨɲɢɛɤɚ ɩɪɨɝɪɚɦɦɢɫɬɚ. Ʉɨɪɪɟɤɬɧɚɹ ɩɪɨɝɪɚɦɦɚ ɞɨɥɠɧɚ ɨɬɜɟɱɚɬɶ,
ɤɚɤ ɦɢɧɢɦɭɦ, ɛɚɡɨɜɨɣ ɝɚɪɚɧɬɢɢ ɞɥɹ ɜɫɟɯ ɮɭɧɤɰɢɣ. Ⱦɚɠɟ ɬɟ ɧɟɦɧɨɝɢɟ ɤɨɪɪɟɤɬɧɵɟ ɩɪɨɝɪɚɦɦɵ,
ɤɨɬɨɪɵɟ ɫɨɡɧɚɬɟɥɶɧɨ ɢɞɭɬ ɧɚ ɭɬɟɱɤɭ ɪɟɫɭɪɫɨɜ, ɜ ɱɚɫɬɧɨɫɬɢ, ɜ ɫɢɬɭɚɰɢɹɯ, ɤɨɝɞɚ ɩɪɨɝɪɚɦɦɚ ɚɜɚ-
ɪɢɣɧɨ ɡɚɜɟɪɲɚɟɬɫɹ, ɩɨɫɬɭɩɚɸɬ ɬɚɤ ɫ ɭɱɟɬɨɦ ɬɨɝɨ, ɱɬɨ ɪɟɫɭɪɫɵ ɛɭɞɭɬ ɨɫɜɨɛɨɠɞɟɧɵ ɨɩɟɪɚɰɢɨɧ-
ɧɨɣ ɫɢɫɬɟɦɨɣ. ȼɫɟɝɞɚ ɪɚɡɪɚɛɚɬɵɜɚɣɬɟ ɤɨɞ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ ɤɨɪɪɟɤɬɧɨ ɨɫɜɨɛɨɠɞɚɥɢɫɶ ɜɫɟ
ɪɟɫɭɪɫɵ, ɚ ɞɚɧɧɵɟ ɧɚɯɨɞɢɥɢɫɶ ɜ ɫɨɝɥɚɫɨɜɚɧɧɨɦ ɫɨɫɬɨɹɧɢɢ ɞɚɠɟ ɩɪɢ ɧɚɥɢɱɢɢ ɨɲɢɛɨɤ, ɟɫɥɢ
ɬɨɥɶɤɨ ɨɲɢɛɤɚ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɧɟɦɟɞɥɟɧɧɨɦɭ ɚɜɚɪɢɣɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ ɩɪɨɝɪɚɦɦɵ.
ɉɪɢ ɩɪɢɧɹɬɢɢ ɪɟɲɟɧɢɹ ɨ ɬɨɦ, ɤɚɤɨɣ ɭɪɨɜɟɧɶ ɝɚɪɚɧɬɢɢ ɫɥɟɞɭɟɬ ɩɨɞɞɟɪɠɢɜɚɬɶ, ɧɚɞɨ ɧɟ ɡɚ-
ɛɵɜɚɬɶ ɨ ɩɟɪɫɩɟɤɬɢɜɟ ɪɚɡɜɢɬɢɹ ɩɪɨɟɤɬɚ. ȼɫɟɝɞɚ ɩɪɨɳɟ ɭɫɢɥɢɬɶ ɝɚɪɚɧɬɢɸ ɜ ɩɨɫɥɟɞɭɸɳɢɯ ɜɟɪ-
ɫɢɹɯ, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɫɧɢɠɟɧɢɟ ɫɬɟɩɟɧɢ ɝɚɪɚɧɬɢɢ ɜɟɞɟɬ ɤ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɩɟɪɟɞɟɥɤɢ ɜɵɡɵɜɚɸ-
ɳɟɝɨ ɤɨɞɚ, ɩɨɥɚɝɚɸɳɟɝɨɫɹ ɧɚ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɮɭɧɤɰɢɟɣ ɛɨɥɟɟ ɫɬɪɨɝɨɣ ɝɚɪɚɧɬɢɢ.
ɉɨɦɧɢɬɟ, ɱɬɨ “ɧɟɛɟɡɨɩɚɫɧɨɫɬɶ ɜ ɨɬɧɨɲɟɧɢɢ ɨɲɢɛɨɤ” ɢ “ɩɥɨɯɨɟ ɩɪɨɟɤɬɢɪɨɜɚɧɢɟ” ɢɞɭɬ ɪɭ-
ɤɚ ɨɛ ɪɭɤɭ: ɟɫɥɢ ɧɟɤɨɬɨɪɭɸ ɱɚɫɬɶ ɤɨɞɚ ɫɥɨɠɧɨ ɫɞɟɥɚɬɶ ɨɛɟɫɩɟɱɢɜɚɸɳɟɣ ɛɚɡɨɜɭɸ ɝɚɪɚɧɬɢɸ,
ɬɨ ɩɨɱɬɢ ɜɫɟɝɞɚ ɷɬɨ ɝɨɜɨɪɢɬ ɨ ɩɥɨɯɨɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɨɬɜɟɱɚɟɬ ɡɚ
ɜɵɩɨɥɧɟɧɢɟ ɧɟɫɤɨɥɶɤɢɯ ɧɟɫɜɹɡɚɧɧɵɯ ɡɚɞɚɱ, ɟɟ ɬɪɭɞɧɨ ɫɞɟɥɚɬɶ ɛɟɡɨɩɚɫɧɨɣ ɜ ɨɬɧɨɲɟɧɢɢ ɨɲɢ-
ɛɨɤ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5).
Ɉɫɬɟɪɟɝɚɣɬɟɫɶ ɨɩɟɪɚɬɨɪɚ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɤɨɬɨɪɨɦɭ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ
ɬɪɟɛɭɟɬɫɹ ɩɪɨɜɟɪɤɚ, ɧɟ ɜɵɩɨɥɧɹɟɬɫɹ ɥɢ ɩɪɢɫɜɚɢɜɚɧɢɟ ɨɛɴɟɤɬɚ ɫɚɦɨɦɭ ɫɟɛɟ. Ȼɟɡɨɩɚɫɧɵɣ ɜ ɨɬ-
ɧɨɲɟɧɢɢ ɨɲɢɛɨɤ ɨɩɟɪɚɬɨɪ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɛɟɡɨɩɚɫɟɧ ɢ ɜ ɩɥɚɧɟ
ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ. ɂɫɩɨɥɶɡɨɜɚɬɶ ɩɪɨɜɟɪɤɭ ɩɪɢɫɜɚɢɜɚɧɢɹ ɫɚɦɨɦɭ ɫɟɛɟ ɦɨɠɧɨ ɬɨɥɶɤɨ
ɜ ɤɚɱɟɫɬɜɟ ɨɩɬɢɦɢɡɚɰɢɢ, ɞɥɹ ɬɨɝɨ ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɢɡɥɢɲɧɟɣ ɪɚɛɨɬɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 55).
Примеры
ɉɪɢɦɟɪ 1. ɉɨɜɬɨɪɧɚɹ ɩɨɩɵɬɤɚ ɩɨɫɥɟ ɫɛɨɹ. ȿɫɥɢ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɜɤɥɸɱɚɟɬ ɤɨɦɚɧɞɭ ɞɥɹ
ɫɨɯɪɚɧɟɧɢɹ ɞɚɧɧɵɯ ɜ ɮɚɣɥ ɢ ɜɨ ɜɪɟɦɹ ɡɚɩɢɫɢ ɩɪɨɢɡɨɲɟɥ ɫɛɨɣ, ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɜɟɪɧɭɥɢɫɶ ɤ
ɫɨɫɬɨɹɧɢɸ, ɤɨɝɞɚ ɨɩɟɪɚɰɢɹ ɦɨɠɟɬ ɛɵɬɶ ɩɨɜɬɨɪɟɧɚ. ȼ ɱɚɫɬɧɨɫɬɢ, ɧɟ ɨɫɜɨɛɨɠɞɚɣɬɟ ɧɢɤɚɤɢɟ
ɫɬɪɭɤɬɭɪɵ ɞɚɧɧɵɯ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɞɚɧɧɵɟ ɧɟ ɛɭɞɭɬ ɩɨɥɧɨɫɬɶɸ ɫɛɪɨɲɟɧɵ ɧɚ ɞɢɫɤ. ɗɬɨ ɧɟ
ɬɟɨɪɟɬɢɡɢɪɨɜɚɧɢɟ — ɧɚɦ ɢɡɜɟɫɬɟɧ ɨɞɢɧ ɬɟɤɫɬɨɜɵɣ ɪɟɞɚɤɬɨɪ, ɤɨɬɨɪɵɣ ɧɟ ɩɨɡɜɨɥɹɟɬ ɢɡɦɟɧɢɬɶ
ɢɦɹ ɮɚɣɥɚ ɞɥɹ ɫɨɯɪɚɧɟɧɢɹ ɞɚɧɧɵɯ ɩɨɫɥɟ ɨɲɢɛɤɢ ɡɚɩɢɫɢ.
ɉɪɢɦɟɪ 2. Ɍɟɤɫɬɭɪɵ. ȿɫɥɢ ɜɵ ɩɢɲɟɬɟ ɩɪɢɥɨɠɟɧɢɟ, ɭ ɤɨɬɨɪɨɝɨ ɦɨɠɧɨ ɦɟɧɹɬɶ ɜɧɟɲɧɢɣ ɜɢɞ,
ɡɚɝɪɭɠɚɹ ɧɨɜɵɟ ɬɟɤɫɬɭɪɵ, ɬɨ ɭɱɬɢɬɟ, ɱɬɨ ɧɟ ɫɥɟɞɭɟɬ ɭɧɢɱɬɨɠɚɬɶ ɫɬɚɪɵɟ ɬɟɤɫɬɭɪɵ ɞɨ ɬɟɯ ɩɨɪ, ɩɨ-
ɤɚ ɧɟ ɛɭɞɭɬ ɩɨɥɧɨɫɬɶɸ ɡɚɝɪɭɠɟɧɵ ɢ ɩɪɢɦɟɧɟɧɵ ɧɨɜɵɟ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɩɪɢ ɫɛɨɟ ɜɨ ɜɪɟɦɹ
ɡɚɝɪɭɡɤɢ ɧɨɜɵɯ ɬɟɤɫɬɭɪ ɜɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜ ɧɟɫɬɚɛɢɥɶɧɨɦ ɫɨɫɬɨɹɧɢɢ.
ɉɪɢɦɟɪ 3. std::vector::insert. ɉɨɫɤɨɥɶɤɭ ɜɧɭɬɪɟɧɧɟɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ vector<T>
ɢɫɩɨɥɶɡɭɟɬ ɧɟɩɪɟɪɵɜɧɵɣ ɛɥɨɤ ɩɚɦɹɬɢ, ɜɫɬɚɜɤɚ ɷɥɟɦɟɧɬɚ ɜ ɫɪɟɞɢɧɭ ɬɪɟɛɭɟɬ ɩɟɪɟɦɟɳɟɧɢɹ ɪɹɞɚ
ɢɦɟɸɳɢɯɫɹ ɡɧɚɱɟɧɢɣ ɧɚ ɨɞɧɭ ɩɨɡɢɰɢɸ ɞɥɹ ɨɫɜɨɛɨɠɞɟɧɢɹ ɦɟɫɬɚ ɞɥɹ ɜɫɬɚɜɥɹɟɦɨɝɨ ɷɥɟɦɟɧɬɚ.
ɉɟɪɟɦɟɳɟɧɢɟ ɜɵɩɨɥɧɹɟɬɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ T::T(const T&)
ɢ ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ T::operator=, ɢ ɟɫɥɢ ɨɞɧɚ ɢɡ ɷɬɢɯ ɨɩɟɪɚɰɢɣ ɦɨɠɟɬ ɫɛɨɢɬɶ
(ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ), ɬɨ ɟɞɢɧɫɬɜɟɧɧɵɣ ɫɩɨɫɨɛ ɨɛɟɫɩɟɱɢɬɶ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ — ɷɬɨ
Стр. 152
ɫɞɟɥɚɬɶ ɩɨɥɧɭɸ ɤɨɩɢɸ ɤɨɧɬɟɣɧɟɪɚ, ɜɵɩɨɥɧɢɬɶ ɨɩɟɪɚɰɢɸ ɧɚɞ ɤɨɩɢɟɣ, ɚ ɡɚɬɟɦ ɨɛɦɟɧɹɬɶ ɨɪɢ-
ɝɢɧɚɥ ɢ ɤɨɩɢɸ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɛɟɫɫɛɨɣɧɨɣ ɮɭɧɤɰɢɢ vector<T>::swap.
Ɉɞɧɚɤɨ ɜɵɩɨɥɧɟɧɢɟ ɜɫɟɯ ɭɤɚɡɚɧɧɵɯ ɞɟɣɫɬɜɢɣ ɨɛɯɨɞɢɬɫɹ ɢɡɥɢɲɧɟ ɞɨɪɨɝɨ ɤɚɤ ɜ ɩɥɚɧɟ ɬɪɟ-
ɛɭɟɦɨɣ ɩɚɦɹɬɢ, ɬɚɤ ɢ ɩɪɨɰɟɫɫɨɪɧɨɝɨ ɜɪɟɦɟɧɢ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɨɛɟɫɩɟɱɟɧɢɟ ɫɬɪɨɝɨɣ ɝɚɪɚɧɬɢɢ
ɞɚɠɟ ɬɨɝɞɚ, ɤɨɝɞɚ ɨɧɚ ɧɟ ɹɜɥɹɟɬɫɹ ɧɟɨɛɯɨɞɢɦɨɣ, ɨɤɚɡɵɜɚɟɬɫɹ ɱɪɟɡɦɟɪɧɨ ɪɚɫɬɨɱɢɬɟɥɶɧɵɦ. ɉɨ-
ɷɬɨɦɭ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɞɨɥɠɟɧ ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɨɛɟɫɩɟɱɢɜɚɬɶ ɫɚɦɨ-
ɫɬɨɹɬɟɥɶɧɨ — ɞɥɹ ɷɬɨɝɨ ɲɚɛɥɨɧ vector ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɜɫɟ ɧɟɨɛɯɨɞɢɦɵɟ ɢɧɫɬɪɭɦɟɧɬɵ. (ȼ
ɥɭɱɲɟɦ ɫɥɭɱɚɟ, ɟɫɥɢ ɬɢɩ ɫɨɞɟɪɠɢɦɨɝɨ ɤɨɧɬɟɣɧɟɪɚ ɧɟ ɝɟɧɟɪɢɪɭɟɬ ɢɫɤɥɸɱɟɧɢɣ ɜ ɤɨɩɢɪɭɸɳɟɦ
ɤɨɧɫɬɪɭɤɬɨɪɟ ɢ ɤɨɩɢɪɭɸɳɟɦ ɨɩɟɪɚɬɨɪɟ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɧɢɤɚɤɢɯ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɞɟɣɫɬɜɢɣ ɧɟ
ɬɪɟɛɭɟɬɫɹ. ȼ ɯɭɞɲɟɦ ɫɥɟɞɭɟɬ ɫɨɡɞɚɬɶ ɤɨɩɢɸ ɜɟɤɬɨɪɚ, ɜɵɩɨɥɧɢɬɶ ɜɫɬɚɜɤɭ ɜ ɤɨɩɢɸ ɢ ɩɨɫɥɟ ɭɫ-
ɩɟɲɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɞɚɧɧɨɣ ɨɩɟɪɚɰɢɢ ɨɛɦɟɧɹɬɶ ɤɨɩɢɸ ɢ ɢɫɯɨɞɧɵɣ ɜɟɤɬɨɪ.)
ɉɪɢɦɟɪ 4. Ɂɚɩɭɫɤ ɫɩɭɬɧɢɤɚ. Ɋɚɫɫɦɨɬɪɢɦ ɮɭɧɤɰɢɸ f, ɜ ɤɨɬɨɪɨɣ ɱɚɫɬɶɸ ɟɟ ɪɚɛɨɬɵ ɹɜɥɹɟɬɫɹ
ɡɚɩɭɫɤ ɫɩɭɬɧɢɤɚ, ɢ ɢɫɩɨɥɶɡɭɟɦɭɸ ɟɸ ɮɭɧɤɰɢɸ LaunchSatellite, ɨɛɟɫɩɟɱɢɜɚɸɳɭɸ ɝɚɪɚɧ-
ɬɢɸ ɧɟ ɧɢɠɟ ɫɬɪɨɝɨɣ. ȿɫɥɢ ɮɭɧɤɰɢɹ f ɦɨɠɟɬ ɜɵɩɨɥɧɢɬɶ ɜɫɸ ɪɚɛɨɬɭ, ɩɪɢ ɤɨɬɨɪɨɣ ɦɨɠɟɬ ɩɪɨ-
ɢɡɨɣɬɢ ɫɛɨɣ, ɞɨ ɡɚɩɭɫɤɚ ɫɩɭɬɧɢɤɚ, ɬɨ f ɫɩɨɫɨɛɧɚ ɨɛɟɫɩɟɱɢɬɶ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ. ɇɨ ɟɫɥɢ f
ɞɨɥɠɧɚ ɜɵɩɨɥɧɢɬɶ ɧɟɤɨɬɨɪɵɟ ɨɩɟɪɚɰɢɢ, ɜ ɩɪɨɰɟɫɫɟ ɤɨɬɨɪɵɯ ɦɨɠɟɬ ɩɪɨɢɡɨɣɬɢ ɫɛɨɣ, ɭɠɟ ɩɨ-
ɫɥɟ ɡɚɩɭɫɤɚ ɫɩɭɬɧɢɤɚ, ɬɨ ɨɛɟɫɩɟɱɟɧɢɟ ɫɬɪɨɝɨɣ ɝɚɪɚɧɬɢɢ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɜɨɡɦɨɠɧɵɦ — ɜɟɪɧɭɬɶ
ɡɚɩɭɳɟɧɧɵɣ ɫɩɭɬɧɢɤ ɧɚ ɫɬɚɪɬɨɜɭɸ ɩɥɨɳɚɞɤɭ ɭɠɟ ɧɟɥɶɡɹ. (Ɍɚɤɭɸ ɮɭɧɤɰɢɸ f ɫɥɟɞɭɟɬ ɪɚɡɞɟ-
ɥɢɬɶ ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ ɧɚ ɞɜɟ, ɩɨɫɤɨɥɶɤɭ ɨɞɧɚ ɮɭɧɤɰɢɹ ɧɟ ɞɨɥɠɧɚ ɞɚɠɟ ɩɵɬɚɬɶɫɹ ɜɵɩɨɥɧɢɬɶ
ɧɟɫɤɨɥɶɤɨ ɪɚɡɥɢɱɧɵɯ ɞɟɣɫɬɜɢɣ ɬɚɤɨɣ ɜɚɠɧɨɫɬɢ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5.)
Ссылки
[Abrahams96] • [Abrahams01b] • [Alexandrescu03d] • [Josuttis99] §5.11.2 • [Stroustrup00] §14.4.3,
§E.2-4, §E.6 • [Sutter00] §8-19, §40-41, §47 • [Sutter02] §17-23 • [Sutter04] §11-13 • [Sutter04b]
71. Проектируйте и пишите безопасный в отношении ошибок код 153
Стр. 153
72. Для уведомления об ошибках следует
использовать исключения
Резюме
Ⱦɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɟɯɚɧɢɡɦ ɢɫɤɥɸɱɟɧɢɣ, ɚ ɧɟ ɤɨɞɵ ɨɲɢɛɨɤ.
ɉɪɢɦɟɧɹɬɶ ɤɨɞɵ ɫɨɫɬɨɹɧɢɹ (ɧɚɩɪɢɦɟɪ, ɤɨɞɵ ɨɲɢɛɨɤ, ɩɟɪɟɦɟɧɧɭɸ errno) ɫɥɟɞɭɟɬ ɬɨɥɶɤɨ ɬɨɝɞɚ,
ɤɨɝɞɚ ɧɟɥɶɡɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 62), ɚ ɬɚɤɠɟ ɞɥɹ ɫɢɬɭɚɰɢɣ, ɤɨɬɨɪɵɟ
ɧɟ ɹɜɥɹɸɬɫɹ ɨɲɢɛɤɚɦɢ. Ʉ ɞɪɭɝɢɦ ɦɟɬɨɞɚɦ, ɬɚɤɢɦ ɤɚɤ ɷɤɫɬɪɟɧɧɨɟ ɡɚɜɟɪɲɟɧɢɟ ɩɪɨɝɪɚɦɦɵ (ɢɥɢ
ɩɥɚɧɨɜɨɟ ɡɚɜɟɪɲɟɧɢɟ ɫ ɨɫɜɨɛɨɠɞɟɧɢɟɦ ɪɟɫɭɪɫɨɜ ɢ ɬ.ɩ. ɞɟɣɫɬɜɢɹɦɢ), ɫɥɟɞɭɟɬ ɩɪɢɛɟɝɚɬɶ ɬɨɥɶɤɨ
ɜ ɫɢɬɭɚɰɢɹɯ, ɤɨɝɞɚ ɜɨɫɫɬɚɧɨɜɥɟɧɢɟ ɩɨɫɥɟ ɨɲɢɛɤɢ ɧɟɜɨɡɦɨɠɧɨ (ɢɥɢ ɧɟ ɬɪɟɛɭɟɬɫɹ).
Ɍɨ, ɱɬɨ ɫɨɜɪɟɦɟɧɧɵɟ ɹɡɵɤɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɫɨɡɞɚɧɧɵɟ ɜ ɬɟɱɟɧɢɟ ɩɨɫɥɟɞɧɢɯ 20 ɥɟɬ,
ɢɫɩɨɥɶɡɭɸɬ ɜ ɤɚɱɟɫɬɜɟ ɨɫɧɨɜɧɨɝɨ ɦɟɯɚɧɢɡɦɚ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɢɫɤɥɸɱɟɧɢɹ, — ɧɟ ɫɥɭ-
ɱɚɣɧɨɫɬɶ. ɉɪɚɤɬɢɱɟɫɤɢ ɩɨ ɨɩɪɟɞɟɥɟɧɢɸ ɢɫɤɥɸɱɟɧɢɹ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɢɫ-
ɤɥɸɱɟɧɢɹɯ ɜ ɧɨɪɦɚɥɶɧɨɦ ɩɪɨɰɟɫɫɟ — ɢɡɜɟɫɬɧɵɯ ɬɚɤɠɟ ɤɚɤ “ɨɲɢɛɤɢ”, ɤɨɬɨɪɵɟ ɨɩɪɟɞɟɥɟɧɵ ɜ
ɪɟɤɨɦɟɧɞɚɰɢɢ 70 ɤɚɤ ɧɚɪɭɲɟɧɢɹ ɩɪɟɞɭɫɥɨɜɢɣ, ɩɨɫɬɭɫɥɨɜɢɣ ɢ ɢɧɜɚɪɢɚɧɬɨɜ. Ɍɚɤ ɠɟ, ɤɚɤ ɢ ɜɫɟ
ɞɪɭɝɢɟ ɦɟɯɚɧɢɡɦɵ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ, ɢɫɤɥɸɱɟɧɢɹ ɧɟ ɞɨɥɠɧɵ ɝɟɧɟɪɢɪɨɜɚɬɶɫɹ ɩɪɢ
ɧɨɪɦɚɥɶɧɨɣ ɭɫɩɟɲɧɨɣ ɪɚɛɨɬɟ.
Ⱦɚɥɟɟ ɦɵ ɛɭɞɟɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɟɪɦɢɧ “ɤɨɞɵ ɫɨɫɬɨɹɧɢɹ” ɞɥɹ ɜɫɟɯ ɜɢɞɨɜ ɫɨɨɛɳɟɧɢɹ ɨɛ
ɨɲɢɛɤɚɯ ɩɨɫɪɟɞɫɬɜɨɦ ɤɨɞɨɜ (ɜɤɥɸɱɚɹ ɤɨɞɵ ɜɨɡɜɪɚɬɚ, errno, ɮɭɧɤɰɢɸ GetLastError ɢ
ɩɪɨɱɢɟ ɫɬɪɚɬɟɝɢɢ ɜɨɡɜɪɚɬɚ ɢɥɢ ɩɨɥɭɱɟɧɢɹ ɤɨɞɨɜ), ɚ ɬɟɪɦɢɧ “ɤɨɞɵ ɨɲɢɛɨɤ” — ɞɥɹ ɬɟɯ ɤɨɞɨɜ
ɫɨɫɬɨɹɧɢɹ, ɤɨɬɨɪɵɟ ɨɡɧɚɱɚɸɬ ɨɲɢɛɤɢ. ȼ C++ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɲɢɛɤɚɯ ɩɨɫɪɟɞɫɬɜɨɦ ɢɫɤɥɸɱɟ-
ɧɢɣ ɢɦɟɟɬ ɹɜɧɵɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɩɟɪɟɞ ɭɜɟɞɨɦɥɟɧɢɟɦ ɩɨɫɪɟɞɫɬɜɨɦ ɤɨɞɨɜ ɨɲɢɛɨɤ.
• ɂɫɤɥɸɱɟɧɢɹ ɧɟɜɨɡɦɨɠɧɨ ɩɪɨɢɝɧɨɪɢɪɨɜɚɬɶ. ɋɚɦɨɟ ɫɥɚɛɨɟ ɦɟɫɬɨ ɤɨɞɨɜ ɨɲɢɛɨɤ ɡɚɤɥɸ-
ɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɩɨ ɭɦɨɥɱɚɧɢɸ ɨɧɢ ɢɝɧɨɪɢɪɭɸɬɫɹ; ɱɬɨɛɵ ɭɞɟɥɢɬɶ ɯɨɬɹ ɛɵ ɦɢɧɢɦɚɥɶ-
ɧɨɟ ɜɧɢɦɚɧɢɟ ɤɨɞɚɦ ɨɲɢɛɨɤ, ɜɵ ɞɨɥɠɧɵ ɹɜɧɨ ɩɢɫɚɬɶ ɤɨɞ, ɤɨɬɨɪɵɣ ɨɩɪɚɲɢɜɚɟɬ ɤɨɞ
ɨɲɢɛɤɢ ɢ ɨɬɜɟɱɚɟɬ ɧɚ ɧɟɝɨ. ȼɟɫɶɦɚ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɫɪɟɞɢ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɩɪɚɤɬɢ-
ɤɚ — ɫɥɭɱɚɣɧɨ (ɢɥɢ ɢɡ-ɡɚ ɥɟɧɢ) ɡɚɛɵɬɶ ɨɩɪɨɫɢɬɶ ɤɨɞ ɨɲɢɛɤɢ. ɂɫɤɥɸɱɟɧɢɹ ɠɟ ɧɟɜɨɡ-
ɦɨɠɧɨ ɩɪɨɫɬɨ ɩɪɨɢɝɧɨɪɢɪɨɜɚɬɶ; ɱɬɨɛɵ ɩɪɨɢɝɧɨɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ, ɜɵ ɞɨɥɠɧɵ ɹɜ-
ɧɨ ɩɟɪɟɯɜɚɬɢɬɶ ɟɝɨ (ɞɚɠɟ ɟɫɥɢ ɜɵ ɫɞɟɥɚɟɬɟ ɷɬɨ ɩɪɢ ɩɨɦɨɳɢ ɟɞɢɧɫɬɜɟɧɧɨɣ ɢɧɫɬɪɭɤɰɢɢ
catch(...)) ɢ ɧɢɤɚɤ ɧɚ ɧɟɝɨ ɧɟ ɨɬɪɟɚɝɢɪɨɜɚɬɶ.
• ɂɫɤɥɸɱɟɧɢɹ ɪɚɫɩɪɨɫɬɪɚɧɹɸɬɫɹ ɚɜɬɨɦɚɬɢɱɟɫɤɢ. Ʉɨɞɵ ɨɲɢɛɨɤ ɩɨ ɭɦɨɥɱɚɧɢɸ ɡɚ ɩɪɟ-
ɞɟɥɵ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɧɟ ɪɚɫɩɪɨɫɬɪɚɧɹɸɬɫɹ; ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɢɧɮɨɪɦɢɪɨɜɚɬɶ ɜɵɫɨ-
ɤɨɭɪɨɜɧɟɜɭɸ ɜɵɡɵɜɚɸɳɭɸ ɮɭɧɤɰɢɸ ɨ ɧɢɡɤɨɭɪɨɜɧɟɜɨɣ ɨɲɢɛɤɟ, ɩɪɨɝɪɚɦɦɢɫɬ ɞɨɥɠɟɧ
ɧɚɩɢɫɚɬɶ ɩɪɨɦɟɠɭɬɨɱɧɵɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɩɟɪɟɞɚɫɬ ɢɧɮɨɪɦɚɰɢɸ ɨɛ ɨɲɢɛɤɟ. ɂɫɤɥɸɱɟ-
ɧɢɹ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɪɚɫɩɪɨɫɬɪɚɧɹɸɬɫɹ ɡɚ ɩɪɟɞɟɥɵ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ
ɨɧɢ ɧɟ ɛɭɞɭɬ ɩɟɪɟɯɜɚɱɟɧɵ. (“ɗɬɨ ɧɟ ɫɚɦɨɟ ɪɚɡɭɦɧɨɟ — ɩɵɬɚɬɶɫɹ ɫɞɟɥɚɬɶ ɢɡ ɤɚɠɞɨɣ
ɮɭɧɤɰɢɢ ɛɪɚɧɞɦɚɭɷɪ”. — [Stroustrup94, §16.8])
• ɂɫɤɥɸɱɟɧɢɹ ɜɵɧɨɫɹɬ ɨɛɪɚɛɨɬɤɭ ɨɲɢɛɨɤ ɢ ɜɨɫɫɬɚɧɨɜɥɟɧɢɟ ɩɨɫɥɟ ɧɢɯ ɢɡ ɨɫɧɨɜɧɨɝɨ ɩɨɬɨ-
ɤɚ ɭɩɪɚɜɥɟɧɢɹ. ɉɪɨɜɟɪɤɚ ɤɨɞɚ ɨɲɢɛɤɢ ɢ ɟɟ ɨɛɪɚɛɨɬɤɚ ɩɟɪɟɦɟɠɚɟɬɫɹ ɫ ɨɫɧɨɜɧɵɦ ɩɨɬɨɤɨɦ
ɭɩɪɚɜɥɟɧɢɹ ɩɪɨɝɪɚɦɦɵ, ɬɟɦ ɫɚɦɵɦ ɡɚɩɭɬɵɜɚɹ ɟɝɨ. ɗɬɨ ɡɚɬɪɭɞɧɹɟɬ ɩɨɧɢɦɚɧɢɟ ɢ ɫɨɩɪɨɜɨ-
ɠɞɟɧɢɟ ɤɚɤ ɨɫɧɨɜɧɨɝɨ ɤɨɞɚ ɩɪɨɝɪɚɦɦɵ, ɬɚɤ ɢ ɤɨɞɚ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ. Ɉɛɪɚɛɨɬɤɚ ɢɫɤɥɸ-
ɱɟɧɢɣ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ ɩɟɪɟɦɟɳɚɟɬ ɨɛɧɚɪɭɠɟɧɢɟ ɨɲɢɛɨɤ ɢ ɜɨɫɫɬɚɧɨɜɥɟɧɢɟ ɩɨ-
ɫɥɟ ɧɢɯ ɜ ɨɬɞɟɥɶɧɵɟ catch-ɛɥɨɤɢ, ɬ.ɟ. ɞɟɥɚɸɬ ɨɛɪɚɛɨɬɤɭ ɨɲɢɛɨɤ ɫɭɳɟɫɬɜɟɧɧɨ ɛɨɥɟɟ
Стр. 154
ɦɨɞɭɥɶɧɨɣ. Ɍɟɦ ɫɚɦɵɦ ɨɫɧɨɜɧɨɣ ɤɨɞ ɩɪɨɝɪɚɦɦɵ, ɤɚɤ ɢ ɤɨɞ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ, ɨɤɚɡɵɜɚ-
ɟɬɫɹ ɛɨɥɟɟ ɩɨɧɹɬɧɵɦ ɢ ɥɟɝɱɟ ɫɨɩɪɨɜɨɠɞɚɟɦɵɦ.
• ɂɫɤɥɸɱɟɧɢɹ ɨɤɚɡɵɜɚɸɬɫɹ ɧɚɢɥɭɱɲɢɦ ɫɩɨɫɨɛɨɦ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɜ ɤɨɧɫɬɪɭɤ-
ɬɨɪɚɯ ɢ ɨɩɟɪɚɬɨɪɚɯ. Ʉɨɩɢɪɭɸɳɢɟ ɤɨɧɫɬɪɭɤɬɨɪɵ ɢ ɨɩɟɪɚɬɨɪɵ ɢɦɟɸɬ ɩɪɟɞɨɩɪɟɞɟɥɟɧ-
ɧɵɟ ɫɢɝɧɚɬɭɪɵ, ɜ ɤɨɬɨɪɵɯ ɩɪɨɫɬɨ ɧɟɬ ɦɟɫɬɚ ɞɥɹ ɤɨɞɨɜ ɜɨɡɜɪɚɬɚ. ȼ ɱɚɫɬɧɨɫɬɢ, ɤɨɧɫɬ-
ɪɭɤɬɨɪɵ ɜɨɨɛɳɟ ɧɟ ɢɦɟɸɬ ɜɨɡɜɪɚɳɚɟɦɨɝɨ ɬɢɩɚ (ɞɚɠɟ void), ɚ, ɧɚɩɪɢɦɟɪ, ɤɚɠɞɵɣ
ɨɩɟɪɚɬɨɪ operator+ ɞɨɥɠɟɧ ɩɨɥɭɱɚɬɶ ɜ ɬɨɱɧɨɫɬɢ ɞɜɚ ɩɚɪɚɦɟɬɪɚ ɢ ɜɨɡɜɪɚɳɚɬɶ ɬɨɥɶɤɨ
ɨɞɢɧ ɨɛɴɟɤɬ (ɩɪɟɞɨɩɪɟɞɟɥɟɧɧɨɝɨ ɬɢɩɚ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 26). ȼ ɫɥɭɱɚɟ ɨɩɟɪɚɬɨɪɨɜ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɞɨɜ ɨɲɢɛɨɤ, ɤɚɤ ɦɢɧɢɦɭɦ, ɜɨɡɦɨɠɧɨ, ɟɫɥɢ ɧɟ ɠɟɥɚɬɟɥɶɧɨ; ɞɥɹ ɷɬɨɝɨ
ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɝɥɨɛɚɥɶɧɨɣ ɩɟɪɟɦɟɧɧɨɣ ɧɚɩɨɞɨɛɢɟ errno ɢɥɢ ɧɟɫɤɨɥɶɤɨ ɛɨ-
ɥɟɟ ɯɭɞɲɢɦ ɦɟɬɨɞɨɦ ɜɧɟɞɪɟɧɢɹ ɤɨɞɚ ɫɨɫɬɨɹɧɢɹ ɜ ɫɨɫɬɚɜ ɨɛɴɟɤɬɚ. ɇɨ ɞɥɹ ɤɨɧɫɬɪɭɤɬɨ-
ɪɨɜ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɞɨɜ ɨɲɢɛɨɤ ɧɟɩɪɢɦɟɧɢɦɨ, ɩɨɫɤɨɥɶɤɭ ɜ ɹɡɵɤɟ C++ ɢɫɤɥɸɱɟɧɢɹ
ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ ɢ ɫɛɨɢ ɜ ɤɨɧɫɬɪɭɤɬɨɪɟ ɧɚɫɬɨɥɶɤɨ ɬɟɫɧɨ ɫɜɹɡɚɧɵ, ɱɬɨ ɩɨ ɫɭɬɢ ɹɜɥɹɸɬɫɹ
ɫɢɧɨɧɢɦɚɦɢ. ȿɫɥɢ ɜɵ ɩɨɩɵɬɚɟɬɟɫɶ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɨɞɯɨɞ ɫ ɝɥɨɛɚɥɶɧɨɣ ɩɟɪɟɦɟɧɧɨɣ ɧɚ-
ɩɨɞɨɛɢɟ
SomeType anObject; // ǕǹǸǼǽǻǾǳǻǹǭǫǸǳǰ ǹǬȅǰǵǽǫ
if( SomeType::ConstructionWasOk() ) { // ǚǻǹǭǰǻǵǫ ǻǰǲǾǶȇǽǫǽǫ
// ... // ǵǹǸǼǽǻǾǳǻǹǭǫǸǳȊ
ɬɨ ɪɟɡɭɥɶɬɚɬ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟ ɬɨɥɶɤɨ ɭɪɨɞɥɢɜɵɦ ɢ ɩɨɞɜɟɪɠɟɧɧɵɦ ɨɲɢɛɤɚɦ, ɧɨ ɢ ɜɟɞɟɬ ɤ
“ɧɟɡɚɤɨɧɧɨɪɨɠɞɟɧɧɵɦ” ɨɛɴɟɤɬɚɦ, ɤɨɬɨɪɵɟ ɩɪɢɡɧɚɸɬɫɹ ɤɨɪɪɟɤɬɧɵɦɢ, ɧɨ ɧɚ ɫɚɦɨɦ ɞɟ-
ɥɟ ɧɟ ɭɞɨɜɥɟɬɜɨɪɹɸɬ ɢɧɜɚɪɢɚɧɬɚɦ ɬɢɩɚ. ɗɬɨ ɫɜɹɡɚɧɨ ɫ ɜɨɡɦɨɠɧɵɦɢ ɭɫɥɨɜɢɹɦɢ ɝɨɧɤɢ
ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɮɭɧɤɰɢɢ SomeType::ConstructionWasOk ɜ ɦɧɨɝɨɩɨɬɨɱɧɵɯ
ɩɪɢɥɨɠɟɧɢɹɯ (ɫɦ. [Stroustrup00] §E.3.5).
Ƚɥɚɜɧɵɣ ɩɨɬɟɧɰɢɚɥɶɧɵɣ ɧɟɞɨɫɬɚɬɨɤ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɬɪɟ-
ɛɭɟɬ ɨɬ ɩɪɨɝɪɚɦɦɢɫɬɚ ɯɨɪɨɲɢɯ ɡɧɚɧɢɣ ɨ ɧɟɤɨɬɨɪɵɯ ɢɞɢɨɦɚɯ, ɜɨɡɧɢɤɚɸɳɢɯ ɜ ɪɟɡɭɥɶɬɚɬɟ ɜɵ-
ɧɟɫɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ ɢɡ ɨɫɧɨɜɧɨɝɨ ɩɨɬɨɤɚ ɭɩɪɚɜɥɟɧɢɹ. ɇɚɩɪɢɦɟɪ, ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɮɭɧɤɰɢɢ ɨɫ-
ɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɧɟ ɞɨɥɠɧɵ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 51), ɚ ɩɪɨɦɟ-
ɠɭɬɨɱɧɵɣ ɤɨɞ ɞɨɥɠɟɧ ɛɵɬɶ ɤɨɪɪɟɤɬɟɧ ɩɪɢ ɧɚɥɢɱɢɢ ɢɫɤɥɸɱɟɧɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71
ɢ ɫɫɵɥɤɢ); ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɢɞɢɨɦɚ ɞɥɹ ɞɨɫɬɢɠɟɧɢɹ ɷɬɨɝɨ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɨɬɞɟɥɶɧɨɦ ɜɵɩɨɥ-
ɧɟɧɢɢ ɜɫɟɣ ɪɚɛɨɬɵ, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ, ɢ ɬɨɥɶɤɨ ɩɨɫɥɟ ɭɫɩɟɲ-
ɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɪɟɡɭɥɶɬɚɬɵ ɪɚɛɨɬɵ ɩɪɢɧɢɦɚɸɬɫɹ, ɢ ɫɨɫɬɨɹɧɢɟ ɩɪɨɝɪɚɦɦɵ ɦɨɞɢɮɢɰɢɪɭɟɬɫɹ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɬɨɥɶɤɨ ɬɟɯ ɨɩɟɪɚɰɢɣ, ɤɨɬɨɪɵɟ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɝɚɪɚɧɬɢɸ ɛɟɫɫɛɨɣɧɨɫɬɢ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 51 ɢ [Sutter00] §9-10, §13). Ɉɞɧɚɤɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɞɨɜ ɨɲɢɛɨɤ ɬɚɤɠɟ
ɢɦɟɟɬ ɫɨɛɫɬɜɟɧɧɵɟ ɢɞɢɨɦɵ. ɉɪɨɫɬɨ ɷɬɢ ɢɞɢɨɦɵ ɛɨɥɟɟ ɫɬɚɪɵɟ ɢ ɢɯ ɡɧɚɟɬ ɛɨɥɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ
ɩɪɨɝɪɚɦɦɢɫɬɨɜ — ɧɨ ɩɪɢ ɷɬɨɦ, ɤ ɫɨɠɚɥɟɧɢɸ, ɡɚɱɚɫɬɭɸ ɢɯ ɩɪɨɫɬɨ ɢɝɧɨɪɢɪɭɟɬ…
Ɉɛɵɱɧɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɫɧɢɠɟɧɢɸ ɩɪɨɢɡɜɨɞɢɬɟɥɶ-
ɧɨɫɬɢ. Ⱦɥɹ ɧɚɱɚɥɚ ɡɚɦɟɬɢɦ, ɱɬɨ ɜɵ ɜɫɟɝɞɚ ɞɨɥɠɧɵ ɜɤɥɸɱɚɬɶ ɩɨɞɞɟɪɠɤɭ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟ-
ɧɢɣ ɜ ɜɚɲɟɦ ɤɨɦɩɢɥɹɬɨɪɟ, ɞɚɠɟ ɟɫɥɢ ɩɨ ɭɦɨɥɱɚɧɢɸ ɨɧɚ ɨɬɤɥɸɱɟɧɚ; ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵ
ɧɟ ɫɦɨɠɟɬɟ ɩɨɥɭɱɢɬɶ ɩɪɟɞɭɫɦɨɬɪɟɧɧɨɟ ɫɬɚɧɞɚɪɬɨɦ ɩɨɜɟɞɟɧɢɟ ɢ ɭɜɟɞɨɦɥɟɧɢɟ ɨɛ ɨɲɢɛɤɚɯ ɨɬ
ɬɚɤɢɯ ɨɩɟɪɚɰɢɣ C++, ɤɚɤ ɨɩɟɪɚɬɨɪ new ɢɥɢ ɨɩɟɪɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ ɧɚɩɨɞɨɛɢɟ
ɜɫɬɚɜɨɤ ɜ ɤɨɧɬɟɣɧɟɪ (ɫɦ. ɪɚɡɞɟɥ ɢɫɤɥɸɱɟɧɢɣ ɜ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ).
[ɇɟɛɨɥɶɲɨɟ ɨɬɫɬɭɩɥɟɧɢɟ. ȼɤɥɸɱɟɧɢɟ ɩɨɞɞɟɪɠɤɢ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɦɨɠɟɬ ɛɵɬɶ
ɪɟɚɥɢɡɨɜɚɧɨ ɬɚɤ, ɱɬɨ ɨɧɨ ɭɜɟɥɢɱɢɬ ɪɚɡɦɟɪ ɜɵɩɨɥɧɢɦɨɝɨ ɮɚɣɥɚ (ɱɬɨ ɧɟɢɡɛɟɠɧɨ), ɧɨ ɩɪɢ
ɷɬɨɦ ɩɪɚɤɬɢɱɟɫɤɢ ɧɟ ɩɨɜɥɢɹɟɬ ɧɚ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɶ ɩɪɢɥɨɠɟɧɢɹ ɩɪɢ ɨɬɫɭɬɫɬɜɢɢ ɫɝɟɧɟ-
ɪɢɪɨɜɚɧɧɵɯ ɢɫɤɥɸɱɟɧɢɣ, ɩɪɢɱɟɦ ɧɟɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪɵ ɢɦɟɧɧɨ ɬɚɤ ɢ ɩɨɫɬɭɩɚɸɬ. Ⱦɪɭɝɢɟ
ɤɨɦɩɢɥɹɬɨɪɵ ɩɪɢɜɨɞɹɬ ɤ ɨɩɪɟɞɟɥɟɧɧɵɦ ɧɚɤɥɚɞɧɵɦ ɪɚɫɯɨɞɚɦ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɩɪɢ ɨɛɟɫɩɟ-
ɱɟɧɢɢ ɪɟɠɢɦɚ ɛɟɡɨɩɚɫɧɨɫɬɢ ɞɥɹ ɩɪɟɞɨɬɜɪɚɳɟɧɢɹ ɚɬɚɤ ɩɨɫɪɟɞɫɬɜɨɦ ɩɟɪɟɩɨɥɧɟɧɢɹ ɛɭɮɟɪɚ
ɜ ɦɟɯɚɧɢɡɦɟ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ. Ɉɞɧɚɤɨ ɢɦɟɸɬɫɹ ɥɢ ɧɚɤɥɚɞɧɵɟ ɪɚɫɯɨɞɵ, ɫɜɹɡɚɧɧɵɟ
72. Для уведомления об ошибках следует использовать исключения 155
Стр. 155
ɫ ɦɟɯɚɧɢɡɦɨɦ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ, ɢɥɢ ɧɟɬ — ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ, ɜɵ ɞɨɥɠɧɵ ɜɤɥɸɱɢɬɶ
ɟɝɨ, ɢɧɚɱɟ ɜɵ ɧɟ ɫɦɨɠɟɬɟ ɩɨɥɭɱɚɬɶ ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɨɬ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɢ
ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ.]
ɉɪɢ ɜɤɥɸɱɟɧɧɨɣ ɩɨɞɞɟɪɠɤɟ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɤɨɦɩɢɥɹɬɨɪɨɦ ɪɚɡɧɢɰɚ ɜ ɩɪɨɢɡɜɨɞɢ-
ɬɟɥɶɧɨɫɬɢ ɦɟɠɞɭ ɝɟɧɟɪɚɰɢɟɣ ɢɫɤɥɸɱɟɧɢɣ ɢ ɜɨɡɜɪɚɬɨɦ ɤɨɞɚ ɨɲɢɛɤɢ ɩɪɢ ɧɨɪɦɚɥɶɧɨɣ ɪɚɛɨɬɟ
(ɜ ɨɬɫɭɬɫɬɜɢɟ ɨɲɢɛɨɤ) ɨɛɵɱɧɨ ɧɟɡɧɚɱɢɬɟɥɶɧɚ. Ɉɩɪɟɞɟɥɟɧɧɭɸ ɪɚɡɧɢɰɭ ɜ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ
ɦɨɠɧɨ ɡɚɦɟɬɢɬɶ ɬɨɥɶɤɨ ɩɪɢ ɨɲɢɛɤɚɯ, ɧɨ ɟɫɥɢ ɨɲɢɛɤɢ ɩɪɨɢɫɯɨɞɹɬ ɬɚɤ ɱɚɫɬɨ, ɱɬɨ ɫɬɚɧɨɜɢɬɫɹ
ɨɳɭɬɢɦɨɣ ɪɚɡɧɢɰɚ ɜ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ — ɫɤɨɪɟɟ ɜɫɟɝɨ, ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɢɫɤɥɸɱɟɧɢɹ ɞɥɹ
ɫɢɬɭɚɰɢɣ, ɤɨɬɨɪɵɟ ɨɲɢɛɤɚɦɢ ɧɟ ɹɜɥɹɸɬɫɹ, ɚ ɡɧɚɱɢɬ, ɜɵ ɧɟ ɫɦɨɝɥɢ ɤɨɪɪɟɤɬɧɨ ɜɵɱɥɟɧɢɬɶ
ɨɲɢɛɤɢ ɢɡ ɩɪɨɱɢɯ ɫɢɬɭɚɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 70). ȿɫɥɢ ɠɟ ɷɬɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɨɲɢɛɤɢ, ɤɨ-
ɬɨɪɵɟ ɧɚɪɭɲɚɸɬ ɩɪɟɞ-, ɩɨɫɬɭɫɥɨɜɢɹ ɢɥɢ ɢɧɜɚɪɢɚɧɬɵ, ɢ ɨɧɢ ɜɫɬɪɟɱɚɸɬɫɹ ɧɚɫɬɨɥɶɤɨ ɱɚɫɬɨ —
ɡɧɚɱɢɬ, ɭ ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ ɢɦɟɸɬɫɹ ɝɨɪɚɡɞɨ ɛɨɥɟɟ ɫɟɪɶɟɡɧɵɟ ɩɪɨɛɥɟɦɵ, ɱɟɦ ɫɧɢɠɟɧɢɟ ɩɪɨ-
ɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɢɡ-ɡɚ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ.
Ɉɞɢɧ ɢɡ ɫɢɦɩɬɨɦɨɜ ɧɟɜɟɪɧɨɝɨ ɭɩɨɬɪɟɛɥɟɧɢɹ ɤɨɞɨɜ ɨɲɢɛɨɤ — ɤɨɝɞɚ ɤɨɞɭ ɩɪɢɥɨɠɟɧɢɹ
ɩɪɢɯɨɞɢɬɫɹ ɩɨɫɬɨɹɧɧɨ ɩɪɨɜɟɪɹɬɶ ɬɪɢɜɢɚɥɶɧɵɟ ɢɫɬɢɧɧɵɟ ɭɫɥɨɜɢɹ, ɥɢɛɨ (ɱɬɨ ɟɳɟ ɯɭɠɟ) ɤɨɝɞɚ
ɩɪɢɥɨɠɟɧɢɟ ɧɟ ɩɪɨɜɟɪɹɟɬ ɤɨɞɵ ɨɲɢɛɨɤ, ɤɨɬɨɪɵɟ ɞɨɥɠɧɨ ɩɪɨɜɟɪɹɬɶ.
ɋɢɦɩɬɨɦ ɡɥɨɭɩɨɬɪɟɛɥɟɧɢɹ ɢɫɤɥɸɱɟɧɢɹɦɢ — ɤɨɝɞɚ ɤɨɞ ɩɪɢɥɨɠɟɧɢɹ ɝɟɧɟɪɢɪɭɟɬ ɢ ɩɟɪɟ-
ɯɜɚɬɵɜɚɟɬ ɢɫɤɥɸɱɟɧɢɹ ɧɚɫɬɨɥɶɤɨ ɱɚɫɬɨ, ɱɬɨ ɤɨɥɢɱɟɫɬɜɚ ɭɫɩɟɲɧɵɯ ɢ ɧɟɭɫɩɟɲɧɵɯ ɜɵɩɨɥɧɟɧɢɣ
try-ɛɥɨɤɚ ɨɤɚɡɵɜɚɸɬɫɹ ɜɟɥɢɱɢɧɚɦɢ ɨɞɧɨɝɨ ɩɨɪɹɞɤɚ. Ɍɚɤɨɣ catch-ɛɥɨɤ ɥɢɛɨ ɜ ɞɟɣɫɬɜɢɬɟɥɶ-
ɧɨɫɬɢ ɨɛɪɚɛɚɬɵɜɚɟɬ ɧɟ ɢɫɬɢɧɧɵɟ ɨɲɢɛɤɢ (ɤɨɬɨɪɵɟ ɧɚɪɭɲɚɸɬ ɩɪɟɞ-, ɩɨɫɬɭɫɥɨɜɢɹ ɢɥɢ ɢɧɜɚɪɢ-
ɚɧɬɵ), ɥɢɛɨ ɭ ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ ɢɦɟɸɬɫɹ ɫɟɪɶɟɡɧɵɟ ɩɪɨɛɥɟɦɵ.
Примеры
ɉɪɢɦɟɪ 1. Ʉɨɧɫɬɪɭɤɬɨɪɵ (ɨɲɢɛɤɚ ɢɧɜɚɪɢɚɧɬɚ). ȿɫɥɢ ɤɨɧɫɬɪɭɤɬɨɪ ɧɟ ɫɩɨɫɨɛɟɧ ɭɫɩɟɲɧɨ
ɫɨɡɞɚɬɶ ɨɛɴɟɤɬ ɫɜɨɟɝɨ ɬɢɩɚ (ɱɬɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɨɧ ɧɟ ɫɩɨɫɨɛɟɧ ɭɫɬɚɧɨɜɢɬɶ ɜɫɟ ɢɧɜɚɪɢɚɧɬɵ ɧɨ-
ɜɨɝɨ ɨɛɴɟɤɬɚ), ɨɧ ɞɨɥɠɟɧ ɫɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ. ȼɟɪɧɨ ɢ ɨɛɪɚɬɧɨɟ — ɢɫɤɥɸɱɟɧɢɟ, ɫɝɟ-
ɧɟɪɢɪɨɜɚɧɧɨɟ ɤɨɧɫɬɪɭɤɬɨɪɨɦ, ɨɡɧɚɱɚɟɬ, ɱɬɨ ɤɨɧɫɬɪɭɢɪɨɜɚɧɢɟ ɨɛɴɟɤɬɚ ɧɟ ɜɵɩɨɥɧɟɧɨ ɢ ɱɬɨ
ɜɪɟɦɹ ɠɢɡɧɢ ɨɛɴɟɤɬɚ ɧɢɤɨɝɞɚ ɧɟ ɧɚɱɢɧɚɥɨɫɶ.
ɉɪɢɦɟɪ 2. ɍɫɩɟɲɧɵɣ ɪɟɤɭɪɫɢɜɧɵɣ ɩɨɢɫɤ ɜ ɞɟɪɟɜɟ. ɉɪɢ ɩɨɢɫɤɟ ɜ ɞɟɪɟɜɟ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
ɪɟɤɭɪɫɢɜɧɨɝɨ ɚɥɝɨɪɢɬɦɚ ɦɨɠɟɬ ɩɨɤɚɡɚɬɶɫɹ ɡɚɦɚɧɱɢɜɨɣ ɢɞɟɹ ɜɟɪɧɭɬɶ ɪɟɡɭɥɶɬɚɬ — ɢ ɥɟɝɤɨ
ɫɜɟɪɧɭɬɶ ɫɬɟɤ — ɝɟɧɟɪɢɪɭɹ ɢɫɤɥɸɱɟɧɢɟ ɫ ɪɟɡɭɥɶɬɚɬɨɦ ɩɨɢɫɤɚ. ɇɨ ɬɚɤ ɞɟɥɚɬɶ ɧɟ ɫɥɟɞɭɟɬ: ɢɫ-
ɤɥɸɱɟɧɢɟ ɨɡɧɚɱɚɟɬ ɨɲɢɛɤɭ, ɚ ɪɟɡɭɥɶɬɚɬ ɩɨɢɫɤɚ ɨɲɢɛɤɨɣ ɧɟ ɹɜɥɹɟɬɫɹ (ɫɦ. [Stroustrup00]).
(Ɂɚɦɟɬɢɦ, ɱɬɨ, ɤɨɧɟɱɧɨ, ɧɟɭɫɩɟɲɧɵɣ ɩɨɢɫɤ ɬɚɤɠɟ ɧɟ ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ ɜ ɤɨɧɬɟɤɫɬɟ ɮɭɧɤɰɢɢ
ɩɨɢɫɤɚ; ɫɦ. ɩɪɢɦɟɪ ɫ ɮɭɧɤɰɢɟɣ find_first_of ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 70.)
Ɉɛɪɚɬɢɬɟɫɶ ɬɚɤɠɟ ɤ ɩɪɢɦɟɪɚɦ ɪɟɤɨɦɟɧɞɚɰɢɢ 70, ɡɚɦɟɧɹɹ ɜ ɢɯ ɬɟɤɫɬɟ “ɫɨɨɛɳɟɧɢɟ ɨɛ
ɨɲɢɛɤɟ” ɧɚ “ɝɟɧɟɪɚɰɢɹ ɢɫɤɥɸɱɟɧɢɹ”.
ȼ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɦɨɠɧɨ ɪɚɫɫɦɨɬɪɟɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɤɨɞɨɜ ɨɲɢɛɨɤ, ɟɫɥɢ
ɨɤɚɡɵɜɚɸɬɫɹ ɜɵɩɨɥɧɟɧɵ ɫɥɟɞɭɸɳɢɟ ɭɫɥɨɜɢɹ.
• ɇɟ ɩɪɢɦɟɧɢɦɵ ɩɪɟɢɦɭɳɟɫɬɜɚ ɢɫɤɥɸɱɟɧɢɣ. ɇɚɩɪɢɦɟɪ, ɜɵ ɡɧɚɟɬɟ, ɱɬɨ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟ-
ɝɞɚ ɨɲɢɛɤɚ ɛɭɞɟɬ ɨɛɪɚɛɚɬɵɜɚɬɶɫɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ, ɬɚɤ ɱɬɨ ɪɚɫ-
ɩɪɨɫɬɪɚɧɟɧɢɟ ɨɲɢɛɤɢ ɧɢɤɨɝɞɚ (ɢɥɢ ɩɪɚɤɬɢɱɟɫɤɢ ɧɢɤɨɝɞɚ) ɧɟ ɛɭɞɟɬ ɜɨɫɬɪɟɛɨɜɚɧɨ. ɗɬɨ
ɜɟɫɶɦɚ ɪɟɞɤɚɹ ɫɢɬɭɚɰɢɹ, ɩɨɫɤɨɥɶɤɭ ɨɛɵɱɧɨ ɜɵɡɵɜɚɟɦɚɹ ɮɭɧɤɰɢɹ ɧɟ ɢɦɟɟɬ ɞɨɫɬɚɬɨɱɧɨɣ
ɢɧɮɨɪɦɚɰɢɢ ɨ ɬɨɦ, ɤɚɤɨɣ ɤɨɞ ɛɭɞɟɬ ɟɟ ɜɵɡɵɜɚɬɶ.
Стр. 156
• ɂɡɦɟɪɟɧɢɹ ɩɨɤɚɡɵɜɚɸɬ ɧɚɥɢɱɢɟ ɪɟɚɥɶɧɨɝɨ ɫɧɢɠɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɩɪɢ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɢ ɢɫɤɥɸɱɟɧɢɣ ɩɨ ɫɪɚɜɧɟɧɢɸ ɫ ɤɨɞɚɦɢ ɨɲɢɛɨɤ. Ɉɛɵɱɧɨ ɬɚɤɨɟ ɫɧɢɠɟɧɢɟ ɩɪɨ-
ɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɫɬɚɧɨɜɢɬɫɹ ɡɚɦɟɬɧɵɦ ɩɪɢ ɱɚɫɬɨɣ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɜɨ ɜɧɭɬɪɟɧ-
ɧɟɦ ɰɢɤɥɟ; ɫɥɟɞɭɟɬ ɧɚɩɨɦɧɢɬɶ, ɱɬɨ ɱɚɫɬɚɹ ɝɟɧɟɪɚɰɢɹ ɢɫɤɥɸɱɟɧɢɣ ɨɛɵɱɧɨ ɝɨɜɨɪɢɬ
ɨ ɬɨɦ, ɱɬɨ ɜ ɤɚɱɟɫɬɜɟ ɨɲɢɛɤɢ ɪɚɫɫɦɚɬɪɢɜɚɟɬɫɹ ɫɢɬɭɚɰɢɹ, ɤɨɬɨɪɚɹ ɨɲɢɛɤɨɣ ɧɟ ɹɜɥɹɟɬɫɹ.
ȼ ɧɟɤɨɬɨɪɵɯ ɨɱɟɧɶ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɧɟɤɨɬɨɪɵɟ ɩɪɨɝɪɚɦɦɵ, ɪɚɛɨɬɚɸɳɢɟ ɜ ɪɟɚɥɶɧɨɦ ɜɪɟ-
ɦɟɧɢ, ɦɨɝɭɬ ɫɨɛɢɪɚɬɶɫɹ ɫ ɨɬɤɥɸɱɟɧɧɨɣ ɨɛɪɚɛɨɬɤɨɣ ɢɫɤɥɸɱɟɧɢɣ ɢɡ-ɡɚ ɬɨɝɨ, ɱɬɨ ɦɟɯɚɧɢɡɦ ɷɬɨɣ
ɨɛɪɚɛɨɬɤɢ, ɩɪɟɞɥɚɝɚɟɦɵɣ ɤɨɦɩɢɥɹɬɨɪɨɦ, ɢɦɟɟɬ ɜ ɯɭɞɲɟɦ ɫɥɭɱɚɟ ɜɪɟɦɹ ɪɚɛɨɬɵ, ɤɨɬɨɪɨɟ ɧɟ
ɩɨɡɜɨɥɹɟɬ ɤɥɸɱɟɜɵɦ ɨɩɟɪɚɰɢɹɦ ɜɵɩɨɥɧɹɬɶɫɹ ɜ ɪɟɚɥɶɧɨɦ ɜɪɟɦɟɧɢ. Ʉɨɧɟɱɧɨ, ɬɚɤɨɟ ɨɬɤɥɸɱɟ-
ɧɢɟ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɹɡɵɤ ɢ ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ ɧɟ ɛɭɞɭɬ ɭɜɟɞɨɦɥɹɬɶ
ɨɛ ɨɲɢɛɤɚɯ ɫɬɚɧɞɚɪɬɧɵɦ ɫɩɨɫɨɛɨɦ (ɢɥɢ ɧɟ ɛɭɞɭɬ ɭɜɟɞɨɦɥɹɬɶ ɨɛ ɨɲɢɛɤɚɯ ɜɨɨɛɳɟ — ɫɦ. ɞɨ-
ɤɭɦɟɧɬɚɰɢɸ ɧɚ ɜɚɲ ɤɨɦɩɢɥɹɬɨɪ), ɢ ɦɟɯɚɧɢɡɦ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɜ ɜɚɲɟɦ ɩɪɨɟɤɬɟ ɞɨɥ-
ɠɟɧ ɛɵɬɶ ɨɫɧɨɜɚɧ ɧɟ ɧɚ ɢɫɤɥɸɱɟɧɢɹɯ, ɚ ɧɚ ɤɨɞɚɯ ɨɲɢɛɨɤ. Ɍɪɭɞɧɨ ɩɪɟɭɜɟɥɢɱɢɬɶ ɜɫɸ ɧɟɠɟɥɚ-
ɬɟɥɶɧɨɫɬɶ ɩɪɢɧɹɬɢɹ ɬɚɤɨɝɨ ɪɟɲɟɧɢɹ. ɉɟɪɟɞ ɬɟɦ ɤɚɤ ɪɟɲɢɬɶɫɹ ɧɚ ɬɚɤɨɣ ɲɚɝ, ɜɵ ɞɨɥɠɧɵ ɞɟ-
ɬɚɥɶɧɨ ɩɪɨɚɧɚɥɢɡɢɪɨɜɚɬɶ, ɤɚɤɢɦ ɨɛɪɚɡɨɦ ɛɭɞɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɭɜɟɞɨɦɥɟɧɢɟ ɨɛ ɨɲɢɛɤɚɯ ɜ ɤɨɧ-
ɫɬɪɭɤɬɨɪɚɯ ɢ ɨɩɟɪɚɬɨɪɚɯ ɢ ɤɚɤ ɩɪɟɞɥɨɠɟɧɧɚɹ ɫɯɟɦɚ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ ɧɚ ɜɚɲɟɦ ɤɨɦɩɢɥɹɬɨɪɟ.
ȿɫɥɢ ɩɨɫɥɟ ɫɟɪɶɟɡɧɨɝɨ ɢ ɝɥɭɛɨɤɨɝɨ ɚɧɚɥɢɡɚ ɜɵ ɜɫɟ ɠɟ ɪɟɲɢɬɟ ɨɬɤɥɸɱɢɬɶ ɦɟɯɚɧɢɡɦ ɨɛɪɚɛɨɬɤɢ
ɢɫɤɥɸɱɟɧɢɣ, ɬɨ ɧɟ ɞɟɥɚɣɬɟ ɷɬɨ ɜɨ ɜɫɟɦ ɩɪɨɟɤɬɟ; ɩɨɫɬɚɪɚɣɬɟɫɶ ɨɝɪɚɧɢɱɢɬɶɫɹ ɤɚɤ ɦɨɠɧɨ ɦɟɧɶ-
ɲɢɦ ɤɨɥɢɱɟɫɬɜɨɦ ɦɨɞɭɥɟɣ, ɫɨɛɪɚɜ ɜ ɧɢɯ ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɟ ɢ ɱɭɜɫɬɜɢɬɟɥɶɧɵɟ ɤɨ ɜɪɟɦɟɧɢ ɜɵ-
ɩɨɥɧɟɧɢɹ ɨɩɟɪɚɰɢɢ.
Ссылки
[Alexandrescu03d] • [Allison98] §13 • [Stroustrup94] §16 • [Stroustrup00] §8.3.3, §14.1, §14.4-5,
§14.9, §E.3.5 • [Sutter00] §8-19, §40-41, §47 • [Sutter02] §17-23 • [Sutter04] §11-16 • [Sutter04b]
72. Для уведомления об ошибках следует использовать исключения 157
Стр. 157
73. Генерируйте исключения по значению,
перехватывайте — по ссылке
Резюме
Ƚɟɧɟɪɢɪɭɣɬɟ ɢɫɤɥɸɱɟɧɢɹ ɩɨ ɡɧɚɱɟɧɢɸ (ɧɟ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɶ) ɢ ɩɟɪɟɯɜɚɬɵɜɚɣɬɟ ɢɯ ɤɚɤ ɫɫɵɥ-
ɤɢ (ɨɛɵɱɧɨ ɤɨɧɫɬɚɧɬɧɵɟ). ɗɬɚ ɤɨɦɛɢɧɚɰɢɹ ɧɚɢɥɭɱɲɢɦ ɨɛɪɚɡɨɦ ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɫɟɦɚɧɬɢɤɟ ɢɫ-
ɤɥɸɱɟɧɢɣ. ɉɪɢ ɩɨɜɬɨɪɧɨɣ ɝɟɧɟɪɚɰɢɢ ɩɟɪɟɯɜɚɱɟɧɧɨɝɨ ɢɫɤɥɸɱɟɧɢɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɢɫɩɨɥɶ-
ɡɨɜɚɬɶ ɩɪɨɫɬɨ ɨɩɟɪɚɬɨɪ throw;, ɚ ɧɟ ɢɧɫɬɪɭɤɰɢɸ throw e;.
ɉɪɢ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɹ ɝɟɧɟɪɢɪɭɣɬɟ ɟɝɨ ɩɨ ɡɧɚɱɟɧɢɸ. ɂɡɛɟɝɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸ-
ɱɟɧɢɟ-ɭɤɚɡɚɬɟɥɶ, ɩɨɫɤɨɥɶɤɭ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɜɚɦ ɩɪɢɞɟɬɫɹ ɫɬɨɥɤɧɭɬɶɫɹ ɫ ɦɚɫɫɨɣ ɜɨɩɪɨɫɨɜ
ɭɩɪɚɜɥɟɧɢɹ ɩɚɦɹɬɶɸ: ɜɵ ɧɟ ɦɨɠɟɬɟ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ-ɭɤɚɡɚɬɟɥɶ ɧɚ ɡɧɚɱɟɧɢɟ ɜ ɫɬɟɤɟ,
ɩɨɫɤɨɥɶɤɭ ɞɨ ɬɨɝɨ, ɤɚɤ ɭɤɚɡɚɬɟɥɶ ɞɨɫɬɢɝɧɟɬ ɬɨɱɤɢ ɧɚɡɧɚɱɟɧɢɹ, ɫɬɟɤ ɛɭɞɟɬ ɫɜɟɪɧɭɬ. ȼɵ ɦɨɠɟɬɟ
ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɟ-ɭɤɚɡɚɬɟɥɶ ɧɚ ɞɢɧɚɦɢɱɟɫɤɢ ɜɵɞɟɥɟɧɧɭɸ ɩɚɦɹɬɶ (ɟɫɥɢ, ɤɨɧɟɱɧɨ,
ɨɲɢɛɤɚ, ɨ ɤɨɬɨɪɨɣ ɜɵ ɫɨɨɛɳɚɟɬɟ, ɧɟ ɫɨɫɬɨɢɬ ɜ ɧɟɯɜɚɬɤɟ ɩɚɦɹɬɢ), ɧɨ ɩɪɢ ɷɬɨɦ ɜɵ ɜɨɡɥɚɝɚɟɬɟ
ɧɚ catch-ɛɥɨɤ ɡɚɞɚɱɭ ɩɨ ɨɫɜɨɛɨɠɞɟɧɢɸ ɜɵɞɟɥɟɧɧɨɣ ɩɚɦɹɬɢ. ȿɫɥɢ ɜɵ ɭɜɟɪɟɧɵ, ɱɬɨ ɜɚɦ ɧɚɞɨ
ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɦɟɧɧɨ ɭɤɚɡɚɬɟɥɶ, ɩɨɞɭɦɚɣɬɟ, ɧɟɥɶɡɹ ɥɢ ɡɚɦɟɧɢɬɶ ɟɝɨ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦ ɭɤɚɡɚ-
ɬɟɥɟɦ ɬɢɩɚ shared_ptr<T> ɜɦɟɫɬɨ ɨɛɵɱɧɨɝɨ T*.
ɉɪɢ ɝɟɧɟɪɚɰɢɢ ɩɨ ɡɧɚɱɟɧɢɸ ɤɨɦɩɢɥɹɬɨɪ ɫɚɦ ɨɬɜɟɱɚɟɬ ɡɚ ɡɚɩɭɬɚɧɧɵɣ ɩɪɨɰɟɫɫ ɭɩɪɚɜɥɟɧɢɹ
ɩɚɦɹɬɶɸ, ɜɵɞɟɥɟɧɧɨɣ ɝɟɧɟɪɢɪɭɟɦɨɦɭ ɨɛɴɟɤɬɭ. ȼɫɟ, ɱɬɨ ɬɪɟɛɭɟɬɫɹ ɨɬ ɜɚɫ, — ɷɬɨ ɩɪɢɧɹɬɶ ɦɟɪɵ
ɞɥɹ ɝɚɪɚɧɬɢɢ ɬɨɝɨ, ɱɬɨ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɤɥɚɫɫɚ ɜɚɲɟɝɨ ɢɫɤɥɸɱɟɧɢɹ ɧɟ ɦɨɠɟɬ ɝɟɧɟ-
ɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 32).
ȿɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ ɝɟɧɟɪɢɪɭɟɬɟ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ ɭɤɚɡɚɬɟɥɶ, ɤɨɬɨɪɵɣ ɞɨɛɚɜɥɹɟɬ ɭɪɨɜɟɧɶ
ɤɨɫɜɟɧɧɨɫɬɢ ɞɥɹ ɫɨɯɪɚɧɟɧɢɹ ɩɨɥɢɦɨɪɮɢɡɦɚ, ɩɟɪɟɯɜɚɬɵɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɫɥɟɞɭɟɬ ɩɨ ɫɫɵɥɤɟ.
ɉɟɪɟɯɜɚɬ ɩɨ ɡɧɚɱɟɧɢɸ ɩɪɢɜɟɞɟɬ ɤ ɫɪɟɡɤɟ ɜ ɬɨɱɤɟ ɩɟɪɟɯɜɚɬɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 54), ɱɬɨ ɥɢɲɢɬ
ɜɚɫ ɨɛɵɱɧɨ ɜɟɫɶɦɚ ɜɚɠɧɨɝɨ ɤɚɱɟɫɬɜɚ ɩɨɥɢɦɨɪɮɢɡɦɚ ɨɛɴɟɤɬɚ ɢɫɤɥɸɱɟɧɢɹ. ɉɟɪɟɯɜɚɬ ɩɨ ɫɫɵɥɤɟ
ɫɨɯɪɚɧɹɟɬ ɩɨɥɢɦɨɪɮɢɡɦ ɨɛɴɟɤɬɚ ɢɫɤɥɸɱɟɧɢɹ.
ɉɪɢ ɩɨɜɬɨɪɧɨɣ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɹ e ɥɭɱɲɟ ɩɪɨɫɬɨ ɩɢɫɚɬɶ ɨɩɟɪɚɬɨɪ throw; ɜɦɟɫɬɨ
ɢɧɫɬɪɭɤɰɢɢ throw e;. Ⱦɟɥɨ ɜ ɬɨɦ, ɱɬɨ ɩɟɪɜɵɣ ɫɩɨɫɨɛ ɜɫɟɝɞɚ ɫɨɯɪɚɧɹɟɬ ɩɨɥɢɦɨɪɮɢɡɦ ɨɛɴɟɤ-
ɬɚ ɩɨɜɬɨɪɧɨ ɝɟɧɟɪɢɪɭɟɦɨɝɨ ɢɫɤɥɸɱɟɧɢɹ.
Примеры
ɉɪɢɦɟɪ. ɉɨɜɬɨɪɧɚɹ ɝɟɧɟɪɚɰɢɹ ɢɡɦɟɧɟɧɧɨɝɨ ɢɫɤɥɸɱɟɧɢɹ. ɉɪɢ ɩɨɜɬɨɪɧɨɣ ɝɟɧɟɪɚɰɢɢ ɩɟɪɟ-
ɯɜɚɱɟɧɧɨɝɨ ɢɫɤɥɸɱɟɧɢɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɨɫɬɨɣ ɨɩɟɪɚɬɨɪ throw;.
catch( MyException& e ) { // ǚǰǻǰȀǭǫǽ ǸǰǵǹǸǼǽǫǸǽǸǹǴ ǼǼȆǶǵǳ
e.AppendContext("ǚǰǻǰȀǭǫǽ");// ǍǸǰǼǰǸǳǰ ǳǲǷǰǸǰǸǳȊ
throw; // ǚǹǭǽǹǻǸǫȊ ǮǰǸǰǻǫȁǳȊ
// ǷǹǯǳǿǳȁǳǻǹǭǫǸǸǹǮǹ ǳǼǵǶȉȂǰǸǳȊ
}
Ссылки
[Dewhurst03] §64-65 • [Meyers96] §13 • [Stroustrup00] §14.3 • [Vandevoorde03] §20
Стр. 158
74. Уведомляйте об ошибках, обрабатывайте
и преобразовывайте их там, где следует
Резюме
ɋɨɨɛɳɚɣɬɟ ɨɛ ɨɲɢɛɤɚɯ ɜ ɬɨɬ ɦɨɦɟɧɬ, ɤɨɝɞɚ ɨɧɢ ɨɛɧɚɪɭɠɟɧɵ ɢ ɢɞɟɧɬɢɮɢɰɢɪɨɜɚɧɵ ɤɚɤ
ɨɲɢɛɤɢ. Ɉɛɪɚɛɚɬɵɜɚɣɬɟ ɢɥɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɢɯ ɧɚ ɫɚɦɨɦ ɧɢɠɧɟɦ ɭɪɨɜɧɟ, ɧɚ ɤɨɬɨɪɨɦ ɷɬɨ
ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɤɨɪɪɟɤɬɧɨ.
ɋɨɨɛɳɚɣɬɟ ɨɛ ɨɲɢɛɤɟ (ɬ.ɟ. ɩɢɲɢɬɟ throw) ɬɚɦ, ɝɞɟ ɮɭɧɤɰɢɹ ɨɛɧɚɪɭɠɢɜɚɟɬ ɨɲɢɛɤɭ, ɤɨɬɨ-
ɪɭɸ ɧɟ ɦɨɠɟɬ ɪɚɡɪɟɲɢɬɶ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɢ ɤɨɬɨɪɚɹ ɞɟɥɚɟɬ ɧɟɜɨɡɦɨɠɧɵɦ ɩɪɨɞɨɥɠɟɧɢɟ ɜɵ-
ɩɨɥɧɟɧɢɹ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 70).
Ɉɛɪɚɛɚɬɵɜɚɣɬɟ ɨɲɢɛɤɭ (ɬ.ɟ. ɩɢɲɢɬɟ catch, ɤɨɬɨɪɵɣ ɧɟ ɝɟɧɟɪɢɪɭɟɬ ɩɨɜɬɨɪɧɨ ɬɨ ɠɟ ɢɥɢ
ɢɧɨɟ ɢɫɤɥɸɱɟɧɢɟ ɢ ɧɟ ɢɫɩɨɥɶɡɭɟɬ ɢɧɨɣ ɫɩɨɫɨɛ ɞɥɹ ɞɚɥɶɧɟɣɲɟɝɨ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɟ, ɧɚ-
ɩɪɢɦɟɪ, ɤɨɞ ɨɲɢɛɤɢ) ɬɚɦ, ɝɞɟ ɜɵ ɨɛɥɚɞɚɟɬɟ ɞɨɫɬɚɬɨɱɧɨɣ ɢɧɮɨɪɦɚɰɢɟɣ, ɱɬɨɛɵ ɟɟ ɨɛɪɚɛɨɬɚɬɶ,
ɜ ɬɨɦ ɱɢɫɥɟ ɞɥɹ ɨɛɟɫɩɟɱɟɧɢɹ ɝɪɚɧɢɰ, ɨɩɪɟɞɟɥɟɧɧɵɯ ɫɬɪɚɬɟɝɢɟɣ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ (ɧɚɩɪɢɦɟɪ,
ɝɪɚɧɢɰ ɮɭɧɤɰɢɢ main ɢɥɢ ɩɨɬɨɤɨɜ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 62) ɢ ɞɥɹ ɩɨɝɥɨɳɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ ɜ
ɬɟɥɚɯ ɞɟɫɬɪɭɤɬɨɪɨɜ ɢ ɮɭɧɤɰɢɣ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ.
ɉɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɨɲɢɛɤɭ (ɬ.ɟ. ɩɢɲɢɬɟ catch, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɧɨɟ ɢɫɤɥɸ-
ɱɟɧɢɟ ɢɥɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɧɨɣ ɫɩɨɫɨɛ ɞɥɹ ɞɚɥɶɧɟɣɲɟɝɨ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɟ, ɧɚɩɪɢɦɟɪ, ɤɨɞ
ɨɲɢɛɤɢ) ɜ ɫɥɟɞɭɸɳɢɯ ɨɛɫɬɨɹɬɟɥɶɫɬɜɚɯ.
• Ⱦɥɹ ɞɨɛɚɜɥɟɧɢɹ ɜɵɫɨɤɨɭɪɨɜɧɟɜɨɝɨ ɫɟɦɚɧɬɢɱɟɫɤɨɝɨ ɡɧɚɱɟɧɢɹ. ɇɚɩɪɢɦɟɪ, ɜ ɬɟɤɫɬɨɜɨɦ
ɪɟɞɚɤɬɨɪɟ ɮɭɧɤɰɢɹ Document::Open ɦɨɠɟɬ ɩɪɢɧɢɦɚɬɶ ɧɢɡɤɨɭɪɨɜɧɟɜɭɸ ɨɲɢɛɤɭ
“ɧɟɨɠɢɞɚɧɧɨɟ ɨɤɨɧɱɚɧɢɟ ɮɚɣɥɚ” ɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶ ɟɟ ɜ ɨɲɢɛɤɭ “ɧɟɜɟɪɧɵɣ ɢɥɢ ɩɨ-
ɜɪɟɠɞɟɧɧɵɣ ɞɨɤɭɦɟɧɬ”, ɞɨɛɚɜɥɹɹ ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ ɫɟɦɚɧɬɢɱɟɫɤɭɸ ɢɧɮɨɪɦɚɰɢɸ.
• Ⱦɥɹ ɢɡɦɟɧɟɧɢɹ ɦɟɯɚɧɢɡɦɚ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ. ɇɚɩɪɢɦɟɪ, ɜ ɦɨɞɭɥɟ, ɤɨɬɨɪɵɣ ɜɧɭɬɪɟɧɧɟ
ɢɫɩɨɥɶɡɭɟɬ ɢɫɤɥɸɱɟɧɢɹ, ɧɨ ɱɟɣ API ɜ ɫɬɢɥɟ C ɫɨɨɛɳɚɟɬ ɨɛ ɨɲɢɛɤɚɯ ɩɨɫɪɟɞɫɬɜɨɦ ɤɨ-
ɞɨɜ ɨɲɢɛɨɤ, ɮɭɧɤɰɢɢ API ɞɨɥɠɧɵ ɩɟɪɟɯɜɚɬɵɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɢ ɜɨɡɜɪɚɳɚɬɶ ɞɨɤɭɦɟɧ-
ɬɢɪɨɜɚɧɧɵɟ ɤɨɞɵ ɨɲɢɛɤɢ, ɩɨɧɹɬɧɵɟ ɜɵɡɵɜɚɸɳɟɦɭ ɤɨɞɭ.
Ʉɨɞ ɧɟ ɞɨɥɠɟɧ ɩɟɪɟɯɜɚɬɵɜɚɬɶ ɨɲɢɛɤɭ, ɟɫɥɢ ɤɨɧɬɟɤɫɬ ɧɟ ɩɨɡɜɨɥɹɟɬ ɟɦɭ ɫɞɟɥɚɬɶ ɫ ɧɟɣ ɱɬɨ-
ɥɢɛɨ ɩɨɥɟɡɧɨɟ. ȿɫɥɢ ɮɭɧɤɰɢɹ ɧɟ ɦɨɠɟɬ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɨɛɪɚɛɨɬɚɬɶ ɨɲɢɛɤɭ (ɜɨɡɦɨɠɧɨ, ɩɪɟ-
ɨɛɪɚɡɨɜɚɬɶ ɢɥɢ ɫɨɡɧɚɬɟɥɶɧɨ ɩɨɝɥɨɬɢɬɶ ɟɟ), ɬɨ ɨɧɚ ɧɟ ɞɨɥɠɧɚ ɦɟɲɚɬɶ ɨɲɢɛɤɟ ɪɚɫɩɪɨɫɬɪɚɧɹɬɶ-
ɫɹ ɞɚɥɟɟ, ɱɬɨɛɵ ɞɨɫɬɢɱɶ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ, ɤɨɬɨɪɵɣ ɫɦɨɠɟɬ ɟɟ ɨɛɪɚɛɨɬɚɬɶ.
ɂɧɨɝɞɚ ɨɤɚɡɵɜɚɟɬɫɹ ɩɨɥɟɡɧɵɦ ɩɟɪɟɯɜɚɬɢɬɶ ɢ ɩɨɜɬɨɪɧɨ ɝɟɧɟɪɢɪɨɜɚɬɶ ɬɭ ɠɟ ɨɲɢɛɤɭ (ɬ.ɟ. ɜɨɫ-
ɩɨɥɶɡɨɜɚɬɶɫɹ catch ɫ ɩɨɫɥɟɞɭɸɳɢɦ throw) ɞɥɹ ɤɨɧɬɪɨɥɹ ɡɚ ɨɲɢɛɤɚɦɢ, ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ
ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɤɢ ɩɪɢ ɷɬɨɦ ɧɟ ɩɪɨɢɫɯɨɞɢɬ.
Ссылки
[Stroustrup00] §3.7.2, §14.7, §14.9 • [Sutter00] §8 • [Sutter04] §11 • [Sutter04b]
74. Уведомляйте об ошибках, обрабатывайте и преобразовывайте их там, где следует 159
Стр. 159
75. Избегайте спецификаций исключений
Резюме
ɇɟ ɩɢɲɢɬɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ ɭ ɜɚɲɢɯ ɮɭɧɤɰɢɣ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɚɫ ɧɟ ɡɚɫɬɚɜɥɹɸɬ
ɷɬɨ ɞɟɥɚɬɶ ɜɧɟɲɧɢɟ ɨɛɫɬɨɹɬɟɥɶɫɬɜɚ (ɧɚɩɪɢɦɟɪ, ɤɨɞ, ɤɨɬɨɪɵɣ ɜɵ ɧɟ ɦɨɠɟɬɟ ɢɡɦɟɧɢɬɶ, ɭɠɟ
ɜɜɟɥ ɢɯ; ɫɦ. ɢɫɤɥɸɱɟɧɢɹ ɤ ɞɚɧɧɨɦɭ ɪɚɡɞɟɥɭ).
ȿɫɥɢ ɝɨɜɨɪɢɬɶ ɤɨɪɨɬɤɨ — ɧɟ ɛɟɫɩɨɤɨɣɬɟɫɶ ɨ ɫɩɟɰɢɮɢɤɚɰɢɹɯ ɢɫɤɥɸɱɟɧɢɣ. Ɉɫɧɨɜɧɚɹ ɩɪɨ-
ɛɥɟɦɚ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɜɫɟɝɨ ɥɢɲɶ “ɹɤɨɛɵ” ɹɜɥɹɸɬɫɹ ɫɨ-
ɫɬɚɜɧɨɣ ɱɚɫɬɶɸ ɫɢɫɬɟɦɵ ɬɢɩɨɜ. Ɉɧɢ ɧɟ ɞɟɥɚɸɬ ɬɨɝɨ, ɱɬɨ ɨɬ ɧɢɯ ɨɠɢɞɚɟɬ ɛɨɥɶɲɢɧɫɬɜɨ ɩɪɨ-
ɝɪɚɦɦɢɫɬɨɜ, ɢ ɜɚɦ ɩɨɱɬɢ ɧɢɤɨɝɞɚ ɧɟ ɧɚɞɨ ɬɨ, ɱɬɨ ɨɧɢ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɞɟɥɚɸɬ.
ɋɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɧɟ ɹɜɥɹɸɬɫɹ ɱɚɫɬɶɸ ɬɢɩɚ ɮɭɧɤɰɢɢ ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɬɟɯ ɫɥɭɱɚɟɜ,
ɤɨɝɞɚ ɨɧɢ ɬɚɤɢ ɟɸ ɹɜɥɹɸɬɫɹ. ɗɬɨ ɧɟ ɲɭɬɤɚ — ɨɧɢ ɩɨ ɫɭɬɢ ɨɛɪɚɡɭɸɬ “ɬɟɧɟɜɭɸ” ɫɢɫɬɟɦɭ ɬɢɩɨɜ,
ɢɡ-ɡɚ ɱɟɝɨ ɧɚɩɢɫɚɧɢɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ ɜ ɪɚɡɧɵɯ ɦɟɫɬɚɯ ɩɪɨɝɪɚɦɦɵ ɨɤɚɡɵɜɚɟɬɫɹ:
• ɧɟɜɟɪɧɵɦ — ɜ ɢɧɫɬɪɭɤɰɢɢ typedef ɞɥɹ ɭɤɚɡɚɬɟɥɹ ɧɚ ɮɭɧɤɰɢɸ;
• ɪɚɡɪɟɲɟɧɧɵɦ — ɜ ɬɨɱɧɨ ɬɚɤɨɦ ɠɟ ɤɨɞɟ, ɧɨ ɛɟɡ ɢɫɩɨɥɶɡɨɜɚɧɢɹ typedef;
• ɧɟɨɛɯɨɞɢɦɵɦ — ɜ ɨɛɴɹɜɥɟɧɢɢ ɜɢɪɬɭɚɥɶɧɨɣ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɚɹ ɩɟɪɟɤɪɵɜɚɟɬ ɜɢɪɬɭɚɥɶ-
ɧɭɸ ɮɭɧɤɰɢɸ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɫɨ ɫɩɟɰɢɮɢɤɚɰɢɟɣ ɢɫɤɥɸɱɟɧɢɣ;
• ɧɟɹɜɧɵɦ ɢ ɚɜɬɨɦɚɬɢɱɟɫɤɢɦ — ɜ ɨɛɴɹɜɥɟɧɢɢ ɤɨɧɫɬɪɭɤɬɨɪɨɜ, ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚ-
ɧɢɹ, ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ ɢ ɞɟɫɬɪɭɤɬɨɪɨɜ, ɤɨɝɞɚ ɨɧɢ ɧɟɹɜɧɨ ɝɟɧɟɪɢɪɭɸɬɫɹ ɤɨɦɩɢ-
ɥɹɬɨɪɨɦ.
ȼɟɫɶɦɚ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ, ɧɨ ɬɟɦ ɧɟ ɦɟɧɟɟ ɧɟ ɜɟɪɧɵɦ ɹɜɥɹɟɬɫɹ ɭɛɟɠɞɟɧɢɟ ɨ ɬɨɦ, ɱɬɨ
ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɫɬɚɬɢɱɟɫɤɢ ɝɚɪɚɧɬɢɪɭɸɬ, ɱɬɨ ɮɭɧɤɰɢɢ ɛɭɞɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɬɨɥɶɤɨ
ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɢɫɤɥɸɱɟɧɢɹ (ɜɨɡɦɨɠɧɨ, ɧɟ ɛɭɞɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ ɜɨɨɛɳɟ), ɱɬɨ ɩɨ-
ɡɜɨɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ ɜɵɩɨɥɧɢɬɶ ɨɩɬɢɦɢɡɚɰɢɸ ɧɚ ɨɫɧɨɜɟ ɞɚɧɧɨɣ ɝɚɪɚɧɬɢɢ.
ȼ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɠɟ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɞɟɥɚɸɬ ɧɟɱɬɨ ɜɪɨɞɟ ɛɵ ɢ ɧɟɡɧɚɱɢɬɟɥɶ-
ɧɨɟ, ɧɨ ɮɭɧɞɚɦɟɧɬɚɥɶɧɨ ɨɬɥɢɱɚɸɳɟɟɫɹ: ɨɧɢ ɡɚɫɬɚɜɥɹɸɬ ɤɨɦɩɢɥɹɬɨɪ ɜɜɟɫɬɢ ɜ ɩɪɨɝɪɚɦɦɭ ɞɨ-
ɩɨɥɧɢɬɟɥɶɧɵɣ ɤɨɞ ɜ ɮɨɪɦɟ ɧɟɹɜɧɵɯ ɛɥɨɤɨɜ try/catch ɜɨɤɪɭɝ ɬɟɥɚ ɮɭɧɤɰɢɢ ɞɥɹ ɨɛɟɫɩɟɱɟɧɢɹ
ɩɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɬɨɝɨ, ɱɬɨ ɮɭɧɤɰɢɹ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɝɟɧɟɪɢɪɭɟɬ ɬɨɥɶɤɨ ɩɟɪɟɱɢɫ-
ɥɟɧɧɵɟ ɢɫɤɥɸɱɟɧɢɹ ɢɥɢ ɧɟ ɝɟɧɟɪɢɪɭɟɬ ɢɯ ɜɨɨɛɳɟ, ɤɪɨɦɟ ɬɟɯ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪ ɦɨ-
ɠɟɬ ɫɬɚɬɢɱɟɫɤɢ ɞɨɤɚɡɚɬɶ, ɱɬɨ ɫɩɟɰɢɮɢɤɚɰɢɹ ɢɫɤɥɸɱɟɧɢɣ ɧɢɤɨɝɞɚ ɧɟ ɛɭɞɟɬ ɧɚɪɭɲɟɧɚ. ȼ ɩɨ-
ɫɥɟɞɧɟɦ ɫɥɭɱɚɟ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɨɩɬɢɦɢɡɢɪɨɜɚɬɶ ɤɨɞ, ɭɛɪɚɜ ɨɩɢɫɚɧɧɭɸ ɩɪɨɜɟɪɤɭ. ɋɩɟɰɢ-
ɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ, ɤɪɨɦɟ ɬɨɝɨ, ɦɨɝɭɬ ɩɨɦɟɲɚɬɶ ɞɚɥɶɧɟɣɲɟɣ ɨɩɬɢɦɢɡɚɰɢɢ ɤɨɞɚ ɤɨɦɩɢɥɹ-
ɬɨɪɨɦ — ɬɚɤ, ɧɚɩɪɢɦɟɪ, ɧɟɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪɵ ɧɟ ɦɨɝɭɬ ɞɟɥɚɬɶ ɜɫɬɪɚɢɜɚɟɦɵɦɢ ɮɭɧɤɰɢɢ,
ɢɦɟɸɳɢɟ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ.
Ɉɞɧɚɤɨ ɯɭɠɟ ɜɫɟɝɨ ɬɨ, ɱɬɨ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ — ɨɱɟɧɶ “ɬɭɩɨɣ” ɢɧɫɬɪɭɦɟɧɬ: ɩɪɢ
ɧɚɪɭɲɟɧɢɢ ɨɧɢ ɩɨ ɭɦɨɥɱɚɧɢɸ ɧɟɦɟɞɥɟɧɧɨ ɩɪɟɤɪɚɳɚɸɬ ɜɵɩɨɥɧɟɧɢɟ ɩɪɨɝɪɚɦɦɵ. ȼɵ ɦɨɠɟɬɟ
ɡɚɪɟɝɢɫɬɪɢɪɨɜɚɬɶ ɮɭɧɤɰɢɸ-ɨɛɪɚɛɨɬɱɢɤ ɞɚɧɧɨɝɨ ɧɚɪɭɲɟɧɢɹ, ɧɨ ɷɬɨɬ ɜɪɹɞ ɥɢ ɜɚɦ ɩɨɦɨɠɟɬ,
ɩɨɫɤɨɥɶɤɭ ɬɚɤɨɣ ɨɛɪɚɛɨɬɱɢɤ ɬɨɥɶɤɨ ɨɞɢɧ ɧɚ ɜɫɸ ɩɪɨɝɪɚɦɦɭ, ɢ ɜɫɟ, ɱɬɨ ɨɧ ɦɨɠɟɬ ɫɞɟɥɚɬɶ ɞɥɹ
ɬɨɝɨ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɦɟɞɥɟɧɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɩɪɨɝɪɚɦɦɵ, — ɷɬɨ ɫɝɟɧɟɪɢɪɨɜɚɬɶ ɞɨɩɭɫɬɢ-
ɦɨɟ ɢɫɤɥɸɱɟɧɢɟ. ɇɨ, ɧɚɩɨɦɧɢɦ, ɬɚɤɨɣ ɨɛɪɚɛɨɬɱɢɤ — ɟɞɢɧɫɬɜɟɧɧɵɣ ɞɥɹ ɜɫɟɝɨ ɩɪɢɥɨɠɟɧɢɹ,
ɬɚɤ ɱɬɨ ɬɪɭɞɧɨ ɩɪɟɞɫɬɚɜɢɬɶ, ɤɚɤ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɱɬɨ-ɬɨ ɩɨɥɟɡɧɨɟ ɜ ɬɚɤɨɣ ɫɢɬɭɚɰɢɢ ɢɥɢ ɤɚɤ ɭɡ-
ɧɚɬɶ, ɤɚɤɨɟ ɢɫɤɥɸɱɟɧɢɟ ɦɨɠɧɨ ɩɨɜɬɨɪɧɨ ɫɝɟɧɟɪɢɪɨɜɚɬɶ ɜ ɧɟɦ ɛɟɡ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɜɨ ɜɫɟ ɫɩɟ-
ɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ (ɧɚɩɪɢɦɟɪ, ɨɩɪɟɞɟɥɢɬɶ, ɱɬɨ ɜɫɟ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɞɨɥɠɧɵ
Стр. 160
ɜɤɥɸɱɚɬɶ ɧɟɤɨɬɨɪɨɟ ɨɛɳɟɟ ɢɫɤɥɸɱɟɧɢɟ UnknownException, ɝɟɧɟɪɢɪɭɟɦɨɟ ɨɛɪɚɛɨɬɱɢɤɨɦ.
Ɂɚɦɟɬɢɦ, ɱɬɨ ɷɬɨ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɭɧɢɱɬɨɠɢɬ ɜɫɟ ɩɪɟɢɦɭɳɟɫɬɜɚ ɨɬ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɫɩɟɰɢɮɢɤɚ-
ɰɢɣ ɢɫɤɥɸɱɟɧɢɣ).
Ɉɛɵɱɧɨ ɜɵ ɧɟ ɦɨɠɟɬɟ ɩɢɫɚɬɶ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɞɥɹ ɲɚɛɥɨɧɨɜ ɮɭɧɤɰɢɣ, ɩɨ-
ɫɤɨɥɶɤɭ ɜɵ ɧɟ ɦɨɠɟɬɟ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ ɫɤɚɡɚɬɶ ɡɚɪɚɧɟɟ, ɤɚɤɢɟ ɬɢɩɵ ɢɫɤɥɸɱɟɧɢɣ ɦɨɝɭɬ ɫɝɟɧɟ-
ɪɢɪɨɜɚɬɶ ɬɢɩɵ, ɫ ɤɨɬɨɪɵɦɢ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ ɲɚɛɥɨɧ.
ɋɧɢɠɟɧɢɟ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɜ ɨɛɦɟɧ ɧɚ ɜɜɟɞɟɧɢɟ ɨɝɪɚɧɢɱɟɧɢɣ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟɝɞɚ ɛɟɫ-
ɩɨɥɟɡɧɨ. ɗɬɨ ɨɬɥɢɱɧɵɣ ɩɪɢɦɟɪ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).
ɇɟɬ ɩɪɨɫɬɨɝɨ ɩɭɬɢ ɪɟɲɟɧɢɹ ɨɩɢɫɚɧɧɵɯ ɜ ɞɚɧɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɩɪɨɛɥɟɦ. ȼ ɱɚɫɬɧɨɫɬɢ,
ɩɪɨɛɥɟɦɵ ɧɟ ɪɟɲɚɸɬɫɹ ɩɭɬɟɦ ɩɟɪɟɯɨɞɚ ɤ ɫɬɚɬɢɱɟɫɤɢɦ ɩɪɨɜɟɪɤɚɦ. ɉɪɨɝɪɚɦɦɢɫɬɵ ɱɚɫɬɨ ɩɪɟɞ-
ɥɚɝɚɸɬ ɩɟɪɟɣɬɢ ɨɬ ɞɢɧɚɦɢɱɟɫɤɨɣ ɩɪɨɜɟɪɤɢ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ ɤ ɫɬɚɬɢɱɟɫɤɨɣ, ɤɚɤ ɷɬɨ
ɞɟɥɚɟɬɫɹ ɜ Java ɢ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɷɬɨ ɩɪɨɫɬɨ ɨɡɧɚɱɚɟɬ ɩɨ-
ɦɟɧɹɬɶ ɲɢɥɨ ɧɚ ɦɵɥɨ, ɬ.ɟ. ɨɞɢɧ ɪɹɞ ɩɪɨɛɥɟɦ ɧɚ ɞɪɭɝɨɣ. ɉɨɥɶɡɨɜɚɬɟɥɢ ɹɡɵɤɨɜ ɫɨ ɫɬɚɬɢɱɟɫɤɨɣ
ɩɪɨɜɟɪɤɨɣ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ ɧɟ ɦɟɧɟɟ ɱɚɫɬɨ ɩɪɟɞɥɚɝɚɸɬ ɩɟɪɟɣɬɢ ɤ ɞɢɧɚɦɢɱɟɫɤɨɣ
ɩɪɨɜɟɪɤɟ…
ȿɫɥɢ ɜɵ ɩɟɪɟɤɪɵɜɚɟɬɟ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ, ɤɨɬɨɪɚɹ ɭɠɟ ɢɦɟɟɬ ɫɩɟɰɢ-
ɮɢɤɚɰɢɸ ɢɫɤɥɸɱɟɧɢɣ, ɢ ɭ ɜɚɫ ɧɟɬ ɜɨɡɦɨɠɧɨɫɬɢ ɜɧɟɫɬɢ ɢɡɦɟɧɟɧɢɹ ɜ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɢ ɭɛɪɚɬɶ
ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ (ɢɥɢ ɭɛɟɞɢɬɶ ɫɞɟɥɚɬɶ ɷɬɨ ɚɜɬɨɪɚ ɤɥɚɫɫɚ), ɬɨ ɜɵ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ ɫɨɜɦɟɫɬɢɦɭɸ ɫɩɟɰɢɮɢɤɚɰɢɸ ɢɫɤɥɸɱɟɧɢɣ ɜ ɜɚɲɟɣ ɩɟɪɟɤɪɵɜɚɸɳɟɣ ɮɭɧɤɰɢɢ, ɩɪɢɱɟɦ
ɫɥɟɞɭɟɬ ɫɞɟɥɚɬɶ ɟɟ ɧɟ ɦɟɧɟɟ ɨɝɪɚɧɢɱɢɜɚɸɳɟɣ, ɱɟɦ ɜ ɛɚɡɨɜɨɣ ɜɟɪɫɢɢ, ɱɬɨɛɵ ɦɢɧɢɦɢɡɢɪɨɜɚɬɶ
ɜɨɡɦɨɠɧɨɫɬɶ ɧɚɪɭɲɟɧɢɣ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ:
class Base { // ... // Ǎ ȂǾǱǹǷ ǵǶǫǼǼǰ ǳǷǰǰǽǼȊ
virtual f() // ǼǺǰȁǳǿǳǵǫȁǳȊ ǳǼǵǶȉȂǰǸǳǴ,
throw(X, Y, Z); // ǳ ǰǼǶǳ ǭȆ Ǹǰ ǷǹǱǰǽǰ
}; // ǰǰ ǾǯǫǶǳǽȇ...
class MyDerived
: public Base { // ... // ... ǽǹ ǭ ǭǫȃǰǷ ǵǶǫǼǼǰ Ǻǻǳ
virtual f() // ǺǰǻǰǮǻǾǲǵǰ ǿǾǸǵȁǳǳ ǹǸǫ ǯǹǶǱǸǫ
throw(X, Y, Z); // ǳǷǰǽȇ ǼǹǭǷǰǼǽǳǷǾȉ (ǱǰǶǫǽǰǶȇǸǹ
}; // ǳǯǰǸǽǳȂǸǾȉ) ǼǺǰȁǳǿǳǵǫȁǳȉ ǳǼǵǶȉȂǰǸǳǴ
ɂɡ ɨɩɵɬɚ [BoostLRG] ɫɥɟɞɭɟɬ, ɱɬɨ ɬɨɥɶɤɨ ɩɭɫɬɵɟ ɫɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ (ɬ.ɟ. throw())
ɭ ɧɟɜɫɬɪɚɢɜɚɟɦɵɯ ɮɭɧɤɰɢɣ “ɦɨɝɭɬ ɞɚɜɚɬɶ ɧɟɤɨɬɨɪɨɟ ɩɪɟɢɦɭɳɟɫɬɜɨ ɭ ɧɟɤɨɬɨɪɵɯ ɤɨɦɩɢɥɹɬɨɪɨɜ”.
ɇɟ ɫɥɢɲɤɨɦ ɨɩɬɢɦɢɫɬɢɱɧɨɟ ɡɚɹɜɥɟɧɢɟ ɞɥɹ ɨɞɧɨɝɨ ɢɡ ɧɚɢɛɨɥɟɟ ɩɪɨɞɜɢɧɭɬɵɯ, ɪɚɡɪɚɛɚɬɵɜɚɟɦɨɝɨ
ɷɤɫɩɟɪɬɚɦɢ ɦɢɪɨɜɨɝɨ ɭɪɨɜɧɹ ɩɪɨɟɤɬɚ…
Ссылки
[BoostLRG] • [Stroustrup00] §14.1, §14.6 • [Sutter04] §13
75. Избегайте спецификаций исключений 161
Стр. 161
Стр. 162
STL: контейнеры
ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ ɤɨɧɬɟɣɧɟɪ, ɩɨ ɭɦɨɥɱɚɧɢɸ ɢɫɩɨɥɶɡɭɣɬɟ vector.
Ɇɵ ɡɧɚɟɦ, ɱɬɨ ɜɵ ɭɠɟ ɩɪɟɞɩɨɱɢɬɚɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɬɚɧɞɚɪɬɧɵɟ ɤɨɧɬɟɣɧɟɪɵ ɜɦɟɫɬɨ ɧɚɩɢ-

ɫɚɧɧɵɯ ɜɪɭɱɧɭɸ. ɇɨ ɤɚɤɨɣ ɢɦɟɧɧɨ ɤɨɧɬɟɣɧɟɪ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ? ɑɬɨ ɞɨɥɠɧɨ (ɢ ɱɬɨ ɧɟ
ɞɨɥɠɧɨ) ɯɪɚɧɢɬɶɫɹ ɜ ɤɨɧɬɟɣɧɟɪɚɯ ɢ ɩɨɱɟɦɭ? Ʉɚɤ ɫɥɟɞɭɟɬ ɡɚɩɨɥɧɹɬɶ ɤɨɧɬɟɣɧɟɪɵ? Ʉɚɤɢɟ ɜɚɠ-
ɧɵɟ ɢɞɢɨɦɵ ɧɚɞɨ ɡɧɚɬɶ?
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɢɦɟɸɬɫɹ ɨɬɜɟɬɵ ɧɚ ɜɫɟ ɩɟɪɟɱɢɫɥɟɧɧɵɟ (ɢ ɧɟ ɬɨɥɶɤɨ) ɜɨɩɪɨɫɵ. ɂ ɧɟ ɫɥɭ-
ɱɚɣɧɨ, ɱɬɨ ɬɪɢ ɩɟɪɜɵɟ ɪɟɤɨɦɟɧɞɚɰɢɢ ɜ ɧɟɦ ɫɨɞɟɪɠɚɬ ɫɥɨɜɚ “ɂɫɩɨɥɶɡɭɣɬɟ vector…”.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 79 — “ɏɪɚɧɢɬɟ ɜ ɤɨɧɬɟɣ-
ɧɟɪɚɯ ɬɨɥɶɤɨ ɡɧɚɱɟɧɢɹ ɢɥɢ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ”. Ʉ ɧɟɣ ɦɵ ɞɨɛɚɜɢɦ — ɟɫɥɢ ɞɚɠɟ ɜɵ
ɧɟ ɩɥɚɧɢɪɭɟɬɟ ɩɪɢɦɟɧɹɬɶ [Boost] ɢ [C++TR104] ɞɥɹ ɢɧɵɯ ɰɟɥɟɣ, ɜɫɟ ɪɚɜɧɨ ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɢɯ
ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦ ɭɤɚɡɚɬɟɥɟɦ shared_ptr.
75. Избегайте спецификаций исключений 163
Стр. 163
76. По умолчанию используйте vector ...
76. По умолчанию используйте vector.

В противном случае выбирайте
контейнер, соответствующий задаче
76. По умолчанию используйте vector ...
Резюме
Ɉɱɟɧɶ ɜɚɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ “ɩɪɚɜɢɥɶɧɵɣ ɤɨɧɬɟɣɧɟɪ”. ȿɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɜɟɫɨɦɵɟ ɩɪɢɱɢɧɵ
ɜɵɛɪɚɬɶ ɨɩɪɟɞɟɥɟɧɧɵɣ ɬɢɩ ɤɨɧɬɟɣɧɟɪɚ, ɢɫɩɨɥɶɡɭɣɬɟ ɬɨɬ ɤɨɧɬɟɣɧɟɪ, ɤɨɬɨɪɵɣ ɧɚɢɛɨɥɟɟ ɩɨɞ-
ɯɨɞɢɬ ɞɥɹ ɜɚɲɟɣ ɡɚɞɚɱɢ.
ȿɫɥɢ ɤɨɧɤɪɟɬɧɵɯ ɩɪɟɞɩɨɱɬɟɧɢɣ ɧɟɬ, ɜɨɡɶɦɢɬɟ vector ɢ ɫɩɨɤɨɣɧɨ ɪɚɛɨɬɚɣɬɟ, ɡɧɚɹ, ɱɬɨ ɜɵ
ɫɞɟɥɚɥɢ ɜɟɪɧɵɣ ɜɵɛɨɪ.
ɇɢɠɟ ɩɪɟɞɫɬɚɜɥɟɧɵ ɬɪɢ ɝɥɚɜɧɵɯ ɚɫɩɟɤɬɚ, ɤɨɬɨɪɵɟ ɤɚɫɚɸɬɫɹ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɜɨɨɛɳɟ,
ɢ ɜɵɛɨɪɚ ɤɨɧɬɟɣɧɟɪɚ ɜ ɱɚɫɬɧɨɫɬɢ.
• ɋɥɟɞɭɟɬ ɩɢɫɚɬɶ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɤɨɪɪɟɤɬɧɵɣ, ɩɪɨɫɬɨɣ ɢ ɩɨɧɹɬɧɵɣ ɤɨɞ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 6). ɉɪɟɞɩɨɱɬɢɬɟɥɟɧ ɜɵɛɨɪ ɤɨɧɬɟɣɧɟɪɚ, ɤɨɬɨɪɵɣ ɩɨɡɜɨɥɢɬ ɜɚɦ ɧɚɩɢɫɚɬɶ
ɧɚɢɛɨɥɟɟ ɩɨɧɹɬɧɵɣ ɤɨɞ. Ɍɚɤ, ɟɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɜɫɬɚɜɤɚ ɜ ɨɩɪɟɞɟɥɟɧɧɭɸ ɩɨɡɢɰɢɸ, ɢɫ-
ɩɨɥɶɡɭɣɬɟ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɤɨɧɬɟɣɧɟɪ (ɧɚɩɪɢɦɟɪ, vector, list). ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ
ɢɬɟɪɚɬɨɪ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ, ɜɵɛɟɪɢɬɟ vector, deque ɢɥɢ string. ȿɫɥɢ ɧɭɠɟɧ
ɫɥɨɜɚɪɧɵɣ ɩɨɢɫɤ ɧɚɩɨɞɨɛɢɟ c[0] = 42;, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɚɫɫɨɰɢɚɬɢɜɧɵɦ ɤɨɧɬɟɣɧɟ-
ɪɨɦ (ɧɚɩɪɢɦɟɪ, set, map) — ɧɨ ɟɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɭɩɨɪɹɞɨɱɟɧɧɚɹ ɚɫɫɨɰɢɚɬɢɜɧɚɹ ɤɨɥ-
ɥɟɤɰɢɹ, ɬɨ ɜɵ ɧɟ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɬɟɣɧɟɪɵ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɯɟɲɢɪɨɜɚɧɢɹ
(ɧɟɫɬɚɧɞɚɪɬɧɵɟ hash_… ɢɥɢ ɫɬɚɧɞɚɪɬɧɵɟ unordered_… ɤɨɧɬɟɣɧɟɪɵ).
• ȼɨɩɪɨɫɵ ɷɮɮɟɤɬɢɜɧɨɫɬɢ ɩɪɢ ɧɚɩɢɫɚɧɢɢ ɞɨɥɠɧɵ ɭɱɢɬɵɜɚɬɶɫɹ ɬɨɥɶɤɨ ɬɨɝɞɚ ɢ ɬɚɦ,
ɝɞɟ ɷɬɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟɨɛɯɨɞɢɦɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8). ȿɫɥɢ ɧɚ ɨɫɧɨɜɚɧɢɢ ɩɪɨɜɟ-
ɞɟɧɧɵɯ ɢɡɦɟɪɟɧɢɣ ɫ ɪɟɚɥɶɧɵɦɢ ɞɚɧɧɵɦɢ ɞɨɤɚɡɚɧɨ, ɱɬɨ ɫɤɨɪɨɫɬɶ ɩɨɢɫɤɚ ɞɟɣɫɬɜɢɬɟɥɶ-
ɧɨ ɤɪɢɬɢɱɧɚ, ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɤɨɧɬɟɣɧɟɪɚɦɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɯɟɲɢɪɨɜɚɧɢɹ
(ɧɟɫɬɚɧɞɚɪɬɧɵɦɢ hash_… ɢɥɢ ɫɬɚɧɞɚɪɬɧɵɦɢ unordered_… ɤɨɧɬɟɣɧɟɪɚɦɢ), ɡɚɬɟɦ —
ɨɬɫɨɪɬɢɪɨɜɚɧɧɵɦ vector, ɡɚɬɟɦ — set ɢɥɢ map, ɨɛɵɱɧɨ ɜ ɩɪɢɜɟɞɟɧɧɨɦ ɩɨɪɹɞɤɟ.
Ⱦɚɠɟ ɜ ɷɬɨɣ ɫɢɬɭɚɰɢɢ ɨɬɥɢɱɢɹ ɚɫɢɦɩɬɨɬɢɱɟɫɤɨɝɨ ɜɪɟɦɟɧɢ ɪɚɛɨɬɵ (ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
“ɛɨɥɶɲɨɝɨ O”, ɧɚɩɪɢɦɟɪ, ɥɢɧɟɣɧɨɟ ɢ ɥɨɝɚɪɢɮɦɢɱɟɫɤɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ; ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 7) ɢɦɟɟɬ ɡɧɚɱɟɧɢɟ, ɬɨɥɶɤɨ ɟɫɥɢ ɤɨɧɬɟɣɧɟɪɵ ɞɨɫɬɚɬɨɱɧɨ ɜɟɥɢɤɢ, ɱɬɨɛɵ ɩɨɫɬɨɹɧɧɵɟ
ɦɧɨɠɢɬɟɥɢ ɩɟɪɟɫɬɚɥɢ ɢɝɪɚɬɶ ɪɨɥɶ. Ⱦɥɹ ɤɨɧɬɟɣɧɟɪɨɜ, ɫɨɞɟɪɠɚɳɢɯ ɧɟɛɨɥɶɲɢɟ ɨɛɴɟɤɬɵ
ɧɚɩɨɞɨɛɢɟ double, ɞɥɹ ɩɪɟɨɞɨɥɟɧɢɹ ɜɥɢɹɧɢɹ ɩɨɫɬɨɹɧɧɵɯ ɦɧɨɠɢɬɟɥɟɣ ɨɛɵɱɧɨ ɬɪɟɛɭ-
ɟɬɫɹ ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ ɧɟɫɤɨɥɶɤɨ ɬɵɫɹɱ ɷɥɟɦɟɧɬɨɜ.
• Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ ɢ ɪɚɡɭɦɧɨ, ɥɭɱɲɟ ɩɢɫɚɬɶ ɬɪɚɧɡɚɤɰɢɨɧɧɵɣ ɤɨɞ ɫɨ ɫɬɪɨɝɨɣ ɝɚ-
ɪɚɧɬɢɟɣ ɛɟɡɨɩɚɫɧɨɫɬɢ ɤɨɞ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71), ɢ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɟɤɨɪɪɟɤɬɧɵɟ
ɨɛɴɟɤɬɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 99). ȿɫɥɢ ɞɥɹ ɜɫɬɚɜɤɢ ɢ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ ɜɚɦ ɬɪɟɛɭɟɬ-
ɫɹ ɬɪɚɧɡɚɤɰɢɨɧɧɚɹ ɫɟɦɚɧɬɢɤɚ, ɢɥɢ ɟɫɥɢ ɧɟɨɛɯɨɞɢɦɨ ɦɢɧɢɦɢɡɢɪɨɜɚɬɶ ɧɟɞɟɣɫɬɜɢɬɟɥɶ-
ɧɨɫɬɶ ɢɬɟɪɚɬɨɪɨɜ, ɥɭɱɲɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɤɨɧɬɟɣɧɟɪɚɦɢ ɧɚ ɨɫɧɨɜɟ ɭɡɥɨɜ (ɧɚɩɪɢɦɟɪ,
list, set, map).
ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɫɥɟɞɭɣɬɟ ɫɨɜɟɬɭ ɋɬɚɧɞɚɪɬɚ: “vector ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɬɢɩ ɩɨɫɥɟ-
ɞɨɜɚɬɟɥɶɧɨɫɬɢ, ɤɨɬɨɪɵɣ ɧɭɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɨ ɭɦɨɥɱɚɧɢɸ” ([C++03] §23.1.1).
164 STL: контейнеры
Стр. 164
ȿɫɥɢ ɜɵ ɫɨɦɧɟɜɚɟɬɟɫɶ ɜ ɞɚɧɧɨɦ ɫɨɜɟɬɟ, ɫɩɪɨɫɢɬɟ ɫɚɦɢ ɫɟɛɹ — ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɥɢ ɭ ɜɚɫ ɟɫɬɶ
ɧɟɩɪɟɨɞɨɥɢɦɵɟ ɩɪɢɱɢɧɵ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɬɚɧɞɚɪɬɧɵɣ ɤɨɧɬɟɣɧɟɪ vector, ɤɨɬɨɪɵɣ ɨɛɥɚɞɚɟɬ
ɫɥɟɞɭɸɳɢɦɢ ɫɜɨɣɫɬɜɚɦɢ.
• Ƚɚɪɚɧɬɢɪɭɟɬ ɦɢɧɢɦɚɥɶɧɵɟ ɫɪɟɞɢ ɜɫɟɯ ɤɨɧɬɟɣɧɟɪɨɜ ɧɚɤɥɚɞɧɵɟ ɪɚɫɯɨɞɵ ɩɚɦɹɬɢ ɧɚ ɯɪɚ-
ɧɟɧɢɟ (ɧɨɥɶ ɛɚɣɬɨɜ ɧɚ ɨɛɴɟɤɬ).
• Ƚɚɪɚɧɬɢɪɭɟɬ ɧɚɢɜɵɫɲɭɸ ɫɪɟɞɢ ɜɫɟɯ ɤɨɧɬɟɣɧɟɪɨɜ ɫɤɨɪɨɫɬɶ ɞɨɫɬɭɩɚ ɤ ɯɪɚɧɢɦɵɦ ɷɥɟ-
ɦɟɧɬɚɦ.
• Ƚɚɪɚɧɬɢɪɭɟɬ ɥɨɤɚɥɶɧɨɫɬɶ ɫɫɵɥɨɤ, ɨɡɧɚɱɚɸɳɭɸ, ɱɬɨ ɨɛɴɟɤɬɵ, ɧɚɯɨɞɹɳɢɟɫɹ ɪɹɞɨɦ ɞɪɭɝ
ɫ ɞɪɭɝɨɦ ɜ ɤɨɧɬɟɣɧɟɪɟ, ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɧɚɯɨɞɹɬɫɹ ɪɹɞɨɦ ɢ ɜ ɩɚɦɹɬɢ, ɱɬɨ ɧɟ ɝɚɪɚɧɬɢɪɭ-
ɟɬ ɧɢ ɨɞɢɧ ɞɪɭɝɨɣ ɤɨɧɬɟɣɧɟɪ.
• Ƚɚɪɚɧɬɢɪɭɟɬ ɫɨɜɦɟɫɬɢɦɨɫɬɶ ɪɚɡɦɟɳɟɧɢɹ ɜ ɩɚɦɹɬɢ ɫ ɪɚɡɦɟɳɟɧɢɟɦ, ɢɫɩɨɥɶɡɭɟɦɵɦ ɹɡɵ-
ɤɨɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ C, ɜ ɨɬɥɢɱɢɟ ɨɬ ɨɫɬɚɥɶɧɵɯ ɫɬɚɧɞɚɪɬɧɵɯ ɤɨɧɬɟɣɧɟɪɨɜ (ɫɦ. ɪɟ-
ɤɨɦɟɧɞɚɰɢɢ 77 ɢ 78).
• Ƚɚɪɚɧɬɢɪɭɟɬ ɧɚɥɢɱɢɟ ɫɚɦɵɯ ɝɢɛɤɢɯ ɢɬɟɪɚɬɨɪɨɜ (ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ).
• ɉɨɱɬɢ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɢɦɟɟɬ ɫɚɦɵɟ ɛɵɫɬɪɵɟ ɢɬɟɪɚɬɨɪɵ (ɭɤɚɡɚɬɟɥɢ ɢɥɢ ɤɥɚɫɫɵ ɫɨ ɫɪɚɜ-
ɧɢɦɨɣ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɶɸ, ɤɨɬɨɪɵɟ ɡɚɱɚɫɬɭɸ ɪɚɛɨɬɚɸɬ ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ (ɧɟ ɨɬɥɚɞɨɱ-
ɧɨɣ) ɜɟɪɫɢɢ ɫ ɬɨɣ ɠɟ ɫɤɨɪɨɫɬɶɸ, ɱɬɨ ɢ ɭɤɚɡɚɬɟɥɢ).
ȿɫɬɶ ɥɢ ɭ ɜɚɫ ɩɪɢɱɢɧɵ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɚɤɨɣ ɤɨɧɬɟɣɧɟɪ ɩɨ ɭɦɨɥɱɚɧɢɸ? ȿɫɥɢ ɭ ɜɚɫ ɟɫɬɶ
ɬɚɤɚɹ ɩɪɢɱɢɧɚ, ɫɜɹɡɚɧɧɚɹ ɫ ɨɞɧɢɦ ɢɡ ɬɪɟɯ ɚɫɩɟɤɬɨɜ ɜ ɧɚɱɚɥɟ ɷɬɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ, ɬɨ ɜɫɟ ɡɚɦɟ-
ɱɚɬɟɥɶɧɨ — ɩɪɨɫɬɨ ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɧɚɢɛɨɥɟɟ ɩɨɞɯɨɞɹɳɢɦ ɞɥɹ ɜɚɫ ɤɨɧɬɟɣɧɟɪɨɦ. ȿɫɥɢ ɬɚɤɨɣ
ɩɪɢɱɢɧɵ ɧɟɬ — ɜɨɡɶɦɢɬɟ vector ɢ ɫɩɨɤɨɣɧɨ ɪɚɛɨɬɚɣɬɟ, ɡɧɚɹ, ɱɬɨ ɜɵ ɫɞɟɥɚɥɢ ɜɟɪɧɵɣ ɜɵɛɨɪ.
ɂ ɩɨɫɥɟɞɧɟɟ — ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɬɟɣɧɟɪɵ ɢ ɚɥɝɨɪɢɬɦɵ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ,
ɚ ɧɟ ɫɬɨɪɨɧɧɟɝɨ ɩɪɨɢɡɜɨɞɢɬɟɥɹ ɢɥɢ ɪɚɡɪɚɛɨɬɚɧɧɵɟ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ.
Примеры
ɉɪɢɦɟɪ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ vector ɞɥɹ ɧɟɛɨɥɶɲɢɯ ɫɩɢɫɤɨɜ. Ɋɚɫɩɪɨɫɬɪɚɧɟɧɧɨɟ ɡɚɛɥɭɠɞɟɧɢɟ —
ɢɫɩɨɥɶɡɨɜɚɬɶ list ɬɨɥɶɤɨ ɩɨɬɨɦɭ, ɱɬɨ “ɨɱɟɜɢɞɧɨ, ɱɬɨ list —ɩɨɞɯɨɞɹɳɢɣ ɬɢɩ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ
ɨɩɟɪɚɰɢɣ ɫɨ ɫɩɢɫɤɨɦ”, ɬɚɤɢɯ ɤɚɤ ɜɫɬɚɜɤɚ ɜ ɫɪɟɞɢɧɭ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ. Ɍɢɩ vector ɞɥɹ ɧɟ-
ɛɨɥɶɲɢɯ ɫɩɢɫɤɨɜ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟɝɞɚ ɩɪɟɜɨɫɯɨɞɢɬ ɬɢɩ list. ɇɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɜɫɬɚɜɤɚ ɜ ɫɪɟ-
ɞɢɧɭ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ ɬɪɟɛɭɟɬ ɥɢɧɟɣɧɨɝɨ ɜɪɟɦɟɧɢ ɪɚɛɨɬɵ ɭ vector, ɢ ɩɨɫɬɨɹɧɧɨɝɨ —
ɭ list, ɜɟɤɬɨɪ ɫ ɧɟɛɨɥɶɲɢɦ ɤɨɥɢɱɟɫɬɜɨɦ ɷɥɟɦɟɧɬɨɜ ɨɛɵɱɧɨ ɫɩɪɚɜɥɹɟɬɫɹ ɫ ɷɬɨɣ ɡɚɞɚɱɟɣ ɛɵɫɬ-
ɪɟɟ — ɡɚ ɫɱɟɬ ɦɟɧɶɲɟɝɨ ɩɨɫɬɨɹɧɧɨɝɨ ɦɧɨɠɢɬɟɥɹ; ɩɪɟɢɦɭɳɟɫɬɜɚ ɚɫɢɦɩɬɨɬɢɱɟɫɤɨɝɨ ɜɪɟɦɟɧɢ ɪɚ-
ɛɨɬɵ list ɩɪɨɹɜɥɹɸɬɫɹ ɬɨɥɶɤɨ ɩɪɢ ɛɨɥɶɲɢɯ ɤɨɥɢɱɟɫɬɜɚɯ ɷɥɟɦɟɧɬɨɜ ɜ ɤɨɧɬɟɣɧɟɪɟ.
Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɢɫɩɨɥɶɡɭɣɬɟ vector, ɩɨɤɚ ɪɚɡɦɟɪɵ ɞɚɧɧɵɯ ɧɟ ɩɨɬɪɟɛɭɸɬ ɢɧɨɝɨ ɜɵɛɨɪɚ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 7), ɥɢɛɨ ɩɨɤɚ ɧɟ ɫɬɚɧɟɬ ɫɭɳɟɫɬɜɟɧɧɨɣ ɨɛɟɫɩɟɱɟɧɢɟ ɫɬɪɨɝɨɣ ɝɚɪɚɧɬɢɢ
ɛɟɡɨɩɚɫɧɨɫɬɢ ɩɪɢ ɜɨɡɦɨɠɧɨɣ ɝɟɧɟɪɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ ɤɨɩɢɪɭɸɳɢɦ ɤɨɧɫɬɪɭɤɬɨɪɨɦ ɢɥɢ ɤɨɩɢ-
ɪɭɸɳɢɦ ɨɩɟɪɚɬɨɪɨɦ ɩɪɢɫɜɚɢɜɚɧɢɹ ɬɢɩɚ ɨɛɴɟɤɬɨɜ, ɯɪɚɧɹɳɢɯɫɹ ɜ ɤɨɧɬɟɣɧɟɪɟ. ȼ ɩɨɫɥɟɞɧɟɦ
ɫɥɭɱɚɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜɚɠɧɵɦ, ɱɬɨ ɤɨɧɬɟɣɧɟɪ list ɨɛɟɫɩɟɱɢɜɚɟɬ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɛɟɡɨ-
ɩɚɫɧɨɫɬɢ ɞɥɹ ɨɩɟɪɚɰɢɢ ɜɫɬɚɜɤɢ ɜ ɤɨɥɥɟɤɰɢɸ ɬɚɤɢɯ ɬɢɩɨɜ.
Ссылки
[Austern99] §5.4.1 • [C++03] §23.1.1 • [Josuttis99] §6.9 • [Meyers01] §1-2, §13, §16, §23, §25 •
[Musser01] §6.1 • [Stroustrup00] §17.1, §17.6 • [Sutter00] §7, §20 • [Sutter02] §7
76. По умолчанию используйте vector... 165
Стр. 165
77. Вместо массивов используйте vector
и string
Резюме
ɂɡɛɟɝɚɣɬɟ ɪɟɚɥɢɡɚɰɢɢ ɚɛɫɬɪɚɤɰɢɢ ɦɚɫɫɢɜɚ ɩɨɫɪɟɞɫɬɜɨɦ ɦɚɫɫɢɜɨɜ ɜ ɫɬɢɥɟ C, ɚɪɢɮɦɟɬɢɤɢ ɭɤɚɡɚ-
ɬɟɥɟɣ ɢ ɩɪɢɦɢɬɢɜɨɜ ɭɩɪɚɜɥɟɧɢɹ ɩɚɦɹɬɶɸ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ vector ɢɥɢ string ɧɟ ɬɨɥɶɤɨ ɫɞɟɥɚɟɬ
ɩɪɨɳɟ ɜɚɲɭ ɠɢɡɧɶ, ɧɨ ɢ ɩɨɡɜɨɥɢɬ ɧɚɩɢɫɚɬɶ ɛɨɥɟɟ ɛɟɡɨɩɚɫɧɭɸ ɢ ɦɚɫɲɬɚɛɢɪɭɟɦɭɸ ɩɪɨɝɪɚɦɦɭ.
ɋɟɝɨɞɧɹ ɟɞɜɚ ɥɢ ɧɟ ɨɫɧɨɜɧɵɦɢ ɜɨɩɪɨɫɚɦɢ ɩɪɢ ɧɚɩɢɫɚɧɢɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ ɹɜ-
ɥɹɸɬɫɹ ɜɨɩɪɨɫɵ ɛɟɡɨɩɚɫɧɨɫɬɢ ɢ ɩɟɪɟɩɨɥɧɟɧɢɹ ɛɭɮɟɪɚ. Ɉɝɪɚɧɢɱɟɧɢɹ, ɫɜɹɡɚɧɧɵɟ ɫ ɮɢɤɫɢɪɨ-
ɜɚɧɧɵɦ ɪɚɡɦɟɪɨɦ ɦɚɫɫɢɜɨɜ, ɞɨɫɬɚɜɥɹɸɬ ɧɟɦɚɥɨ ɛɟɫɩɨɤɨɣɫɬɜɚ, ɞɚɠɟ ɟɫɥɢ ɩɪɢɥɨɠɟɧɢɸ ɭɞɚɟɬ-
ɫɹ ɨɫɬɚɬɶɫɹ ɜ ɪɚɦɤɚɯ ɤɨɪɪɟɤɬɧɨɫɬɢ. ȼɫɟ ɷɬɢ ɩɪɨɛɥɟɦɵ ɫɜɹɡɚɧɵ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɬɚɪɵɯ
ɫɪɟɞɫɬɜ C, ɬɚɤɢɯ ɤɚɤ ɜɫɬɪɨɟɧɧɵɟ ɦɚɫɫɢɜɵ, ɭɤɚɡɚɬɟɥɢ ɢ ɢɯ ɚɪɢɮɦɟɬɢɤɚ, ɚ ɬɚɤɠɟ ɭɩɪɚɜɥɟɧɢɟ
ɩɚɦɹɬɶɸ ɜɪɭɱɧɭɸ ɜɦɟɫɬɨ ɬɚɤɢɯ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɯ ɤɨɧɰɟɩɰɢɣ, ɤɚɤ ɛɭɮɟɪɵ, ɜɟɤɬɨɪɵ ɢ ɫɬɪɨɤɢ.
ȼɨɬ ɧɟɤɨɬɨɪɵɟ ɢɡ ɩɪɢɱɢɧ, ɩɨ ɤɨɬɨɪɵɦ ɦɚɫɫɢɜɚɦ ɜ ɫɬɢɥɟ C ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɫɬɚɧɞɚɪɬ-
ɧɵɟ ɫɪɟɞɫɬɜɚ C++.
• Ɉɧɢ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɭɩɪɚɜɥɹɸɬ ɫɨɛɫɬɜɟɧɧɨɣ ɩɚɦɹɬɶɸ. Ȼɨɥɶɲɟ ɧɟ ɬɪɟɛɭɟɬɫɹ ɧɢɤɚɤɢɯ ɮɢɤ-
ɫɢɪɨɜɚɧɧɵɯ ɛɭɮɟɪɨɜ ɫ ɪɚɡɦɟɪɨɦ “ɛɨɥɶɲɢɦ, ɱɟɦ ɥɸɛɚɹ ɪɚɡɭɦɧɚɹ ɞɥɢɧɚ” (“ɛɨɦɛɚ ɫ ɱɚɫɨɜɵɦ
ɦɟɯɚɧɢɡɦɨɦ” — ɜɨɬ ɤɚɤ ɩɪɚɜɢɥɶɧɨ ɩɪɨɱɟɫɬɶ ɷɬɨ ɨɩɪɟɞɟɥɟɧɢɟ), ɢɥɢ ɫɩɥɨɲɧɵɯ ɩɟɪɟɪɚɫɩɪɟ-
ɞɟɥɟɧɢɣ ɩɚɦɹɬɢ ɩɪɢ ɩɨɦɨɳɢ realloc ɢ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɯ ɨɛɧɨɜɥɟɧɢɣ ɭɤɚɡɚɬɟɥɟɣ.
• ɍ ɧɢɯ ɛɨɝɚɬɵɣ ɢɧɬɟɪɮɟɣɫ. ȼɵ ɥɟɝɤɨ ɢ ɜɵɪɚɡɢɬɟɥɶɧɨ ɦɨɠɟɬɟ ɪɟɚɥɢɡɨɜɚɬɶ ɫɥɨɠɧɭɸ ɮɭɧɤ-
ɰɢɨɧɚɥɶɧɨɫɬɶ.
• Ɉɧɢ ɫɨɜɦɟɫɬɢɦɵ ɫ ɦɨɞɟɥɶɸ ɩɚɦɹɬɢ ɜ C. vector ɢ string::c_str ɦɨɝɭɬ ɛɵɬɶ ɩɟɪɟɞɚ-
ɧɵ ɮɭɧɤɰɢɹɦ API ɧɚ ɹɡɵɤɟ C. ȼ ɱɚɫɬɧɨɫɬɢ, ɜ C++ vector ɫɥɭɠɢɬ “ɩɟɪɟɯɨɞɧɢɤɨɦ” ɤ C
ɢ ɞɪɭɝɢɦ ɹɡɵɤɚɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 76 ɢ 78).
• Ɉɧɢ ɨɛɟɫɩɟɱɢɜɚɸɬ ɪɚɫɲɢɪɟɧɧɵɟ ɜɨɡɦɨɠɧɨɫɬɢ ɩɪɨɜɟɪɤɢ. ɋɬɚɧɞɚɪɬɧɵɟ ɫɪɟɞɫɬɜɚ ɩɨ-
ɡɜɨɥɹɸɬ ɪɟɚɥɢɡɨɜɚɬɶ (ɜ ɨɬɥɚɞɨɱɧɨɦ ɪɟɠɢɦɟ) ɢɬɟɪɚɬɨɪɵ ɢ ɨɩɟɪɚɬɨɪɵ ɢɧɞɟɤɫɢɪɨɜɚɧɢɹ,
ɤɨɬɨɪɵɟ ɫɩɨɫɨɛɧɵ ɜɵɹɜɢɬɶ ɛɨɥɶɲɨɣ ɤɥɚɫɫ ɨɲɢɛɨɤ ɩɚɦɹɬɢ. Ɇɧɨɝɢɟ ɢɡ ɫɨɜɪɟɦɟɧɧɵɯ
ɪɟɚɥɢɡɚɰɢɣ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɬɚɤɢɟ ɨɬɥɚɞɨɱɧɵɟ ɜɨɡɦɨɠɧɨ-
ɫɬɢ — ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɢɦɢ! (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 83.)
• Ɉɧɢ ɩɪɚɤɬɢɱɟɫɤɢ ɧɟ ɫɧɢɠɚɸɬ ɷɮɮɟɤɬɢɜɧɨɫɬɶ ɜɚɲɢɯ ɩɪɨɝɪɚɦɦ. ȼ ɤɥɚɫɫɚɯ vector
ɢ string ɩɪɢ ɜɵɛɨɪɟ ɦɟɠɞɭ ɷɮɮɟɤɬɢɜɧɨɫɬɶɸ ɢ ɛɟɡɨɩɚɫɧɨɫɬɶɸ ɪɟɲɟɧɢɟ ɩɪɢɧɢɦɚɟɬɫɹ
ɜ ɩɨɥɶɡɭ ɷɮɮɟɤɬɢɜɧɨɫɬɢ (ɟɫɬɟɫɬɜɟɧɧɨ, ɧɟ ɜ ɨɬɥɚɞɨɱɧɨɦ ɪɟɠɢɦɟ). Ɍɟɦ ɧɟ ɦɟɧɟɟ, ɫɬɚɧ-
ɞɚɪɬɧɵɟ ɫɪɟɞɫɬɜɚ ɨɤɚɡɵɜɚɸɬɫɹ ɝɨɪɚɡɞɨ ɥɭɱɲɟɣ ɩɥɚɬɮɨɪɦɨɣ ɞɥɹ ɫɨɡɞɚɧɢɹ ɛɟɡɨɩɚɫɧɵɯ
ɤɨɦɩɨɧɟɧɬɨɜ, ɱɟɦ ɨɛɵɱɧɵɟ ɦɚɫɫɢɜɵ ɢ ɭɤɚɡɚɬɟɥɢ.
• Ɉɧɢ ɫɬɢɦɭɥɢɪɭɸɬ ɨɩɬɢɦɢɡɚɰɢɸ. ɋɨɜɪɟɦɟɧɧɵɟ ɪɟɚɥɢɡɚɰɢɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ
ɜɤɥɸɱɚɸɬ ɨɩɬɢɦɢɡɚɰɢɢ, ɨ ɤɨɬɨɪɵɯ ɦɧɨɝɢɟ ɢɡ ɧɚɫ ɩɪɨɫɬɨ ɧɢɤɨɝɞɚ ɛɵ ɢ ɧɟ ɩɨɞɭɦɚɥɢ.
ɉɪɢɦɟɧɟɧɢɟ ɦɚɫɫɢɜɚ ɦɨɠɟɬ ɛɵɬɶ ɨɩɪɚɜɞɚɧɧɨ, ɤɨɝɞɚ ɟɝɨ ɪɚɡɦɟɪ ɮɢɤɫɢɪɨɜɚɧ ɧɚ ɫɬɚɞɢɢ
ɤɨɦɩɢɥɹɰɢɢ (ɧɚɩɪɢɦɟɪ, float[3] ɞɥɹ ɬɪɟɯɦɟɪɧɨɣ ɬɨɱɤɢ; ɩɟɪɟɯɨɞ ɤ ɱɟɬɜɟɪɬɨɦɭ ɢɡɦɟɪɟɧɢɸ
ɜɫɟ ɪɚɜɧɨ ɩɨɬɪɟɛɭɟɬ ɩɟɪɟɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɪɨɝɪɚɦɦɵ).
Ссылки
[Alexandrescu01a] • [Dewhurst03] §13, §60, §68 • [Meyers01] §13, §16 • [Stroustrup00] §3.5-7,
§5.3, §20.4.1, §C.7 • [Sutter00] §36
Стр. 166
78. Используйте vector (и string::c_str)
для обмена данными с API на других
языках
Резюме
vector ɢ string::c_str ɫɥɭɠɚɬ ɲɥɸɡɨɦ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ. Ɉɞɧɚ-
ɤɨ ɧɟ ɩɨɥɚɝɚɣɬɟɫɶ ɧɚ ɬɨ, ɱɬɨ ɢɬɟɪɚɬɨɪɵ ɹɜɥɹɸɬɫɹ ɭɤɚɡɚɬɟɥɹɦɢ; ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɚɞɪɟɫɚ ɷɥɟɦɟɧ-
ɬɚ, ɧɚ ɤɨɬɨɪɵɣ ɫɫɵɥɚɟɬɫɹ vector<T>::iterator iter, ɢɫɩɨɥɶɡɭɣɬɟ ɜɵɪɚɠɟɧɢɟ &*iter.
vector (ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ) ɢ string::c_str ɢ string::data (ɜɨ ɜɬɨɪɭɸ) ɩɪɟɞɫɬɚɜ-
ɥɹɸɬ ɫɨɛɨɣ ɧɚɢɥɭɱɲɢɟ ɫɩɨɫɨɛɵ ɨɛɦɟɧɚ ɞɚɧɧɵɦɢ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɜɨɨɛɳɟ ɢ ɫ ɛɢɛɥɢɨ-
ɬɟɤɚɦɢ ɧɚ C ɜ ɱɚɫɬɧɨɫɬɢ.
Ⱦɚɧɧɵɟ vector ɜɫɟɝɞɚ ɯɪɚɧɹɬɫɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨ, ɬɚɤ ɱɬɨ ɩɨɥɭɱɟɧɢɟ ɚɞɪɟɫɚ ɩɟɪɜɨɝɨ ɷɥɟ-
ɦɟɧɬɚ ɜɟɤɬɨɪɚ ɞɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ. ɂɫɩɨɥɶɡɭɣɬɟ &*v.begin(), &v[0] ɢɥɢ
&v.front() ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɭɤɚɡɚɬɟɥɹ ɧɚ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ v. Ⱦɥɹ ɩɨɥɭɱɟɧɢɹ ɭɤɚɡɚɬɟɥɹ ɧɚ n-ɣ
ɷɥɟɦɟɧɬ ɜɟɤɬɨɪɚ ɥɭɱɲɟ ɫɧɚɱɚɥɚ ɩɪɨɜɟɫɬɢ ɚɪɢɮɦɟɬɢɱɟɫɤɢɟ ɜɵɱɢɫɥɟɧɢɹ, ɚ ɡɚɬɟɦ ɩɨɥɭɱɢɬɶ ɚɞ-
ɪɟɫ (ɧɚɩɪɢɦɟɪ, &v.begin()[n] ɢɥɢ &v[n]) ɜɦɟɫɬɨ ɩɨɥɭɱɟɧɢɹ ɭɤɚɡɚɬɟɥɹ ɧɚ ɧɚɱɚɥɨ ɞɚɧɧɵɯ
ɫ ɩɨɫɥɟɞɭɸɳɢɦ ɩɪɢɦɟɧɟɧɢɟɦ ɚɪɢɮɦɟɬɢɤɢ ɭɤɚɡɚɬɟɥɟɣ (ɧɚɩɪɢɦɟɪ, (&v.front())[n]). ɗɬɨ
ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɜ ɩɟɪɜɨɦ ɫɥɭɱɚɟ ɜ ɨɬɥɚɞɨɱɧɨɣ ɪɟɚɥɢɡɚɰɢɢ ɜɵɩɨɥɧɹɟɬɫɹ ɩɪɨɜɟɪɤɚ ɧɚ ɞɨɫɬɭɩ
ɤ ɷɥɟɦɟɧɬɭ ɡɚ ɩɪɟɞɟɥɚɦɢ v (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 83).
ɇɟɥɶɡɹ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɬɨ, ɱɬɨ v.begin() ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ ɢɥɢ,
ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ, ɱɬɨ ɢɬɟɪɚɬɨɪɵ ɜɟɤɬɨɪɚ ɹɜɥɹɸɬɫɹ ɭɤɚɡɚɬɟɥɹɦɢ. ɏɨɬɹ ɧɟɤɨɬɨɪɵɟ ɪɟɚɥɢɡɚɰɢɢ
STL ɨɩɪɟɞɟɥɹɸɬ vector<T>::iterator ɤɚɤ ɨɛɵɱɧɵɣ ɭɤɚɡɚɬɟɥɶ T*, ɢɬɟɪɚɬɨɪɵ ɦɨɝɭɬ ɛɵɬɶ
(ɢ ɜɫɟ ɱɚɳɟ ɬɚɤ ɨɧɨ ɢ ɟɫɬɶ) ɩɨɥɧɨɰɟɧɧɵɦɢ ɬɢɩɚɦɢ (ɟɳɟ ɪɚɡ ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 83).
ɏɨɬɹ ɜ ɛɨɥɶɲɢɧɫɬɜɟ ɪɟɚɥɢɡɚɰɢɣ ɞɥɹ string ɬɚɤɠɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɧɟɩɪɟɪɵɜɧɵɣ ɛɥɨɤ ɩɚɦɹ-
ɬɢ, ɷɬɨ ɧɟ ɝɚɪɚɧɬɢɪɭɟɬɫɹ ɫɬɚɧɞɚɪɬɨɦ, ɬɚɤ ɱɬɨ ɧɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɚɞɪɟɫ ɫɢɦɜɨɥɚ ɜ ɫɬɪɨɤɟ,
ɫɱɢɬɚɹ ɟɝɨ ɭɤɚɡɚɬɟɥɟɦ ɧɚ ɜɫɟ ɫɨɞɟɪɠɢɦɨɟ ɫɬɪɨɤɢ. ɏɨɪɨɲɚɹ ɧɨɜɨɫɬɶ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ
ɮɭɧɤɰɢɹ string::c_str ɜɫɟɝɞɚ ɜɨɡɜɪɚɳɚɟɬ ɫɬɪɨɤɭ ɜ ɫɬɢɥɟ C ɫ ɡɚɜɟɪɲɚɸɳɢɦ ɧɭɥɟɜɵɦ ɫɢɦ-
ɜɨɥɨɦ (string::data ɬɚɤɠɟ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟɩɪɟɪɵɜɧɵɣ ɛɥɨɤ ɩɚɦɹɬɢ, ɧɨ ɧɟ ɝɚ-
ɪɚɧɬɢɪɭɟɬ ɧɚɥɢɱɢɹ ɡɚɜɟɪɲɚɸɳɟɝɨ ɧɭɥɟɜɨɝɨ ɫɢɦɜɨɥɚ).
Ʉɨɝɞɚ ɜɵ ɩɟɪɟɞɚɟɬɟ ɭɤɚɡɚɬɟɥɶ ɧɚ ɞɚɧɧɵɟ ɨɛɴɟɤɬɚ v ɬɢɩɚ vector, ɤɨɞ ɧɚ ɹɡɵɤɟ C ɦɨɠɟɬ
ɤɚɤ ɱɢɬɚɬɶ, ɬɚɤ ɢ ɡɚɩɢɫɵɜɚɬɶ ɷɥɟɦɟɧɬɵ v; ɨɞɧɚɤɨ ɨɧ ɧɟ ɞɨɥɠɟɧ ɜɵɯɨɞɢɬɶ ɡɚ ɝɪɚɧɢɰɵ ɞɚɧɧɵɯ.
ɏɨɪɨɲɨ ɩɪɨɞɭɦɚɧɧɵɣ API ɧɚ ɹɡɵɤɟ C ɞɨɥɠɟɧ ɩɨɥɭɱɚɬɶ ɧɚɪɹɞɭ ɫ ɭɤɚɡɚɬɟɥɟɦ ɥɢɛɨ ɦɚɤɫɢɦɚɥɶ-
ɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɨɛɴɟɤɬɨɜ (ɞɨ v.size()), ɥɢɛɨ ɭɤɚɡɚɬɟɥɶ ɧɚ ɷɥɟɦɟɧɬ, ɫɥɟɞɭɸɳɢɣ ɡɚ ɩɨɫɥɟɞ-
ɧɢɦ (&*v.begin()+v.size()).
ȿɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɤɨɧɬɟɣɧɟɪ ɨɛɴɟɤɬɨɜ ɬɢɩɚ T, ɨɬɥɢɱɧɵɣ ɨɬ vector ɢɥɢ string, ɢ ɜɵ ɯɨɬɢɬɟ
ɩɟɪɟɞɚɬɶ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ (ɢɥɢ ɡɚɩɨɥɧɢɬɶ ɟɝɨ) ɮɭɧɤɰɢɢ API ɧɚ ɞɪɭɝɨɦ ɹɡɵɤɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ,
ɤɨɬɨɪɚɹ ɨɠɢɞɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɦɚɫɫɢɜ ɨɛɴɟɤɬɨɜ ɬɢɩɚ T, ɫɤɨɩɢɪɭɣɬɟ ɫɨɞɟɪɠɢɦɨɟ ɤɨɧɬɟɣɧɟɪɚ ɜ
(ɢɥɢ ɢɡ) vector<T>, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɫɨɨɛɳɚɬɶɫɹ ɫ ɬɚɤɢɦɢ ɮɭɧɤɰɢɹɦɢ.
Ссылки
[Josuttis99] §6.2.3, §11.2.4 • [Meyers01] §16 • [Musser01] §B • [Stroustrup00] §16.3.1
78. Используйте vector (и string::c_str) для обмена данными с API на других языках 167
Стр. 167
79. Храните в контейнерах только значения
или интеллектуальные указатели
Резюме
ɏɪɚɧɢɬɟ ɤ ɤɨɧɬɟɣɧɟɪɚɯ ɨɛɴɟɤɬɵ-ɡɧɚɱɟɧɢɹ. Ʉɨɧɬɟɣɧɟɪɵ ɩɨɥɚɝɚɸɬ, ɱɬɨ ɢɯ ɫɨɞɟɪɠɢɦɨɟ
ɢɦɟɟɬ ɬɢɩ ɡɧɚɱɟɧɢɹ, ɜɤɥɸɱɚɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɯɪɚɧɹɳɢɟɫɹ ɡɧɚɱɟɧɢɹ, ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚ-
ɡɚɬɟɥɢ ɢ ɢɬɟɪɚɬɨɪɵ.
ɇɚɢɛɨɥɟɟ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɧɬɟɣɧɟɪɨɜ — ɞɥɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɯɪɚɧɟɧɢɹ
ɡɧɚɱɟɧɢɣ (ɧɚɩɪɢɦɟɪ, vector<int>, set<string>). ȼ ɫɥɭɱɚɟ ɤɨɧɬɟɣɧɟɪɨɜ ɭɤɚɡɚɬɟɥɟɣ, ɟɫɥɢ ɤɨɧ-
ɬɟɣɧɟɪ ɜɥɚɞɟɟɬ ɨɛɴɟɤɬɚɦɢ, ɧɚ ɤɨɬɨɪɵɟ ɭɤɚɡɵɜɚɟɬ, ɬɨ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɬɟɣɧɟɪ ɢɧɬɟɥɥɟɤɬɭ-
ɚɥɶɧɵɯ ɭɤɚɡɚɬɟɥɟɣ ɫɨ ɫɱɟɬɱɢɤɨɦ ɫɫɵɥɨɤ (ɧɚɩɪɢɦɟɪ, list<shared_ptr<Widget> >); ɜ ɩɪɨɬɢɜ-
ɧɨɦ ɫɥɭɱɚɟ ɦɨɠɧɨ ɜɵɛɪɚɬɶ ɤɨɧɬɟɣɧɟɪ ɨɛɵɱɧɵɯ ɭɤɚɡɚɬɟɥɟɣ (ɧɚɩɪɢɦɟɪ, list<Widget*>) ɢɥɢ ɢɧɵɯ
ɡɧɚɱɟɧɢɣ, ɩɨɞɨɛɧɵɯ ɭɤɚɡɚɬɟɥɹɦ — ɬɚɤɢɯ ɤɚɤ ɢɬɟɪɚɬɨɪɵ (ɧɚɩɪɢɦɟɪ, list<vector<Widget>::
iterator>).
Примеры
ɉɪɢɦɟɪ 1. auto_ptr. Ɉɛɴɟɤɬɵ auto_ptr<T> ɧɟ ɹɜɥɹɸɬɫɹ ɨɛɴɟɤɬɚɦɢ-ɡɧɚɱɟɧɢɹɦɢ ɢɡ-ɡɚ
ɫɜɨɟɣ ɫɟɦɚɧɬɢɤɢ ɩɟɪɟɞɚɱɢ ɜɥɚɞɟɧɢɹ ɩɪɢ ɤɨɩɢɪɨɜɚɧɢɢ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɧɬɟɣɧɟɪɚ ɨɛɴɟɤɬɨɜ
auto_ptr (ɧɚɩɪɢɦɟɪ, vector<auto_ptr<int> >) ɞɨɥɠɧɨ ɩɪɢɜɟɫɬɢ ɤ ɨɲɢɛɤɟ ɤɨɦɩɢɥɹɰɢɢ.
ɇɨ ɞɚɠɟ ɜ ɫɥɭɱɚɟ ɭɫɩɟɲɧɨɣ ɤɨɦɩɢɥɹɰɢɢ ɧɢɤɨɝɞɚ ɧɟ ɩɢɲɢɬɟ ɬɚɤɨɣ ɤɨɞ — ɜɦɟɫɬɨ ɷɬɨɝɨ ɜɚɦ
ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɬɟɣɧɟɪ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ ɭɤɚɡɚɬɟɥɟɣ shared_ptr.
ɉɪɢɦɟɪ 2. Ƚɟɬɟɪɨɝɟɧɧɵɟ ɤɨɧɬɟɣɧɟɪɵ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɤɨɧɬɟɣɧɟɪ, ɯɪɚɧɹɳɢɣ
ɢ ɜɥɚɞɟɸɳɢɣ ɨɛɴɟɤɬɚɦɢ ɪɚɡɥɢɱɧɵɯ, ɧɨ ɫɜɹɡɚɧɧɵɯ ɬɢɩɨɜ, ɧɚɩɪɢɦɟɪ, ɬɢɩɨɜ, ɩɪɨɢɡɜɨɞɧɵɯ ɨɬ
ɨɛɳɟɝɨ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ, ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ container<shared_ptr<Base> >. Ⱥɥɶɬɟɪ-
ɧɚɬɢɜɨɣ ɹɜɥɹɟɬɫɹ ɯɪɚɧɟɧɢɟ ɩɪɨɤɫɢ-ɨɛɴɟɤɬɨɜ, ɧɟɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɤɨɬɨɪɵɯ ɩɟɪɟɞɚɸɬ ɜɵ-
ɡɨɜɵ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ ɜɢɪɬɭɚɥɶɧɵɦ ɮɭɧɤɰɢɹɦ ɪɟɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ.
ɉɪɢɦɟɪ 3. Ʉɨɧɬɟɣɧɟɪɵ ɬɢɩɨɜ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ ɡɧɚɱɟɧɢɹɦɢ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɯɪɚɧɢɬɶ ɨɛɴɟɤɬɵ,
ɧɟɫɦɨɬɪɹ ɧɚ ɧɟɜɨɡɦɨɠɧɨɫɬɶ ɢɯ ɤɨɩɢɪɨɜɚɧɢɹ ɢɥɢ ɞɪɭɝɨɟ ɢɯ ɩɨɜɟɞɟɧɢɟ, ɞɟɥɚɸɳɟɟ ɢɯ ɬɢɩɚɦɢ, ɧɟ
ɹɜɥɹɸɳɢɦɢɫɹ ɡɧɚɱɟɧɢɹɦɢ (ɧɚɩɪɢɦɟɪ, DatabaseLock ɢɥɢ TcpConnection), ɢɯ ɫɥɟɞɭɟɬ ɯɪɚ-
ɧɢɬɶ ɨɩɨɫɪɟɞɨɜɚɧɧɨ, ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ ɭɤɚɡɚɬɟɥɟɣ (ɧɚɩɪɢɦɟɪ, container
<shared_ptr<DatabaseLock> > ɢɥɢ container<shared_ptr<TcpConnection> >).
ɉɪɢɦɟɪ 4. ɇɟɨɛɹɡɚɬɟɥɶɧɵɟ ɡɧɚɱɟɧɢɹ. ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ ɤɨɧɬɟɣɧɟɪ map<Thing,Widget>,
ɧɨ ɧɟɤɨɬɨɪɵɟ Thing ɧɟ ɢɦɟɸɬ ɫɜɹɡɚɧɧɵɯ ɫ ɧɢɦɢ ɨɛɴɟɤɬɨɜ Widget, ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ
map<Thing,shared_ptr<Widget> >.
ɉɪɢɦɟɪ 5. ɂɧɞɟɤɫɧɵɟ ɤɨɧɬɟɣɧɟɪɵ. ȿɫɥɢ ɜɚɦ ɧɭɠɟɧ ɤɨɧɬɟɣɧɟɪ, ɯɪɚɧɹɳɢɣ ɨɛɴɟɤɬɵ, ɢ ɞɨɫ-
ɬɭɩ ɤ ɧɢɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɪɚɡɧɵɯ ɜɢɞɨɜ ɭɩɨɪɹɞɨɱɟɧɢɹ ɛɟɡ ɩɟɪɟɫɨɪɬɢɪɨɜɤɢ ɨɫɧɨɜɧɨɝɨ ɤɨɧ-
ɬɟɣɧɟɪɚ, ɜɵ ɦɨɠɟɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜɬɨɪɢɱɧɵɦ ɤɨɧɬɟɣɧɟɪɨɦ, ɤɨɬɨɪɵɣ “ɭɤɚɡɵɜɚɟɬ ɜ” ɨɫɧɨɜ-
ɧɨɣ ɤɨɧɬɟɣɧɟɪ, ɢ ɨɬɫɨɪɬɢɪɨɜɚɬɶ ɟɝɨ ɪɚɡɥɢɱɧɵɦɢ ɫɩɨɫɨɛɚɦɢ ɫ ɩɪɢɦɟɧɟɧɢɟɦ ɩɪɟɞɢɤɚɬɨɜ ɫɪɚɜ-
ɧɟɧɢɹ ɫ ɪɚɡɵɦɟɧɨɜɚɧɢɟɦ. Ɉɞɧɚɤɨ ɜɦɟɫɬɨ ɤɨɧɬɟɣɧɟɪɚ ɭɤɚɡɚɬɟɥɟɣ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɬɟɣ-
ɧɟɪ ɨɛɴɟɤɬɨɜ ɬɢɩɚ MainContainer::iterator (ɤɨɬɨɪɵɟ ɹɜɥɹɸɬɫɹ ɡɧɚɱɟɧɢɹɦɢ).
Ссылки
[Allison98] §14 • [Austern99] §6 • [Dewhurst03] §68 • [Josuttis99] §5.10.2 • [Koenig97] §5 •
[Meyers01] §3, §7-8 • [SuttHysl04b]
Стр. 168
80. Предпочитайте push_back другим
способам расширения
последовательности
Резюме
ɂɫɩɨɥɶɡɭɣɬɟ push_back ɜɟɡɞɟ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ. ȿɫɥɢ ɞɥɹ ɜɚɫ ɧɟ ɜɚɠɧɚ ɩɨɡɢɰɢɹ ɜɫɬɚɜɤɢ
ɧɨɜɨɝɨ ɨɛɴɟɤɬɚ, ɥɭɱɲɟ ɜɫɟɝɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɞɨɛɚɜɥɟɧɢɹ ɷɥɟɦɟɧɬɚ ɜ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɮɭɧɤɰɢɸ push_back. ȼɫɟ ɩɪɨɱɢɟ ɫɪɟɞɫɬɜɚ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɤɚɤ ɝɨɪɚɡɞɨ ɦɟɧɟɟ ɛɵɫɬɪɵɦɢ, ɬɚɤ
ɢ ɦɟɧɟɟ ɩɨɧɹɬɧɵɦɢ.
ȼɵ ɦɨɠɟɬɟ ɜɫɬɚɜɢɬɶ ɷɥɟɦɟɧɬɵ ɜ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɜ ɪɚɡɧɵɯ ɬɨɱɤɚɯ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
insert; ɞɨɛɚɜɢɬɶ ɷɥɟɦɟɧɬɵ ɜ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɦɨɠɧɨ ɪɚɡɧɵɦɢ ɫɩɨɫɨɛɚɦɢ, ɜɤɥɸɱɚɹ ɫɥɟ-
ɞɭɸɳɢɟ:
vector<int> vec; // vec ǺǾǼǽ
vec.resize(vec.size() + 1, 1); // vec ǼǹǯǰǻǱǳǽ { 1 }
vec.insert(vec.end(), 2); // vec ǼǹǯǰǻǱǳǽ { 1, 2 }
vec.push_back(3); // vec ǼǹǯǰǻǱǳǽ { 1, 2, 3 }
ɋɪɟɞɢ ɩɪɨɱɢɯ ɦɟɬɨɞɨɜ push_back ɟɞɢɧɫɬɜɟɧɧɵɣ ɢɦɟɟɬ ɩɨɫɬɨɹɧɧɨɟ ɚɦɨɪɬɢɡɢɪɨɜɚɧɧɨɟ
ɜɪɟɦɹ ɪɚɛɨɬɵ. ȼɪɟɦɹ ɪɚɛɨɬɵ ɞɪɭɝɢɯ ɦɟɬɨɞɨɜ ɯɭɠɟ — ɜɩɥɨɬɶ ɞɨ ɤɜɚɞɪɚɬɢɱɧɨɝɨ. ɂɡɥɢɲɧɟ ɝɨ-
ɜɨɪɢɬɶ, ɱɬɨ ɩɪɢ ɛɨɥɶɲɢɯ ɪɚɡɦɟɪɚɯ ɞɚɧɧɵɯ ɩɥɨɯɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ ɩɪɟɩɹɬɫɬɜɭɟɬ ɦɚɫɲɬɚɛɢɪɭɟ-
ɦɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 7).
Ɇɚɝɢɹ push_back ɩɪɨɫɬɚ: ɷɬɚ ɮɭɧɤɰɢɹ ɭɜɟɥɢɱɢɜɚɟɬ ɟɦɤɨɫɬɶ ɷɤɫɩɨɧɟɧɰɢɚɥɶɧɨ, ɚ ɧɟ ɧɚ
ɮɢɤɫɢɪɨɜɚɧɧɨɟ ɡɧɚɱɟɧɢɟ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɤɨɥɢɱɟɫɬɜɨ ɩɟɪɟɪɚɫɩɪɟɞɟɥɟɧɢɣ ɩɚɦɹɬɢ ɢ ɤɨɩɢɪɨɜɚ-
ɧɢɣ ɛɵɫɬɪɨ ɭɦɟɧɶɲɚɟɬɫɹ ɫ ɭɜɟɥɢɱɟɧɢɟɦ ɪɚɡɦɟɪɚ. ȼ ɫɥɭɱɚɟ ɤɨɧɬɟɣɧɟɪɚ, ɤɨɬɨɪɵɣ ɡɚɩɨɥɧɹɟɬɫɹ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɬɨɥɶɤɨ ɥɢɲɶ ɮɭɧɤɰɢɢ push_back, ɤɚɠɞɵɣ ɷɥɟɦɟɧɬ ɤɨɩɢɪɭɟɬɫɹ ɜ ɫɪɟɞɧɟɦ
ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ — ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɤɨɧɟɱɧɨɝɨ ɪɚɡɦɟɪɚ ɤɨɧɬɟɣɧɟɪɚ.
Ʉɨɧɟɱɧɨ, resize ɢ insert ɦɨɝɭɬ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɬɨɣ ɠɟ ɫɬɪɚɬɟɝɢɟɣ, ɧɨ ɷɬɨ ɭɠɟ ɡɚɜɢɫɢɬ
ɨɬ ɪɟɚɥɢɡɚɰɢɢ; ɝɚɪɚɧɬɢɸ ɞɚɟɬ ɬɨɥɶɤɨ push_back.
Ⱥɥɝɨɪɢɬɦɵ ɧɟ ɦɨɝɭɬ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɨɛɪɚɳɚɬɶɫɹ ɤ push_back, ɩɨɫɤɨɥɶɤɭ ɨɧɢ ɧɟ ɢɦɟɸɬ
ɞɨɫɬɭɩɚ ɤ ɤɨɧɬɟɣɧɟɪɚɦ. ȼɵ ɦɨɠɟɬɟ ɩɨɬɪɟɛɨɜɚɬɶ ɨɬ ɚɥɝɨɪɢɬɦɚ ɢɫɩɨɥɶɡɨɜɚɬɶ push_back, ɜɨɫ-
ɩɨɥɶɡɨɜɚɜɲɢɫɶ back_inserter.
ȿɫɥɢ ɜɵ ɞɨɛɚɜɥɹɟɬɟ ɧɟ ɨɞɢɧ ɷɥɟɦɟɧɬ, ɚ ɞɢɚɩɚɡɨɧ, ɬɨ ɞɚɠɟ ɟɫɥɢ ɞɨɛɚɜɥɟɧɢɟ ɜɵɩɨɥɧɹɟɬɫɹ
ɜ ɤɨɧɟɰ ɤɨɧɬɟɣɧɟɪɚ, ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɭɧɤɰɢɸ ɞɥɹ ɜɫɬɚɜɤɢ ɞɢɚɩɚɡɨɧɚ ɡɧɚɱɟɧɢɣ (ɫɦ. ɪɟɤɨ-
ɗɤɫɩɨɧɟɧɰɢɚɥɶɧɵɣ ɪɨɫɬ ɩɪɢɜɨɞɢɬ ɤ ɪɚɫɬɨɱɢɬɟɥɶɧɨɦɭ ɜɵɞɟɥɟɧɢɸ ɩɚɦɹɬɢ. Ⱦɥɹ ɬɨɧɤɨɣ ɧɚ-
ɫɬɪɨɣɤɢ ɪɨɫɬɚ ɦɨɠɧɨ ɹɜɧɨ ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ reserve — ɮɭɧɤɰɢɢ push_back, resize ɢ ɩɨ-
ɞɨɛɧɵɟ ɧɟ ɛɭɞɭɬ ɩɟɪɟɪɚɫɩɪɟɞɟɥɹɬɶ ɩɚɦɹɬɶ, ɟɫɥɢ ɟɟ ɞɨɫɬɚɬɨɱɧɨ ɞɥɹ ɪɚɛɨɬɵ. Ⱦɥɹ ɩɨɥɭɱɟɧɢɹ ɜɟɤ-
ɬɨɪɚ “ɩɪɚɜɢɥɶɧɨɝɨ ɪɚɡɦɟɪɚ” ɫɥɟɞɭɟɬ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɞɢɨɦɨɣ “ɝɨɪɹɱɟɣ ɩɨɫɚɞɤɢ” (ɫɦ. ɪɟɤɨɦɟɧ-
ɞɚɰɢɸ 82).
Ссылки
[Stroustrup00] §3.7-8, §16.3.5, §17.1.4.1
80. Предпочитайте push_back другим способам расширения последовательности 169
Стр. 169
81. Предпочитайте операции с диапазонами
операциям с отдельными элементами
Резюме
ɉɪɢ ɞɨɛɚɜɥɟɧɢɢ ɷɥɟɦɟɧɬɨɜ ɜ ɤɨɧɬɟɣɧɟɪ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɩɟɪɚɰɢɢ ɫ ɞɢɚɩɚɡɨɧɚɦɢ
(ɬ.ɟ. ɮɭɧɤɰɢɸ insert, ɤɨɬɨɪɚɹ ɩɨɥɭɱɚɟɬ ɩɚɪɭ ɢɬɟɪɚɬɨɪɨɜ), ɚ ɧɟ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɜɵɡɨɜɨɜ
ɮɭɧɤɰɢɢ ɞɥɹ ɜɫɬɚɜɤɢ ɨɞɧɨɝɨ ɷɥɟɦɟɧɬɚ. ȼɵɡɨɜ ɮɭɧɤɰɢɢ ɞɥɹ ɞɢɚɩɚɡɨɧɚ ɨɛɵɱɧɨ ɩɪɨɳɟ ɧɚɩɢ-
ɫɚɬɶ, ɥɟɝɱɟ ɱɢɬɚɬɶ, ɢ ɨɧ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɟɧ, ɱɟɦ ɹɜɧɵɣ ɰɢɤɥ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 84).
ɑɟɦ ɛɨɥɶɲɢɣ ɤɨɧɬɟɤɫɬ ɩɟɪɟɞɚɟɬɫɹ ɮɭɧɤɰɢɢ, ɬɟɦ ɛɨɥɶɲɟ ɜɟɪɨɹɬɧɨɫɬɶ ɬɨɝɨ, ɱɬɨ ɨɧɚ ɫɦɨɠɟɬ
ɥɭɱɲɟ ɪɚɫɩɨɪɹɞɢɬɶɫɹ ɩɨɥɭɱɟɧɧɨɣ ɢɧɮɨɪɦɚɰɢɟɣ. ȼ ɱɚɫɬɧɨɫɬɢ, ɤɨɝɞɚ ɜɵ ɜɵɡɵɜɚɟɬɟ ɮɭɧɤɰɢɸ
ɢ ɩɟɪɟɞɚɟɬɟ ɟɣ ɩɚɪɭ ɢɬɟɪɚɬɨɪɨɜ, ɭɤɚɡɵɜɚɸɳɢɯ ɧɟɤɨɬɨɪɵɣ ɞɢɚɩɚɡɨɧ, ɨɧɚ ɦɨɠɟɬ ɜɵɩɨɥɧɢɬɶ
ɨɩɬɢɦɢɡɚɰɢɸ, ɨɫɧɨɜɚɧɧɭɸ ɧɚ ɡɧɚɧɢɢ ɤɨɥɢɱɟɫɬɜɚ ɨɛɴɟɤɬɨɜ, ɤɨɬɨɪɵɟ ɞɨɥɠɧɵ ɛɵɬɶ ɞɨɛɚɜɥɟɧɵ
(ɜɵɱɢɫɥɹɟɦɨɟ ɤɚɤ distance(first,last)).
Ɍɨ ɠɟ ɫɚɦɨɟ ɦɨɠɧɨ ɫɤɚɡɚɬɶ ɢ ɨɛ ɨɩɟɪɚɰɢɹɯ “ɩɨɜɬɨɪɢɬɶ n ɪɚɡ”, ɧɚɩɪɢɦɟɪ, ɨ ɤɨɧɫɬɪɭɤɬɨɪɟ
vector, ɤɨɬɨɪɵɣ ɩɨɥɭɱɚɟɬ ɤɨɥɢɱɟɫɬɜɨ ɩɨɜɬɨɪɟɧɢɣ ɢ ɡɧɚɱɟɧɢɟ.
Примеры
ɉɪɢɦɟɪ 1. vector::insert. ɉɭɫɬɶ ɜɚɦ ɧɚɞɨ ɞɨɛɚɜɢɬɶ n ɷɥɟɦɟɧɬɨɜ ɜ vector v. Ɇɧɨɝɨ-
ɤɪɚɬɧɵɣ ɜɵɡɨɜ v.insert(position,x) ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɨɞɧɨɤɪɚɬɧɨɦɭ ɩɟɪɟɪɚɫɩɪɟɞɟ-
ɥɟɧɢɸ ɩɚɦɹɬɢ, ɤɨɝɞɚ ɜɟɤɬɨɪ v ɢɦɟɟɬ ɧɟɞɨɫɬɚɬɨɱɧɨ ɦɟɫɬɚ ɞɥɹ ɪɚɡɦɟɳɟɧɢɹ ɧɨɜɨɝɨ ɷɥɟɦɟɧɬɚ.
ɑɬɨ ɟɳɟ ɯɭɠɟ, ɜɫɬɚɜɤɚ ɤɚɠɞɨɝɨ ɨɬɞɟɥɶɧɨɝɨ ɷɥɟɦɟɧɬɚ ɢɦɟɟɬ ɥɢɧɟɣɧɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ, ɩɨɫɤɨɥɶ-
ɤɭ ɨɧɚ ɞɨɥɠɧɚ ɩɟɪɟɧɟɫɬɢ ɪɹɞ ɷɥɟɦɟɧɬɨɜ, ɱɬɨɛɵ ɨɫɜɨɛɨɞɢɬɶ ɬɪɟɛɭɟɦɭɸ ɩɨɡɢɰɢɸ ɞɥɹ ɜɫɬɚɜ-
ɥɹɟɦɨɝɨ ɷɥɟɦɟɧɬɚ, ɚ ɷɬɨ ɩɪɢɜɨɞɢɬ ɤ ɬɨɦɭ, ɱɬɨ ɜɫɬɚɜɤɚ n ɷɥɟɦɟɧɬɨɜ ɩɪɢ ɩɨɦɨɳɢ ɩɨɫɥɟɞɨɜɚ-
ɬɟɥɶɧɵɯ ɜɵɡɨɜɨɜ ɢɦɟɟɬ ɤɜɚɞɪɚɬɢɱɧɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ! Ʉɨɧɟɱɧɨ, ɢɡɛɟɠɚɬɶ ɩɪɨɛɥɟɦɵ ɦɧɨɠɟɫɬ-
ɜɟɧɧɨɝɨ ɩɟɪɟɪɚɫɩɪɟɞɟɥɟɧɢɹ ɩɚɦɹɬɢ ɦɨɠɧɨ ɩɪɢ ɩɨɦɨɳɢ ɜɵɡɨɜɚ reserve, ɧɨ ɷɬɨ ɧɟ ɫɧɢɡɢɬ
ɤɨɥɢɱɟɫɬɜɚ ɩɟɪɟɦɟɳɟɧɢɣ ɷɥɟɦɟɧɬɨɜ ɢ ɤɜɚɞɪɚɬɢɱɧɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ ɬɚɤɨɝɨ ɚɥɝɨɪɢɬɦɚ. Ȼɵɫɬɪɟɟ
ɢ ɩɪɨɳɟ ɹɫɧɨ ɫɤɚɡɚɬɶ, ɱɬɨ ɜɚɦ ɧɚɞɨ: v.insert(position,first,last), ɝɞɟ first
ɢ last — ɢɬɟɪɚɬɨɪɵ, ɨɩɪɟɞɟɥɹɸɳɢɟ ɞɢɚɩɚɡɨɧ ɷɥɟɦɟɧɬɨɜ, ɤɨɬɨɪɵɟ ɞɨɥɠɧɵ ɛɵɬɶ ɞɨɛɚɜɥɟɧɵ
ɜ v. (ȿɫɥɢ first ɢ last — ɜɯɨɞɧɵɟ ɢɬɟɪɚɬɨɪɵ, ɬɨ ɜɨɡɦɨɠɧɨɫɬɢ ɨɩɪɟɞɟɥɢɬɶ ɪɚɡɦɟɪ ɞɢɚɩɚɡɨ-
ɧɚ ɩɟɪɟɞ ɟɝɨ ɞɟɣɫɬɜɢɬɟɥɶɧɵɦ ɩɪɨɯɨɞɨɦ ɧɟɬ, ɬɚɤ ɱɬɨ ɜɟɤɬɨɪɭ v ɦɨɠɟɬ ɩɨɬɪɟɛɨɜɚɬɶɫɹ ɦɧɨɝɨ-
ɤɪɚɬɧɨɟ ɩɟɪɟɪɚɫɩɪɟɞɟɥɟɧɢɟ ɩɚɦɹɬɢ; ɬɟɦ ɧɟ ɦɟɧɟɟ, ɜɟɪɫɢɹ ɞɥɹ ɜɫɬɚɜɤɢ ɞɢɚɩɚɡɨɧɚ ɜɫɟ ɪɚɜɧɨ
ɫɤɨɪɟɟ ɜɫɟɝɨ ɛɭɞɟɬ ɛɨɥɟɟ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɣ, ɱɟɦ ɜɫɬɚɜɤɚ ɨɬɞɟɥɶɧɵɯ ɷɥɟɦɟɧɬɨɜ.)
ɉɪɢɦɟɪ 2. ɋɨɡɞɚɧɢɟ ɢ ɩɪɢɫɜɚɢɜɚɧɢɟ ɞɢɚɩɚɡɨɧɚ. ȼɵɡɨɜ ɤɨɧɫɬɪɭɤɬɨɪɚ (ɢɥɢ ɮɭɧɤɰɢɢ ɩɪɢ-
ɫɜɚɢɜɚɧɢɹ), ɤɨɬɨɪɵɣ ɩɨɥɭɱɚɟɬ ɞɢɚɩɚɡɨɧ ɢɬɟɪɚɬɨɪɨɜ, ɨɛɵɱɧɨ ɜɵɩɨɥɧɹɟɬɫɹ ɛɵɫɬɪɟɟ, ɱɟɦ ɜɵɡɨɜ
ɤɨɧɫɬɪɭɤɬɨɪɚ ɩɨ ɭɦɨɥɱɚɧɢɸ (ɢɥɢ ɮɭɧɤɰɢɢ clear) ɫ ɩɨɫɥɟɞɭɸɳɢɦɢ ɢɧɞɢɜɢɞɭɚɥɶɧɵɦɢ ɜɫɬɚɜ-
ɤɚɦɢ ɜ ɤɨɧɬɟɣɧɟɪ.
Ссылки
[Meyers01] §5 • [Stroustrup00] §16.3.8
Стр. 170
82. Используйте подходящие идиомы для реального уменьшения емкости контейнера ...
82. Используйте подходящие идиомы

для реального уменьшения емкости
контейнера и удаления элементов
82. Используйте подходящие идиомы для реального уменьшения емкости контейнера ...
Резюме
Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɢɡɛɚɜɢɬɶɫɹ ɨɬ ɢɡɥɢɲɧɟɣ ɟɦɤɨɫɬɢ ɤɨɧɬɟɣɧɟɪɚ, ɜɨɫɩɨɥɶɡɭɣ-
ɬɟɫɶ ɬɪɸɤɨɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɛɦɟɧɚ, ɚ ɞɥɹ ɪɟɚɥɶɧɨɝɨ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ ɢɡ ɤɨɧɬɟɣɧɟɪɚ —
ɢɞɢɨɦɨɣ erase-remove.
ɇɟɤɨɬɨɪɵɟ ɤɨɧɬɟɣɧɟɪɵ (ɧɚɩɪɢɦɟɪ, vector, string, deque) ɦɨɝɭɬ ɢɦɟɬɶ “ɥɢɲɧɸɸ” ɟɦ-
ɤɨɫɬɶ, ɤɨɬɨɪɚɹ ɛɨɥɶɲɟ ɧɟ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ. ɏɨɬɹ ɫɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɧɟ ɩɪɟ-
ɞɨɫɬɚɜɥɹɟɬ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨɝɨ ɫɩɨɫɨɛɚ ɞɥɹ ɭɞɚɥɟɧɢɹ ɢɡɥɢɲɧɟɣ ɟɦɤɨɫɬɢ, ɫɥɟɞɭɸɳɚɹ ɢɞɢɨɦɚ ɧɚ
ɩɪɚɤɬɢɤɟ ɨɤɚɡɵɜɚɟɬɫɹ ɜɩɨɥɧɟ ɪɚɛɨɬɨɫɩɨɫɨɛɧɨɣ:
container<T>(c).swap(c); // ǓǯǳǹǷǫ "ǮǹǻȊȂǰǴ ǺǹǼǫǯǵǳ" ǯǶȊ
// ǾǼǽǻǫǸǰǸǳȊ ǳǲǶǳȃǸǰǴ ǰǷǵǹǼǽǳ
// ǵǹǸǽǰǴǸǰǻǫ
Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɩɨɥɧɨɫɬɶɸ ɨɩɭɫɬɨɲɢɬɶ c, ɭɞɚɥɢɜ ɜɫɟ ɷɥɟɦɟɧɬɵ ɢ ɭɛɪɚɜ ɜɫɸ ɟɦɤɨɫɬɶ,
ɢɞɢɨɦɚ ɞɨɥɠɧɚ ɜɵɝɥɹɞɟɬɶ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
container<T>().swap(c); // ǓǯǳǹǷǫ ǯǶȊ ǾǯǫǶǰǸǳȊ ǭǼǰǮǹ
// ǼǹǯǰǻǱǳǷǹǮǹ ǳ ǰǷǵǹǼǽǳ
Ʉɪɨɦɟ ɬɨɝɨ, ɨɛɵɱɧɨ ɞɥɹ ɧɨɜɢɱɤɨɜ ɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ STL ɨɤɚɡɵɜɚɟɬ-
ɫɹ ɫɸɪɩɪɢɡɨɦ ɬɨ, ɱɬɨ ɚɥɝɨɪɢɬɦ remove ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɧɟ ɭɞɚɥɹɟɬ ɷɥɟɦɟɧɬɵ ɢɡ ɤɨɧɬɟɣ-
ɧɟɪɚ. ɉɨɧɹɬɧɨ, ɱɬɨ ɞɚɧɧɵɣ ɚɥɝɨɪɢɬɦ ɧɚ ɷɬɨ ɧɟ ɫɩɨɫɨɛɟɧ — ɜɟɞɶ ɚɥɝɨɪɢɬɦ ɪɚɛɨɬɚɟɬ ɬɨɥɶɤɨ
ɫ ɞɢɚɩɚɡɨɧɨɦ ɢɬɟɪɚɬɨɪɨɜ ɢ ɧɟ ɦɨɠɟɬ ɧɢɱɟɝɨ ɪɟɚɥɶɧɨ ɭɞɚɥɢɬɶ ɢɡ ɤɨɧɬɟɣɧɟɪɚ ɛɟɡ ɜɵɡɨɜɚ ɮɭɧɤ-
ɰɢɢ-ɱɥɟɧɚ ɤɨɧɬɟɣɧɟɪɚ, ɨɛɵɱɧɨ erase. ɍɞɚɥɟɧɢɟ ɫɜɨɞɢɬɫɹ ɤ ɩɟɪɟɦɟɳɟɧɢɸ ɷɥɟɦɟɧɬɨɜ, ɤɨɬɨ-
ɪɵɟ ɞɨɥɠɧɵ ɛɵɬɶ “ɭɞɚɥɟɧɵ”, ɢ ɜɨɡɜɪɚɬɭ ɢɬɟɪɚɬɨɪɚ, ɭɤɚɡɵɜɚɸɳɟɝɨ ɧɚ ɷɥɟɦɟɧɬ, ɫɥɟɞɭɸɳɢɣ ɡɚ
ɩɨɫɥɟɞɧɢɦ ɧɟɭɞɚɥɟɧɧɵɦ. Ⱦɥɹ ɪɟɚɥɶɧɨɝɨ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ ɢɡ ɤɨɧɬɟɣɧɟɪɚ ɩɨɫɥɟ ɜɵɡɨɜɚ
remove ɫɥɟɞɭɟɬ ɜɵɡɜɚɬɶ erase — ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɞɢɨɦɨɣ erase-remove. ɇɚɩɪɢɦɟɪ, ɞɥɹ
ɪɟɚɥɶɧɨɝɨ ɭɞɚɥɟɧɢɹ ɜɫɟɯ ɷɥɟɦɟɧɬɨɜ, ɪɚɜɧɵɯ value, ɢɡ ɤɨɧɬɟɣɧɟɪɚ c, ɦɨɠɧɨ ɧɚɩɢɫɚɬɶ:
c.e
erase( remove ( c.begin(), c.end() ,value ), c.end() );
ȿɫɥɢ ɤɨɧɬɟɣɧɟɪ ɢɦɟɟɬ ɫɨɛɫɬɜɟɧɧɭɸ ɜɟɪɫɢɸ remove ɢɥɢ remove_if, ɠɟɥɚɬɟɥɶɧɨ ɢɫɩɨɥɶ-
ɡɨɜɚɬɶ ɢɦɟɧɧɨ ɟɟ.
Ɉɩɢɫɚɧɧɚɹ ɢɞɢɨɦɚ “ɝɨɪɹɱɟɣ ɭɫɚɞɤɢ” ɧɟ ɪɚɛɨɬɚɟɬ ɫ ɪɟɚɥɢɡɚɰɢɹɦɢ std::string ɫ ɤɨɩɢɪɨ-
ɜɚɧɢɟɦ ɩɪɢ ɡɚɩɢɫɢ. Ɉɛɵɱɧɨ ɪɚɛɨɬɚɟɬ ɜɵɡɨɜ s.reserve(0) ɢɥɢ ɬɚɤɨɣ ɬɪɸɤ, ɤɚɤ
string(s.begin(),s.end()).swap(s);, ɜ ɤɨɬɨɪɨɦ ɢɫɩɨɥɶɡɨɜɚɧ ɤɨɧɫɬɪɭɤɬɨɪ ɧɚ ɨɫɧɨɜɟ
ɞɜɭɯ ɢɬɟɪɚɬɨɪɨɜ. ɇɚ ɩɪɚɤɬɢɤɟ ɷɬɢ ɦɟɬɨɞɵ ɨɛɵɱɧɨ ɪɚɛɨɬɚɸɬ ɢ ɭɫɬɪɚɧɹɸɬ ɢɡɥɢɲɧɸɸ ɟɦɤɨɫɬɶ.
(Ȼɵɥɨ ɛɵ ɟɳɟ ɥɭɱɲɟ, ɱɬɨɛɵ ɪɟɚɥɢɡɚɰɢɢ std::string ɧɟ ɢɫɩɨɥɶɡɨɜɚɥɢ ɬɚɤɨɣ ɭɫɬɚɪɟɜɲɢɣ
ɦɟɬɨɞ ɨɩɬɢɦɢɡɚɰɢɢ, ɤɚɤ ɤɨɩɢɪɨɜɚɧɢɟ ɩɪɢ ɡɚɩɢɫɢ; ɫɦ. [Sutter02].)
Ссылки
[Josuttis99] §6.2.1 • [Meyers01] §17, §32, §44 • [Sutter00] §7 • [Sutter02] §7, §16
82. Используйте подходящие идиомы для реального уменьшения емкости контейнера...171
Стр. 171
Стр. 172
STL: алгоритмы
ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɚɥɝɨɪɢɬɦɵ ɰɢɤɥɚɦ.
Ⱥɥɝɨɪɢɬɦɵ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɰɢɤɥɵ — ɬɨɥɶɤɨ ɨɧɢ ɥɭɱɲɟ ɰɢɤɥɨɜ. Ⱥɥɝɨɪɢɬɦɵ — ɷɬɨ
“ɲɚɛɥɨɧɵ” ɰɢɤɥɨɜ, ɫ ɞɨɛɚɜɥɟɧɢɟɦ ɞɨɩɨɥɧɢɬɟɥɶɧɨɣ ɫɟɦɚɧɬɢɤɢ ɩɨ ɫɪɚɜɧɟɧɢɸ ɫ ɩɪɨɫɬɵɦɢ for
ɢ do. Ʉɨɧɟɱɧɨ, ɧɚɱɚɜ ɢɫɩɨɥɶɡɨɜɚɬɶ ɚɥɝɨɪɢɬɦɵ, ɜɵ ɧɚɱɧɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ
ɨɛɴɟɤɬɵ ɢ ɩɪɟɞɢɤɚɬɵ; ɤɨɪɪɟɤɬɧɨ ɩɢɲɢɬɟ ɢɯ ɢ ɲɢɪɨɤɨ ɢɫɩɨɥɶɡɭɣɬɟ ɜ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦɚɯ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 83 — “ɂɫɩɨɥɶɡɭɣɬɟ
ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ STL”.
82. Используйте подходящие идиомы для реального уменьшения емкости контейнера...173
Стр. 173
83. Используйте отладочную реализацию STL
Резюме
Ȼɟɡɨɩɚɫɧɨɫɬɶ ɩɪɟɜɵɲɟ ɜɫɟɝɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6). ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ
STL4, ɞɚɠɟ ɟɫɥɢ ɨɧɚ ɢɦɟɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɨɞɧɨɝɨ ɢɡ ɜɚɲɢɯ ɤɨɦɩɢɥɹɬɨɪɨɜ, ɢ ɞɚɠɟ ɟɫɥɢ ɨɧɚ ɢɫ-
ɩɨɥɶɡɭɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɨɬɥɚɞɨɱɧɨɝɨ ɬɟɫɬɢɪɨɜɚɧɢɹ.
Ɍɚɤ ɠɟ, ɤɚɤ ɥɟɝɤɨ ɨɲɢɛɢɬɶɫɹ ɩɪɢ ɪɚɛɨɬɟ ɫ ɭɤɚɡɚɬɟɥɹɦɢ, ɥɟɝɤɨ ɞɨɩɭɫɬɢɬɶ ɢ ɨɲɢɛɤɭ ɩɪɢ ɪɚ-
ɛɨɬɟ ɫ ɢɬɟɪɚɬɨɪɚɦɢ, ɩɪɢɱɟɦ ɬɚɤɭɸ, ɱɬɨ ɩɪɨɝɪɚɦɦɚ ɩɪɢ ɷɬɨɦ ɭɫɩɟɲɧɨ ɤɨɦɩɢɥɢɪɭɟɬɫɹ, ɚ ɩɪɢ
ɪɚɛɨɬɟ ɧɟɦɟɞɥɟɧɧɨ ɚɜɚɪɢɣɧɨ ɡɚɜɟɪɲɚɟɬɫɹ (ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ) ɢɥɢ ɪɚɛɨɬɚɟɬ ɧɟɜɟɪɧɨ (ɜ ɯɭɞ-
ɲɟɦ). Ⱦɚɠɟ ɟɫɥɢ ɜɚɲ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɨɛɧɚɪɭɠɢɥ ɧɢ ɨɞɧɨɣ ɨɲɢɛɤɢ, ɜɵ ɧɟ ɞɨɥɠɧɵ ɩɨɥɚɝɚɬɶɫɹ
ɧɚ “ɜɢɡɭɚɥɶɧɵɣ ɤɨɧɬɪɨɥɶ”: ɢɦɟɸɬɫɹ ɫɩɟɰɢɚɥɶɧɵɟ ɢɧɫɬɪɭɦɟɧɬɵ — ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɢɦɢ.
Ɋɹɞ ɨɲɢɛɨɤ ɩɪɢ ɪɚɛɨɬɟ ɫ STL ɱɚɫɬɨ ɞɨɩɭɫɤɚɸɬ ɞɚɠɟ ɨɩɵɬɧɵɟ ɩɪɨɝɪɚɦɦɢɫɬɵ.
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɯ ɢɥɢ ɧɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɯ ɢɬɟɪɚɬɨɪɨɜ. ȼ ɨɫɨɛɟɧ-
ɧɨɫɬɢ ɥɟɝɤɨ ɞɨɩɭɫɬɢɬɶ ɩɟɪɜɨɟ.
• ɉɟɪɟɞɚɱɚ ɢɧɞɟɤɫɚ, ɜɵɯɨɞɹɳɟɝɨ ɡɚ ɝɪɚɧɢɰɵ ɤɨɧɬɟɣɧɟɪɚ. ɇɚɩɪɢɦɟɪ, ɨɛɪɚɳɟɧɢɟ ɤ 113-ɦɭ
ɷɥɟɦɟɧɬɭ 100-ɷɥɟɦɟɧɬɧɨɝɨ ɤɨɧɬɟɣɧɟɪɚ.
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ “ɞɢɚɩɚɡɨɧɚ” ɢɬɟɪɚɬɨɪɨɜ, ɤɨɬɨɪɵɣ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟ ɹɜɥɹɟɬɫɹ ɞɢɚɩɚɡɨ-
ɧɨɦ. ɇɚɩɪɢɦɟɪ, ɩɟɪɟɞɚɱɚ ɞɜɭɯ ɢɬɟɪɚɬɨɪɨɜ, ɩɟɪɜɵɣ ɢɡ ɤɨɬɨɪɵɯ ɧɟ ɩɪɟɞɲɟɫɬɜɭɟɬ ɜɬɨ-
ɪɨɦɭ, ɢɥɢ ɤɨɝɞɚ ɨɧɢ ɭɤɚɡɵɜɚɸɬ ɧɚ ɪɚɡɧɵɟ ɤɨɧɬɟɣɧɟɪɵ.
• ɉɟɪɟɞɚɱɚ ɧɟɜɟɪɧɨɣ ɩɨɡɢɰɢɢ ɢɬɟɪɚɬɨɪɚ. ȼɵɡɨɜ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ ɤɨɧɬɟɣɧɟɪɚ, ɤɨɬɨɪɚɹ ɩɨ-
ɥɭɱɚɟɬ ɩɨɡɢɰɢɸ ɢɬɟɪɚɬɨɪɚ (ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɩɨɡɢɰɢɹ, ɩɟɪɟɞɚɜɚɟɦɚɹ ɮɭɧɤɰɢɢ insert), ɧɨ ɫ
ɩɟɪɟɞɚɱɟɣ ɢɬɟɪɚɬɨɪɚ, ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɜ ɞɪɭɝɨɣ ɤɨɧɬɟɣɧɟɪ.
• ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɜɟɪɧɨɝɨ ɭɩɨɪɹɞɨɱɟɧɢɹ. ɉɪɟɞɨɫɬɚɜɥɟɧɢɟ ɧɟɜɟɪɧɨɝɨ ɩɪɚɜɢɥɚ ɞɥɹ ɭɩɨ-
ɪɹɞɨɱɟɧɢɹ ɚɫɫɨɰɢɚɬɢɜɧɨɝɨ ɤɨɧɬɟɣɧɟɪɚ ɢɥɢ ɜ ɤɚɱɟɫɬɜɟ ɤɪɢɬɟɪɢɹ ɫɪɚɜɧɟɧɢɹ ɜ ɚɥɝɨɪɢɬɦɟ
ɫɨɪɬɢɪɨɜɤɢ (ɫɦ. ɩɪɢɦɟɪɵ ɜ [Meyers01]). ȿɫɥɢ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɬɥɚɞɨɱɧɨɣ ɜɟɪɫɢɢ STL,
ɬɚɤɢɟ ɨɲɢɛɤɢ ɨɛɵɱɧɨ ɩɪɨɹɜɥɹɸɬɫɹ ɜ ɩɪɨɰɟɫɫɟ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɤɚɤ ɧɟɜɟɪɧɨɟ
ɩɨɜɟɞɟɧɢɟ ɢɥɢ ɛɟɫɤɨɧɟɱɧɵɟ ɰɢɤɥɵ, ɧɨ ɧɟ ɤɚɤ ɚɜɚɪɢɣɧɵɣ ɨɫɬɚɧɨɜ.
Ȼɨɥɶɲɢɧɫɬɜɨ ɨɬɥɚɞɨɱɧɵɯ ɪɟɚɥɢɡɚɰɢɣ STL ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɨɛɧɚɪɭɠɢɜɚɸɬ ɬɚɤɢɟ ɨɲɢɛɤɢ,
ɩɪɢ ɩɨɦɨɳɢ ɞɨɩɨɥɧɢɬɟɥɶɧɨɣ ɨɬɥɚɞɨɱɧɨɣ ɢ ɫɢɫɬɟɦɧɨɣ ɢɧɮɨɪɦɚɰɢɢ, ɯɪɚɧɹɳɟɣɫɹ ɜ ɤɨɧɬɟɣɧɟ-
ɪɚɯ ɢ ɢɬɟɪɚɬɨɪɚɯ. ɇɚɩɪɢɦɟɪ, ɢɬɟɪɚɬɨɪ ɦɨɠɟɬ ɡɚɩɨɦɧɢɬɶ ɤɨɧɬɟɣɧɟɪ, ɤ ɤɨɬɨɪɨɦɭ ɨɧ ɨɛɪɚɳɚɟɬ-
ɫɹ, ɚ ɤɨɧɬɟɣɧɟɪ — ɡɚɩɨɦɧɢɬɶ ɜɫɟ ɢɬɟɪɚɬɨɪɵ, ɫɫɵɥɚɸɳɢɟɫɹ ɧɚ ɧɟɝɨ, ɬɚɤ ɱɬɨ ɦɨɠɧɨ ɨɬɫɥɟɞɢɬɶ
ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɫɬɚɜɲɟɝɨ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦ ɢɬɟɪɚɬɨɪɚ. Ʉɨɧɟɱɧɨ, ɷɬɨ ɭɜɟɥɢɱɢɜɚɟɬ ɪɚɡɦɟɪ ɢɬɟ-
ɪɚɬɨɪɨɜ ɢ ɤɨɧɬɟɣɧɟɪɨɜ, ɚ ɬɚɤɠɟ ɬɪɟɛɭɟɬ ɜɵɩɨɥɧɟɧɢɹ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɞɟɣɫɬɜɢɣ ɩɪɢ ɤɚɠɞɨɦ
ɢɡɦɟɧɟɧɢɢ ɤɨɧɬɟɣɧɟɪɚ. ɇɨ ɜɨɡɦɨɠɧɨɫɬɶ ɨɬɫɥɟɠɢɜɚɧɢɹ ɨɲɢɛɨɤ ɫɬɨɢɬ ɬɨɝɨ — ɩɨ ɤɪɚɣɧɟɣ ɦɟ-
ɪɟ, ɜ ɩɪɨɰɟɫɫɟ ɨɬɥɚɞɤɢ, ɚ ɜɨɡɦɨɠɧɨ, ɢ ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ ɜɟɪɫɢɢ ɩɪɨɝɪɚɦɦɵ (ɜɫɩɨɦɧɢɬɟ ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 8; ɧɟ ɨɬɤɥɸɱɚɣɬɟ ɩɨɥɟɡɧɵɟ ɩɪɨɜɟɪɤɢ ɞɥɹ ɩɨɜɵɲɟɧɢɹ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ ɞɨ ɬɟɯ
ɩɨɪ, ɩɨɤɚ ɧɟ ɭɛɟɞɢɬɟɫɶ ɜ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɬɚɤɨɝɨ ɲɚɝɚ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɵɦɢ ɢɡɦɟɪɟɧɢɹɦɢ).
Ⱦɚɠɟ ɟɫɥɢ ɜɵ ɧɟ ɧɚɦɟɪɟɧɵ ɨɫɬɚɜɥɹɬɶ ɩɪɨɜɟɪɤɢ ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ ɜɟɪɫɢɢ, ɢ ɞɚɠɟ ɟɫɥɢ ɭ ɜɚɫ
ɢɦɟɟɬɫɹ ɩɪɨɜɟɪɨɱɧɚɹ ɪɟɚɥɢɡɚɰɢɹ STL ɬɨɥɶɤɨ ɞɥɹ ɨɞɧɨɣ ɢɡ ɢɫɩɨɥɶɡɭɟɦɵɯ ɜɚɦɢ ɩɥɚɬɮɨɪɦ,
ɨɛɹɡɚɬɟɥɶɧɨ ɩɪɨɬɟɫɬɢɪɭɣɬɟ ɜɚɲɭ ɩɪɨɝɪɚɦɦɭ ɩɨɥɧɵɦ ɤɨɦɩɥɟɤɬɨɦ ɬɟɫɬɨɜ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ
ɨɬɥɚɞɨɱɧɨɣ ɪɟɚɥɢɡɚɰɢɢ STL. ȼɵ ɧɟ ɩɨɠɚɥɟɟɬɟ ɨɛ ɷɬɨɦ.
4
Checked implementation — ɩɨɞ ɷɬɢɦ ɩɨɞɪɚɡɭɦɟɜɚɟɬɫɹ ɪɟɚɥɢɡɚɰɢɹ STL ɫ ɞɨɩɨɥɧɢɬɟɥɶɧɵɦɢ ɩɪɨɜɟɪɤɚɦɢ ɜ
ɤɨɞɟ, ɧɟɨɛɹɡɚɬɟɥɶɧɵɦɢ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɫɬɚɧɞɚɪɬɚ. — ɉɪɢɦ. ɩɟɪɟɜ.
174 STL: алгоритмы
Стр. 174
Примеры
ɉɪɢɦɟɪ 1. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɨɝɨ ɢɬɟɪɚɬɨɪɚ. Ɉɱɟɧɶ ɩɪɨɫɬɨ ɡɚɛɵɬɶ, ɱɬɨ ɢɬɟ-
ɪɚɬɨɪɵ ɫɬɚɥɢ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵ, ɢ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɬɚɤɢɦ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɦ ɢɬɟɪɚɬɨɪɨɦ (ɫɦ.
ɪɟɤɨɦɟɧɞɚɰɢɸ 99). Ɋɚɫɫɦɨɬɪɢɦ ɩɨɞɨɛɧɵɣ ɩɪɢɦɟɪ, ɚɞɚɩɬɢɪɨɜɚɧɧɵɣ ɢɡ [Meyers01], ɝɞɟ ɩɪɨɢɫ-
ɯɨɞɢɬ ɜɫɬɚɜɤɚ ɷɥɟɦɟɧɬɨɜ ɜ ɧɚɱɚɥɨ deque:
deque<double>::iterator current = d.begin();
for( size_t i = 0; i < max; ++i )
d.insert(current++, data[i] + 41 ); // Ǎǳǯǳǽǰ Ƕǳ ǭȆ ǹȃǳǬǵǾ?
Ȼɵɫɬɪɨ ɨɬɜɟɬɶɬɟ — ɭɜɢɞɟɥɢ ɥɢ ɜɵ ɨɲɢɛɤɭ ɜ ɩɪɢɜɟɞɟɧɧɨɦ ɮɪɚɝɦɟɧɬɟ ɢɥɢ ɧɟɬ? ɍ ɜɚɫ ɬɨɥɶɤɨ
ɬɪɢ ɫɟɤɭɧɞɵ!
ȼɪɟɦɹ ɜɵɲɥɨ! ȿɫɥɢ ɜɵ ɧɟ ɡɚɦɟɬɢɥɢ ɨɲɢɛɤɭ ɡɚ ɨɬɩɭɳɟɧɧɨɟ ɜɪɟɦɹ, ɧɟ ɜɨɥɧɭɣɬɟɫɶ — ɷɬɨ ɞɨɫ-
ɬɚɬɨɱɧɨ ɬɨɧɤɚɹ ɢ ɩɨɧɹɬɧɚɹ ɨɲɢɛɤɚ. Ɉɬɥɚɞɨɱɧɚɹ ɜɟɪɫɢɹ STL ɨɛɧɚɪɭɠɢɬ ɞɚɧɧɭɸ ɨɲɢɛɤɭ ɧɚ ɜɬɨ-
ɪɨɣ ɢɬɟɪɚɰɢɢ ɰɢɤɥɚ, ɬɚɤ ɱɬɨ ɜɚɦ ɧɟ ɩɪɢɞɟɬɫɹ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɫɜɨɣ ɧɟɜɨɨɪɭɠɟɧɧɵɣ ɜɡɝɥɹɞ.
(ɂɫɩɪɚɜɥɟɧɧɚɹ ɜɟɪɫɢɹ ɞɚɧɧɨɝɨ ɤɨɞɚ ɢ ɚɥɶɬɟɪɧɚɬɢɜɧɵɟ ɜɚɪɢɚɧɬɵ ɜɵ ɧɚɣɞɟɬɟ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 84.)
ɉɪɢɦɟɪ 2. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɞɢɚɩɚɡɨɧɚ ɢɬɟɪɚɬɨɪɨɜ, ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟ ɹɜɥɹɸɳɟɝɨɫɹ ɞɢɚɩɚ-
ɡɨɧɨɦ. Ⱦɢɚɩɚɡɨɧ ɢɬɟɪɚɬɨɪɨɜ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɩɚɪɭ ɢɬɟɪɚɬɨɪɨɜ first ɢ last, ɤɨɬɨɪɵɟ
ɭɤɚɡɵɜɚɸɬ ɧɚ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ ɞɢɚɩɚɡɨɧɚ, ɢ ɷɥɟɦɟɧɬ, ɫɥɟɞɭɸɳɢɣ ɡɚ ɩɨɫɥɟɞɧɢɦ ɷɥɟɦɟɧɬɨɦ
ɞɢɚɩɚɡɨɧɚ. Ⱦɢɚɩɚɡɨɧ ɬɪɟɛɭɟɬ, ɱɬɨɛɵ ɢɬɟɪɚɬɨɪ last ɛɵɥ ɞɨɫɬɢɠɢɦ ɢɡ first ɩɭɬɟɦ ɧɟɤɨɬɨɪɨ-
ɝɨ ɤɨɥɢɱɟɫɬɜɚ ɩɨɜɬɨɪɧɵɯ ɭɜɟɥɢɱɟɧɢɣ ɩɪɢ ɩɨɦɨɳɢ ɨɩɟɪɚɬɨɪɚ ɢɧɤɪɟɦɟɧɬɚ ɢɬɟɪɚɬɨɪɚ first.
ɂɡɜɟɫɬɧɵ ɞɜɚ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ ɜɢɞɚ ɨɲɢɛɤɢ, ɤɨɝɞɚ ɩɪɨɢɫɯɨɞɢɬ ɩɨɩɵɬɤɚ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɢɚ-
ɩɚɡɨɧ, ɤɨɬɨɪɵɣ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɞɢɚɩɚɡɨɧɨɦ ɧɟ ɹɜɥɹɟɬɫɹ. ɉɟɪɜɚɹ ɨɲɢɛɤɚ ɜɨɡɧɢɤɚɟɬ, ɤɨɝɞɚ ɞɜɚ
ɢɬɟɪɚɬɨɪɚ ɨɝɪɚɧɢɱɢɜɚɸɬ ɞɢɚɩɚɡɨɧ ɜ ɩɪɟɞɟɥɚɯ ɨɞɧɨɝɨ ɤɨɧɬɟɣɧɟɪɚ, ɧɨ ɢɬɟɪɚɬɨɪ first ɧɚ ɫɚ-
ɦɨɦ ɞɟɥɟ ɧɟ ɩɪɟɞɲɟɫɬɜɭɟɬ ɢɬɟɪɚɬɨɪɭ second:
for_each(c.e
end(),c.b
begin(),Something); // ǘǰ ǭǼǰǮǯǫ ǹȂǰǭǳǯǸǹ
ɇɚ ɤɚɠɞɨɣ ɢɬɟɪɚɰɢɢ ɫɜɨɟɝɨ ɜɧɭɬɪɟɧɧɟɝɨ ɰɢɤɥɚ ɚɥɝɨɪɢɬɦ for_each ɛɭɞɟɬ ɩɪɨɜɟɪɹɬɶ ɢɬɟɪɚɬɨɪ
first ɧɚ ɪɚɜɟɧɫɬɜɨ ɢɬɟɪɚɬɨɪɭ second, ɢ ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɨɧɢ ɧɟ ɪɚɜɧɵ, ɨɧ ɛɭɞɟɬ ɭɜɟɥɢɱɢ-
ɜɚɬɶ ɢɬɟɪɚɬɨɪ first. Ʉɨɧɟɱɧɨ, ɫɤɨɥɶɤɨ ɛɵ ɪɚɡ ɧɟ ɛɵɥ ɭɜɟɥɢɱɟɧ ɢɬɟɪɚɬɨɪ first, ɟɦɭ ɧɢɤɨɝɞɚ
ɧɟ ɫɬɚɬɶ ɪɚɜɧɵɦ ɢɬɟɪɚɬɨɪɭ second, ɬɚɤ ɱɬɨ ɰɢɤɥ ɩɨ ɫɭɬɢ ɨɤɚɡɵɜɚɟɬɫɹ ɛɟɫɤɨɧɟɱɧɵɦ. ɇɚ ɩɪɚɤ-
ɬɢɤɟ ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ ɰɢɤɥ ɡɚɜɟɪɲɢɬɫɹ ɜɵɯɨɞɨɦ ɡɚ ɩɪɟɞɟɥɵ ɤɨɧɬɟɣɧɟɪɚ c ɢ ɧɟɦɟɞɥɟɧɧɵɦ
ɚɜɚɪɢɣɧɵɦ ɡɚɜɟɪɲɟɧɢɟɦ ɩɪɨɝɪɚɦɦɵ ɢɡ-ɡɚ ɧɚɪɭɲɟɧɢɹ ɡɚɳɢɬɵ ɩɚɦɹɬɢ. ȼ ɯɭɞɲɟɦ ɫɥɭɱɚɟ, ɜɵɣ-
ɞɹ ɡɚ ɩɪɟɞɟɥɵ ɤɨɧɬɟɣɧɟɪɚ, ɢɬɟɪɚɬɨɪ ɛɭɞɟɬ ɫɱɢɬɵɜɚɬɶ ɢɥɢ ɞɚɠɟ ɦɟɧɹɬɶ ɞɚɧɧɵɟ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ
ɱɚɫɬɶɸ ɤɨɧɬɟɣɧɟɪɚ. ɗɬɨɬ ɪɟɡɭɥɶɬɚɬ ɜ ɩɪɢɧɰɢɩɟ ɧɟ ɫɥɢɲɤɨɦ ɨɬɥɢɱɚɟɬɫɹ ɨɬ ɡɧɚɤɨɦɵɯ ɧɚɦ ɩɨ-
ɫɥɟɞɫɬɜɢɣ ɩɟɪɟɩɨɥɧɟɧɢɹ ɛɭɮɟɪɚ…
ȼɬɨɪɚɹ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɚɹ ɨɲɢɛɤɚ ɜɨɡɧɢɤɚɟɬ, ɤɨɝɞɚ ɢɬɟɪɚɬɨɪɵ ɭɤɚɡɵɜɚɸɬ ɜ ɪɚɡɧɵɟ ɤɨɧ-
ɬɟɣɧɟɪɵ:
for_each(c
c.begin(),d
d.end(),Something); // ǘǰ ǭǼǰǮǯǫ ǹȂǰǭǳǯǸǹ
Ɋɟɡɭɥɶɬɚɬ ɬɚɤɨɣ ɨɲɢɛɤɢ ɚɧɚɥɨɝɢɱɟɧ ɪɟɡɭɥɶɬɚɬɭ ɩɪɟɞɵɞɭɳɟɣ. Ɉɞɧɚɤɨ ɩɨɫɤɨɥɶɤɭ ɢɬɟɪɚɬɨɪɵ
ɨɬɥɚɞɨɱɧɨɣ ɜɟɪɫɢɢ STL ɩɨɦɧɹɬ ɤɨɧɬɟɣɧɟɪ, ɫ ɤɨɬɨɪɵɦ ɪɚɛɨɬɚɸɬ, ɬɚɤɭɸ ɨɲɢɛɤɭ ɦɨɠɧɨ ɜɵ-
ɹɜɢɬɶ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ.
Ссылки
[Dinkumware-Safe] • [Horstmann95] • [Josuttis99] §5.11.1 • [Metrowerks] • [Meyers01] §21, §50 •
[STLport-Debug] • [Stroustrup00] §18.3.1, §19.3.1
83. Используйте отладочную реализацию STL 175
Стр. 175
84. Предпочитайте вызовы алгоритмов
самостоятельно разрабатываемым
циклам
Резюме
Ɋɚɡɭɦɧɨ ɢɫɩɨɥɶɡɭɣɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ. ȼ ɨɱɟɧɶ ɩɪɨɫɬɵɯ ɫɥɭɱɚɹɯ ɧɚɩɢɫɚɧɧɵɟ ɫɚ-
ɦɨɫɬɨɹɬɟɥɶɧɨ ɰɢɤɥɵ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɛɨɥɟɟ ɩɪɨɫɬɵɦ ɢ ɷɮɮɟɤɬɢɜɧɵɦ ɪɟɲɟɧɢɟɦ. Ɍɟɦ ɧɟ ɦɟ-
ɧɟɟ, ɜɵɡɨɜ ɚɥɝɨɪɢɬɦɚ ɜɦɟɫɬɨ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɪɚɡɪɚɛɨɬɚɧɧɨɝɨ ɰɢɤɥɚ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɛɨɥɟɟ
ɜɵɪɚɡɢɬɟɥɶɧɵɦ, ɥɟɝɱɟ ɫɨɩɪɨɜɨɠɞɚɟɦɵɦ, ɦɟɧɟɟ ɩɨɞɜɟɪɠɟɧɧɵɦ ɨɲɢɛɤɚɦ ɢ ɧɟ ɦɟɧɟɟ ɷɮɮɟɤ-
ɬɢɜɧɵɦ.
ɉɪɢ ɜɵɡɨɜɟ ɚɥɝɨɪɢɬɦɚ ɩɨɞɭɦɚɣɬɟ ɨ ɧɚɩɢɫɚɧɢɢ ɫɨɛɫɬɜɟɧɧɨɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɝɨ ɨɛɴɟɤɬɚ,
ɤɨɬɨɪɵɣ ɢɧɤɚɩɫɭɥɢɪɭɟɬ ɜɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɥɨɝɢɤɭ. ɂɡɛɟɝɚɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɫɜɹɡɵɜɚɬɟɥɟɣ ɩɚ-
ɪɚɦɟɬɪɨɜ ɢ ɩɪɨɫɬɵɯ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ (ɧɚɩɪɢɦɟɪ, bind2nd, plus), ɱɬɨ ɨɛɵɱɧɨ
ɫɧɢɠɚɟɬ ɹɫɧɨɫɬɶ ɤɨɞɚ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɥɹɦɛɞɚ-ɛɢɛɥɢɨɬɟɤɢ [Boost], ɤɨɬɨɪɚɹ ɚɜ-
ɬɨɦɚɬɢɡɢɪɭɟɬ ɡɚɞɚɱɭ ɧɚɩɢɫɚɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ.
ɉɪɨɝɪɚɦɦɵ, ɤɨɬɨɪɵɟ ɢɫɩɨɥɶɡɭɸɬ STL, ɢɦɟɸɬ ɬɟɧɞɟɧɰɢɸ ɤ ɦɟɧɶɲɟɦɭ ɤɨɥɢɱɟɫɬɜɭ ɹɜɧɵɯ
ɰɢɤɥɨɜ, ɱɟɦ ɭ ɩɪɨɝɪɚɦɦ ɛɟɡ ɩɪɢɦɟɧɟɧɢɹ STL ɛɥɚɝɨɞɚɪɹ ɡɚɦɟɧɟ ɧɢɡɤɨɭɪɨɜɧɟɜɵɯ ɰɢɤɥɨɜ ɜɵɫɨ-
ɤɨɭɪɨɜɧɟɜɵɦɢ ɚɛɫɬɪɚɤɬɧɵɦɢ ɨɩɟɪɚɰɢɹɦɢ ɫ ɫɭɳɟɫɬɜɟɧɧɨ ɛɨɥɶɲɟɣ ɫɟɦɚɧɬɢɤɨɣ. ɉɪɢ ɩɪɨɝɪɚɦ-
ɦɢɪɨɜɚɧɢɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ STL, ɫɥɟɞɭɟɬ ɞɭɦɚɬɶ ɧɟ ɜ ɤɚɬɟɝɨɪɢɹɯ “ɤɚɤ ɨɛɪɚɛɨɬɚɬɶ ɤɚɠɞɵɣ
ɷɥɟɦɟɧɬ”, ɚ “ɤɚɤ ɨɛɪɚɛɨɬɚɬɶ ɞɢɚɩɚɡɨɧ ɷɥɟɦɟɧɬɨɜ”.
Ƚɥɚɜɧɨɟ ɩɪɟɢɦɭɳɟɫɬɜɨ ɚɥɝɨɪɢɬɦɨɜ ɢ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɜ ɨɛɳɟɦ ɫɥɭɱɚɟ ɡɚɤɥɸɱɚ-
ɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɨɧɢ ɩɨɡɜɨɥɹɸɬ ɧɚɦ ɝɨɜɨɪɢɬɶ ɧɚ ɛɨɥɟɟ ɜɵɫɨɤɨɦ ɭɪɨɜɧɟ ɚɛɫɬɪɚɤɰɢɢ. ȼ ɫɨɜɪɟ-
ɦɟɧɧɨɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ ɦɵ ɧɟ ɝɨɜɨɪɢɦ “ɩɭɫɬɶ ɧɟɫɤɨɥɶɤɨ ɨɛɴɟɤɬɨɜ ɫɥɟɞɹɬ ɡɚ ɨɞɧɢɦ ɨɛɴɟɤ-
ɬɨɦ ɢ ɩɨɥɭɱɚɸɬ ɚɜɬɨɦɚɬɢɱɟɫɤɢɟ ɭɜɟɞɨɦɥɟɧɢɹ ɩɪɢ ɢɡɦɟɧɟɧɢɢ ɟɝɨ ɫɨɫɬɨɹɧɢɹ”. ȼɦɟɫɬɨ ɷɬɨɝɨ
ɦɵ ɝɨɜɨɪɢɦ ɩɪɨɫɬɨ ɨ “ɲɚɛɥɨɧɟ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Observer”. Ⱥɧɚɥɨɝɢɱɧɨ, ɦɵ ɝɨɜɨɪɢɦ “Bridge”,
“Factory” ɢ “Visitor”. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɫɥɨɜɚɪɹ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɨɡɜɨɥɹɟɬ ɩɨɜɵɫɢɬɶ
ɭɪɨɜɟɧɶ, ɷɮɮɟɤɬɢɜɧɨɫɬɶ ɢ ɤɨɪɪɟɤɬɧɨɫɬɶ ɧɚɲɟɝɨ ɨɛɫɭɠɞɟɧɢɹ. Ɍɨɱɧɨ ɬɚɤ ɠɟ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɢ ɚɥɝɨɪɢɬɦɨɜ ɦɵ ɧɟ ɝɨɜɨɪɢɦ “ɜɵɩɨɥɧɹɟɦ ɞɟɣɫɬɜɢɟ ɧɚɞ ɤɚɠɞɵɦ ɷɥɟɦɟɧɬɨɦ ɞɢɚɩɚɡɨɧɚ ɢ ɡɚ-
ɩɢɫɵɜɚɟɦ ɪɟɡɭɥɶɬɚɬ ɜ ɧɟɤɨɬɨɪɨɟ ɦɟɫɬɨ”; ɜɦɟɫɬɨ ɷɬɨɝɨ ɦɵ ɝɨɜɨɪɢɦ ɩɪɨɫɬɨ — transform.
Ⱥɧɚɥɨɝɢɱɧɨ, ɦɵ ɦɨɠɟɦ ɫɤɚɡɚɬɶ for_each, replace_if ɢ partition. Ⱥɥɝɨɪɢɬɦɵ, ɩɨɞɨɛɧɨ
ɲɚɛɥɨɧɚɦ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɫɚɦɨɞɨɤɭɦɟɧɬɢɪɭɟɦɵ. “Ƚɨɥɵɟ” ɰɢɤɥɵ for ɢ while ɧɢɱɟɝɨ ɧɟ ɝɨ-
ɜɨɪɹɬ ɨ ɬɨɦ, ɞɥɹ ɱɟɝɨ ɨɧɢ ɩɪɟɞɧɚɡɧɚɱɟɧɵ, ɢ ɱɢɬɚɬɟɥɸ ɩɪɢɯɨɞɢɬɫɹ ɢɡɭɱɚɬɶ ɬɟɥɚ ɰɢɤɥɨɜ, ɱɬɨɛɵ
ɪɚɫɲɢɮɪɨɜɚɬɶ ɢɯ ɫɟɦɚɧɬɢɤɭ.
Ⱥɥɝɨɪɢɬɦɵ ɨɛɵɱɧɨ ɛɨɥɟɟ ɤɨɪɪɟɤɬɧɵ, ɱɟɦ ɰɢɤɥɵ. ȼ ɪɚɡɪɚɛɚɬɵɜɚɟɦɵɯ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ
ɰɢɤɥɚɯ ɥɟɝɤɨ ɞɨɩɭɫɬɢɬɶ ɨɲɢɛɤɭ, ɧɚɩɪɢɦɟɪ, ɬɚɤɭɸ ɤɚɤ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɯ ɢɬɟ-
ɪɚɬɨɪɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 83 ɢ 99); ɚɥɝɨɪɢɬɦɵ ɜ ɛɢɛɥɢɨɬɟɤɟ ɨɬɥɚɠɟɧɵ ɧɚ ɩɪɟɞɦɟɬ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɹ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɯ ɢɬɟɪɚɬɨɪɨɜ ɢ ɞɪɭɝɢɯ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ ɨɲɢɛɨɤ.
ɂ ɧɚɤɨɧɟɰ, ɚɥɝɨɪɢɬɦɵ ɡɚɱɚɫɬɭɸ ɬɚɤɠɟ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵ, ɱɟɦ ɩɪɨɫɬɵɟ ɰɢɤɥɵ (ɫɦ. [Sutter00]
ɢ [Meyers01]). ȼ ɧɢɯ ɭɫɬɪɚɧɟɧɵ ɧɟɛɨɥɶɲɢɟ ɧɟɷɮɮɟɤɬɢɜɧɨɫɬɢ, ɬɚɤɢɟ ɤɚɤ ɩɨɜɬɨɪɧɵɟ ɜɵɱɢɫɥɟɧɢɹ
container.end(). ɇɟ ɦɟɧɟɟ ɜɚɠɧɨ, ɱɬɨ ɫɬɚɧɞɚɪɬɧɵɟ ɚɥɝɨɪɢɬɦɵ, ɢɫɩɨɥɶɡɭɟɦɵɟ ɜɚɦɢ, ɛɵɥɢ
ɪɟɚɥɢɡɨɜɚɧɵ ɬɟɦɢ ɠɟ ɩɪɨɝɪɚɦɦɢɫɬɚɦɢ, ɤɬɨ ɪɟɚɥɢɡɨɜɵɜɚɥ ɢ ɢɫɩɨɥɶɡɭɟɦɵɟ ɜɚɦɢ ɫɬɚɧɞɚɪɬɧɵɟ
ɤɨɧɬɟɣɧɟɪɵ, ɢ ɩɨɧɹɬɧɨ, ɱɬɨ ɢɯ ɡɧɚɧɢɟ ɤɨɧɤɪɟɬɧɵɯ ɪɟɚɥɢɡɚɰɢɣ ɩɨɡɜɨɥɹɟɬ ɢɦ ɧɚɩɢɫɚɬɶ ɚɥɝɨɪɢɬ-
ɦɵ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɨ, ɱɟɦ ɷɬɨ ɫɦɨɠɟɬɟ ɫɞɟɥɚɬɶ ɜɵ. ȼɚɠɧɟɟ ɜɫɟɝɨ, ɨɞɧɚɤɨ, ɬɨ, ɱɬɨ ɦɧɨɝɢɟ ɚɥɝɨ-
ɪɢɬɦɵ ɢɦɟɸɬ ɜɵɫɨɤɨɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɪɟɚɥɢɡɚɰɢɢ, ɤɨɬɨɪɵɟ ɦɵ ɧɢɤɨɝɞɚ ɧɟ ɫɦɨɠɟɦ ɪɟɚɥɢɡɨɜɚɬɶ
Стр. 176
ɜ ɫɨɛɫɬɜɟɧɧɨɪɭɱɧɨ ɪɚɡɪɚɛɨɬɚɧɧɨɦ ɤɨɞɟ (ɧɟ ɫɱɢɬɚɹ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɧɚɦ ɧɟ ɧɭɠɧɚ ɬɚ ɫɬɟɩɟɧɶ
ɨɛɨɛɳɟɧɧɨɫɬɢ, ɤɨɬɨɪɭɸ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɚɥɝɨɪɢɬɦɵ). ȼɨɨɛɳɟ ɝɨɜɨɪɹ, ɛɨɥɟɟ ɢɫɩɨɥɶɡɭɟɦɚɹ ɛɢɛ-
ɥɢɨɬɟɤɚ ɜɫɟɝɞɚ ɨɤɚɡɵɜɚɟɬɫɹ ɥɭɱɲɟ ɨɬɥɚɠɟɧɧɨɣ ɢ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɨɣ ɩɪɨɫɬɨ ɩɨɬɨɦɭ, ɱɬɨ ɭ ɧɟɟ
ɛɨɥɶɲɟ ɩɨɥɶɡɨɜɚɬɟɥɟɣ. ȼɪɹɞ ɥɢ ɜɵ ɧɚɣɞɟɬɟ ɢ ɫɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜ ɫɜɨɟɣ ɩɪɨɝɪɚɦɦɟ ɛɢɛɥɢɨ-
ɬɟɤɭ, ɧɚɫɬɨɥɶɤɨ ɠɟ ɲɢɪɨɤɨ ɩɪɢɦɟɧɹɟɦɭɸ, ɤɚɤ ɢ ɪɟɚɥɢɡɚɰɢɹ ɜɚɲɟɣ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ.
ȼɨɫɩɨɥɶɡɭɣɬɟɫɶ ɟɸ. Ⱥɥɝɨɪɢɬɦɵ STL ɭɠɟ ɧɚɩɢɫɚɧɵ — ɬɚɤ ɩɨɱɟɦɭ ɛɵ ɧɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɦɢ?
ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɥɹɦɛɞɚ-ɮɭɧɤɰɢɣ [Boost]. Ʌɹɦɛɞɚ-ɮɭɧɤɰɢɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨ-
ɛɨɣ ɜɚɠɧɵɣ ɢɧɫɬɪɭɦɟɧɬ, ɤɨɬɨɪɵɣ ɩɨɡɜɨɥɹɟɬ ɫɩɪɚɜɢɬɶɫɹ ɫ ɨɫɧɨɜɧɵɦ ɧɟɞɨɫɬɚɬɤɨɦ ɚɥɝɨɪɢɬɦɨɜ,
ɚ ɢɦɟɧɧɨ ɫ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɶɸ. Ȼɟɡ ɢɯ ɩɪɢɦɟɧɟɧɢɹ ɜɵ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɥɢɛɨ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ (ɧɨ ɬɨɝɞɚ ɬɟɥɚ ɞɚɠɟ ɩɪɨɫɬɵɯ ɰɢɤɥɨɜ ɧɚɯɨɞɹɬɫɹ ɜ ɨɬɞɟɥɶɧɨɦ ɦɟɫɬɟ, ɞɚɥɟɤɨ ɨɬ
ɬɨɱɤɢ ɜɵɡɨɜɚ), ɥɢɛɨ ɫɬɚɧɞɚɪɬɧɵɟ ɫɜɹɡɵɜɚɬɟɥɢ ɢ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɧɚɩɨɞɨɛɢɟ
bind2nd ɢ plus (ɞɨɫɬɚɬɨɱɧɨ ɡɚɩɭɬɚɧɧɵɟ, ɫɥɨɠɧɵɟ ɢ ɭɬɨɦɢɬɟɥɶɧɵɟ ɜ ɢɫɩɨɥɶɡɨɜɚɧɢɢ).
Примеры
ȼɨɬ ɞɜɚ ɩɪɢɦɟɪɚ, ɚɞɚɩɬɢɪɨɜɚɧɧɵɯ ɢɡ [Meyers01].
ɉɪɢɦɟɪ 1. ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ deque. ɉɨɫɥɟ ɬɨɝɨ ɤɚɤ ɛɵɥɨ ɜɵɩɨɥɧɟɧɨ ɧɟɫɤɨɥɶɤɨ ɧɟɤɨɪɪɟɤɬ-
ɧɵɯ ɢɬɟɪɚɰɢɣ ɢɡ-ɡɚ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɯ ɢɬɟɪɚɬɨɪɨɜ (ɧɚɩɪɢɦɟɪ, ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 83), ɦɵ
ɩɪɢɲɥɢ ɤ ɨɤɨɧɱɚɬɟɥɶɧɨɣ ɜɟɪɫɢɢ ɰɢɤɥɚ ɞɥɹ ɩɪɢɛɚɜɥɟɧɢɹ 41 ɤ ɤɚɠɞɨɦɭ ɷɥɟɦɟɧɬɭ ɦɚɫɫɢɜɚ ɞɚɧ-
ɧɵɯ ɬɢɩɚ double ɢ ɩɨɦɟɳɟɧɢɹ ɪɟɡɭɥɶɬɚɬɚ ɜ ɞɟɤ deque<double>:
deque<double>::iterator current = d.begin();
for( size_t i = 0; i < max; ++i ) {
// ǜǹȀǻǫǸȊǰǷ current ǯǰǴǼǽǭǳǽǰǶȇǸȆǷ
current = d.insert( current, data[i] + 41 );
++current; // ǞǭǰǶǳȂǳǭǫǰǷ ǰǮǹ, ǵǹǮǯǫ Ȉǽǹ
} // ǼǽǫǸǹǭǳǽǼȊ ǬǰǲǹǺǫǼǸȆǷ
ȼɵɡɨɜ ɚɥɝɨɪɢɬɦɚ ɩɨɡɜɨɥɹɟɬ ɥɟɝɤɨ ɨɛɨɣɬɢ ɜɫɟ ɥɨɜɭɲɤɢ ɜ ɷɬɨɦ ɤɨɞɟ:
transform(
data.begin(), data.end(), // ǕǹǺǳǻǾǰǷ ȈǶǰǷǰǸǽȆ data
inserter(d, d.begin()), // ǭ d Ǽ ǸǫȂǫǶǫ ǵǹǸǽǰǴǸǰǻǫ,
bind2nd (plus<double >(),41) ); // ǯǹǬǫǭǶȊȊ ǵ ǵǫǱǯǹǷǾ 41
ȼɩɪɨɱɟɦ, bind2nd ɢ plus ɞɨɫɬɚɬɨɱɧɨ ɧɟɭɞɨɛɧɵ. Ɉɬɤɪɨɜɟɧɧɨ ɝɨɜɨɪɹ, ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ
ɢɯ ɦɚɥɨ ɤɬɨ ɢɫɩɨɥɶɡɭɟɬ, ɢ ɫɜɹɡɚɧɨ ɷɬɨ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɫ ɩɥɨɯɨɣ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɶɸ ɬɚɤɨɝɨ
ɤɨɞɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6).
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɥɹɦɛɞɚ-ɮɭɧɤɰɢɣ, ɝɟɧɟɪɢɪɭɸɳɢɯ ɞɥɹ ɧɚɫ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ,
ɦɵ ɦɨɠɟɦ ɧɚɩɢɫɚɬɶ ɫɨɜɫɟɦ ɩɪɨɫɬɨɣ ɤɨɞ:
transform(data, data+max, inserter(d,d.begin()), _1 + 41);
ɉɪɢɦɟɪ 2. ɇɚɣɬɢ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ ɦɟɠɞɭ x ɢ y. Ɋɚɫɫɦɨɬɪɢɦ ɩɪɨɫɬɨɣ ɰɢɤɥ, ɤɨɬɨɪɵɣ ɜɵ-
ɩɨɥɧɹɟɬ ɩɨɢɫɤ ɜ vector<int> v ɩɟɪɜɨɝɨ ɷɥɟɦɟɧɬɚ, ɡɧɚɱɟɧɢɟ ɤɨɬɨɪɨɝɨ ɧɚɯɨɞɢɬɫɹ ɦɟɠɞɭ x ɢ
y. Ɉɧ ɜɵɱɢɫɥɹɟɬ ɢɬɟɪɚɬɨɪ, ɤɨɬɨɪɵɣ ɭɤɚɡɵɜɚɟɬ ɥɢɛɨ ɧɚ ɧɚɣɞɟɧɧɵɣ ɷɥɟɦɟɧɬ, ɥɢɛɨ ɧɚ v.end():
vector<int>::iterator i = v.begin();
for( ; i != v.end(); ++i)
if( *i > x && *i < y ) break;
ȼɵɡɨɜ ɚɥɝɨɪɢɬɦɚ ɞɨɫɬɚɬɨɱɧɨ ɩɪɨɛɥɟɦɚɬɢɱɟɧ. ɉɪɢ ɨɬɫɭɬɫɬɜɢɢ ɥɹɦɛɞɚ-ɮɭɧɤɰɢɣ ɭ ɧɚɫ ɟɫɬɶ
ɞɜɚ ɜɚɪɢɚɧɬɚ — ɧɚɩɢɫɚɧɢɟ ɫɨɛɫɬɜɟɧɧɨɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɝɨ ɨɛɴɟɤɬɚ ɢɥɢ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɫɬɚɧ-
ɞɚɪɬɧɵɯ ɫɜɹɡɵɜɚɬɟɥɟɣ. ɍɜɵ, ɜ ɩɨɫɥɟɞɧɟɦ ɫɥɭɱɚɟ ɦɵ ɧɟ ɦɨɠɟɦ ɨɛɨɣɬɢɫɶ ɬɨɥɶɤɨ ɫɬɚɧɞɚɪɬɧɵɦɢ
ɫɜɹɡɵɜɚɬɟɥɹɦɢ ɢ ɞɨɥɠɧɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɟɫɬɚɧɞɚɪɬɧɵɣ (ɯɨɬɹ ɢ ɞɨɫɬɚɬɨɱɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɣ)
ɚɞɚɩɬɟɪ compose2, ɧɨ ɞɚɠɟ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɤɨɞ ɩɨɥɭɱɚɟɬɫɹ ɫɨɜɟɪɲɟɧɧɨ ɧɟɩɨɧɹɬɧɵɦ, ɬɚɤ ɱɬɨ
ɬɚɤɨɣ ɤɨɞ ɧɚ ɩɪɚɤɬɢɤɟ ɧɢɤɬɨ ɩɪɨɫɬɨ ɧɟ ɧɚɩɢɲɟɬ:
84. Предпочитайте вызовы алгоритмов самостоятельно разрабатываемым циклам 177
Стр. 177
vector<int>::iterator i =
find_if(v.begin(), v.end(),
compose2 (logical_and <bool>(),
bind2nd (greater <int>(), x),
bind2nd (less<int>(), y)));
Ⱦɪɭɝɨɣ ɜɚɪɢɚɧɬ, ɚ ɢɦɟɧɧɨ — ɧɚɩɢɫɚɧɢɟ ɫɨɛɫɬɜɟɧɧɨɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɝɨ ɨɛɴɟɤɬɚ — ɞɨɫɬɚ-
ɬɨɱɧɨ ɠɢɡɧɟɫɩɨɫɨɛɟɧ. Ɉɧ ɞɨɫɬɚɬɨɱɧɨ ɯɨɪɨɲɨ ɜɵɝɥɹɞɢɬ ɜ ɬɨɱɤɟ ɜɵɡɨɜɚ, ɚ ɝɥɚɜɧɵɣ ɟɝɨ ɧɟɞɨɫ-
ɬɚɬɨɤ — ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɧɚɩɢɫɚɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɝɨ ɨɛɴɟɤɬɚ BetweenValues, ɤɨɬɨɪɵɣ ɜɢ-
ɡɭɚɥɶɧɨ ɭɞɚɥɹɟɬ ɥɨɝɢɤɭ ɢɡ ɬɨɱɤɢ ɜɵɡɨɜɚ:
class BetweenValues : public unary_function<T, bool> {
public:
BetweenValues( const T& low, const T& high )
: low_(low), high_(high) { }
bool operator()( const T& val ) const
{ return val > low_ && val < high_; }
private:
T low_, high_;
};
find_if( v.begin(), v.end(), BetweenValues <int>(x, y));
ɉɪɢ ɩɪɢɦɟɧɟɧɢɢ ɥɹɦɛɞɚ-ɮɭɧɤɰɢɣ ɦɨɠɧɨ ɧɚɩɢɫɚɬɶ ɩɪɨɫɬɨ:
find_if( v.begin(), v.end(), _1 > x && _1 < y );
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ ɬɟɥɨ ɰɢɤɥɚ ɨɤɚɡɵɜɚɟɬɫɹ ɪɚɡɦɟɳɟɧɨ ɜ ɧɟɤɨ-
ɬɨɪɨɦ ɦɟɫɬɟ, ɭɞɚɥɟɧɧɨɦ ɨɬ ɬɨɱɤɢ ɜɵɡɨɜɚ, ɱɬɨ ɡɚɬɪɭɞɧɹɟɬ ɱɬɟɧɢɟ ɢɫɯɨɞɧɨɝɨ ɬɟɤɫɬɚ.
(ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɩɪɨɫɬɵɯ ɨɛɴɟɤɬɨɜ ɫɨ ɫɬɚɧɞɚɪɬɧɵɦɢ ɢ ɧɟɫɬɚɧɞɚɪɬɧɵɦɢ ɫɜɹɡɵɜɚɬɟɥɹɦɢ ɩɪɟɞ-
ɫɬɚɜɥɹɟɬɫɹ ɧɟɪɟɚɥɢɫɬɢɱɧɵɦ.)
Ʌɹɦɛɞɚ-ɮɭɧɤɰɢɢ [Boost] ɪɟɲɚɸɬ ɩɪɨɛɥɟɦɭ ɢ ɧɚɞɟɠɧɨ ɪɚɛɨɬɚɸɬ ɧɚ ɫɨɜɪɟɦɟɧɧɵɯ ɤɨɦɩɢɥɹ-
ɬɨɪɚɯ, ɧɨ ɨɧɢ ɧɟ ɝɨɞɹɬɫɹ ɞɥɹ ɛɨɥɟɟ ɫɬɚɪɵɯ ɤɨɦɩɢɥɹɬɨɪɨɜ ɢ ɦɨɝɭɬ ɜɵɞɚɜɚɬɶ ɛɨɥɶɲɢɟ ɡɚɩɭɬɚɧɧɵɟ
ɫɨɨɛɳɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɩɪɢ ɧɟɤɨɪɪɟɤɬɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ. ȼɵɡɨɜ ɠɟ ɢɦɟɧɨɜɚɧɧɵɯ ɮɭɧɤɰɢɣ,
ɜɤɥɸɱɚɹ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ, ɜɫɟ ɪɚɜɧɨ ɬɪɟɛɭɟɬ ɫɢɧɬɚɤɫɢɫɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɜɹɡɵɜɚɬɟɥɟɣ.
Ссылки
[Allison98] §15 • [Austern99] §11-13 • [Boost] Lambda library • [McConnell93] §15 • [Meyers01]
§43 • [Musser01] §11 • [Stroustrup00] §6.1.8, §18.5.1 • [Sutter00] §7
Стр. 178
85. Пользуйтесь правильным
алгоритмом поиска
Резюме
Ⱦɚɧɧɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɩɪɢɦɟɧɢɦɚ ɤ ɩɨɢɫɤɭ ɨɩɪɟɞɟɥɟɧɧɨɝɨ ɡɧɚɱɟɧɢɹ ɜ ɞɢɚɩɚɡɨɧɟ. ɉɪɢ ɩɨɢɫɤɟ
ɜ ɧɟɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɞɢɚɩɚɡɨɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɚɥɝɨɪɢɬɦɵ find/find_if ɢɥɢ count/count_if.
Ⱦɥɹ ɩɨɢɫɤɚ ɜ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɞɢɚɩɚɡɨɧɟ ɜɵɛɟɪɢɬɟ lower_bound, upper_bound, equal_
range ɢɥɢ (ɪɟɠɟ) binary_search. (ȼɨɩɪɟɤɢ ɫɜɨɟɦɭ ɢɦɟɧɢ, binary_search ɨɛɵɱɧɨ — ɧɟ-
ɜɟɪɧɵɣ ɜɵɛɨɪ.)
ȼ ɫɥɭɱɚɟ ɧɟɨɬɫɨɪɬɢɪɨɜɚɧɧɵɯ ɞɢɚɩɚɡɨɧɨɜ, find/find_if ɢ count/count_if ɦɨɝɭɬ ɡɚ
ɥɢɧɟɣɧɨɟ ɜɪɟɦɹ ɨɩɪɟɞɟɥɢɬɶ, ɧɚɯɨɞɢɬɫɹ ɥɢ ɞɚɧɧɵɣ ɷɥɟɦɟɧɬ ɜ ɞɢɚɩɚɡɨɧɟ, ɢ ɟɫɥɢ ɞɚ, ɬɨ ɝɞɟ
ɢɦɟɧɧɨ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɚɥɝɨɪɢɬɦɵ find/find_if ɨɛɵɱɧɨ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵ, ɩɨɫɤɨɥɶɤɭ ɦɨɝɭɬ
ɡɚɜɟɪɲɢɬɶ ɩɨɢɫɤ, ɤɚɤ ɬɨɥɶɤɨ ɢɫɤɨɦɵɣ ɷɥɟɦɟɧɬ ɨɤɚɡɵɜɚɟɬɫɹ ɧɚɣɞɟɧ.
ȼ ɫɥɭɱɚɟ ɫɨɪɬɢɪɨɜɚɧɧɵɯ ɞɢɚɩɚɡɨɧɨɜ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɚɥɝɨɪɢɬɦɵ ɛɢɧɚɪɧɨɝɨ ɩɨɢɫɤɚ —
binary_search, lower_bound, upper_bound ɢ equal_range, ɤɨɬɨɪɵɟ ɢɦɟɸɬ ɥɨɝɚɪɢɮ-
ɦɢɱɟɫɤɨɟ ɜɪɟɦɹ ɪɚɛɨɬɵ. ɍɜɵ, ɧɟɫɦɨɬɪɹ ɧɚ ɫɜɨɟ ɤɪɚɫɢɜɨɟ ɢɦɹ, binary_search ɩɪɚɤɬɢɱɟɫɤɢ
ɜɫɟɝɞɚ ɛɟɫɩɨɥɟɡɟɧ, ɩɨɫɤɨɥɶɤɭ ɜɨɡɜɪɚɳɚɟɬ ɜɫɟɝɨ ɥɢɲɶ ɡɧɚɱɟɧɢɟ ɬɢɩɚ bool, ɭɤɚɡɵɜɚɸɳɟɟ, ɧɚɣ-
ɞɟɧ ɢɫɤɨɦɵɣ ɷɥɟɦɟɧɬ ɢɥɢ ɧɟɬ. Ɉɛɵɱɧɨ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɚɥɝɨɪɢɬɦ lower_bound ɢɥɢ
upper_bound, ɢɥɢ equal_range, ɤɨɬɨɪɵɣ ɜɵɞɚɟɬ ɪɟɡɭɥɶɬɚɬɵ ɨɛɨɢɯ ɚɥɝɨɪɢɬɦɨɜ — ɢ
lower_bound, ɢ upper_bound (ɢ ɬɪɟɛɭɟɬ ɜ ɞɜɚ ɪɚɡɚ ɛɨɥɶɲɟ ɜɪɟɦɟɧɢ).
Ⱥɥɝɨɪɢɬɦ lower_bound ɜɨɡɜɪɚɳɚɟɬ ɢɬɟɪɚɬɨɪ, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ ɩɟɪɜɵɣ ɩɨɞɯɨɞɹɳɢɣ
ɷɥɟɦɟɧɬ (ɟɫɥɢ ɬɚɤɨɜɨɣ ɢɦɟɟɬɫɹ) ɢɥɢ ɧɚ ɩɨɡɢɰɢɸ, ɝɞɟ ɨɧ ɦɨɝ ɛɵ ɛɵɬɶ (ɟɫɥɢ ɬɚɤɨɝɨ ɷɥɟɦɟɧɬɚ
ɧɟɬ); ɩɨɫɥɟɞɧɟɟ ɩɨɥɟɡɧɨ ɞɥɹ ɩɨɢɫɤɚ ɜɟɪɧɨɝɨ ɦɟɫɬɚ ɞɥɹ ɜɫɬɚɜɤɢ ɧɨɜɵɯ ɡɧɚɱɟɧɢɣ ɜ ɨɬɫɨɪɬɢɪɨ-
ɜɚɧɧɭɸ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ. Ⱥɥɝɨɪɢɬɦ upper_bound ɜɨɡɜɪɚɳɚɟɬ ɢɬɟɪɚɬɨɪ, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ
ɷɥɟɦɟɧɬ, ɫɥɟɞɭɸɳɢɣ ɡɚ ɩɨɫɥɟɞɧɢɦ ɧɚɣɞɟɧɧɵɦ ɷɥɟɦɟɧɬɨɦ (ɟɫɥɢ ɬɚɤɨɜɨɣ ɢɦɟɟɬɫɹ), ɬ.ɟ. ɧɚ ɩɨ-
ɡɢɰɢɸ, ɤɭɞɚ ɦɨɠɧɨ ɞɨɛɚɜɢɬɶ ɫɥɟɞɭɸɳɢɣ ɷɤɜɢɜɚɥɟɧɬɧɵɣ ɷɥɟɦɟɧɬ; ɷɬɨ ɩɨɥɟɡɧɨ ɩɪɢ ɩɨɢɫɤɟ
ɩɪɚɜɢɥɶɧɨɝɨ ɦɟɫɬɚ ɞɥɹ ɜɫɬɚɜɤɢ ɧɨɜɵɯ ɡɧɚɱɟɧɢɣ ɜ ɨɬɫɨɪɬɢɪɨɜɚɧɧɭɸ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ, ɱɬɨ-
ɛɵ ɩɨɞɞɟɪɠɢɜɚɬɶ ɭɩɨɪɹɞɨɱɟɧɧɨɫɬɶ, ɩɪɢ ɤɨɬɨɪɨɣ ɪɚɜɧɵɟ ɷɥɟɦɟɧɬɵ ɪɚɫɩɨɥɚɝɚɸɬɫɹ ɜ ɩɨɫɥɟɞɨ-
ɜɚɬɟɥɶɧɨɫɬɢ ɜ ɩɨɪɹɞɤɟ ɢɯ ɜɫɬɚɜɤɢ.
Ⱦɥɹ ɫɨɪɬɢɪɨɜɚɧɧɵɯ ɞɢɚɩɚɡɨɧɨɜ ɜ ɤɚɱɟɫɬɜɟ ɛɵɫɬɪɨɣ ɜɟɪɫɢɢ count(first,last,value);
ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɚɪɭ ɜɵɡɨɜɨɜ:
p = equal_range(first,last,value);
distance(p.first,p.second);
ɉɪɢ ɩɨɢɫɤɟ ɜ ɚɫɫɨɰɢɚɬɢɜɧɨɦ ɤɨɧɬɟɣɧɟɪɟ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɜɦɟɫɬɨ ɚɥɝɨɪɢɬɦɨɜ-ɧɟ ɱɥɟ-
ɧɨɜ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ ɫ ɬɟɦ ɠɟ ɢɦɟɧɟɦ. Ɏɭɧɤɰɢɢ-ɱɥɟɧɵ ɨɛɵɱɧɨ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɵ; ɧɚɩɪɢɦɟɪ,
ɮɭɧɤɰɢɹ-ɱɥɟɧ count ɜɵɩɨɥɧɹɟɬɫɹ ɡɚ ɥɨɝɚɪɢɮɦɢɱɟɫɤɨɟ ɜɪɟɦɹ (ɬɚɤ ɱɬɨ, ɤɫɬɚɬɢ, ɧɟɬ ɧɢɤɚɤɢɯ
ɨɫɧɨɜɚɧɢɣ ɡɚɦɟɧɹɬɶ ɟɟ ɜɵɡɨɜɨɦ equal_range ɫ ɩɨɫɥɟɞɭɸɳɢɦ distance, ɱɬɨ ɢɦɟɟɬ ɫɦɵɫɥ
ɞɥɹ ɮɭɧɤɰɢɢ count, ɧɟ ɹɜɥɹɸɳɟɣɫɹ ɱɥɟɧɨɦ).
Ссылки
[Austern99] §13.2-3 • [Bentley00] §13 • [Meyers01] §34, §45 • [Musser01] §22.2 • [Stroustrup00]
§17.1.4.1, §18.7.2
85. Пользуйтесь правильным алгоритмом поиска 179
Стр. 179
86. Пользуйтесь правильным алгоритмом
сортировки
Резюме
ɉɪɢ ɫɨɪɬɢɪɨɜɤɟ ɜɵ ɞɨɥɠɧɵ ɱɟɬɤɨ ɩɨɧɢɦɚɬɶ, ɤɚɤ ɪɚɛɨɬɚɟɬ ɤɚɠɞɵɣ ɢɡ ɫɨɪɬɢɪɭɸɳɢɯ ɚɥɝɨ-
ɪɢɬɦɨɜ, ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɚɢɛɨɥɟɟ ɞɟɲɟɜɵɣ ɫɪɟɞɢ ɬɟɯ, ɤɨɬɨɪɵɟ ɩɪɢɝɨɞɧɵ ɞɥɹ ɪɟɲɟɧɢɹ ɜɚɲɟɣ
ɡɚɞɚɱɢ.
ȼɚɦ ɧɟ ɜɫɟɝɞɚ ɬɪɟɛɭɟɬɫɹ ɩɨɥɧɵɣ sort; ɨɛɵɱɧɨ ɧɚɞɨ ɦɟɧɶɲɟɟ, ɢ ɜɟɫɶɦɚ ɪɟɞɤɨ — ɛɨɥɶɲɟɟ.
ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɫɬɚɧɞɚɪɬɧɵɟ ɚɥɝɨɪɢɬɦɵ ɫɨɪɬɢɪɨɜɤɢ ɪɚɫɩɨɥɚɝɚɸɬɫɹ ɨɬ ɧɚɢɛɨɥɟɟ ɞɟɲɟɜɵɯ ɞɨ
ɧɚɢɛɨɥɟɟ ɞɨɪɨɝɢɯ ɜ ɫɥɟɞɭɸɳɟɦ ɩɨɪɹɞɤɟ: partition, stable_partition, nth_element,
partial_sort (ɢ ɟɝɨ ɜɚɪɢɚɧɬ partial_sort_copy), sort ɢ stable_sort. ɂɫɩɨɥɶɡɭɣɬɟ
ɧɚɢɦɟɧɟɟ ɞɨɪɨɝɨɣ ɢɡ ɚɥɝɨɪɢɬɦɨɜ, ɤɨɬɨɪɵɟ ɜɵɩɨɥɧɹɸɬ ɧɟɨɛɯɨɞɢɦɭɸ ɜɚɦ ɪɚɛɨɬɭ; ɩɪɢɦɟɧɟɧɢɟ
ɢɡɥɢɲɧɟ ɦɨɳɧɨɝɨ ɚɥɝɨɪɢɬɦɚ — ɪɚɫɬɨɱɢɬɟɥɶɫɬɜɨ.
ȼɪɟɦɹ ɪɚɛɨɬɵ ɚɥɝɨɪɢɬɦɨɜ partition, stable_partition ɢ nth_element — ɥɢɧɟɣ-
ɧɨɟ, ɱɬɨ ɹɜɥɹɟɬɫɹ ɨɱɟɧɶ ɯɨɪɨɲɢɦ ɩɨɤɚɡɚɬɟɥɟɦ.
Ⱥɥɝɨɪɢɬɦɵ nth_element, partial_sort, sort ɢ stable_sort ɬɪɟɛɭɸɬ ɢɬɟɪɚɬɨɪɵ
ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ. ȼɵ ɧɟ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɯ ɩɪɢ ɧɚɥɢɱɢɢ ɬɨɥɶɤɨ ɞɜɭɧɚɩɪɚɜɥɟɧɧɵɯ
ɢɬɟɪɚɬɨɪɨɜ (ɧɚɩɪɢɦɟɪ, list<T>::iterator). ȿɫɥɢ ɜɚɦ ɧɭɠɧɵ ɞɚɧɧɵɟ ɚɥɝɨɪɢɬɦɵ, ɧɨ ɭ ɜɚɫ
ɧɟɬ ɢɬɟɪɚɬɨɪɨɜ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ, ɜɵ ɦɨɠɟɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɞɢɨɦɨɣ ɢɧɞɟɤɫɧɨɝɨ ɤɨɧ-
ɬɟɣɧɟɪɚ: ɫɨɡɞɚɣɬɟ ɤɨɧɬɟɣɧɟɪ, ɩɨɞɞɟɪɠɢɜɚɸɳɢɣ ɢɬɟɪɚɬɨɪɵ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ (ɧɚɩɪɢɦɟɪ,
vector), ɜ ɤɨɬɨɪɨɦ ɛɭɞɭɬ ɯɪɚɧɢɬɶɫɹ ɢɬɟɪɚɬɨɪɵ, ɭɤɚɡɵɜɚɸɳɢɟ ɧɚ ɷɥɟɦɟɧɬɵ ɢɧɬɟɪɟɫɭɸɳɟɝɨ
ɜɚɫ ɞɢɚɩɚɡɨɧɚ, ɢ ɡɚɬɟɦ ɩɪɢɦɟɧɢɬɟ ɤ ɧɟɦɭ ɛɨɥɟɟ ɦɨɳɧɵɣ ɚɥɝɨɪɢɬɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɪɚɡɵɦɟ-
ɧɨɜɵɜɚɸɳɟɣ ɜɟɪɫɢɢ ɜɚɲɟɝɨ ɩɪɟɞɢɤɚɬɚ (ɜ ɤɨɬɨɪɨɣ ɩɟɪɟɞ ɨɛɵɱɧɵɦ ɫɪɚɜɧɟɧɢɟɦ ɜɵɩɨɥɧɹɟɬɫɹ
ɪɚɡɵɦɟɧɨɜɚɧɢɟ ɢɬɟɪɚɬɨɪɨɜ).
ȼɟɪɫɢɢ stable_… ɫɥɟɞɭɟɬ ɩɪɢɦɟɧɹɬɶ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɜɚɦ ɧɟɨɛɯɨɞɢɦɨ ɫɨɯɪɚɧɢɬɶ ɨɬ-
ɧɨɫɢɬɟɥɶɧɵɣ ɩɨɪɹɞɨɤ ɨɞɢɧɚɤɨɜɵɯ ɷɥɟɦɟɧɬɨɜ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɚɥɝɨɪɢɬɦɵ partial_sort
ɢ nth_element ɧɟ ɹɜɥɹɸɬɫɹ ɭɫɬɨɣɱɢɜɵɦɢ (ɬ.ɟ. ɨɧɢ ɧɟ ɨɫɬɚɜɥɹɸɬ ɨɞɢɧɚɤɨɜɵɟ ɷɥɟɦɟɧɬɵ ɜ
ɬɨɦ ɠɟ ɨɬɧɨɫɢɬɟɥɶɧɨɦ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɢ ɧɚɯɨɞɢɥɢɫɶ ɞɨ ɫɨɪɬɢɪɨɜɤɢ), ɢ ɭ ɧɢɯ ɧɟɬ ɫɬɚɧ-
ɞɚɪɬɢɡɢɪɨɜɚɧɧɵɯ ɭɫɬɨɣɱɢɜɵɯ ɜɟɪɫɢɣ. ȿɫɥɢ ɜɚɦ ɜɫɟ ɠɟ ɬɪɟɛɭɟɬɫɹ ɫɨɯɪɚɧɟɧɢɟ ɨɬɧɨɫɢɬɟɥɶɧɨɣ
ɭɩɨɪɹɞɨɱɟɧɧɨɫɬɢ ɷɥɟɦɟɧɬɨɜ, ɜɟɪɨɹɬɧɨ, ɜɚɦ ɧɚɞɨ ɢɫɩɨɥɶɡɨɜɚɬɶ stable_sort.
ɋɚɦɨ ɫɨɛɨɣ ɪɚɡɭɦɟɟɬɫɹ, ɧɟ ɫɥɟɞɭɟɬ ɩɪɢɛɟɝɚɬɶ ɧɢ ɤ ɤɚɤɢɦ ɚɥɝɨɪɢɬɦɚɦ ɫɨɪɬɢɪɨɜɤɢ, ɟɫɥɢ ɜɵ
ɦɨɠɟɬɟ ɨɛɨɣɬɢɫɶ ɛɟɡ ɧɢɯ. ȿɫɥɢ ɜɵ ɩɨɥɶɡɭɟɬɟɫɶ ɫɬɚɧɞɚɪɬɧɵɦ ɚɫɫɨɰɢɚɬɢɜɧɵɦ ɤɨɧɬɟɣɧɟɪɨɦ
(set/multiset ɢɥɢ map/multimap) ɢɥɢ ɚɞɚɩɬɟɪɨɦ priority_queue, ɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ
ɬɨɥɶɤɨ ɨɞɢɧ ɩɨɪɹɞɨɤ ɫɨɪɬɢɪɨɜɤɢ, ɬɨ ɧɟ ɡɚɛɵɜɚɣɬɟ, ɱɬɨ ɷɥɟɦɟɧɬɵ ɜ ɷɬɢɯ ɤɨɧɬɟɣɧɟɪɚɯ ɜɫɟɝɞɚ
ɧɚɯɨɞɹɬɫɹ ɜ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɜɢɞɟ.
Примеры
ɉɪɢɦɟɪ 1. partition. ȿɫɥɢ ɜɚɦ ɧɚɞɨ ɪɚɡɞɟɥɢɬɶ ɜɟɫɶ ɞɢɚɩɚɡɨɧ ɧɚ ɞɜɟ ɝɪɭɩɩɵ (ɝɪɭɩɩɚ
ɷɥɟɦɟɧɬɨɜ, ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ ɩɪɟɞɢɤɚɬɭ, ɡɚ ɤɨɬɨɪɵɦɢ ɫɥɟɞɭɟɬ ɝɪɭɩɩɚ ɷɥɟɦɟɧɬɨɜ, ɩɪɟɞɢɤɚɬɭ
ɧɟ ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ), ɬɨ ɞɥɹ ɷɬɨɝɨ ɞɨɫɬɚɬɨɱɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɚɥɝɨɪɢɬɦɨɦ partition. ɗɬɨ
ɜɫɟ, ɱɬɨ ɜɚɦ ɧɚɞɨ, ɱɬɨɛɵ ɨɬɜɟɬɢɬɶ ɧɚ ɜɨɩɪɨɫɵ ɧɚɩɨɞɨɛɢɟ ɩɪɢɜɟɞɟɧɧɵɯ ɞɚɥɟɟ.
Стр. 180
• Ʉɬɨ ɢɡ ɫɬɭɞɟɧɬɨɜ ɢɦɟɟɬ ɫɪɟɞɧɢɣ ɛɚɥ ɧɟ ɧɢɠɟ 4.5? Ⱦɥɹ ɨɬɜɟɬɚ ɧɚ ɷɬɨɬ ɜɨɩɪɨɫ ɦɨɠɧɨ
ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɜɵɡɨɜɨɦ partition(students.begin(), students.end(),
GradeAtLeast(4.5));, ɤɨɬɨɪɵɣ ɜɟɪɧɟɬ ɢɬɟɪɚɬɨɪ, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ ɩɟɪɜɨɝɨ ɫɬɭɞɟɧ-
ɬɚ, ɱɟɣ ɫɪɟɞɧɢɣ ɛɚɥɥ ɧɢɠɟ 4.5.
• Ʉɚɤɢɟ ɢɡ ɬɨɜɚɪɨɜ ɢɦɟɸɬ ɜɟɫ ɦɟɧɟɟ 10 ɤɝ? ȼɵɡɨɜ partition(products.begin(),
products.end(), WeightUnder(10)); ɜɟɪɧɟɬ ɢɬɟɪɚɬɨɪ, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ ɩɟɪɜɵɣ
ɬɨɜɚɪ, ɜɟɫ ɤɨɬɨɪɨɝɨ ɧɟ ɧɢɠɟ 10 ɤɝ.
ɉɪɢɦɟɪ 2. nth_element. Ⱥɥɝɨɪɢɬɦ nth_element ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨ-
ɥɭɱɢɬɶ ɨɞɢɧ ɷɥɟɦɟɧɬ ɜ ɤɨɪɪɟɤɬɧɨɣ n-ɣ ɩɨɡɢɰɢɢ, ɜ ɤɨɬɨɪɨɣ ɨɧ ɛɵ ɧɚɯɨɞɢɥɫɹ ɩɪɢ ɩɨɥɧɨɣ ɫɨɪɬɢ-
ɪɨɜɤɟ ɜɫɟɝɨ ɞɢɚɩɚɡɨɧɚ, ɩɪɢ ɷɬɨɦ ɜɫɟ ɩɪɨɱɢɟ ɷɥɟɦɟɧɬɵ ɤɨɪɪɟɤɬɧɨ ɪɚɫɩɨɥɚɝɚɸɬɫɹ ɞɨ ɢɥɢ ɩɨɫɥɟ
ɷɬɨɝɨ n-ɝɨ ɷɥɟɦɟɧɬɚ. ɗɬɨɝɨ ɞɨɫɬɚɬɨɱɧɨ, ɱɬɨɛɵ ɨɬɜɟɬɢɬɶ ɧɚ ɜɨɩɪɨɫɵ ɧɚɩɨɞɨɛɢɟ ɫɥɟɞɭɸɳɢɯ.
• ɉɟɪɟɱɢɫɥɢɬɟ 20 ɥɭɱɲɢɯ ɩɨɤɭɩɚɬɟɥɟɣ. ȼɵɡɨɜ nth_element(s.begin(),
s.begin()+19, s.end(), SalesRating); ɩɨɦɟɳɚɟɬ 20 ɧɚɢɥɭɱɲɢɯ ɩɨɤɭɩɚ-
ɬɟɥɟɣ ɜ ɧɚɱɚɥɨ ɤɨɧɬɟɣɧɟɪɚ.
• Ʉɚɤɨɟ ɢɡɞɟɥɢɟ ɢɦɟɟɬ ɦɟɞɢɚɧɧɨɟ ɡɧɚɱɟɧɢɟ ɤɚɱɟɫɬɜɚ ɜ ɞɚɧɧɨɦ ɧɚɛɨɪɟ? ɂɫɤɨɦɵɣ ɷɥɟɦɟɧɬ
ɧɚɯɨɞɢɬɫɹ ɜ ɫɪɟɞɧɟɣ ɩɨɡɢɰɢɢ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɝɨ ɞɢɚɩɚɡɨɧɚ. Ⱦɥɹ ɟɝɨ ɩɨɢɫɤɚ ɞɨɫɬɚɬɨɱɧɨ
ɜɵɡɨɜɚ nth_element(run.begin(), run.begin()+run.size()/2, run.end(),
ItemQuality);.
• ɍ ɤɚɤɨɝɨ ɢɡɞɟɥɢɹ ɭɪɨɜɟɧɶ ɤɚɱɟɫɬɜɚ ɧɚɯɨɞɢɬɫɹ ɧɚ 75-ɦ ɩɟɪɰɟɧɬɢɥɟ? ɂɫɤɨɦɵɣ ɷɥɟɦɟɧɬ
ɧɚɯɨɞɢɬɫɹ ɜ ɩɨɡɢɰɢɢ, ɨɬɫɬɨɹɳɟɣ ɧɚ 25% ɨɬ ɧɚɱɚɥɚ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɝɨ ɞɢɚɩɚɡɨɧɚ. Ⱦɥɹ
ɟɝɨ ɩɨɢɫɤɚ ɞɨɫɬɚɬɨɱɧɨ ɜɵɡɨɜɚ nth_element(run.begin(), run.begin()+run.
size()*.25, run.end(), ItemQuality);.
ɉɪɢɦɟɪ 3. partial_sort. Ⱥɥɝɨɪɢɬɦ partial_sort ɜɵɩɨɥɧɹɟɬ ɬɟ ɠɟ ɞɟɣɫɬɜɢɹ, ɱɬɨ ɢ
nth_element, ɧɨ ɤɪɨɦɟ ɬɨɝɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɤɨɪɪɟɤɬɧɨɟ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɟ ɪɚɡɦɟɳɟɧɢɟ ɜɫɟɯ
ɷɥɟɦɟɧɬɨɜ ɞɨ n-ɝɨ. Ⱥɥɝɨɪɢɬɦ partial_sort ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɨɬɜɟɬɨɜ ɧɚ ɜɨɩɪɨɫɵ, ɚɧɚɥɨ-
ɝɢɱɧɵɟ ɜɨɩɪɨɫɚɦ ɞɥɹ nth_element, ɧɨ ɜ ɤɨɬɨɪɵɯ ɬɪɟɛɭɟɬɫɹ, ɱɬɨɛɵ ɜɫɟ ɢɧɬɟɪɟɫɭɸɳɢɟ ɷɥɟ-
ɦɟɧɬɵ ɛɵɥɢ ɤɨɪɪɟɤɬɧɨ ɨɬɫɨɪɬɢɪɨɜɚɧɵ. ɗɬɨɬ ɚɥɝɨɪɢɬɦ — ɜɫɟ, ɱɬɨ ɜɚɦ ɧɚɞɨ ɞɥɹ ɨɬɜɟɬɚ, ɧɚɩɪɢɦɟɪ,
ɧɚ ɜɨɩɪɨɫ: “Ʉɬɨ ɢɡ ɭɱɚɫɬɧɢɤɨɜ ɡɚɧɹɥ ɩɟɪɜɨɟ, ɜɬɨɪɨɟ ɢ ɬɪɟɬɶɟ ɦɟɫɬɚ?” Ɉɬɜɟɬ ɦɨɠɧɨ ɩɨɥɭɱɢɬɶ
ɩɪɢ ɩɨɦɨɳɢ ɜɵɡɨɜɚ partial_sort(contestants.begin(), contestants.begin()+3,
contestants.end(),ScoreCompare);, ɩɨɫɥɟ ɤɨɬɨɪɨɝɨ ɭɱɚɫɬɧɢɤɢ, ɡɚɧɹɜɲɢɟ ɬɪɢ ɩɟɪɜɵɟ ɦɟɫ-
ɬɚ, ɨɤɚɠɭɬɫɹ ɜ ɤɨɪɪɟɤɬɧɨɦ ɩɨɪɹɞɤɟ ɜ ɬɪɟɯ ɩɟɪɜɵɯ ɷɥɟɦɟɧɬɚɯ ɤɨɧɬɟɣɧɟɪɚ, ɢ ɧɟ ɛɨɥɟɟ ɬɨɝɨ.
ɏɨɬɹ ɨɛɵɱɧɨ ɚɥɝɨɪɢɬɦ partial_sort ɛɵɫɬɪɟɟ ɩɨɥɧɨɣ ɫɨɪɬɢɪɨɜɤɢ (ɬɚɤ ɤɚɤ ɞɨɥɠɟɧ ɜɵ-
ɩɨɥɧɹɬɶ ɦɟɧɶɲɟɟ ɤɨɥɢɱɟɫɬɜɨ ɪɚɛɨɬɵ), ɟɫɥɢ ɜɚɦ ɧɚɞɨ ɨɬɫɨɪɬɢɪɨɜɚɬɶ ɩɨɱɬɢ ɜɟɫɶ (ɢɥɢ ɜɟɫɶ)
ɞɢɚɩɚɡɨɧ, ɬɨ ɜ ɷɬɨɣ ɫɢɬɭɚɰɢɢ ɚɥɝɨɪɢɬɦ sort ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɛɵɫɬɪɟɟ.
Ссылки
[Austern99] §13.1 • [Bentley00] §11 • [Josuttis99] §9.2.2 • [Meyers01] §31 • [Musser01] §5.4,
§22.26 • [Stroustrup00] §17.1.4.1, §18.7
86. Пользуйтесь правильным алгоритмом сортировки 181
Стр. 181
87. Делайте предикаты чистыми функциями
Резюме
ɉɪɟɞɢɤɚɬ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ ɨɬɜɟɬ ɞɚ/ɧɟɬ,
ɨɛɵɱɧɨ ɜ ɜɢɞɟ ɡɧɚɱɟɧɢɹ ɬɢɩɚ bool. Ɏɭɧɤɰɢɹ ɹɜɥɹɟɬɫɹ “ɱɢɫɬɨɣ” ɜ ɦɚɬɟɦɚɬɢɱɟɫɤɨɦ ɫɦɵɫɥɟ,
ɟɫɥɢ ɟɟ ɪɟɡɭɥɶɬɚɬ ɡɚɜɢɫɢɬ ɬɨɥɶɤɨ ɨɬ ɟɟ ɚɪɝɭɦɟɧɬɨɜ (ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ — ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ
ɬɟɪɦɢɧ “ɱɢɫɬɚɹ” ɧɟ ɢɦɟɟɬ ɧɢɤɚɤɨɝɨ ɨɬɧɨɲɟɧɢɹ ɤ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɵɦ ɮɭɧɤɰɢɹɦ).
ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɩɪɟɞɢɤɚɬɚɦ ɫɨɯɪɚɧɹɬɶ ɢɥɢ ɨɛɪɚɳɚɬɶɫɹ ɤ ɫɨɫɬɨɹɧɢɸ ɬɚɤ, ɱɬɨɛɵ ɷɬɨ ɦɨɝɥɨ
ɜɥɢɹɬɶ ɧɚ ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɨɩɟɪɚɬɨɪɚ operator(); ɩɪɢ ɷɬɨɦ ɩɨɧɹɬɢɟ ɫɨɫɬɨɹɧɢɹ ɜɤɥɸɱɚɟɬ
ɤɚɤ ɞɚɧɧɵɟ-ɱɥɟɧɵ, ɬɚɤ ɢ ɝɥɨɛɚɥɶɧɵɟ ɫɨɫɬɨɹɧɢɹ. Ⱦɥɹ ɩɪɟɞɢɤɚɬɨɜ ɠɟɥɚɬɟɥɶɧɨ ɞɟɥɚɬɶ ɨɩɟɪɚɬɨɪ
operator() ɤɨɧɫɬɚɧɬɧɨɣ ɮɭɧɤɰɢɟɣ-ɱɥɟɧɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15).
Ⱥɥɝɨɪɢɬɦɵ ɫɨɡɞɚɸɬ ɧɟɢɡɜɟɫɬɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɤɨɩɢɣ ɩɪɟɞɢɤɚɬɨɜ ɜ ɧɟɢɡɜɟɫɬɧɵɟ ɦɨɦɟɧɬɵ
ɜɪɟɦɟɧɢ ɢ ɜ ɧɟɢɡɜɟɫɬɧɨɦ ɩɨɪɹɞɤɟ, ɬɚɤ ɱɬɨ ɩɪɢɯɨɞɢɬɫɹ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɬɨ, ɱɬɨ ɜɫɟ ɤɨɩɢɢ ɷɤɜɢ-
ɜɚɥɟɧɬɧɵ.
ɂɦɟɧɧɨ ɩɨɷɬɨɦɭ ɜɵ ɨɬɜɟɱɚɟɬɟ ɡɚ ɬɨ, ɱɬɨɛɵ ɜɫɟ ɤɨɩɢɢ ɩɪɟɞɢɤɚɬɨɜ ɛɵɥɢ ɷɤɜɢɜɚɥɟɧɬɧɵ; ɷɬɨ
ɨɡɧɚɱɚɟɬ, ɱɬɨ ɜɫɟ ɨɧɢ ɞɨɥɠɧɵ ɛɵɬɶ ɱɢɫɬɵɦɢ ɮɭɧɤɰɢɹɦɢ, ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɤɨɬɨɪɵɯ ɩɨɥɧɨ-
ɫɬɶɸ ɢ ɨɞɧɨɡɧɚɱɧɨ ɨɩɪɟɞɟɥɹɟɬɫɹ ɚɪɝɭɦɟɧɬɚɦɢ, ɩɟɪɟɞɚɜɚɟɦɵɦɢ ɨɩɟɪɚɬɨɪɭ operator() ɢ ɧɟ
ɡɚɜɢɫɢɬ ɧɢ ɨɬ ɤɚɤɢɯ ɢɧɵɯ ɮɚɤɬɨɪɨɜ. ɉɪɢ ɩɟɪɟɞɚɱɟ ɨɞɧɢɯ ɢ ɬɟɯ ɠɟ ɚɪɝɭɦɟɧɬɨɜ ɩɪɟɞɢɤɚɬ ɜɫɟɝɞɚ
ɞɨɥɠɟɧ ɜɨɡɜɪɚɳɚɬɶ ɨɞɧɨ ɢ ɬɨ ɠɟ ɡɧɚɱɟɧɢɟ.
ɉɪɟɞɢɤɚɬɵ ɫ ɫɨɫɬɨɹɧɢɹɦɢ ɦɨɝɭɬ ɩɨɤɚɡɚɬɶɫɹ ɩɨɥɟɡɧɵɦɢ, ɧɨ ɨɧɢ ɹɜɧɨ ɧɟ ɨɱɟɧɶ ɩɨɥɟɡɧɵ ɩɪɢ
ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɫ ɚɥɝɨɪɢɬɦɚɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ C++, ɢ ɷɬɨ ɫɞɟɥɚɧɨ ɩɪɟɞɧɚɦɟɪɟɧɧɨ. ȼ
ɱɚɫɬɧɨɫɬɢ, ɩɪɟɞɢɤɚɬɵ ɫ ɫɨɫɬɨɹɧɢɹɦɢ ɦɨɝɭɬ ɛɵɬɶ ɩɨɥɟɡɧɵ ɬɨɥɶɤɨ ɩɪɢ ɜɵɩɨɥɧɟɧɢɢ ɪɹɞɚ ɭɫɥɨɜɢɣ.
• ɉɪɟɞɢɤɚɬ ɧɟ ɤɨɩɢɪɭɟɬɫɹ. ɋɬɚɧɞɚɪɬɧɵɟ ɚɥɝɨɪɢɬɦɵ ɧɟ ɞɚɸɬ ɬɚɤɨɣ ɝɚɪɚɧɬɢɢ; ɜ ɞɟɣɫɬɜɢ-
ɬɟɥɶɧɨɫɬɢ ɚɥɝɨɪɢɬɦɵ, ɧɚɩɪɨɬɢɜ, ɩɪɟɞɩɨɥɚɝɚɸɬ, ɱɬɨ ɩɪɟɞɢɤɚɬɵ ɦɨɝɭɬ ɛɟɡɨɩɚɫɧɨ ɤɨɩɢ-
ɪɨɜɚɬɶɫɹ.
• ɉɪɟɞɢɤɚɬɵ ɢɫɩɨɥɶɡɭɸɬɫɹ ɜ ɩɪɟɞɨɩɪɟɞɟɥɟɧɧɨɦ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɨɦ ɩɨɪɹɞɤɟ. ȼ ɨɛɳɟɦ
ɫɥɭɱɚɟ ɫɬɚɧɞɚɪɬɧɵɟ ɚɥɝɨɪɢɬɦɵ ɧɟ ɞɚɸɬ ɧɢɤɚɤɨɣ ɝɚɪɚɧɬɢɢ ɨɬɧɨɫɢɬɟɥɶɧɨ ɩɨɪɹɞɤɚ ɩɪɢ-
ɦɟɧɟɧɢɹ ɩɪɟɞɢɤɚɬɨɜ ɤ ɷɥɟɦɟɧɬɚɦ ɞɢɚɩɚɡɨɧɚ. ɉɪɢ ɨɬɫɭɬɫɬɜɢɢ ɝɚɪɚɧɬɢɣ ɩɨ ɩɨɜɨɞɭ ɩɨ-
ɪɹɞɤɚ ɨɛɪɚɛɨɬɤɢ ɷɥɟɦɟɧɬɨɜ, ɨɩɟɪɚɰɢɹ ɧɚɩɨɞɨɛɢɟ “ɩɨɦɟɬɢɬɶ ɬɪɟɬɢɣ ɷɥɟɦɟɧɬ” (ɫɦ. ɩɪɢ-
ɦɟɪɵ) ɢɦɟɟɬ ɦɚɥɨ ɫɦɵɫɥɚ, ɩɨɫɤɨɥɶɤɭ ɧɟ ɨɩɪɟɞɟɥɟɧɨ, ɤɚɤɨɣ ɢɦɟɧɧɨ ɷɥɟɦɟɧɬ ɛɭɞɟɬ ɨɛ-
ɪɚɛɨɬɚɧ ɬɪɟɬɶɢɦ.
ɉɟɪɜɨɟ ɭɫɥɨɜɢɟ ɦɨɠɧɨ ɨɛɨɣɬɢ, ɧɚɩɢɫɚɜ ɩɪɟɞɢɤɚɬ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɱɟɬɱɢɤɚ ɫɫɵɥɨɤ.
ɗɬɨɬ ɦɟɬɨɞ ɪɟɲɚɟɬ ɩɪɨɛɥɟɦɭ ɤɨɩɢɪɨɜɚɧɢɹ ɩɪɟɞɢɤɚɬɨɜ, ɩɨɫɤɨɥɶɤɭ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɩɪɟɞɢɤɚɬɵ
ɦɨɝɭɬ ɛɟɡɨɩɚɫɧɨ ɤɨɩɢɪɨɜɚɬɶɫɹ ɛɟɡ ɢɡɦɟɧɟɧɢɹ ɢɯ ɫɟɦɚɧɬɢɤɢ ɩɪɢ ɩɪɢɦɟɧɟɧɢɢ ɤ ɨɛɴɟɤɬɚɦ (ɫɦ.
[Sutter02]). Ɉɞɧɚɤɨ ɨɛɨɣɬɢ ɜɬɨɪɨɟ ɭɫɥɨɜɢɟ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɜɨɡɦɨɠɧɨ.
ȼɫɟɝɞɚ ɨɛɴɹɜɥɹɣɬɟ ɨɩɟɪɚɬɨɪ ɩɪɟɞɢɤɚɬɚ operator() ɤɚɤ ɤɨɧɫɬɚɧɬɧɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ,
ɱɬɨɛɵ ɤɨɦɩɢɥɹɬɨɪ ɦɨɝ ɩɨɦɨɱɶ ɜɚɦ ɢɡɛɟɠɚɬɶ ɧɟɩɪɢɹɬɧɨɫɬɟɣ, ɜɵɜɨɞɹ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɲɢɛɤɟ
ɩɪɢ ɩɨɩɵɬɤɚɯ ɢɡɦɟɧɢɬɶ ɥɸɛɵɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɛɵɬɶ ɭ ɩɪɟɞɢɤɚɬɚ. ɗɬɨ ɧɟ ɩɨ-
ɡɜɨɥɹɟɬ ɩɪɟɫɟɱɶ ɜɫɟ ɡɥɨɭɩɨɬɪɟɛɥɟɧɢɹ, ɧɚɩɪɢɦɟɪ, ɞɨɫɬɭɩ ɤ ɝɥɨɛɚɥɶɧɵɦ ɞɚɧɧɵɦ, ɧɨ, ɩɨ ɤɪɚɣ-
ɧɟɣ ɦɟɪɟ, ɩɨɦɨɠɟɬ ɢɡɛɟɠɚɬɶ ɧɚɢɛɨɥɟɟ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɯ ɨɲɢɛɨɤ.
Стр. 182
Примеры
ɉɪɢɦɟɪ. FlagNth. ɉɟɪɟɞ ɜɚɦɢ ɤɥɚɫɫɢɱɟɫɤɢɣ ɩɪɢɦɟɪ ɢɡ [Sutter02], ɜ ɤɨɬɨɪɨɦ ɜɵɩɨɥɧɹɟɬɫɹ
ɩɨɩɵɬɤɚ ɭɞɚɥɢɬɶ ɬɪɟɬɢɣ ɷɥɟɦɟɧɬ ɢɡ ɤɨɧɬɟɣɧɟɪɚ v.
class FlagNth {
public:
FlagNth( size_t n ) : current_(0), n_(n) { }
// ǍǹǲǭǻǫȄǫǰǷ ǲǸǫȂǰǸǳǰ true ǽǹǶȇǵǹ Ǻǻǳ ǽǻǰǽȇǰǷ ǭȆǲǹǭǰ
bool operator()( const T& ) // ǚǶǹȀǹ: ǸǰǵǹǸǼǽǫǸǽǸǫȊ
{ return ++current_ == n_; } // ǿǾǸǵȁǳȊ
private:
size_t current_, n_;
};
// ... ǺǹǲǱǰ ...

v.erase( remove_if( v.begin(), v.end(), FlagNth(3) ) );
ɍɜɵ, ɧɟɬ ɧɢɤɚɤɨɣ ɝɚɪɚɧɬɢɢ, ɱɬɨ ɛɭɞɟɬ ɭɞɚɥɟɧ ɢɦɟɧɧɨ ɬɪɟɬɢɣ ɷɥɟɦɟɧɬ ȼ ɛɨɥɶɲɢɧɫɬɜɟ ɪɟɚɥɶ-
ɧɵɯ ɪɟɚɥɢɡɚɰɢɣ STL ɩɪɢɜɟɞɟɧɧɵɣ ɤɨɞ ɧɚɪɹɞɭ ɫ ɬɪɟɬɶɢɦ ɭɞɚɥɢɬ ɢ ɲɟɫɬɨɣ ɷɥɟɦɟɧɬ. ɉɨɱɟɦɭ? ɉɨ-
ɬɨɦɭ ɱɬɨ remove_if ɨɛɵɱɧɨ ɪɟɚɥɢɡɭɟɬɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ find_if ɢ remove_copy_if,
ɢ ɤɨɩɢɹ ɩɪɟɞɢɤɚɬɚ ɩɟɪɟɞɚɟɬɫɹ ɤɚɠɞɨɣ ɢɡ ɷɬɢɯ ɮɭɧɤɰɢɣ.
Ʉɨɧɰɟɩɬɭɚɥɶɧɨ ɷɬɨɬ ɩɪɢɦɟɪ ɧɟɜɟɪɟɧ, ɩɨɫɤɨɥɶɤɭ ɚɥɝɨɪɢɬɦ remove_if ɝɚɪɚɧɬɢɪɭɟɬ ɬɨɥɶɤɨ
ɬɨ, ɱɬɨ ɨɧ ɭɞɚɥɢɬ ɜɫɟ ɷɥɟɦɟɧɬɵ, ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɟ ɧɟɤɨɬɨɪɨɦɭ ɤɪɢɬɟɪɢɸ. Ɉɧ ɧɟ ɞɨɤɭɦɟɧɬɢ-
ɪɭɟɬ ɩɨɪɹɞɨɤ, ɜ ɤɨɬɨɪɨɦ ɫɨɜɟɪɲɚɟɬɫɹ ɨɛɯɨɞ ɢɥɢ ɭɞɚɥɟɧɢɟ ɷɥɟɦɟɧɬɨɜ ɢɡ ɨɛɪɚɛɚɬɵɜɚɟɦɨɝɨ
ɞɢɚɩɚɡɨɧɚ, ɬɚɤ ɱɬɨ ɩɪɢɜɟɞɟɧɧɵɣ ɤɨɞ ɢɫɩɨɥɶɡɭɟɬ ɩɪɟɞɩɨɥɨɠɟɧɢɟ, ɤɨɬɨɪɨɟ ɧɟ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɨ
ɢ, ɛɨɥɟɟ ɬɨɝɨ, ɧɟ ɜɵɩɨɥɧɹɟɬɫɹ.
Ʉɨɪɪɟɤɬɧɵɣ ɫɩɨɫɨɛ ɭɞɚɥɟɧɢɹ ɬɪɟɬɶɟɝɨ ɷɥɟɦɟɧɬɚ — ɜɵɩɨɥɧɢɬɶ ɢɬɟɪɚɰɢɢ ɞɥɹ ɟɝɨ ɩɨɢɫɤɚ ɢ
ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ erase.
Ссылки
[Austern99] §4.2.2 • [Josuttis99] §5.8.2, §8.1.4 • [Meyers01] §39 • [Stroustrup00] §10.2.6 •
[Sutter02] §2-3
87. Делайте предикаты чистыми функциями 183
Стр. 183
88. В качестве аргументов алгоритмов и компараторов ...
88. В качестве аргументов алгоритмов

и компараторов лучше использовать
функциональные объекты, а не функции
88. В качестве аргументов алгоритмов и компараторов ...
Резюме
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɟɪɟɞɚɜɚɬɶ ɚɥɝɨɪɢɬɦɚɦ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɚ ɧɟ ɮɭɧɤɰɢɢ, ɚ ɤɨɦ-
ɩɚɪɚɬɨɪɵ ɚɫɫɨɰɢɚɬɢɜɧɵɯ ɤɨɧɬɟɣɧɟɪɨɜ ɩɪɨɫɬɨ ɞɨɥɠɧɵ ɛɵɬɶ ɮɭɧɤɰɢɨɧɚɥɶɧɵɦɢ ɨɛɴɟɤɬɚɦɢ.
Ɏɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɚɞɚɩɬɢɪɭɟɦɵ ɢ, ɜɨɩɪɟɤɢ ɨɠɢɞɚɧɢɹɦ, ɨɛɵɱɧɨ ɞɚɸɬ ɛɨɥɟɟ ɛɵɫɬɪɵɣ
ɩɨ ɫɪɚɜɧɟɧɢɸ ɫ ɮɭɧɤɰɢɹɦɢ ɤɨɞ.
ȼɨ-ɩɟɪɜɵɯ, ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɥɟɝɤɨ ɫɞɟɥɚɬɶ ɚɞɚɩɬɢɪɭɟɦɵɦɢ (ɢ ɬɚɤɢɦɢ ɢɯ ɢ ɫɥɟɞɭ-
ɟɬ ɞɟɥɚɬɶ — ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 89). Ⱦɚɠɟ ɟɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɝɨɬɨɜɚɹ ɮɭɧɤɰɢɹ, ɢɧɨɝɞɚ ɞɥɹ ɟɟ ɢɫ-
ɩɨɥɶɡɨɜɚɧɢɹ ɬɪɟɛɭɟɬɫɹ “ɨɛɟɪɬɤɚ” ɢɡ ptr_fun ɢɥɢ mem_fun. ɇɚɩɪɢɦɟɪ, ɬɚɤɚɹ ɨɛɟɪɬɤɚ ɬɪɟɛɭ-
ɟɬɫɹ ɩɪɢ ɩɨɫɬɪɨɟɧɢɢ ɛɨɥɟɟ ɫɥɨɠɧɵɯ ɜɵɪɚɠɟɧɢɣ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɜɹɡɵɜɚɬɟɥɟɣ (ɫɦ. ɬɚɤɠɟ
ɪɟɤɨɦɟɧɞɚɰɢɸ 84):
inline bool IsHeavy( const Thing& ) { /* ... */ }
find_if(v.begin(), v.end(), not1(IsHeavy )); // ǙȃǳǬǵǫ
Ɉɛɨɣɬɢ ɷɬɭ ɨɲɢɛɤɭ ɨɛɵɱɧɨ ɦɨɠɧɨ ɩɭɬɟɦ ɩɪɢɦɟɧɟɧɢɹ ptr_fun (ɢɥɢ, ɜ ɫɥɭɱɚɟ ɮɭɧɤɰɢɢ-
ɱɥɟɧɚ, mem_fun ɢɥɢ mem_fun_ref), ɱɬɨ, ɤ ɫɨɠɚɥɟɧɢɸ, ɧɟ ɪɚɛɨɬɚɟɬ ɜ ɞɚɧɧɨɦ ɤɨɧɤɪɟɬɧɨɦ
ɫɥɭɱɚɟ:
inline bool IsHeavy( const Thing& ) { /* ... */ }
find_if(v.begin(), v.end(),
not1(ptr_fun (IsHeavy ))); // ǎǰǻǹǳȂǰǼǵǫȊ ǺǹǺȆǽǵǫ...
Ȼɟɞɚ ɜ ɬɨɦ, ɱɬɨ ɷɬɨɬ ɫɩɨɫɨɛ ɧɟ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ, ɞɚɠɟ ɟɫɥɢ ɜɵ ɹɜɧɨ ɭɤɚɠɟɬɟ ɚɪɝɭɦɟɧɬɵ
ɲɚɛɥɨɧɚ ptr_fun. Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɩɪɨɛɥɟɦɚ ɜ ɬɨɦ, ɱɬɨ ptr_fun ɬɨɱɧɨ ɜɵɜɨɞɢɬ ɬɢɩɵ ɚɪɝɭ-
ɦɟɧɬɨɜ ɢ ɜɨɡɜɪɚɳɚɟɦɵɣ ɬɢɩ (ɜ ɱɚɫɬɧɨɫɬɢ, ɬɢɩ ɩɚɪɚɦɟɬɪɚ ɛɭɞɟɬ ɜɵɜɟɞɟɧ ɤɚɤ const Thing&)
ɢ ɫɨɡɞɚɟɬ ɜɧɭɬɪɟɧɧɢɣ ɦɟɯɚɧɢɡɦ, ɤɨɬɨɪɵɣ, ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ, ɩɵɬɚɟɬɫɹ ɞɨɛɚɜɢɬɶ ɞɪɭɝɨɣ &,
ɚ ɫɫɵɥɤɚ ɧɚ ɫɫɵɥɤɭ ɜ ɧɚɫɬɨɹɳɟɟ ɜɪɟɦɹ ɜ C++ ɧɟ ɪɚɡɪɟɲɟɧɚ. ɂɦɟɸɬɫɹ ɫɩɨɫɨɛɵ ɢɫɩɪɚɜɥɟɧɢɣ
ɹɡɵɤɚ ɢ/ɢɥɢ ɛɢɛɥɢɨɬɟɤɚ ɞɥɹ ɪɟɲɟɧɢɹ ɞɚɧɧɨɣ ɩɪɨɛɥɟɦɵ (ɧɚɩɪɢɦɟɪ, ɩɨɡɜɨɥɹɹ ɫɫɵɥɤɟ ɧɚ ɫɫɵɥ-
ɤɭ ɫɜɟɪɧɭɬɶɫɹ ɜ ɨɛɵɱɧɭɸ ɫɫɵɥɤɭ; ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 89), ɧɨ ɧɚ ɫɟɝɨɞɧɹɲɧɢɣ ɞɟɧɶ ɩɪɨ-
ɛɥɟɦɚ ɨɫɬɚɟɬɫɹ ɧɟɪɟɲɟɧɧɨɣ.
ɉɪɢɛɟɝɚɬɶ ɤɨ ɜɫɟɦ ɷɬɢɦ ɭɯɢɳɪɟɧɢɹɦ ɫɨɜɟɪɲɟɧɧɨ ɢɡɥɢɲɧɟ, ɟɫɥɢ ɭ ɜɚɫ ɢɦɟɟɬɫɹ ɤɨɪɪɟɤɬɧɨ
ɧɚɩɢɫɚɧɧɵɣ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 89), ɤɨɬɨɪɵɣ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɛɟɡ ɤɚɤɨɝɨ-ɥɢɛɨ ɫɩɟɰɢɚɥɶɧɨɝɨ ɫɢɧɬɚɤɫɢɫɚ:
struct IsHeavy : unary_function<Thing, bool> {
bool operator()( const Thing& ) const { /* ... */ }
};
find_if(v.begin(), v.end(), not1(IsHeavy ())); // OK

ȿɳɟ ɛɨɥɟɟ ɜɚɠɧɨ ɬɨ, ɱɬɨ ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɫɪɚɜɧɟɧɢɹ ɜ ɚɫɫɨɰɢɚɬɢɜɧɵɯ ɤɨɧɬɟɣɧɟɪɚɯ ɜɚɦ
ɧɭɠɟɧ ɢɦɟɧɧɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, ɚ ɧɟ ɮɭɧɤɰɢɹ. ɗɬɨ ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɧɟɥɶɡɹ ɢɧɫɬɚɧ-
ɰɢɪɨɜɚɬɶ ɲɚɛɥɨɧ ɫ ɮɭɧɤɰɢɟɣ ɜ ɤɚɱɟɫɬɜɟ ɩɚɪɚɦɟɬɪɚ:
bool CompareThings( const Thing&, const Thing& );
set<Thing, CompareThings > s; // ǙȃǳǬǵǫ
Стр. 184
ȼɦɟɫɬɨ ɷɬɨɝɨ ɫɥɟɞɭɟɬ ɧɚɩɢɫɚɬɶ:
struct CompareThings
: public binary_function<Thing,Thing,bool>
{
bool operator()( const Thing&, const Thing& ) const;
};
set<Thing, CompareThings > s; // OK
ɇɚɤɨɧɟɰ, ɢɦɟɟɬɫɹ ɟɳɟ ɨɞɧɨ ɩɪɟɢɦɭɳɟɫɬɜɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ — ɷɮɮɟɤɬɢɜɧɨɫɬɶ.
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɡɧɚɤɨɦɵɣ ɚɥɝɨɪɢɬɦ:
template<typename Iter, typename Compare>
Iter find_if( Iter first, Iter last, Compare comp );
ȿɫɥɢ ɦɵ ɩɟɪɟɞɚɞɢɦ ɚɥɝɨɪɢɬɦɭ ɜ ɤɚɱɟɫɬɜɟ ɤɨɦɩɚɪɚɬɨɪɚ ɮɭɧɤɰɢɸ
inline bool Function( const Thing& ) { /* ... */ }
find_if( v.begin(), v.end(), Function );
ɬɨ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɛɭɞɟɬ ɩɟɪɟɞɚɧɚ ɫɫɵɥɤɚ ɧɚ ɮɭɧɤɰɢɸ. Ʉɨɦɩɢɥɹɬɨɪɵ ɪɟɞɤɨ ɜɫɬɪɚɢɜɚɸɬ ɜɵɡɨɜɵ
ɬɚɤɢɯ ɮɭɧɤɰɢɣ (ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɧɟɤɨɬɨɪɵɯ ɨɬɧɨɫɢɬɟɥɶɧɨ ɫɜɟɠɢɯ ɤɨɦɩɢɥɹɬɨɪɨɜ, ɤɨɬɨɪɵɟ
ɜ ɫɨɫɬɨɹɧɢɢ ɩɪɨɜɟɫɬɢ ɚɧɚɥɢɡ ɜɫɟɣ ɩɪɨɝɪɚɦɦɵ ɜ ɰɟɥɨɦ), ɞɚɠɟ ɟɫɥɢ ɨɧɢ ɨɛɴɹɜɥɟɧɵ ɤɚɤ ɬɚɤɨɜɵɟ
ɢ ɜɢɞɢɦɵ ɜ ɦɨɦɟɧɬ ɤɨɦɩɢɥɹɰɢɢ ɜɵɡɨɜɚ find_if. Ʉɪɨɦɟ ɬɨɝɨ, ɤɚɤ ɭɠɟ ɭɩɨɦɢɧɚɥɨɫɶ, ɮɭɧɤ-
ɰɢɢ ɧɟ ɚɞɚɩɬɢɪɭɟɦɵ.
Ⱦɚɜɚɣɬɟ ɩɟɪɟɞɚɞɢɦ ɚɥɝɨɪɢɬɦɭ find_if ɜ ɤɚɱɟɫɬɜɟ ɤɨɦɩɚɪɚɬɨɪɚ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ:
struct FunctionObject : unary_function<Thing, bool> {
bool operator()( const Thing& ) const { /* ... */ }
};
find_if( v.begin(), v.end(), FunctionObject () );

ȿɫɥɢ ɦɵ ɩɟɪɟɞɚɟɦ ɨɛɴɟɤɬ, ɤɨɬɨɪɵɣ ɢɦɟɟɬ (ɹɜɧɨ ɢɥɢ ɧɟɹɜɧɨ) ɜɫɬɪɚɢɜɚɟɦɵɣ ɨɩɟɪɚɬɨɪ
operator(), ɬɨ ɬɚɤɢɟ ɜɵɡɨɜɵ ɤɨɦɩɢɥɹɬɨɪɵ C++ ɫɩɨɫɨɛɧɵ ɞɟɥɚɬɶ ɜɫɬɪɚɢɜɚɟɦɵɦɢ ɭɠɟ ɨɱɟɧɶ
ɞɚɜɧɨ.
ɉɪɢɦɟɱɚɧɢɟ. ɗɬɚ ɦɟɬɨɞɢɤɚ ɧɟ ɹɜɥɹɟɬɫɹ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɟɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 8); ɟɟ ɫɥɟɞɭɟɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɤɚɤ ɩɪɟɩɹɬɫɬɜɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨ-
ɦɟɧɞɚɰɢɸ 9). ȿɫɥɢ ɭ ɜɚɫ ɢɦɟɟɬɫɹ ɝɨɬɨɜɚɹ ɮɭɧɤɰɢɹ — ɩɟɪɟɞɚɜɚɣɬɟ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɟɟ (ɤɪɨɦɟ ɬɟɯ
ɫɢɬɭɚɰɢɣ, ɤɨɝɞɚ ɜɵ ɞɨɥɠɧɵ ɨɛɹɡɚɬɟɥɶɧɨ ɨɛɟɪɧɭɬɶ ɟɟ ɜ ptr_fun ɢɥɢ mem_fun). ɇɨ ɟɫɥɢ ɜɵ
ɩɢɲɟɬɟ ɧɨɜɵɣ ɤɨɞ ɞɥɹ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɚ ɚɥɝɨɪɢɬɦɚ, ɬɨ ɥɭɱɲɟ ɫɞɟɥɚɬɶ ɟɝɨ
ɮɭɧɤɰɢɨɧɚɥɶɧɵɦ ɨɛɴɟɤɬɨɦ.
Ссылки
[Austern99] §4, §8, §15 • [Josuttis99] §5.9 • [Meyers01] §46 • [Musser01] §8 • [Sutter04] §25
88. В качестве аргументов алгоритмов и компараторов... 185
Стр. 185
89. Корректно пишите функциональные
объекты
Резюме
Ɋɚɡɪɚɛɚɬɵɜɚɣɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɬɚɤ, ɱɬɨɛɵ ɢɯ ɤɨɩɢɪɨɜɚɧɢɟ ɜɵɩɨɥɧɹɥɨɫɶ ɤɚɤ
ɦɨɠɧɨ ɷɮɮɟɤɬɢɜɧɟɟ. Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɞɟɥɚɣɬɟ ɢɯ ɦɚɤɫɢɦɚɥɶɧɨ ɚɞɚɩɬɢɪɭɟɦɵɦɢ ɩɭɬɟɦ
ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ unary_function ɢɥɢ binary_function.
Ɏɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɦɨɞɟɥɢɪɭɸɬ ɭɤɚɡɚɬɟɥɢ ɧɚ ɮɭɧɤɰɢɢ. ɉɨɞɨɛɧɨ ɭɤɚɡɚɬɟɥɹɦ ɧɚ
ɮɭɧɤɰɢɢ, ɨɧɢ ɨɛɵɱɧɨ ɩɟɪɟɞɚɸɬɫɹ ɜ ɮɭɧɤɰɢɢ ɩɨ ɡɧɚɱɟɧɢɸ. ȼɫɟ ɫɬɚɧɞɚɪɬɧɵɟ ɚɥɝɨɪɢɬɦɵ ɩɟɪɟ-
ɞɚɸɬ ɨɛɴɟɤɬɵ ɩɨ ɡɧɚɱɟɧɢɸ, ɢ ɬɨ ɠɟ ɞɨɥɠɧɵ ɞɟɥɚɬɶ ɢ ɜɚɲɢ ɚɥɝɨɪɢɬɦɵ, ɧɚɩɪɢɦɟɪ:
template<class InputIter, class Func>
Function for_each(InputIter first, InputIter last, Function f);
ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɞɨɥɠɧɵ ɥɟɝɤɨ ɤɨɩɢɪɨɜɚɬɶɫɹ ɢ ɛɵɬɶ ɦɨɧɨɦɨɪɮɧɵ-
ɦɢ (ɞɥɹ ɡɚɳɢɬɵ ɨɬ ɫɪɟɡɤɢ), ɬɚɤ ɱɬɨ ɢɡɛɟɝɚɣɬɟ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 54).
Ʉɨɧɟɱɧɨ, ɭ ɜɚɫ ɦɨɝɭɬ ɛɵɬɶ ɛɨɥɶɲɢɟ ɢ/ɢɥɢ ɩɨɥɢɦɨɪɮɧɵɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ — ɢɯ ɬɨɠɟ
ɜɩɨɥɧɟ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ; ɩɪɨɫɬɨ ɫɤɪɨɣɬɟ ɢɯ ɪɚɡɦɟɪ ɫ ɩɨɦɨɳɶɸ ɢɞɢɨɦɵ Pimpl (ɭɤɚɡɚɬɟɥɹ
ɧɚ ɪɟɚɥɢɡɚɰɢɸ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 43). ɗɬɚ ɢɞɢɨɦɚ ɩɨɡɜɨɥɹɟɬ, ɤɚɤ ɢ ɬɪɟɛɭɟɬɫɹ, ɩɨɥɭɱɢɬɶ
ɜɧɟɲɧɢɣ ɦɨɧɨɦɨɪɮɧɵɣ ɤɥɚɫɫ ɦɚɥɨɝɨ ɪɚɡɦɟɪɚ, ɨɛɟɫɩɟɱɢɜɚɸɳɢɣ ɞɨɫɬɭɩ ɤ ɛɨɝɚɬɨɣ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɨɫɬɢ. ȼɧɟɲɧɢɣ ɤɥɚɫɫ ɞɨɥɠɟɧ ɭɞɨɜɥɟɬɜɨɪɹɬɶ ɫɥɟɞɭɸɳɢɦ ɭɫɥɨɜɢɹɦ.
• Ȼɵɬɶ ɚɞɚɩɬɢɪɭɟɦɵɦ. ɇɚɫɥɟɞɭɣɬɟ ɟɝɨ ɨɬ unary_function ɢɥɢ binary_function.
• ɂɫɩɨɥɶɡɨɜɚɬɶ ɢɞɢɨɦɭ Pimpl. Ɍɚɤɨɣ ɤɥɚɫɫ ɫɨɞɟɪɠɢɬ ɭɤɚɡɚɬɟɥɶ (ɧɚɩɪɢɦɟɪ, shared_ptr)
ɧɚ (ɜɨɡɦɨɠɧɨ, ɛɨɥɶɲɨɝɨ ɪɚɡɦɟɪɚ) ɪɟɚɥɢɡɚɰɢɸ ɧɟɨɛɯɨɞɢɦɨɣ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ.
• ɂɦɟɬɶ ɨɩɟɪɚɬɨɪ(ɵ) ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ. ɗɬɢ ɨɩɟɪɚɬɨɪɵ ɩɟɪɟɞɚɸɬ ɜɵɡɨɜɵ ɨɛɴɟɤɬɭ-ɪɟɚɥɢ-
ɡɚɰɢɢ.
ɗɬɢɦ ɨɝɪɚɧɢɱɢɜɚɸɬɫɹ ɬɪɟɛɨɜɚɧɢɹ ɤ ɜɧɟɲɧɟɦɭ ɤɥɚɫɫɭ (ɧɟ ɫɱɢɬɚɹ ɜɨɡɦɨɠɧɨɝɨ ɧɚɥɢɱɢɹ ɫɨɛɫɬɜɟɧɧɵɯ
(ɧɟ ɝɟɧɟɪɢɪɭɟɦɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ) ɤɨɧɫɬɪɭɤɬɨɪɨɜ, ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ ɢ/ɢɥɢ ɞɟɫɬɪɭɤɬɨɪɚ.
Ɏɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɞɨɥɠɧɵ ɛɵɬɶ ɚɞɚɩɬɢɪɭɟɦɵ. ɋɬɚɧɞɚɪɬɧɵɟ ɫɜɹɡɵɜɚɬɟɥɢ ɢ ɚɞɚɩɬɟɪɵ
ɩɨɥɚɝɚɸɬɫɹ ɧɚ ɧɚɥɢɱɢɟ ɨɩɪɟɞɟɥɟɧɧɵɯ ɢɧɫɬɪɭɤɰɢɣ typedef, ɨɛɟɫɩɟɱɢɬɶ ɤɨɬɨɪɵɟ ɥɟɝɱɟ ɜɫɟɝɨ ɩɪɢ
ɧɚɫɥɟɞɨɜɚɧɢɢ ɜɚɲɢɯ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ ɨɬ unary_function ɢɥɢ binary_function.
ɂɧɫɬɚɧɰɢɪɭɣɬɟ unary_function ɢɥɢ binary_function ɫ ɬɟɦɢ ɬɢɩɚɦɢ, ɤɨɬɨɪɵɟ ɩɨɥɭɱɚɟɬ
ɢ ɜɨɡɜɪɚɳɚɟɬ ɜɚɲ ɨɩɟɪɚɬɨɪ operator() (ɩɪɢ ɷɬɨɦ ɭ ɤɚɠɞɨɝɨ ɬɢɩɚ, ɧɟ ɹɜɥɹɸɳɟɝɨɫɹ ɭɤɚɡɚɬɟɥɟɦ,
ɫɥɟɞɭɟɬ ɭɛɪɚɬɶ ɜɫɟ ɫɩɟɰɢɮɢɤɚɬɨɪɵ const ɜɟɪɯɧɟɝɨ ɭɪɨɜɧɹ, ɚ ɬɚɤɠɟ ɜɫɟ &).
ɉɨɫɬɚɪɚɣɬɟɫɶ ɢɡɛɟɠɚɬɶ ɧɚɥɢɱɢɹ ɧɟɫɤɨɥɶɤɢɯ ɨɩɟɪɚɬɨɪɨɜ operator(), ɩɨɫɤɨɥɶɤɭ ɷɬɨ ɡɚ-
ɬɪɭɞɧɹɟɬ ɚɞɚɩɬɢɪɭɟɦɨɫɬɶ. Ⱦɟɥɨ ɜ ɬɨɦ, ɱɬɨ ɨɛɵɱɧɨ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɜɨɡɦɨɠɧɨ ɨɛɟɫɩɟɱɢɬɶ ɤɨɪ-
ɪɟɤɬɧɵɟ ɢɧɫɬɪɭɤɰɢɢ typedef, ɧɟɨɛɯɨɞɢɦɵɟ ɞɥɹ ɚɞɚɩɬɢɪɨɜɚɧɢɹ, ɩɨɫɤɨɥɶɤɭ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɫɢ-
ɧɨɧɢɦ ɬɢɩɚ, ɨɩɪɟɞɟɥɹɟɦɵɣ ɱɟɪɟɡ ɢɧɫɬɪɭɤɰɢɸ typedef, ɢɦɟɟɬ ɪɚɡɧɵɟ ɡɧɚɱɟɧɢɹ ɞɥɹ ɪɚɡɧɵɯ
ɨɩɟɪɚɬɨɪɨɜ operator().
ɇɟ ɜɫɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɹɜɥɹɸɬɫɹ ɩɪɟɞɢɤɚɬɚɦɢ — ɩɪɟɞɢɤɚɬɵ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨ-
ɛɨɣ ɩɨɞɦɧɨɠɟɫɬɜɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 87).
Ссылки
[Allison98] §15, §C • [Austern99] §4, §8, §15 • [Gamma95] Bridge • [Josuttis99] §8.2.4 • [Koenig97]
§21, §29 • [Meyers97] §34 • [Meyers01] §38, §40, §46 • [Musser01] §2.4, §8, §23 • [Sutter00] §26-30 •
[Vandevoorde03] §22
Стр. 186
Безопасность типов
ȿɫɥɢ ɜɵ ɥɠɟɬɟ ɤɨɦɩɢɥɹɬɨɪɭ, ɨɧ ɛɭɞɟɬ ɦɫɬɢɬɶ.
— Ƚɟɧɪɢ ɋɩɟɧɫɟɪ (Henry Spencer)
ȼɫɟɝɞɚ ɛɭɞɭɬ ɜɟɳɢ, ɤɨɬɨɪɵɟ ɦɵ ɛɭɞɟɦ ɯɨɬɟɬɶ ɫɤɚɡɚɬɶ ɜ ɧɚɲɢɯ

ɩɪɨɝɪɚɦɦɚɯ ɢ ɤɨɬɨɪɵɟ ɬɪɭɞɧɨ ɫɮɨɪɦɭɥɢɪɨɜɚɬɶ ɧɚ ɥɸɛɨɦ ɹɡɵɤɟ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
ɉɨɫɥɟɞɧɟɣ (ɧɟ ɩɨ ɜɚɠɧɨɫɬɢ) ɬɟɦɨɣ ɤɧɢɝɢ ɹɜɥɹɟɬɫɹ ɤɨɪɪɟɤɬɧɨɫɬɶ ɬɢɩɨɜ — ɨɱɟɧɶ ɜɚɠɧɨɟ
ɫɜɨɣɫɬɜɨ ɩɪɨɝɪɚɦɦ, ɤɨɬɨɪɨɟ ɜɵ ɞɨɥɠɧɵ ɢɡɨ ɜɫɟɯ ɫɢɥ ɫɬɚɪɚɬɶɫɹ ɩɨɞɞɟɪɠɢɜɚɬɶ. Ɍɟɨɪɟɬɢɱɟɫɤɢ
ɤɨɪɪɟɤɬɧɚɹ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɬɢɩɨɜ ɮɭɧɤɰɢɹ ɧɟ ɦɨɠɟɬ ɨɛɪɚɬɢɬɶɫɹ ɤ ɧɟɬɢɩɢɡɢɪɨɜɚɧɧɨɣ ɩɚɦɹɬɢ
ɢɥɢ ɜɟɪɧɭɬɶ ɧɟɜɟɪɧɵɟ ɡɧɚɱɟɧɢɹ. ɇɚ ɩɪɚɤɬɢɤɟ, ɟɫɥɢ ɜɚɲ ɤɨɞ ɩɨɞɞɟɪɠɢɜɚɟɬ ɤɨɪɪɟɤɬɧɨɫɬɶ ɬɢ-
ɩɨɜ, ɨɧ ɬɟɦ ɫɚɦɵɦ ɢɡɛɟɝɚɟɬ ɛɨɥɶɲɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɧɟɩɪɢɹɬɧɵɯ ɨɲɢɛɨɤ, ɨɬ ɧɟɩɟɪɟɧɨɫɢɦɨɫɬɢ
ɩɪɨɝɪɚɦɦ ɞɨ ɩɨɪɱɢ ɫɨɞɟɪɠɢɦɨɝɨ ɩɚɦɹɬɢ ɢ ɧɟɨɩɪɟɞɟɥɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ ɩɪɨɝɪɚɦɦ.
Ɉɫɧɨɜɧɚɹ ɢɞɟɹ ɩɨɞɞɟɪɠɤɢ ɤɨɪɪɟɤɬɧɨɫɬɢ ɬɢɩɨɜ — ɜɫɟɝɞɚ ɫɱɢɬɵɜɚɬɶ ɢɧɮɨɪɦɚɰɢɸ ɜ ɬɨɦ
ɮɨɪɦɚɬɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɚ ɛɵɥɚ ɡɚɩɢɫɚɧɚ. ɂɧɨɝɞɚ C++ ɩɨɡɜɨɥɹɟɬ ɥɟɝɤɨ ɧɚɪɭɲɢɬɶ ɷɬɨ ɩɪɚɜɢɥɨ;
ɩɪɢɜɟɞɟɧɧɵɟ ɜ ɷɬɨɦ ɪɚɡɞɟɥɟ ɪɟɤɨɦɟɧɞɚɰɢɢ ɩɨɦɨɝɭɬ ɜɚɦ ɢɡɛɟɠɚɬɶ ɩɨɞɨɛɧɵɯ ɨɲɢɛɨɤ.
ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɡɧɚɱɢɦɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 91 — “Ɋɚɛɨɬɚɣɬɟ ɫ ɬɢɩɚɦɢ,
ɚ ɧɟ ɫ ɩɪɟɞɫɬɚɜɥɟɧɢɹɦɢ”. ɋɢɫɬɟɦɚ ɬɢɩɨɜ — ɜɚɲ ɞɪɭɝ ɢ ɜɟɪɧɵɣ ɫɨɸɡɧɢɤ. ȼɨɫɩɨɥɶɡɭɣɬɟɫɶ ɟɟ
ɩɨɦɨɳɶɸ ɢ ɩɨɩɵɬɚɣɬɟɫɶ ɧɟ ɡɥɨɭɩɨɬɪɟɛɥɹɬɶ ɟɟ ɞɨɜɟɪɢɟɦ.
Стр. 187
90. Избегайте явного выбора типов —
используйте полиморфизм
Резюме
ɂɡɛɟɝɚɣɬɟ ɹɜɧɨɝɨ ɜɵɛɨɪɚ ɬɢɩɚ ɨɛɴɟɤɬɚ ɞɥɹ ɧɚɫɬɪɨɣɤɢ ɩɨɜɟɞɟɧɢɹ. ɂɫɩɨɥɶɡɭɣɬɟ ɲɚɛɥɨɧɵ ɢ
ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɟɞɟɧɢɟ ɨɛɴɟɤɬɚ ɨɩɪɟɞɟɥɹɥɨɫɶ ɟɝɨ ɬɢɩɨɦ, ɚ ɧɟ ɜɵɡɵ-
ɜɚɸɳɢɦ ɤɨɞɨɦ.
ɇɚɫɬɪɨɣɤɚ ɩɨɜɟɞɟɧɢɹ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɢɩɚ ɨɛɴɟɤɬɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɢɧɫɬɪɭɤɰɢɢ ɜɵɛɨ-
ɪɚ switch — ɷɬɨ ɧɟɧɚɞɟɠɧɵɣ, ɱɪɟɜɚɬɵɣ ɨɲɢɛɤɚɦɢ, ɧɟɛɟɡɨɩɚɫɧɵɣ ɦɟɬɨɞ, ɩɪɟɞɫɬɚɜɥɹɸɳɢɣ
ɫɨɛɨɣ ɩɟɪɟɧɨɫ ɦɟɬɨɞɨɜ C ɢɥɢ Fortran ɜ C++. ɗɬɨ ɠɟɫɬɤɚɹ ɬɟɯɧɨɥɨɝɢɹ, ɡɚɫɬɚɜɥɹɸɳɚɹ ɜɚɫ ɜɫɹ-
ɤɢɣ ɪɚɡ ɩɪɢ ɞɨɛɚɜɥɟɧɢɢ ɧɨɜɵɯ ɜɨɡɦɨɠɧɨɫɬɟɣ ɩɟɪɟɩɢɫɵɜɚɬɶ ɭɠɟ ɝɨɬɨɜɵɣ ɢ ɨɬɥɚɠɟɧɧɵɣ ɤɨɞ.
ɗɬɨɬ ɦɟɬɨɞ ɧɟɛɟɡɨɩɚɫɟɧ ɟɳɟ ɢ ɩɨɬɨɦɭ, ɱɬɨ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɦɨɠɟɬ ɩɨɞɫɤɚɡɚɬɶ ɜɚɦ, ɱɬɨ ɜɵ ɡɚ-
ɛɵɥɢ ɜɧɟɫɬɢ ɞɨɩɨɥɧɟɧɢɹ ɜ ɤɚɤɭɸ-ɬɨ ɢɡ ɢɧɫɬɪɭɤɰɢɣ switch ɩɪɢ ɞɨɛɚɜɥɟɧɢɢ ɧɨɜɨɝɨ ɬɢɩɚ.
ȼ ɢɞɟɚɥɟ ɞɨɛɚɜɥɟɧɢɟ ɧɨɜɵɯ ɜɨɡɦɨɠɧɨɫɬɟɣ ɜ ɩɪɨɝɪɚɦɦɭ ɞɨɥɠɧɨ ɨɫɭɳɟɫɬɜɥɹɬɶɫɹ ɞɨɛɚɜɥɟɧɢ-
ɟɦ ɧɨɜɨɝɨ ɤɨɞɚ, ɚ ɧɟ ɢɡɦɟɧɟɧɢɟɦ ɫɬɚɪɨɝɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 37). ȼ ɪɟɚɥɶɧɨɣ ɠɢɡɧɢ ɷɬɨ ɧɟ ɜɫɟ-
ɝɞɚ ɬɚɤ — ɡɚɱɚɫɬɭɸ ɜ ɞɨɩɨɥɧɟɧɢɟ ɤ ɧɚɩɢɫɚɧɢɸ ɧɨɜɨɝɨ ɤɨɞɚ ɦɵ ɜɵɧɭɠɞɟɧɵ ɜɧɨɫɢɬɶ ɢɡɦɟɧɟɧɢɹ
ɜ ɭɠɟ ɢɦɟɸɳɢɣɫɹ ɤɨɞ. Ɍɚɤɢɟ ɢɡɦɟɧɟɧɢɹ, ɨɞɧɚɤɨ, ɤɪɚɣɧɟ ɧɟɠɟɥɚɬɟɥɶɧɵ ɢ ɞɨɥɠɧɵ ɛɵɬɶ ɦɢɧɢɦɢ-
ɡɢɪɨɜɚɧɵ ɩɨ ɞɜɭɦ ɩɪɢɱɢɧɚɦ. ȼɨ-ɩɟɪɜɵɯ, ɢɡɦɟɧɟɧɢɹ ɦɨɝɭɬ ɧɚɪɭɲɢɬɶ ɢɦɟɸɳɭɸɫɹ ɮɭɧɤɰɢɨɧɚɥɶ-
ɧɨɫɬɶ. ȼɨ-ɜɬɨɪɵɯ, ɨɧɢ ɩɪɟɩɹɬɫɬɜɭɸɬ ɦɚɫɲɬɚɛɢɪɭɟɦɨɫɬɢ ɩɪɢ ɪɨɫɬɟ ɫɢɫɬɟɦɵ ɢ ɞɨɛɚɜɥɟɧɢɢ ɧɨɜɵɯ
ɜɨɡɦɨɠɧɨɫɬɟɣ, ɩɨɫɤɨɥɶɤɭ ɤɨɥɢɱɟɫɬɜɨ “ɭɡɥɨɜ ɩɨɞɞɟɪɠɤɢ”, ɤ ɤɨɬɨɪɵɦ ɧɚɞɨ ɜɨɡɜɪɚɳɚɬɶɫɹ ɢ ɜɧɨ-
ɫɢɬɶ ɢɡɦɟɧɟɧɢɹ, ɜɫɟ ɜɪɟɦɹ ɜɨɡɪɚɫɬɚɟɬ. ɗɬɨ ɧɚɛɥɸɞɟɧɢɟ ɩɪɢɜɨɞɢɬ ɤ ɩɪɢɧɰɢɩɭ Ɉɬɤɪɵɬɨɫɬɢ-
Ɂɚɤɪɵɬɨɫɬɢ, ɤɨɬɨɪɵɣ ɝɥɚɫɢɬ: ɥɸɛɚɹ ɫɭɳɧɨɫɬɶ (ɧɚɩɪɢɦɟɪ, ɤɥɚɫɫ ɢɥɢ ɦɨɞɭɥɶ) ɞɨɥɠɧɚ ɛɵɬɶ ɨɬ-
ɤɪɵɬɚ ɞɥɹ ɪɚɫɲɢɪɟɧɢɣ, ɧɨ ɡɚɤɪɵɬɚ ɞɥɹ ɢɡɦɟɧɟɧɢɣ (ɫɦ. [Martin96c] ɢ [Meyer00]).
Ʉɚɤɢɦ ɠɟ ɨɛɪɚɡɨɦ ɦɵ ɦɨɠɟɦ ɧɚɩɢɫɚɬɶ ɤɨɞ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɥɟɝɤɨ ɪɚɫɲɢɪɹɟɦ ɛɟɡ ɜɧɟɫɟɧɢɹ
ɢɡɦɟɧɟɧɢɣ? ɂɫɩɨɥɶɡɭɣɬɟ ɩɨɥɢɦɨɪɮɢɡɦ ɞɥɹ ɧɚɩɢɫɚɧɢɹ ɤɨɞɚ ɜ ɬɟɪɦɢɧɚɯ ɚɛɫɬɪɚɤɰɢɣ (ɫɦ. ɬɚɤɠɟ
ɪɟɤɨɦɟɧɞɚɰɢɸ 36), ɩɨɫɥɟ ɱɟɝɨ ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɞɨɛɚɜɥɟɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɷɬɨ ɦɨɠɧɨ
ɛɭɞɟɬ ɫɞɟɥɚɬɶ ɩɭɬɟɦ ɪɚɡɪɚɛɨɬɤɢ ɢ ɞɨɛɚɜɥɟɧɢɹ ɪɚɡɥɢɱɧɵɯ ɪɟɚɥɢɡɚɰɢɣ ɭɩɨɦɹɧɭɬɵɯ ɚɛɫɬɪɚɤɰɢɣ.
ɒɚɛɥɨɧɵ ɢ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɨɛɪɚɡɭɸɬ ɛɚɪɶɟɪ ɞɥɹ ɡɚɜɢɫɢɦɨɫɬɟɣ ɦɟɠɞɭ ɤɨɞɨɦ, ɢɫɩɨɥɶ-
ɡɭɸɳɢɦ ɚɛɫɬɪɚɤɰɢɢ, ɢ ɤɨɞɨɦ, ɢɯ ɪɟɚɥɢɡɭɸɳɢɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 64).
Ʉɨɧɟɱɧɨ, ɭɩɪɚɜɥɟɧɢɟ ɡɚɜɢɫɢɦɨɫɬɹɦɢ ɨɛɭɫɥɨɜɥɟɧɨ ɜɵɛɨɪɨɦ ɜɟɪɧɵɯ ɚɛɫɬɪɚɤɰɢɣ. ȿɫɥɢ ɚɛ-
ɫɬɪɚɤɰɢɢ ɧɟɫɨɜɟɪɲɟɧɧɵ, ɞɨɛɚɜɥɟɧɢɟ ɧɨɜɨɣ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɩɨɬɪɟɛɭɟɬ ɢɡɦɟɧɟɧɢɣ ɢɧɬɟɪ-
ɮɟɣɫɚ (ɚ ɧɟ ɩɪɨɫɬɨ ɞɨɛɚɜɥɟɧɢɹ ɧɨɜɵɯ ɪɟɚɥɢɡɚɰɢɣ ɢɧɬɟɪɮɟɣɫɚ), ɤɨɬɨɪɵɟ ɨɛɵɱɧɨ ɜɥɟɤɭɬ ɡɚ ɫɨ-
ɛɨɣ ɡɧɚɱɢɬɟɥɶɧɵɟ ɢɡɦɟɧɟɧɢɹ ɫɭɳɟɫɬɜɭɸɳɟɝɨ ɤɨɞɚ. ɇɨ ɚɛɫɬɪɚɤɰɢɢ ɩɨɬɨɦɭ ɢ ɧɚɡɵɜɚɸɬɫɹ
“ɚɛɫɬɪɚɤɰɢɹɦɢ”, ɱɬɨ ɩɪɟɞɩɨɥɚɝɚɟɬɫɹ ɢɯ ɛɨɥɶɲɚɹ ɫɬɚɛɢɥɶɧɨɫɬɶ ɩɨ ɫɪɚɜɧɟɧɢɸ ɫ “ɞɟɬɚɥɹɦɢ”,
ɬ.ɟ. ɜɨɡɦɨɠɧɵɦɢ ɪɟɚɥɢɡɚɰɢɹɦɢ ɚɛɫɬɪɚɤɰɢɣ.
ɋɨɜɫɟɦ ɢɧɚɱɟ ɨɛɫɬɨɢɬ ɞɟɥɨ ɫ ɩɪɟɞɟɥɶɧɨ ɞɟɬɚɥɢɡɢɪɨɜɚɧɧɵɦ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɦɚɥɨ
ɚɛɫɬɪɚɤɰɢɣ ɢɥɢ ɜɨɜɫɟ ɨɛɯɨɞɢɬɫɹ ɛɟɡ ɧɢɯ, ɪɚɛɨɬɚɹ ɢɫɤɥɸɱɢɬɟɥɶɧɨ ɫ ɤɨɧɤɪɟɬɧɵɦɢ ɬɢɩɚɦɢ ɢ ɢɯ
ɨɬɞɟɥɶɧɵɦɢ ɨɩɟɪɚɰɢɹɦɢ. Ⱦɨɛɚɜɥɟɧɢɟ ɧɨɜɨɣ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɜ ɬɚɤɨɣ ɤɨɞ — ɫɭɳɟɟ ɦɭɱɟɧɢɟ.
Примеры
ɉɪɢɦɟɪ. Ɋɢɫɨɜɚɧɢɟ ɮɢɝɭɪ. Ʉɥɚɫɫɢɱɟɫɤɢɣ ɩɪɢɦɟɪ — ɪɢɫɨɜɚɧɢɟ ɪɚɡɥɢɱɧɵɯ ɨɛɴɟɤɬɨɜ. Ɍɢ-
ɩɢɱɧɵɣ ɩɨɞɯɨɞ ɜ ɫɬɢɥɟ C ɢɫɩɨɥɶɡɭɟɬ ɜɵɛɨɪ ɬɢɩɚ. Ⱦɥɹ ɷɬɨɝɨ ɨɩɪɟɞɟɥɹɟɬɫɹ ɱɥɟɧ-ɩɟɪɟɱɢɫɥɟɧɢɟ
id_, ɤɨɬɨɪɵɣ ɯɪɚɧɢɬ ɬɢɩ ɤɚɠɞɨɣ ɮɢɝɭɪɵ — ɩɪɹɦɨɭɝɨɥɶɧɢɤ, ɨɤɪɭɠɧɨɫɬɶ ɢ ɬ.ɞ. Ɋɢɫɭɸɳɢɣ ɤɨɞ
ɜɵɩɨɥɧɹɟɬ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɜɵɛɪɚɧɧɨɝɨ ɬɢɩɚ:
188 Безопасность типов
Стр. 188
class Shape { // ...
enum { RECTANGLE, TRIANGLE, CIRCLE } id_;
void Draw() const {
switch( id_ ) { // ǚǶǹȀǹǴ Ƿǰǽǹǯ
case RECTANGLE:
// ... Ǖǹǯ ǯǶȊ ǺǻȊǷǹǾǮǹǶȇǸǳǵǫ ...
break;
case TRIANGLE:
// ... Ǖǹǯ ǯǶȊ ǽǻǰǾǮǹǶȇǸǳǵǫ ...
break;
case CIRCLE:
// ... Ǖǹǯ ǯǶȊ ǹǵǻǾǱǸǹǼǽǳ ...
break;
default : // ǚǶǹȀǹǰ ǻǰȃǰǸǳǰ
assert (!"ǚǻǳ ǯǹǬǫǭǶǰǸǳǳ ǸǹǭǹǮǹ ǽǳǺǫ Ǹǫǯǹ "
"ǹǬǸǹǭǳǽȇ ȈǽǾ ǵǹǸǼǽǻǾǵȁǳȉ" );
break;
}
}
};
Ɍɚɤɨɣ ɤɨɞ ɫɝɢɛɚɟɬɫɹ ɩɨɞ ɫɨɛɫɬɜɟɧɧɵɦ ɜɟɫɨɦ, ɨɧ ɯɪɭɩɨɤ, ɧɟɧɚɞɟɠɟɧ ɢ ɫɥɨɠɟɧ. ȼ ɱɚɫɬɧɨ-
ɫɬɢ, ɨɧ ɫɬɪɚɞɚɟɬ ɬɪɚɧɡɢɬɢɜɧɨɣ ɰɢɤɥɢɱɟɫɤɨɣ ɡɚɜɢɫɢɦɨɫɬɶɸ, ɨ ɤɨɬɨɪɨɣ ɝɨɜɨɪɢɥɨɫɶ ɜ ɪɟɤɨɦɟɧ-
ɞɚɰɢɢ 22. ȼɟɬɜɶ ɩɨ ɭɦɨɥɱɚɧɢɸ ɤɨɧɫɬɪɭɤɰɢɢ switch — ɱɟɬɤɢɣ ɫɢɦɩɬɨɦ ɫɢɧɞɪɨɦɚ “ɧɟ ɡɧɚɸ,
ɱɬɨ ɦɧɟ ɞɟɥɚɬɶ ɫ ɷɬɢɦ ɬɢɩɨɦ”. ɂ ɜɫɟ ɷɬɢ ɛɨɥɟɡɧɟɧɧɵɟ ɧɟɩɪɢɹɬɧɨɫɬɢ ɩɨɥɧɨɫɬɶɸ ɢɫɱɟɡɚɸɬ,
ɫɬɨɢɬ ɬɨɥɶɤɨ ɜɫɩɨɦɧɢɬɶ, ɱɬɨ C++ — ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɵɣ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ:
class Shape { // ...
virtual void Draw() const = 0; // ǕǫǱǯȆǴ ǺǻǹǳǲǭǹǯǸȆǴ
// ǵǶǫǼǼ ǻǰǫǶǳǲǾǰǽ Ǽǭǹȉ ǿǾǸǵȁǳȉ
};
ȼ ɤɚɱɟɫɬɜɟ ɚɥɶɬɟɪɧɚɬɢɜɵ (ɢɥɢ ɜ ɤɚɱɟɫɬɜɟ ɞɨɩɨɥɧɟɧɢɹ) ɪɚɫɫɦɨɬɪɢɦ ɪɟɚɥɢɡɚɰɢɸ, ɤɨɬɨɪɚɹ ɫɥɟ-
ɞɭɟɬ ɫɨɜɟɬɭ ɩɨ ɜɨɡɦɨɠɧɨɫɬɢ ɩɪɢɧɢɦɚɬɶ ɪɟɲɟɧɢɹ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 64):
template<class S>
void Draw( const S& shape ) {
shape.Draw(); // ǗǹǱǰǽ ǬȆǽȇ ǭǳǻǽǾǫǶȇǸǹǴ, ǫ ǷǹǱǰǽ ǳ Ǹǰ ǬȆǽȇ
}; // ǜǷ. ǻǰǵǹǷǰǸǯǫȁǳȉ 64
Ɍɟɩɟɪɶ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɪɢɫɨɜɚɧɢɟ ɤɚɠɞɨɣ ɝɟɨɦɟɬɪɢɱɟɫɤɨɣ ɮɢɝɭɪɵ ɩɟɪɟɯɨɞɢɬ ɤ ɪɟɚɥɢ-
ɡɚɰɢɢ ɫɚɦɨɣ ɮɢɝɭɪɵ, ɢ ɫɢɧɞɪɨɦ “ɧɟ ɡɧɚɸ, ɱɬɨ ɞɟɥɚɬɶ ɫ ɷɬɢɦ ɬɢɩɨɦ” ɩɪɨɫɬɨ ɧɟɜɨɡɦɨɠɟɧ.
Ссылки
[Dewhurst03] §69, §96 • [Martin96c] • [Meyer00] • [Stroustrup00] §12.2.5 • [Sutter04] §36
90. Избегайте явного выбора типов — используйте полиморфизм 189
Стр. 189
91. Работайте с типами,
а не с представлениями
Резюме
ɇɟ ɩɵɬɚɣɬɟɫɶ ɞɟɥɚɬɶ ɤɚɤɢɟ-ɬɨ ɩɪɟɞɩɨɥɨɠɟɧɢɹ ɨ ɬɨɦ, ɤɚɤ ɢɦɟɧɧɨ ɨɛɴɟɤɬɵ ɩɪɟɞɫɬɚɜɥɟɧɵ
ɜ ɩɚɦɹɬɢ. Ʉɚɤ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɡɚɩɢɫɵɜɚɬɶ ɢ ɫɱɢɬɵɜɚɬɶ ɨɛɴɟɤɬɵ ɢɡ ɩɚɦɹɬɢ — ɩɭɫɬɶ ɪɟɲɚɸɬ
ɬɢɩɵ ɨɛɴɟɤɬɨɜ.
ɋɬɚɧɞɚɪɬ C++ ɞɚɟɬ ɨɱɟɧɶ ɦɚɥɨ ɝɚɪɚɧɬɢɣ ɩɨ ɩɨɜɨɞɭ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɬɢɩɨɜ ɜ ɩɚɦɹɬɢ.
• ɐɟɥɵɟ ɱɢɫɥɚ ɢɫɩɨɥɶɡɭɸɬ ɞɜɨɢɱɧɨɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ.
• Ⱦɥɹ ɨɬɪɢɰɚɬɟɥɶɧɵɯ ɱɢɫɟɥ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɵɣ ɤɨɞ ɱɢɫɥɚ ɜ ɞɜɨɢɱɧɨɣ ɫɢɫɬɟɦɟ.
• Ɉɛɵɱɧɵɟ ɫɬɚɪɵɟ ɬɢɩɵ (Plain Old Data, POD5) ɢɦɟɸɬ ɫɨɜɦɟɫɬɢɦɨɟ ɫ C ɪɚɡɦɟɳɟɧɢɟ ɜ ɩɚ-
ɦɹɬɢ: ɩɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɯɪɚɧɹɬɫɹ ɜ ɩɨɪɹɞɤɟ ɢɯ ɨɛɴɹɜɥɟɧɢɹ.
• Ɍɢɩ int ɡɚɧɢɦɚɟɬ ɤɚɤ ɦɢɧɢɦɭɦ 16 ɛɢɬɨɜ.
ȼ ɱɚɫɬɧɨɫɬɢ, ɞɨɫɬɚɬɨɱɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɟ ɫɨɝɥɚɲɟɧɢɹ ɧɟ ɝɚɪɚɧɬɢɪɨɜɚɧɵ ɧɢ ɞɥɹ ɜɫɟɯ
ɢɦɟɸɳɢɯɫɹ ɚɪɯɢɬɟɤɬɭɪ, ɧɢ ɬɟɦ ɛɨɥɟɟ ɞɥɹ ɚɪɯɢɬɟɤɬɭɪ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɩɨɹɜɢɬɶɫɹ ɜ ɛɭɞɭɳɟɦ.
Ɍɚɤ ɱɬɨ ɧɟ ɡɚɛɵɜɚɣɬɟ ɨ ɫɥɟɞɭɸɳɟɦ.
• Ɋɚɡɦɟɪ int ɧɟ ɪɚɜɟɧ ɧɢ 32 ɛɢɬɚɦ, ɧɢ ɤɚɤɨɦɭ-ɥɢɛɨ ɢɧɨɦɭ ɮɢɤɫɢɪɨɜɚɧɧɨɦɭ ɪɚɡɦɟɪɭ.
• ɍɤɚɡɚɬɟɥɢ ɢ ɰɟɥɵɟ ɱɢɫɥɚ ɧɟ ɜɫɟɝɞɚ ɢɦɟɸɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɪɚɡɦɟɪ ɢ ɧɟ ɦɨɝɭɬ ɫɜɨɛɨɞɧɨ
ɩɪɟɨɛɪɚɡɨɜɵɜɚɬɶɫɹ ɞɪɭɝ ɜ ɞɪɭɝɚ.
• Ɋɚɡɦɟɳɟɧɢɟ ɤɥɚɫɫɚ ɜ ɩɚɦɹɬɢ ɧɟ ɜɫɟɝɞɚ ɩɪɢɜɨɞɢɬ ɤ ɪɚɡɦɟɳɟɧɢɸ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɢ ɱɥɟ-
ɧɨɜ ɜ ɭɤɚɡɚɧɧɨɦ ɩɨɪɹɞɤɟ.
• Ɇɟɠɞɭ ɱɥɟɧɚɦɢ ɤɥɚɫɫɚ (ɞɚɠɟ ɟɫɥɢ ɨɧɢ ɹɜɥɹɸɬɫɹ POD) ɦɨɝɭɬ ɛɵɬɶ ɩɪɨɦɟɠɭɬɤɢ ɜ ɰɟɥɹɯ
ɜɵɪɚɜɧɢɜɚɧɢɹ.
• offsetof ɪɚɛɨɬɚɟɬ ɬɨɥɶɤɨ ɞɥɹ POD, ɧɨ ɧɟ ɞɥɹ ɜɫɟɯ ɤɥɚɫɫɨɜ (ɯɨɬɹ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɢ
ɧɟ ɫɨɨɛɳɚɬɶ ɨɛ ɨɲɢɛɤɚɯ).
• Ʉɥɚɫɫ ɦɨɠɟɬ ɢɦɟɬɶ ɫɤɪɵɬɵɟ ɩɨɥɹ.
• ɍɤɚɡɚɬɟɥɢ ɦɨɝɭɬ ɛɵɬɶ ɫɨɜɫɟɦ ɧɟ ɩɨɯɨɠɢ ɧɚ ɰɟɥɵɟ ɱɢɫɥɚ. ȿɫɥɢ ɞɜɚ ɭɤɚɡɚɬɟɥɹ ɭɩɨɪɹɞɨ-
ɱɟɧɵ ɢ ɜɵ ɦɨɠɟɬɟ ɩɪɟɨɛɪɚɡɨɜɚɬɶ ɢɯ ɜ ɰɟɥɵɟ ɱɢɫɥɚ, ɬɨ ɩɨɥɭɱɚɸɳɢɟɫɹ ɡɧɚɱɟɧɢɹ ɦɨɝɭɬ
ɛɵɬɶ ɭɩɨɪɹɞɨɱɟɧɵ ɢɧɚɱɟ.
• ɇɟɥɶɡɹ ɩɟɪɟɧɨɫɢɦɨ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɤɨɧɤɪɟɬɧɨɟ ɪɚɡɦɟɳɟɧɢɟ ɚɜɬɨɦɚɬɢɱɟɫɤɢɯ ɩɟɪɟɦɟɧ-
ɧɵɯ ɜ ɩɚɦɹɬɢ ɢɥɢ ɧɚ ɧɚɩɪɚɜɥɟɧɢɟ ɪɨɫɬɚ ɫɬɟɤɚ.
5
ɇɟɮɨɪɦɚɥɶɧɨ POD ɨɡɧɚɱɚɟɬ ɥɸɛɨɣ ɬɢɩ, ɩɪɟɞɫɬɚɜɥɹɸɳɢɣ ɫɨɛɨɣ ɧɚɛɨɪ ɩɪɨɫɬɵɯ ɞɚɧɧɵɯ, ɜɨɡɦɨɠɧɨ, ɫ
ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɦɢ ɮɭɧɤɰɢɹɦɢ-ɱɥɟɧɚɦɢ ɞɥɹ ɭɞɨɛɫɬɜɚ. Ƚɨɜɨɪɹ ɛɨɥɟɟ ɫɬɪɨɝɨ, POD ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɤɥɚɫɫ ɢɥɢ ɨɛɴɟɞɢɧɟɧɢɟ, ɭ ɤɨɬɨɪɨɝɨ ɧɟɬ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ, ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɢ
ɞɟɫɬɪɭɤɬɨɪɚ, ɚ ɬɚɤɠɟ ɧɟɬ (ɧɟɫɬɚɬɢɱɟɫɤɢɯ) ɱɥɟɧɨɜ-ɞɚɧɧɵɯ, ɹɜɥɹɸɳɢɯɫɹ ɫɫɵɥɤɚɦɢ, ɭɤɚɡɚɬɟɥɹɦɢ ɧɚ ɱɥɟɧɵ
ɢɥɢ ɧɟ ɹɜɥɹɸɳɢɯɫɹ POD. — ɉɪɢɦ. ɪɟɞ.
Стр. 190
• ɍɤɚɡɚɬɟɥɢ ɧɚ ɮɭɧɤɰɢɢ ɦɨɝɭɬ ɢɦɟɬɶ ɪɚɡɦɟɪ, ɨɬɥɢɱɧɵɣ ɨɬ ɪɚɡɦɟɪɚ ɭɤɚɡɚɬɟɥɹ void*, ɧɟ-
ɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɧɟɤɨɬɨɪɵɟ API ɡɚɫɬɚɜɥɹɸɬ ɜɚɫ ɩɪɟɞɩɨɥɨɠɢɬɶ, ɱɬɨ ɢɯ ɪɚɡɦɟɪɵ ɨɞɢ-
ɧɚɤɨɜɵ.
• ɂɡ-ɡɚ ɜɨɩɪɨɫɨɜ ɜɵɪɚɜɧɢɜɚɧɢɹ ɜɵ ɧɟ ɦɨɠɟɬɟ ɡɚɩɢɫɵɜɚɬɶ ɧɢ ɨɞɢɧ ɨɛɴɟɤɬ ɩɨ ɩɪɨɢɡɜɨɥɶ-
ɧɨɦɭ ɚɞɪɟɫɭ ɜ ɩɚɦɹɬɢ.
ɉɪɨɫɬɨ ɤɨɪɪɟɤɬɧɨ ɨɩɪɟɞɟɥɢɬɟ ɬɢɩɵ, ɚ ɡɚɬɟɦ ɱɢɬɚɣɬɟ ɢ ɡɚɩɢɫɵɜɚɣɬɟ ɞɚɧɧɵɟ ɫ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟɦ ɭɤɚɡɚɧɧɵɯ ɬɢɩɨɜ ɜɦɟɫɬɨ ɪɚɛɨɬɵ ɫ ɨɬɞɟɥɶɧɵɦɢ ɛɢɬɚɦɢ, ɫɥɨɜɚɦɢ ɢ ɚɞɪɟɫɚɦɢ. Ɇɨɞɟɥɶ ɩɚ-
ɦɹɬɢ C++ ɝɚɪɚɧɬɢɪɭɟɬ ɷɮɮɟɤɬɢɜɧɭɸ ɪɚɛɨɬɭ, ɧɟ ɡɚɫɬɚɜɥɹɹ ɜɚɫ ɩɪɢ ɷɬɨɦ ɪɚɛɨɬɚɬɶ ɫ ɩɪɟɞɫɬɚɜ-
ɥɟɧɢɹɦɢ ɞɚɧɧɵɯ ɜ ɩɚɦɹɬɢ. Ɍɚɤ ɢ ɧɟ ɞɟɥɚɣɬɟ ɷɬɨɝɨ.
Ссылки
[Dewhurst03] §95
91. Работайте с типами, а не с представлениями 191
Стр. 191
92. Избегайте reinterpret_cast
Резюме
Ʉɚɤ ɝɥɚɫɢɬ ɪɢɦɫɤɚɹ ɩɨɫɥɨɜɢɰɚ, ɭ ɥɠɢ ɤɨɪɨɬɤɢɟ ɧɨɝɢ. ɇɟ ɩɵɬɚɣɬɟɫɶ ɢɫɩɨɥɶɡɨɜɚɬɶ
reinterpret_cast, ɱɬɨɛɵ ɡɚɫɬɚɜɢɬɶ ɤɨɦɩɢɥɹɬɨɪ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɛɢɬɵ ɨɛɴɟɤɬɚ ɨɞɧɨɝɨ ɬɢɩɚ
ɤɚɤ ɛɢɬɵ ɨɛɴɟɤɬɚ ɞɪɭɝɨɝɨ ɬɢɩɚ. Ɍɚɤɨɟ ɞɟɣɫɬɜɢɟ ɩɪɨɬɢɜɨɪɟɱɢɬ ɛɟɡɨɩɚɫɧɨɫɬɢ ɬɢɩɨɜ.
ȼɫɩɨɦɧɢɬɟ: ȿɫɥɢ ɜɵ ɥɠɟɬɟ ɤɨɦɩɢɥɹɬɨɪɭ, ɨɧ ɛɭɞɟɬ ɦɫɬɢɬɶ (Ƚɟɧɪɢ ɋɩɟɧɫɟɪ).
ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ reinterpret_cast ɨɬɪɚɠɚɟɬ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɩɪɨɝɪɚɦɦɢɫɬɚ ɨ ɩɪɟɞɫɬɚɜ-
ɥɟɧɢɢ ɨɛɴɟɤɬɨɜ ɜ ɩɚɦɹɬɢ, ɬ.ɟ. ɩɪɨɝɪɚɦɦɢɫɬ ɛɟɪɟɬ ɧɚ ɫɟɛɹ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɬɨ, ɱɬɨ ɨɧ ɥɭɱɲɟ
ɤɨɦɩɢɥɹɬɨɪɚ ɡɧɚɟɬ, ɱɬɨ ɦɨɠɧɨ ɢ ɱɬɨ ɧɟɥɶɡɹ. Ʉɨɦɩɢɥɹɬɨɪ ɦɨɥɱɚ ɫɞɟɥɚɟɬ ɬɨ, ɱɬɨ ɜɵ ɟɦɭ ɫɤɚɠɟ-
ɬɟ, ɧɨ ɩɪɢɦɟɧɹɬɶ ɬɚɤɭɸ ɝɪɭɛɭɸ ɫɢɥɭ ɜ ɨɬɧɨɲɟɧɢɹɯ ɫ ɤɨɦɩɢɥɹɬɨɪɨɦ — ɩɨɫɥɟɞɧɟɟ ɞɟɥɨ. ɂɡɛɟ-
ɝɚɣɬɟ ɤɚɤɢɯ-ɥɢɛɨ ɩɪɟɞɩɨɥɨɠɟɧɢɣ ɨ ɩɪɟɞɫɬɚɜɥɟɧɢɢ ɞɚɧɧɵɯ, ɩɨɫɤɨɥɶɤɭ ɬɚɤɢɟ ɩɪɟɞɩɨɥɨɠɟɧɢɹ
ɨɱɟɧɶ ɫɢɥɶɧɨ ɜɥɢɹɸɬ ɧɚ ɛɟɡɨɩɚɫɧɨɫɬɶ ɢ ɧɚɞɟɠɧɨɫɬɶ ɜɚɲɟɝɨ ɤɨɞɚ.
Ʉɪɨɦɟ ɬɨɝɨ, ɪɟɚɥɶɧɨɫɬɶ ɬɚɤɨɜɚ, ɱɬɨ ɪɟɡɭɥɶɬɚɬ ɩɪɢɦɟɧɟɧɢɹ reinterpret_cast ɟɳɟ ɯɭɠɟ,
ɱɟɦ ɩɪɨɫɬɨ ɧɚɫɢɥɶɫɬɜɟɧɧɚɹ ɢɧɬɟɪɩɪɟɬɚɰɢɹ ɛɢɬɨɜ ɨɛɴɟɤɬɚ (ɱɬɨ ɫɚɦɨ ɩɨ ɫɟɛɟ ɞɨɫɬɚɬɨɱɧɨ ɧɟɯɨ-
ɪɨɲɨ). Ɂɚ ɢɫɤɥɸɱɟɧɢɟɦ ɧɟɤɨɬɨɪɵɯ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɨɛɪɚɬɢɦɵɯ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ ɪɟɡɭɥɶɬɚɬ ɪɚ-
ɛɨɬɵ reinterpret_cast ɡɚɜɢɫɢɬ ɨɬ ɪɟɚɥɢɡɚɰɢɢ, ɬɚɤ ɱɬɨ ɜɵ ɞɚɠɟ ɧɟ ɡɧɚɟɬɟ ɬɨɱɧɨ, ɤɚɤ ɢɦɟɧ-
ɧɨ ɨɧ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ. ɗɬɨ ɨɱɟɧɶ ɧɟɧɚɞɟɠɧɨɟ ɢ ɧɟɩɟɪɟɧɨɫɢɦɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ.
ɇɟɤɨɬɨɪɵɟ ɧɢɡɤɨɭɪɨɜɧɟɜɵɟ ɫɩɟɰɢɮɢɱɧɵɟ ɞɥɹ ɞɚɧɧɨɣ ɫɢɫɬɟɦɵ ɩɪɨɝɪɚɦɦɵ ɦɨɝɭɬ ɡɚɫɬɚɜɢɬɶ
ɜɚɫ ɩɪɢɦɟɧɢɬɶ reinterpret_cast ɤ ɩɨɬɨɤɭ ɛɢɬɨɜ, ɩɪɨɯɨɞɹɳɢɯ ɱɟɪɟɡ ɧɟɤɨɬɨɪɵɣ ɩɨɪɬ, ɢɥɢ ɞɥɹ
ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɰɟɥɵɯ ɱɢɫɟɥ ɜ ɚɞɪɟɫɚ. ɂɫɩɨɥɶɡɭɣɬɟ ɬɚɤɨɟ ɧɟɛɟɡɨɩɚɫɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɤɚɤ
ɦɨɠɧɨ ɪɟɠɟ ɢ ɬɨɥɶɤɨ ɜ ɬɳɚɬɟɥɶɧɨ ɫɤɪɵɬɵɯ ɡɚ ɚɛɫɬɪɚɤɰɢɹɦɢ ɮɭɧɤɰɢɹɯ, ɱɬɨɛɵ ɜɚɲ ɤɨɞ ɦɨɠɧɨ
ɛɵɥɨ ɩɟɪɟɧɨɫɢɬɶ ɫ ɦɢɧɢɦɚɥɶɧɵɦɢ ɢɡɦɟɧɟɧɢɹɦɢ. ȿɫɥɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɦɟɠɞɭ
ɭɤɚɡɚɬɟɥɹɦɢ ɧɟɫɜɹɡɚɧɧɵɯ ɬɢɩɨɜ, ɥɭɱɲɟ ɜɵɩɨɥɧɹɬɶ ɟɝɨ ɱɟɪɟɡ ɩɪɢɜɟɞɟɧɢɟ ɤ void* ɜɦɟɫɬɨ ɧɟɩɨ-
ɫɪɟɞɫɬɜɟɧɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ reinterpret_cast, ɬ.ɟ. ɜɦɟɫɬɨ ɤɨɞɚ
T1* p1 = ... ;
T2* p2 = reinterpret_cast <T2*>( p1 );
ɥɭɱɲɟ ɩɢɫɚɬɶ
T1* p1 = ... ;
void* pV = p1;
T2* p2 = static_cast <T2*>( pV );
Ссылки
[C++03] §5.2.10(3) • [Dewhurst03] §39 • [Stroustrup00] §5.6
Стр. 192
93. Избегайте применения static_cast
к указателям
Резюме
Ʉ ɭɤɚɡɚɬɟɥɹɦ ɧɚ ɞɢɧɚɦɢɱɟɫɤɢɟ ɨɛɴɟɤɬɵ ɧɟ ɫɥɟɞɭɟɬ ɩɪɢɦɟɧɹɬ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ static_cast.
ɂɫɩɨɥɶɡɭɣɬɟ ɛɟɡɨɩɚɫɧɵɟ ɚɥɶɬɟɪɧɚɬɢɜɵ — ɨɬ dynamic_cast ɞɨ ɩɟɪɟɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
ɉɨɞɭɦɚɣɬɟ ɨ ɡɚɦɟɧɟ static_cast ɛɨɥɟɟ ɦɨɳɧɵɦ ɨɩɟɪɚɬɨɪɨɦ dynamic_cast, ɢ ɜɚɦ ɧɟ ɩɪɢ-
ɞɟɬɫɹ ɡɚɩɨɦɢɧɚɬɶ, ɜ ɤɚɤɢɯ ɫɥɭɱɚɹɯ ɩɪɢɦɟɧɟɧɢɟ static_cast ɛɟɡɨɩɚɫɧɨ, ɚ ɜ ɤɚɤɢɯ — ɱɪɟɜɚɬɨ ɧɟ-
ɩɪɢɹɬɧɨɫɬɹɦɢ. ɏɨɬɹ dynamic_cast ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɧɟɦɧɨɝɨ ɦɟɧɟɟ ɷɮɮɟɤɬɢɜɧɵɦ ɩɪɟɨɛɪɚɡɨɜɚ-
ɧɢɟɦ, ɟɝɨ ɩɪɢɦɟɧɟɧɢɟ ɩɨɡɜɨɥɹɟɬ ɨɛɧɚɪɭɠɢɬɶ ɧɟɜɟɪɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ (ɧɨ ɧɟ ɡɚɛɵɜɚɣɬɟ
ɨ ɪɟɤɨɦɟɧɞɚɰɢɢ 8). ɂɫɩɨɥɶɡɨɜɚɧɢɟ static_cast ɜɦɟɫɬɨ dynamic_cast ɧɚɩɨɦɢɧɚɟɬ ɷɤɨɧɨɦɢɸ
ɧɚ ɧɨɱɧɨɦ ɨɫɜɟɳɟɧɢɢ, ɤɨɝɞɚ ɜɵɢɝɪɵɲ ɞɨɥɥɚɪɚ ɜ ɝɨɞ ɨɛɨɪɚɱɢɜɚɟɬɫɹ ɩɟɪɟɥɨɦɚɧɧɵɦɢ ɧɨɝɚɦɢ.
ɉɪɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɢ ɩɨɫɬɚɪɚɣɬɟɫɶ ɢɡɛɟɝɚɬɶ ɩɨɧɢɠɚɸɳɟɝɨ ɩɪɢɜɟɞɟɧɢɹ. ɉɟɪɟɩɪɨɟɤɬɢɪɭɣɬɟ
ɜɚɲ ɤɨɞ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ ɬɚɤɨɟ ɩɪɢɜɟɞɟɧɢɟ ɫɬɚɥɨ ɢɡɥɢɲɧɢɦ. ȿɫɥɢ ɜɵ ɜɢɞɢɬɟ, ɱɬɨ ɩɟɪɟɞɚɟ-
ɬɟ ɜ ɮɭɧɤɰɢɸ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɬɚɦ, ɝɞɟ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɩɨɬɪɟɛɭɟɬɫɹ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ, ɩɪɨ-
ɫɥɟɞɢɬɟ ɜɫɸ ɰɟɩɨɱɤɭ ɜɵɡɨɜɨɜ, ɱɬɨɛɵ ɩɨɧɹɬɶ, ɝɞɟ ɠɟ ɨɤɚɡɚɥɚɫɶ ɩɨɬɟɪɹɧɧɨɣ ɢɧɮɨɪɦɚɰɢɹ ɨ ɬɢɩɟ;
ɡɚɱɚɫɬɭɸ ɢɡɦɟɧɟɧɢɟ ɩɚɪɵ ɩɪɨɬɨɬɢɩɨɜ ɨɤɚɡɵɜɚɟɬɫɹ ɡɚɦɟɱɚɬɟɥɶɧɵɦ ɪɟɲɟɧɢɟɦ, ɤɨɬɨɪɨɟ ɤ ɬɨɦɭ ɠɟ
ɞɟɥɚɟɬ ɤɨɞ ɛɨɥɟɟ ɩɪɨɫɬɵɦ ɢ ɩɨɧɹɬɧɵɦ.
ɑɪɟɡɦɟɪɧɨɟ ɩɪɢɦɟɧɟɧɢɟ ɩɨɧɢɠɚɸɳɟɝɨ ɩɪɢɜɟɞɟɧɢɹ ɦɨɠɟɬ ɫɥɭɠɢɬɶ ɩɪɢɡɧɚɤɨɦ ɫɥɢɲɤɨɦ ɛɟɞɧɨ-
ɝɨ ɢɧɬɟɪɮɟɣɫɚ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ. Ɍɚɤɨɣ ɢɧɬɟɪɮɟɣɫ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɬɨɦɭ, ɱɬɨ ɛɨɥɶɲɚɹ ɮɭɧɤɰɢɨ-
ɧɚɥɶɧɨɫɬɶ ɨɩɪɟɞɟɥɹɟɬɫɹ ɜ ɩɪɨɢɡɜɨɞɧɵɯ ɤɥɚɫɫɚɯ, ɢ ɜɫɹɤɢɣ ɪɚɡ ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɪɚɫɲɢɪɟɧɢɹ ɢɧ-
ɬɟɪɮɟɣɫɚ ɩɪɢɯɨɞɢɬɫɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɨɧɢɠɚɸɳɟɟ ɩɪɢɜɟɞɟɧɢɟ. Ɉɞɧɨ ɢɡ ɪɟɲɟɧɢɣ ɞɚɧɧɨɣ ɩɪɨɛɥɟ-
ɦɵ — ɩɟɪɟɩɪɨɟɤɬɢɪɨɜɚɧɢɟ ɛɚɡɨɜɨɝɨ ɢɧɬɟɪɮɟɣɫɚ ɜ ɰɟɥɹɯ ɩɨɜɵɲɟɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ.
Ɍɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɫɬɚɧɨɜɹɬɫɹ ɫɭɳɟɫɬɜɟɧɧɵ ɧɚɤɥɚɞɧɵɟ ɪɚɫɯɨɞɵ, ɜɵɡɜɚɧɧɵɟ ɩɪɢɦɟɧɟ-
ɧɢɟɦ dynamic_cast (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8), ɫɥɟɞɭɟɬ ɩɨɞɭɦɚɬɶ ɨ ɪɚɡɪɚɛɨɬɤɟ ɫɨɛɫɬɜɟɧɧɨɝɨ ɩɪɟɨɛɪɚ-
ɡɨɜɚɧɢɹ ɬɢɩɨɜ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ dynamic_cast ɩɪɢ ɨɬɥɚɞɤɟ ɢ static_cast ɜ ɨɤɨɧɱɚɬɟɥɶɧɨɣ
ɜɟɪɫɢɢ (ɫɦ. [Stroustrup00]):
template<class To, class From> To checked_cast (From* from) {
assert(dynamic_cast<To>(from) ==
static_cast<To>(from) && "checked_cast failed" );
return static_cast<To>( from );
}
template<class To, class From> To checked_cast (From& from) {
typedef tr1::remove_reference<To>::type* ToPtr; // [C++TR104]
assert(dynamic_cast<ToPtr>(&from) ==
static_cast<ToPtr>(&from) && "checked_cast failed" );
return static_cast<To>( from );
}
ɗɬɚ ɩɚɪɚ ɮɭɧɤɰɢɣ (ɩɨ ɨɞɧɨɣ ɞɥɹ ɭɤɚɡɚɬɟɥɟɣ ɢ ɫɫɵɥɨɤ) ɩɪɨɫɬɨ ɩɪɨɜɟɪɹɟɬ ɫɨɝɥɚɫɨɜɚɧɧɨɫɬɶ ɞɜɭɯ
ɜɚɪɢɚɧɬɨɜ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ. ȼɵ ɦɨɠɟɬɟ ɥɢɛɨ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɩɪɢɫɩɨɫɨɛɢɬɶ checked_cast
ɞɥɹ ɫɜɨɢɯ ɧɭɠɞ, ɥɢɛɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɟɸɳɢɣɫɹ ɜ ɛɢɛɥɢɨɬɟɤɟ.
Ссылки
[Dewhurst03] §29, §35, §41 • [Meyers97] §39 • [Stroustrup00] §13.6.2 • [Sutter00] §44
93. Избегайте применения static_cast к указателям 193
Стр. 193
94. Избегайте преобразований,
отменяющих const
Резюме
ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ, ɨɬɦɟɧɹɸɳɟɟ const, ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟ-
ɧɢɸ, ɚ ɤɪɨɦɟ ɬɨɝɨ, ɷɬɨ ɫɜɢɞɟɬɟɥɶɫɬɜɨ ɩɥɨɯɨɝɨ ɫɬɢɥɹ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɞɚɠɟ ɜ ɬɨɦ ɫɥɭɱɚɟ,
ɤɨɝɞɚ ɩɪɢɦɟɧɟɧɢɟ ɬɚɤɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɜɩɨɥɧɟ ɡɚɤɨɧɧɨ.
ɉɪɢɦɟɧɟɧɢɟ const — ɷɬɨ ɞɨɪɨɝɚ ɫ ɨɞɧɨɫɬɨɪɨɧɧɢɦ ɞɜɢɠɟɧɢɟɦ, ɢ, ɜɨɫɩɨɥɶɡɨɜɚɜɲɢɫɶ ɷɬɢɦ
ɫɩɟɰɢɮɢɤɚɬɨɪɨɦ, ɜɵ ɧɟ ɞɨɥɠɧɵ ɞɚɜɚɬɶ ɡɚɞɧɢɣ ɯɨɞ. ȿɫɥɢ ɜɵ ɨɬɦɟɧɹɟɬɟ const ɞɥɹ ɨɛɴɟɤɬɚ, ɤɨ-
ɬɨɪɵɣ ɢɡɧɚɱɚɥɶɧɨ ɛɵɥ ɨɛɴɹɜɥɟɧ ɤɚɤ ɤɨɧɫɬɚɧɬɧɵɣ, ɡɚɞɧɢɣ ɯɨɞ ɩɪɢɜɨɞɢɬ ɜɚɫ ɧɚ ɬɟɪɪɢɬɨɪɢɸ ɧɟ-
ɨɩɪɟɞɟɥɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ. ɇɚɩɪɢɦɟɪ, ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ (ɢ, ɛɵɜɚɟɬ, ɬɚɤ ɢ ɩɨɫɬɭɩɚɟɬ) ɩɨɦɟɫɬɢɬɶ
ɤɨɧɫɬɚɧɬɧɵɟ ɞɚɧɧɵɟ ɜ ɩɚɦɹɬɶ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ (ROM) ɢɥɢ ɜ ɫɬɪɚɧɢɰɵ ɩɚɦɹɬɢ, ɡɚɳɢɳɟɧɧɵɟ ɨɬ
ɡɚɩɢɫɢ. Ɉɬɤɚɡ ɨɬ const ɭ ɬɚɤɨɝɨ ɢɫɬɢɧɧɨ ɤɨɧɫɬɚɧɬɧɨɝɨ ɨɛɴɟɤɬɚ — ɩɪɟɫɬɭɩɧɵɣ ɨɛɦɚɧ, ɡɚɱɚɫɬɭɸ
ɤɚɪɚɟɦɵɣ ɚɜɚɪɢɣɧɵɦ ɡɚɜɟɪɲɟɧɢɟɦ ɩɪɨɝɪɚɦɦɵ ɢɡ-ɡɚ ɧɚɪɭɲɟɧɢɹ ɡɚɳɢɬɵ ɩɚɦɹɬɢ.
Ⱦɚɠɟ ɟɫɥɢ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɧɟ ɩɨɬɟɪɩɢɬ ɤɪɚɯ, ɨɬɦɟɧɚ const ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɬɦɟɧɭ
ɨɛɟɳɚɧɧɨɝɨ ɢ ɧɟ ɞɟɥɚɟɬ ɬɨɝɨ, ɱɟɝɨ ɨɬ ɧɟɟ ɡɚɱɚɫɬɭɸ ɨɠɢɞɚɸɬ. ɇɚɩɪɢɦɟɪ, ɜ ɩɪɢɜɟɞɟɧɧɨɦ ɮɪɚɝ-
ɦɟɧɬɟ ɧɟ ɩɪɨɢɫɯɨɞɢɬ ɜɵɞɟɥɟɧɢɹ ɦɚɫɫɢɜɚ ɩɟɪɟɦɟɧɧɨɣ ɞɥɢɧɵ:
void Foolish( unsigned int n ) {
const unsigned int size = 1;
const_cast <unsigned int&>(size) = n; // ǘǰ ǯǰǶǫǴǽǰ ǽǫǵ!
char buffer[size]; // ǛǫǲǷǰǻ ǷǫǼǼǳǭǫ
// ... // ǭǼǰ ǻǫǭǸǹ ǻǫǭǰǸ 1
}
ȼ C++ ɢɦɟɟɬɫɹ ɨɞɧɨ ɧɟɹɜɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ const_cast ɢɡ ɫɬɪɨɤɨɜɨɝɨ ɥɢɬɟɪɚɥɚ ɜ char*:
char* weird = "Trick or treat?";
Ʉɨɦɩɢɥɹɬɨɪ ɦɨɥɱɚ ɜɵɩɨɥɧɹɟɬ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ const_cast ɢɡ const char[16] ɜ char*.
ɗɬɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɩɨɡɜɨɥɟɧɨ ɞɥɹ ɫɨɜɦɟɫɬɢɦɨɫɬɢ ɫ API ɜ ɫɬɢɥɟ C, ɯɨɬɹ ɢ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɞɵɪɭ ɜ ɫɢɫɬɟɦɟ ɬɢɩɨɜ C++. ɋɬɪɨɤɨɜɵɟ ɥɢɬɟɪɚɥɵ ɦɨɝɭɬ ɪɚɡɦɟɳɚɬɶɫɹ ɜ ɩɚɦɹɬɢ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟ-
ɧɢɹ, ɢ ɩɨɩɵɬɤɚ ɢɡɦɟɧɟɧɢɹ ɬɚɤɨɣ ɫɬɪɨɤɢ ɦɨɠɟɬ ɜɵɡɜɚɬɶ ɧɚɪɭɲɟɧɢɟ ɡɚɳɢɬɵ ɩɚɦɹɬɢ.
ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ, ɨɬɦɟɧɹɸɳɟɟ const, ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɧɟɨɛɯɨɞɢɦɵɦ ɞɥɹ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ
API, ɧɟɤɨɪɪɟɤɬɧɨ ɭɤɚɡɵɜɚɸɳɟɣ ɤɨɧɫɬɚɧɬɧɨɫɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15). Ɉɧɨ ɬɚɤɠɟ ɩɨɥɟɡɧɨ,
ɤɨɝɞɚ ɮɭɧɤɰɢɹ, ɤɨɬɨɪɚɹ ɞɨɥɠɧɚ ɩɨɥɭɱɚɬɶ ɢ ɜɨɡɜɪɚɳɚɬɶ ɫɫɵɥɤɭ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɬɢɩɚ, ɢɦɟɟɬ
ɤɚɤ ɤɨɧɫɬɚɧɬɧɭɸ, ɬɚɤ ɢ ɧɟɤɨɧɫɬɚɧɬɧɭɸ ɩɟɪɟɝɪɭɡɤɢ, ɩɪɢɱɟɦ ɨɞɧɚ ɢɡ ɧɢɯ ɜɵɡɵɜɚɟɬ ɞɪɭɝɭɸ:
const Object& f( const Object& );
Object& f( Object& obj ) {
const Object& ref = obj;
return const_cast <Object &>(f(ref))
); // ǚǻǰǹǬǻǫǲǹǭǫǸǳǰ
} // ǭǹǲǭǻǫȄǫǰǷǹǮǹ ǽǳǺǫ
Ссылки
[Dewhurst03] §32, §40 • [Sutter00] §44
Стр. 194
95. Не используйте преобразование типов
в стиле C
Резюме
ȼɨɡɪɚɫɬ ɧɟ ɜɫɟɝɞɚ ɨɡɧɚɱɚɟɬ ɦɭɞɪɨɫɬɶ. ɋɬɚɪɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɢɦɟɟɬ ɪɚɡ-
ɥɢɱɧɭɸ (ɢ ɱɚɫɬɨ ɨɩɚɫɧɭɸ) ɫɟɦɚɧɬɢɤɭ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɤɨɧɬɟɤɫɬɚ, ɫɩɪɹɬɚɧɧɭɸ ɡɚ ɟɞɢɧɵɦ
ɫɢɧɬɚɤɫɢɫɨɦ. Ɂɚɦɟɧɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɩɪɟɨɛɪɚɡɨɜɚɧɢɹɦɢ C++ ɩɨɦɨɠɟɬ ɡɚɳɢ-
ɬɢɬɶɫɹ ɨɬ ɧɟɨɠɢɞɚɧɧɵɯ ɨɲɢɛɨɤ.
Ɉɞɧɚ ɢɡ ɩɪɨɛɥɟɦ, ɫɜɹɡɚɧɧɵɯ ɫ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ
ɨɧɨ ɢɫɩɨɥɶɡɭɟɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɫɢɧɬɚɤɫɢɫ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɧɟɫɤɨɥɶɤɨ ɪɚɡɧɵɯ ɜɟɳɟɣ, ɜ ɡɚɜɢɫɢ-
ɦɨɫɬɢ ɨɬ ɬɚɤɢɯ ɦɟɥɨɱɟɣ, ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɤɚɤɢɟ ɢɦɟɧɧɨ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɜɤɥɸɱɟɧɵ ɩɪɢ
ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include. ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C++, ɫɨɯɪɚɧɹɹ ɨɩɪɟɞɟɥɟɧɧɭɸ
ɨɩɚɫɧɨɫɬɶ, ɩɪɢɫɭɳɭɸ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹɦ ɜɨɨɛɳɟ, ɢɦɟɸɬ ɱɟɬɤɨ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɨɟ ɩɪɟɞɧɚɡɧɚ-
ɱɟɧɢɟ, ɢɯ ɥɟɝɤɨ ɧɚɣɬɢ, ɞɨɥɶɲɟ ɩɢɫɚɬɶ (ɱɬɨ ɞɚɟɬ ɜɪɟɦɹ ɞɜɚɠɞɵ ɩɨɞɭɦɚɬɶ ɩɪɢ ɢɯ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɢ), ɢ ɧɟ ɩɨɡɜɨɥɹɸɬ ɧɟɡɚɦɟɬɧɨ ɜɵɩɨɥɧɢɬɶ ɨɩɚɫɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ reinterpret_cast
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ, ɜ ɤɨɬɨɪɨɦ Derived — ɩɪɨɢɡɜɨɞɧɵɣ ɨɬ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ Base:
extern void Fun( Derived* );
void Gun( Base* pb ) {

// ǌǾǯǰǷ ǼȂǳǽǫǽȇ, Ȃǽǹ ǿǾǸǵȁǳȊ Gun ǲǸǫǰǽ, Ȃǽǹ pb ǭ
// ǯǰǴǼǽǭǳǽǰǶȇǸǹǼǽǳ ǾǵǫǲȆǭǫǰǽ Ǹǫ ǹǬȅǰǵǽ ǽǳǺǫ Derived ǳ
// ȀǹȂǰǽ Ǻǰǻǰǯǫǽȇ ǰǮǹ ǿǾǸǵȁǳǳ Fun
Derived* pd = (Derived*)pb; // ǚǶǹȀǹ: ǺǻǰǹǬǻǫǲǹǭǫǸǳǰ
Fun( pd ); // ǭ ǼǽǳǶǰ C
}
ȿɫɥɢ ɮɭɧɤɰɢɹ Gun ɢɦɟɟɬ ɞɨɫɬɭɩ ɤ ɨɩɪɟɞɟɥɟɧɢɸ Derived (ɧɚɩɪɢɦɟɪ, ɩɪɢ ɜɤɥɸɱɟɧɢɢ ɡɚ-
ɝɨɥɨɜɨɱɧɨɝɨ ɮɚɣɥɚ derived.h), ɬɨ ɤɨɦɩɢɥɹɬɨɪ ɢɦɟɟɬ ɜɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨ ɪɚɡ-
ɦɟɳɟɧɢɢ ɨɛɴɟɤɬɚ, ɱɬɨɛɵ ɜɵɩɨɥɧɢɬɶ ɜɫɟ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ ɩɨ ɤɨɪɪɟɤɬɢɪɨɜɤɟ ɭɤɚɡɚɬɟɥɹ
ɩɪɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɢ ɨɬ Base ɤ Derived. ɇɨ ɟɫɥɢ ɚɜɬɨɪ Gun ɡɚɛɵɥ ɜɤɥɸɱɢɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸ-
ɳɢɣ ɮɚɣɥ ɨɩɪɟɞɟɥɟɧɢɹ, ɢ ɮɭɧɤɰɢɢ Gun ɜɢɞɧɨ ɬɨɥɶɤɨ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɟ ɨɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ
Derived, ɬɨ ɤɨɦɩɢɥɹɬɨɪ ɛɭɞɟɬ ɩɨɥɚɝɚɬɶ, ɱɬɨ Base ɢ Derived — ɧɟɫɜɹɡɚɧɧɵɟ ɬɢɩɵ, ɢ ɢɧ-
ɬɟɪɩɪɟɬɢɪɭɟɬ ɛɢɬɵ ɭɤɚɡɚɬɟɥɹ Base* ɤɚɤ ɛɢɬɵ ɭɤɚɡɚɬɟɥɹ Derived*, ɧɟ ɞɟɥɚɹ ɧɢɤɚɤɢɯ ɤɨɪɪɟɤ-
ɰɢɣ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɞɢɤɬɨɜɚɬɶɫɹ ɪɚɡɦɟɳɟɧɢɟɦ ɨɛɴɟɤɬɚ ɜ ɩɚɦɹɬɢ!
Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɟɫɥɢ ɜɵ ɡɚɛɭɞɟɬɟ ɜɤɥɸɱɢɬɶ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ, ɬɨ ɜɚɲ ɤɨɞ ɦɨɠɟɬ ɚɜɚ-
ɪɢɣɧɨ ɡɚɜɟɪɲɢɬɶɫɹ ɛɟɡ ɜɢɞɢɦɵɯ ɩɪɢɱɢɧ, ɩɪɢ ɬɨɦ ɱɬɨ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɫɨɨɛɳɢɥ ɧɢ ɨɛ ɨɞɧɨɣ
ɨɲɢɛɤɟ. ɂɡɛɚɜɢɦɫɹ ɨɬ ɩɪɨɛɥɟɦɵ ɫɥɟɞɭɸɳɢɦ ɫɩɨɫɨɛɨɦ:
extern void Fun( Derived* );
void Gun( Base* pb ) {
// ǐǼǶǳ ǷȆ ǮǫǻǫǸǽǳǻǹǭǫǸǸǹ ǲǸǫǰǷ, Ȃǽǹ pb Ǹǫ ǼǫǷǹǷ ǯǰǶǰ
// ǾǵǫǲȆǭǫǰǽ Ǹǫ ǹǬȅǰǵǽ ǽǳǺǫ Derived:
// ǚǻǰǹǬǻǫǲǹǭǫǸǳǰ ǭ ǼǽǳǶǰ C++
Derived * pd = static_cast <Derived *>(pb);
95. Не используйте преобразование типов в стиле C 195
Стр. 195
// Ǎ ǺǻǹǽǳǭǸǹǷ ǼǶǾȂǫǰ ǼǶǰǯǾǰǽ ǳǼǺǹǶȇǲǹǭǫǽȇ
// = dynamic_cast<Derived*>(pb);
Fun(pd);
}
Ɍɟɩɟɪɶ, ɟɫɥɢ ɭ ɤɨɦɩɢɥɹɬɨɪɚ ɧɟɞɨɫɬɚɬɨɱɧɨ ɫɬɚɬɢɱɟɫɤɨɣ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɨɬɧɨɲɟɧɢɹɯ ɦɟɠɞɭ
Base ɢ Derived, ɨɧ ɜɵɜɟɞɟɬ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɲɢɛɤɟ, ɜɦɟɫɬɨ ɬɨɝɨ ɱɬɨɛɵ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɩɪɢ-
ɦɟɧɢɬɶ ɩɨɛɢɬɨɜɨɟ (ɢ ɩɨɬɟɧɰɢɚɥɶɧɨ ɨɩɚɫɧɨɟ) ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ reinterpret_cast (ɫɦ. ɪɟɤɨ-
ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɜ ɫɬɢɥɟ C++ ɦɨɝɭɬ ɡɚɳɢɬɢɬɶ ɤɨɪɪɟɤɬɧɨɫɬɶ ɜɚɲɟɝɨ ɤɨɞɚ ɜ ɩɪɨɰɟɫɫɟ ɷɜɨ-
ɥɸɰɢɢ ɫɢɫɬɟɦɵ. ɉɭɫɬɶ, ɧɚɩɪɢɦɟɪ, ɭ ɜɚɫ ɟɫɬɶ ɢɟɪɚɪɯɢɹ ɫ ɤɨɪɧɟɦ ɜ Employee, ɢ ɜɚɦ ɧɚɞɨ ɨɩ-
ɪɟɞɟɥɢɬɶ ɭɧɢɤɚɥɶɧɵɣ ɢɞɟɧɬɢɮɢɤɚɬɨɪ ID ɞɥɹ ɤɚɠɞɨɝɨ ɨɛɴɟɤɬɚ Employee. ȼɵ ɦɨɠɟɬɟ ɨɩɪɟɞɟ-
ɥɢɬɶ ID ɤɚɤ ɭɤɚɡɚɬɟɥɶ ɧɚ ɫɚɦ ɨɛɴɟɤɬ Employee. ɍɤɚɡɚɬɟɥɢ ɨɞɧɨɡɧɚɱɧɨ ɢɞɟɧɬɢɮɢɰɢɪɭɸɬ ɨɛɴ-
ɟɤɬɵ, ɧɚ ɤɨɬɨɪɵɟ ɭɤɚɡɵɜɚɸɬ, ɢ ɦɨɝɭɬ ɫɪɚɜɧɢɜɚɬɶɫɹ ɧɚ ɪɚɜɟɧɫɬɜɨ ɞɪɭɝ ɞɪɭɝɭ — ɱɬɨ ɜ ɬɨɱɧɨɫɬɢ
ɬɨ, ɱɬɨ ɧɚɦ ɢ ɧɚɞɨ. ɂɬɚɤ, ɡɚɩɢɲɟɦ:
typedef Employee* EmployeeID;
Employee& Fetch( EmployeeID id ) {

return *id;
}
ɉɭɫɬɶ ɜɵ ɤɨɞɢɪɭɟɬɟ ɱɚɫɬɶ ɫɢɫɬɟɦɵ ɫ ɞɚɧɧɵɦ ɞɢɡɚɣɧɨɦ. ɉɭɫɬɶ ɩɨɡɠɟ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɫɨɯɪɚ-
ɧɹɬɶ ɜɚɲɢ ɡɚɩɢɫɢ ɜ ɪɟɥɹɰɢɨɧɧɨɣ ɛɚɡɟ ɞɚɧɧɵɯ. ɉɨɧɹɬɧɨ, ɱɬɨ ɫɨɯɪɚɧɟɧɢɟ ɭɤɚɡɚɬɟɥɟɣ — ɧɟ ɬɨ,
ɱɬɨ ɜɚɦ ɬɪɟɛɭɟɬɫɹ. ȼ ɪɟɡɭɥɶɬɚɬɟ ɜɵ ɢɡɦɟɧɹɟɬɟ ɞɢɡɚɣɧ ɬɚɤ, ɱɬɨɛɵ ɤɚɠɞɵɣ ɨɛɴɟɤɬ ɢɦɟɥ ɭɧɢ-
ɤɚɥɶɧɵɣ ɰɟɥɨɱɢɫɥɟɧɧɵɣ ɢɞɟɧɬɢɮɢɤɚɬɨɪ. Ɍɨɝɞɚ ɰɟɥɨɱɢɫɥɟɧɧɵɣ ɢɞɟɧɬɢɮɢɤɚɬɨɪ ɦɨɠɟɬ ɯɪɚ-
ɧɢɬɶɫɹ ɜ ɛɚɡɟ ɞɚɧɧɵɯ, ɚ ɯɷɲ-ɬɚɛɥɢɰɚ ɨɬɨɛɪɚɠɚɟɬ ɢɞɟɧɬɢɮɢɤɚɬɨɪɵ ɧɚ ɨɛɴɟɤɬɵ Employee. Ɍɟ-
ɩɟɪɶ typedef ɜɵɝɥɹɞɢɬ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
typedef int EmployeeID;
Employee& Fetch( EmployeeID id ) {

return employeeTable_.lookup(id);
}
ɗɬɨ ɤɨɪɪɟɤɬɧɵɣ ɞɢɡɚɣɧ, ɢ ɜɵ ɨɠɢɞɚɟɬɟ, ɱɬɨ ɥɸɛɨɟ ɧɟɜɟɪɧɨɟ ɭɩɨɬɪɟɛɥɟɧɢɟ EmployeeID
ɞɨɥɠɧɨ ɩɪɢɜɟɫɬɢ ɤ ɨɲɢɛɤɟ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ. Ɍɚɤ ɢ ɩɨɥɭɱɚɟɬɫɹ, ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɫɥɟɞɭɸ-
ɳɟɝɨ ɧɟɛɨɥɶɲɨɝɨ ɮɪɚɝɦɟɧɬɚ:
void TooCoolToUseNewCasts( EmployeeID id ) {
Secretary* pSecretary = (Secretary*)id; // ǚǶǹȀǹ:
// ... // ǺǻǰǹǬǻǫǲǹǭǫǸǳǰ ǭ ǼǽǳǶǰ C
}
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɫɬɚɪɨɣ ɢɧɫɬɪɭɤɰɢɢ typedef ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɜ ɫɬɢɥɟ C ɜɵɩɨɥɧɹɟɬ
static_cast, ɩɪɢ ɧɨɜɨɣ ɛɭɞɟɬ ɜɵɩɨɥɧɟɧɨ reinterpret_cast ɫ ɧɟɤɨɬɨɪɵɦ ɰɟɥɵɦ ɱɢɫɥɨɦ,
ɱɬɨ ɞɚɫɬ ɧɚɦ ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ ɩɪɨɝɪɚɦɦɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92).
ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɜ ɫɬɢɥɟ C++ ɩɪɨɳɟ ɢɫɤɚɬɶ ɜ ɢɫɯɨɞɧɵɯ ɬɟɤɫɬɚɯ ɩɪɢ ɩɨɦɨɳɢ ɚɜɬɨɦɚɬɢɱɟ-
ɫɤɨɝɨ ɢɧɫɬɪɭɦɟɧɬɚɪɢɹ ɧɚɩɨɞɨɛɢɟ grep (ɧɨ ɧɢɤɚɤɨɟ ɪɟɝɭɥɹɪɧɨɟ ɜɵɪɚɠɟɧɢɟ grep ɧɟ ɩɨɡɜɨɥɢɬ
ɜɵɥɨɜɢɬɶ ɫɢɧɬɚɤɫɢɫ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C). ɉɨɫɤɨɥɶɤɭ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɨɱɟɧɶ
ɨɩɚɫɧɵ (ɜ ɨɫɨɛɟɧɧɨɫɬɢ static_cast ɞɥɹ ɭɤɚɡɚɬɟɥɟɣ ɢ reinterpret_cast; ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 92), ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɨɝɨ ɢɧɫɬɪɭɦɟɧɬɚɪɢɹ ɞɥɹ ɢɯ ɨɬɫɥɟɠɢɜɚɧɢɹ — ɧɟ-
ɩɥɨɯɚɹ ɢɞɟɹ.
Ссылки
[Dewhurst03] §40 • [Meyers96] §2 • [Stroustrup00] §15.4.5 • [Sutter00] §44
Стр. 196
96. Не применяйте memcpy или memcmp
к не@POD типам
Резюме
ɇɟ ɪɚɛɨɬɚɣɬɟ ɪɟɧɬɝɟɧɨɜɫɤɢɦ ɚɩɩɚɪɚɬɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 91). ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ memcpy
ɢ memcmp ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɢɥɢ ɫɪɚɜɧɟɧɢɹ ɱɟɝɨ-ɥɢɛɨ ɫɬɪɭɤɬɭɪɢɪɨɜɚɧɧɨɝɨ ɛɨɥɟɟ, ɱɟɦ ɨɛɵɱɧɚɹ
ɩɚɦɹɬɶ.
Ɏɭɧɤɰɢɢ memcpy ɢ memcmp ɧɚɪɭɲɚɸɬ ɫɢɫɬɟɦɭ ɬɢɩɨɜ. ɂɫɩɨɥɶɡɨɜɚɬɶ memcpy ɞɥɹ ɤɨɩɢɪɨ-
ɜɚɧɢɹ ɨɛɴɟɤɬɨɜ — ɷɬɨ ɬɨ ɠɟ, ɱɬɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɫɟɪɨɤɫ ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɞɟɧɟɝ, ɚ ɫɪɚɜɧɢɜɚɬɶ
ɨɛɴɟɤɬɵ ɩɪɢ ɩɨɦɨɳɢ memcmp — ɬɨ ɠɟ, ɱɬɨ ɫɪɚɜɧɢɜɚɬɶ ɞɜɭɯ ɥɟɨɩɚɪɞɨɜ ɩɨ ɤɨɥɢɱɟɫɬɜɭ ɩɹɬɟɧ.
ɂɧɫɬɪɭɦɟɧɬɵ ɢ ɦɟɬɨɞɵ ɦɨɝɭɬ ɤɚɡɚɬɶɫɹ ɩɨɞɯɨɞɹɳɢɦɢ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɪɚɛɨɬɵ, ɧɨ ɨɧɢ ɫɥɢɲ-
ɤɨɦ ɝɪɭɛɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɟɟ ɩɪɚɜɢɥɶɧɨ.
Ɉɛɴɟɤɬɵ C++ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɤɪɵɬɢɹ ɞɚɧɧɵɯ (ɜɨɡɦɨɠɧɨ, ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɣ ɩɪɢɧɰɢɩ
ɜ ɪɚɡɪɚɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). Ɉɛɴɟɤɬɵ ɫɤɪɵɜɚɸɬ ɞɚɧɧɵɟ
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41) ɢ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɬɨɱɧɵɟ ɚɛɫɬɪɚɤɰɢɢ ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɷɬɢɯ ɞɚɧɧɵɯ
ɩɨɫɪɟɞɫɬɜɨɦ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɢ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 52 ɩɨ 55). ɉɪɨɣ-
ɬɢɫɶ ɩɨ ɧɢɦ ɝɪɭɛɵɦ ɢɧɫɬɪɭɦɟɧɬɨɦ ɬɢɩɚ memcpy — ɫɟɪɶɟɡɧɨɟ ɧɚɪɭɲɟɧɢɟ ɩɪɢɧɰɢɩɚ ɫɨɤɪɵɬɢɹ
ɢɧɮɨɪɦɚɰɢɢ, ɤɨɬɨɪɨɟ ɡɚɱɚɫɬɭɸ ɩɪɢɜɨɞɢɬ ɤ ɭɬɟɱɤɚɦ ɩɚɦɹɬɢ ɢ ɪɟɫɭɪɫɨɜ (ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ),
ɚɜɚɪɢɣɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ ɩɪɨɝɪɚɦɦɵ (ɜ ɫɥɭɱɚɟ ɩɨɯɭɠɟ) ɢɥɢ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ
(ɜ ɫɚɦɨɦ ɯɭɞɲɟɦ ɫɥɭɱɚɟ). ɇɚɩɪɢɦɟɪ:
{
// ǜǹǲǯǫǰǷ ǯǭǫ int ǭ ǺǫǷȊǽǳ
shared_ptr<int> p1( new int ), p2( new int );
memcpy (&p1, &p2, sizeof (p1)); // ǝǫǵ ǯǰǶǫǽȇ ǸǰǶȇǲȊ!!!
} // ǞǽǰȂǵǫ ǺǫǷȊǽǳ: p2 ǸǳǵǹǮǯǫ Ǹǰ ǾǯǫǶȊǰǽǼȊ
// ǚǹǭǻǰǱǯǰǸǳǰ ǺǫǷȊǽǳ: p1 ǾǯǫǶȊǰǽǼȊ ǯǭǫǱǯȆ
ɇɟɜɟɪɧɨɟ ɩɪɢɦɟɧɟɧɢɟ memcpy ɦɨɠɟɬ ɜɥɢɹɬɶ ɧɚ ɬɚɤɢɟ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ ɫɜɨɣɫɬɜɚ, ɤɚɤ ɬɢɩ
ɢ ɫɭɳɧɨɫɬɶ ɨɛɴɟɤɬɚ. Ʉɨɦɩɢɥɹɬɨɪɵ ɱɚɫɬɨ ɞɨɛɚɜɥɹɸɬ ɤ ɩɨɥɢɦɨɪɮɧɵɦ ɨɛɴɟɤɬɚɦ ɫɤɪɵɬɵɟ ɞɚɧ-
ɧɵɟ (ɬɚɤ ɧɚɡɵɜɚɟɦɵɣ ɭɤɚɡɚɬɟɥɶ ɧɚ ɜɢɪɬɭɚɥɶɧɭɸ ɬɚɛɥɢɰɭ), ɤɨɬɨɪɵɟ ɨɩɪɟɞɟɥɹɸɬ ɫɭɳɧɨɫɬɶ ɨɛɴ-
ɟɤɬɚ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ. ȼ ɫɥɭɱɚɟ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɜ ɨɛɴɟɤɬɟ ɫɨ-
ɞɟɪɠɢɬɫɹ ɧɟɫɤɨɥɶɤɨ ɬɚɤɢɯ ɬɚɛɥɢɰ, ɫ ɪɚɡɥɢɱɧɵɦɢ ɫɦɟɳɟɧɢɹɦɢ ɜɧɭɬɪɢ ɨɛɴɟɤɬɚ, ɢ ɛɨɥɶɲɢɧɫɬɜɨ
ɪɟɚɥɢɡɚɰɢɣ ɞɨɛɚɜɥɹɸɬ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɜɧɭɬɪɟɧɧɢɟ ɭɤɚɡɚɬɟɥɢ ɩɪɢ ɜɢɪɬɭɚɥɶɧɨɦ ɧɚɫɥɟɞɨɜɚ-
ɧɢɢ. ɉɪɢ ɨɛɵɱɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɤɨɦɩɢɥɹɬɨɪ ɩɪɢɧɢɦɚɟɬ ɦɟɪɵ ɞɥɹ ɤɨɪɪɟɤɬɧɨɝɨ ɭɩɪɚɜɥɟɧɢɹ
ɜɫɟɦɢ ɫɤɪɵɬɵɦɢ ɩɨɥɹɦɢ; ɩɪɢɦɟɧɟɧɢɟ memcpy ɫɩɨɫɨɛɧɨ ɜɧɟɫɬɢ ɜ ɷɬɨɬ ɦɟɯɚɧɢɡɦ ɬɨɥɶɤɨ ɯɚɨɫ.
Ⱥɧɚɥɨɝɢɱɧɨ, ɮɭɧɤɰɢɹ memcmp — ɧɟɩɨɞɯɨɞɹɳɢɣ ɢɧɫɬɪɭɦɟɧɬ ɞɥɹ ɫɪɚɜɧɟɧɢɹ ɱɟɝɨ-ɬɨ ɛɨɥɟɟ
ɫɥɨɠɧɨɝɨ, ɱɟɦ ɩɪɨɫɬɨ ɧɚɛɨɪɵ ɛɢɬɨɜ. ɂɧɨɝɞɚ ɷɬɚ ɮɭɧɤɰɢɹ ɞɟɥɚɟɬ ɫɥɢɲɤɨɦ ɦɚɥɨ (ɧɚɩɪɢɦɟɪ,
ɫɪɚɜɧɟɧɢɟ ɫɬɪɨɤ ɜ ɫɬɢɥɟ C — ɧɟ ɬɨ ɠɟ, ɱɬɨ ɢ ɫɪɚɜɧɟɧɢɟ ɭɤɚɡɚɬɟɥɟɣ, ɩɪɢ ɩɨɦɨɳɢ ɤɨɬɨɪɵɯ ɷɬɢ
ɫɬɪɨɤɢ ɪɟɚɥɢɡɨɜɚɧɵ). Ⱥ ɢɧɨɝɞɚ, ɤɚɤ ɷɬɨ ɧɢ ɩɚɪɚɞɨɤɫɚɥɶɧɨ, memcmp ɞɟɥɚɟɬ ɫɥɢɲɤɨɦ ɦɧɨɝɨ
(ɧɚɩɪɢɦɟɪ, memcmp ɦɨɠɟɬ ɫɨɜɟɪɲɟɧɧɨ ɧɚɩɪɚɫɧɨ ɫɪɚɜɧɢɜɚɬɶ ɛɚɣɬɵ, ɤɨɬɨɪɵɟ ɧɟ ɹɜɥɹɸɬɫɹ ɱɚ-
ɫɬɶɸ ɫɨɫɬɨɹɧɢɹ ɨɛɴɟɤɬɚ, ɬɚɤɢɟ ɤɚɤ ɡɚɩɨɥɧɢɬɟɥɢ, ɜɫɬɚɜɥɟɧɧɵɟ ɤɨɦɩɢɥɹɬɨɪɨɦ ɞɥɹ ɜɵɪɚɜɧɢɜɚ-
ɧɢɹ). ȼ ɨɛɨɢɯ ɫɥɭɱɚɹɯ ɪɟɡɭɥɶɬɚɬ ɫɪɚɜɧɟɧɢɹ ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɜɟɪɧɵɦ.
Ссылки
[Dewhurst03] §50 • [Stroustrup94] §11.4.4
96. Не применяйте memcpy или memcmp к неPOD типам 197
Стр. 197
97. Не используйте объединения
для преобразований
Резюме
ɏɢɬɪɨɫɬɶ ɜɫɟ ɪɚɜɧɨ ɨɫɬɚɟɬɫɹ ɥɨɠɶɸ: ɨɛɴɟɞɢɧɟɧɢɹ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɩɨɥɭɱɟɧɢɹ
“ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɚ ɛɟɡ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ”, ɡɚɩɢɫɵɜɚɹ ɢɧɮɨɪɦɚɰɢɸ ɜ ɨɞɢɧ ɱɥɟɧ ɢ ɫɱɢɬɵɜɚɹ ɢɡ
ɞɪɭɝɨɝɨ. Ɉɞɧɚɤɨ ɷɬɨ ɟɳɟ ɛɨɥɟɟ ɨɩɚɫɧɨ ɢ ɦɟɧɟɟ ɩɪɟɞɫɤɚɡɭɟɦɨ, ɱɟɦ ɩɪɢɦɟɧɟɧɢɟ reinterpret_
cast (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92).
ɇɟ ɫɱɢɬɵɜɚɣɬɟ ɞɚɧɧɵɟ ɢɡ ɩɨɥɹ ɨɛɴɟɞɢɧɟɧɢɹ, ɟɫɥɢ ɩɨɫɥɟɞɧɹɹ ɡɚɩɢɫɶ ɛɵɥɚ ɧɟ ɜ ɷɬɨ ɠɟ ɩɨɥɟ.
ɑɬɟɧɢɟ ɢɡ ɩɨɥɹ, ɨɬɥɢɱɧɨɝɨ ɨɬ ɩɨɥɹ, ɜ ɤɨɬɨɪɨɟ ɩɪɨɢɡɜɨɞɢɥɚɫɶ ɡɚɩɢɫɶ, ɢɦɟɟɬ ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ
ɩɨɜɟɞɟɧɢɟ, ɢ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɷɬɨɝɨ ɦɟɬɨɞɚ ɟɳɟ ɯɭɠɟ, ɱɟɦ ɩɪɢɦɟɧɟɧɢɟ reinterpret_cast
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92); ɜ ɩɨɫɥɟɞɧɟɦ ɫɥɭɱɚɟ ɤɨɦɩɢɥɹɬɨɪ, ɤɚɤ ɦɢɧɢɦɭɦ, ɦɨɠɟɬ ɩɪɟɞɭɩɪɟɞɢɬɶ
ɩɪɨɝɪɚɦɦɢɫɬɚ ɢ ɧɟ ɞɨɩɭɫɬɢɬɶ “ɧɟɜɨɡɦɨɠɧɨɣ ɢɧɬɟɪɩɪɟɬɚɰɢɢ” ɧɚɩɨɞɨɛɢɟ ɭɤɚɡɚɬɟɥɹ ɜ char.
ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɞɥɹ ɷɬɨɣ ɰɟɥɢ ɨɛɴɟɞɢɧɟɧɢɹ ɧɢɤɚɤɚɹ ɢɧɬɟɪɩɪɟɬɚɰɢɹ ɧɟ ɩɪɢɜɟɞɟɬ ɤ ɨɲɢɛɤɟ
ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ (ɤɚɤ ɢ ɤ ɧɚɞɟɠɧɨɦɭ ɪɟɡɭɥɶɬɚɬɭ).
Ɋɚɫɫɦɨɬɪɢɦ ɮɪɚɝɦɟɧɬ ɤɨɞɚ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɨɝɨ ɞɥɹ ɫɨɯɪɚɧɟɧɢɹ ɡɧɚɱɟɧɢɹ ɨɞɧɨɝɨ ɬɢɩɚ
(char*) ɢ ɜɵɛɨɪɤɢ ɛɢɬɨɜ ɷɬɨɝɨ ɡɧɚɱɟɧɢɹ ɜ ɜɢɞɟ ɜɟɥɢɱɢɧɵ ɢɧɨɝɨ ɬɢɩɚ (long):
union {
long intValue_;
char* pointerValue_;
};
pointerValue_ = somePointer;
long int gotcha = intValue_;
Ɂɞɟɫɶ ɟɫɬɶ ɞɜɟ ɩɪɨɛɥɟɦɵ.
• Ⱦɚɧɧɵɣ ɤɨɞ ɬɪɟɛɭɟɬ ɫɥɢɲɤɨɦ ɦɧɨɝɨɝɨ. Ɉɧ ɩɨɥɚɝɚɟɬɫɹ ɧɚ ɬɨ, ɱɬɨ sizeof(long)
ɢ sizeof(char*) ɪɚɜɧɵ ɢ ɱɬɨ ɢɯ ɛɢɬɨɜɵɟ ɩɪɟɞɫɬɚɜɥɟɧɢɹ ɢɞɟɧɬɢɱɧɵ. ɗɬɢ ɭɬɜɟɪɠɞɟ-
ɧɢɹ ɫɩɪɚɜɟɞɥɢɜɵ ɧɟ ɞɥɹ ɜɫɟɯ ɜɨɡɦɨɠɧɵɯ ɪɟɚɥɢɡɚɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 91).
• Ɉɧ ɫɤɪɵɜɚɟɬ ɫɜɨɟ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ ɤɚɤ ɨɬ ɱɟɥɨɜɟɤɚ, ɬɚɤ ɢ ɨɬ ɤɨɦɩɢɥɹɬɨɪɚ. ɂɝɪɵ
ɫ ɨɛɴɟɞɢɧɟɧɢɹɦɢ ɡɚɬɪɭɞɧɹɸɬ ɞɥɹ ɤɨɦɩɢɥɹɬɨɪɚ ɩɨɢɫɤ ɨɲɢɛɨɤ, ɫɜɹɡɚɧɧɵɯ ɫ ɬɢɩɚɦɢ, ɚ ɞɥɹ
ɱɟɥɨɜɟɤɚ — ɜɵɹɜɥɟɧɢɟ ɥɨɝɢɱɟɫɤɢɯ ɨɲɢɛɨɤ.
ȿɫɥɢ ɞɜɟ POD-ɫɬɪɭɤɬɭɪɵ ɹɜɥɹɸɬɫɹ ɱɥɟɧɚɦɢ ɨɛɴɟɞɢɧɟɧɢɹ ɢ ɧɚɱɢɧɚɸɬɫɹ ɫ ɩɨɥɟɣ ɨɞɧɢɯ
ɢ ɬɟɯ ɠɟ ɬɢɩɨɜ, ɦɨɠɧɨ ɡɚɩɢɫɵɜɚɬɶ ɨɞɧɨ ɢɡ ɬɚɤɢɯ ɩɨɥɟɣ, ɚ ɡɚɬɟɦ ɫɱɢɬɵɜɚɬɶ ɞɚɧɧɵɟ ɢɡ ɞɪɭɝɨɝɨ.
Ссылки
[Alexandrescu02b] • [Stroustrup00] §C.8.2 • [Sutter04] §36
Стр. 198
98. Не используйте неизвестные аргументы
(троеточия)
Резюме
ɇɚɥɢɱɢɟ ɬɪɨɟɬɨɱɢɣ ɜ C++ — ɨɩɚɫɧɨɟ ɧɚɫɥɟɞɢɟ C. ɂɡɛɟɝɚɣɬɟ ɢɯ ɜ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦɚɯ; ɢɫ-
ɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɤɨɧɫɬɪɭɤɰɢɢ ɢ ɛɢɛɥɢɨɬɟɤɢ C++.
Ɏɭɧɤɰɢɢ ɫ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ ɞɨɫɬɚɬɨɱɧɨ ɭɞɨɛɧɵ, ɨɞɧɚɤɨ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟ ɧɟɢɡɜɟɫɬɧɵɯ ɚɪɝɭɦɟɧɬɨɜ ɜ ɫɬɢɥɟ C — ɧɟ ɥɭɱɲɢɣ ɫɩɨɫɨɛ ɩɨɥɭɱɟɧɢɹ ɬɚɤɢɯ ɮɭɧɤɰɢɣ. ɗɬɢ
ɚɪɝɭɦɟɧɬɵ ɢɦɟɸɬ ɦɧɨɝɨ ɫɟɪɶɟɡɧɵɯ ɧɟɞɨɫɬɚɬɤɨɜ.
• ɇɟɞɨɫɬɚɬɨɱɧɚɹ ɛɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ. ɉɨ ɫɭɬɢ, ɬɪɨɟɬɨɱɢɟ ɝɨɜɨɪɢɬ ɤɨɦɩɢɥɹɬɨɪɭ:
“ȼɵɤɥɸɱɢ ɜɫɟ ɩɪɨɜɟɪɤɢ. ɋ ɷɬɨɝɨ ɦɨɦɟɧɬɚ ɹ ɜɫɟ ɛɟɪɭ ɧɚ ɫɟɛɹ, ɢ ɬɟɩɟɪɶ ɧɚɱɢɧɚɟɬ ɪɚɛɨ-
ɬɚɬɶ reinterpret_cast”. (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92).
• ɋɢɥɶɧɨɟ ɫɜɹɡɵɜɚɧɢɟ ɢ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɫɨɝɥɚɫɨɜɚɧɢɹ ɜɵɡɵɜɚɟɦɨɝɨ ɢ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ
ɜɪɭɱɧɭɸ. ɉɪɨɜɟɪɤɚ ɬɢɩɨɜ ɹɡɵɤɨɦ ɨɤɚɡɵɜɚɟɬɫɹ ɨɬɤɥɸɱɟɧɚ, ɬɚɤ ɱɬɨ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ
ɞɨɥɠɟɧ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɧɵɟ ɫɩɨɫɨɛɵ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨ ɬɢɩɚɯ ɩɟɪɟɞɚɜɚɟɦɵɯ ɚɪɝɭɦɟɧɬɨɜ.
Ɍɚɤɢɟ ɩɪɨɬɨɤɨɥɵ (ɧɚɩɪɢɦɟɪ, ɮɨɪɦɚɬɧɚɹ ɫɬɪɨɤɚ printf) ɩɨɞɜɟɪɠɟɧɵ ɨɲɢɛɤɚɦ ɢ ɧɟ-
ɛɟɡɨɩɚɫɧɵ, ɩɨɫɤɨɥɶɤɭ ɧɟ ɦɨɝɭɬ ɛɵɬɶ ɩɨɥɧɨɫɬɶɸ ɩɪɨɜɟɪɟɧɵ ɧɢ ɜɵɡɵɜɚɸɳɢɦ, ɧɢ ɜɵɡɵ-
ɜɚɟɦɵɦ ɤɨɞɨɦ. (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 99.)
• ɇɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ ɞɥɹ ɨɛɴɟɤɬɨɜ ɬɢɩɨɜ, ɹɜɥɹɸɳɢɯɫɹ ɤɥɚɫɫɚɦɢ. ɉɟɪɟɞɚɱɚ ɱɟɝɨ
ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɤɪɨɦɟ POD ɢ ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ ɜɦɟɫɬɨ ɬɪɨɟɬɨɱɢɣ ɩɪɢɜɨɞɢɬ ɤ ɧɟɨɩ-
ɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ ɜ C++. Ʉ ɫɨɠɚɥɟɧɢɸ, ɛɨɥɶɲɢɧɫɬɜɨ ɤɨɦɩɢɥɹɬɨɪɨɜ ɞɚɠɟ ɧɟ
ɩɪɟɞɭɩɪɟɠɞɚɟɬ ɨɛ ɷɬɨɦ.
• ɇɟɢɡɜɟɫɬɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɚɪɝɭɦɟɧɬɨɜ. Ⱦɚɠɟ ɜ ɫɥɭɱɚɟ ɩɪɨɫɬɟɣɲɢɯ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧ-
ɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ (ɧɚɩɪɢɦɟɪ, min) ɜɚɦ ɜɫɟ ɪɚɜɧɨ ɬɪɟɛɭɟɬɫɹ ɩɪɨɬɨɤɨɥ, ɩɨ-
ɡɜɨɥɹɸɳɢɣ ɭɤɚɡɚɬɶ ɤɨɥɢɱɟɫɬɜɨ ɩɟɪɟɞɚɜɚɟɦɵɯ ɚɪɝɭɦɟɧɬɨɜ. (Ʉɚɤ ɧɢ ɫɦɟɲɧɨ, ɧɨ ɷɬɨ,
ɩɨɠɚɥɭɣ, ɯɨɪɨɲɟɟ ɫɜɨɣɫɬɜɨ, ɩɨɫɤɨɥɶɤɭ ɹɜɥɹɟɬɫɹ ɟɳɟ ɨɞɧɢɦ ɩɪɟɩɹɬɫɬɜɢɟɦ ɲɢɪɨɤɨɦɭ
ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɸ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧɧɵɦ ɱɢɫɥɨɦ ɚɪɝɭɦɟɧɬɨɜ.)
ɂɡɛɟɝɚɣɬɟ ɬɪɨɟɬɨɱɢɣ ɜ ɫɢɝɧɚɬɭɪɚɯ ɜɚɲɢɯ ɮɭɧɤɰɢɣ. ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɚ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧɧɵɦ
ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ ɫɨ ɫɜɨɢɦɢ ɫɨɛɫɬɜɟɧɧɵɦɢ ɫɢɝɧɚɬɭɪɚɦɢ, ɞɚɠɟ ɟɫɥɢ ɷɬɨ ɜɩɨɥɧɟ ɤɨɪɪɟɤɬ-
ɧɵɟ ɮɭɧɤɰɢɢ ɢɡ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ C, ɬɚɤɢɟ ɤɚɤ sprintf. ȼɵɡɨɜɵ sprintf ɱɚɫɬɨ ɜɵɝɥɹ-
ɞɹɬ ɛɨɥɟɟ ɤɨɦɩɚɤɬɧɵɦɢ ɢ ɩɪɨɫɬɵɦɢ ɞɥɹ ɩɨɧɢɦɚɧɢɹ, ɱɟɦ ɷɤɜɢɜɚɥɟɧɬɧɵɟ ɜɵɡɨɜɵ ɫ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟɦ ɮɨɪɦɚɬɢɪɨɜɚɧɢɹ stringstream ɢ ɨɩɟɪɚɬɨɪɨɜ operator<< — ɬɚɤ ɠɟ, ɤɚɤ ɥɟɝɱɟ ɫɟɫɬɶ
ɜ ɦɚɲɢɧɭ, ɧɟ ɨɛɨɪɭɞɨɜɚɧɧɭɸ ɪɟɦɧɹɦɢ ɢ ɩɨɞɭɲɤɨɣ ɛɟɡɨɩɚɫɧɨɫɬɢ, ɞɚ ɟɳɟ ɢ ɛɟɡ ɞɜɟɪɟɰ. ɍɞɨɛɫɬɜɚ
ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɬɚɤɢɯ ɮɭɧɤɰɢɣ ɧɟ ɫɬɨɹɬ ɜɨɡɧɢɤɚɸɳɟɝɨ ɩɪɢ ɷɬɨɦ ɪɢɫɤɚ. Ɏɭɧɤɰɢɢ ɜ ɫɬɢɥɟ
printf ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɫɟɪɶɟɡɧɭɸ ɩɪɨɛɥɟɦɭ ɛɟɡɨɩɚɫɧɨɫɬɢ (ɫɦ. [Cowan01]), ɬɚɤ ɱɬɨ ɢɦɟɟɬ-
ɫɹ ɰɟɥɚɹ ɨɬɪɚɫɥɶ ɪɚɡɪɚɛɨɬɤɢ ɢɧɫɬɪɭɦɟɧɬɚɪɢɹ ɞɥɹ ɩɨɢɫɤɚ ɨɲɢɛɨɤ ɬɚɤɨɝɨ ɪɨɞɚ (ɫɦ. [Tsai01]).
Ʌɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɛɟɡɨɩɚɫɧɵɟ ɜ ɫɦɵɫɥɟ ɬɢɩɨɜ ɛɢɛɥɢɨɬɟɤɢ, ɤɨɬɨɪɵɟ ɩɨɞɞɟɪɠɢɜɚɸɬ ɩɟɪɟɦɟɧ-
ɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɚɪɝɭɦɟɧɬɨɜ ɢɧɵɦɢ ɫɪɟɞɫɬɜɚɦɢ. ɇɚɩɪɢɦɟɪ, ɛɢɛɥɢɨɬɟɤɚ ɮɨɪɦɚɬɢɪɨɜɚɧɢɹ [Boost] ɢɫ-
ɩɨɥɶɡɭɟɬ ɧɨɜɟɣɲɢɟ ɫɪɟɞɫɬɜɚ C++ ɞɥɹ ɫɨɜɦɟɳɟɧɢɹ ɛɟɡɨɩɚɫɧɨɫɬɢ ɫɨ ɫɤɨɪɨɫɬɶɸ ɢ ɭɞɨɛɫɬɜɨɦ.
Ссылки
[Boost] • [Cowan01] • [Murray93] §2.6 • [Sutter04] §2-3 • [Tsai01]
98. Не используйте неизвестные аргументы (троеточия) 199
Стр. 199
99. Не используйте недействительные
объекты и небезопасные функции
Резюме
ȼɵ ɠɟ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɩɪɨɫɪɨɱɟɧɧɵɟ ɥɟɤɚɪɫɬɜɚ? ɂ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɢ “ɚɧɬɢɤɜɚɪ-
ɧɵɟ”, ɧɨ ɧɟɛɟɡɨɩɚɫɧɵɟ ɮɭɧɤɰɢɢ ɫɩɨɫɨɛɧɵ ɧɚɜɪɟɞɢɬɶ ɡɞɨɪɨɜɶɸ ɜɚɲɢɯ ɩɪɨɝɪɚɦɦ.
ɂɦɟɟɬɫɹ ɬɪɢ ɨɫɧɨɜɧɵɟ ɤɚɬɟɝɨɪɢɢ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɯ ɨɛɴɟɤɬɨɜ.
• ɍɧɢɱɬɨɠɟɧɧɵɟ ɨɛɴɟɤɬɵ. Ɍɢɩɢɱɧɵɦɢ ɩɪɢɦɟɪɚɦɢ ɬɚɤɢɯ ɨɛɴɟɤɬɨɜ ɹɜɥɹɸɬɫɹ ɚɜɬɨɦɚɬɢ-
ɱɟɫɤɢɟ ɨɛɴɟɤɬɵ, ɜɵɲɟɞɲɢɟ ɢɡ ɨɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ, ɢ ɭɞɚɥɟɧɧɵɟ ɞɢɧɚɦɢɱɟɫɤɢɟ ɨɛɴɟɤ-
ɬɵ. ɉɨɫɥɟ ɬɨɝɨ ɤɚɤ ɜɵ ɜɵɡɜɚɥɢ ɞɟɫɬɪɭɤɬɨɪ ɨɛɴɟɤɬɚ, ɟɝɨ ɜɪɟɦɹ ɠɢɡɧɢ ɢɫɬɟɤɥɨ, ɢ ɥɸɛɵɟ
ɞɟɣɫɬɜɢɹ ɫ ɧɢɦ ɧɟɛɟɡɨɩɚɫɧɵ ɢ ɩɪɢɜɨɞɹɬ ɤ ɧɟɩɪɟɞɫɤɚɡɭɟɦɵɦ ɩɨɫɥɟɞɫɬɜɢɹɦ.
• ɋɟɦɚɧɬɢɱɟɫɤɢ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ. Ɍɢɩɢɱɧɵɟ ɩɪɢɦɟɪɵ ɜɤɥɸɱɚɸɬ “ɜɢɫɹɱɢɟ”
ɭɤɚɡɚɬɟɥɢ ɧɚ ɭɞɚɥɟɧɧɵɟ ɨɛɴɟɤɬɵ (ɧɚɩɪɢɦɟɪ, ɭɤɚɡɚɬɟɥɶ p ɩɨɫɥɟ ɜɵɩɨɥɧɟɧɢɹ delete p;)
ɢ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɢɬɟɪɚɬɨɪɵ (ɧɚɩɪɢɦɟɪ, vector<T>::iterator i ɩɨɫɥɟ ɜɫɬɚɜɤɢ
ɜ ɧɚɱɚɥɨ ɤɨɧɬɟɣɧɟɪɚ, ɤ ɤɨɬɨɪɨɦɭ ɨɛɪɚɳɚɟɬɫɹ ɢɬɟɪɚɬɨɪ). Ɂɚɦɟɬɢɦ, ɱɬɨ ɜɢɫɹɱɢɟ ɭɤɚɡɚɬɟɥɢ ɢ
ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɢɬɟɪɚɬɨɪɵ ɤɨɧɰɟɩɬɭɚɥɶɧɨ ɢɞɟɧɬɢɱɧɵ, ɢ ɩɨɫɥɟɞɧɢɟ ɱɚɫɬɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧ-
ɧɨ ɫɨɞɟɪɠɚɬ ɩɟɪɜɵɟ. Ɉɛɵɱɧɨ ɧɟɛɟɡɨɩɚɫɧɨ ɢ ɧɟɩɪɟɞɫɤɚɡɭɟɦɨ ɞɟɥɚɬɶ ɱɬɨ-ɥɢɛɨ ɫ ɬɚɤɢɦɢ ɭɤɚ-
ɡɚɬɟɥɹɦɢ ɢ ɢɬɟɪɚɬɨɪɚɦɢ, ɡɚ ɢɫɤɥɸɱɟɧɢɟɦ ɩɪɢɫɜɚɢɜɚɧɢɹ ɞɪɭɝɨɝɨ ɤɨɪɪɟɤɬɧɨɝɨ ɡɧɚɱɟɧɢɹ ɧɟ-
ɞɟɣɫɬɜɢɬɟɥɶɧɨɦɭ ɨɛɴɟɤɬɭ (ɧɚɩɪɢɦɟɪ, p = new Object; ɢɥɢ i = v.begin();).
• Ɉɛɴɟɤɬɵ, ɤɨɬɨɪɵɟ ɧɢɤɨɝɞɚ ɧɟ ɛɵɥɢ ɞɟɣɫɬɜɢɬɟɥɶɧɵɦɢ. ɉɪɢɦɟɪɵ ɜɤɥɸɱɚɸɬ ɨɛɴɟɤɬɵ,
“ɩɨɥɭɱɟɧɧɵɟ” ɩɭɬɟɦ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɭɤɚɡɚɬɟɥɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ reinterpret_cast
(ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92) ɢɥɢ ɩɪɢ ɨɛɪɚɳɟɧɢɢ ɡɚ ɩɪɟɞɟɥɵ ɝɪɚɧɢɰ ɦɚɫɫɢɜɚ.
ɇɢɤɨɝɞɚ ɧɟ ɡɚɛɵɜɚɣɬɟ ɨ ɜɪɟɦɟɧɢ ɠɢɡɧɢ ɨɛɴɟɤɬɚ ɢ ɟɝɨ ɤɨɪɪɟɤɬɧɨɫɬɢ. ɇɟ ɪɚɡɵɦɟɧɨɜɵɜɚɣɬɟ
ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɢɬɟɪɚɬɨɪɵ ɢ ɭɤɚɡɚɬɟɥɢ. ɇɟ ɞɟɥɚɣɬɟ ɧɢɤɚɤɢɯ ɩɪɟɞɩɨɥɨɠɟɧɢɣ ɨ ɬɨɦ, ɱɬɨ ɞɟ-
ɥɚɟɬ ɢ ɱɟɝɨ ɧɟ ɞɟɥɚɟɬ ɨɩɟɪɚɬɨɪ delete; ɨɫɜɨɛɨɠɞɟɧɧɚɹ ɩɚɦɹɬɶ — ɷɬɨ ɨɫɜɨɛɨɠɞɟɧɧɚɹ ɩɚɦɹɬɶ,
ɢ ɨɛɪɚɳɟɧɢɣ ɤ ɧɟɣ ɧɟ ɞɨɥɠɧɨ ɛɵɬɶ ɧɢ ɩɪɢ ɤɚɤɢɯ ɭɫɥɨɜɢɹɯ. ɇɟ ɩɵɬɚɣɬɟɫɶ ɢɝɪɚɬɶɫɹ ɫɨ ɜɪɟɦɟ-
ɧɟɦ ɠɢɡɧɢ ɨɛɴɟɤɬɚ ɩɭɬɟɦ ɜɵɡɨɜɚ ɞɟɫɬɪɭɤɬɨɪɚ ɜɪɭɱɧɭɸ (ɧɚɩɪɢɦɟɪ, obj.~T()) ɫ ɩɨɫɥɟɞɭɸ-
ɳɢɦ ɜɵɡɨɜɨɦ ɪɚɡɦɟɳɚɸɳɟɝɨ new (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 55).
ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɛɟɡɨɩɚɫɧɨɟ ɧɚɫɥɟɞɫɬɜɨ C: strcpy, strncpy, sprintf ɢɥɢ ɩɪɨɱɢɟ
ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɜɵɩɨɥɧɹɸɬ ɡɚɩɢɫɶ ɜ ɛɭɮɟɪ ɛɟɡ ɩɪɨɜɟɪɤɢ ɜɵɯɨɞɚ ɡɚ ɟɝɨ ɩɪɟɞɟɥɵ. Ɏɭɧɤɰɢɹ
strcpy ɧɟ ɜɵɩɨɥɧɹɟɬ ɩɪɨɜɟɪɤɢ ɝɪɚɧɢɰ ɛɭɮɟɪɚ, ɚ ɮɭɧɤɰɢɹ [C99] strncpy ɜɵɩɨɥɧɹɟɬ ɩɪɨɜɟɪ-
ɤɭ, ɧɨ ɧɟ ɞɨɛɚɜɥɹɟɬ ɧɭɥɟɜɨɣ ɫɢɦɜɨɥ ɩɪɢ ɜɵɯɨɞɟ ɧɚ ɝɪɚɧɢɰɭ. Ɉɛɟ ɷɬɢ ɮɭɧɤɰɢɢ — ɩɨɬɟɧɰɢɚɥɶ-
ɧɵɣ ɢɫɬɨɱɧɢɤ ɧɟɩɪɢɹɬɧɨɫɬɟɣ. ɂɫɩɨɥɶɡɭɣɬɟ ɫɨɜɪɟɦɟɧɧɵɟ, ɛɨɥɟɟ ɛɟɡɨɩɚɫɧɵɟ ɢ ɝɢɛɤɢɟ ɫɬɪɭɤɬɭ-
ɪɵ ɢ ɮɭɧɤɰɢɢ, ɬɚɤɢɟ, ɤɨɬɨɪɵɟ ɢɦɟɸɬɫɹ ɜ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɟ C++ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 77). Ɉɧɢ ɧɟ ɜɫɟɝɞɚ ɫɨɜɟɪɲɟɧɧɨ ɛɟɡɨɩɚɫɧɵ (ɜ ɨɫɧɨɜɧɨɦ ɷɬɨ ɫɜɹɡɚɧɨ ɫ ɜɨɩɪɨɫɚɦɢ ɷɮɮɟɤ-
ɬɢɜɧɨɫɬɢ), ɧɨ ɫɭɳɟɫɬɜɟɧɧɨ ɦɟɧɶɲɟ ɩɨɞɜɟɪɠɟɧɵ ɨɲɢɛɤɚɦ ɢ ɩɨɡɜɨɥɹɸɬ ɫɨɡɞɚɜɚɬɶ ɝɨɪɚɡɞɨ
ɛɨɥɟɟ ɛɟɡɨɩɚɫɧɵɣ ɤɨɞ.
Ссылки
[C99] • [Sutter00] §1 • [Sutter04] §2-3
Стр. 200
100. Не рассматривайте массивы
полиморфно
Резюме
ɉɨɥɢɦɨɪɮɧɚɹ ɪɚɛɨɬɚ ɫ ɦɚɫɫɢɜɚɦɢ — ɛɨɥɶɲɚɹ ɨɲɢɛɤɚ. Ʉ ɫɨɠɚɥɟɧɢɸ, ɨɛɵɱɧɨ ɤɨɦɩɢɥɹɬɨɪ
ɧɢɤɚɤ ɧɚ ɧɟɟ ɧɟ ɪɟɚɝɢɪɭɟɬ. ɇɟ ɩɨɩɚɞɚɣɬɟɫɶ ɜ ɷɬɭ ɥɨɜɭɲɤɭ!
ɍɤɚɡɚɬɟɥɢ ɫɥɭɠɚɬ ɨɞɧɨɜɪɟɦɟɧɧɨ ɞɥɹ ɞɜɭɯ ɰɟɥɟɣ: ɜ ɤɚɱɟɫɬɜɟ ɦɚɥɨɝɨ ɪɚɡɦɟɪɚ ɢɞɟɧɬɢɮɢɤɚ-
ɬɨɪɨɜ ɨɛɴɟɤɬɨɜ ɢ ɜ ɤɚɱɟɫɬɜɟ ɢɬɟɪɚɬɨɪɨɜ ɞɥɹ ɦɚɫɫɢɜɨɜ (ɨɧɢ ɦɨɝɭɬ ɨɛɯɨɞɢɬɶ ɦɚɫɫɢɜɵ ɨɛɴɟɤɬɨɜ
ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɚɪɢɮɦɟɬɢɤɢ ɭɤɚɡɚɬɟɥɟɣ). ȼ ɤɚɱɟɫɬɜɟ ɢɞɟɧɬɢɮɢɤɚɬɨɪɨɜ ɢɦɟɟɬ ɫɦɵɫɥ ɪɚɫ-
ɫɦɚɬɪɢɜɚɬɶ ɭɤɚɡɚɬɟɥɶ ɧɚ Derived ɤɚɤ ɭɤɚɡɚɬɟɥɶ ɧɚ Base. Ɉɞɧɚɤɨ ɤɚɤ ɬɨɥɶɤɨ ɦɵ ɩɟɪɟɯɨɞɢɦ
ɤɨ ɜɬɨɪɨɣ ɰɟɥɢ, ɬɚɤɚɹ ɡɚɦɟɧɚ ɧɟ ɪɚɛɨɬɚɟɬ, ɩɨɫɤɨɥɶɤɭ ɦɚɫɫɢɜ ɨɛɴɟɤɬɨɜ Derived — ɫɨɜɫɟɦ ɧɟ
ɬɨ ɠɟ, ɱɬɨ ɢ ɦɚɫɫɢɜ ɨɛɴɟɤɬɨɜ Base. ɑɬɨɛɵ ɩɪɨɢɥɥɸɫɬɪɢɪɨɜɚɬɶ ɫɤɚɡɚɧɧɨɟ, ɡɚɦɟɬɢɦ, ɱɬɨ
ɢ ɦɵɲɶ, ɢ ɫɥɨɧ — ɨɛɚ ɦɥɟɤɨɩɢɬɚɸɳɢɟ, ɧɨ ɷɬɨ ɧɟ ɡɧɚɱɢɬ, ɱɬɨ ɤɨɥɨɧɧɚ ɢɡ ɫɬɚ ɫɥɨɧɨɜ ɛɭɞɟɬ ɩɨ
ɞɥɢɧɟ ɬɚɤɨɣ ɠɟ, ɱɬɨ ɢ ɤɨɥɨɧɧɚ ɢɡ ɫɬɚ ɦɵɲɟɣ.
Ɋɚɡɦɟɪ ɢɦɟɟɬ ɡɧɚɱɟɧɢɟ. ɉɪɢ ɡɚɦɟɧɟ ɭɤɚɡɚɬɟɥɹ ɧɚ Derived ɭɤɚɡɚɬɟɥɟɦ ɧɚ Base ɤɨɦɩɢɥɹ-
ɬɨɪ ɬɨɱɧɨ ɡɧɚɟɬ, ɤɚɤ ɫɥɟɞɭɟɬ ɩɨɞɤɨɪɪɟɤɬɢɪɨɜɚɬɶ (ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ) ɭɤɚɡɚɬɟɥɶ, ɩɨɫɤɨɥɶɤɭ
ɭ ɧɟɝɨ ɟɫɬɶ ɞɨɫɬɚɬɨɱɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɨɛɨɢɯ ɤɥɚɫɫɚɯ. Ɉɞɧɚɤɨ ɩɪɢ ɜɵɩɨɥɧɟɧɢɢ
ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ ɨɩɟɪɚɰɢɣ ɧɚɞ ɭɤɚɡɚɬɟɥɟɦ p ɧɚ Base ɤɨɦɩɢɥɹɬɨɪ ɜɵɱɢɫɥɹɟɬ p[n] ɤɚɤ
*(p+n*sizeof(Base)), ɬɚɤɢɦ ɨɛɪɚɡɨɦ ɩɨɥɚɝɚɹɫɶ ɧɚ ɬɨ, ɱɬɨ ɨɛɴɟɤɬɵ, ɧɚɯɨɞɹɳɢɟɫɹ ɜ ɩɚɦɹ-
ɬɢ, — ɷɬɨ ɨɛɴɟɤɬɵ ɬɢɩɚ Base, ɚ ɧɟ ɧɟɤɨɬɨɪɨɝɨ ɩɪɨɢɡɜɨɞɧɨɝɨ ɬɢɩɚ, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɢɦɟɬɶ ɞɪɭ-
ɝɨɣ ɪɚɡɦɟɪ. ɉɪɟɞɫɬɚɜɥɹɟɬɟ, ɤɚɤɚɹ ɟɪɭɧɞɚ ɦɨɠɟɬ ɩɨɥɭɱɢɬɶɫɹ ɩɪɢ ɪɚɛɨɬɟ ɫ ɦɚɫɫɢɜɨɦ ɨɛɴɟɤɬɨɜ
Derived, ɟɫɥɢ ɜɵ ɩɪɟɨɛɪɚɡɭɟɬɟ ɭɤɚɡɚɬɟɥɶ ɧɚ ɧɚɱɚɥɨ ɷɬɨɝɨ ɦɚɫɫɢɜɚ ɜ ɭɤɚɡɚɬɟɥɶ ɬɢɩɚ Base*
(ɱɬɨ ɤɨɦɩɢɥɹɬɨɪ ɜɩɨɥɧɟ ɞɨɩɭɫɤɚɟɬ), ɚ ɡɚɬɟɦ ɩɪɢɦɟɧɢɬɟ ɚɪɢɮɦɟɬɢɱɟɫɤɢɟ ɨɩɟɪɚɰɢɢ ɤ ɷɬɨɦɭ
ɭɤɚɡɚɬɟɥɸ (ɱɬɨ ɤɨɦɩɢɥɹɬɨɪ ɬɚɤɠɟ ɩɪɨɩɭɫɬɢɬ, ɧɟ ɦɨɪɝɧɭɜ ɝɥɚɡɨɦ)!
Ɍɚɤɢɟ ɧɟɩɪɢɹɬɧɨɫɬɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɪɟɡɭɥɶɬɚɬ ɜɡɚɢɦɨɞɟɣɫɬɜɢɹ ɞɜɭɯ ɤɨɧɰɟɩɰɢɣ —
ɡɚɦɟɧɢɦɨɫɬɢ ɭɤɚɡɚɬɟɥɟɣ ɧɚ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɭɤɚɡɚɬɟɥɹɦɢ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ, ɢ ɭɧɚɫɥɟɞɨɜɚɧ-
ɧɨɣ ɨɬ C ɚɪɢɮɦɟɬɢɤɨɣ ɭɤɚɡɚɬɟɥɟɣ, ɤɨɬɨɪɚɹ ɫɱɢɬɚɟɬ ɭɤɚɡɚɬɟɥɢ ɦɨɧɨɦɨɪɮɧɵɦɢ ɢ ɢɫɩɨɥɶɡɭɟɬ
ɩɪɢ ɜɵɱɢɫɥɟɧɢɹɯ ɬɨɥɶɤɨ ɫɬɚɬɢɱɟɫɤɭɸ ɢɧɮɨɪɦɚɰɢɸ.
Ⱦɥɹ ɯɪɚɧɟɧɢɹ ɦɚɫɫɢɜɚ ɩɨɥɢɦɨɪɮɧɵɯ ɨɛɴɟɤɬɨɜ ɜɚɦ ɧɭɠɟɧ ɦɚɫɫɢɜ (ɚ ɟɳɟ ɥɭɱɲɟ — ɤɨɧɬɟɣ-
ɧɟɪ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 77) ɭɤɚɡɚɬɟɥɟɣ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ (ɧɚɩɪɢɦɟɪ, ɨɛɵɱɧɵɯ ɭɤɚɡɚɬɟɥɟɣ ɢɥɢ,
ɱɬɨ ɟɳɟ ɥɭɱɲɟ, ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ ɭɤɚɡɚɬɟɥɟɣ shared_ptr; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 79). Ɍɨɝɞɚ ɤɚ-
ɠɞɵɣ ɭɤɚɡɚɬɟɥɶ ɦɚɫɫɢɜɚ ɭɤɚɡɵɜɚɟɬ ɧɚ ɩɨɥɢɦɨɪɮɧɵɣ ɨɛɴɟɤɬ, ɫɤɨɪɟɟ ɜɫɟɝɨ, ɨɛɴɟɤɬ ɜ ɞɢɧɚɦɢ-
ɱɟɫɤɢ ɜɵɞɟɥɟɧɧɨɣ ɩɚɦɹɬɢ. (ȿɫɥɢ ɜɵ ɯɨɬɢɬɟ ɨɛɟɫɩɟɱɢɬɶ ɢɧɬɟɪɮɟɣɫ ɤɨɧɬɟɣɧɟɪɚ ɩɨɥɢɦɨɪɮɧɵɯ
ɨɛɴɟɤɬɨɜ, ɜɚɦ ɧɚɞɨ ɢɧɤɚɩɫɭɥɢɪɨɜɚɬɶ ɜɟɫɶ ɦɚɫɫɢɜ ɢ ɩɪɟɞɨɫɬɚɜɢɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɩɨɥɢ-
ɦɨɪɮɧɵɣ ɢɧɬɟɪɮɟɣɫ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɢɬɟɪɚɰɢɣ.)
Ʉɫɬɚɬɢ, ɨɞɧɚ ɢɡ ɩɪɢɱɢɧ, ɩɨ ɤɨɬɨɪɨɣ ɜ ɢɧɬɟɪɮɟɣɫɚɯ ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɢɬɚɬɶ ɫɫɵɥɤɢ ɭɤɚɡɚɬɟ-
ɥɹɦ, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨɛɵ ɛɵɥɨ ɫɨɜɟɪɲɟɧɧɨ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɪɟɱɶ ɢɞɟɬ ɬɨɥɶɤɨ ɨɛ ɨɞɧɨɦ
ɨɛɴɟɤɬɟ, ɚ ɧɟ ɨ ɦɚɫɫɢɜɟ ɨɛɴɟɤɬɨɜ.
Ссылки
[C++TR104] • [Dewhurst03] §33, §89 • [Sutter00] §36 • [Meyers96] §3
100. Не рассматривайте массивы полиморфно 201
Стр. 201
Список литературы
ɉɪɢɦɟɱɚɧɢɟ: ɞɥɹ ɭɞɨɛɫɬɜɚ ɱɢɬɚɬɟɥɟɣ ɜɟɫɶ ɫɩɢɫɨɤ ɥɢɬɟɪɚɬɭɪɵ ɞɨɫɬɭɩɟɧ ɩɨ ɚɞɪɟɫɭ
http://www.gotw.ca/publications/c++cs/bibliography.htm
ɋɫɵɥɤɢ, ɜɵɞɟɥɟɧɧɵɟ ɩɨɥɭɠɢɪɧɵɦ ɲɪɢɮɬɨɦ (ɧɚɩɪɢɦɟɪ, [Abrahams96]), ɩɪɟɞɫɬɚɜɥɹɸɬ
ɫɨɛɨɣ ɝɢɩɟɪɫɫɵɥɤɢ ɜ ɩɪɢɜɟɞɟɧɧɨɣ ɜɵɲɟ ɫɬɪɚɧɢɰɟ.
[Abelson96] Abelson H. and Sussman G. J. Structure and Interpretation of Computer Programs

(2nd Edition) (MIT Press, 1996).
[Abrahams96] Abrahams D. Exception Safety in STLport. STLport website, 1996.
[Abrahams01a] Abrahams D. Exception Safety in Generic Components, in Jazayeri M., Loos R.,
Musser D. (eds.), Generic Programming: International Seminar on Generic Pro-
gramming, Dagstuhl Castle, Germany, April/May 1998, Selected Papers, Lecture
Notes in Computer Science 1766 (Springer, 2001).
[Abrahams01b] Abrahams D. Error and Exception Handling. [Boost] website, 2001.
[Alexandrescu00a] Alexandrescu A. Traits: The else-if-then of Types. C++ Report, 12(4), April 2000.
[Alexandrescu00b] Alexandrescu A. Traits on Steroids. C++ Report, 12(6), June 2000.
[Alexandrescu00c] Alexandrescu A. and Marginean P. Change the Way You Write Exception-Safe
Code—Forever. C/C++ Users Journal, 18(12), December 2000.
[Alexandrescu01] Alexandrescu A. Modern C++ Design. Addison-Wesley, 2001.
ɉɟɪɟɜɨɞ: Ⱥɥɟɤɫɚɧɞɪɟɫɤɭ Ⱥ. ɋɨɜɪɟɦɟɧɧɨɟ ɩɪɨɟɤɬɢɪɨɜɚɧɢɟ ɧɚ C++. ɋɟɪɢɹ C++
In-Depth, ɬ.3. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2002.
[Alexandrescu01a] Alexandrescu A. A Policy-Based basic_string Implementation. C/C++ Users
Journal, 19(6), June 2001.
[Alexandrescu02a] Alexandrescu A. Multithreading and the C++ Type System. InformIT website, Feb-
ruary 2002.
[Alexandrescu02b] Alexandrescu A. “Discriminated Unions (I),” “… (II),” and “… (III)”. C/C++ Users
Journal, 20(4,6,8), April/June/August 2002.
[Alexandrescu03a] Alexandrescu A. Move Constructors. C/C++ Users Journal, 21(2), February 2003.
[Alexandrescu03b] Alexandrescu A. Assertions. C/C++ Users Journal, 21(4), April 2003.
[Alexandrescu03c] Alexandrescu A. and Marginean P. Enforcements. C/C++ Users Journal, 21(6), June
2003.
[Alexandrescu03d] Alexandrescu A. and Held D. Smart Pointers Reloaded. C/C++ Users Journal,
21(10), October 2003.
[Alexandrescu04] Alexandrescu A. Lock-Free Data Structures. C/C++ Users Journal, 22(10), October 2004.
[Allison98] Allison C. C & C++ Code Capsules. Prentice Hall, 1998.
[Austern99] Austern M. H. Generic Programming and the STL. Addison-Wesley, 1999.
[Barton94] Barton J. and Nackman L. Scientific and Engineering C++. Addison-Wesley, 1994.
[Bentley00] Bentley J. Programming Pearls (2nd Edition). Addison-Wesley, 2000.
ɉɟɪɟɜɨɞ: Ȼɟɧɬɥɢ Ⱦɠ. ɀɟɦɱɭɠɢɧɵ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. ȼɬɨɪɨɟ ɢɡɞɚɧɢɟ. —
ɋɉɛ.: ɉɢɬɟɪ, 2002.
[BetterSCM] Web-ɭɡɟɥ Better SCM Initiative.
[Boost] C++ Boost.
[BoostLRG] Boost Library Requirements and Guidelines. (Web-ɭɡɟɥ Boost).
[Brooks95] Brooks F. The Mythical Man-Month. Addison-Wesley, 1975; reprinted with correc-
tions in 1995.
[Butenhof97] Butenhof D. Programming with POSIX Threads. Addison-Wesley, 1997.
[Cargill92] Cargill T. C++ Programming Style. Addison-Wesley, 1992.
Стр. 202
[C90] ISO/IEC 9899:1990(E), Programming Languages — C (ISO C90 and ANSI C89
Standard).
[C99] ISO/IEC 9899:1999(E), Programming Languages — C (revised ISO and ANSI C99
Standard).
[C++98] ISO/IEC 14882:1998(E), Programming Languages—C++ (ISO and ANSI C++
Standard).
[C++03] ISO/IEC 14882:2003(E), Programming Languages—C++ (updated ISO and ANSI
C++ Standard including the contents of [C++98] plus errata corrections).
[C++TR104] ISO/IEC JTC1/SC22/WG21/N1711. (Draft) Technical Report on Standard Library Exten-
sions (ISO C++ committee working document, November 2004). Ȼɥɢɡɤɢɣ ɤ ɨɤɨɧɱɚɧɢɸ
ɱɟɪɧɨɜɢɤ ɫ ɪɚɫɲɢɪɟɧɢɹɦɢ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ C++, ɜɤɥɸɱɚɹ shared_ptr.
[Cline99] Cline M., Lomow G., and Girou M. C++ FAQs (2nd Edition). Addison-Wesley, 1999.
[Constantine95] Constantine L. Constantine on Peopleware. Yourdon Press, 1995.
[Coplien92] Coplien J. Advanced C++ Programming Styles and Idioms. Addison-Wesley, 1992.
[Cormen01] Cormen T., Leiserson C., Rivest R., Stein C. Introduction to Algorithms (2nd
Edition). MIT Press, 2001.
ɉɟɪɟɜɨɞ: Ʉɨɪɦɟɧ Ɍ., Ʌɟɣɡɟɪɫɨɧ ɑ., Ɋɢɜɟɫɬ Ɋ., ɋɬɟɣɧ Ʉ. ȼɜɟɞɟɧɢɟ ɜ ɚɥɝɨɪɢɬɦɵ.
2-ɟ ɢɡɞ. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ” (ɜ ɩɟɱɚɬɢ)
[CVS] Web-ɭɡɟɥ CVS.
[Cowan01] Cowan C., Barringer M., Beattie S., and Kroah-Hartman G. FormatGuard: Automatic
Protection From printf Format String Vulnerabilities. Proceedings of the 2001
USENIX Security Symposium, August 2001, Washington, D.C.
[Dewhurst03] Dewhurst S. C++ Gotchas. Addison-Wesley, 2003.
[Dinkumware-Safe] Dinkumware Unabridged Library documentation (Web-ɭɡɟɥ Dinkumware).
[Ellis90] Ellis M. and Stroustrup B. The Annotated C++ Reference Manual. Addison-Wesley, 1990.
ɉɟɪɟɜɨɞ: ɗɥɥɢɫ Ɇ., ɋɬɪɚɭɫɬɪɭɩ Ȼ. ɋɩɪɚɜɨɱɧɨɟ ɪɭɤɨɜɨɞɫɬɜɨ ɩɨ ɹɡɵɤɭ ɩɪɨɝɪɚɦ-
ɦɢɪɨɜɚɧɢɹ ɋ++ ɫ ɤɨɦɦɟɧɬɚɪɢɹɦɢ. — Ɇ.: Ɇɢɪ, 1992.
[Gamma95] Gamma E., Helm R., Johnson R., and Vlissides J. Design Patterns: Elements of Reus-
able Object-Oriented Software. Addison-Wesley, 1995.
ɉɟɪɟɜɨɞ: Ƚɚɦɦɚ ɗ., ɏɟɥɦ Ɋ., Ⱦɠɨɧɫɨɧ Ɋ., ȼɥɢɫɫɢɞɟɫ Ⱦɠ. ɉɪɢɟɦɵ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧ-
ɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. ɉɚɬɬɟɪɧɵ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. — ɋɉɛ.: ɉɢɬɟɪ, 2001.
[GnuMake] Gnu make (Web-ɭɡɟɥ Gnu).
[GotW] Sutter H. Guru of the Week column.
[Henney00] Henney K. C++ Patterns: Executing Around Sequences (EuroPLoP 2000 proceedings).
[Henney01] Henney K. C++ Patterns: Reference Accounting (EuroPLoP 2001 proceedings).
[Henney02a] Henney K. Stringing Things Along. Application Development Advisor, July-August 2002.
[Henney02b] Henney K. The Next Best String. Application Development Advisor, October 2002.
[Henricson97] Henricson M. and Nyquist E. Industrial Strength C++. Prentice Hall,1997.
[Horstmann95] Horstmann C. S. Safe STL., 1995.
[Josuttis99] Josuttis N. The C++ Standard Library. Addison-Wesley, 1999.
ɉɟɪɟɜɨɞ: Ⱦɠɨɫɶɸɬɢɫ ɇ. C++. ɋɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ. — ɋɉɛ.: ɉɢɬɟɪ (ɜ ɩɟɱɚɬɢ).
[Keffer95] Keffer T. Rogue Wave C++ Design, Implementation, and Style Guide. Rogue Wave
Software, 1995.
[Kernighan99] Kernighan B. and Pike R. The Practice of Programming. Addison-Wesley, 1999.
[Knuth89] Knuth D. The Errors of TeX. Software—Practice & Experience, 19(7), July 1989.
[Knuth97a] Knuth D. The Art of Computer Programming, Volume 1: Fundamental Algorithms,
3rd Edition. Addison-Wesley, 1997.
ɉɟɪɟɜɨɞ: Ʉɧɭɬ Ⱦ. ɂɫɤɭɫɫɬɜɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɬɨɦ 1. Ɉɫɧɨɜɧɵɟ ɚɥɝɨɪɢɬɦɵ,
3-ɟ ɢɡɞ. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2000.
Список литературы 203
Стр. 203
[Knuth97b] Knuth D. The Art of Computer Programming, Volume 2: Seminumerical Algorithms,
3rd Edition. Addison-Wesley, 1997.
ɉɟɪɟɜɨɞ: Ʉɧɭɬ Ⱦ. ɂɫɤɭɫɫɬɜɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɬɨɦ 1. ɉɨɥɭɱɢɫɥɟɧɧɵɟ ɚɥɝɨ-
ɪɢɬɦɵ, 3-ɟ ɢɡɞ. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2000.
[Knuth98] Knuth D. The Art of Computer Programming, Volume 3: Sorting and Searching, 2nd
Edition. Addison-Wesley, 1998.
ɉɟɪɟɜɨɞ: Ʉɧɭɬ Ⱦ. ɂɫɤɭɫɫɬɜɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɬɨɦ 1. ɋɨɪɬɢɪɨɜɤɚ ɢ ɩɨɢɫɤ, 2-
ɟ ɢɡɞ. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2000.
[Koenig97] Koenig A. and Moo B. Ruminations on C++. Addison-Wesley, 1997.
[Lakos96] Lakos J. Large-Scale C++ Software Design. Addison-Wesley, 1996.
[Liskov88] Liskov B. Data Abstraction and Hierarchy. SIGPLAN Notices, 23(5), May 1988.
[Martin96a] Martin R. C. The Dependency Inversion Principle. C++ Report, 8(5), May 1996.
[Martin96b] Martin R. C. Granularity. C++ Report, 8(9), October 1996.
[Martin96c] Martin R. C. The Open-Closed Principle. C++ Report, 8(1), January 1996.
[Martin98] Martin R. C., Riehle D., Buschmann F. (eds.). Pattern Languages of Program Design
3. Addison-Wesley, 1998.
[Martin00] Martin R. C. Abstract Classes and Pure Virtual Functions in Martin R. C. (ed.), More
C++ Gems. Cambridge University Press, 2000.
[McConnell93] McConnell S. Code Complete. Microsoft Press, 1993.
[Metrowerks] Metrowerks.
[Meyer00] Meyer B. Object-Oriented Software Construction, 2nd Edition. Prentice Hall, 2000.
[Meyers96] Meyers S. More Effective C++. Addison-Wesley, 1996.
ɉɟɪɟɜɨɞ: Ɇɟɣɟɪɫ ɋ. ɇɚɢɛɨɥɟɟ ɷɮɮɟɤɬɢɜɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ C++. 35 ɧɨɜɵɯ ɪɟɤɨ-
ɦɟɧɞɚɰɢɣ ɩɨ ɭɥɭɱɲɟɧɢɸ ɜɚɲɢɯ ɩɪɨɝɪɚɦɦ ɢ ɩɪɨɟɤɬɨɜ. — M.: ȾɆɄ ɉɪɟɫɫ, 2000.
[Meyers97] Meyers S. Effective C++, 2nd Edition. Addison-Wesley, 1997.
ɉɟɪɟɜɨɞ: Ɇɟɣɟɪɫ ɋ. ɗɮɮɟɤɬɢɜɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ C++. 50 ɪɟɤɨɦɟɧɞɚɰɢɣ ɩɨ
ɭɥɭɱɲɟɧɢɸ ɜɚɲɢɯ ɩɪɨɝɪɚɦɦ ɢ ɩɪɨɟɤɬɨɜ. — M.: ȾɆɄ ɉɪɟɫɫ, 2000.
[Meyers00] Meyers S. How Non-Member Functions Improve Encapsulation. C/C++ Users Jour-
nal, 18(2), February 2000.
[Meyers01] Meyers S. Effective STL. Addison-Wesley, 2001.
ɉɟɪɟɜɨɞ: Ɇɟɣɟɪɫ ɋ. ɗɮɮɟɤɬɢɜɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ STL. — ɋɉɛ.: ɉɢɬɟɪ, 2002.
[Meyers04] Meyers S. and Alexandrescu A. C++ and the Perils of Double-Checked Locking, Part
1 and …Part 2. Dr. Dobb’s Journal, 29(7,8), July and August 2004.
[Milewski01] Milewski B. C++ In Action. Addison-Wesley, 2001.
[Miller56] Miller G. A. The Magical Number Seven, Plus or Minus Two: Some Limits on Our
Capacity for Processing Information. The Psychological Review, 1956, vol. 63.
[MozillaCRFAQ] Frequently Asked Questions About mozilla.org’s Code Review Process (Web-ɭɡɟɥ
Mozilla).
[Murray93] Murray R. C++ Strategies and Tactics. Addison-Wesley, 1993.
[Musser01] Musser D. R., Derge G. J., and Saini A. STL Tutorial and Reference Guide, 2nd Edi-
tion. Addison-Wesley, 2001.
[Parnas02] Parnas D. The Secret History of Information Hiding. Software Pioneers: Contribu-
tions To Software Engineering, Springer-Verlag, New York, 2002.
[Peters99] Peters T. The Zen of Python. Comp.lang.python, June 1999.
[Piwowarski82] Piwowarski P. A Nesting Level Complexity Measure. ACM SIGPLAN Notices, 9/1982.
[Saks99] Saks D. Thinking Deeply, Thinking Deeper, and Thinking Even Deeper. C/C++ Us-
ers Journal, 17(4,5,6), April, May, and June 1999.
[Schmidt01] Schmidt D., Stal M., Rohnert H., Buschmann F. Pattern-Oriented Software Archi-
tecture, Volume 2: Patterns for Concurrent and Networked Objects, Wiley, 2001.
204 Список литературы
Стр. 204
[SeamonkeyCR] Seamonkey Code Reviewer’s Guide (Web-ɭɡɟɥ Mozilla).
[Sedgewick98] Sedgewick R. Algorithms in C++, Parts 1-4: Fundamentals, Data Structure,
Sorting, Searching, 3rd Edition. Addison-Wesley, 1998.
[STLport-Debug] Fomitchev B. STLport: Debug Mode (Web-ɭɡɟɥ STLport).
[Stroustrup94] Stroustrup B. The Design and Evolution of C++. Addison-Wesley, 1994.
ɉɟɪɟɜɨɞ: ɋɬɪɚɭɫɬɪɭɩ Ȼ. Ⱦɢɡɚɣɧ ɢ ɷɜɨɥɸɰɢɹ ɹɡɵɤɚ C++. — M.: ȾɆɄ ɉɪɟɫɫ, 2000.
[Stroustrup00] Stroustrup B. The C++ Programming Language (Special 3rd Edition).
Addison-Wesley, 2000.
ɉɟɪɟɜɨɞ: ɋɬɪɚɭɫɬɪɭɩ Ȼ. əɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ C++. ɋɩɟɰɢɚɥɶɧɨɟ ɢɡɞɚɧɢɟ. —
M.: Ȼɢɧɨɦ, 2001.
[Sutter99] Sutter H. ACID Programming. Guru of the Week #61.
[Sutter00] Sutter H. Exceptional C++. Addison-Wesley, 2000.
ɉɟɪɟɜɨɞ: ɋɚɬɬɟɪ Ƚ. Ɋɟɲɟɧɢɟ ɫɥɨɠɧɵɯ ɡɚɞɚɱ ɧɚ C++. ɋɟɪɢɹ C++ In-Depth,
ɬ.4. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2002.
[Sutter02] Sutter H. More Exceptional C++. Addison-Wesley, 2002.
ɉɟɪɟɜɨɞ: ɋɚɬɬɟɪ Ƚ. Ɋɟɲɟɧɢɟ ɫɥɨɠɧɵɯ ɡɚɞɚɱ ɧɚ C++. ɋɟɪɢɹ C++ In-Depth,
ɬ.4. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2002.
[Sutter03] Sutter H. Generalizing Observer. C/C++ Users Journal, 21(9), September 2003.
[Sutter04] Sutter H. Exceptional C++ Style. Addison-Wesley, 2004.
ɉɟɪɟɜɨɞ: ɋɚɬɬɟɪ Ƚ. ɇɨɜɵɟ ɫɥɨɠɧɵɟ ɡɚɞɚɱɢ ɧɚ C++. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ
“ȼɢɥɶɹɦɫ” (ɜ ɩɟɱɚɬɢ).
[Sutter04a] Sutter H. Function Types. C/C++ Users Journal, 22(7), July 2004.
[Sutter04b] Sutter H. When and How To Use Exceptions. C/C++ Users Journal, 22(8), August 2004.
[Sutter04c] Sutter H. Just Enough’ Thread Safety. C/C++ Users Journal, 22(9), September 2004.
[Sutter04d] Sutter H. How to Provide (or Avoid) Points of Customiza-tion in Templates. C/C++
Users Journal, 22(11), November 2004.
[SuttHysl01] Sutter H. and Hyslop J. Hungarian wartHogs. C/C++ Users Journal, 19(11), No-
vember 2001.
[SuttHysl02] Sutter H. and Hyslop J. A Midsummer Night’s Madness. C/C++ Users Journal,
20(8), August 2002.
[SuttHysl03] Sutter H. and Hyslop J. Sharing Causes Contention. C/C++ Users Journal, 21(4),
April 2003.
[SuttHysl04a] Sutter H. and Hyslop J. Getting Abstractions. C/C++ Users Journal, 22(6), June 2004.
[SuttHysl04b] Sutter H. and Hyslop J. Collecting Shared Objects. C/C++ Users Journal, 22(8),
August 2004.
[Taligent94] Taligent’s Guide to Designing Programs. Addison-Wesley, 1994.
[Tsai01] Tsai T. and Singh N. Libsafe 2.0: Detection of Format String Vulnerability Exploits.
Avaya Labs, March 2001.
[Vandevoorde03] Vandevoorde D. and Josuttis N. C++ Templates. Addison-Wesley, 2003.
ɉɟɪɟɜɨɞ: ȼɚɧɞɟɜɭɪɞ Ⱦ., Ⱦɠɨɫɚɬɬɢɫ ɇ. ɒɚɛɥɨɧɵ C++. ɋɩɪɚɜɨɱɧɢɤ ɪɚɡɪɚɛɨɬɱɢ-
ɤɚ. — Ɇ.: ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”, 2003.
[Webber03] Webber A. B. Modern Programming Languages: A Practical Introduction. Franklin,
Beedle & Associates, 2003.
Список литературы 205
Стр. 205
Резюме из резюме
Вопросы организации и стратегии

0. ɇɟ ɦɟɥɨɱɢɬɟɫɶ, ɢɥɢ ɑɬɨ ɧɟ ɫɥɟɞɭɟɬ ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɬɶ
ɋɤɚɠɟɦ ɤɪɚɬɤɨ: ɧɟ ɦɟɥɨɱɢɬɟɫɶ.
1. Ʉɨɦɩɢɥɢɪɭɣɬɟ ɛɟɡ ɡɚɦɟɱɚɧɢɣ ɩɪɢ ɦɚɤɫɢɦɚɥɶɧɨɦ ɭɪɨɜɧɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ
ɋɥɟɞɭɟɬ ɫɟɪɶɟɡɧɨ ɨɬɧɨɫɢɬɶɫɹ ɤ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ ɤɨɦɩɢɥɹɬɨɪɚ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɚɤɫɢ-
ɦɚɥɶɧɵɣ ɭɪɨɜɟɧɶ ɜɵɜɨɞɚ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ ɜɚɲɢɦ ɤɨɦɩɢɥɹɬɨɪɨɦ. Ʉɨɦɩɢɥɹɰɢɹ ɞɨɥɠɧɚ ɜɵ-
ɩɨɥɧɹɬɶɫɹ ɛɟɡ ɤɚɤɢɯ-ɥɢɛɨ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ. ȼɵ ɞɨɥɠɧɵ ɩɨɧɢɦɚɬɶ ɜɫɟ ɜɵɞɚɜɚɟɦɵɟ ɩɪɟɞɭ-
ɩɪɟɠɞɟɧɢɹ ɢ ɭɫɬɪɚɧɹɬɶ ɢɯ ɩɭɬɟɦ ɢɡɦɟɧɟɧɢɹ ɤɨɞɚ, ɚ ɧɟ ɫɧɢɠɟɧɢɹ ɭɪɨɜɧɹ ɜɵɜɨɞɚ ɩɪɟɞɭɩɪɟɠ-
ɞɟɧɢɣ.
2. ɂɫɩɨɥɶɡɭɣɬɟ ɚɜɬɨɦɚɬɢɱɟɫɤɢɟ ɫɢɫɬɟɦɵ ɫɛɨɪɤɢ ɩɪɨɝɪɚɦɦ
ɇɚɠɢɦɚɣɬɟ ɧɚ ɨɞɧɭ (ɟɞɢɧɫɬɜɟɧɧɭɸ) ɤɧɨɩɤɭ: ɢɫɩɨɥɶɡɭɣɬɟ ɩɨɥɧɨɫɬɶɸ ɚɜɬɨɦɚɬɢɡɢɪɨɜɚɧɧɵɟ
(“ɜ ɨɞɧɨ ɞɟɣɫɬɜɢɟ”) ɫɢɫɬɟɦɵ, ɤɨɬɨɪɵɟ ɫɨɛɢɪɚɸɬ ɜɟɫɶ ɩɪɨɟɤɬ ɛɟɡ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɩɨɥɶɡɨɜɚɬɟɥɹ.
3. ɂɫɩɨɥɶɡɭɣɬɟ ɫɢɫɬɟɦɭ ɤɨɧɬɪɨɥɹ ɜɟɪɫɢɣ
Ʉɚɤ ɝɥɚɫɢɬ ɤɢɬɚɣɫɤɚɹ ɩɨɫɥɨɜɢɰɚ, ɩɥɨɯɢɟ ɱɟɪɧɢɥɚ ɥɭɱɲɟ ɯɨɪɨɲɟɣ ɩɚɦɹɬɢ: ɢɫɩɨɥɶɡɭɣɬɟ ɫɢɫ-
ɬɟɦɵ ɭɩɪɚɜɥɟɧɢɹ ɜɟɪɫɢɹɦɢ. ɇɟ ɨɫɬɚɜɥɹɣɬɟ ɮɚɣɥɵ ɛɟɡ ɩɪɢɫɦɨɬɪɚ ɧɚ ɞɨɥɝɢɣ ɫɪɨɤ. ɉɪɨɜɟɪɹɣɬɟ
ɢɯ ɜɫɹɤɢɣ ɪɚɡ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɨɛɧɨɜɥɟɧɧɵɟ ɦɨɞɭɥɢ ɩɪɨɯɨɞɹɬ ɬɟɫɬɵ ɧɚ ɪɚɛɨɬɨɫɩɨɫɨɛɧɨɫɬɶ.
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɧɟɫɟɧɧɵɟ ɨɛɧɨɜɥɟɧɢɹ ɧɟ ɩɪɟɩɹɬɫɬɜɭɸɬ ɤɨɪɪɟɤɬɧɨɣ ɫɛɨɪɤɟ ɩɪɨɝɪɚɦɦɵ.
4. Ɉɞɧɚ ɝɨɥɨɜɚ ɯɨɪɨɲɨ, ɚ ɞɜɟ — ɥɭɱɲɟ
Ɋɟɝɭɥɹɪɧɨ ɩɪɨɫɦɚɬɪɢɜɚɣɬɟ ɤɨɞ ɜɫɟɣ ɤɨɦɚɧɞɨɣ. ɑɟɦ ɛɨɥɶɲɟ ɝɥɚɡ — ɬɟɦ ɜɵɲɟ ɤɚɱɟɫɬɜɨ
ɤɨɞɚ. ɉɨɤɚɠɢɬɟ ɜɚɲ ɤɨɞ ɞɪɭɝɢɦ ɢ ɩɨɡɧɚɤɨɦɶɬɟɫɶ ɫ ɢɯ ɤɨɞɨɦ — ɷɬɨ ɩɪɢɧɟɫɟɬ ɩɨɥɶɡɭ ɜɫɟɦ.
Стиль проектирования
5. Ɉɞɢɧ ɨɛɴɟɤɬ — ɨɞɧɚ ɡɚɞɚɱɚ
Ʉɨɧɰɟɧɬɪɢɪɭɣɬɟɫɶ ɨɞɧɨɜɪɟɦɟɧɧɨ ɬɨɥɶɤɨ ɧɚ ɨɞɧɨɣ ɩɪɨɛɥɟɦɟ. Ʉɚɠɞɵɣ ɨɛɴɟɤɬ (ɩɟɪɟɦɟɧ-
ɧɚɹ, ɤɥɚɫɫ, ɮɭɧɤɰɢɹ, ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, ɦɨɞɭɥɶ, ɛɢɛɥɢɨɬɟɤɚ) ɞɨɥɠɧɵ ɪɟɲɚɬɶ ɨɞɧɭ ɬɨɱɧɨ
ɩɨɫɬɚɜɥɟɧɧɭɸ ɡɚɞɚɱɭ. ɋ ɪɨɫɬɨɦ ɨɛɴɟɤɬɨɜ, ɟɫɬɟɫɬɜɟɧɧɨ, ɭɜɟɥɢɱɢɜɚɟɬɫɹ ɨɛɥɚɫɬɶ ɢɯ ɨɬɜɟɬ-
ɫɬɜɟɧɧɨɫɬɢ, ɧɨ ɨɧɢ ɧɟ ɞɨɥɠɧɵ ɨɬɤɥɨɧɹɬɶɫɹ ɨɬ ɫɜɨɟɝɨ ɩɪɟɞɧɚɡɧɚɱɟɧɢɹ.
6. Ƚɥɚɜɧɨɟ — ɤɨɪɪɟɤɬɧɨɫɬɶ, ɩɪɨɫɬɨɬɚ ɢ ɹɫɧɨɫɬɶ
Ʉɨɪɪɟɤɬɧɨɫɬɶ ɥɭɱɲɟ ɛɵɫɬɪɨɬɵ. ɉɪɨɫɬɨɬɚ ɥɭɱɲɟ ɫɥɨɠɧɨɫɬɢ. əɫɧɨɫɬɶ ɥɭɱɲɟ ɯɢɬɪɨ-
ɭɦɢɹ. Ȼɟɡɨɩɚɫɧɨɫɬɶ ɥɭɱɲɟ ɧɟɧɚɞɟɠɧɨɫɬɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 83 ɢ 99).
7. Ʉɨɞɢɪɨɜɚɧɢɟ ɫ ɭɱɟɬɨɦ ɦɚɫɲɬɚɛɢɪɭɟɦɨɫɬɢ
ȼɫɟɝɞɚ ɩɨɦɧɢɬɟ ɨ ɜɨɡɦɨɠɧɨɦ ɪɨɫɬɟ ɞɚɧɧɵɯ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɚɫɢɦɩɬɨɬɢɱɟɫɤɨɣ ɫɥɨɠɧɨɫɬɢ ɛɟɡ
ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɨɩɬɢɦɢɡɚɰɢɢ. Ⱥɥɝɨɪɢɬɦɵ, ɤɨɬɨɪɵɟ ɪɚɛɨɬɚɸɬ ɫ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɦɢ ɞɚɧɧɵɦɢ,
ɞɨɥɠɧɵ ɢɦɟɬɶ ɩɪɟɞɫɤɚɡɭɟɦɨɟ ɢ, ɠɟɥɚɬɟɥɶɧɨ, ɧɟ ɯɭɠɟ ɱɟɦ ɥɢɧɟɣɧɨ ɡɚɜɢɫɹɳɟɟ ɨɬ ɤɨɥɢɱɟɫɬɜɚ ɨɛ-
ɪɚɛɚɬɵɜɚɟɦɵɯ ɞɚɧɧɵɯ ɜɪɟɦɹ ɪɚɛɨɬɵ. Ʉɨɝɞɚ ɫɬɚɧɨɜɢɬɫɹ ɜɚɠɧɨɣ ɢ ɧɟɨɛɯɨɞɢɦɨɣ ɨɩɬɢɦɢɡɚɰɢɹ,
ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɢɡ-ɡɚ ɪɨɫɬɚ ɨɛɴɟɦɨɜ ɞɚɧɧɵɯ, ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɫɥɟɞɭɟɬ ɭɥɭɱɲɚɬɶ O-ɫɥɨɠɧɨɫɬɶ ɚɥ-
ɝɨɪɢɬɦɚ, ɚ ɧɟ ɡɚɧɢɦɚɬɶɫɹ ɦɢɤɪɨɨɩɬɢɦɢɡɚɰɢɹɦɢ ɬɢɩɚ ɷɤɨɧɨɦɢɢ ɧɚ ɨɞɧɨɦ ɫɥɨɠɟɧɢɢ.
206 Резюме из резюме
Стр. 206
8. ɇɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ
Ʉɚɤ ɝɥɚɫɢɬ ɩɨɫɥɨɜɢɰɚ, ɧɟ ɩɨɞɝɨɧɹɣɬɟ ɫɤɚɱɭɳɭɸ ɥɨɲɚɞɶ. ɉɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ
ɧɟɩɪɨɞɭɤɬɢɜɧɚ ɢ ɛɵɫɬɪɨ ɜɯɨɞɢɬ ɜ ɩɪɢɜɵɱɤɭ. ɉɟɪɜɨɟ ɩɪɚɜɢɥɨ ɨɩɬɢɦɢɡɚɰɢɢ: ɧɟ ɨɩɬɢɦɢɡɢ-
ɪɭɣɬɟ. ȼɬɨɪɨɟ ɩɪɚɜɢɥɨ ɨɩɬɢɦɢɡɚɰɢɢ (ɬɨɥɶɤɨ ɞɥɹ ɷɤɫɩɟɪɬɨɜ): ɧɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɧɢ ɜ ɤɨɟɦ
ɫɥɭɱɚɟ. ɋɟɦɶ ɪɚɡ ɨɬɦɟɪɶ, ɨɞɢɧ ɪɚɡ ɨɩɬɢɦɢɡɢɪɭɣ.
9. ɇɟ ɩɟɫɫɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ
Ɍɨ, ɱɬɨ ɩɪɨɫɬɨ ɞɥɹ ɜɚɫ, — ɩɪɨɫɬɨ ɢ ɞɥɹ ɤɨɞɚ. ɉɪɢ ɩɪɨɱɢɯ ɪɚɜɧɵɯ ɭɫɥɨɜɢɹɯ, ɜ ɨɫɨɛɟɧɧɨ-
ɫɬɢ — ɫɥɨɠɧɨɫɬɢ ɢ ɭɞɨɛɨɱɢɬɚɟɦɨɫɬɢ ɤɨɞɚ, ɪɹɞ ɷɮɮɟɤɬɢɜɧɵɯ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
ɢ ɢɞɢɨɦ ɤɨɞɢɪɨɜɚɧɢɹ ɞɨɥɠɧɵ ɟɫɬɟɫɬɜɟɧɧɵɦ ɨɛɪɚɡɨɦ “ɫɬɟɤɚɬɶ ɫ ɤɨɧɱɢɤɨɜ ɜɚɲɢɯ ɩɚɥɶɰɟɜ”
ɢ ɛɵɬɶ ɧɟ ɫɥɨɠɧɟɟ ɜ ɧɚɩɢɫɚɧɢɢ, ɱɟɦ ɢɯ ɩɟɫɫɢɦɢɡɢɪɨɜɚɧɧɵɟ ɚɥɶɬɟɪɧɚɬɢɜɵ. ɗɬɨ ɧɟ ɩɪɟɠɞɟ-
ɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ, ɚ ɢɡɛɟɠɚɧɢɟ ɢɡɥɢɲɧɟɣ ɩɟɫɫɢɦɢɡɚɰɢɢ.
10. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɝɥɨɛɚɥɶɧɵɟ ɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ
ɋɨɜɦɟɫɬɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɜɵɡɵɜɚɟɬ ɫɩɨɪɵ ɢ ɪɚɡɞɨɪɵ. ɂɡɛɟɝɚɣɬɟ ɫɨɜɦɟɫɬɧɨɝɨ ɢɫɩɨɥɶɡɨ-
ɜɚɧɢɹ ɞɚɧɧɵɯ, ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɝɥɨɛɚɥɶɧɵɯ ɞɚɧɧɵɯ. ɋɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ ɭɫɢɥɢɜɚɸɬ
ɫɜɹɡɧɨɫɬɶ, ɱɬɨ ɩɪɢɜɨɞɢɬ ɤ ɫɧɢɠɟɧɢɸ ɫɨɩɪɨɜɨɠɞɚɟɦɨɫɬɢ, ɚ ɡɚɱɚɫɬɭɸ ɢ ɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɫɬɢ.
11. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ
ɇɟ ɜɵɩɭɫɤɚɣɬɟ ɜɧɭɬɪɟɧɧɸɸ ɢɧɮɨɪɦɚɰɢɸ ɡɚ ɩɪɟɞɟɥɵ ɨɛɴɟɤɬɚ, ɨɛɟɫɩɟɱɢɜɚɸɳɟɝɨ ɚɛɫɬɪɚɤɰɢɸ.
12. Ʉɨɞɢɪɨɜɚɧɢɟ ɩɚɪɚɥɥɟɥɶɧɵɯ ɜɵɱɢɫɥɟɧɢɣ
ȿɫɥɢ ɜɚɲɟ ɩɪɢɥɨɠɟɧɢɟ ɢɫɩɨɥɶɡɭɟɬ ɧɟɫɤɨɥɶɤɨ ɩɨɬɨɤɨɜ ɢɥɢ ɩɪɨɰɟɫɫɨɜ, ɫɥɟɞɭɟɬ ɦɢɧɢɦɢɡɢ-
ɪɨɜɚɬɶ ɤɨɥɢɱɟɫɬɜɨ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɨɛɴɟɤɬɨɜ, ɝɞɟ ɷɬɨ ɬɨɥɶɤɨ ɦɨɠɧɨ (ɫɦ. ɪɟɤɨɦɟɧ-
ɞɚɰɢɸ 10), ɢ ɚɤɤɭɪɚɬɧɨ ɪɚɛɨɬɚɬɶ ɫ ɨɫɬɚɜɲɢɦɢɫɹ.
13. Ɋɟɫɭɪɫɵ ɞɨɥɠɧɵ ɛɵɬɶ ɜɨ ɜɥɚɞɟɧɢɢ ɨɛɴɟɤɬɨɜ
ɇɟ ɪɚɛɨɬɚɣɬɟ ɜɪɭɱɧɭɸ, ɟɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɦɨɳɧɵɟ ɢɧɫɬɪɭɦɟɧɬɵ. ɂɞɢɨɦɚ C++ “ɜɵɞɟɥɟɧɢɟ
ɪɟɫɭɪɫɚ ɟɫɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ” (resource acquisition is initialization — RAII) ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨ-
ɛɨɣ ɦɨɳɧɵɣ ɢɧɫɬɪɭɦɟɧɬ ɞɥɹ ɤɨɪɪɟɤɬɧɨɣ ɪɚɛɨɬɵ ɫ ɪɟɫɭɪɫɚɦɢ. RAII ɩɨɡɜɨɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ
ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɨɛɟɫɩɟɱɢɬɶ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɬɨɝɨ, ɱɬɨ ɜ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɧɚɞɨ ɞɟɥɚɬɶ
ɜɪɭɱɧɭɸ. ɉɪɢ ɜɵɞɟɥɟɧɢɢ ɪɟɫɭɪɫɚ ɩɟɪɟɞɚɣɬɟ ɟɝɨ ɨɛɴɟɤɬɭ-ɜɥɚɞɟɥɶɰɭ. ɇɢɤɨɝɞɚ ɧɟ ɜɵɞɟɥɹɣɬɟ
ɧɟɫɤɨɥɶɤɨ ɪɟɫɭɪɫɨɜ ɜ ɨɞɧɨɣ ɢɧɫɬɪɭɤɰɢɢ.
Стиль кодирования
14. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɲɢɛɤɢ ɤɨɦɩɢɥɹɰɢɢ ɢ ɤɨɦɩɨɧɨɜɤɢ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ
ɜɵɩɨɥɧɟɧɢɹ
ɇɟ ɫɬɨɢɬ ɨɬɤɥɚɞɵɜɚɬɶ ɞɨ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨɝɪɚɦɦɵ ɜɵɹɜɥɟɧɢɟ ɨɲɢɛɨɤ, ɤɨɬɨɪɵɟ ɦɨɠɧɨ
ɨɛɧɚɪɭɠɢɬɶ ɩɪɢ ɟɟ ɫɛɨɪɤɟ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɢɫɚɬɶ ɤɨɞ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɭɟɬ ɤɨɦɩɢɥɹɬɨɪ
ɞɥɹ ɩɪɨɜɟɪɤɢ ɢɧɜɚɪɢɚɧɬɨɜ ɜ ɩɪɨɰɟɫɫɟ ɤɨɦɩɢɥɹɰɢɢ, ɜɦɟɫɬɨ ɬɨɝɨ, ɱɬɨɛɵ ɩɪɨɜɟɪɹɬɶ ɢɯ ɜɨ ɜɪɟ-
ɦɹ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ. ɉɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɡɚɜɢɫɹɬ ɨɬ ɜɵɩɨɥɧɢɦɨɝɨ ɤɨɞɚ ɢ ɞɚɧ-
ɧɵɯ, ɬɚɤ ɱɬɨ ɜɵ ɬɨɥɶɤɨ ɢɡɪɟɞɤɚ ɦɨɠɟɬɟ ɩɨɥɧɨɫɬɶɸ ɩɨɥɚɝɚɬɶɫɹ ɧɚ ɧɢɯ. ɉɪɨɜɟɪɤɢ ɜɪɟɦɟɧɢ
ɤɨɦɩɢɥɹɰɢɢ, ɧɚɩɪɨɬɢɜ, ɧɟ ɡɚɜɢɫɹɬ ɨɬ ɞɚɧɧɵɯ ɢ ɩɪɟɞɵɫɬɨɪɢɢ ɢɫɩɨɥɧɟɧɢɹ, ɱɬɨ ɨɛɵɱɧɨ ɨɛɟɫ-
ɩɟɱɢɜɚɟɬ ɛɨɥɟɟ ɜɵɫɨɤɭɸ ɫɬɟɩɟɧɶ ɧɚɞɟɠɧɨɫɬɢ.
15. Ⱥɤɬɢɜɧɨ ɢɫɩɨɥɶɡɭɣɬɟ const
const — ɜɚɲ ɞɪɭɝ: ɧɟɢɡɦɟɧɹɟɦɵɟ ɡɧɚɱɟɧɢɹ ɩɪɨɳɟ ɩɨɧɢɦɚɬɶ, ɨɬɫɥɟɠɢɜɚɬɶ ɢ ɦɨɬɢɜɢɪɨɜɚɬɶ,
ɬ.ɟ. ɬɚɦ, ɝɞɟ ɷɬɨ ɰɟɥɟɫɨɨɛɪɚɡɧɨ, ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɧɫɬɚɧɬɵ ɜɦɟɫɬɨ ɩɟɪɟɦɟɧɧɵɯ.
ɋɞɟɥɚɣɬɟ const ɨɩɢɫɚɧɢɟɦ ɩɨ ɭɦɨɥɱɚɧɢɸ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɡɧɚɱɟɧɢɹ — ɷɬɨ ɛɟɡɨɩɚɫɧɨ,
ɩɪɨɜɟɪɹɟɦɨ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 14) ɢ ɢɧɬɟɝɪɢɪɭɟɦɨ ɫ ɫɢɫɬɟɦɨɣ ɬɢɩɨɜ
Резюме из резюме 207
Стр. 207
C++. ɇɟ ɜɵɩɨɥɧɹɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ ɬɢɩɨɜ ɫ ɨɬɛɪɚɫɵɜɚɧɢɟɦ const ɤɪɨɦɟ ɤɚɤ ɩɪɢ ɜɵɡɨɜɟ
ɧɟɤɨɪɪɟɤɬɧɨɣ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɭɩɨɬɪɟɛɥɟɧɢɹ const ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 94).
16. ɂɡɛɟɝɚɣɬɟ ɦɚɤɪɨɫɨɜ
Ɇɚɤɪɨɫ — ɫɚɦɵɣ ɧɟɩɪɢɹɬɧɵɣ ɢɧɫɬɪɭɦɟɧɬ C ɢ C++, ɨɛɨɪɨɬɟɧɶ, ɫɤɪɵɜɚɸɳɢɣɫɹ ɩɨɞ ɥɢ-
ɱɢɧɨɣ ɮɭɧɤɰɢɢ, ɤɨɬ, ɝɭɥɹɸɳɢɣ ɫɚɦ ɩɨ ɫɟɛɟ ɢ ɧɟ ɨɛɪɚɳɚɸɳɢɣ ɧɢɤɚɤɨɝɨ ɜɧɢɦɚɧɢɹ ɧɚ ɝɪɚɧɢɰɵ
ɜɚɲɢɯ ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ. Ȼɟɪɟɝɢɬɟɫɶ ɟɝɨ!
17. ɂɡɛɟɝɚɣɬɟ ɦɚɝɢɱɟɫɤɢɯ ɱɢɫɟɥ
ɂɡɛɟɝɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɤɨɞɟ ɥɢɬɟɪɚɥɶɧɵɯ ɤɨɧɫɬɚɧɬ ɧɚɩɨɞɨɛɢɟ 42 ɢɥɢ 3.1415926. Ɍɚ-
ɤɢɟ ɤɨɧɫɬɚɧɬɵ ɧɟ ɫɚɦɨɨɱɟɜɢɞɧɵ ɢ ɭɫɥɨɠɧɹɸɬ ɫɨɩɪɨɜɨɠɞɟɧɢɟ ɤɨɞɚ, ɩɨɫɤɨɥɶɤɭ ɜɧɨɫɹɬ ɜ ɧɟ-
ɝɨ ɬɪɭɞɧɨɨɩɪɟɞɟɥɢɦɵɣ ɜɢɞ ɞɭɛɥɢɪɨɜɚɧɢɹ. ɂɫɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɧɢɯ ɫɢɦɜɨɥɶɧɵɟ ɢɦɟɧɚ ɢ ɜɵ-
ɪɚɠɟɧɢɹ ɧɚɩɨɞɨɛɢɟ width*aspectRatio.
18. Ɉɛɴɹɜɥɹɣɬɟ ɩɟɪɟɦɟɧɧɵɟ ɤɚɤ ɦɨɠɧɨ ɥɨɤɚɥɶɧɟɟ
ɂɡɛɟɝɚɣɬɟ “ɪɚɡɞɭɜɚɧɢɹ” ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ. ɉɟɪɟɦɟɧɧɵɯ ɞɨɥɠɧɨ ɛɵɬɶ ɤɚɤ ɦɨɠɧɨ
ɦɟɧɶɲɟ, ɚ ɜɪɟɦɹ ɢɯ ɠɢɡɧɢ — ɤɚɤ ɦɨɠɧɨ ɤɨɪɨɱɟ. ɗɬɚ ɪɟɤɨɦɟɧɞɚɰɢɹ ɩɨ ɫɭɬɢ ɹɜɥɹɟɬɫɹ ɱɚɫɬ-
ɧɵɦ ɫɥɭɱɚɟɦ ɪɟɤɨɦɟɧɞɚɰɢɢ 10.
19. ȼɫɟɝɞɚ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ
ɇɟɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɩɟɪɟɦɟɧɧɵɟ — ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɣ ɢɫɬɨɱɧɢɤ ɨɲɢɛɨɤ ɜ ɩɪɨɝɪɚɦ-
ɦɚɯ ɧɚ C ɢ C++. ɂɡɛɟɝɚɣɬɟ ɢɯ, ɜɵɪɚɛɨɬɚɜ ɩɪɢɜɵɱɤɭ ɨɱɢɳɚɬɶ ɩɚɦɹɬɶ ɩɟɪɟɞ ɟɟ ɢɫɩɨɥɶɡɨɜɚ-
ɧɢɟɦ; ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ ɩɪɢ ɢɯ ɨɩɪɟɞɟɥɟɧɢɢ.
20. ɂɡɛɟɝɚɣɬɟ ɞɥɢɧɧɵɯ ɮɭɧɤɰɢɣ ɢ ɝɥɭɛɨɤɨɣ ɜɥɨɠɟɧɧɨɫɬɢ
Ʉɪɚɬɤɨɫɬɶ — ɫɟɫɬɪɚ ɬɚɥɚɧɬɚ. ɑɟɪɟɫɱɭɪ ɞɥɢɧɧɵɟ ɮɭɧɤɰɢɢ ɢ ɱɪɟɡɦɟɪɧɨ ɜɥɨɠɟɧɧɵɟ ɛɥɨ-
ɤɢ ɤɨɞɚ ɡɚɱɚɫɬɭɸ ɩɪɟɩɹɬɫɬɜɭɸɬ ɪɟɚɥɢɡɚɰɢɢ ɩɪɢɧɰɢɩɚ “ɨɞɧɚ ɮɭɧɤɰɢɹ — ɨɞɧɚ ɡɚɞɚɱɚ” (ɫɦ.
ɪɟɤɨɦɟɧɞɚɰɢɸ 5), ɢ ɨɛɵɱɧɨ ɷɬɚ ɩɪɨɛɥɟɦɚ ɪɟɲɚɟɬɫɹ ɥɭɱɲɢɦ ɪɚɡɞɟɥɟɧɢɟɦ ɡɚɞɚɱɢ ɧɚ ɨɬɞɟɥɶ-
ɧɵɟ ɱɚɫɬɢ.
21. ɂɡɛɟɝɚɣɬɟ ɡɚɜɢɫɢɦɨɫɬɟɣ ɢɧɢɰɢɚɥɢɡɚɰɢɣ ɦɟɠɞɭ ɟɞɢɧɢɰɚɦɢ ɤɨɦɩɢɥɹɰɢɢ
Ɉɛɴɟɤɬɵ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɜ ɪɚɡɧɵɯ ɟɞɢɧɢɰɚɯ ɤɨɦɩɢɥɹɰɢɢ ɧɟ ɞɨɥɠɧɵ ɡɚɜɢɫɟɬɶ
ɞɪɭɝ ɨɬ ɞɪɭɝɚ ɩɪɢ ɢɧɢɰɢɚɥɢɡɚɰɢɢ, ɩɨɫɤɨɥɶɤɭ ɩɨɪɹɞɨɤ ɢɯ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ. ȼ ɩɪɨ-
ɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɚɦ ɨɛɟɫɩɟɱɟɧɚ ɝɨɥɨɜɧɚɹ ɛɨɥɶ ɩɪɢ ɩɨɩɵɬɤɚɯ ɪɚɡɨɛɪɚɬɶɫɹ ɫɨ ɫɛɨɹɦɢ ɜ ɪɚɛɨɬɟ
ɩɪɨɝɪɚɦɦɵ ɩɨɫɥɟ ɜɧɟɫɟɧɢɹ ɧɟɛɨɥɶɲɢɯ ɢɡɦɟɧɟɧɢɣ ɜ ɜɚɲ ɩɪɨɟɤɬ ɢ ɧɟɜɨɡɦɨɠɧɨɫɬɶɸ ɟɝɨ ɩɟɪɟ-
ɧɨɫɚ ɞɚɠɟ ɧɚ ɧɨɜɭɸ ɜɟɪɫɢɸ ɬɨɝɨ ɠɟ ɫɚɦɨɝɨ ɤɨɦɩɢɥɹɬɨɪɚ.
22. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɡɚɜɢɫɢɦɨɫɬɢ ɨɩɪɟɞɟɥɟɧɢɣ ɢ ɢɡɛɟɝɚɣɬɟ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ
ɂɡɛɟɝɚɣɬɟ ɢɡɥɢɲɧɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ. ɇɟ ɜɤɥɸɱɚɣɬɟ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include ɨɩɪɟ-
ɞɟɥɟɧɢɹ ɬɚɦ, ɝɞɟ ɞɨɫɬɚɬɨɱɧɨ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɝɨ ɨɛɴɹɜɥɟɧɢɹ.
ɂɡɛɟɝɚɣɬɟ ɜɡɚɢɦɨɡɚɜɢɫɢɦɨɫɬɟɣ. ɐɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨɫɬɢ ɜɨɡɧɢɤɚɸɬ, ɤɨɝɞɚ ɞɜɚ ɦɨɞɭɥɹ
ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɢɥɢ ɨɩɨɫɪɟɞɨɜɚɧɧɨ ɡɚɜɢɫɹɬ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. Ɇɨɞɭɥɶ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɨɛɨɫɨɛɥɟɧɧɭɸ ɟɞɢɧɢɰɭ; ɜɡɚɢɦɨɡɚɜɢɫɢɦɵɟ ɦɨɞɭɥɢ ɧɟ ɹɜɥɹɸɬɫɹ ɩɨɥɧɨɫɬɶɸ ɨɬɞɟɥɶɧɵɦɢ ɦɨɞɭ-
ɥɹɦɢ, ɛɭɞɭɱɢ ɩɨ ɫɭɬɢ ɱɚɫɬɹɦɢ ɨɞɧɨɝɨ ɛɨɥɶɲɟɝɨ ɦɨɞɭɥɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɰɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢ-
ɦɨɫɬɢ ɹɜɥɹɸɬɫɹ ɩɪɨɬɢɜɧɢɤɚɦɢ ɦɨɞɭɥɶɧɨɫɬɢ ɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɭɝɪɨɡɭ ɛɨɥɶɲɢɦ ɩɪɨɟɤɬɚɦ.
ɂɡɛɟɝɚɣɬɟ ɢɯ.
23. Ⱦɟɥɚɣɬɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɫɚɦɨɞɨɫɬɚɬɨɱɧɵɦɢ
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɤɚɠɞɵɣ ɧɚɩɢɫɚɧɧɵɣ ɜɚɦɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɤɨɦɩɢɥɢɪɭɟɦ ɫɚɦɨɫɬɨɹɬɟɥɶ-
ɧɨ, ɬ.ɟ. ɱɬɨ ɨɧ ɜɤɥɸɱɚɟɬ ɜɫɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɨɬ ɤɨɬɨɪɵɯ ɡɚɜɢɫɢɬ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ.
24. ɂɫɩɨɥɶɡɭɣɬɟ ɬɨɥɶɤɨ ɜɧɭɬɪɟɧɧɸɸ, ɧɨ ɧɟ ɜɧɟɲɧɸɸ ɡɚɳɢɬɭ ɞɢɪɟɤɬɢɜɵ #include
ɉɪɟɞɨɬɜɪɚɳɚɣɬɟ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɟ ɦɧɨɠɟɫɬɜɟɧɧɨɟ ɜɤɥɸɱɟɧɢɟ ɜɚɲɢɯ ɡɚɝɨɥɨɜɨɱɧɵɯ
ɮɚɣɥɨɜ ɞɢɪɟɤɬɢɜɨɣ #include, ɢɫɩɨɥɶɡɭɹ ɜ ɧɢɯ ɡɚɳɢɬɭ ɫ ɭɧɢɤɚɥɶɧɵɦɢ ɢɦɟɧɚɦɢ.
Стр. 208
Функции и операторы
25. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ, (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɦɭ ) ɭɤɚɡɚɬɟɥɸ ɢɥɢ ɫɫɵɥɤɟ
ȼɵ ɞɨɥɠɧɵ ɱɟɬɤɨ ɭɹɫɧɢɬɶ ɪɚɡɧɢɰɭ ɦɟɠɞɭ ɜɯɨɞɧɵɦɢ, ɜɵɯɨɞɧɵɦɢ ɩɚɪɚɦɟɬɪɚɦɢ ɢ ɩɚɪɚ-
ɦɟɬɪɚɦɢ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɦɢ ɢ ɞɥɹ ɜɜɨɞɚ, ɢ ɞɥɹ ɜɵɜɨɞɚ ɢɧɮɨɪɦɚɰɢɢ, ɚ ɬɚɤɠɟ ɦɟɠɞɭ ɩɟɪɟ-
ɞɚɱɟɣ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ ɢ ɩɨ ɫɫɵɥɤɟ, ɢ ɤɨɪɪɟɤɬɧɨ ɢɯ ɢɫɩɨɥɶɡɨɜɚɬɶ.
26. ɋɨɯɪɚɧɹɣɬɟ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ
ɉɪɨɝɪɚɦɦɢɫɬɵ ɧɟɧɚɜɢɞɹɬ ɫɸɪɩɪɢɡɵ. ɉɟɪɟɝɪɭɠɚɣɬɟ ɨɩɟɪɚɬɨɪɵ ɬɨɥɶɤɨ ɜ ɫɥɭɱɚɟ ɜɟɫɤɢɯ
ɧɚ ɬɨ ɨɫɧɨɜɚɧɢɣ, ɢ ɫɨɯɪɚɧɹɣɬɟ ɩɪɢ ɷɬɨɦ ɢɯ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ. ȿɫɥɢ ɷɬɨ ɨɤɚɡɵɜɚɟɬ-
ɫɹ ɫɥɨɠɧɵɦ, ɜɨɡɦɨɠɧɨ, ɜɵ ɧɟɜɟɪɧɨ ɢɫɩɨɥɶɡɭɟɬɟ ɩɟɪɟɝɪɭɡɤɭ ɨɩɟɪɚɬɨɪɨɜ.
27. Ɉɬɞɚɜɚɣɬɟ ɩɪɟɞɩɨɱɬɟɧɢɟ ɤɚɧɨɧɢɱɟɫɤɢɦ ɮɨɪɦɚɦ ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ ɨɩɟɪɚɬɨɪɨɜ
ɢ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ
ȿɫɥɢ ɦɨɠɧɨ ɡɚɩɢɫɚɬɶ a+b, ɬɨ ɧɟɨɛɯɨɞɢɦɨ, ɱɬɨɛɵ ɦɨɠɧɨ ɛɵɥɨ ɡɚɩɢɫɚɬɶ ɢ a+=b. ɉɪɢ
ɨɩɪɟɞɟɥɟɧɢɢ ɛɢɧɚɪɧɵɯ ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ ɨɩɟɪɚɬɨɪɨɜ ɨɞɧɨɜɪɟɦɟɧɧɨ ɩɪɟɞɨɫɬɚɜɥɹɣɬɟ ɢ ɢɯ
ɩɪɢɫɜɚɢɜɚɸɳɢɟ ɜɟɪɫɢɢ, ɩɪɢɱɟɦ ɞɟɥɚɣɬɟ ɷɬɨ ɫ ɦɢɧɢɦɚɥɶɧɵɦ ɞɭɛɥɢɪɨɜɚɧɢɟɦ ɢ ɦɚɤɫɢɦɚɥɶɧɨɣ
ɷɮɮɟɤɬɢɜɧɨɫɬɶɸ.
28. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ++ ɢ --, ɢ ɜɵɡɨɜ ɩɪɟɮɢɤɫɧɵɯ ɨɩɟɪɚɬɨɪɨɜ
Ɉɫɨɛɟɧɧɨɫɬɶ ɨɩɟɪɚɬɨɪɨɜ ɢɧɤɪɟɦɟɧɬɚ ɢ ɞɟɤɪɟɦɟɧɬɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɭ ɧɢɯ ɟɫɬɶ
ɩɪɟɮɢɤɫɧɚɹ ɢ ɩɨɫɬɮɢɤɫɧɚɹ ɮɨɪɦɵ ɫ ɧɟɦɧɨɝɨ ɨɬɥɢɱɚɸɳɟɣɫɹ ɫɟɦɚɧɬɢɤɨɣ. Ɉɩɪɟɞɟɥɹɣɬɟ ɨɩɟ-
ɪɚɬɨɪɵ operator++ ɢ operator-- ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɩɨɞɪɚɠɚɥɢ ɩɨɜɟɞɟɧɢɸ ɫɜɨɢɯ ɜɫɬɪɨɟɧɧɵɯ
ɞɜɨɣɧɢɤɨɜ. ȿɫɥɢ ɬɨɥɶɤɨ ɜɚɦ ɧɟ ɬɪɟɛɭɟɬɫɹ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɮɢɤɫɧɵɟ
ɜɟɪɫɢɢ ɨɩɟɪɚɬɨɪɨɜ.
29. ɂɫɩɨɥɶɡɭɣɬɟ ɩɟɪɟɝɪɭɡɤɭ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ
ɇɟ ɩɪɟɭɦɧɨɠɚɣɬɟ ɨɛɴɟɤɬɵ ɫɜɟɪɯ ɧɟɨɛɯɨɞɢɦɨɫɬɢ (Ȼɪɢɬɜɚ Ɉɤɤɚɦɚ): ɧɟɹɜɧɨɟ ɩɪɟɨɛɪɚɡɨ-
ɜɚɧɢɟ ɬɢɩɨɜ ɨɛɟɫɩɟɱɢɜɚɟɬ ɨɩɪɟɞɟɥɟɧɧɨɟ ɫɢɧɬɚɤɫɢɱɟɫɤɨɟ ɭɞɨɛɫɬɜɨ (ɨɞɧɚɤɨ ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 40), ɧɨ ɜ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɞɨɩɭɫɬɢɦɚ ɨɩɬɢɦɢɡɚɰɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8) ɢ ɠɟɥɚɬɟɥɶɧɨ
ɢɡɛɟɠɚɬɶ ɫɨɡɞɚɧɢɹ ɢɡɥɢɲɧɢɯ ɨɛɴɟɤɬɨɜ, ɦɨɠɧɨ ɨɛɟɫɩɟɱɢɬɶ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤɰɢɢ ɫ ɫɢɝ-
ɧɚɬɭɪɚɦɢ, ɬɨɱɧɨ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɬɢɩɚɦ ɚɪɝɭɦɟɧɬɨɜ, ɢ ɬɟɦ ɫɚɦɵɦ
ɢɡɛɟɠɚɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ.
30. ɂɡɛɟɝɚɣɬɟ ɩɟɪɟɝɪɭɡɤɢ &&, || ɢ , (ɡɚɩɹɬɨɣ)
Ɇɭɞɪɨɫɬɶ — ɷɬɨ ɡɧɚɧɢɟ ɬɨɝɨ, ɤɨɝɞɚ ɧɚɞɨ ɜɨɡɞɟɪɠɚɬɶɫɹ. ȼɫɬɪɨɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ &&, ||
ɢ , (ɡɚɩɹɬɚɹ) ɬɪɚɤɬɭɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ ɫɩɟɰɢɚɥɶɧɵɦ ɨɛɪɚɡɨɦ. ɉɨɫɥɟ ɩɟɪɟɝɪɭɡɤɢ ɨɧɢ ɫɬɚ-
ɧɨɜɹɬɫɹ ɨɛɵɱɧɵɦɢ ɮɭɧɤɰɢɹɦɢ ɫ ɜɟɫɶɦɚ ɨɬɥɢɱɧɨɣ ɫɟɦɚɧɬɢɤɨɣ (ɩɪɢ ɷɬɨɦ ɜɵ ɧɚɪɭɲɚɟɬɟ ɪɟ-
ɤɨɦɟɧɞɚɰɢɢ 26 ɢ 31), ɚ ɷɬɨ ɩɪɹɦɨɣ ɩɭɬɶ ɤ ɬɪɭɞɧɨɨɩɪɟɞɟɥɢɦɵɦ ɨɲɢɛɤɚɦ ɢ ɧɟɧɚɞɟɠɧɨɫɬɢ.
ɇɟ ɩɟɪɟɝɪɭɠɚɣɬɟ ɷɬɢ ɨɩɟɪɚɬɨɪɵ ɛɟɡ ɤɪɚɣɧɟɣ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɢ ɝɥɭɛɨɤɨɝɨ ɩɨɧɢɦɚɧɢɹ.
31. ɇɟ ɩɢɲɢɬɟ ɤɨɞ, ɤɨɬɨɪɵɣ ɡɚɜɢɫɢɬ ɨɬ ɩɨɪɹɞɤɚ ɜɵɱɢɫɥɟɧɢɣ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ
ɉɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ, ɩɨɷɬɨɦɭ ɧɢɤɨɝɞɚ ɧɟ ɩɨɥɚɝɚɣɬɟɫɶ
ɧɚ ɬɨ, ɱɬɨ ɚɪɝɭɦɟɧɬɵ ɛɭɞɭɬ ɜɵɱɢɫɥɹɬɶɫɹ ɜ ɬɨɣ ɢɥɢ ɢɧɨɣ ɨɱɟɪɟɞɧɨɫɬɢ.
Проектирование классов и наследование

32. əɫɧɨ ɩɪɟɞɫɬɚɜɥɹɣɬɟ, ɤɚɤɨɣ ɜɢɞ ɤɥɚɫɫɚ ɜɵ ɫɨɡɞɚɟɬɟ
ɋɭɳɟɫɬɜɭɟɬ ɛɨɥɶɲɨɟ ɤɨɥɢɱɟɫɬɜɨ ɪɚɡɥɢɱɧɵɯ ɜɢɞɨɜ ɤɥɚɫɫɨɜ, ɢ ɫɥɟɞɭɟɬ ɡɧɚɬɶ, ɤɚɤɨɣ ɢɦɟɧ-
ɧɨ ɤɥɚɫɫ ɜɵ ɫɨɡɞɚɟɬɟ.
Стр. 209
33. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɦɢɧɢɦɚɥɶɧɵɟ ɤɥɚɫɫɵ ɦɨɧɨɥɢɬɧɵɦ
Ɋɚɡɞɟɥɹɣ ɢ ɜɥɚɫɬɜɭɣ: ɧɟɛɨɥɶɲɢɟ ɤɥɚɫɫɵ ɥɟɝɱɟ ɩɢɫɚɬɶ, ɬɟɫɬɢɪɨɜɚɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ. Ɉɧɢ
ɬɚɤɠɟ ɩɪɢɦɟɧɢɦɵ ɜ ɛɨɥɶɲɟɦ ɤɨɥɢɱɟɫɬɜɟ ɫɢɬɭɚɰɢɣ. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɬɚɤɢɟ ɧɟɛɨɥɶɲɢɟ ɤɥɚɫ-
ɫɵ, ɤɨɬɨɪɵɟ ɜɨɩɥɨɳɚɸɬ ɩɪɨɫɬɵɟ ɤɨɧɰɟɩɰɢɢ, ɤɥɚɫɫɚɦ, ɩɵɬɚɸɳɢɦɫɹ ɪɟɚɥɢɡɨɜɚɬɶ ɤɚɤ ɧɟ-
ɫɤɨɥɶɤɨ ɤɨɧɰɟɩɰɢɣ, ɬɚɤ ɢ ɫɥɨɠɧɵɟ ɤɨɧɰɟɩɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 5 ɢ 6).
34. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɨɦɩɨɡɢɰɢɸ ɧɚɫɥɟɞɨɜɚɧɢɸ
ɂɡɛɟɝɚɣɬɟ “ɧɚɥɨɝɚ ɧɚ ɧɚɫɥɟɞɫɬɜɨ”: ɧɚɫɥɟɞɨɜɚɧɢɟ — ɜɬɨɪɚɹ ɩɨ ɫɢɥɟ ɩɨɫɥɟ ɨɬɧɨɲɟɧɢɹ
ɞɪɭɠɛɵ ɜɡɚɢɦɨɫɜɹɡɶ, ɤɨɬɨɪɭɸ ɦɨɠɧɨ ɜɵɪɚɡɢɬɶ ɜ C++. ɋɢɥɶɧɵɟ ɫɜɹɡɢ ɧɟɠɟɥɚɬɟɥɶɧɵ, ɢ ɢɯ
ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ ɜɟɡɞɟ, ɝɞɟ ɬɨɥɶɤɨ ɦɨɠɧɨ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɥɟɞɭɟɬ ɩɪɟɞɩɨɱɢɬɚɬɶ ɤɨɦɩɨ-
ɡɢɰɢɸ ɧɚɫɥɟɞɨɜɚɧɢɸ, ɤɪɨɦɟ ɫɥɭɱɚɟɜ, ɤɨɝɞɚ ɜɵ ɬɨɱɧɨ ɡɧɚɟɬɟ, ɱɬɨ ɞɟɥɚɟɬɟ ɢ ɤɚɤɢɟ ɩɪɟɢɦɭɳɟ-
ɫɬɜɚ ɞɚɟɬ ɧɚɫɥɟɞɨɜɚɧɢɟ ɜ ɜɚɲɟɦ ɩɪɨɟɤɬɟ.
35. ɂɡɛɟɝɚɣɬɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɫɩɪɨɟɤɬɢɪɨɜɚɧɵ ɞɥɹ ɷɬɨɣ ɰɟɥɢ
Ʉɥɚɫɫɵ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɟ ɞɥɹ ɚɜɬɨɧɨɦɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɩɨɞɱɢɧɹɸɬɫɹ ɩɪɚɜɢɥɚɦ ɩɪɨ-
ɟɤɬɢɪɨɜɚɧɢɹ, ɨɬɥɢɱɧɵɦ ɨɬ ɩɪɚɜɢɥ ɞɥɹ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 32). ɂɫɩɨɥɶɡɨɜɚ-
ɧɢɟ ɚɜɬɨɧɨɦɧɵɯ ɤɥɚɫɫɨɜ ɜ ɤɚɱɟɫɬɜɟ ɛɚɡɨɜɵɯ ɹɜɥɹɟɬɫɹ ɫɟɪɶɟɡɧɨɣ ɨɲɢɛɤɨɣ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
ɢ ɟɝɨ ɫɥɟɞɭɟɬ ɢɡɛɟɝɚɬɶ. Ⱦɥɹ ɞɨɛɚɜɥɟɧɢɹ ɫɩɟɰɢɮɢɱɟɫɤɨɝɨ ɩɨɜɟɞɟɧɢɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɜɦɟɫɬɨ
ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɞɨɛɚɜɥɹɬɶ ɨɛɵɱɧɵɟ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 44). Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɞɨɛɚ-
ɜɢɬɶ ɫɨɫɬɨɹɧɢɟ, ɜɦɟɫɬɨ ɧɚɫɥɟɞɨɜɚɧɢɹ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɦɩɨɡɢɰɢɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚ-
ɰɢɸ 34). ɂɡɛɟɝɚɣɬɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ ɤɨɧɤɪɟɬɧɵɯ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ.
36. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɚɛɫɬɪɚɤɬɧɵɯ ɢɧɬɟɪɮɟɣɫɨɜ
ȼɵ ɥɸɛɢɬɟ ɚɛɫɬɪɚɤɰɢɨɧɢɡɦ? Ⱥɛɫɬɪɚɤɬɧɵɟ ɢɧɬɟɪɮɟɣɫɵ ɩɨɦɨɝɚɸɬ ɜɚɦ ɫɨɫɪɟɞɨɬɨɱɢɬɶ-
ɫɹ ɧɚ ɩɪɨɛɥɟɦɚɯ ɩɪɚɜɢɥɶɧɨɝɨ ɚɛɫɬɪɚɝɢɪɨɜɚɧɢɹ, ɧɟ ɜɞɚɜɚɹɫɶ ɜ ɞɟɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ ɢɥɢ ɭɩɪɚɜ-
ɥɟɧɢɹ ɫɨɫɬɨɹɧɢɹɦɢ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɪɨɟɤɬɢɪɨɜɚɬɶ ɢɟɪɚɪɯɢɢ, ɪɟɚɥɢɡɭɸɳɢɟ ɚɛɫɬɪɚɤɬɧɵɟ
ɢɧɬɟɪɮɟɣɫɵ, ɤɨɬɨɪɵɟ ɦɨɞɟɥɢɪɭɸɬ ɚɛɫɬɪɚɤɬɧɵɟ ɤɨɧɰɟɩɰɢɢ.
37. Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɡɧɚɱɚɟɬ ɡɚɦɟɧɢɦɨɫɬɶ. ɇɚɫɥɟɞɨɜɚɬɶ ɧɚɞɨ
ɧɟ ɞɥɹ ɩɨɜɬɨɪɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɚ ɱɬɨɛɵ ɛɵɬɶ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɧɧɵɦ
Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɩɨɡɜɨɥɹɟɬ ɭɤɚɡɚɬɟɥɸ ɢɥɢ ɫɫɵɥɤɟ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ ɜ ɞɟɣɫɬɜɢ-
ɬɟɥɶɧɨɫɬɢ ɨɛɪɚɳɚɬɶɫɹ ɤ ɨɛɴɟɤɬɭ ɧɟɤɨɬɨɪɨɝɨ ɩɪɨɢɡɜɨɞɧɨɝɨ ɤɥɚɫɫɚ ɛɟɡ ɢɡɦɟɧɟɧɢɹ ɫɭɳɟɫɬ-
ɜɭɸɳɟɝɨ ɤɨɞɚ ɢ ɧɚɪɭɲɟɧɢɹ ɟɝɨ ɤɨɪɪɟɤɬɧɨɫɬɢ.
ɇɟ ɩɪɢɦɟɧɹɣɬɟ ɨɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɨɞ
(ɧɚɯɨɞɹɳɢɣɫɹ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ); ɨɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɧɟɨɛɯɨɞɢɦɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɛɵɬɶ
ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɧɧɵɦ (ɫɭɳɟɫɬɜɭɸɳɢɦ ɤɨɞɨɦ, ɤɨɬɨɪɵɣ ɩɨɥɢɦɨɪɮɧɨ ɢɫɩɨɥɶɡɭɟɬ ɨɛɴɟɤ-
ɬɵ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ).
38. ɉɪɚɤɬɢɤɭɣɬɟ ɛɟɡɨɩɚɫɧɨɟ ɩɟɪɟɤɪɵɬɢɟ
Ɉɬɜɟɬɫɬɜɟɧɧɨ ɩɨɞɯɨɞɢɬɟ ɜ ɩɟɪɟɤɪɵɬɢɸ ɮɭɧɤɰɢɣ. Ʉɨɝɞɚ ɜɵ ɩɟɪɟɤɪɵɜɚɟɬɟ ɜɢɪɬɭɚɥɶɧɭɸ
ɮɭɧɤɰɢɸ, ɫɨɯɪɚɧɹɣɬɟ ɡɚɦɟɧɢɦɨɫɬɶ; ɜ ɱɚɫɬɧɨɫɬɢ, ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɩɪɟɞ- ɢ ɩɨɫɬɭɫɥɨ-
ɜɢɹ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ. ɇɟ ɢɡɦɟɧɹɣɬɟ ɚɪɝɭɦɟɧɬɵ ɩɨ ɭɦɨɥɱɚɧɢɸ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ. ɉɪɟɞ-
ɩɨɱɬɢɬɟɥɶɧɨ ɹɜɧɨ ɭɤɚɡɵɜɚɬɶ ɩɟɪɟɤɪɵɜɚɟɦɵɟ ɮɭɧɤɰɢɢ ɤɚɤ ɜɢɪɬɭɚɥɶɧɵɟ. ɇɟ ɡɚɛɵɜɚɣɬɟ ɨ ɫɨ-
ɤɪɵɬɢɢ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɮɭɧɤɰɢɣ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ.
39. ȼɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɫɬɨɢɬ ɞɟɥɚɬɶ ɧɟɨɬɤɪɵɬɵɦɢ, ɚ ɨɬɤɪɵɬɵɟ —
ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ
ȼ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ ɫ ɜɵɫɨɤɨɣ ɫɬɨɢɦɨɫɬɶɸ ɢɡɦɟɧɟɧɢɣ (ɜ ɱɚɫɬɧɨɫɬɢ, ɜ ɛɢɛɥɢɨɬɟɤɚɯ) ɥɭɱɲɟ
ɞɟɥɚɬɶ ɨɬɤɪɵɬɵɟ ɮɭɧɤɰɢɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ. ȼɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɥɭɱɲɟ ɞɟɥɚɬɶ ɡɚɤɪɵ-
ɬɵɦɢ, ɢɥɢ ɡɚɳɢɳɟɧɧɵɦɢ — ɟɫɥɢ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɞɨɥɠɟɧ ɢɦɟɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɜɵɡɵɜɚɬɶ
ɢɯ ɛɚɡɨɜɵɟ ɜɟɪɫɢɢ (ɷɬɨɬ ɫɨɜɟɬ ɧɟ ɨɬɧɨɫɢɬɫɹ ɤ ɞɟɫɬɪɭɤɬɨɪɚɦ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 50).
Стр. 210
40. ɂɡɛɟɝɚɣɬɟ ɜɨɡɦɨɠɧɨɫɬɟɣ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ
ɇɟ ɜɫɟ ɢɡɦɟɧɟɧɢɹ ɩɪɨɝɪɟɫɫɢɜɧɵ: ɧɟɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɡɚɱɚɫɬɭɸ ɩɪɢɧɨɫɹɬ ɛɨɥɶɲɟ
ɜɪɟɞɚ, ɱɟɦ ɩɨɥɶɡɵ. Ⱦɜɚɠɞɵ ɩɨɞɭɦɚɣɬɟ ɩɟɪɟɞ ɬɟɦ, ɤɚɤ ɩɪɟɞɨɫɬɚɜɢɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɧɟɹɜɧɨɝɨ
ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɤ ɬɢɩɭ ɢ ɢɡ ɬɢɩɚ, ɤɨɬɨɪɵɣ ɜɵ ɨɩɪɟɞɟɥɹɟɬɟ, ɢ ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɩɨɥɚɝɚɬɶɫɹ ɧɚ
ɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ (ɢɫɩɨɥɶɡɭɣɬɟ ɤɨɧɫɬɪɭɤɬɨɪɵ, ɨɛɴɹɜɥɟɧɧɵɟ ɤɚɤ explicit, ɢ ɢɦɟɧɨɜɚɧɧɵɟ
ɮɭɧɤɰɢɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ).
41. Ⱦɟɥɚɣɬɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɡɚɤɪɵɬɵɦɢ (ɤɪɨɦɟ ɫɥɭɱɚɹ ɚɝɪɟɝɚɬɨɜ ɜ ɫɬɢɥɟ ɫɬɪɭɤɬɭɪ C)
Ⱦɚɧɧɵɟ-ɱɥɟɧɵ ɞɨɥɠɧɵ ɛɵɬɶ ɡɚɤɪɵɬɵ. Ɍɨɥɶɤɨ ɜ ɫɥɭɱɚɟ ɩɪɨɫɬɟɣɲɢɯ ɬɢɩɨɜ ɜ ɫɬɢɥɟ ɫɬɪɭɤ-
ɬɭɪ ɹɡɵɤɚ C, ɨɛɴɟɞɢɧɹɸɳɢɯ ɜ ɟɞɢɧɨɟ ɰɟɥɨɟ ɧɚɛɨɪ ɡɧɚɱɟɧɢɣ, ɧɟ ɩɪɟɬɟɧɞɭɸɳɢɯ ɧɚ ɢɧɤɚɩɫɭɥɹɰɢɸ
ɢ ɧɟ ɨɛɟɫɩɟɱɢɜɚɸɳɢɯ ɩɨɜɟɞɟɧɢɟ, ɞɟɥɚɣɬɟ ɜɫɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɨɬɤɪɵɬɵɦɢ. ɂɡɛɟɝɚɣɬɟ ɫɦɟɲɢɜɚ-
ɧɢɹ ɨɬɤɪɵɬɵɯ ɢ ɡɚɤɪɵɬɵɯ ɞɚɧɧɵɯ, ɱɬɨ ɩɪɚɤɬɢɱɟɫɤɢ ɜɫɟɝɞɚ ɝɨɜɨɪɢɬ ɨ ɛɟɫɬɨɥɤɨɜɨɦ ɞɢɡɚɣɧɟ.
42. ɇɟ ɞɨɩɭɫɤɚɣɬɟ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɜɨ ɜɧɭɬɪɟɧɧɢɟ ɞɟɥɚ
ɂɡɛɟɝɚɣɬɟ ɜɨɡɜɪɚɬɚ ɞɟɫɤɪɢɩɬɨɪɨɜ ɜɧɭɬɪɟɧɧɢɯ ɞɚɧɧɵɯ, ɭɩɪɚɜɥɹɟɦɵɯ ɜɚɲɢɦ ɤɥɚɫɫɨɦ,
ɱɬɨɛɵ ɤɥɢɟɧɬɵ ɧɟ ɦɨɝɥɢ ɧɟɤɨɧɬɪɨɥɢɪɭɟɦɨ ɢɡɦɟɧɹɬɶ ɫɨɫɬɨɹɧɢɟ ɜɚɲɟɝɨ ɨɛɴɟɤɬɚ, ɤɚɤ ɫɜɨɟɝɨ
ɫɨɛɫɬɜɟɧɧɨɝɨ.
43. Ɋɚɡɭɦɧɨ ɩɨɥɶɡɭɣɬɟɫɶ ɢɞɢɨɦɨɣ Pimpl
C++ ɞɟɥɚɟɬ ɡɚɤɪɵɬɵɟ ɱɥɟɧɵ ɧɟɞɨɫɬɭɩɧɵɦɢ, ɧɨ ɧɟ ɧɟɜɢɞɢɦɵɦɢ. Ɍɚɦ, ɝɞɟ ɷɬɨ ɨɩɪɚɜɞɵɜɚɟɬɫɹ
ɩɨɥɭɱɚɟɦɵɦɢ ɩɪɟɢɦɭɳɟɫɬɜɚɦɢ, ɫɥɟɞɭɟɬ ɩɨɞɭɦɚɬɶ ɨɛ ɢɫɬɢɧɧɨɣ ɧɟɜɢɞɢɦɨɫɬɢ, ɞɨɫɬɢɝɚɟɦɨɣ
ɩɪɢɦɟɧɟɧɢɟɦ ɢɞɢɨɦɵ Pimpl (ɭɤɚɡɚɬɟɥɹ ɧɚ ɪɟɚɥɢɡɚɰɢɸ) ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɛɪɚɧɞɦɚɭɷɪɨɜ ɤɨɦɩɢɥɹɬɨɪɚ
ɢ ɩɨɜɵɲɟɧɢɹ ɫɨɤɪɵɬɢɹ ɢɧɮɨɪɦɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 11 ɢ 41).
44. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɧɟ ɹɜɥɹɸɬɫɹ ɧɢ ɱɥɟɧɚɦɢ, ɧɢ ɞɪɭɡɶɹɦɢ
Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɩɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɞɟɥɚɬɶ ɮɭɧɤɰɢɢ ɧɟ ɱɥɟɧɚɦɢ ɢ ɧɟ ɞɪɭɡɶɹɦɢ ɤɥɚɫɫɨɜ.
45. new ɢ delete ɜɫɟɝɞɚ ɞɨɥɠɧɵ ɪɚɡɪɚɛɚɬɵɜɚɬɶɫɹ ɜɦɟɫɬɟ
Ʉɚɠɞɚɹ ɩɟɪɟɝɪɭɡɤɚ void* operator new(parms) ɜ ɤɥɚɫɫɟ ɞɨɥɠɧɚ ɫɨɩɪɨɜɨɠɞɚɬɶɫɹ
ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɣ ɩɟɪɟɝɪɭɡɤɨɣ ɨɩɟɪɚɬɨɪɚ void operator delete(void*, parms), ɝɞɟ parms —
ɫɩɢɫɨɤ ɬɢɩɨɜ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɩɚɪɚɦɟɬɪɨɜ (ɩɟɪɜɵɣ ɢɡ ɤɨɬɨɪɵɯ ɜɫɟɝɞɚ std::size_t). Ɍɨ ɠɟ
ɨɬɧɨɫɢɬɫɹ ɢ ɤ ɨɩɟɪɚɬɨɪɚɦ ɞɥɹ ɦɚɫɫɢɜɨɜ new[] ɢ delete[].
46. ɉɪɢ ɧɚɥɢɱɢɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ new ɫɥɟɞɭɟɬ ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɜɫɟ ɫɬɚɧɞɚɪɬɧɵɟ
ɬɢɩɵ ɷɬɨɝɨ ɨɩɟɪɚɬɨɪɚ
ȿɫɥɢ ɤɥɚɫɫ ɨɩɪɟɞɟɥɹɟɬ ɥɸɛɭɸ ɩɟɪɟɝɪɭɡɤɭ ɨɩɟɪɚɬɨɪɚ new, ɨɧ ɞɨɥɠɟɧ ɩɟɪɟɝɪɭɡɢɬɶ ɜɫɟ ɬɪɢ
ɫɬɚɧɞɚɪɬɧɵɯ ɬɢɩɚ ɷɬɨɝɨ ɨɩɟɪɚɬɨɪɚ — ɨɛɵɱɧɵɣ new, ɪɚɡɦɟɳɚɸɳɢɣ ɢ ɧɟ ɝɟɧɟɪɢɪɭɸɳɢɣ ɢɫ-
ɤɥɸɱɟɧɢɣ. ȿɫɥɢ ɷɬɨɝɨ ɧɟ ɫɞɟɥɚɬɶ, ɬɨ ɷɬɢ ɨɩɟɪɚɬɨɪɵ ɨɤɚɠɭɬɫɹ ɫɤɪɵɬɵɦɢ ɢ ɧɟɞɨɫɬɭɩɧɵɦɢ
ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ.
Конструкторы, деструкторы и копирование

47. Ɉɩɪɟɞɟɥɹɣɬɟ ɢ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɜ ɨɞɧɨɦ ɩɨɪɹɞɤɟ
ɉɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɜɫɟɝɞɚ ɢɧɢɰɢɚɥɢɡɢɪɭɸɬɫɹ ɜ ɬɨɦ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɢ ɨɛɴɹɜɥɟɧɵ
ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɤɥɚɫɫɚ; ɩɨɪɹɞɨɤ ɢɯ ɭɩɨɦɢɧɚɧɢɹ ɜ ɫɩɢɫɤɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɝɧɨ-
ɪɢɪɭɟɬɫɹ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜ ɤɨɞɟ ɤɨɧɫɬɪɭɤɬɨɪɚ ɭɤɚɡɚɧ ɬɨɬ ɠɟ ɩɨɪɹɞɨɤ, ɱɬɨ ɢ ɜ ɨɩɪɟɞɟɥɟ-
ɧɢɢ ɤɥɚɫɫɚ.
48. ȼ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɩɪɢɫɜɚɢɜɚɧɢɸ
ȼ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɜɦɟɫɬɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɞɥɹ ɭɫɬɚɧɨɜɤɢ ɡɧɚ-
ɱɟɧɢɣ ɩɟɪɟɦɟɧɧɵɯ-ɱɥɟɧɨɜ ɩɪɟɞɨɯɪɚɧɹɟɬ ɨɬ ɧɟɧɭɠɧɨɣ ɪɚɛɨɬɵ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɪɢ ɬɨɦ
ɠɟ ɨɛɴɟɦɟ ɜɜɨɞɢɦɨɝɨ ɢɫɯɨɞɧɨɝɨ ɬɟɤɫɬɚ.
Стр. 211
49. ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɨɜ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɜ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɢ ɞɟɫɬɪɭɤɬɨɪɚɯ
ȼɧɭɬɪɢ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɢ ɞɟɫɬɪɭɤɬɨɪɨɜ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɬɟɪɹɸɬ ɜɢɪɬɭɚɥɶɧɨɫɬɶ.
ɏɭɠɟ ɬɨɝɨ — ɜɫɟ ɩɪɹɦɵɟ ɢɥɢ ɤɨɫɜɟɧɧɵɟ ɜɵɡɨɜɵ ɧɟɪɟɚɥɢɡɨɜɚɧɧɵɯ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ
ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪɚ ɩɪɢɜɨɞɹɬ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ. ȿɫɥɢ ɜɚɲ ɞɢɡɚɣɧ
ɬɪɟɛɭɟɬ ɜɢɪɬɭɚɥɶɧɨɣ ɩɟɪɟɞɚɱɢ ɜ ɩɪɨɢɡɜɨɞɧɵɣ ɤɥɚɫɫ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪɚ ɛɚɡɨ-
ɜɨɝɨ ɤɥɚɫɫɚ, ɫɥɟɞɭɟɬ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɧɨɣ ɦɟɬɨɞɢɤɨɣ, ɧɚɩɪɢɦɟɪ, ɩɨɫɬɤɨɧɫɬɪɭɤɬɨɪɚɦɢ.
50. Ⱦɟɥɚɣɬɟ ɞɟɫɬɪɭɤɬɨɪɵ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ ɨɬɤɪɵɬɵɦɢ ɢ ɜɢɪɬɭɚɥɶɧɵɦɢ ɥɢɛɨ
ɡɚɳɢɳɟɧɧɵɦɢ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ
ɍɞɚɥɹɬɶ ɢɥɢ ɧɟ ɭɞɚɥɹɬɶ — ɜɨɬ ɜ ɱɟɦ ɜɨɩɪɨɫ! ȿɫɥɢ ɫɥɟɞɭɟɬ ɨɛɟɫɩɟɱɢɬɶ ɜɨɡɦɨɠɧɨɫɬɶ
ɭɞɚɥɟɧɢɹ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɹ ɧɚ ɛɚɡɨɜɵɣ ɤɥɚɫɫ, ɬɨ ɞɟɫɬɪɭɤɬɨɪ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɟɧ
ɛɵɬɶ ɨɬɤɪɵɬɵɦ ɢ ɜɢɪɬɭɚɥɶɧɵɦ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɨɧ ɞɨɥɠɟɧ ɛɵɬɶ ɡɚɳɢɳɟɧɧɵɦ ɢ ɧɟ-
ɜɢɪɬɭɚɥɶɧɵɦ.
51. Ⱦɟɫɬɪɭɤɬɨɪɵ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɢ ɨɛɦɟɧɚ ɧɟ ɨɲɢɛɚɸɬɫɹ
ȼɫɟ ɡɚɩɭɫɤɢ ɷɬɢɯ ɮɭɧɤɰɢɣ ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɩɟɲɧɵɦɢ. ɇɢɤɨɝɞɚ ɧɟ ɩɨɡɜɨɥɹɣɬɟ ɨɲɢɛɤɟ ɜɵɣɬɢ
ɡɚ ɩɪɟɞɟɥɵ ɞɟɫɬɪɭɤɬɨɪɚ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, ɨɩɟɪɚɬɨɪɚ delete) ɢɥɢ
ɮɭɧɤɰɢɢ ɨɛɦɟɧɚ. ȼ ɱɚɫɬɧɨɫɬɢ, ɬɢɩɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɤɨɬɨɪɵɯ ɦɨɝɭɬ ɝɟɧɟɪɢɪɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ,
ɤɚɬɟɝɨɪɢɱɟɫɤɢ ɡɚɩɪɟɳɟɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɫɨ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɨɣ C++.
52. Ʉɨɩɢɪɭɣɬɟ ɢ ɥɢɤɜɢɞɢɪɭɣɬɟ ɫɨɝɥɚɫɨɜɚɧɧɨ
ȿɫɥɢ ɜɵ ɨɩɪɟɞɟɥɢɥɢ ɨɞɧɭ ɢɡ ɫɥɟɞɭɸɳɟɝɨ ɫɩɢɫɤɚ ɮɭɧɤɰɢɣ — ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ,
ɨɩɟɪɚɬɨɪ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɢɥɢ ɞɟɫɬɪɭɤɬɨɪ — ɜɟɪɨɹɬɧɨ, ɜɚɦ ɩɨɬɪɟɛɭɟɬɫɹ ɨɩɪɟ-
ɞɟɥɢɬɶ ɢ ɨɛɟ ɨɫɬɚɜɲɢɟɫɹ ɮɭɧɤɰɢɢ (ɢɥɢ ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ ɨɞɧɭ ɢɡ ɧɢɯ).
53. əɜɧɨ ɪɚɡɪɟɲɚɣɬɟ ɢɥɢ ɡɚɩɪɟɳɚɣɬɟ ɤɨɩɢɪɨɜɚɧɢɟ
Ʉɨɩɢɪɭɣɬɟ ɫɨ ɡɧɚɧɢɟɦ ɞɟɥɚ: ɬɳɚɬɟɥɶɧɨ ɜɵɛɢɪɚɣɬɟ ɦɟɠɞɭ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɫɝɟɧɟɪɢɪɨɜɚɧ-
ɧɵɯ ɤɨɦɩɢɥɹɬɨɪɨɦ ɤɨɩɢɪɭɸɳɟɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ ɢ ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɧɚɩɢɫɚɧɢɟɦ ɫɨɛɫɬ-
ɜɟɧɧɵɯ ɜɟɪɫɢɣ ɢɥɢ ɹɜɧɵɦ ɡɚɩɪɟɳɟɧɢɟɦ ɨɛɨɢɯ, ɟɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɧɟ ɞɨɥɠɧɨ ɛɵɬɶ ɪɚɡɪɟɲɟɧɨ.
54. ɂɡɛɟɝɚɣɬɟ ɫɪɟɡɤɢ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ ɤɥɨɧɢɪɨɜɚɧɢɹ
ɜɦɟɫɬɨ ɤɨɩɢɪɨɜɚɧɢɹ
ɋɪɟɡɤɚ ɨɛɴɟɤɬɨɜ ɩɪɨɢɫɯɨɞɢɬ ɚɜɬɨɦɚɬɢɱɟɫɤɢ, ɧɟɜɢɞɢɦɨ ɢ ɦɨɠɟɬ ɩɪɢɜɨɞɢɬɶ ɤ ɩɨɥɧɨɦɭ
ɪɚɡɪɭɲɟɧɢɸ ɱɭɞɟɫɧɨɝɨ ɩɨɥɢɦɨɪɮɧɨɝɨ ɞɢɡɚɣɧɚ. ɉɨɞɭɦɚɣɬɟ ɨ ɩɨɥɧɨɦ ɡɚɩɪɟɬɟ ɤɨɩɢɪɭɸɳɟɝɨ
ɤɨɧɫɬɪɭɤɬɨɪɚ ɢ ɤɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɜ ɛɚɡɨɜɵɯ ɤɥɚɫɫɚɯ. ȼɦɟɫɬɨ ɧɢɯ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ Clone, ɟɫɥɢ ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɥɚɫɫɚ ɧɟɨɛɯɨɞɢɦɨ ɩɨɥɭ-
ɱɚɬɶ ɩɨɥɢɦɨɪɮɧɵɟ (ɩɨɥɧɵɟ, ɝɥɭɛɨɤɢɟ) ɤɨɩɢɢ.
55. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ɩɪɢɫɜɚɢɜɚɧɢɹ
ɉɪɢ ɪɟɚɥɢɡɚɰɢɢ ɨɩɟɪɚɬɨɪɚ operator= ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ —
ɧɟɜɢɪɬɭɚɥɶɧɵɣ ɫ ɨɩɪɟɞɟɥɟɧɧɨɣ ɫɢɝɧɚɬɭɪɨɣ.
56. Ɉɛɟɫɩɟɱɶɬɟ ɛɟɫɫɛɨɣɧɭɸ ɮɭɧɤɰɢɸ ɨɛɦɟɧɚ
Ɉɛɵɱɧɨ ɢɦɟɟɬ ɫɦɵɫɥ ɩɪɟɞɨɫɬɚɜɢɬɶ ɞɥɹ ɤɥɚɫɫɚ ɮɭɧɤɰɢɸ swap ɜ ɰɟɥɹɯ ɷɮɮɟɤɬɢɜɧɨɝɨ
ɢ ɛɟɫɫɛɨɣɧɨɝɨ ɨɛɦɟɧɚ ɜɧɭɬɪɟɧɧɟɝɨ ɫɨɞɟɪɠɢɦɨɝɨ ɨɛɴɟɤɬɚ ɫ ɜɧɭɬɪɟɧɧɢɦ ɫɨɞɟɪɠɢɦɵɦ ɞɪɭɝɨ-
ɝɨ ɨɛɴɟɤɬɚ. Ɍɚɤɚɹ ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɩɪɢɝɨɞɢɬɶɫɹ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɪɹɞɚ ɢɞɢɨɦ, ɨɬ ɩɪɨɫɬɨɝɨ
ɩɟɪɟɦɟɳɟɧɢɹ ɨɛɴɟɤɬɨɜ ɞɨ ɪɟɚɥɢɡɚɰɢɢ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɥɟɝɤɨ ɨɛɟɫɩɟɱɢɜɚɸɳɟɝɨ ɮɭɧɤɰɢɸ ɩɪɢ-
ɧɹɬɢɹ ɪɟɡɭɥɶɬɚɬɨɜ ɪɚɛɨɬɵ ɫɨ ɫɬɪɨɝɢɦɢ ɝɚɪɚɧɬɢɹɦɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɞɥɹ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ
(ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 51).
Стр. 212
Пространства имен и модули
57. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɢɯ ɫɜɨɛɨɞɧɵɣ ɢɧɬɟɪɮɟɣɫ ɜ ɨɞɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ
Ɏɭɧɤɰɢɢ, ɧɟ ɹɜɥɹɸɳɢɟɫɹ ɱɥɟɧɚɦɢ ɢ ɪɚɡɪɚɛɨɬɚɧɧɵɟ ɤɚɤ ɱɚɫɬɶ ɢɧɬɟɪɮɟɣɫɚ ɤɥɚɫɫɚ X
(ɜ ɨɫɨɛɟɧɧɨɫɬɢ ɨɩɟɪɚɬɨɪɵ ɢ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɮɭɧɤɰɢɢ), ɞɨɥɠɧɵ ɛɵɬɶ ɨɩɪɟɞɟɥɟɧɵ ɜ ɬɨɦ ɠɟ
ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɱɬɨ ɢ X, ɱɬɨ ɨɛɟɫɩɟɱɢɜɚɟɬ ɢɯ ɤɨɪɪɟɤɬɧɵɣ ɜɵɡɨɜ.
58. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɮɭɧɤɰɢɢ ɜ ɪɚɡɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ, ɟɫɥɢ ɬɨɥɶɤɨ ɨɧɢ
ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɜɦɟɫɬɧɨɣ ɪɚɛɨɬɵ
Ɉɛɟɪɟɝɚɣɬɟ ɜɚɲɢ ɬɢɩɵ ɨɬ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɝɨ ɩɨɢɫɤɚ, ɡɚɜɢɫɹɳɟɝɨ ɨɬ ɚɪɝɭɦɟɧɬɨɜ (argument-
dependent lookup — ADL, ɢɡɜɟɫɬɧɵɣ ɬɚɤɠɟ ɤɚɤ ɩɨɢɫɤ Ʉɺɧɢɝɚ); ɨɞɧɚɤɨ ɩɪɟɞɧɚɦɟɪɟɧɧɵɣ ɩɨɢɫɤ
ɞɨɥɠɟɧ ɡɚɜɟɪɲɚɬɶɫɹ ɭɫɩɟɲɧɨ. ɗɬɨɝɨ ɦɨɠɧɨ ɞɨɛɢɬɶɫɹ ɩɭɬɟɦ ɪɚɡɦɟɳɟɧɢɹ ɬɢɩɨɜ ɜ ɫɜɨɢɯ ɫɨɛɫɬ-
ɜɟɧɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ (ɜɦɟɫɬɟ ɫ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɫɜɹɡɚɧɧɵɦɢ ɫ ɧɢɦɢ ɫɜɨɛɨɞɧɵɦɢ ɮɭɧɤ-
ɰɢɹɦɢ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ɂɡɛɟɝɚɣɬɟ ɩɨɦɟɳɟɧɢɹ ɬɢɩɨɜ ɜ ɬɟ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ, ɱɬɨ
ɢ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ ɢɥɢ ɨɩɟɪɚɬɨɪɨɜ).
59. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ ɢɥɢ ɩɟɪɟɞ
ɞɢɪɟɤɬɢɜɨɣ #include
Ⱦɢɪɟɤɬɢɜɚ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɫɨɡɞɚɧɚ ɞɥɹ ɜɚɲɟɝɨ ɭɞɨɛɫɬɜɚ, ɚ ɧɟ ɞɥɹ ɝɨɥɨɜɧɨɣ ɛɨ-
ɥɢ ɞɪɭɝɢɯ. ɇɢɤɨɝɞɚ ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɨɛɴɹɜɥɟɧɢɹ ɢɥɢ ɞɢɪɟɤɬɢɜɵ using ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ #include.
ȼɵɜɨɞ: ɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɞɢɪɟɤɬɢɜɵ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɢɥɢ using-ɨɛɴɹɜɥɟɧɢɹ
ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ. ȼɦɟɫɬɨ ɷɬɨɝɨ ɩɨɥɧɨɫɬɶɸ ɤɜɚɥɢɮɢɰɢɪɭɣɬɟ ɜɫɟ ɢɦɟɧɚ. (ȼɬɨɪɨɟ ɩɪɚɜɢɥɨ
ɫɥɟɞɭɟɬ ɢɡ ɩɟɪɜɨɝɨ, ɩɨɫɤɨɥɶɤɭ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɟ ɦɨɝɭɬ ɡɧɚɬɶ, ɤɚɤɢɟ ɞɪɭɝɢɟ ɞɢɪɟɤɬɢɜɵ
#include ɦɨɝɭɬ ɩɨɹɜɢɬɶɫɹ ɜ ɬɟɤɫɬɟ ɩɨɫɥɟ ɧɢɯ.)
60. ɂɡɛɟɝɚɣɬɟ ɜɵɞɟɥɟɧɢɹ ɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ ɜ ɪɚɡɧɵɯ ɦɨɞɭɥɹɯ
Ɂɨɥɨɬɨɟ ɩɪɚɜɢɥɨ ɩɪɨɝɪɚɦɦɢɫɬɚ — ɩɨɥɨɠɢ, ɝɞɟ ɜɡɹɥ. ȼɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ ɜ ɨɞɧɨɦ ɦɨɞɭɥɟ,
ɚ ɨɫɜɨɛɨɠɞɟɧɢɟ ɜ ɞɪɭɝɨɦ ɞɟɥɚɟɬ ɩɪɨɝɪɚɦɦɭ ɛɨɥɟɟ ɯɪɭɩɤɨɣ, ɫɨɡɞɚɜɚɹ ɬɨɧɤɭɸ ɞɚɥɶɧɸɸ ɡɚɜɢ-
ɫɢɦɨɫɬɶ ɦɟɠɞɭ ɷɬɢɦɢ ɦɨɞɭɥɹɦɢ. Ɍɚɤɢɟ ɦɨɞɭɥɢ ɞɨɥɠɧɵ ɛɵɬɶ ɤɨɦɩɢɥɢɪɭɟɦɵ ɨɞɧɨɣ ɢ ɬɨɣ
ɠɟ ɜɟɪɫɢɟɣ ɤɨɦɩɢɥɹɬɨɪɚ ɫ ɨɞɧɢɦɢ ɢ ɬɟɦɢ ɠɟ ɮɥɚɝɚɦɢ (ɜ ɱɚɫɬɧɨɫɬɢ, ɨɬɥɚɞɨɱɧɵɟ ɜɟɪɫɢɢ
ɢ ɜɟɪɫɢɢ NDEBUG) ɢ ɫ ɨɞɧɨɣ ɢ ɬɨɣ ɠɟ ɪɟɚɥɢɡɚɰɢɟɣ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ; ɤɪɨɦɟ ɬɨɝɨ,
ɫ ɩɪɚɤɬɢɱɟɫɤɨɣ ɬɨɱɤɢ ɡɪɟɧɢɹ ɥɭɱɲɟ, ɱɬɨɛɵ ɦɨɞɭɥɶ, ɜɵɞɟɥɹɸɳɢɣ ɩɚɦɹɬɶ, ɨɫɬɚɜɚɥɫɹ ɡɚɝɪɭ-
ɠɟɧ ɩɪɢ ɟɟ ɨɫɜɨɛɨɠɞɟɧɢɢ.
61. ɇɟ ɨɩɪɟɞɟɥɹɣɬɟ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɨɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ
Ɉɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ, ɜɤɥɸɱɚɹ ɩɟɪɟɦɟɧɧɵɟ ɢɥɢ ɮɭɧɤɰɢɢ ɭɪɨɜɧɹ ɩɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ,
ɨɛɥɚɞɚɸɬ ɜɵɞɟɥɟɧɧɨɣ ɞɥɹ ɧɢɯ ɩɚɦɹɬɶɸ. Ɉɩɪɟɞɟɥɟɧɢɟ ɬɚɤɢɯ ɨɛɴɟɤɬɨɜ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣ-
ɥɚɯ ɩɪɢɜɨɞɢɬ ɥɢɛɨ ɤ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ ɤɨɦɩɨɧɨɜɤɢ, ɥɢɛɨ ɤ ɛɟɫɩɨɥɟɡɧɨɦɭ ɪɚɫɯɨɞɭ ɩɚɦɹɬɢ.
ɉɨɦɟɳɚɣɬɟ ɜɫɟ ɨɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ ɜ ɮɚɣɥɵ ɪɟɚɥɢɡɚɰɢɢ.
62. ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟɤɚɬɶ ɝɪɚɧɢɰɵ ɦɨɞɭɥɟɣ
ɇɟ ɛɪɨɫɚɣɬɟ ɤɚɦɧɢ ɜ ɫɨɫɟɞɫɤɢɣ ɨɝɨɪɨɞ — ɩɨɫɤɨɥɶɤɭ ɧɟɬ ɩɨɜɫɟɦɟɫɬɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɝɨ
ɛɢɧɚɪɧɨɝɨ ɫɬɚɧɞɚɪɬɚ ɞɥɹ ɨɛɪɚɛɨɬɤɢ ɢɫɤɥɸɱɟɧɢɣ C++, ɧɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟ-
ɤɚɬɶ ɪɚɫɩɪɨɫɬɪɚɧɹɬɶɫɹ ɦɟɠɞɭ ɞɜɭɦɹ ɱɚɫɬɹɦɢ ɤɨɞɚ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ ɜ ɫɨɫɬɨɹɧɢɢ ɤɨɧ-
ɬɪɨɥɢɪɨɜɚɬɶ, ɤɚɤɢɦ ɤɨɦɩɢɥɹɬɨɪɨɦ ɢ ɫ ɤɚɤɢɦɢ ɨɩɰɢɹɦɢ ɫɤɨɦɩɢɥɢɪɨɜɚɧɵ ɨɛɟ ɷɬɢ ɱɚɫɬɢ ɤɨ-
ɞɚ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ, ɱɬɨ ɦɨɞɭɥɢ ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɬ ɫɨɜɦɟɫɬɢɦɵɟ ɪɟɚ-
ɥɢɡɚɰɢɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɹ ɢɫɤɥɸɱɟɧɢɣ. Ɉɛɵɱɧɨ ɷɬɨ ɩɪɚɜɢɥɨ ɫɜɨɞɢɬɫɹ ɤ ɫɥɟɞɭɸɳɟɦɭ: ɧɟ ɩɨ-
ɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟɤɚɬɶ ɝɪɚɧɢɰɵ ɦɨɞɭɥɟɣ/ɩɨɞɫɢɫɬɟɦ.
63. ɂɫɩɨɥɶɡɭɣɬɟ ɞɨɫɬɚɬɨɱɧɨ ɩɟɪɟɧɨɫɢɦɵɟ ɬɢɩɵ ɜ ɢɧɬɟɪɮɟɣɫɚɯ ɦɨɞɭɥɟɣ
ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɬɢɩɚɦ ɩɨɹɜɥɹɬɶɫɹ ɜɨ ɜɧɟɲɧɟɦ ɢɧɬɟɪɮɟɣɫɟ ɦɨɞɭɥɹ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɵ ɧɟ ɭɜɟ-
ɪɟɧɵ ɜ ɬɨɦ, ɱɬɨ ɜɫɟ ɩɨɥɶɡɨɜɚɬɟɥɢ ɫɦɨɝɭɬ ɤɨɪɪɟɤɬɧɨ ɢɯ ɩɨɧɹɬɶ ɢ ɪɚɛɨɬɚɬɶ ɫ ɧɢɦɢ. ɂɫɩɨɥɶ-
ɡɭɣɬɟ ɧɚɢɜɵɫɲɢɣ ɭɪɨɜɟɧɶ ɚɛɫɬɪɚɤɰɢɢ, ɤɨɬɨɪɵɣ ɜ ɫɨɫɬɨɹɧɢɢ ɩɨɧɹɬɶ ɤɥɢɟɧɬɫɤɢɣ ɤɨɞ.
Стр. 213
Шаблоны и обобщенность
64. Ɋɚɡɭɦɧɨ ɫɨɱɟɬɚɣɬɟ ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ
ɋɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɨɩɨɥɧɹɸɬ ɞɪɭɝ ɞɪɭɝɚ. ɋɥɟɞɭɟɬ ɹɫɧɨ ɩɪɟɞ-
ɫɬɚɜɥɹɬɶ ɫɟɛɟ ɢɯ ɩɪɟɢɦɭɳɟɫɬɜɚ ɢ ɧɟɞɨɫɬɚɬɤɢ, ɱɬɨɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɠɞɵɣ ɢɡ ɧɢɯ ɬɚɦ, ɝɞɟ
ɨɧ ɞɚɟɬ ɧɚɢɥɭɱɲɢɟ ɪɟɡɭɥɶɬɚɬɵ, ɢ ɫɨɱɟɬɚɬɶ ɢɯ ɬɚɤ, ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɥɭɱɲɟɟ ɢɡ ɨɛɨɢɯ ɦɢɪɨɜ.
65. ȼɵɩɨɥɧɹɣɬɟ ɧɚɫɬɪɨɣɤɭ ɹɜɧɨ ɢ ɩɪɟɞɧɚɦɟɪɟɧɧɨ
ɉɪɢ ɪɚɡɪɚɛɨɬɤɟ ɲɚɛɥɨɧɚ ɬɨɱɤɢ ɧɚɫɬɪɨɣɤɢ ɞɨɥɠɧɵ ɛɵɬɶ ɧɚɩɢɫɚɧɵ ɤɨɪɪɟɤɬɧɨ, ɫ ɨɫɨɛɨɣ
ɬɳɚɬɟɥɶɧɨɫɬɶɸ, ɚ ɬɚɤɠɟ ɹɫɧɨ ɩɪɨɤɨɦɦɟɧɬɢɪɨɜɚɧɵ. ɉɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɲɚɛɥɨɧɚ ɧɟɨɛɯɨ-
ɞɢɦɨ ɱɟɬɤɨ ɡɧɚɬɶ, ɤɚɤ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɧɚɫɬɪɨɢɬɶ ɲɚɛɥɨɧ ɞɥɹ ɪɚɛɨɬɵ ɫ ɜɚɲɢɦ ɬɢɩɨɦ, ɢ
ɜɵɩɨɥɧɢɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɞɟɣɫɬɜɢɹ.
66. ɇɟ ɫɩɟɰɢɚɥɢɡɢɪɭɣɬɟ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ
ɉɪɢ ɪɚɫɲɢɪɟɧɢɢ ɧɟɤɨɬɨɪɨɝɨ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ (ɜɤɥɸɱɚɹ std::swap) ɢɡɛɟɝɚɣɬɟ ɩɨɩɵɬɨɤ
ɫɩɟɰɢɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɚ. ȼɦɟɫɬɨ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɣɬɟ ɩɟɪɟɝɪɭɡɤɭ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɭɸ
ɫɥɟɞɭɟɬ ɩɨɦɟɫɬɢɬɶ ɜ ɩɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ ɬɢɩɚ(ɨɜ), ɞɥɹ ɤɨɬɨɪɵɯ ɪɚɡɪɚɛɨɬɚɧɚ ɞɚɧɧɚɹ ɩɟɪɟ-
ɝɪɭɡɤɚ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ɉɪɢ ɧɚɩɢɫɚɧɢɢ ɫɨɛɫɬɜɟɧɧɨɝɨ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ ɬɚɤɠɟ ɢɡɛɟ-
ɝɚɣɬɟ ɟɝɨ ɫɩɟɰɢɚɥɢɡɚɰɢɢ.
67. ɉɢɲɢɬɟ ɦɚɤɫɢɦɚɥɶɧɨ ɨɛɨɛɳɟɧɧɵɣ ɤɨɞ
ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɢ ɧɚɢɛɨɥɟɟ ɨɛɨɛɳɟɧɧɵɟ ɢ ɚɛɫɬɪɚɤɬɧɵɟ
ɫɪɟɞɫɬɜɚ.
Обработка ошибок и исключения

68. ɒɢɪɨɤɨ ɩɪɢɦɟɧɹɣɬɟ assert ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ ɜɧɭɬɪɟɧɧɢɯ ɞɨɩɭɳɟɧɢɣ
ɢ ɢɧɜɚɪɢɚɧɬɨɜ
ɂɫɩɨɥɶɡɭɣɬɟ assert ɢɥɢ ɟɝɨ ɷɤɜɢɜɚɥɟɧɬ ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ ɜɧɭɬɪɟɧɧɢɯ ɞɨɩɭɳɟɧɢɣ
ɜ ɦɨɞɭɥɟ (ɬ.ɟ. ɬɚɦ, ɝɞɟ ɜɵɡɵɜɚɟɦɵɣ ɢ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɩɨɞɞɟɪɠɢɜɚɸɬɫɹ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ
ɩɪɨɝɪɚɦɦɢɫɬɨɦ ɢɥɢ ɤɨɦɚɧɞɨɣ), ɤɨɬɨɪɵɟ ɞɨɥɠɧɵ ɜɫɟɝɞɚ ɜɵɩɨɥɧɹɬɶɫɹ (ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ
ɨɧɢ ɹɜɥɹɸɬɫɹ ɫɥɟɞɫɬɜɢɟɦ ɩɪɨɝɪɚɦɦɧɨɣ ɨɲɢɛɤɢ; ɧɚɩɪɢɦɟɪ, ɧɚɪɭɲɟɧɢɟ ɩɨɫɬɭɫɥɨɜɢɣ ɮɭɧɤɰɢɢ,
ɨɛɧɚɪɭɠɟɧɧɨɟ ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ). (ɋɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 70.) ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɢɫɩɨɥɶ-
ɡɨɜɚɧɢɟ assert ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɩɨɛɨɱɧɵɦ ɞɟɣɫɬɜɢɹɦ.
69. Ɉɩɪɟɞɟɥɢɬɟ ɪɚɡɭɦɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɟɣ ɫɥɟɞɭɣɬɟ
ȿɳɟ ɧɚ ɪɚɧɧɟɣ ɫɬɚɞɢɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɪɚɡɪɚɛɨɬɚɣɬɟ ɩɪɚɤɬɢɱɧɭɸ, ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɭɸ ɢ
ɪɚɡɭɦɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɫɥɟɞɭɣɬɟ ɟɣ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɚɲɚ ɫɬɪɚ-
ɬɟɝɢɹ ɜɤɥɸɱɚɟɬ ɫɥɟɞɭɸɳɟɟ.
• ɂɞɟɧɬɢɮɢɤɚɰɢɹ: ɤɚɤɢɟ ɭɫɥɨɜɢɹ ɹɜɥɹɸɬɫɹ ɨɲɢɛɤɨɣ.
• ɋɬɪɨɝɨɫɬɶ: ɧɚɫɤɨɥɶɤɨ ɜɚɠɧɚ ɤɚɠɞɚɹ ɨɲɢɛɤɚ.
• Ɉɛɧɚɪɭɠɟɧɢɟ: ɤɚɤɨɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɡɚ ɨɛɧɚɪɭɠɟɧɢɟ ɨɲɢɛɤɢ.
• Ɋɚɫɩɪɨɫɬɪɚɧɟɧɢɟ: ɤɚɤɨɣ ɦɟɯɚɧɢɡɦ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɨɩɢɫɚɧɢɹ ɢ ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɹ
ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɟ ɜ ɤɚɠɞɨɦ ɦɨɞɭɥɟ.
• Ɉɛɪɚɛɨɬɤɚ: ɤɚɤɨɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɡɚ ɜɵɩɨɥɧɟɧɢɟ ɞɟɣɫɬɜɢɣ, ɫɜɹɡɚɧɧɵɯ ɫ ɨɲɢɛɤɨɣ.
• ɍɜɟɞɨɦɥɟɧɢɟ: ɤɚɤɢɦ ɨɛɪɚɡɨɦ ɢɧɮɨɪɦɚɰɢɹ ɨɛ ɨɲɢɛɤɟ ɜɧɨɫɢɬɫɹ ɜ ɠɭɪɧɚɥɶɧɵɣ ɮɚɣɥ
ɢɥɢ ɩɪɨɢɡɜɨɞɢɬɫɹ ɭɜɟɞɨɦɥɟɧɢɟ ɩɨɥɶɡɨɜɚɬɟɥɹ ɩɪɨɝɪɚɦɦɵ.
ɂɡɦɟɧɹɣɬɟ ɦɟɯɚɧɢɡɦɵ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɬɨɥɶɤɨ ɜ ɩɪɟɞɟɥɚɯ ɝɪɚɧɢɰ ɦɨɞɭɥɹ.
Стр. 214
70. Ɉɬɥɢɱɚɣɬɟ ɨɲɢɛɤɢ ɨɬ ɫɢɬɭɚɰɢɣ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ ɨɲɢɛɤɚɦɢ
Ɏɭɧɤɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɟɞɢɧɢɰɭ ɪɚɛɨɬɵ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɫɛɨɢ ɫɥɟɞɭɟɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶ
ɥɢɛɨ ɤɚɤ ɨɲɢɛɤɢ, ɥɢɛɨ ɤɚɤ ɲɬɚɬɧɵɟ ɫɢɬɭɚɰɢɢ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɢɯ ɜɥɢɹɧɢɹ ɧɚ ɮɭɧɤɰɢɢ. ȼ ɮɭɧɤ-
ɰɢɢ f ɫɛɨɣ ɹɜɥɹɟɬɫɹ ɨɲɢɛɤɨɣ ɬɨɝɞɚ ɢ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɨɧ ɧɚɪɭɲɚɟɬ ɨɞɧɨ ɢɡ ɩɪɟɞɭɫɥɨɜɢɣ f, ɧɟ
ɩɨɡɜɨɥɹɟɬ ɜɵɩɨɥɧɢɬɶ ɩɪɟɞɭɫɥɨɜɢɟ ɜɵɡɵɜɚɟɦɨɣ ɟɸ ɮɭɧɤɰɢɢ, ɩɪɟɩɹɬɫɬɜɭɟɬ ɞɨɫɬɢɠɟɧɢɸ ɫɨɛɫɬ-
ɜɟɧɧɵɯ ɩɨɫɬɭɫɥɨɜɢɣ f ɢɥɢ ɫɨɯɪɚɧɟɧɢɸ ɢɧɜɚɪɢɚɧɬɚ, ɡɚ ɩɨɞɞɟɪɠɤɭ ɤɨɬɨɪɨɝɨ ɨɬɜɟɱɚɟɬ ɮɭɧɤɰɢɹ f.
ȼ ɱɚɫɬɧɨɫɬɢ, ɜ ɷɬɨɣ ɪɟɤɨɦɟɧɞɚɰɢɢ ɦɵ ɢɫɤɥɸɱɚɟɦ ɜɧɭɬɪɟɧɧɢɟ ɩɪɨɝɪɚɦɦɧɵɟ ɨɲɢɛɤɢ (ɬ.ɟ. ɬɟ,
ɝɞɟ ɡɚ ɜɵɡɵɜɚɸɳɢɣ ɢ ɜɵɡɵɜɚɟɦɵɣ ɤɨɞ ɨɬɜɟɱɚɟɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɱɟɥɨɜɟɤ ɢɥɢ ɤɨɦɚɧɞɚ, — ɧɚɩɪɢ-
ɦɟɪ, ɜ ɩɪɟɞɟɥɚɯ ɨɞɧɨɝɨ ɦɨɞɭɥɹ). Ɉɧɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɨɬɞɟɥɶɧɭɸ ɤɚɬɟɝɨɪɢɸ ɨɲɢɛɨɤ, ɞɥɹ ɪɚ-
ɛɨɬɵ ɫ ɤɨɬɨɪɨɣ ɢɫɩɨɥɶɡɭɟɬɫɹ ɬɚɤɨɟ ɫɪɟɞɫɬɜɨ, ɤɚɤ ɩɪɨɜɟɪɤɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 68).
71. ɉɪɨɟɤɬɢɪɭɣɬɟ ɢ ɩɢɲɢɬɟ ɛɟɡɨɩɚɫɧɵɣ ɜ ɨɬɧɨɲɟɧɢɢ ɨɲɢɛɨɤ ɤɨɞ
ȼ ɤɚɠɞɨɣ ɮɭɧɤɰɢɢ ɨɛɟɫɩɟɱɢɜɚɣɬɟ ɧɚɢɛɨɥɟɟ ɫɬɪɨɝɭɸ ɝɚɪɚɧɬɢɸ ɛɟɡɨɩɚɫɧɨɫɬɢ, ɤɚɤɨɣ
ɬɨɥɶɤɨ ɦɨɠɧɨ ɞɨɛɢɬɶɫɹ ɛɟɡ ɞɨɩɨɥɧɢɬɟɥɶɧɵɯ ɡɚɬɪɚɬ ɫɨ ɫɬɨɪɨɧɵ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ, ɧɟ
ɬɪɟɛɭɸɳɟɝɨ ɬɚɤɨɝɨ ɭɪɨɜɧɹ ɝɚɪɚɧɬɢɢ. ȼɫɟɝɞɚ ɨɛɟɫɩɟɱɢɜɚɣɬɟ, ɤɚɤ ɦɢɧɢɦɭɦ, ɛɚɡɨɜɭɸ ɝɚɪɚɧ-
ɬɢɸ ɛɟɡɨɩɚɫɧɨɫɬɢ.
ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɩɪɢ ɥɸɛɵɯ ɨɲɢɛɤɚɯ ɜɚɲɚ ɩɪɨɝɪɚɦɦɚ ɜɫɟɝɞɚ ɨɫɬɚɟɬɫɹ ɜ ɤɨɪɪɟɤɬɧɨɦ ɫɨ-
ɫɬɨɹɧɢɢ (ɜ ɷɬɨɦ ɢ ɡɚɤɥɸɱɚɟɬɫɹ ɛɚɡɨɜɚɹ ɝɚɪɚɧɬɢɹ). Ɉɫɬɟɪɟɝɚɣɬɟɫɶ ɨɲɢɛɨɤ, ɧɚɪɭɲɚɸɳɢɯ
ɢɧɜɚɪɢɚɧɬ (ɜɤɥɸɱɚɹ ɭɬɟɱɤɢ, ɧɨ ɧɟ ɨɝɪɚɧɢɱɢɜɚɹɫɶ ɢɦɢ).
ɀɟɥɚɬɟɥɶɧɨ ɞɨɩɨɥɧɢɬɟɥɶɧɨ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɤɨɧɟɱɧɨɟ ɫɨɫɬɨɹɧɢɟ ɥɢɛɨ ɹɜɥɹɟɬɫɹ ɢɫ-
ɯɨɞɧɵɦ ɫɨɫɬɨɹɧɢɟɦ (ɜ ɪɟɡɭɥɶɬɚɬɟ ɨɬɤɚɬɚ ɩɨɫɥɟ ɩɪɨɢɫɲɟɞɲɟɣ ɨɲɢɛɤɢ), ɥɢɛɨ ɤɨɪɪɟɤɬɧɨ
ɜɵɱɢɫɥɟɧɧɵɦ ɰɟɥɟɜɵɦ ɫɨɫɬɨɹɧɢɟɦ (ɟɫɥɢ ɨɲɢɛɨɤ ɧɟ ɛɵɥɨ). ɗɬɨ — ɫɬɪɨɝɚɹ ɝɚɪɚɧɬɢɹ ɛɟɡɨ-
ɩɚɫɧɨɫɬɢ.
ȿɳɟ ɥɭɱɲɟ ɝɚɪɚɧɬɢɪɨɜɚɬɶ, ɱɬɨ ɫɛɨɣ ɜ ɩɪɨɰɟɫɫɟ ɨɩɟɪɚɰɢɢ ɧɟɜɨɡɦɨɠɟɧ. ɏɨɬɹ ɞɥɹ ɛɨɥɶ-
ɲɢɧɫɬɜɚ ɮɭɧɤɰɢɣ ɷɬɨ ɧɟɜɨɡɦɨɠɧɨ, ɬɚɤɭɸ ɝɚɪɚɧɬɢɸ ɫɥɟɞɭɟɬ ɨɛɟɫɩɟɱɢɬɶ ɞɥɹ ɬɚɤɢɯ ɮɭɧɤ-
ɰɢɣ, ɤɚɤ ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ. Ⱦɚɧɧɚɹ ɝɚɪɚɧɬɢɹ — ɝɚɪɚɧɬɢɹ ɛɟɫ-
ɫɛɨɣɧɨɫɬɢ.
72. Ⱦɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ
Ⱦɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɦɟɯɚɧɢɡɦ ɢɫɤɥɸɱɟɧɢɣ, ɚ ɧɟ ɤɨɞɵ ɨɲɢ-
ɛɨɤ. ɉɪɢɦɟɧɹɬɶ ɤɨɞɵ ɫɨɫɬɨɹɧɢɹ (ɧɚɩɪɢɦɟɪ, ɤɨɞɵ ɨɲɢɛɨɤ, ɩɟɪɟɦɟɧɧɭɸ errno) ɫɥɟɞɭɟɬ ɬɨɥɶ-
ɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɧɟɥɶɡɹ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 62), ɚ ɬɚɤɠɟ ɞɥɹ ɫɢɬɭɚ-
ɰɢɣ, ɤɨɬɨɪɵɟ ɧɟ ɹɜɥɹɸɬɫɹ ɨɲɢɛɤɚɦɢ. Ʉ ɞɪɭɝɢɦ ɦɟɬɨɞɚɦ, ɬɚɤɢɦ ɤɚɤ ɷɤɫɬɪɟɧɧɨɟ ɡɚɜɟɪɲɟɧɢɟ
ɩɪɨɝɪɚɦɦɵ (ɢɥɢ ɩɥɚɧɨɜɨɟ ɡɚɜɟɪɲɟɧɢɟ ɫ ɨɫɜɨɛɨɠɞɟɧɢɟɦ ɪɟɫɭɪɫɨɜ ɢ ɬ.ɩ. ɞɟɣɫɬɜɢɹɦɢ), ɫɥɟɞɭɟɬ
ɩɪɢɛɟɝɚɬɶ ɬɨɥɶɤɨ ɜ ɫɢɬɭɚɰɢɹɯ, ɤɨɝɞɚ ɜɨɫɫɬɚɧɨɜɥɟɧɢɟ ɩɨɫɥɟ ɨɲɢɛɤɢ ɧɟɜɨɡɦɨɠɧɨ (ɢɥɢ ɧɟ
ɬɪɟɛɭɟɬɫɹ).
73. Ƚɟɧɟɪɢɪɭɣɬɟ ɢɫɤɥɸɱɟɧɢɹ ɩɨ ɡɧɚɱɟɧɢɸ, ɩɟɪɟɯɜɚɬɵɜɚɣɬɟ — ɩɨ ɫɫɵɥɤɟ
Ƚɟɧɟɪɢɪɭɣɬɟ ɢɫɤɥɸɱɟɧɢɹ ɩɨ ɡɧɚɱɟɧɢɸ (ɧɟ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɶ) ɢ ɩɟɪɟɯɜɚɬɵɜɚɣɬɟ ɢɯ ɤɚɤ
ɫɫɵɥɤɢ (ɨɛɵɱɧɨ ɤɨɧɫɬɚɧɬɧɵɟ). ɗɬɚ ɤɨɦɛɢɧɚɰɢɹ ɧɚɢɥɭɱɲɢɦ ɨɛɪɚɡɨɦ ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɫɟ-
ɦɚɧɬɢɤɟ ɢɫɤɥɸɱɟɧɢɣ. ɉɪɢ ɩɨɜɬɨɪɧɨɣ ɝɟɧɟɪɚɰɢɢ ɩɟɪɟɯɜɚɱɟɧɧɨɝɨ ɢɫɤɥɸɱɟɧɢɹ ɩɪɟɞɩɨɱɬɢɬɟɥɶ-
ɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɨɫɬɨ ɨɩɟɪɚɬɨɪ throw;, ɚ ɧɟ ɢɧɫɬɪɭɤɰɢɸ throw e;.
74. ɍɜɟɞɨɦɥɹɣɬɟ ɨɛ ɨɲɢɛɤɚɯ, ɨɛɪɚɛɚɬɵɜɚɣɬɟ ɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɢɯ ɬɚɦ, ɝɞɟ
ɫɥɟɞɭɟɬ
ɋɨɨɛɳɚɣɬɟ ɨɛ ɨɲɢɛɤɚɯ ɜ ɬɨɬ ɦɨɦɟɧɬ, ɤɨɝɞɚ ɨɧɢ ɨɛɧɚɪɭɠɟɧɵ ɢ ɢɞɟɧɬɢɮɢɰɢɪɨɜɚɧɵ ɤɚɤ
ɨɲɢɛɤɢ. Ɉɛɪɚɛɚɬɵɜɚɣɬɟ ɢɥɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɢɯ ɧɚ ɫɚɦɨɦ ɧɢɠɧɟɦ ɭɪɨɜɧɟ, ɧɚ ɤɨɬɨɪɨɦ
ɷɬɨ ɦɨɠɧɨ ɫɞɟɥɚɬɶ ɤɨɪɪɟɤɬɧɨ.
Стр. 215
75. ɂɡɛɟɝɚɣɬɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ
ɇɟ ɩɢɲɢɬɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ ɭ ɜɚɲɢɯ ɮɭɧɤɰɢɣ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɚɫ ɧɟ ɡɚɫɬɚɜɥɹɸɬ
ɷɬɨ ɞɟɥɚɬɶ ɜɧɟɲɧɢɟ ɨɛɫɬɨɹɬɟɥɶɫɬɜɚ (ɧɚɩɪɢɦɟɪ, ɤɨɞ, ɤɨɬɨɪɵɣ ɜɵ ɧɟ ɦɨɠɟɬɟ ɢɡɦɟɧɢɬɶ,
ɭɠɟ ɜɜɟɥ ɢɯ; ɫɦ. ɢɫɤɥɸɱɟɧɢɹ ɤ ɞɚɧɧɨɦɭ ɪɚɡɞɟɥɭ).
STL: Контейнеры
76. ɉɨ ɭɦɨɥɱɚɧɢɸ ɢɫɩɨɥɶɡɭɣɬɟ vector. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɛɢɪɚɣɬɟ ɤɨɧɬɟɣɧɟɪ,
ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɡɚɞɚɱɟ
Ɉɱɟɧɶ ɜɚɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ “ɩɪɚɜɢɥɶɧɵɣ ɤɨɧɬɟɣɧɟɪ”. ȿɫɥɢ ɭ ɜɚɫ ɟɫɬɶ ɜɟɫɨɦɵɟ ɩɪɢɱɢɧɵ
ɜɵɛɪɚɬɶ ɨɩɪɟɞɟɥɟɧɧɵɣ ɬɢɩ ɤɨɧɬɟɣɧɟɪɚ, ɢɫɩɨɥɶɡɭɣɬɟ ɬɨɬ ɤɨɧɬɟɣɧɟɪ, ɤɨɬɨɪɵɣ ɧɚɢɛɨɥɟɟ
ɩɨɞɯɨɞɢɬ ɞɥɹ ɜɚɲɟɣ ɡɚɞɚɱɢ.
ȿɫɥɢ ɤɨɧɤɪɟɬɧɵɯ ɩɪɟɞɩɨɱɬɟɧɢɣ ɧɟɬ, ɜɨɡɶɦɢɬɟ vector ɢ ɫɩɨɤɨɣɧɨ ɪɚɛɨɬɚɣɬɟ, ɡɧɚɹ, ɱɬɨ
ɜɵ ɫɞɟɥɚɥɢ ɜɟɪɧɵɣ ɜɵɛɨɪ.
77. ȼɦɟɫɬɨ ɦɚɫɫɢɜɨɜ ɢɫɩɨɥɶɡɭɣɬɟ vector ɢ string
ɂɡɛɟɝɚɣɬɟ ɪɟɚɥɢɡɚɰɢɢ ɚɛɫɬɪɚɤɰɢɢ ɦɚɫɫɢɜɚ ɩɨɫɪɟɞɫɬɜɨɦ ɦɚɫɫɢɜɨɜ ɜ ɫɬɢɥɟ C, ɚɪɢɮɦɟɬɢ-
ɤɢ ɭɤɚɡɚɬɟɥɟɣ ɢ ɩɪɢɦɢɬɢɜɨɜ ɭɩɪɚɜɥɟɧɢɹ ɩɚɦɹɬɶɸ. ɂɫɩɨɥɶɡɨɜɚɧɢɟ vector ɢɥɢ string ɧɟ ɬɨɥɶɤɨ
ɫɞɟɥɚɟɬ ɩɪɨɳɟ ɜɚɲɭ ɠɢɡɧɶ, ɧɨ ɢ ɩɨɡɜɨɥɢɬ ɧɚɩɢɫɚɬɶ ɛɨɥɟɟ ɛɟɡɨɩɚɫɧɭɸ ɢ ɦɚɫɲɬɚɛɢɪɭɟɦɭɸ
ɩɪɨɝɪɚɦɦɭ.
78. ɂɫɩɨɥɶɡɭɣɬɟ vector (ɢ string::c_str) ɞɥɹ ɨɛɦɟɧɚ ɞɚɧɧɵɦɢ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ
vector ɢ string::c_str ɫɥɭɠɚɬ ɲɥɸɡɨɦ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ. Ɉɞɧɚɤɨ ɧɟ
ɩɨɥɚɝɚɣɬɟɫɶ ɧɚ ɬɨ, ɱɬɨ ɢɬɟɪɚɬɨɪɵ ɹɜɥɹɸɬɫɹ ɭɤɚɡɚɬɟɥɹɦɢ; ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɚɞɪɟɫɚ ɷɥɟɦɟɧɬɚ,
ɧɚ ɤɨɬɨɪɵɣ ɫɫɵɥɚɟɬɫɹ vector<T>::iterator iter, ɢɫɩɨɥɶɡɭɣɬɟ ɜɵɪɚɠɟɧɢɟ &*iter.
79. ɏɪɚɧɢɬɟ ɜ ɤɨɧɬɟɣɧɟɪɚɯ ɬɨɥɶɤɨ ɡɧɚɱɟɧɢɹ ɢɥɢ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ
ɏɪɚɧɢɬɟ ɤ ɤɨɧɬɟɣɧɟɪɚɯ ɨɛɴɟɤɬɵ-ɡɧɚɱɟɧɢɹ. Ʉɨɧɬɟɣɧɟɪɵ ɩɨɥɚɝɚɸɬ, ɱɬɨ ɢɯ ɫɨɞɟɪɠɢɦɨɟ
ɢɦɟɟɬ ɬɢɩ ɡɧɚɱɟɧɢɹ, ɜɤɥɸɱɚɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɯɪɚɧɹɳɢɟɫɹ ɡɧɚɱɟɧɢɹ, ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ
ɭɤɚɡɚɬɟɥɢ ɢ ɢɬɟɪɚɬɨɪɵ.
80. ɉɪɟɞɩɨɱɢɬɚɣɬɟ push_back ɞɪɭɝɢɦ ɫɩɨɫɨɛɚɦ ɪɚɫɲɢɪɟɧɢɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ
ɂɫɩɨɥɶɡɭɣɬɟ push_back ɜɟɡɞɟ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ. ȿɫɥɢ ɞɥɹ ɜɚɫ ɧɟ ɜɚɠɧɚ ɩɨɡɢɰɢɹ ɜɫɬɚɜɤɢ
ɧɨɜɨɝɨ ɨɛɴɟɤɬɚ, ɥɭɱɲɟ ɜɫɟɝɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɞɨɛɚɜɥɟɧɢɹ ɷɥɟɦɟɧɬɚ ɜ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ
ɮɭɧɤɰɢɸ push_back. ȼɫɟ ɩɪɨɱɢɟ ɫɪɟɞɫɬɜɚ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɤɚɤ ɝɨɪɚɡɞɨ ɦɟɧɟɟ ɛɵɫɬɪɵɦɢ,
ɬɚɤ ɢ ɦɟɧɟɟ ɩɨɧɹɬɧɵɦɢ.
81. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɩɟɪɚɰɢɢ ɫ ɞɢɚɩɚɡɨɧɚɦɢ ɨɩɟɪɚɰɢɹɦ ɫ ɨɬɞɟɥɶɧɵɦɢ ɷɥɟɦɟɧɬɚɦɢ
ɉɪɢ ɞɨɛɚɜɥɟɧɢɢ ɷɥɟɦɟɧɬɨɜ ɜ ɤɨɧɬɟɣɧɟɪ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɩɟɪɚɰɢɢ ɫ ɞɢɚɩɚɡɨɧɚɦɢ
(ɬ.ɟ. ɮɭɧɤɰɢɸ insert, ɤɨɬɨɪɚɹ ɩɨɥɭɱɚɟɬ ɩɚɪɭ ɢɬɟɪɚɬɨɪɨɜ), ɚ ɧɟ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɜɵɡɨɜɨɜ
ɮɭɧɤɰɢɢ ɞɥɹ ɜɫɬɚɜɤɢ ɨɞɧɨɝɨ ɷɥɟɦɟɧɬɚ. ȼɵɡɨɜ ɮɭɧɤɰɢɢ ɞɥɹ ɞɢɚɩɚɡɨɧɚ ɨɛɵɱɧɨ ɩɪɨɳɟ ɧɚɩɢ-
ɫɚɬɶ, ɥɟɝɱɟ ɱɢɬɚɬɶ, ɢ ɨɧ ɛɨɥɟɟ ɷɮɮɟɤɬɢɜɟɧ, ɱɟɦ ɹɜɧɵɣ ɰɢɤɥ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 84).
82. ɂɫɩɨɥɶɡɭɣɬɟ ɩɨɞɯɨɞɹɳɢɟ ɢɞɢɨɦɵ ɞɥɹ ɪɟɚɥɶɧɨɝɨ ɭɦɟɧɶɲɟɧɢɹ ɟɦɤɨɫɬɢ
ɤɨɧɬɟɣɧɟɪɚ ɢ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ
Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɢɡɛɚɜɢɬɶɫɹ ɨɬ ɢɡɥɢɲɧɟɣ ɟɦɤɨɫɬɢ ɤɨɧɬɟɣɧɟɪɚ, ɜɨɫɩɨɥɶ-
ɡɭɣɬɟɫɶ ɬɪɸɤɨɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɛɦɟɧɚ, ɚ ɞɥɹ ɪɟɚɥɶɧɨɝɨ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ ɢɡ ɤɨɧɬɟɣɧɟ-
ɪɚ — ɢɞɢɨɦɨɣ erase-remove.
Стр. 216
STL: алгоритмы
83. ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ STL
Ȼɟɡɨɩɚɫɧɨɫɬɶ ɩɪɟɜɵɲɟ ɜɫɟɝɨ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 6). ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ
STL, ɞɚɠɟ ɟɫɥɢ ɨɧɚ ɢɦɟɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɨɞɧɨɝɨ ɢɡ ɜɚɲɢɯ ɤɨɦɩɢɥɹɬɨɪɨɜ, ɢ ɞɚɠɟ ɟɫɥɢ ɨɧɚ ɢɫ-
ɩɨɥɶɡɭɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɨɬɥɚɞɨɱɧɨɝɨ ɬɟɫɬɢɪɨɜɚɧɢɹ.
84. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɜɵɡɨɜɵ ɚɥɝɨɪɢɬɦɨɜ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɪɚɡɪɚɛɚɬɵɜɚɟɦɵɦ ɰɢɤɥɚɦ
Ɋɚɡɭɦɧɨ ɢɫɩɨɥɶɡɭɣɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ. ȼ ɨɱɟɧɶ ɩɪɨɫɬɵɯ ɫɥɭɱɚɹɯ ɧɚɩɢɫɚɧɧɵɟ
ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɰɢɤɥɵ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɛɨɥɟɟ ɩɪɨɫɬɵɦ ɢ ɷɮɮɟɤɬɢɜɧɵɦ ɪɟɲɟɧɢɟɦ. Ɍɟɦ ɧɟ
ɦɟɧɟɟ, ɜɵɡɨɜ ɚɥɝɨɪɢɬɦɚ ɜɦɟɫɬɨ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɪɚɡɪɚɛɨɬɚɧɧɨɝɨ ɰɢɤɥɚ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ
ɛɨɥɟɟ ɜɵɪɚɡɢɬɟɥɶɧɵɦ, ɥɟɝɱɟ ɫɨɩɪɨɜɨɠɞɚɟɦɵɦ, ɦɟɧɟɟ ɩɨɞɜɟɪɠɟɧɧɵɦ ɨɲɢɛɤɚɦ ɢ ɧɟ ɦɟɧɟɟ
ɷɮɮɟɤɬɢɜɧɵɦ.
ɉɪɢ ɜɵɡɨɜɟ ɚɥɝɨɪɢɬɦɚ ɩɨɞɭɦɚɣɬɟ ɨ ɧɚɩɢɫɚɧɢɢ ɫɨɛɫɬɜɟɧɧɨɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɝɨ ɨɛɴɟɤɬɚ,
ɤɨɬɨɪɵɣ ɢɧɤɚɩɫɭɥɢɪɭɟɬ ɜɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɥɨɝɢɤɭ. ɂɡɛɟɝɚɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɫɜɹɡɵɜɚɬɟɥɟɣ ɩɚ-
ɪɚɦɟɬɪɨɜ ɢ ɩɪɨɫɬɵɯ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ (ɧɚɩɪɢɦɟɪ, bind2nd, plus), ɱɬɨ ɨɛɵɱɧɨ ɫɧɢ-
ɠɚɟɬ ɹɫɧɨɫɬɶ ɤɨɞɚ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɥɹɦɛɞɚ-ɛɢɛɥɢɨɬɟɤɢ [Boost], ɤɨɬɨɪɚɹ ɚɜ-
ɬɨɦɚɬɢɡɢɪɭɟɬ ɡɚɞɚɱɭ ɧɚɩɢɫɚɧɢɹ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ.
85. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɩɨɢɫɤɚ
Ⱦɚɧɧɚɹ ɪɟɤɨɦɟɧɞɚɰɢɹ ɩɪɢɦɟɧɢɦɚ ɤ ɩɨɢɫɤɭ ɨɩɪɟɞɟɥɟɧɧɨɝɨ ɡɧɚɱɟɧɢɹ ɜ ɞɢɚɩɚɡɨɧɟ. ɉɪɢ ɩɨɢɫ-
ɤɟ ɜ ɧɟɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɞɢɚɩɚɡɨɧɟ ɢɫɩɨɥɶɡɭɣɬɟ ɚɥɝɨɪɢɬɦɵ find/find_if ɢɥɢ count/count_if.
Ⱦɥɹ ɩɨɢɫɤɚ ɜ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɞɢɚɩɚɡɨɧɟ ɜɵɛɟɪɢɬɟ lower_bound, upper_bound, equal_ range
ɢɥɢ (ɪɟɠɟ) binary_search. (ȼɨɩɪɟɤɢ ɫɜɨɟɦɭ ɢɦɟɧɢ, binary_search ɨɛɵɱɧɨ — ɧɟɜɟɪɧɵɣ ɜɵɛɨɪ.)
86. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɫɨɪɬɢɪɨɜɤɢ
ɉɪɢ ɫɨɪɬɢɪɨɜɤɟ ɜɵ ɞɨɥɠɧɵ ɱɟɬɤɨ ɩɨɧɢɦɚɬɶ, ɤɚɤ ɪɚɛɨɬɚɟɬ ɤɚɠɞɵɣ ɢɡ ɫɨɪɬɢɪɭɸɳɢɯ
ɚɥɝɨɪɢɬɦɨɜ, ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɧɚɢɛɨɥɟɟ ɞɟɲɟɜɵɣ ɫɪɟɞɢ ɬɟɯ, ɤɨɬɨɪɵɟ ɩɪɢɝɨɞɧɵ ɞɥɹ ɪɟɲɟɧɢɹ
ɜɚɲɟɣ ɡɚɞɚɱɢ.
87. Ⱦɟɥɚɣɬɟ ɩɪɟɞɢɤɚɬɵ ɱɢɫɬɵɦɢ ɮɭɧɤɰɢɹɦɢ
ɉɪɟɞɢɤɚɬ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ ɨɬɜɟɬ ɞɚ/
ɧɟɬ, ɨɛɵɱɧɨ ɜ ɜɢɞɟ ɡɧɚɱɟɧɢɹ ɬɢɩɚ bool. Ɏɭɧɤɰɢɹ ɹɜɥɹɟɬɫɹ “ɱɢɫɬɨɣ” ɜ ɦɚɬɟɦɚɬɢɱɟɫɤɨɦ ɫɦɵɫ-
ɥɟ, ɟɫɥɢ ɟɟ ɪɟɡɭɥɶɬɚɬ ɡɚɜɢɫɢɬ ɬɨɥɶɤɨ ɨɬ ɟɟ ɚɪɝɭɦɟɧɬɨɜ (ɨɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ — ɜ ɞɚɧɧɨɦ ɫɥɭ-
ɱɚɟ ɬɟɪɦɢɧ “ɱɢɫɬɚɹ” ɧɟ ɢɦɟɟɬ ɧɢɤɚɤɨɝɨ ɨɬɧɨɲɟɧɢɹ ɤ ɱɢɫɬɨ ɜɢɪɬɭɚɥɶɧɵɦ ɮɭɧɤɰɢɹɦ).
ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɩɪɟɞɢɤɚɬɚɦ ɫɨɯɪɚɧɹɬɶ ɢɥɢ ɨɛɪɚɳɚɬɶɫɹ ɤ ɫɨɫɬɨɹɧɢɸ ɬɚɤ, ɱɬɨɛɵ ɷɬɨ ɦɨɝɥɨ
ɜɥɢɹɬɶ ɧɚ ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɨɩɟɪɚɬɨɪɚ operator(); ɩɪɢ ɷɬɨɦ ɩɨɧɹɬɢɟ ɫɨɫɬɨɹɧɢɹ ɜɤɥɸɱɚɟɬ
ɤɚɤ ɞɚɧɧɵɟ-ɱɥɟɧɵ, ɬɚɤ ɢ ɝɥɨɛɚɥɶɧɵɟ ɫɨɫɬɨɹɧɢɹ. Ⱦɥɹ ɩɪɟɞɢɤɚɬɨɜ ɠɟɥɚɬɟɥɶɧɨ ɞɟɥɚɬɶ ɨɩɟɪɚɬɨɪ
operator() ɤɨɧɫɬɚɧɬɧɨɣ ɮɭɧɤɰɢɟɣ-ɱɥɟɧɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 15).
88. ȼ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɨɜ ɚɥɝɨɪɢɬɦɨɜ ɢ ɤɨɦɩɚɪɚɬɨɪɨɜ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɚ ɧɟ ɮɭɧɤɰɢɢ
ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɩɟɪɟɞɚɜɚɬɶ ɚɥɝɨɪɢɬɦɚɦ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɚ ɧɟ ɮɭɧɤɰɢɢ,
ɚ ɤɨɦɩɚɪɚɬɨɪɵ ɚɫɫɨɰɢɚɬɢɜɧɵɯ ɤɨɧɬɟɣɧɟɪɨɜ ɩɪɨɫɬɨ ɞɨɥɠɧɵ ɛɵɬɶ ɮɭɧɤɰɢɨɧɚɥɶɧɵɦɢ ɨɛɴ-
ɟɤɬɚɦɢ. Ɏɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɚɞɚɩɬɢɪɭɟɦɵ ɢ, ɜɨɩɪɟɤɢ ɨɠɢɞɚɧɢɹɦ, ɨɛɵɱɧɨ ɞɚɸɬ ɛɨɥɟɟ
ɛɵɫɬɪɵɣ ɩɨ ɫɪɚɜɧɟɧɢɸ ɫ ɮɭɧɤɰɢɹɦɢ ɤɨɞ.
89. Ʉɨɪɪɟɤɬɧɨ ɩɢɲɢɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ
Ɋɚɡɪɚɛɚɬɵɜɚɣɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ ɬɚɤ, ɱɬɨɛɵ ɢɯ ɤɨɩɢɪɨɜɚɧɢɟ ɜɵɩɨɥɧɹɥɨɫɶ ɤɚɤ
ɦɨɠɧɨ ɷɮɮɟɤɬɢɜɧɟɟ. Ɍɚɦ, ɝɞɟ ɷɬɨ ɜɨɡɦɨɠɧɨ, ɞɟɥɚɣɬɟ ɢɯ ɦɚɤɫɢɦɚɥɶɧɨ ɚɞɚɩɬɢɪɭɟɦɵɦɢ ɩɭ-
ɬɟɦ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ unary_function ɢɥɢ binary_function.
Стр. 217
Безопасность типов
90. ɂɡɛɟɝɚɣɬɟ ɹɜɧɨɝɨ ɜɵɛɨɪɚ ɬɢɩɨɜ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɨɥɢɦɨɪɮɢɡɦ
ɂɡɛɟɝɚɣɬɟ ɹɜɧɨɝɨ ɜɵɛɨɪɚ ɬɢɩɚ ɨɛɴɟɤɬɚ ɞɥɹ ɧɚɫɬɪɨɣɤɢ ɩɨɜɟɞɟɧɢɹ. ɂɫɩɨɥɶɡɭɣɬɟ ɲɚɛɥɨɧɵ
ɢ ɜɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɟɞɟɧɢɟ ɨɛɴɟɤɬɚ ɨɩɪɟɞɟɥɹɥɨɫɶ ɟɝɨ ɬɢɩɨɦ, ɚ ɧɟ
ɜɵɡɵɜɚɸɳɢɦ ɤɨɞɨɦ.
91. Ɋɚɛɨɬɚɣɬɟ ɫ ɬɢɩɚɦɢ, ɚ ɧɟ ɫ ɩɪɟɞɫɬɚɜɥɟɧɢɹɦɢ
ɇɟ ɩɵɬɚɣɬɟɫɶ ɞɟɥɚɬɶ ɤɚɤɢɟ-ɬɨ ɩɪɟɞɩɨɥɨɠɟɧɢɹ ɨ ɬɨɦ, ɤɚɤ ɢɦɟɧɧɨ ɨɛɴɟɤɬɵ ɩɪɟɞɫɬɚɜɥɟ-
ɧɵ ɜ ɩɚɦɹɬɢ. Ʉɚɤ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɡɚɩɢɫɵɜɚɬɶ ɢ ɫɱɢɬɵɜɚɬɶ ɨɛɴɟɤɬɵ ɢɡ ɩɚɦɹɬɢ — ɩɭɫɬɶ
ɪɟɲɚɸɬ ɬɢɩɵ ɨɛɴɟɤɬɨɜ.
92. ɂɡɛɟɝɚɣɬɟ reinterpret_cast
Ʉɚɤ ɝɥɚɫɢɬ ɪɢɦɫɤɚɹ ɩɨɫɥɨɜɢɰɚ, ɭ ɥɠɢ ɤɨɪɨɬɤɢɟ ɧɨɝɢ. ɇɟ ɩɵɬɚɣɬɟɫɶ ɢɫɩɨɥɶɡɨɜɚɬɶ
reinterpret_cast, ɱɬɨɛɵ ɡɚɫɬɚɜɢɬɶ ɤɨɦɩɢɥɹɬɨɪ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɛɢɬɵ ɨɛɴɟɤɬɚ ɨɞɧɨɝɨ ɬɢɩɚ
ɤɚɤ ɛɢɬɵ ɨɛɴɟɤɬɚ ɞɪɭɝɨɝɨ ɬɢɩɚ. Ɍɚɤɨɟ ɞɟɣɫɬɜɢɟ ɩɪɨɬɢɜɨɪɟɱɢɬ ɛɟɡɨɩɚɫɧɨɫɬɢ ɬɢɩɨɜ.
93. ɂɡɛɟɝɚɣɬɟ ɩɪɢɦɟɧɟɧɢɹ static_cast ɤ ɭɤɚɡɚɬɟɥɹɦ
Ʉ ɭɤɚɡɚɬɟɥɹɦ ɧɚ ɞɢɧɚɦɢɱɟɫɤɢɟ ɨɛɴɟɤɬɵ ɧɟ ɫɥɟɞɭɟɬ ɩɪɢɦɟɧɹɬ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ static_cast.
ɂɫɩɨɥɶɡɭɣɬɟ ɛɟɡɨɩɚɫɧɵɟ ɚɥɶɬɟɪɧɚɬɢɜɵ — ɨɬ dynamic_cast ɞɨ ɩɟɪɟɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
94. ɂɡɛɟɝɚɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ, ɨɬɦɟɧɹɸɳɢɯ const
ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ, ɨɬɦɟɧɹɸɳɟɟ const, ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟ-
ɧɢɸ, ɚ ɤɪɨɦɟ ɬɨɝɨ, ɷɬɨ ɫɜɢɞɟɬɟɥɶɫɬɜɨ ɩɥɨɯɨɝɨ ɫɬɢɥɹ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɞɚɠɟ ɜ ɬɨɦ ɫɥɭɱɚɟ,
ɤɨɝɞɚ ɩɪɢɦɟɧɟɧɢɟ ɬɚɤɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɜɩɨɥɧɟ ɡɚɤɨɧɧɨ.
95. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C
ȼɨɡɪɚɫɬ ɧɟ ɜɫɟɝɞɚ ɨɡɧɚɱɚɟɬ ɦɭɞɪɨɫɬɶ. ɋɬɚɪɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɢɦɟɟɬ
ɪɚɡɥɢɱɧɭɸ (ɢ ɱɚɫɬɨ ɨɩɚɫɧɭɸ) ɫɟɦɚɧɬɢɤɭ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɤɨɧɬɟɤɫɬɚ, ɫɩɪɹɬɚɧɧɭɸ ɡɚ ɟɞɢ-
ɧɵɦ ɫɢɧɬɚɤɫɢɫɨɦ. Ɂɚɦɟɧɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɩɪɟɨɛɪɚɡɨɜɚɧɢɹɦɢ C++ ɩɨɦɨ-
ɠɟɬ ɡɚɳɢɬɢɬɶɫɹ ɨɬ ɧɟɨɠɢɞɚɧɧɵɯ ɨɲɢɛɨɤ.
96. ɇɟ ɩɪɢɦɟɧɹɣɬɟ memcpy ɢɥɢ memcmp ɤ ɧɟ-POD ɬɢɩɚɦ
ɇɟ ɪɚɛɨɬɚɣɬɟ ɪɟɧɬɝɟɧɨɜɫɤɢɦ ɚɩɩɚɪɚɬɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 91). ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ
memcpy ɢ memcmp ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɢɥɢ ɫɪɚɜɧɟɧɢɹ ɱɟɝɨ-ɥɢɛɨ ɫɬɪɭɤɬɭɪɢɪɨɜɚɧɧɨɝɨ ɛɨɥɟɟ, ɱɟɦ
ɨɛɵɱɧɚɹ ɩɚɦɹɬɶ.
97. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɞɥɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ
ɏɢɬɪɨɫɬɶ ɜɫɟ ɪɚɜɧɨ ɨɫɬɚɟɬɫɹ ɥɨɠɶɸ: ɨɛɴɟɞɢɧɟɧɢɹ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɩɨɥɭɱɟɧɢɹ
“ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɚ ɛɟɡ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ”, ɡɚɩɢɫɵɜɚɹ ɢɧɮɨɪɦɚɰɢɸ ɜ ɨɞɢɧ ɱɥɟɧ ɢ ɫɱɢɬɵɜɚɹ
ɢɡ ɞɪɭɝɨɝɨ. Ɉɞɧɚɤɨ ɷɬɨ ɟɳɟ ɛɨɥɟɟ ɨɩɚɫɧɨ ɢ ɦɟɧɟɟ ɩɪɟɞɫɤɚɡɭɟɦɨ, ɱɟɦ ɩɪɢɦɟɧɟɧɢɟ
reinterpret_cast (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92).
98. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɢɡɜɟɫɬɧɵɟ ɚɪɝɭɦɟɧɬɵ (ɬɪɨɟɬɨɱɢɹ)
ɇɚɥɢɱɢɟ ɬɪɨɟɬɨɱɢɣ ɜ C++ — ɨɩɚɫɧɨɟ ɧɚɫɥɟɞɢɟ C. ɂɡɛɟɝɚɣɬɟ ɢɯ ɜ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦɚɯ; ɢɫ-
ɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɤɨɧɫɬɪɭɤɰɢɢ ɢ ɛɢɛɥɢɨɬɟɤɢ C++.
99. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ ɢ ɧɟɛɟɡɨɩɚɫɧɵɟ ɮɭɧɤɰɢɢ
ȼɵ ɠɟ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɩɪɨɫɪɨɱɟɧɧɵɟ ɥɟɤɚɪɫɬɜɚ? ɂ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɢ
“ɚɧɬɢɤɜɚɪɧɵɟ”, ɧɨ ɧɟɛɟɡɨɩɚɫɧɵɟ ɮɭɧɤɰɢɢ ɫɩɨɫɨɛɧɵ ɧɚɜɪɟɞɢɬɶ ɡɞɨɪɨɜɶɸ ɜɚɲɢɯ ɩɪɨɝɪɚɦɦ.
100. ɇɟ ɪɚɫɫɦɚɬɪɢɜɚɣɬɟ ɦɚɫɫɢɜɵ ɩɨɥɢɦɨɪɮɧɨ
ɉɨɥɢɦɨɪɮɧɚɹ ɪɚɛɨɬɚ ɫ ɦɚɫɫɢɜɚɦɢ — ɛɨɥɶɲɚɹ ɨɲɢɛɤɚ. Ʉ ɫɨɠɚɥɟɧɢɸ, ɨɛɵɱɧɨ ɤɨɦɩɢɥɹ-
ɬɨɪ ɧɢɤɚɤ ɧɚ ɧɟɟ ɧɟ ɪɟɚɝɢɪɭɟɬ. ɇɟ ɩɨɩɚɞɚɣɬɟɫɶ ɜ ɷɬɭ ɥɨɜɭɲɤɭ!
Стр. 218
От издательского дома “Вильямс”
Вы, читатель этой книги, и есть главный ее критик. Мы ценим ваше мнение и хотим
знать, что было сделано нами правильно, что можно было сделать лучше и что еще вы хо!
тели бы увидеть изданным нами. Нам интересно услышать и любые другие замечания,
которые вам хотелось бы высказать в наш адрес.
Мы ждем ваших комментариев и надеемся на них. Вы можете прислать нам бумажное
или электронное письмо либо просто посетить наш Web!сервер и оставить свои замеча!
ния там. Одним словом, любым удобным для вас способом дайте нам знать, нравится ли
вам эта книга, а также выскажите свое мнение о том, как сделать наши книги более инте!
ресными для вас.
Посылая письмо или сообщение, не забудьте указать название книги и ее авторов, а также
ваш обратный адрес. Мы внимательно ознакомимся с вашим мнением и обязательно учтем
его при отборе и подготовке к изданию последующих книг. Наши координаты:
E!mail: info@williamspublishing.com
WWW: http://www.williamspublishing.com
Информация для писем из
России: 115419, Москва, а/я 783
Украины: 03150, Киев, а/я 152
Стр. 219
Предметный указатель
# I
#include, 45 inline, 30
A K
Abelson, Harold, 25 Knuth, Donald, 23; 29
ADL, ɋɦ. ɉɨɢɫɤ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ
assert, 45; 112; 144
auto_ptr, 168 L
list, 164
B lower_bound, 179
Bell, Gordon, 25
Bentley, Jon, 25; 29
M
binary_search, 179 map, 164
McConnell, Steve, 25; 144
memcmp, 197
C memcpy, 197
Cargill, Tom, 92 mutable, 42
const, 42; 142; 194
ɍ ɜɯɨɞɧɵɯ ɩɚɪɚɦɟɬɪɨɜ ɮɭɧɤɰɢɣ, 58
CVS, 20
N
new, 95; 97
Ɋɚɡɦɟɳɚɸɳɢɣ, 98
D nth_element, 180
delete, 95
Dependency inversion principle, 54; 77
deque, 164; 171
P
Diamond, Norman, 99 partial_sort, 180
dynamic_cast, 41; 193 partition, 180
Perlis, Alan, 23; 39; 57; 117; 143; 187
Plain Old Data, 190
E POD, 190
equal_range, 179 push_back, 28; 169
errno, 154
explicit, 85; 110
R
RAII, 37
F realloc, 24
find, 179 reinterpret_cast, 192
find_if, 179 return, 17
for_each, 28
Стр. 220
S Ⱦ
Schwarz, Jerry, 127 Ⱦɚɣɦɨɧɞ, ɇɨɪɦɚɧ, 99
set, 164 Ⱦɟɤɪɟɦɟɧɬ
shared_ptr, 125; 168 ɉɪɟɮɢɤɫɧɚɹ ɢ ɩɨɫɬɮɢɤɫɧɚɹ ɮɨɪɦɵ, 62
sort, 180 Ⱦɟɫɤɪɢɩɬɨɪ, 89
Spencer, Henry, 187 Ⱦɟɫɬɪɭɤɬɨɪ, 106; 151
stable_partition, 180 ȼɢɪɬɭɚɥɶɧɵɣ, 76; 104
stable_sort, 180 Ⱦɢɧɚɦɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ, 134
static_cast, 41; 193 Ⱦɪɭɠɛɚ, 73
string, 167; 171
Stroustrup, Bjarne, 69; 133; 143; 163; 173
struct, 33 Ɂ
Sussman, Gerald Jay, 25 Ɂɚɜɢɫɢɦɨɫɬɢ ɨɩɪɟɞɟɥɟɧɢɣ, 53
swap, 114; 140 Ɂɚɜɢɫɢɦɵɟ ɢɦɟɧɚ, 55; 138
Ɂɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ, 16; 55
U Ɂɚɳɢɬɚ ɨɬ ɦɧɨɠɟɫɬɜɟɧɧɨɝɨ ɜɤɥɸɱɟɧɢɹ, 56
Ɂɚɤɨɧ ȼɬɨɪɨɝɨ ɒɚɧɫɚ, 78
upper_bound, 179
using, 119; 122
ɂ
V ɂɞɢɨɦɚ
Erase-remove, 171
vector, 164; 166; 167; 171 Pimpl, 42; 73; 87; 91; 114; 186
volatile, 49 RAII, 17; 37; 108; 109
Ȼɟɫɫɛɨɣɧɨɝɨ ɩɪɢɧɹɬɢɹ ɪɚɛɨɬɵ, 155
ȼɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ ɟɫɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ,
Ⱥ ɋɦ. RAII
Ⱥɛɟɥɶɫɨɧ, Ƚɚɪɨɥɶɞ, 25 ɂɧɞɟɤɫɧɨɝɨ ɤɨɧɬɟɣɧɟɪɚ, 180
Ⱥɛɫɬɪɚɤɬɧɵɣ ɢɧɬɟɪɮɟɣɫ, 77; 188 Ʉɥɨɧɢɪɨɜɚɧɢɹ, 111
Ⱥɝɪɟɝɚɬɵ ɡɧɚɱɟɧɢɣ, 88 Ʉɨɩɢɪɭɸɳɟɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ, 107
Ⱥɥɝɨɪɢɬɦɵ STL, 173 ɉɪɢɫɜɚɢɜɚɧɢɹ ɱɟɪɟɡ ɨɛɦɟɧ, 114
Ⱥɪɝɭɦɟɧɬ ɩɨ ɭɦɨɥɱɚɧɢɸ, 81 Ɋɟɚɥɢɡɚɰɢɢ ɨɩɟɪɚɬɨɪɚ ɱɟɪɟɡ
Ⱥɬɨɦɚɪɧɵɟ ɨɩɟɪɚɰɢɢ, 34 ɩɪɢɫɜɚɢɜɚɸɳɭɸ ɜɟɪɫɢɸ, 60
Ɋɟɚɥɢɡɚɰɢɢ ɩɨɫɬɮɢɤɫɧɨɝɨ ɨɩɟɪɚɬɨɪɚ ɱɟɪɟɡ
ɩɪɟɮɢɤɫɧɵɣ, 62
Ȼ ɍɫɬɪɚɧɟɧɢɹ ɢɡɥɢɲɧɟɣ ɟɦɤɨɫɬɢ
ɤɨɧɬɟɣɧɟɪɚ, 171
Ȼɟɥɥ, Ƚɨɪɞɨɧ, 25 ɂɦɹ
Ȼɟɧɬɥɢ, Ƀɨɧ, 25; 29 Ɂɚɜɢɫɢɦɨɟ, 138
ɂɧɜɚɪɢɚɧɬ, 148
ȼ ɂɧɢɰɢɚɥɢɡɚɰɢɹ, 17; 32; 48; 100; 101
ɉɨɪɹɞɨɤ, 52
ȼɟɧɝɟɪɫɤɚɹ ɡɚɩɢɫɶ, 15 ɂɧɤɚɩɫɭɥɹɰɢɹ, 83; 87
ȼɡɚɢɦɨɛɥɨɤɢɪɨɜɤɚ, 34; 36 ɂɧɤɪɟɦɟɧɬ
ȼɥɨɠɟɧɧɨɫɬɶ ɛɥɨɤɨɜ, 50 ɉɪɟɮɢɤɫɧɚɹ ɢ ɩɨɫɬɮɢɤɫɧɚɹ ɮɨɪɦɵ, 62
ȼɧɟɲɧɟɟ ɫɜɹɡɵɜɚɧɢɟ, 32 ɂɧɬɟɥɥɟɤɬɭɚɥɶɧɵɣ ɭɤɚɡɚɬɟɥɶ, 38; 168
ȼɪɟɦɹ ɠɢɡɧɢ, 47; 200 ɂɧɬɟɪɮɟɣɫ, 130
Ⱥɛɫɬɪɚɤɬɧɵɣ, 77
ɇɟɹɜɧɵɣ, 134
Ƚ Ɉɬɤɪɵɬɵɣ, 83; 118
Ƚɚɪɚɧɬɢɢ ɛɟɡɨɩɚɫɧɨɫɬɢ, 151 ɂɫɤɥɸɱɟɧɢɟ, 71; 106; 128; 146; 154; 158
Ƚɥɨɛɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, 32 Ƚɟɧɟɪɚɰɢɹ, 158
ɉɨɜɬɨɪɧɚɹ ɝɟɧɟɪɚɰɢɹ, 158
ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ, 159
Предметный указатель 221
Стр. 221
ɂɬɟɪɚɬɨɪ, 142 ɇɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ, 200
ɇɟɞɟɣɫɬɜɢɬɟɥɶɧɵɣ, 175 ɇɟɢɫɩɨɥɶɡɭɟɦɵɣ ɩɚɪɚɦɟɬɪ ɮɭɧɤɰɢɢ, 17
Ʉ Ɉ
Ʉɚɪɝɢɥɥ, Ɍɨɦ, 92 Ɉɛɨɛɳɟɧɧɨɫɬɶ ɤɨɞɚ, 94; 142
Ʉɥɚɫɫ, 69 Ɉɛɴɟɞɢɧɟɧɢɟ, 198
Ȼɚɡɨɜɵɣ, 70; 74; 75; 84; 105 Ɉɩɟɪɚɬɨɪ, 155
ȼɫɩɨɦɨɝɚɬɟɥɶɧɵɣ, 71 ++, --, 62
ɂɧɢɰɢɚɥɢɡɚɰɢɹ, 100; 101 <<, >>, 119
ɂɫɤɥɸɱɟɧɢɹ, 71 ɉɪɢɫɜɚɢɜɚɧɢɹ, 113
Ʉɥɚɫɫ-ɡɧɚɱɟɧɢɟ, 70 Ɉɲɢɛɤɚ, 151; 154
Ɇɢɧɢɦɚɥɶɧɵɣ, 72 ȼɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, 146
Ɇɧɨɠɟɫɬɜɟɧɧɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ, 78 Ɉɛɪɚɛɨɬɤɚ, 159
Ɇɨɧɨɥɢɬɧɵɣ, 72 ɉɪɢ ɪɚɛɨɬɟ ɫ STL, 174
ɉɪɨɢɡɜɨɞɧɵɣ, 81
ɉɭɫɬɨɣ ɛɚɡɨɜɵɣ, 74; 78
ɋɜɨɣɫɬɜ, 70 ɉ
ɋɬɪɚɬɟɝɢɢ, 70; 80; 105 ɉɚɦɹɬɶ, 125
Ʉɧɭɬ, Ⱦɨɧɚɥɶɞ, 23; 29 ɉɟɪɟɝɪɭɡɤɚ ɨɩɟɪɚɬɨɪɨɜ, 25; 59
Ʉɨɞ ɫɨɫɬɨɹɧɢɹ, 154 &&, || ɢ ,, 65
Ʉɨɦɚɧɞɧɚɹ ɪɚɛɨɬɚ, 21; 131 ɉɟɪɟɧɨɫɢɦɨɫɬɶ, 34
Ʉɨɦɦɟɧɬɚɪɢɣ, 14 ɉɟɪɥɢɫ, Ⱥɥɚɧ, 23; 39; 57; 117; 143; 187
Ʉɨɦɩɨɡɢɰɢɹ, 73 ɉɨɜɬɨɪɧɚɹ ɝɟɧɟɪɚɰɢɹ ɢɫɤɥɸɱɟɧɢɹ, 158
Ʉɨɧɫɬɪɭɤɬɨɪ, 155 ɉɨɜɬɨɪɧɨɟ ɢɫɩɨɥɶɡɨɜɚɧɢɟ, 80
ɇɟɹɜɧɨ ɩɪɟɨɛɪɚɡɭɸɳɢɣ, 85 ɉɨɢɫɤ
Ʉɨɩɢɪɨɜɚɧɢɟ, 109 Ɂɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɨɜ, 118; 120; 136
Ʉɨɩɢɪɭɸɳɟɟ ɩɪɢɫɜɚɢɜɚɧɢɟ, 152 ɂɦɟɧ, 73; 75; 78
Ʉɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ, 37 Ʉɺɧɢɝɚ, 118; 120
ɉɨɥɢɦɨɪɮɢɡɦ, 74; 110; 158; 188; 201
Ʌ Ⱦɢɧɚɦɢɱɟɫɤɢɣ, 80; 134
ɋɬɚɬɢɱɟɫɤɢɣ, 78; 134
Ʌɹɦɛɞɚ-ɮɭɧɤɰɢɹ, 177 ɉɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ
ɮɭɧɤɰɢɢ, 67
ɉɨɪɹɞɨɤ ɢɧɢɰɢɚɥɢɡɚɰɢɢ, 32
Ɇ ɉɨɫɬɤɨɧɫɬɪɭɤɬɨɪ, 102
Ɇɚɤ-Ʉɨɧɧɟɥɥ, ɋɬɢɜ, 25; 144 ɉɨɫɬɭɫɥɨɜɢɟ, 148
Ɇɚɤɪɨɫ, 44 ɉɨɬɨɤɢ ɜɵɩɨɥɧɟɧɢɹ, 34
Ɇɚɫɫɢɜ, 201 ɉɪɚɜɢɥɨ
Ɇɚɫɲɬɚɛɢɪɭɟɦɨɫɬɶ, 27; 31; 32 Ɉɞɧɨɝɨ ɨɩɪɟɞɟɥɟɧɢɹ, 124
Ɇɢɧɢɦɢɡɚɰɢɹ ɡɚɜɢɫɢɦɨɫɬɟɣ, 33 ɉɪɟɞɢɤɚɬ, 182
Ɇɧɨɝɨɩɨɬɨɱɧɨɫɬɶ, 34 ɉɪɟɞɭɫɥɨɜɢɟ, 148
ȼɡɚɢɦɨɛɥɨɤɢɪɨɜɤɚ, 34 ɉɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ, 25; 29
ȼɧɟɲɧɹɹ ɛɥɨɤɢɪɨɜɤɚ, 35 ɉɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɩɟɫɫɢɦɢɡɚɰɢɹ, 31
ȼɧɭɬɪɟɧɧɹɹ ɛɥɨɤɢɪɨɜɤɚ, 35 ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ, 64; 85
ɍɫɥɨɜɢɹ ɝɨɧɤɢ, 34 ɉɪɢɧɰɢɩ
Ɇɧɨɠɟɫɬɜɟɧɧɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ, 78 ɂɧɜɟɪɫɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ, 54; 77
Ɇɨɞɭɥɶɧɨɫɬɶ, 77 ɂɧɬɟɪɮɟɣɫɚ, 118
Ɉɬɤɪɵɬɨɫɬɢ-Ɂɚɤɪɵɬɨɫɬɢ, 188
ɉɨɞɫɬɚɧɨɜɤɢ Ʌɢɫɤɨɜ, 79
ɇ ɉɪɢɫɜɚɢɜɚɧɢɟ, 37
Ʉɨɩɢɪɭɸɳɟɟ, 113
ɇɚɫɥɟɞɨɜɚɧɢɟ, 73; 75 ɋɚɦɨɦɭ ɫɟɛɟ, 113; 152
Ɉɬɤɪɵɬɨɟ, 79 ɉɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ, 122
222 Предметный указатель
Стр. 222
Ɋ Ɏ
Ɋɚɛɨɬɚ ɫ ɪɟɫɭɪɫɚɦɢ, 37 Ɏɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, 184; 186
Ɋɚɡɪɚɛɨɬɤɚ ɛɢɛɥɢɨɬɟɤɢ, 30; 31; 33; 36; 59; Ɏɭɧɤɰɢɹ, 50
66; 130; 136 Ⱥɪɝɭɦɟɧɬ ɩɨ ɭɦɨɥɱɚɧɢɸ, 81
Ɋɚɫɩɪɟɞɟɥɟɧɢɟ ɩɚɦɹɬɢ, 125; 167 ȼɢɪɬɭɚɥɶɧɚɹ, 83; 102
Ɋɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ, 21 ȼɫɬɪɚɢɜɚɟɦɚɹ, 127
ɂɧɜɚɪɢɚɧɬ, 148
ɇɟɢɫɩɨɥɶɡɭɟɦɵɣ ɩɚɪɚɦɟɬɪ, 17
ɋ Ɉɛɦɟɧɚ, 107; 114; 151
ɋɚɫɫɦɚɧ, Ⱦɠɟɪɚɥɶɞ, 25 Ɉɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ, 107; 151
ɋɛɨɪɤɚ ɩɪɨɝɪɚɦɦɵ, 19 ɉɟɪɟɝɪɭɡɤɚ, 85; 140
ɋɜɹɡɧɨɫɬɶ, 94 ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ, 43; 58
ɋɜɹɡɵɜɚɧɢɟ, 73; 126 ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɫɫɵɥɤɟ, 58
Ⱦɢɧɚɦɢɱɟɫɤɨɟ, 134 ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨɫɪɟɞɫɬɜɨɦ
ɋɬɚɬɢɱɟɫɤɨɟ, 135 ɭɤɚɡɚɬɟɥɟɣ, 58
ɋɟɪɢɚɥɢɡɚɰɢɹ, 32; 34 ɉɟɪɟɤɪɵɬɢɟ, 81
ɋɢɫɬɟɦɚ ɭɩɪɚɜɥɟɧɢɹ ɜɟɪɫɢɹɦɢ, 20 ɉɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ, 67
ɋɥɨɠɧɨɫɬɶ ɚɥɝɨɪɢɬɦɚ, 27 ɉɨɫɬɭɫɥɨɜɢɟ, 148
ɋɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ, 32 ɉɪɟɞɭɫɥɨɜɢɟ, 148
ɋɨɤɪɵɬɢɟ ɞɚɧɧɵɯ, 33; 87; 89; 197 ɋ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ,
ɋɨɤɪɵɬɢɟ ɢɦɟɧ, 82 199
ɋɩɟɧɫɟɪ, Ƚɟɧɪɢ, 187 ɒɚɛɥɨɧ, 140
ɋɩɟɰɢɚɥɢɡɚɰɢɹ ɲɚɛɥɨɧɚ ɮɭɧɤɰɢɢ, 140 Ɏɭɧɤɰɢɹ ɨɛɪɚɬɧɨɝɨ ɜɵɡɨɜɚ, 36
ɋɩɟɰɢɮɢɤɚɰɢɢ ɢɫɤɥɸɱɟɧɢɣ, 160
ɋɪɟɡɤɚ, 76; 110 ɒ
ɋɬɚɬɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ, 135
ɋɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, 23 ɒɚɛɥɨɧ, 134
ɋɬɪɚɭɫɬɪɭɩ, Ȼɶɹɪɧ, 69; 133; 143; 163; 173 Ɍɨɱɤɚ ɧɚɫɬɪɨɣɤɢ, 136
Ɏɭɧɤɰɢɢ, 140
ɒɚɛɥɨɧ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
Ɍ Acyclic Visitor, 54
Ɍɚɛɭɥɹɰɢɹ, 15 Command, 54; 135
Ɍɪɚɧɡɚɤɰɢɹ, 106; 151 Nonvirtual Interface, 83; 104; 111
Observer, 176
Singleton, 52
ɍ Template Method, 83; 104
Visitor, 54; 135
ɍɤɚɡɚɬɟɥɶ ɧɚ ɪɟɚɥɢɡɚɰɢɸ, 91 ɒɜɚɪɰ, Ⱦɠɟɪɪɢ, 127
ɍɫɥɨɜɢɹ ɝɨɧɤɢ, 34
ɍɬɟɱɤɚ, 38
ɗ
ɗɮɮɟɤɬɢɜɧɨɫɬɶ ɚɥɝɨɪɢɬɦɚ, 27; 169
Предметный указатель 223
Стр. 223
ɇɚɭɱɧɨ-ɩɨɩɭɥɹɪɧɨɟ ɢɡɞɚɧɢɟ
Ƚɟɪɛ ɋɚɬɬɟɪ, Ⱥɧɞɪɟɣ Ⱥɥɟɤɫɚɧɞɪɟɫɤɭ
Стандарты программирования
на С++
Ʌɢɬɟɪɚɬɭɪɧɵɣ ɪɟɞɚɤɬɨɪ ɋ.Ƚ. Ɍɚɬɚɪɟɧɤɨ

ȼɟɪɫɬɤɚ Ɉ.ȼ. Ɇɢɲɭɬɢɧɚ
ɏɭɞɨɠɟɫɬɜɟɧɧɵɣ ɪɟɞɚɤɬɨɪ ȿ.ɉ. Ⱦɵɧɧɢɤ
Ʉɨɪɪɟɤɬɨɪ Ʌ.Ⱥ. Ƚɨɪɞɢɟɧɤɨ
ɂɡɞɚɬɟɥɶɫɤɢɣ ɞɨɦ “ȼɢɥɶɹɦɫ”

127055, ɝ. Ɇɨɫɤɜɚ, ɭɥ. Ʌɟɫɧɚɹ, ɞ. 43, ɫɬɪ. 1
ɉɨɞɩɢɫɚɧɨ ɜ ɩɟɱɚɬɶ 29.02.2008. Ɏɨɪɦɚɬ 70x100/16.

Ƚɚɪɧɢɬɭɪɚ Times. ɉɟɱɚɬɶ ɨɮɫɟɬɧɚɹ.
ɍɫɥ. ɩɟɱ. ɥ. 19,35. ɍɱ.-ɢɡɞ. ɥ. 13,2.
Ɍɢɪɚɠ 1000 ɷɤɡ. Ɂɚɤɚɡ ʋ 0000.
Îòïå÷àòàíî ïî òåõíîëîãèè ÑtP

â ÎÀÎ “Ïå÷àòíûé äâîð” èì. À. Ì. Ãîðüêîãî
197110, Ñàíêò-Ïåòåðáóðã, ×êàëîâñêèé ïð., 15
Стр. 224

Стандарты программирования на С++

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Стандарты программирования на С++

Загружено:

Авторское право:

Доступные форматы

Ñòàíäàðòû

titula_Standart-program-C++.indd3 3 27.02.2008 16:58:10

titula_Standart-program-C++.indd2 2 27.02.2008 16:58:10

Издательский дом “Вильямс”

titula_Standart-program-C++.indd1 1 27.02.2008 16:58:10

Издательский дом “Вильямс”

Перевод с английского и редакция канд. техн. наук И.В. Красикова

По общим вопросам обращайтесь в Издательский дом “Вильямс”

Саттер, Герб, Александреску, Андрей.

Все названия программных продуктов являются зарегистрированными торговыми марками соответст-

ISBN 978-5-8459-0859-9 (рус.) © Издательский дом “Вильямс”, 2008

ȼɨɩɪɨɫɵ ɨɪɝɚɧɢɡɚɰɢɢ ɢ ɫɬɪɚɬɟɝɢɢ 13

Ʌɭɱɲɟɟ ɜ ɫɬɚɧɞɚɪɬɟ ɬɨ, ɱɬɨ ɨɧ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɛɨɝɚɬɵɣ ɜɵɛɨɪ.

Как пользоваться этой книгой

Ƚɟɪɛ ɋɚɬɬɟɪ (Herb Sutter)

14 Вопросы организации и стратегии

0. Не мелочитесь, или Что не следует стандартизировать 15

16 Вопросы организации и стратегии

// ǘǹǭǫȊ ǭǰǻǼǳȊ: ǺǻǰǯǾǺǻǰǱǯǰǸǳǰ ǾǼǽǻǫǸǰǸǹ

1. Компилируйте без замечаний при максимальном уровне предупреждений 17

// ǘǹǭǫȊ ǭǰǻǼǳȊ: ǺǻǰǯǾǺǻǰǱǯǰǸǳǰ ǾǼǽǻǫǸǰǸǹ

18 Вопросы организации и стратегии

2. Используйте автоматические системы сборки программ 19

20 Вопросы организации и стратегии

4. Одна голова хорошо, а две — лучше 21

ə ɬɚɤɠɟ ɡɧɚɥ, ɧɨ ɡɚɛɵɥ ɚɮɨɪɢɡɦ ɏɨɚɪɚ ɨ ɬɨɦ, ɱɬɨ ɩɪɟɠɞɟ-

Ɉɱɟɧɶ ɫɥɨɠɧɨ ɨɬɞɟɥɢɬɶ ɫɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɨɬ ɫɬɢɥɹ ɤɨɞɢɪɨɜɚɧɢɹ. Ɇɵ ɩɨɩɵɬɚɥɢɫɶ ɩɨ-

6. Главное — корректность, простота и ясность 25

7. Кодирование с учетом масштабируемости 27

11. Сокрытие информации 33

12. Кодирование параллельных вычислений 35

13. Ресурсы должны быть во владении объектов 37

ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɩɟɪɟɣɞɟɦ ɨɬ ɜɨɩɪɨɫɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɤ ɜɨɩɪɨɫɚɦ, ɤɨɬɨɪɵɟ ɩɨɹɜɥɹɸɬ-

14. Предпочитайте ошибки компиляции... 39

14. Предпочитайте ошибки компиляции

14. Предпочитайте ошибки компиляции... 41

15. Активно используйте const 43

16. Избегайте макросов 45

18. Объявляйте переменные как можно локальнее 47

// ǖǾȂȃǰ: ǳǸǳȁǳǫǶǳǲǳǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ

19. Всегда инициализируйте переменные 49

20. Избегайте длинных функций и глубокой вложенности 51

22. Минимизируйте зависимости

22. Минимизируйте зависимости определений... 53

23. Делайте заголовочные файлы самодостаточными 55

Ɏɭɧɤɰɢɢ, ɜɤɥɸɱɚɹ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ

24. Используйте только внутреннюю, но не внешнюю защиту директивы #include 57

26. Сохраняйте естественную семантику перегруженных операторов 59

27. Отдавайте предпочтение каноническим

String operator+( const String& lhs, const String& rhs ) {

27. Отдавайте предпочтение каноническим формам... 61

// ---- ǚǹǼǽǿǳǵǼǸȆǰ ǹǺǰǻǫǽǹǻȆ -------------------

28. Предпочитайте канонический вид ++ и , и вызов префиксных операторов 63

// ... ǎǯǰ-ǽǹ ǭ ǵǹǯǰ ...

30. Избегайте перегрузки &&, || и , (запятой) 65

31. Не пишите код, который зависит от порядка вычислений аргументов функции 67

Ʉɚɤɨɝɨ ɜɢɞɚ ɤɥɚɫɫɵ ɩɪɟɞɩɨɱɢɬɚɟɬ ɪɚɡɪɚɛɚɬɵɜɚɬɶ ɢ ɫɬɪɨɢɬɶ ɜɚɲɚ ɤɨɦɚɧɞɚ? ɉɨɱɟɦɭ?

31. Не пишите код, который зависит от порядка вычислений аргументов функции 69

70 Проектирование классов и наследование

ȼɫɩɨɦɨɝɚɬɟɥɶɧɵɟ ɤɥɚɫɫɵ ɨɛɵɱɧɨ ɩɨɞɞɟɪɠɢɜɚɸɬ ɨɬɞɟɥɶɧɵɟ ɢɞɢɨɦɵ (ɧɚɩɪɢɦɟɪ, RAII —

32. Ясно представляйте, какой вид класса вы создаете 71

72 Проектирование классов и наследование

34. Предпочитайте композицию наследованию 73

28. Предпочитайте канонический вид ++ и , и вызов префиксных операторов 63

41. Делайте данныечлены закрытыми (кроме случая агрегатов в стиле структур C) 87