Стандарты программирования на С++. 101 правило и рекомендация 9785845908599, 0321113586

Citation preview

Ñòàíäàðòû ïðîãðàììèðîâàíèÿ íà 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

titula_Standart-program-C++.indd2 2

27.02.2008 16:58:10

Ñòàíäàðòû ïðîãðàììèðîâàíèÿ íà C++ 101 правило и рекомендация

Ãåðá Ñàòòåð Àíäðåé Àëåêñàíäðåñêó

Издательский дом “Вильямс” Москва • СанктПетербург • Киев 2008

titula_Standart-program-C++.indd1 1

27.02.2008 16:58:10

ББК 32.973.26-018.2.75 С21 УДК 681.3.07 Издательский дом “Вильямс” Зав. редакцией С.Н. Тригуб Перевод с английского и редакция канд. техн. наук И.В. Красикова По общим вопросам обращайтесь в Издательский дом “Вильямс” по адресу: [email protected], 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 Enterprises International, Copyright © 2008

ISBN 978-5-8459-0859-9 (рус.) ISBN 0-321-11358-6 (англ.)

Стр. 4

© Издательский дом “Вильямс”, 2008 © Pearson Education, Inc., 2005

Оглавление ɉɪɟɞɢɫɥɨɜɢɟ ȼɨɩɪɨɫɵ ɨɪɝɚɧɢɡɚɰɢɢ ɢ ɫɬɪɚɬɟɝɢɢ ɋɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɋɬɢɥɶ ɤɨɞɢɪɨɜɚɧɢɹ Ɏɭɧɤɰɢɢ ɢ ɨɩɟɪɚɬɨɪɵ ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɥɚɫɫɨɜ ɢ ɧɚɫɥɟɞɨɜɚɧɢɟ Ʉɨɧɫɬɪɭɤɬɨɪɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɤɨɩɢɪɨɜɚɧɢɟ ɉɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢ ɦɨɞɭɥɢ ɒɚɛɥɨɧɵ ɢ ɨɛɨɛɳɟɧɧɨɫɬɶ Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ STL: ɤɨɧɬɟɣɧɟɪɵ STL: ɚɥɝɨɪɢɬɦɵ Ȼɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ ɋɩɢɫɨɤ ɥɢɬɟɪɚɬɭɪɵ Ɋɟɡɸɦɟ ɢɡ ɪɟɡɸɦɟ ɉɪɟɞɦɟɬɧɵɣ ɭɤɚɡɚɬɟɥɶ

Стр. 5

9 13 23 39 57 69 99 117 133 143 163 173 187 202 206 220

Содержание ɉɪɟɞɢɫɥɨɜɢɟ ȼɨɩɪɨɫɵ ɨɪɝɚɧɢɡɚɰɢɢ ɢ ɫɬɪɚɬɟɝɢɢ 0. ɇɟ ɦɟɥɨɱɢɬɟɫɶ, ɢɥɢ ɑɬɨ ɧɟ ɫɥɟɞɭɟɬ ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɬɶ 1. Ʉɨɦɩɢɥɢɪɭɣɬɟ ɛɟɡ ɡɚɦɟɱɚɧɢɣ ɩɪɢ ɦɚɤɫɢɦɚɥɶɧɨɦ ɭɪɨɜɧɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ 2. ɂɫɩɨɥɶɡɭɣɬɟ ɚɜɬɨɦɚɬɢɱɟɫɤɢɟ ɫɢɫɬɟɦɵ ɫɛɨɪɤɢ ɩɪɨɝɪɚɦɦ 3. ɂɫɩɨɥɶɡɭɣɬɟ ɫɢɫɬɟɦɭ ɤɨɧɬɪɨɥɹ ɜɟɪɫɢɣ 4. Ɉɞɧɚ ɝɨɥɨɜɚ ɯɨɪɨɲɨ, ɚ ɞɜɟ — ɥɭɱɲɟ

ɋɬɢɥɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ 5. Ɉɞɢɧ ɨɛɴɟɤɬ — ɨɞɧɚ ɡɚɞɚɱɚ 6. Ƚɥɚɜɧɨɟ — ɤɨɪɪɟɤɬɧɨɫɬɶ, ɩɪɨɫɬɨɬɚ ɢ ɹɫɧɨɫɬɶ 7. Ʉɨɞɢɪɨɜɚɧɢɟ ɫ ɭɱɟɬɨɦ ɦɚɫɲɬɚɛɢɪɭɟɦɨɫɬɢ 8. ɇɟ ɨɩɬɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ 9. ɇɟ ɩɟɫɫɢɦɢɡɢɪɭɣɬɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨ 10. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɝɥɨɛɚɥɶɧɵɟ ɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɚɧɧɵɟ 11. ɋɨɤɪɵɬɢɟ ɢɧɮɨɪɦɚɰɢɢ 12. Ʉɨɞɢɪɨɜɚɧɢɟ ɩɚɪɚɥɥɟɥɶɧɵɯ ɜɵɱɢɫɥɟɧɢɣ 13. Ɋɟɫɭɪɫɵ ɞɨɥɠɧɵ ɛɵɬɶ ɜɨ ɜɥɚɞɟɧɢɢ ɨɛɴɟɤɬɨɜ

ɋɬɢɥɶ ɤɨɞɢɪɨɜɚɧɢɹ 14. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɲɢɛɤɢ ɤɨɦɩɢɥɹɰɢɢ ɢ ɤɨɦɩɨɧɨɜɤɢ ɨɲɢɛɤɚɦ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ 15. Ⱥɤɬɢɜɧɨ ɢɫɩɨɥɶɡɭɣɬɟ const 16. ɂɡɛɟɝɚɣɬɟ ɦɚɤɪɨɫɨɜ 17. ɂɡɛɟɝɚɣɬɟ ɦɚɝɢɱɟɫɤɢɯ ɱɢɫɟɥ 18. Ɉɛɴɹɜɥɹɣɬɟ ɩɟɪɟɦɟɧɧɵɟ ɤɚɤ ɦɨɠɧɨ ɥɨɤɚɥɶɧɟɟ 19. ȼɫɟɝɞɚ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ 20. ɂɡɛɟɝɚɣɬɟ ɞɥɢɧɧɵɯ ɮɭɧɤɰɢɣ ɢ ɝɥɭɛɨɤɨɣ ɜɥɨɠɟɧɧɨɫɬɢ 21. ɂɡɛɟɝɚɣɬɟ ɡɚɜɢɫɢɦɨɫɬɟɣ ɢɧɢɰɢɚɥɢɡɚɰɢɣ ɦɟɠɞɭ ɟɞɢɧɢɰɚɦɢ ɤɨɦɩɢɥɹɰɢɢ 22. Ɇɢɧɢɦɢɡɢɪɭɣɬɟ ɡɚɜɢɫɢɦɨɫɬɢ ɨɩɪɟɞɟɥɟɧɢɣ ɢ ɢɡɛɟɝɚɣɬɟ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ 23. Ⱦɟɥɚɣɬɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɫɚɦɨɞɨɫɬɚɬɨɱɧɵɦɢ 24. ɂɫɩɨɥɶɡɭɣɬɟ ɬɨɥɶɤɨ ɜɧɭɬɪɟɧɧɸɸ, ɧɨ ɧɟ ɜɧɟɲɧɸɸ ɡɚɳɢɬɭ ɞɢɪɟɤɬɢɜɵ #include

Ɏɭɧɤɰɢɢ ɢ ɨɩɟɪɚɬɨɪɵ 25. ɉɟɪɟɞɚɱɚ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ, (ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɨɦɭ) ɭɤɚɡɚɬɟɥɸ ɢɥɢ ɫɫɵɥɤɟ 26. ɋɨɯɪɚɧɹɣɬɟ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ 27. Ɉɬɞɚɜɚɣɬɟ ɩɪɟɞɩɨɱɬɟɧɢɟ ɤɚɧɨɧɢɱɟɫɤɢɦ ɮɨɪɦɚɦ ɚɪɢɮɦɟɬɢɱɟɫɤɢɯ ɨɩɟɪɚɬɨɪɨɜ ɢ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ 28. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ++ ɢ --, ɢ ɜɵɡɨɜ ɩɪɟɮɢɤɫɧɵɯ ɨɩɟɪɚɬɨɪɨɜ 29. ɂɫɩɨɥɶɡɭɣɬɟ ɩɟɪɟɝɪɭɡɤɭ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ 30. ɂɡɛɟɝɚɣɬɟ ɩɟɪɟɝɪɭɡɤɢ &&, || ɢ , (ɡɚɩɹɬɨɣ) 31. ɇɟ ɩɢɲɢɬɟ ɤɨɞ, ɤɨɬɨɪɵɣ ɡɚɜɢɫɢɬ ɨɬ ɩɨɪɹɞɤɚ ɜɵɱɢɫɥɟɧɢɣ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ

ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɥɚɫɫɨɜ ɢ ɧɚɫɥɟɞɨɜɚɧɢɟ 32. əɫɧɨ ɩɪɟɞɫɬɚɜɥɹɣɬɟ, ɤɚɤɨɣ ɜɢɞ ɤɥɚɫɫɚ ɜɵ ɫɨɡɞɚɟɬɟ 33. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɦɢɧɢɦɚɥɶɧɵɟ ɤɥɚɫɫɵ ɦɨɧɨɥɢɬɧɵɦ 34. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɨɦɩɨɡɢɰɢɸ ɧɚɫɥɟɞɨɜɚɧɢɸ

Стр. 6

9 13 14 16 19 20 21 23 24 25 27 29 31 32 33 34 37 39 40 42 44 46 47 48 50 52 53 55 56 57 58 59 60 62 64 65 67 69 70 72 73

35. ɂɡɛɟɝɚɣɬɟ ɧɚɫɥɟɞɨɜɚɧɢɹ ɨɬ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɧɟ ɫɩɪɨɟɤɬɢɪɨɜɚɧɵ ɞɥɹ ɷɬɨɣ ɰɟɥɢ 36. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɩɪɟɞɨɫɬɚɜɥɟɧɢɟ ɚɛɫɬɪɚɤɬɧɵɯ ɢɧɬɟɪɮɟɣɫɨɜ 37. Ɉɬɤɪɵɬɨɟ ɧɚɫɥɟɞɨɜɚɧɢɟ ɨɡɧɚɱɚɟɬ ɡɚɦɟɧɢɦɨɫɬɶ. ɇɚɫɥɟɞɨɜɚɬɶ ɧɚɞɨ ɧɟ ɞɥɹ ɩɨɜɬɨɪɧɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ, ɚ ɱɬɨɛɵ ɛɵɬɶ ɩɨɜɬɨɪɧɨ ɢɫɩɨɥɶɡɨɜɚɧɧɵɦ 38. ɉɪɚɤɬɢɤɭɣɬɟ ɛɟɡɨɩɚɫɧɨɟ ɩɟɪɟɤɪɵɬɢɟ 39. ȼɢɪɬɭɚɥɶɧɵɟ ɮɭɧɤɰɢɢ ɫɬɨɢɬ ɞɟɥɚɬɶ ɧɟɨɬɤɪɵɬɵɦɢ, ɚ ɨɬɤɪɵɬɵɟ — ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ 40. ɂɡɛɟɝɚɣɬɟ ɜɨɡɦɨɠɧɨɫɬɟɣ ɧɟɹɜɧɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ 41. Ⱦɟɥɚɣɬɟ ɞɚɧɧɵɟ-ɱɥɟɧɵ ɡɚɤɪɵɬɵɦɢ (ɤɪɨɦɟ ɫɥɭɱɚɹ ɚɝɪɟɝɚɬɨɜ ɜ ɫɬɢɥɟ ɫɬɪɭɤɬɭɪ C) 42. ɇɟ ɞɨɩɭɫɤɚɣɬɟ ɜɦɟɲɚɬɟɥɶɫɬɜɚ ɜɨ ɜɧɭɬɪɟɧɧɢɟ ɞɟɥɚ 43. Ɋɚɡɭɦɧɨ ɩɨɥɶɡɭɣɬɟɫɶ ɢɞɢɨɦɨɣ Pimpl 44. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɧɟ ɹɜɥɹɸɬɫɹ ɧɢ ɱɥɟɧɚɦɢ, ɧɢ ɞɪɭɡɶɹɦɢ 45. new ɢ delete ɜɫɟɝɞɚ ɞɨɥɠɧɵ ɪɚɡɪɚɛɚɬɵɜɚɬɶɫɹ ɜɦɟɫɬɟ 46. ɉɪɢ ɧɚɥɢɱɢɢ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ new ɫɥɟɞɭɟɬ ɩɪɟɞɨɫɬɚɜɥɹɬɶ ɜɫɟ ɫɬɚɧɞɚɪɬɧɵɟ ɬɢɩɵ ɷɬɨɝɨ ɨɩɟɪɚɬɨɪɚ

Ʉɨɧɫɬɪɭɤɬɨɪɵ, ɞɟɫɬɪɭɤɬɨɪɵ ɢ ɤɨɩɢɪɨɜɚɧɢɟ 47. Ɉɩɪɟɞɟɥɹɣɬɟ ɢ ɢɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɵɟ-ɱɥɟɧɵ ɜ ɨɞɧɨɦ ɩɨɪɹɞɤɟ 48. ȼ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɩɪɟɞɩɨɱɢɬɚɣɬɟ ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɩɪɢɫɜɚɢɜɚɧɢɸ 49. ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɨɜ ɜɢɪɬɭɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɜ ɤɨɧɫɬɪɭɤɬɨɪɚɯ ɢ ɞɟɫɬɪɭɤɬɨɪɚɯ 50. Ⱦɟɥɚɣɬɟ ɞɟɫɬɪɭɤɬɨɪɵ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ ɨɬɤɪɵɬɵɦɢ ɢ ɜɢɪɬɭɚɥɶɧɵɦɢ ɥɢɛɨ ɡɚɳɢɳɟɧɧɵɦɢ ɢ ɧɟɜɢɪɬɭɚɥɶɧɵɦɢ 51. Ⱦɟɫɬɪɭɤɬɨɪɵ, ɮɭɧɤɰɢɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɪɟɫɭɪɫɨɜ ɢ ɨɛɦɟɧɚ ɧɟ ɨɲɢɛɚɸɬɫɹ 52. Ʉɨɩɢɪɭɣɬɟ ɢ ɥɢɤɜɢɞɢɪɭɣɬɟ ɫɨɝɥɚɫɨɜɚɧɧɨ 53. əɜɧɨ ɪɚɡɪɟɲɚɣɬɟ ɢɥɢ ɡɚɩɪɟɳɚɣɬɟ ɤɨɩɢɪɨɜɚɧɢɟ 54. ɂɡɛɟɝɚɣɬɟ ɫɪɟɡɤɢ. ɉɨɞɭɦɚɣɬɟ ɨɛ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜ ɛɚɡɨɜɨɦ ɤɥɚɫɫɟ ɤɥɨɧɢɪɨɜɚɧɢɹ ɜɦɟɫɬɨ ɤɨɩɢɪɨɜɚɧɢɹ 55. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ɩɪɢɫɜɚɢɜɚɧɢɹ 56. Ɉɛɟɫɩɟɱɶɬɟ ɛɟɫɫɛɨɣɧɭɸ ɮɭɧɤɰɢɸ ɨɛɦɟɧɚ

ɉɪɨɫɬɪɚɧɫɬɜɚ ɢɦɟɧ ɢ ɦɨɞɭɥɢ 57. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɢɯ ɫɜɨɛɨɞɧɵɣ ɢɧɬɟɪɮɟɣɫ ɜ ɨɞɧɨɦ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ 58. ɏɪɚɧɢɬɟ ɬɢɩɵ ɢ ɮɭɧɤɰɢɢ ɜ ɪɚɡɧɵɯ ɩɪɨɫɬɪɚɧɫɬɜɚɯ ɢɦɟɧ, ɟɫɥɢ ɬɨɥɶɤɨ ɨɧɢ ɧɟ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɜɦɟɫɬɧɨɣ ɪɚɛɨɬɵ 59. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ using ɞɥɹ ɩɪɨɫɬɪɚɧɫɬɜ ɢɦɟɧ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ ɢɥɢ ɩɟɪɟɞ ɞɢɪɟɤɬɢɜɨɣ #include 60. ɂɡɛɟɝɚɣɬɟ ɜɵɞɟɥɟɧɢɹ ɢ ɨɫɜɨɛɨɠɞɟɧɢɹ ɩɚɦɹɬɢ ɜ ɪɚɡɧɵɯ ɦɨɞɭɥɹɯ 61. ɇɟ ɨɩɪɟɞɟɥɹɣɬɟ ɜ ɡɚɝɨɥɨɜɨɱɧɨɦ ɮɚɣɥɟ ɨɛɴɟɤɬɵ ɫɨ ɫɜɹɡɵɜɚɧɢɟɦ 62. ɇɟ ɩɨɡɜɨɥɹɣɬɟ ɢɫɤɥɸɱɟɧɢɹɦ ɩɟɪɟɫɟɤɚɬɶ ɝɪɚɧɢɰɵ ɦɨɞɭɥɟɣ 63. ɂɫɩɨɥɶɡɭɣɬɟ ɞɨɫɬɚɬɨɱɧɨ ɩɟɪɟɧɨɫɢɦɵɟ ɬɢɩɵ ɜ ɢɧɬɟɪɮɟɣɫɚɯ ɦɨɞɭɥɟɣ

ɒɚɛɥɨɧɵ ɢ ɨɛɨɛɳɟɧɧɨɫɬɶ 64. Ɋɚɡɭɦɧɨ ɫɨɱɟɬɚɣɬɟ ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ 65. ȼɵɩɨɥɧɹɣɬɟ ɧɚɫɬɪɨɣɤɭ ɹɜɧɨ ɢ ɩɪɟɞɧɚɦɟɪɟɧɧɨ 66. ɇɟ ɫɩɟɰɢɚɥɢɡɢɪɭɣɬɟ ɲɚɛɥɨɧɵ ɮɭɧɤɰɢɣ 67. ɉɢɲɢɬɟ ɦɚɤɫɢɦɚɥɶɧɨ ɨɛɨɛɳɟɧɧɵɣ ɤɨɞ

Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ 68. ɒɢɪɨɤɨ ɩɪɢɦɟɧɹɣɬɟ assert ɞɥɹ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɢɹ ɜɧɭɬɪɟɧɧɢɯ ɞɨɩɭɳɟɧɢɣ ɢ ɢɧɜɚɪɢɚɧɬɨɜ 69. Ɉɩɪɟɞɟɥɢɬɟ ɪɚɡɭɦɧɭɸ ɫɬɪɚɬɟɝɢɸ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ ɢ ɫɬɪɨɝɨ ɟɣ ɫɥɟɞɭɣɬɟ 70. Ɉɬɥɢɱɚɣɬɟ ɨɲɢɛɤɢ ɨɬ ɫɢɬɭɚɰɢɣ, ɧɟ ɹɜɥɹɸɳɢɯɫɹ ɨɲɢɛɤɚɦɢ Содержание

Стр. 7

75 77 79 81 83 85 87 89 91 94 95 97 99 100 101 102 104 106 108 109 110 113 114 117 118 120 122 125 126 128 130 133 134 136 140 142 143 144 146 148

7

71. ɉɪɨɟɤɬɢɪɭɣɬɟ ɢ ɩɢɲɢɬɟ ɛɟɡɨɩɚɫɧɵɣ ɜ ɨɬɧɨɲɟɧɢɢ ɨɲɢɛɨɤ ɤɨɞ 72. Ⱦɥɹ ɭɜɟɞɨɦɥɟɧɢɹ ɨɛ ɨɲɢɛɤɚɯ ɫɥɟɞɭɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɫɤɥɸɱɟɧɢɹ 73. Ƚɟɧɟɪɢɪɭɣɬɟ ɢɫɤɥɸɱɟɧɢɹ ɩɨ ɡɧɚɱɟɧɢɸ, ɩɟɪɟɯɜɚɬɵɜɚɣɬɟ — ɩɨ ɫɫɵɥɤɟ 74. ɍɜɟɞɨɦɥɹɣɬɟ ɨɛ ɨɲɢɛɤɚɯ, ɨɛɪɚɛɚɬɵɜɚɣɬɟ ɢ ɩɪɟɨɛɪɚɡɨɜɵɜɚɣɬɟ ɢɯ ɬɚɦ, ɝɞɟ ɫɥɟɞɭɟɬ 75. ɂɡɛɟɝɚɣɬɟ ɫɩɟɰɢɮɢɤɚɰɢɣ ɢɫɤɥɸɱɟɧɢɣ

STL: ɤɨɧɬɟɣɧɟɪɵ

163

76. ɉɨ ɭɦɨɥɱɚɧɢɸ ɢɫɩɨɥɶɡɭɣɬɟ vector. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɛɢɪɚɣɬɟ ɤɨɧɬɟɣɧɟɪ, ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɡɚɞɚɱɟ 77. ȼɦɟɫɬɨ ɦɚɫɫɢɜɨɜ ɢɫɩɨɥɶɡɭɣɬɟ vector ɢ string 78. ɂɫɩɨɥɶɡɭɣɬɟ vector (ɢ string::c_str) ɞɥɹ ɨɛɦɟɧɚ ɞɚɧɧɵɦɢ ɫ API ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ 79. ɏɪɚɧɢɬɟ ɜ ɤɨɧɬɟɣɧɟɪɚɯ ɬɨɥɶɤɨ ɡɧɚɱɟɧɢɹ ɢɥɢ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ 80. ɉɪɟɞɩɨɱɢɬɚɣɬɟ push_back ɞɪɭɝɢɦ ɫɩɨɫɨɛɚɦ ɪɚɫɲɢɪɟɧɢɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ 81. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɨɩɟɪɚɰɢɢ ɫ ɞɢɚɩɚɡɨɧɚɦɢ ɨɩɟɪɚɰɢɹɦ ɫ ɨɬɞɟɥɶɧɵɦɢ ɷɥɟɦɟɧɬɚɦɢ 82. ɂɫɩɨɥɶɡɭɣɬɟ ɩɨɞɯɨɞɹɳɢɟ ɢɞɢɨɦɵ ɞɥɹ ɪɟɚɥɶɧɨɝɨ ɭɦɟɧɶɲɟɧɢɹ ɟɦɤɨɫɬɢ ɤɨɧɬɟɣɧɟɪɚ ɢ ɭɞɚɥɟɧɢɹ ɷɥɟɦɟɧɬɨɜ

STL: ɚɥɝɨɪɢɬɦɵ

90. ɂɡɛɟɝɚɣɬɟ ɹɜɧɨɝɨ ɜɵɛɨɪɚ ɬɢɩɨɜ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɨɥɢɦɨɪɮɢɡɦ 91. Ɋɚɛɨɬɚɣɬɟ ɫ ɬɢɩɚɦɢ, ɚ ɧɟ ɫ ɩɪɟɞɫɬɚɜɥɟɧɢɹɦɢ 92. ɂɡɛɟɝɚɣɬɟ reinterpret_cast 93. ɂɡɛɟɝɚɣɬɟ ɩɪɢɦɟɧɟɧɢɹ static_cast ɤ ɭɤɚɡɚɬɟɥɹɦ 94. ɂɡɛɟɝɚɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ, ɨɬɦɟɧɹɸɳɢɯ const 95. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C 96. ɇɟ ɩɪɢɦɟɧɹɣɬɟ memcpy ɢɥɢ memcmp ɤ ɧɟ-POD ɬɢɩɚɦ 97. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɨɛɴɟɞɢɧɟɧɢɹ ɞɥɹ ɩɪɟɨɛɪɚɡɨɜɚɧɢɣ 98. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɢɡɜɟɫɬɧɵɟ ɚɪɝɭɦɟɧɬɵ (ɬɪɨɟɬɨɱɢɹ) 99. ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ ɧɟɞɟɣɫɬɜɢɬɟɥɶɧɵɟ ɨɛɴɟɤɬɵ ɢ ɧɟɛɟɡɨɩɚɫɧɵɟ ɮɭɧɤɰɢɢ 100. ɇɟ ɪɚɫɫɦɚɬɪɢɜɚɣɬɟ ɦɚɫɫɢɜɵ ɩɨɥɢɦɨɪɮɧɨ

171 174 176 179 180 182 184 186 187 188 190 192 193 194 195 197 198 199 200 201

ɋɩɢɫɨɤ ɥɢɬɟɪɚɬɭɪɵ

202

Ɋɟɡɸɦɟ ɢɡ ɪɟɡɸɦɟ

206

ɉɪɟɞɦɟɬɧɵɣ ɭɤɚɡɚɬɟɥɶ

220

8

Стр. 8

164 166 167 168 169 170

173

83. ɂɫɩɨɥɶɡɭɣɬɟ ɨɬɥɚɞɨɱɧɭɸ ɪɟɚɥɢɡɚɰɢɸ STL 84. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɜɵɡɨɜɵ ɚɥɝɨɪɢɬɦɨɜ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɪɚɡɪɚɛɚɬɵɜɚɟɦɵɦ ɰɢɤɥɚɦ 85. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɩɨɢɫɤɚ 86. ɉɨɥɶɡɭɣɬɟɫɶ ɩɪɚɜɢɥɶɧɵɦ ɚɥɝɨɪɢɬɦɨɦ ɫɨɪɬɢɪɨɜɤɢ 87. Ⱦɟɥɚɣɬɟ ɩɪɟɞɢɤɚɬɵ ɱɢɫɬɵɦɢ ɮɭɧɤɰɢɹɦɢ 88. ȼ ɤɚɱɟɫɬɜɟ ɚɪɝɭɦɟɧɬɨɜ ɚɥɝɨɪɢɬɦɨɜ ɢ ɤɨɦɩɚɪɚɬɨɪɨɜ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɚ ɧɟ ɮɭɧɤɰɢɢ 89. Ʉɨɪɪɟɤɬɧɨ ɩɢɲɢɬɟ ɮɭɧɤɰɢɨɧɚɥɶɧɵɟ ɨɛɴɟɤɬɵ

Ȼɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ

151 154 158 159 160

Содержание

Ɇɢɥɥɢɨɧɚɦ ɧɵɧɟɲɧɢɯ ɩɪɨɝɪɚɦɦɢɫɬɨɜ ɧɚ 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 dzDz // ǬdzǬǶdzǹǽǰǵdz Boost. ǍǼǰǮǯǫ ǭǵǶȉȂǫǴǽǰ dzǷǰǸǸǹ Ȉǽǹǽ ǿǫǴǶ dz Ǹǰ // dzǼǺǹǶȇDzǾǴǽǰ lambda.hpp ǸǰǺǹǼǻǰǯǼǽǭǰǸǸǹ. Boost.Lambda // Ǻǻdzǭǹǯdzǽ ǵ ǭȆǭǹǯǾ ǵǹǷǺdzǶȊǽǹǻǹǷ ǺǻǰǯǾǺǻǰDZǯǰǸdzǴ, ǹ // ǬǰDzǭǻǰǯǸǹǼǽdz ǵǹǽǹǻȆȀ ǸǫǷ ǯǹǺǹǯǶdzǸǸǹ dzDzǭǰǼǽǸǹ. ǕǹǮǯǫ // ǻǫDzǻǫǬǹǽȂdzǵdz ǼǯǰǶǫȉǽ ǸǹǭǾȉ ǭǰǻǼdzȉ, ǵǹǽǹǻǫȊ Ǹǰ ǬǾǯǰǽ // ǭȆDzȆǭǫǽȇ ǺǻǰǯǾǺǻǰDZǯǰǸdzǴ, ǷȆ ǾǯǫǶdzǷ dzDz ȈǽǹǮǹ ǿǫǴǶǫ // ǼǹǹǽǭǰǽǼǽǭǾȉȄdzǰ ǯdzǻǰǵǽdzǭȆ #pragma, Ǹǹ ǼǫǷ DzǫǮǹǶǹǭǹȂǸȆǴ // ǿǫǴǶ ǹǼǽǫǸǰǽǼȊ. // #pragma warning(push) // ǙǽǵǶȉȂǰǸdzǰ ǺǻǰǯǾǺǻǰDZǯǰǸdzǴ ǽǹǶȇǵǹ // ǯǶȊ ǯǫǸǸǹǮǹ DzǫǮǹǶǹǭǹȂǸǹǮǹ ǿǫǴǶǫ #pragma warning(disable:4512) #pragma warning(disable:4180)

16

Стр. 16

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

#include #pragma warning(pop) // ǍǹǼǼǽǫǸǫǭǶdzǭǫǰǷ dzǼȀǹǯǸȆǴ ǾǻǹǭǰǸȇ // ǭȆǭǹǯǫ ǺǻǰǯǾǺǻǰDZǯǰǸdzǴ

ɉɪɢɦɟɪ 2. “ɇɟɢɫɩɨɥɶɡɭɟɦɵɣ ɩɚɪɚɦɟɬɪ ɮɭɧɤɰɢɢ”. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɜ ɫɚɦɨɦ ɞɟɥɟ ɫɨɡɧɚɬɟɥɶɧɨ ɧɟ ɢɫɩɨɥɶɡɭɟɬɟ ɩɚɪɚɦɟɬɪ ɮɭɧɤɰɢɢ (ɇɚɩɪɢɦɟɪ, ɷɬɨ “ɡɚɝɥɭɲɤɚ” ɞɥɹ ɛɭɞɭɳɟɝɨ ɪɚɫɲɢɪɟɧɢɹ ɢɥɢ ɬɪɟɛɭɟɦɚɹ ɫɬɚɧɞɚɪɬɨɦ ɱɚɫɬɶ ɫɢɝɧɚɬɭɪɵ, ɤɨɬɨɪɭɸ ɜɚɲ ɤɨɞ ɧɟ ɢɫɩɨɥɶɡɭɟɬ). ȿɫɥɢ ɷɬɨɬ ɩɚɪɚɦɟɬɪ ɜɚɦ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟ ɧɭɠɟɧ, ɩɪɨɫɬɨ ɭɞɚɥɢɬɟ ɟɝɨ ɢɦɹ: // ... ǭǸǾǽǻdz ǺǹǶȇDzǹǭǫǽǰǶȇǼǵǹǮǹ ǻǫǼǺǻǰǯǰǶdzǽǰǶȊ ǺǹǯǼǵǫDzǵǫ Ǹǰ // dzǼǺǹǶȇDzǾǰǽǼȊ ... // ǚǻǰǯǾǺǻǰDZǯǰǸdzǰ: "ǸǰdzǼǺǹǶȇDzǾǰǷȆǴ ǺǫǻǫǷǰǽǻ 'localityHint'" pointer allocate( size_type numObjects, const void *l localityHint = 0 ) { return static_cast( mallocShared( numObjects * sizeof(T) ) ); } // ǘǹǭǫȊ ǭǰǻǼdzȊ: ǺǻǰǯǾǺǻǰDZǯǰǸdzǰ ǾǼǽǻǫǸǰǸǹ pointer allocate( size_type numObjects, const void * /* localityHint */ = 0 ) { return static_cast( mallocShared( numObjects * sizeof(T) ) ); }

ɉɪɢɦɟɪ 3. “ɉɟɪɟɦɟɧɧɚɹ ɨɩɪɟɞɟɥɟɧɚ, ɧɨ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ”. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟ ɧɚɦɟɪɟɧɵ ɨɛɪɚɳɚɬɶɫɹ ɤ ɞɚɧɧɨɣ ɩɟɪɟɦɟɧɧɨɣ (ɤ ɬɚɤɢɦ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ ɱɚɫɬɨ ɩɪɢɜɨɞɹɬ ɥɨɤɚɥɶɧɵɟ ɨɛɴɟɤɬɵ, ɫɥɟɞɭɸɳɢɟ ɢɞɢɨɦɟ “ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ ɟɫɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɹ”, ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13). ȿɫɥɢ ɨɛɪɚɳɟɧɢɟ ɤ ɨɛɴɟɤɬɭ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɟ ɬɪɟɛɭɟɬɫɹ, ɱɚɫɬɨ ɦɨɠɧɨ ɡɚɫɬɚɜɢɬɶ ɤɨɦɩɢɥɹɬɨɪ ɡɚɦɨɥɱɚɬɶ, ɜɤɥɸɱɢɜ “ɜɵɱɢɫɥɟɧɢɟ” ɫɚɦɨɣ ɩɟɪɟɦɟɧɧɨɣ ɜ ɤɚɱɟɫɬɜɟ ɜɵɪɚɠɟɧɢɹ (ɬɚɤɨɟ ɜɵɱɢɫɥɟɧɢɟ ɧɟ ɜɥɢɹɟɬ ɧɚ ɫɤɨɪɨɫɬɶ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ): // ǚǻǰǯǾǺǻǰDZǯǰǸdzǰ: "ǺǰǻǰǷǰǸǸǫȊ 'lock' ǹǺǻǰǯǰǶǰǸǫ, Ǹǹ Ǹǰ // dzǼǺǹǶȇDzǾǰǽǼȊ" void Fun() { Lock lock; // ... } // ǘǹǭǫȊ ǭǰǻǼdzȊ: ǺǻǰǯǾǺǻǰDZǯǰǸdzǰ Ǹǰ ǯǹǶDZǸǹ ǭȆǭǹǯdzǽȇǼȊ void Fun() { Lock lock; lock; // ... }

ɉɪɢɦɟɪ 4. “ɉɟɪɟɦɟɧɧɚɹ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ, ɧɟ ɛɭɞɭɱɢ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɨɣ”. ɂɧɢɰɢɚɥɢɡɢɪɭɣɬɟ ɩɟɪɟɦɟɧɧɭɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 19). ɉɪɢɦɟɪ 5. “Ɉɬɫɭɬɫɬɜɭɟɬ return”. ɂɧɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪɵ ɬɪɟɛɭɸɬ ɧɚɥɢɱɢɹ ɢɧɫɬɪɭɤɰɢɢ return ɧɟɫɦɨɬɪɹ ɧɚ ɬɨ, ɱɬɨ ɩɨɬɨɤ ɭɩɪɚɜɥɟɧɢɹ ɧɟ ɦɨɠɟɬ ɞɨɫɬɢɱɶ ɤɨɧɰɚ ɮɭɧɤɰɢɢ (ɧɚɩɪɢɦɟɪ, ɩɪɢ ɧɚɥɢɱɢɢ ɛɟɫɤɨɧɟɱɧɨɝɨ ɰɢɤɥɚ, ɢɧɫɬɪɭɤɰɢɢ throw, ɞɪɭɝɢɯ ɢɧɫɬɪɭɤɰɢɣ return). Ɍɚɤɨɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɟ ɧɟ ɫɬɨɢɬ ɢɝɧɨɪɢɪɨɜɚɬɶ, ɩɨɫɤɨɥɶɤɭ ɜɵ ɦɨɠɟɬɟ ɬɨɥɶɤɨ ɞɭɦɚɬɶ, ɱɬɨ ɭɩɪɚɜɥɟɧɢɟ ɧɟ ɞɨɫɬɢɝɚɟɬ ɤɨɧɰɚ ɮɭɧɤɰɢɢ. ɇɚɩɪɢɦɟɪ, ɤɨɧɫɬɪɭɤɰɢɹ switch, ɭ ɤɨɬɨɪɨɣ ɧɟɬ ɜɵɛɨɪɚ default, ɩɪɢ ɜɧɟɫɟɧɢɢ ɢɡɦɟɧɟɧɢɣ ɜ ɩɪɨɝɪɚɦɦɭ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɧɟɩɪɢɹɬɧɨɫɬɹɦ, ɬɚɤ ɱɬɨ ɫɥɟɞɭɟɬ ɢɦɟɬɶ ɜɵɛɨɪ default, ɤɨɬɨɪɵɣ ɩɪɨɫɬɨ ɜɵɩɨɥɧɹɟɬ assert(false) (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 68 ɢ 90): // ǚǻǰǯǾǺǻǰDZǯǰǸdzǰ: ǹǽǼǾǽǼǽǭǾȉȄdzǴ "return" int Fun( Color c ) { switch( c ) { case Red: return 2; case Green: return 0;

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

Стр. 17

17

case Blue: case Black: return 1; } } // ǘǹǭǫȊ ǭǰǻǼdzȊ: ǺǻǰǯǾǺǻǰDZǯǰǸdzǰ ǾǼǽǻǫǸǰǸǹ int Fun( Color c ) { switch( c ) { case Red: return 2; case Green: return 0; case Blue: case Black: return 1; // ǒǸǫȂǰǸdzǰ !"string" ǻǫǭǸǹ false: default : assert (!"should never get here!"); return -1; } }

ɉɪɢɦɟɪ 6. “ɇɟɫɨɨɬɜɟɬɫɬɜɢɟ signed/unsigned”. Ɉɛɵɱɧɨ ɧɟ ɜɨɡɧɢɤɚɟɬ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɫɪɚɜɧɢɜɚɬɶ ɢɥɢ ɩɪɢɫɜɚɢɜɚɬɶ ɱɢɫɥɚ ɫ ɪɚɡɧɵɦ ɬɢɩɨɦ ɡɧɚɤɨɜɨɫɬɢ. ɂɡɦɟɧɢɬɟ ɬɢɩɵ ɫɪɚɜɧɢɜɚɟɦɵɯ ɩɟɪɟɦɟɧɧɵɯ ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɫɨɨɬɜɟɬɫɬɜɨɜɚɥɢ ɞɪɭɝ ɞɪɭɝɭ. ȼ ɤɪɚɣɧɟɦ ɫɥɭɱɚɟ, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɹɜɧɵɦ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɬɢɩɨɜ. (Ʉɨɦɩɢɥɹɬɨɪ ɜɫɟ ɪɚɜɧɨ ɜɫɬɚɜɥɹɟɬ ɜ ɤɨɞ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɢ ɩɪɟɞɭɩɪɟɠɞɚɟɬ ɢɦɟɧɧɨ ɨɛ ɷɬɨɦ, ɬɚɤ ɱɬɨ ɥɭɱɲɟ ɫɞɟɥɚɬɶ ɬɨ ɠɟ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ.)

Исключения ɂɧɨɝɞɚ ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɜɵɞɚɜɚɬɶ ɭɬɨɦɢɬɟɥɶɧɵɟ, ɚ ɩɨɪɨɣ ɢ ɩɪɨɫɬɨ ɥɨɠɧɵɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ, ɧɨ ɭ ɜɚɫ ɧɟɬ ɫɩɨɫɨɛɚ ɢɯ ɭɫɬɪɚɧɟɧɢɹ (ɢɥɢ ɬɚɤɨɣ ɫɩɨɫɨɛ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɧɟɪɟɚɥɶɧɨɣ ɢɥɢ ɧɟɩɪɨɢɡɜɨɞɢɬɟɥɶɧɨɣ ɩɟɪɟɞɟɥɤɟ ɬɟɤɫɬɚ ɩɪɨɝɪɚɦɦɵ). ȼ ɬɚɤɢɯ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɩɨ ɪɟɲɟɧɢɸ ɜɫɟɣ ɤɨɦɚɧɞɵ ɪɚɡɪɚɛɨɬɱɢɤɨɜ ɦɨɠɧɨ ɩɨɣɬɢ ɧɚ ɨɬɤɥɸɱɟɧɢɟ ɤɨɧɤɪɟɬɧɵɯ ɦɟɥɤɢɯ ɩɪɟɞɭɩɪɟɠɞɟɧɢɣ, ɤɨɬɨɪɵɟ ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɧɟ ɧɟɫɭɬ ɧɢɤɚɤɨɣ ɨɫɨɛɨɣ ɢɧɮɨɪɦɚɰɢɢ ɢ ɹɜɥɹɸɬɫɹ ɧɟ ɛɨɥɟɟ, ɱɟɦ ɪɟɡɭɥɶɬɚɬɨɦ ɱɪɟɡɦɟɪɧɨɣ ɨɫɬɨɪɨɠɧɨɫɬɢ ɤɨɦɩɢɥɹɬɨɪɚ. Ɍɚɤɢɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ ɦɨɠɧɨ ɨɬɤɥɸɱɢɬɶ, ɧɨ ɬɨɥɶɤɨ ɞɚɧɧɵɟ ɤɨɧɤɪɟɬɧɵɟ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹ, ɚ ɧɟ ɜɫɟ, ɦɚɤɫɢɦɚɥɶɧɨ ɥɨɤɚɥɢɡɨɜɚɜ ɩɪɢ ɷɬɨɦ ɨɛɥɚɫɬɶ ɨɬɤɥɸɱɟɧɢɹ ɢ ɫɨɩɪɨɜɨɞɢɜ ɟɟ ɹɫɧɵɦ ɢ ɩɨɞɪɨɛɧɵɦ ɤɨɦɦɟɧɬɚɪɢɟɦ, ɩɨɱɟɦɭ ɬɚɤɨɣ ɲɚɝ ɧɟɨɛɯɨɞɢɦ.

Ссылки [Meyers97] §48 • [Stroustrup94] §2.6.2

18

Стр. 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

Стр. 20

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

4. Одна голова хорошо, а две — лучше Резюме Ɋɟɝɭɥɹɪɧɨ ɩɪɨɫɦɚɬɪɢɜɚɣɬɟ ɤɨɞ ɜɫɟɣ ɤɨɦɚɧɞɨɣ. ɑɟɦ ɛɨɥɶɲɟ ɝɥɚɡ — ɬɟɦ ɜɵɲɟ ɤɚɱɟɫɬɜɨ ɤɨɞɚ. ɉɨɤɚɠɢɬɟ ɜɚɲ ɤɨɞ ɞɪɭɝɢɦ ɢ ɩɨɡɧɚɤɨɦɶɬɟɫɶ ɫ ɢɯ ɤɨɞɨɦ — ɷɬɨ ɩɪɢɧɟɫɟɬ ɩɨɥɶɡɭ ɜɫɟɦ.

Обсуждение Ɋɟɝɭɥɹɪɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɞɪɭɝɢɦɢ ɱɥɟɧɚɦɢ ɤɨɦɚɧɞɵ ɩɪɢɧɨɫɢɬ ɫɜɨɢ ɩɥɨɞɵ. • • • • • •

ɉɨɜɵɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɤɨɞɚ ɩɪɢ ɞɨɛɪɨɠɟɥɚɬɟɥɶɧɨɣ ɤɪɢɬɢɤɟ ɞɪɭɝɢɦɢ. ȼɵɹɜɥɟɧɢɟ ɨɲɢɛɨɤ, ɧɟɩɟɪɟɧɨɫɢɦɨɝɨ ɤɨɞɚ (ɟɫɥɢ ɷɬɨ ɜɚɠɧɨ) ɢ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɩɪɨɛɥɟɦ, ɫɜɹɡɚɧɧɵɯ ɫ ɦɚɫɲɬɚɛɢɪɨɜɚɧɢɟɦ ɩɪɨɟɤɬɚ. ɍɥɭɱɲɟɧɢɟ ɤɚɱɟɫɬɜɚ ɞɢɡɚɣɧɚ ɢ ɪɟɚɥɢɡɚɰɢɢ ɩɭɬɟɦ ɨɛɦɟɧɚ ɢɞɟɹɦɢ. Ȼɵɫɬɪɨɟ ɨɛɭɱɟɧɢɟ ɧɨɜɵɯ ɱɥɟɧɨɜ ɤɨɦɚɧɞɵ. Ɋɚɡɪɚɛɨɬɤɚ ɨɛɳɢɯ ɩɪɢɧɰɢɩɨɜ ɜ ɤɨɦɚɧɞɟ. ɉɨɜɵɲɟɧɢɟ ɭɪɨɜɧɹ ɦɟɪɢɬɨɤɪɚɬɢɢ1, ɞɨɜɟɪɢɹ, ɩɪɨɮɟɫɫɢɨɧɚɥɶɧɨɣ ɝɨɪɞɨɫɬɢ ɢ ɫɨɬɪɭɞɧɢɱɟɫɬɜɚ ɜ ɤɨɦɚɧɞɟ.

ȼɨ ɦɧɨɝɢɯ ɮɢɪɦɚɯ ɟɳɟ ɧɟ ɫɬɨɥɶ ɩɨɩɭɥɹɪɧɵ, ɤɚɤ ɯɨɬɟɥɨɫɶ ɛɵ, ɜɨɡɧɚɝɪɚɠɞɟɧɢɹ ɡɚ ɤɚɱɟɫɬɜɨ ɤɨɞɚ, ɚ ɬɚɤɠɟ ɤɚɤɢɟ-ɥɢɛɨ ɜɥɨɠɟɧɢɹ ɜɪɟɦɟɧɢ ɢɥɢ ɫɪɟɞɫɬɜ ɜ ɟɝɨ ɩɨɜɵɲɟɧɢɟ. ɇɚɞɟɠɞ ɧɚ ɤɚɪɞɢɧɚɥɶɧɨɟ ɢɡɦɟɧɟɧɢɟ ɫɢɬɭɚɰɢɢ ɦɚɥɨ, ɧɨ ɜɫɟ ɠɟ ɢɡɦɟɧɟɧɢɹ ɜ ɷɬɨɣ ɨɛɥɚɫɬɢ, ɩɭɫɬɶ ɦɟɞɥɟɧɧɨ, ɧɨ ɩɪɨɢɫɯɨɞɹɬ; ɜ ɱɚɫɬɧɨɫɬɢ, ɷɬɨ ɫɜɹɡɚɧɨ ɫ ɜɨɩɪɨɫɚɦɢ ɧɚɞɟɠɧɨɫɬɢ ɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ. Ʉɨɥɥɟɤɬɢɜɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɩɨɦɨɝɚɟɬ ɜ ɪɟɲɟɧɢɢ ɷɬɢɯ ɜɨɩɪɨɫɨɜ, ɜ ɞɨɩɨɥɧɟɧɢɟ ɤ ɬɨɦɭ, ɱɬɨ ɷɬɨ ɨɬɥɢɱɧɵɣ ɢ ɤ ɬɨɦɭ ɠɟ ɛɟɫɩɥɚɬɧɵɣ ɦɟɬɨɞ ɨɛɭɱɟɧɢɹ ɫɨɬɪɭɞɧɢɤɨɜ. Ⱦɚɠɟ ɟɫɥɢ ɜɚɲ ɪɚɛɨɬɨɞɚɬɟɥɶ ɧɟ ɧɚɦɟɪɟɧ ɡɚɛɨɬɢɬɶɫɹ ɨ ɪɟɰɟɧɡɢɪɨɜɚɧɢɢ ɤɨɞɚ, ɩɨɫɬɚɪɚɣɬɟɫɶ ɞɨɧɟɫɬɢ ɦɵɫɥɶ ɨ ɟɝɨ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɞɨ ɦɟɧɟɞɠɟɪɨɜ (ɦɚɥɟɧɶɤɚɹ ɩɨɞɫɤɚɡɤɚ: ɩɨɤɚɠɢɬɟ ɢɦ ɷɬɭ ɤɧɢɝɭ), ɢ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɨɪɝɚɧɢɡɭɣɬɟ ɬɚɤɨɣ ɨɛɦɟɧ ɨɩɵɬɨɦ. Ɂɚɬɪɚɱɟɧɧɨɟ ɧɚ ɷɬɨ ɜɪɟɦɹ ɨɤɭɩɢɬɫɹ ɫɬɨɪɢɰɟɣ. ɋɞɟɥɚɣɬɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ ɨɛɹɡɚɬɟɥɶɧɨɣ ɱɚɫɬɶɸ ɰɢɤɥɚ ɪɚɡɪɚɛɨɬɤɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ ɜ ɜɚɲɟɣ ɤɨɦɚɧɞɟ. Ʌɭɱɲɢɟ ɪɟɡɭɥɶɬɚɬɵ ɞɚɟɬ ɨɩɟɪɚɬɢɜɧɨɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɤɨɞɚ, ɪɚɡɪɚɛɚɬɵɜɚɟɦɨɝɨ ɜ ɧɚɫɬɨɹɳɢɣ ɦɨɦɟɧɬ. Ⱦɥɹ ɷɬɨɝɨ ɧɟ ɬɪɟɛɭɟɬɫɹ ɧɢɤɚɤɨɝɨ ɮɨɪɦɚɥɢɡɦɚ — ɞɨɫɬɚɬɨɱɧɨ ɩɪɨɫɬɨɣ ɷɥɟɤɬɪɨɧɧɨɣ ɩɨɱɬɵ. ɉɪɢ ɬɚɤɨɣ ɨɪɝɚɧɢɡɚɰɢɢ ɪɚɛɨɬɵ ɥɟɝɱɟ ɨɬɫɥɟɠɢɜɚɬɶ ɜɚɲɢ ɫɨɛɫɬɜɟɧɧɵɟ ɞɟɣɫɬɜɢɹ ɢ ɢɡɛɟɝɚɬɶ ɞɭɛɥɢɪɨɜɚɧɢɹ. Ʉɨɝɞɚ ɜɵ ɪɚɛɨɬɚɟɬɟ ɫ ɱɭɠɢɦ ɤɨɞɨɦ, ɡɚɱɚɫɬɭɸ ɭɞɨɛɧɨ ɢɦɟɬɶ ɩɨɞ ɪɭɤɨɣ ɫɩɢɫɨɤ ɬɨɝɨ, ɧɚ ɱɬɨ ɢɦɟɧɧɨ ɫɥɟɞɭɟɬ ɨɛɪɚɳɚɬɶ ɜɧɢɦɚɧɢɟ. Ɇɵ ɫɤɪɨɦɧɨ ɩɪɟɞɥɚɝɚɟɦ ɜ ɤɚɱɟɫɬɜɟ ɜɚɪɢɚɧɬɚ ɬɚɤɨɝɨ ɫɩɢɫɤɚ ɨɝɥɚɜɥɟɧɢɟ ɞɚɧɧɨɣ ɤɧɢɝɢ. Ɇɵ ɡɧɚɟɦ, ɱɬɨ ɱɢɬɚɟɦ ɩɪɨɩɨɜɟɞɶ, ɧɨ ɦɵ ɞɨɥɠɧɵ ɛɵɥɢ ɫɤɚɡɚɬɶ ɷɬɨ ɜɫɥɭɯ. Ⱦɚ, ɜɚɲɟ ɷɝɨ ɦɨɠɟɬ ɧɟɧɚɜɢɞɟɬɶ ɩɨɤɚɡɵɜɚɬɶ ɫɜɨɢ ɢɫɯɨɞɧɵɟ ɬɟɤɫɬɵ ɞɥɹ ɜɫɟɨɛɳɟɣ ɤɪɢɬɢɤɢ, ɧɨ ɩɨɜɟɪɶɬɟ, ɦɚɥɟɧɶɤɨɦɭ ɝɟɧɢɚɥɶɧɨɦɭ ɩɪɨɝɪɚɦɦɢɫɬɭ ɜɧɭɬɪɢ ɜɚɫ ɩɨ ɞɭɲɟ ɪɟɰɟɧɡɢɪɨɜɚɧɢɟ ɟɝɨ ɤɨɞɚ, ɩɨɬɨɦɭ ɱɬɨ ɜ ɪɟɡɭɥɶɬɚɬɟ ɨɧ ɫɦɨɠɟɬ ɩɢɫɚɬɶ ɟɳɟ ɛɨɥɟɟ ɬɚɥɚɧɬɥɢɜɵɟ ɩɪɨɝɪɚɦɦɵ.

Ссылки [Constantine95] §10, §22, §33 • [McConnell93] §24 • [MozillaCRFAQ]

1

ɋɢɫɬɟɦɚ, ɩɪɢ ɤɨɬɨɪɨɣ ɩɨɥɨɠɟɧɢɟ ɱɟɥɨɜɟɤɚ ɜ ɨɛɳɟɫɬɜɟ ɨɩɪɟɞɟɥɹɟɬɫɹ ɟɝɨ ɫɩɨɫɨɛɧɨɫɬɹɦɢ. — ɉɪɢɦ. ɩɟɪɟɜ.

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

Стр. 21

21

22

Стр. 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

Стр. 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

Стр. 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

Стр. 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

Стр. 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

Стр. 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

Стр. 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 ); // ǍȆDzǹǭ OpenPort ~Port(); // ǍȆDzǹǭ ClosePort // ǚǹǻǽȆ ǹǬȆȂǸǹ Ǹǰ ǵǶǹǸdzǻǾȉǽǼȊ, ǽǫǵ Ȃǽǹ DzǫǺǻǰȄǫǰǷ // ǵǹǺdzǻǹǭǫǸdzǰ dz ǺǻdzǼǭǫdzǭǫǸdzǰ }; void DoSomething() { Port port1( "server1:80" ); // ... } // ǒǫǬȆǽȇ DzǫǵǻȆǽȇ Ǻǹǻǽ ǸǰǶȇDzȊ — ǹǸ ǬǾǯǰǽ DzǫǵǻȆǽ // ǫǭǽǹǷǫǽdzȂǰǼǵdz Ǻǻdz ǭȆȀǹǯǰ dzDz ǹǬǶǫǼǽdz ǭdzǯdzǷǹǼǽdz shared_ptr port2 = /*...*/; // port2 ǬǾǯǰǽ DzǫǵǻȆǽ // ǫǭǽǹǷǫǽdzȂǰǼǵdz, ǵǹǮǯǫ ǬǾǯǰǽ ǾǸdzȂǽǹDZǰǸ ǺǹǼǶǰǯǸdzǴ // ǼǼȆǶǫȉȄdzǴǼȊ Ǹǫ ǸǰǮǹ ǹǬȅǰǵǽ shared_ptr

ȼɵ ɦɨɠɟɬɟ ɬɚɤɠɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɛɢɛɥɢɨɬɟɤɢ, ɤɨɬɨɪɵɟ ɪɟɚɥɢɡɭɸɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɲɚɛɥɨɧ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ (ɫɦ. [Alexandrescu00c]). ɉɪɢ ɪɟɚɥɢɡɚɰɢɢ ɢɞɢɨɦɵ RAII ɫɥɟɞɭɟɬ ɨɫɨɛɨ ɬɳɚɬɟɥɶɧɨ ɩɨɞɯɨɞɢɬɶ ɤ ɜɨɩɪɨɫɭ ɨ ɤɨɩɢɪɭɸɳɟɦ ɤɨɧɫɬɪɭɤɬɨɪɟ ɢ ɩɪɢɫɜɚɢɜɚɧɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 49): ɨɛɵɱɧɨ ɝɟɧɟɪɢɪɭɟɦɵɟ ɤɨɦɩɢɥɹɬɨɪɨɦ ɜɟɪɫɢɢ ɷɬɢɯ ɮɭɧɤɰɢɣ ɧɟ ɩɨɞɯɨɞɹɬ. ȿɫɥɢ ɤɨɩɢɪɨɜɚɧɢɟ ɥɢɲɟɧɨ ɫɦɵɫɥɚ, ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ ɦɨɠɧɨ ɹɜɧɵɦ ɨɛɪɚɡɨɦ ɡɚɩɪɟɬɢɬɶ, ɞɟɥɚɹ ɢɯ ɡɚɤɪɵɬɵɦɢ 13. Ресурсы должны быть во владении объектов

Стр. 37

37

ɱɥɟɧɚɦɢ ɢ ɧɟ ɨɩɪɟɞɟɥɹɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 53). ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɤɨɩɢɪɭɸɳɢɣ ɤɨɧɫɬɪɭɤɬɨɪ ɞɭɛɥɢɪɭɟɬ ɪɟɫɭɪɫ ɢɥɢ ɢɫɩɨɥɶɡɭɟɬ ɫɱɟɬɱɢɤ ɫɫɵɥɨɤ ɧɚ ɧɟɝɨ, ɢ ɬɨ ɠɟ ɞɟɥɚɟɬ ɢ ɨɩɟɪɚɬɨɪ ɩɪɢɫɜɚɢɜɚɧɢɹ, ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɨɫɜɨɛɨɞɢɜ ɪɟɫɭɪɫ, ɤɨɬɨɪɵɦ ɨɛɴɟɤɬ ɜɥɚɞɟɥ ɞɨ ɩɪɢɫɜɚɢɜɚɧɢɹ. Ʉɥɚɫɫɢɱɟɫɤɨɣ ɨɲɢɛɤɨɣ ɹɜɥɹɟɬɫɹ ɨɫɜɨɛɨɠɞɟɧɢɟ ɫɬɚɪɨɝɨ ɪɟɫɭɪɫɚ ɞɨ ɬɨɝɨ, ɤɚɤ ɭɫɩɟɲɧɨ ɞɭɛɥɢɪɨɜɚɧ ɧɨɜɵɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71). Ɉɛɟɫɩɟɱɶɬɟ, ɱɬɨɛɵ ɜɫɟ ɪɟɫɭɪɫɵ ɩɪɢɧɚɞɥɟɠɚɥɢ ɨɛɴɟɤɬɚɦ. ɉɪɟɞɩɨɱɬɢɬɟɥɶɧɨ ɯɪɚɧɢɬɶ ɜɫɟ ɞɢɧɚɦɢɱɟɫɤɢ ɜɵɞɟɥɟɧɧɵɟ ɪɟɫɭɪɫɵ ɩɨɫɪɟɞɫɬɜɨɦ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɯ, ɚ ɧɟ ɨɛɵɱɧɵɯ, ɭɤɚɡɚɬɟɥɟɣ. Ʉɪɨɦɟ ɬɨɝɨ, ɫɥɟɞɭɟɬ ɜɵɩɨɥɧɹɬɶ ɤɚɠɞɨɟ ɹɜɧɨɟ ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, new) ɜ ɨɬɞɟɥɶɧɨɣ ɢɧɫɬɪɭɤɰɢɢ, ɤɨɬɨɪɚɹ ɬɭɬ ɠɟ ɩɟɪɟɞɚɟɬ ɪɟɫɭɪɫ ɭɩɪɚɜɥɹɸɳɟɦɭ ɨɛɴɟɤɬɭ (ɧɚɩɪɢɦɟɪ, shared_ptr). ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɦɨɠɟɬ ɜɨɡɧɢɤɧɭɬɶ ɭɬɟɱɤɚ ɪɟɫɭɪɫɨɜ, ɫɜɹɡɚɧɧɚɹ ɫ ɬɟɦ, ɱɬɨ ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɩɚɪɚɦɟɬɪɨɜ ɮɭɧɤɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 31). ɇɚɩɪɢɦɟɪ: void Fun(shared_ptr sp1, shared_ptr sp2); // ... new Widget), Fun(shared_ptr(n shared_ptr(n new Widget));

Ɍɚɤɨɣ ɤɨɞ ɧɟɛɟɡɨɩɚɫɟɧ. ɋɬɚɧɞɚɪɬ C++ ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɤɨɦɩɢɥɹɬɨɪɭ ɛɨɥɶɲɭɸ ɫɜɨɛɨɞɭ ɞɟɣɫɬɜɢɣ ɩɨ ɩɟɪɟɭɩɨɪɹɞɨɱɟɧɢɸ ɜɵɪɚɠɟɧɢɣ, ɤɨɬɨɪɵɟ ɫɨɡɞɚɸɬ ɞɜɚ ɚɪɝɭɦɟɧɬɚ ɮɭɧɤɰɢɢ. ȼ ɱɚɫɬɧɨɫɬɢ, ɤɨɦɩɢɥɹɬɨɪ ɦɨɠɟɬ ɱɟɪɟɞɨɜɚɬɶ ɜɵɩɨɥɧɟɧɢɟ ɷɬɢɯ ɞɜɭɯ ɜɵɪɚɠɟɧɢɣ: ɫɧɚɱɚɥɚ ɞɥɹ ɨɛɨɢɯ ɨɛɴɟɤɬɨɜ ɦɨɠɟɬ ɛɵɬɶ ɜɵɩɨɥɧɟɧɨ ɜɵɞɟɥɟɧɢɟ ɩɚɦɹɬɢ (ɩɪɢ ɩɨɦɨɳɢ ɨɩɟɪɚɬɨɪɚ new), ɚ ɭɠɟ ɡɚɬɟɦ ɛɭɞɭɬ ɜɵɡɜɚɧɵ ɞɜɚ ɤɨɧɫɬɪɭɤɬɨɪɚ Widget. Ɍɚɤɚɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɞɟɣɫɬɜɢɣ ɦɨɠɟɬ ɩɪɢɜɟɫɬɢ ɤ ɭɬɟɱɤɟ: ɟɫɥɢ ɨɞɢɧ ɢɡ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɫɝɟɧɟɪɢɪɭɟɬ ɢɫɤɥɸɱɟɧɢɟ, ɬɨ ɩɚɦɹɬɶ ɞɥɹ ɞɪɭɝɨɝɨ ɨɛɴɟɤɬɚ ɧɢɤɨɝɞɚ ɧɟ ɛɭɞɟɬ ɨɫɜɨɛɨɠɞɟɧɚ (ɛɨɥɟɟ ɞɟɬɚɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɩɨ ɷɬɨɦɭ ɜɨɩɪɨɫɭ ɜɵ ɧɚɣɞɟɬɟ ɜ [Sutter02]). ɗɬɚ ɬɨɧɤɚɹ ɩɪɨɛɥɟɦɚ ɢɦɟɟɬ ɩɪɨɫɬɨɟ ɪɟɲɟɧɢɟ: ɫɥɟɞɭɣɬɟ ɩɪɢɜɟɞɟɧɧɨɦɭ ɜɵɲɟ ɫɨɜɟɬɭ ɢ ɧɢɤɨɝɞɚ ɧɟ ɜɵɞɟɥɹɣɬɟ ɜ ɨɞɧɨɣ ɢɧɫɬɪɭɤɰɢɢ ɛɨɥɶɲɟ ɨɞɧɨɝɨ ɪɟɫɭɪɫɚ. ɋɥɟɞɭɟɬ ɜɵɩɨɥɧɹɬɶ ɤɚɠɞɨɟ ɹɜɧɨɟ ɜɵɞɟɥɟɧɢɟ ɪɟɫɭɪɫɚ (ɧɚɩɪɢɦɟɪ, new) ɜ ɨɬɞɟɥɶɧɨɣ ɢɧɫɬɪɭɤɰɢɢ, ɤɨɬɨɪɚɹ ɬɭɬ ɠɟ ɩɟɪɟɞɚɟɬ ɪɟɫɭɪɫ ɭɩɪɚɜɥɹɸɳɟɦɭ ɨɛɴɟɤɬɭ (ɧɚɩɪɢɦɟɪ, shared_ptr), ɧɚɩɪɢɦɟɪ: shared_ptr 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

Стр. 38

Стиль проектирования

Стиль кодирования Ʉɨɧɫɬɚɧɬɚ ɞɥɹ ɨɞɧɨɝɨ ɹɜɥɹɟɬɫɹ ɩɟɪɟɦɟɧɧɨɣ ɞɥɹ ɞɪɭɝɨɝɨ. — Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis) ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɩɟɪɟɣɞɟɦ ɨɬ ɜɨɩɪɨɫɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɤ ɜɨɩɪɨɫɚɦ, ɤɨɬɨɪɵɟ ɩɨɹɜɥɹɸɬɫɹ ɜ ɨɫɧɨɜɧɨɦ ɩɪɢ ɪɟɚɥɶɧɨɦ ɤɨɞɢɪɨɜɚɧɢɢ. ɉɪɚɜɢɥɚ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ ɢɡ ɷɬɨɝɨ ɪɚɡɞɟɥɚ ɩɪɢɦɟɧɢɦɵ ɛɟɡɨɬɧɨɫɢɬɟɥɶɧɨ ɤ ɤɨɧɤɪɟɬɧɨɣ ɨɛɥɚɫɬɢ ɹɡɵɤɚ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ (ɧɚɩɪɢɦɟɪ, ɮɭɧɤɰɢɹɦ, ɤɥɚɫɫɚɦ ɢɥɢ ɩɪɨɫɬɪɚɧɫɬɜɚɦ ɢɦɟɧ), ɧɨ ɩɪɢɜɨɞɹɬ ɤ ɩɨɜɵɲɟɧɢɸ ɤɚɱɟɫɬɜɚ ɜɚɲɟɝɨ ɤɨɞɚ. Ɇɧɨɝɢɟ ɢɡ ɩɪɟɞɫɬɚɜɥɟɧɧɵɯ ɢɞɢɨɦ ɩɨɡɜɨɥɹɸɬ ɜɚɲɟɦɭ ɤɨɦɩɢɥɹɬɨɪɭ ɚɤɬɢɜɧɟɟ ɩɨɦɨɝɚɬɶ ɜɚɦ ɜ ɪɚɛɨɬɟ, ɚ ɜɚɦ — ɢɡɛɟɠɚɬɶ ɨɩɚɫɧɵɯ ɦɟɫɬ (ɜɤɥɸɱɚɹ ɧɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ), ɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɜɫɟɝɞɚ ɜ ɫɨɫɬɨɹɧɢɢ ɜɵɹɜɢɬɶ. ȼɫɟ ɷɬɨ ɞɟɥɚɟɬ ɜɚɲ ɤɨɞ ɛɨɥɟɟ ɧɚɞɟɠɧɵɦ. ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɦɵ ɫɱɢɬɚɟɦ ɧɚɢɛɨɥɟɟ ɜɚɠɧɨɣ ɪɟɤɨɦɟɧɞɚɰɢɸ 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& v ) { // ... const size_t len = v.size(); // ... dz ǰȄǰ 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

Стр. 42

Стиль кодирования

ɩɚɫɧɵɦ. ȿɫɥɢ ɜɵ ɜɵɹɫɧɢɥɢ, ɱɬɨ ɧɟɤɨɬɨɪɭɸ ɮɭɧɤɰɢɸ-ɱɥɟɧ ɧɟɜɨɡɦɨɠɧɨ ɫɞɟɥɚɬɶ ɤɨɧɫɬɚɧɬɧɨɣ, ɡɧɚɱɢɬ, ɜɵ ɛɨɥɟɟ ɞɟɬɚɥɶɧɨ ɪɚɡɨɛɪɚɥɢɫɶ ɫ ɬɟɦ, ɤɚɤ, ɝɞɟ ɢ ɩɨɱɟɦɭ ɷɬɚ ɮɭɧɤɰɢɹ ɦɨɞɢɮɢɰɢɪɭɟɬ ɫɨɫɬɨɹɧɢɟ ɨɛɴɟɤɬɚ. Ʉɪɨɦɟ ɬɨɝɨ, ɜɵ ɫɦɨɠɟɬɟ ɩɨɧɹɬɶ, ɤɚɤɢɟ ɱɥɟɧɵ-ɞɚɧɧɵɟ ɨɛɴɟɞɢɧɹɸɬ ɮɢɡɢɱɟɫɤɭɸ ɢ ɥɨɝɢɱɟɫɤɭɸ ɤɨɧɫɬɚɧɬɧɨɫɬɶ (ɫɦ. ɩɪɢɜɟɞɟɧɧɵɟ ɧɢɠɟ ɩɪɢɦɟɪɵ). ɇɢɤɨɝɞɚ ɧɟ ɩɪɢɛɟɝɚɣɬɟ ɤ ɩɪɟɨɛɪɚɡɨɜɚɧɢɸ ɤɨɧɫɬɚɧɬɧɨɝɨ ɬɢɩɚ ɜ ɧɟɤɨɧɫɬɚɧɬɧɵɣ, ɤɪɨɦɟ ɫɥɭɱɚɟɜ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ, ɧɟɤɨɪɪɟɤɬɧɨɣ ɜ ɩɥɚɧɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɦɨɞɢɮɢɤɚɬɨɪɚ const (ɧɟ ɦɨɞɢɮɢɰɢɪɭɸɳɟɣ ɩɚɪɚɦɟɬɪ, ɤɨɬɨɪɵɣ ɬɟɦ ɧɟ ɦɟɧɟɟ ɨɩɢɫɚɧ ɤɚɤ ɧɟɤɨɧɫɬɚɧɬɧɵɣ), ɚ ɬɚɤɠɟ ɬɚɤɨɝɨ ɪɟɞɤɨɝɨ ɫɥɭɱɚɹ, ɤɚɤ ɫɩɨɫɨɛ ɡɚɦɟɧɵ mutable ɜ ɫɬɚɪɨɦ ɤɨɦɩɢɥɹɬɨɪɟ, ɧɟ ɩɨɞɞɟɪɠɢɜɚɸɳɟɦ ɷɬɭ ɜɨɡɦɨɠɧɨɫɬɶ.

Примеры ɉɪɢɦɟɪ. ɂɡɛɟɝɚɣɬɟ const ɜ ɨɛɴɹɜɥɟɧɢɹɯ ɮɭɧɤɰɢɣ, ɩɪɢɧɢɦɚɸɳɢɯ ɩɚɪɚɦɟɬɪɵ ɩɨ ɡɧɚɱɟɧɢɸ. Ⱦɜɚ ɫɥɟɞɭɸɳɢɯ ɨɛɴɹɜɥɟɧɢɹ ɚɛɫɨɥɸɬɧɨ ɷɤɜɢɜɚɥɟɧɬɧɵ: void Fun( int x ); void Fun( const int x ); // ǙǬȅȊǭǶǰǸdzǰ ǽǹǴ DZǰ ǼǫǷǹǴ ǿǾǸǵȁdzdz: // const DzǯǰǼȇ dzǮǸǹǻdzǻǾǰǽǼȊ

ȼɨ ɜɬɨɪɨɦ ɨɛɴɹɜɥɟɧɢɢ ɦɨɞɢɮɢɤɚɬɨɪ const ɢɡɛɵɬɨɱɟɧ. Ɇɵ ɪɟɤɨɦɟɧɞɭɟɦ ɨɛɴɹɜɥɹɬɶ ɮɭɧɤɰɢɢ ɛɟɡ ɬɚɤɢɯ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɯ ɦɨɞɢɮɢɤɚɬɨɪɨɜ const, ɱɬɨɛɵ ɬɨɬ, ɤɬɨ ɱɢɬɚɟɬ ɜɚɲɢ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɧɟ ɛɵɥ ɞɟɡɨɪɢɟɧɬɢɪɨɜɚɧ. Ɉɞɧɚɤɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɬɚɤɨɝɨ ɦɨɞɢɮɢɤɚɬɨɪɚ ɢɦɟɟɬ ɡɧɚɱɟɧɢɟ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɮɭɧɤɰɢɢ ɢ ɟɝɨ ɩɪɢɦɟɧɟɧɢɟ ɦɨɠɟɬ ɛɵɬɶ ɨɩɪɚɜɞɚɧɨ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɨɛɧɚɪɭɠɟɧɢɹ ɧɟɩɪɟɞɧɚɦɟɪɟɧɧɨɝɨ ɢɡɦɟɧɟɧɢɹ ɩɟɪɟɞɚɧɧɨɝɨ ɩɚɪɚɦɟɬɪɚ: void Fun( const int x ) { // ǙǺǻǰǯǰǶǰǸdzǰ ǿǾǸǵȁdzdz Fun // ... ++x; // ǙȃdzǬǵǫ: ǸǰǶȇDzȊ dzDzǷǰǸȊǽȇ ǵǹǸǼǽǫǸǽǸǹǰ DzǸǫȂǰǸdzǰ // ... }

Ссылки [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

Стр. 44

Стиль кодирования

Ⱦɚɠɟ ɜ ɬɟɯ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ, ɝɞɟ ɩɪɢɦɟɧɟɧɢɟ ɦɚɤɪɨɫɨɜ ɨɩɪɚɜɞɚɧɧɨ (ɫɦ. ɩɨɞɪɚɡɞɟɥ, ɩɨɫɜɹɳɟɧɧɵɣ ɢɫɤɥɸɱɟɧɢɹɦ), ɧɟɥɶɡɹ ɞɚɠɟ ɩɨɞɭɦɚɬɶ ɨ ɬɨɦ, ɱɬɨɛɵ ɧɚɩɢɫɚɬɶ ɦɚɤɪɨɫ, ɤɨɬɨɪɵɣ ɹɜɥɹɟɬɫɹ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɦ ɫɥɨɜɨɦ ɢɥɢ ɚɛɛɪɟɜɢɚɬɭɪɨɣ. Ⱦɥɹ ɜɫɟɯ ɦɚɤɪɨɫɨɜ ɤɚɤ ɦɨɠɧɨ ɫɤɨɪɟɟ ɩɪɢɦɟɧɹɣɬɟ ɞɢɪɟɤɬɢɜɭ #undef, ɜɫɟɝɞɚ ɞɚɜɚɹ ɢɦ ɧɟɨɛɵɱɧɵɟ ɭɪɨɞɥɢɜɵɟ ɢɦɟɧɚ ɜ ɜɟɪɯɧɟɦ ɪɟɝɢɫɬɪɟ, ɢɡɛɟɝɚɹ ɩɪɢ ɷɬɨɦ ɪɚɡɦɟɳɟɧɢɹ ɢɯ ɜ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ.

Примеры ɉɪɢɦɟɪ. ɉɟɪɟɞɚɱɚ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ ɲɚɛɥɨɧɚ ɦɚɤɪɨɫɭ. Ɇɚɤɪɨɫɵ ɩɨɧɢɦɚɸɬ ɜ ɞɨɫɬɚɬɨɱɧɨɣ ɦɟɪɟ ɬɨɥɶɤɨ ɤɪɭɝɥɵɟ ɢ ɤɜɚɞɪɚɬɧɵɟ ɫɤɨɛɤɢ. ȼ C++, ɨɞɧɚɤɨ, ɨɩɪɟɞɟɥɟɧɚ ɧɨɜɚɹ ɤɨɧɫɬɪɭɤɰɢɹ ɫ ɭɝɥɨɜɵɦɢ ɫɤɨɛɤɚɦɢ, ɢɫɩɨɥɶɡɭɟɦɚɹ ɜ ɲɚɛɥɨɧɚɯ. Ɇɚɤɪɨɫɵ ɧɟ ɦɨɝɭɬ ɤɨɪɪɟɤɬɧɨ ɨɛɪɚɛɨɬɚɬɶ ɷɬɭ ɫɢɬɭɚɰɢɸ, ɬɚɤ ɱɬɨ ɜɵɡɨɜ MACRO( Foo )

ɦɚɤɪɨɫ ɜɨɫɩɪɢɧɢɦɚɟɬ ɬɚɤ, ɛɭɞɬɨ ɟɦɭ ɩɟɪɟɞɚɧɵ ɞɜɚ ɚɪɝɭɦɟɧɬɚ, ɚ ɢɦɟɧɧɨ Foo, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɷɬɚ ɤɨɧɫɬɪɭɤɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɟɞɢɧɵɣ ɨɛɴɟɤɬ 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 { // ǒǸǫȂǰǸdzǰ ǾǵǫDzǫǸǹ ǭ ǹǬȅȊǭǶǰǸdzdz static const int defaultWidth = 400; // ǒǸǫȂǰǸdzǰ ǾǵǫDzǫǸǹ ǭ ǹǺǻǰǯǰǶǰǸdzdz static const double defaultPercent; static const char* Name() { return "Widget"; } }; // ǟǫǴǶ widget.cpp // ǒǸǫȂǰǸdzǰ ǾǵǫDzǫǸǹ ǭ ǹǺǻǰǯǰǶǰǸdzdz const double Widget::defaultPercent = 66.67; // ǝǻǰǬǾǰǽǼȊ ǹǬȅȊǭǶǰǸdzǰ const int Widget::defaultWidth;

Ссылки [Dewhurst03] §2 • [Kernighan99] §1.5 • [Stroustrup00] §4.8, §5.4

46

Стр. 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. ɂɫɩɨɥɶɡɨɜɚɧɢɟ ɢɧɢɰɢɚɥɢɡɢɪɭɸɳɟɝɨ ɡɧɚɱɟɧɢɹ ɩɨ ɭɦɨɥɱɚɧɢɸ ɢɥɢ ɨɩɟɪɚɬɨɪɚ ?: ɞɥɹ ɫɧɢɠɟɧɢɹ ɫɬɟɩɟɧɢ ɫɦɟɲɢɜɚɧɢɹ ɩɨɬɨɤɚ ɞɚɧɧɵɯ ɢ ɩɨɬɨɤɚ ɭɩɪɚɜɥɟɧɢɹ. // ǘǰ ǻǰǵǹǷǰǸǯǾǰǽǼȊ: Ǹǰ dzǸdzȁdzǫǶdzDzdzǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ int speedupFactor ; if( condition ) speedupFactor = 2; else speedupFactor = -1; // ǖǾȂȃǰ: dzǸdzȁdzǫǶdzDzdzǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ int speedupFactor = -1; if( condition ) speedupFactor = 2; // ǖǾȂȃǰ: dzǸdzȁdzǫǶdzDzdzǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ int speedupFactor = condition ? 2 : -1;

ȼɚɪɢɚɧɬɵ, ɨɬɦɟɱɟɧɧɵɟ ɤɚɤ ɥɭɱɲɢɟ, ɧɟ ɢɦɟɸɬ ɩɪɨɦɟɠɭɬɤɚ ɦɟɠɞɭ ɨɩɪɟɞɟɥɟɧɢɟɦ ɢ ɢɧɢɰɢɚɥɢɡɚɰɢɟɣ.

48

Стр. 48

Стиль кодирования

ɉɪɢɦɟɪ 2. Ɂɚɦɟɧɚ ɫɥɨɠɧɵɯ ɜɵɱɢɫɥɟɧɢɣ ɜɵɡɨɜɨɦ ɮɭɧɤɰɢɢ. ɂɧɨɝɞɚ ɜɵɱɢɫɥɟɧɢɟ ɡɧɚɱɟɧɢɹ ɩɪɨɢɫɯɨɞɢɬ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨ ɥɭɱɲɟ ɢɧɤɚɩɫɭɥɢɪɨɜɚɬɶ ɟɝɨ ɜ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). // ǘǰ ǻǰǵǹǷǰǸǯǾǰǽǼȊ: Ǹǰ dzǸdzȁdzǫǶdzDzdzǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ int speedupFactor ; if( condition ) { // ... ǵǹǯ ... speedupFactor = someValue; } else { // ... ǵǹǯ ... speedupFactor = someOtherValue; } // ǖǾȂȃǰ: dzǸdzȁdzǫǶdzDzdzǻǾǰǽ ǺǰǻǰǷǰǸǸǾȉ int speedupFactor = ComputeSpeedupFactor ();

ɉɪɢɦɟɪ 3. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɦɚɫɫɢɜɨɜ. Ⱦɥɹ ɛɨɥɶɲɢɯ ɫɨɫɬɚɜɧɵɯ ɬɢɩɨɜ, ɬɚɤɢɯ ɤɚɤ ɦɚɫɫɢɜɵ, ɤɨɪɪɟɤɬɧɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɧɟ ɜɫɟɝɞɚ ɨɡɧɚɱɚɟɬ ɪɟɚɥɶɧɨɟ ɨɛɪɚɳɟɧɢɟ ɤ ɞɚɧɧɵɦ. ɉɭɫɬɶ, ɧɚɩɪɢɦɟɪ, ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ API, ɤɨɬɨɪɵɣ ɡɚɫɬɚɜɥɹɟɬ ɜɚɫ ɢɫɩɨɥɶɡɨɜɚɬɶ ɮɢɤɫɢɪɨɜɚɧɧɵɟ ɦɚɫɫɢɜɵ char ɪɚɡɦɟɪɚ MAX_PATH (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 77 ɢ 78). ȿɫɥɢ ɜɵ ɭɜɟɪɟɧɵ, ɱɬɨ ɦɚɫɫɢɜɵ ɜɫɟɝɞɚ ɛɭɞɭɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶɫɹ ɤɚɤ ɫɬɪɨɤɢ ɜ ɫɬɢɥɟ C ɫ ɡɚɜɟɪɲɚɸɳɢɦ ɧɭɥɟɜɵɦ ɫɢɦɜɨɥɨɦ, ɬɨ ɬɚɤɨɝɨ ɧɟɦɟɞɥɟɧɧɨɝɨ ɩɪɢɫɜɚɢɜɚɧɢɹ ɛɭɞɟɬ ɞɨɫɬɚɬɨɱɧɨ: // ǏǹǺǾǼǽdzǷǹ: ǜǹDzǯǫǸdzǰ ǺǾǼǽǹǴ Ǽǽǻǹǵdz char path[MAX_PATH]; path[0] = '\0';

Ȼɨɥɟɟ ɛɟɡɨɩɚɫɧɚɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɡɚɩɨɥɧɹɟɬ ɜɫɟ ɷɥɟɦɟɧɬɵ ɦɚɫɫɢɜɚ ɧɭɥɟɜɵɦɢ ɡɧɚɱɟɧɢɹɦɢ: // ǖǾȂȃǰ: DzǫǺǹǶǸȊǰǷ ǸǾǶȊǷdz ǭǰǼȇ ǷǫǼǼdzǭ 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 ɢ ɬ.ɩ. ɫɨɨɬɜɟɬɫɬɜɭɟɬ ɜɨɬ ɷɬɚ ɡɚɤɪɵɜɚɸɳɚɹ ɮɢɝɭɪɧɚɹ ɫɤɨɛɤɚ? Ȼɨɥɟɟ ɯɨɪɨɲɟɟ ɢ ɩɪɨɞɭɦɚɧɧɨɟ ɪɚɡɥɨɠɟɧɢɟ ɡɚɞɚɱɢ ɧɚ ɮɭɧɤɰɢɢ ɩɨɡɜɨɥɢɬ ɱɢɬɚɬɟɥɸ ɜɚɲɟɣ ɩɪɨɝɪɚɦɦɵ ɨɞɧɨɜɪɟɦɟɧɧɨ ɭɞɟɪɠɢɜɚɬɶ ɜ ɝɨɥɨɜɟ ɫɭɳɟɫɬɜɟɧɧɨ ɛɨɥɶɲɢɣ ɤɨɧɬɟɤɫɬ. ȼɨɫɩɨɥɶɡɭɣɬɟɫɶ ɡɞɪɚɜɵɦ ɫɦɵɫɥɨɦ. Ɉɝɪɚɧɢɱɢɜɚɣɬɟ ɞɥɢɧɭ ɢ ɝɥɭɛɢɧɭ ɜɚɲɢɯ ɮɭɧɤɰɢɣ. Ⱦɚɥɟɟ ɩɪɢɜɟɞɟɧɵ ɧɟɤɨɬɨɪɵɟ ɞɨɛɪɵɟ ɫɨɜɟɬɵ, ɤɨɬɨɪɵɟ ɩɨɦɨɝɭɬ ɜɚɦ ɜ ɷɬɨɦ.

50

Стр. 50

•

ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɫɜɹɡɧɨɫɬɶ. ɉɭɫɬɶ ɨɞɧɚ ɮɭɧɤɰɢɹ ɪɟɲɚɟɬ ɬɨɥɶɤɨ ɨɞɧɭ ɡɚɞɚɱɭ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5).

•

ɇɟ ɩɨɜɬɨɪɹɣɬɟɫɶ. ɋɥɟɞɭɟɬ ɩɪɟɞɩɨɱɟɫɬɶ ɢɦɟɧɨɜɚɧɧɭɸ ɮɭɧɤɰɢɸ ɩɨɜɬɨɪɭ ɫɯɨɠɢɯ ɮɪɚɝɦɟɧɬɨɜ ɤɨɞɚ.

•

ɉɨɥɶɡɭɣɬɟɫɶ ɨɩɟɪɚɬɨɪɨɦ &&. ɂɡɛɟɝɚɣɬɟ ɜɥɨɠɟɧɧɵɯ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɤɨɧɫɬɪɭɤɰɢɣ if ɬɚɦ, ɝɞɟ ɢɯ ɦɨɠɧɨ ɡɚɦɟɧɢɬɶ ɨɩɟɪɚɬɨɪɨɦ &&.

•

ɇɟ ɧɚɝɪɭɠɚɣɬɟ try. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɫɜɨɛɨɠɞɟɧɢɟ ɪɟɫɭɪɫɨɜ ɜ ɞɟɫɬɪɭɤɬɨɪɚɯ, ɚ ɧɟ ɜ try-ɛɥɨɤɚɯ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 13).

•

ɉɨɥɶɡɭɣɬɟɫɶ ɚɥɝɨɪɢɬɦɚɦɢ. Ɉɧɢ ɤɨɪɨɱɟ, ɱɟɦ ɪɭɤɨɩɢɫɧɵɟ ɰɢɤɥɵ, ɢ ɡɚɱɚɫɬɭɸ ɥɭɱɲɟ ɢ ɷɮɮɟɤɬɢɜɧɟɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 84).

•

ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ switch ɞɥɹ ɞɟɫɤɪɢɩɬɨɪɨɜ ɬɢɩɨɜ. ɉɪɢɦɟɧɹɣɬɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɩɨɥɢɦɨɪɮɧɵɟ ɮɭɧɤɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 90).

Стиль кодирования

Исключения Ɏɭɧɤɰɢɹ ɦɨɠɟɬ ɧɚ ɡɚɤɨɧɧɵɯ ɨɫɧɨɜɚɧɢɹɯ ɛɵɬɶ ɞɥɢɧɧɨɣ ɢ/ɢɥɢ ɝɥɭɛɨɤɨɣ, ɟɫɥɢ ɟɟ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɧɟɥɶɡɹ ɪɚɡɭɦɧɨ ɪɚɡɞɟɥɢɬɶ ɧɚ ɨɬɞɟɥɶɧɵɟ ɩɨɞɡɚɞɚɱɢ, ɩɨɫɤɨɥɶɤɭ ɤɚɠɞɨɟ ɬɚɤɨɟ ɩɨɬɟɧɰɢɚɥɶɧɨɟ ɪɚɡɞɟɥɟɧɢɟ ɬɪɟɛɭɟɬ ɩɟɪɟɞɚɱɢ ɦɚɫɫɵ ɥɨɤɚɥɶɧɵɯ ɩɟɪɟɦɟɧɧɵɯ ɢ ɤɨɧɬɟɤɫɬɚ (ɱɬɨ ɩɪɢɜɨɞɢɬ ɤ ɟɳɟ ɦɟɧɟɟ ɭɞɨɛɨɱɢɬɚɟɦɨɦɭ ɪɟɡɭɥɶɬɚɬɭ). ɇɨ ɟɫɥɢ ɧɟɫɤɨɥɶɤɨ ɬɚɤɢɯ ɩɨɬɟɧɰɢɚɥɶɧɵɯ ɮɭɧɤɰɢɣ ɩɨɥɭɱɚɸɬ ɚɧɚɥɨɝɢɱɧɵɟ ɚɪɝɭɦɟɧɬɵ, ɨɧɢ ɦɨɝɭɬ ɛɵɬɶ ɤɚɧɞɢɞɚɬɚɦɢ ɜ ɱɥɟɧɵ ɧɨɜɨɝɨ ɤɥɚɫɫɚ.

Ссылки [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

Стр. 52

Стиль кодирования

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

22. Минимизируйте зависимости определений и избегайте циклических зависимостей 22. Минимизируйте зависимости определений...

Резюме ɂɡɛɟɝɚɣɬɟ ɢɡɥɢɲɧɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ. ɇɟ ɜɤɥɸɱɚɣɬɟ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include ɨɩɪɟɞɟɥɟɧɢɹ ɬɚɦ, ɝɞɟ ɞɨɫɬɚɬɨɱɧɨ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɝɨ ɨɛɴɹɜɥɟɧɢɹ. ɂɡɛɟɝɚɣɬɟ ɜɡɚɢɦɨɡɚɜɢɫɢɦɨɫɬɟɣ. ɐɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨɫɬɢ ɜɨɡɧɢɤɚɸɬ, ɤɨɝɞɚ ɞɜɚ ɦɨɞɭɥɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɢɥɢ ɨɩɨɫɪɟɞɨɜɚɧɧɨ ɡɚɜɢɫɹɬ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. Ɇɨɞɭɥɶ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɛɨɫɨɛɥɟɧɧɭɸ ɟɞɢɧɢɰɭ; ɜɡɚɢɦɨɡɚɜɢɫɢɦɵɟ ɦɨɞɭɥɢ ɧɟ ɹɜɥɹɸɬɫɹ ɩɨɥɧɨɫɬɶɸ ɨɬɞɟɥɶɧɵɦɢ ɦɨɞɭɥɹɦɢ, ɛɭɞɭɱɢ ɩɨ ɫɭɬɢ ɱɚɫɬɹɦɢ ɨɞɧɨɝɨ ɛɨɥɶɲɟɝɨ ɦɨɞɭɥɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɰɢɤɥɢɱɟɫɤɢɟ ɡɚɜɢɫɢɦɨɫɬɢ ɹɜɥɹɸɬɫɹ ɩɪɨɬɢɜɧɢɤɚɦɢ ɦɨɞɭɥɶɧɨɫɬɢ ɢ ɩɪɟɞɫɬɚɜɥɹɸɬ ɭɝɪɨɡɭ ɛɨɥɶɲɢɦ ɩɪɨɟɤɬɚɦ. ɂɡɛɟɝɚɣɬɟ ɢɯ.

Обсуждение ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɟɞɜɚɪɢɬɟɥɶɧɵɟ ɨɛɴɹɜɥɟɧɢɹ ɜɟɡɞɟ, ɝɞɟ ɧɟ ɬɪɟɛɭɟɬɫɹ ɩɨɥɧɨɟ ɨɩɪɟɞɟɥɟɧɢɟ ɬɢɩɚ. ɉɨɥɧɨɟ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ C ɬɪɟɛɭɟɬɫɹ ɜ ɞɜɭɯ ɨɫɧɨɜɧɵɯ ɫɥɭɱɚɹɯ. •

•

Ʉɨɝɞɚ ɜɚɦ ɧɟɨɛɯɨɞɢɦɨ ɡɧɚɬɶ ɪɚɡɦɟɪ ɨɛɴɟɤɬɚ C. ɇɚɩɪɢɦɟɪ, ɩɪɢ ɫɨɡɞɚɧɢɢ ɨɛɴɟɤɬɚ C ɜ ɫɬɟɤɟ ɢɥɢ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɟɝɨ ɜ ɤɚɱɟɫɬɜɟ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɯɪɚɧɢɦɨɝɨ (ɧɟ ɱɟɪɟɡ ɭɤɚɡɚɬɟɥɶ) ɱɥɟɧɚ ɞɪɭɝɨɝɨ ɤɥɚɫɫɚ. Ʉɨɝɞɚ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɢɦɹ ɢɥɢ ɜɵɡɨɜ ɱɥɟɧɚ C. ɇɚɩɪɢɦɟɪ, ɤɨɝɞɚ ɜɵ ɜɵɡɵɜɚɟɬɟ ɮɭɧɤɰɢɸɱɥɟɧ ɷɬɨɝɨ ɤɥɚɫɫɚ.

ɇɟ ɛɭɞɟɦ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɜ ɷɬɨɣ ɤɧɢɝɟ ɬɪɢɜɢɚɥɶɧɵɟ ɫɥɭɱɚɢ ɰɢɤɥɢɱɟɫɤɢɯ ɡɚɜɢɫɢɦɨɫɬɟɣ, ɤɨɬɨɪɵɟ ɩɪɢɜɨɞɹɬ ɤ ɨɲɢɛɤɚɦ ɤɨɦɩɢɥɹɰɢɢ — ɞɭɦɚɟɦ, ɜɵ ɭɫɩɟɲɧɨ ɫɩɪɚɜɢɬɟɫɶ ɫ ɧɢɦɢ, ɜɨɫɩɨɥɶɡɨɜɚɜɲɢɫɶ ɦɧɨɝɢɦɢ ɯɨɪɨɲɢɦɢ ɫɨɜɟɬɚɦɢ, ɢɦɟɸɳɢɦɢɫɹ ɜ ɥɢɬɟɪɚɬɭɪɟ ɢ ɪɟɤɨɦɟɧɞɚɰɢɢ 1. Ɇɵ ɠɟ ɨɛɪɚɬɢɦɫɹ ɤ ɰɢɤɥɢɱɟɫɤɢɦ ɡɚɜɢɫɢɦɨɫɬɹɦ, ɤɨɬɨɪɵɟ ɨɫɬɚɸɬɫɹ ɜ ɤɨɦɩɢɥɢɪɭɟɦɨɦ ɤɨɞɟ, ɢ ɩɨɫɦɨɬɪɢɦ, ɤɚɤ ɨɧɢ ɜɥɢɹɸɬ ɧɚ ɟɝɨ ɤɚɱɟɫɬɜɨ ɢ ɤɚɤɢɟ ɞɟɣɫɬɜɢɹ ɫɥɟɞɭɟɬ ɩɪɟɞɩɪɢɧɹɬɶ, ɱɬɨɛɵ ɢɡɛɟɠɚɬɶ ɢɯ. ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɡɚɜɢɫɢɦɨɫɬɢ ɢ ɢɯ ɰɢɤɥɵ ɫɥɟɞɭɟɬ ɪɚɫɫɦɚɬɪɢɜɚɬɶ ɧɚ ɭɪɨɜɧɟ ɦɨɞɭɥɟɣ. Ɇɨɞɭɥɶ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɨɛɪɚɡɭɸɳɢɣ ɟɞɢɧɨɟ ɰɟɥɨɟ ɧɚɛɨɪ ɫɨɜɦɟɫɬɧɨ ɨɩɭɛɥɢɤɨɜɚɧɧɵɯ ɤɥɚɫɫɨɜ ɢ ɮɭɧɤɰɢɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 5). ɐɢɤɥɢɱɟɫɤɚɹ ɡɚɜɢɫɢɦɨɫɬɶ ɜ ɩɪɨɫɬɟɣɲɟɦ ɜɢɞɟ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɞɜɚ ɤɥɚɫɫɚ, ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɡɚɜɢɫɹɳɢɯ ɞɪɭɝ ɨɬ ɞɪɭɝɚ: class Child;

// ǞǼǽǻǫǸǰǸdzǰ ȁdzǵǶdzȂǰǼǵǹǴ DzǫǭdzǼdzǷǹǼǽdz

class Parent { // ... Child* myChild_; }; // ǍǹDzǷǹDZǸǹ, ǭ ǯǻǾǮǹǷ DzǫǮǹǶǹǭǹȂǸǹǷ ǿǫǴǶǰ class Child { // ... Parent* myParent_; };

Ʉɥɚɫɫɵ Parent ɢ Child ɡɚɜɢɫɹɬ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. ɉɪɢɜɟɞɟɧɧɵɣ ɤɨɞ ɤɨɦɩɢɥɢɪɭɟɬɫɹ, ɧɨ ɦɵ ɫɬɚɥɤɢɜɚɟɦɫɹ ɫ ɮɭɧɞɚɦɟɧɬɚɥɶɧɨɣ ɩɪɨɛɥɟɦɨɣ: ɷɬɢ ɞɜɚ ɤɥɚɫɫɚ ɛɨɥɶɲɟ ɧɟ ɹɜɥɹɸɬɫɹ ɧɟɡɚɜɢɫɢɦɵɦɢ, ɢ ɛɨɥɟɟ ɬɨɝɨ, ɫɬɚɧɨɜɹɬɫɹ ɜɡɚɢɦɨɡɚɜɢɫɢɦɵ ɞɪɭɝ ɨɬ ɞɪɭɝɚ. ɗɬɨ ɧɟ ɜɫɟɝɞɚ ɩɥɨɯɨ, ɧɨ ɞɨɥɠɧɨ ɢɦɟɬɶ ɦɟɫɬɨ ɥɢɲɶ ɜ ɬɨɦ ɫɥɭɱɚɟ, ɤɨɝɞɚ ɨɛɚ ɤɥɚɫɫɚ ɹɜɥɹɸɬɫɹ ɱɚɫɬɹɦɢ ɨɞɧɨɝɨ ɢ ɬɨɝɨ ɠɟ ɦɨ22. Минимизируйте зависимости определений...

Стр. 53

53

ɞɭɥɹ (ɪɚɡɪɚɛɨɬɚɧɧɨɝɨ ɨɞɧɢɦ ɢ ɬɟɦ ɠɟ ɱɟɥɨɜɟɤɨɦ ɢɥɢ ɤɨɦɚɧɞɨɣ, ɨɬɬɟɫɬɢɪɨɜɚɧɧɨɝɨ ɢ ɜɵɩɭɳɟɧɧɨɝɨ ɤɚɤ ɟɞɢɧɨɟ ɰɟɥɨɟ). ȼ ɩɪɨɬɢɜɨɩɨɥɨɠɧɨɫɬɶ ɨɩɢɫɚɧɧɨɣ ɫɢɬɭɚɰɢɢ, ɪɚɫɫɦɨɬɪɢɦ, ɱɬɨ ɛɭɞɟɬ, ɟɫɥɢ ɤɥɚɫɫ Child ɧɟ ɞɨɥɠɟɧ ɛɭɞɟɬ ɯɪɚɧɢɬɶ ɨɛɪɚɬɧɭɸ ɫɜɹɡɶ ɫ ɨɛɴɟɤɬɨɦ Parent? Ɍɨɝɞɚ Child ɦɨɠɟɬ ɛɵɬɶ ɜɵɩɭɳɟɧ ɜ ɫɨɛɫɬɜɟɧɧɨɦ ɨɬɞɟɥɶɧɨɦ ɧɟɛɨɥɶɲɨɦ ɦɨɞɭɥɟ (ɢ, ɜɨɡɦɨɠɧɨ, ɩɨɞ ɞɪɭɝɢɦ ɢɦɟɧɟɦ), ɩɨɥɧɨɫɬɶɸ ɧɟɡɚɜɢɫɢɦɨ ɨɬ Parent — ɱɬɨ, ɤɨɧɟɱɧɨ, ɫɭɳɟɫɬɜɟɧɧɨ ɩɨɜɵɲɚɟɬ ɝɢɛɤɨɫɬɶ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. ȼɫɟ ɫɬɚɧɨɜɢɬɫɹ ɟɳɟ ɯɭɠɟ, ɤɨɝɞɚ ɡɚɜɢɫɢɦɨɫɬɢ ɨɯɜɚɬɵɜɚɸɬ ɧɟɫɤɨɥɶɤɨ ɦɨɞɭɥɟɣ. Ɍɚɤɨɣ ɦɨɳɧɵɣ “ɤɥɟɣ”, ɤɚɤ ɡɚɜɢɫɢɦɨɫɬɢ, ɨɛɴɟɞɢɧɹɸɬ ɷɬɢ ɦɨɞɭɥɹ ɜ ɟɞɢɧɭɸ ɦɨɧɨɥɢɬɧɭɸ ɩɭɛɥɢɤɭɟɦɭɸ ɟɞɢɧɢɰɭ. ȼɨɬ ɩɨɱɟɦɭ ɰɢɤɥɵ ɹɜɥɹɸɬɫɹ ɫɚɦɵɦɢ ɫɬɪɚɲɧɵɦɢ ɜɪɚɝɚɦɢ ɦɨɞɭɥɶɧɨɫɬɢ. ɑɬɨɛɵ ɪɚɡɨɪɜɚɬɶ ɰɢɤɥɵ, ɩɪɢɦɟɧɢɬɟ ɩɪɢɧɰɢɩ ɢɧɜɟɪɫɢɢ ɡɚɜɢɫɢɦɨɫɬɟɣ (Dependency Inversion 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

Стр. 54

Стиль кодирования

23. Делайте заголовочные файлы самодостаточными Резюме ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɤɚɠɞɵɣ ɧɚɩɢɫɚɧɧɵɣ ɜɚɦɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɤɨɦɩɢɥɢɪɭɟɦ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ, ɬ.ɟ. ɱɬɨ ɨɧ ɜɤɥɸɱɚɟɬ ɜɫɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɨɬ ɤɨɬɨɪɵɯ ɡɚɜɢɫɢɬ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ.

Обсуждение ȿɫɥɢ ɨɞɢɧ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɧɟ ɪɚɛɨɬɚɟɬ, ɩɨɤɚ ɧɟ ɜɤɥɸɱɟɧ ɞɪɭɝɨɣ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ, ɩɪɨɟɤɬ ɩɨɥɭɱɚɟɬɫɹ ɨɱɟɧɶ ɧɟɭɤɥɸɠɢɦ, ɚ ɧɚ ɩɨɥɶɡɨɜɚɬɟɥɹ ɜɨɡɥɚɝɚɟɬɫɹ ɞɨɩɨɥɧɢɬɟɥɶɧɚɹ ɡɚɞɚɱɚ ɫɥɟɞɢɬɶ ɡɚ ɬɟɦ, ɤɚɤɢɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɚɞɨ ɜɤɥɸɱɢɬɶ ɜ ɢɫɯɨɞɧɵɣ ɬɟɤɫɬ. Ɋɚɧɶɲɟ ɧɟɤɨɬɨɪɵɟ ɷɤɫɩɟɪɬɵ ɫɨɜɟɬɨɜɚɥɢ, ɱɬɨɛɵ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɧɟ ɜɤɥɸɱɚɥɢ ɞɪɭɝɢɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɢɡ-ɡɚ ɧɚɤɥɚɞɧɵɯ ɪɚɫɯɨɞɨɜ ɧɚ ɦɧɨɝɨɤɪɚɬɧɨɟ ɨɬɤɪɵɬɢɟ ɢ ɚɧɚɥɢɡ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ, ɡɚɳɢɳɟɧɧɵɯ ɞɢɪɟɤɬɢɜɚɦɢ ɩɪɟɩɪɨɰɟɫɫɨɪɨɜ ɨɬ ɩɨɜɬɨɪɧɨɣ ɨɛɪɚɛɨɬɤɢ. Ʉ ɫɱɚɫɬɶɸ, ɫɟɣɱɚɫ ɷɬɨɬ ɫɨɜɟɬ ɭɫɬɚɪɟɥ. Ɇɧɨɝɢɟ ɫɨɜɪɟɦɟɧɧɵɟ ɤɨɦɩɢɥɹɬɨɪɵ C++ ɪɚɫɩɨɡɧɚɸɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɭɸ ɡɚɳɢɬɭ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ ɚɜɬɨɦɚɬɢɱɟɫɤɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 24) ɢ ɩɪɨɫɬɨ ɧɟ ɨɬɤɪɵɜɚɸɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɞɜɚɠɞɵ. ɇɟɤɨɬɨɪɵɟ ɤɨɦɩɢɥɹɬɨɪɵ ɢɫɩɨɥɶɡɭɸɬ ɩɪɟɞɤɨɦɩɢɥɹɰɢɸ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ, ɤɨɬɨɪɚɹ ɩɨɡɜɨɥɹɟɬ ɢɡɛɟɠɚɬɶ ɚɧɚɥɢɡɚ ɱɚɫɬɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ. Ɉɞɧɚɤɨ ɧɟ ɜɤɥɸɱɚɣɬɟ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ, ɜ ɤɨɬɨɪɵɯ ɜɵ ɧɟ ɧɭɠɞɚɟɬɟɫɶ, ɬɚɤ ɤɚɤ ɷɬɨ ɧɚɩɪɚɫɧɨ ɫɨɡɞɚɟɬ ɩɚɪɚɡɢɬɧɵɟ ɡɚɜɢɫɢɦɨɫɬɢ. Ⱦɥɹ ɝɚɪɚɧɬɢɢ ɫɚɦɨɞɨɫɬɚɬɨɱɧɨɫɬɢ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ ɫɤɨɦɩɢɥɢɪɭɣɬɟ ɤɚɠɞɵɣ ɢɡ ɧɢɯ ɨɬɞɟɥɶɧɨ ɨɬ ɞɪɭɝɢɯ ɢ ɭɛɟɞɢɬɟɫɶ, ɱɬɨ ɷɬɨ ɧɟ ɩɪɢɜɨɞɢɬ ɤ ɨɲɢɛɤɚɦ ɢɥɢ ɩɪɟɞɭɩɪɟɠɞɟɧɢɹɦ.

Примеры Ɋɹɞ ɬɨɧɤɢɯ ɦɨɦɟɧɬɨɜ ɜɨɡɧɢɤɚɟɬ ɜ ɫɜɹɡɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɲɚɛɥɨɧɨɜ. ɉɪɢɦɟɪ 1. Ɂɚɜɢɫɢɦɵɟ ɢɦɟɧɚ. ɒɚɛɥɨɧɵ ɤɨɦɩɢɥɢɪɭɸɬɫɹ ɜ ɬɨɱɤɟ, ɝɞɟ ɨɧɢ ɨɩɪɟɞɟɥɟɧɵ, ɫ ɬɟɦ ɢɫɤɥɸɱɟɧɢɟɦ, ɱɬɨ ɜɫɟ ɡɚɜɢɫɢɦɵɟ ɢɦɟɧɚ ɢɥɢ ɬɢɩɵ ɧɟ ɤɨɦɩɢɥɢɪɭɸɬɫɹ ɞɨ ɬɨɱɤɢ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɹ. ɗɬɨ ɨɡɧɚɱɚɟɬ, ɱɬɨ template class Widget ɫ ɱɥɟɧɨɦ std::deque ɧɟ ɩɪɢɜɟɞɟɬ ɤ ɨɲɢɛɤɟ ɜɪɟɦɟɧɢ ɤɨɦɩɢɥɹɰɢɢ, ɞɚɠɟ ɟɫɥɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɧɟ ɜɤɥɸɱɟɧ — ɟɫɥɢ ɩɪɢ ɷɬɨɦ ɧɟ ɩɪɨɢɫɯɨɞɢɬ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɟ Widget. ɉɨɫɤɨɥɶɤɭ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɲɚɛɥɨɧ Widget ɫɭɳɟɫɬɜɭɟɬ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɛɵɬɶ ɢɧɫɬɚɧɰɢɪɨɜɚɧɧɵɦ, ɟɝɨ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɞɨɥɠɟɧ ɫɨɞɟɪɠɚɬɶ ɫɬɪɨɤɭ #include . ɉɪɢɦɟɪ 2. ɒɚɛɥɨɧɵ ɮɭɧɤɰɢɣ-ɱɥɟɧɨɜ ɢ ɮɭɧɤɰɢɢ-ɱɥɟɧɵ ɲɚɛɥɨɧɨɜ ɢɧɫɬɚɧɰɢɪɭɸɬɫɹ ɬɨɥɶɤɨ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ. ɉɪɟɞɩɨɥɨɠɢɦ, ɱɬɨ Widget ɧɟ ɢɦɟɟɬ ɱɥɟɧɚ ɬɢɩɚ std::deque, ɧɨ ɮɭɧɤɰɢɹɱɥɟɧ Widget ɫ ɢɦɟɧɟɦ Transmogrify ɢɫɩɨɥɶɡɭɟɬ deque. Ɍɨɝɞɚ ɜɵɡɵɜɚɸɳɚɹ Widget ɮɭɧɤɰɢɹ ɦɨɠɟɬ ɢɧɫɬɚɧɰɢɪɨɜɚɬɶ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ Widget, ɞɚɠɟ ɟɫɥɢ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɧɟ ɜɤɥɸɱɟɧ — ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɮɭɧɤɰɢɹ-ɱɥɟɧ Transmogrify. ɉɨ ɭɦɨɥɱɚɧɢɸ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ Widget ɜɫɟ ɠɟ ɞɨɥɠɟɧ ɜɤɥɸɱɚɬɶ , ɩɨɫɤɨɥɶɤɭ ɷɬɨ ɧɟɨɛɯɨɞɢɦɨ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɞɥɹ ɧɟɤɨɬɨɪɵɯ ɩɨɥɶɡɨɜɚɬɟɥɟɣ 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_ // ... ǜǹǯǰǻDZdzǷǹǰ ǿǫǴǶǫ ... #endif

Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɫɥɟɞɭɸɳɢɟ ɩɪɚɜɢɥɚ ɩɪɢ ɨɩɪɟɞɟɥɟɧɢɢ ɡɚɳɢɬɵ ɜɤɥɸɱɟɧɢɹ. •

•

ɂɫɩɨɥɶɡɭɣɬɟ ɞɥɹ ɡɚɳɢɬɵ ɭɧɢɤɚɥɶɧɵɟ ɢɦɟɧɚ. ɍɛɟɞɢɬɟɫɶ, ɱɬɨ ɜɵ ɢɫɩɨɥɶɡɭɟɬɟ ɢɦɟɧɚ, ɭɧɢɤɚɥɶɧɵɟ, ɩɨ ɤɪɚɣɧɟɣ ɦɟɪɟ, ɜ ɩɪɟɞɟɥɚɯ ɜɚɲɟɝɨ ɩɪɢɥɨɠɟɧɢɹ. ȼɵɲɟ ɦɵ ɢɫɩɨɥɶɡɨɜɚɥɢ ɨɞɧɨ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɨɟ ɫɨɝɥɚɲɟɧɢɟ ɞɥɹ ɢɫɩɨɥɶɡɭɟɦɵɯ ɜ ɡɚɳɢɬɟ ɢɦɟɧ; ɢɦɟɧɚ ɞɥɹ ɡɚɳɢɬɵ ɦɨɝɭɬ ɜɤɥɸɱɚɬɶ ɢɦɹ ɩɪɢɥɨɠɟɧɢɹ, ɚ ɧɟɤɨɬɨɪɵɟ ɢɧɫɬɪɭɦɟɧɬɵ ɝɟɧɟɪɢɪɭɸɬ ɢɦɟɧɚ ɞɥɹ ɡɚɳɢɬɵ, ɫɨɞɟɪɠɚɳɢɟ ɫɥɭɱɚɣɧɵɟ ɱɢɫɥɚ. ɇɟ ɩɵɬɚɣɬɟɫɶ ɯɢɬɪɢɬɶ. ɇɟ ɪɚɡɦɟɳɚɣɬɟ ɧɢɤɚɤɨɝɨ ɤɨɞɚ ɢɥɢ ɤɨɦɦɟɧɬɚɪɢɟɜ ɞɨ ɢ ɩɨɫɥɟ ɡɚɳɢɳɟɧɧɨɣ ɱɚɫɬɢ, ɢ ɫɥɟɞɭɣɬɟ ɩɨɤɚɡɚɧɧɨɣ ɜɵɲɟ ɫɬɚɧɞɚɪɬɧɨɣ ɮɨɪɦɟ ɡɚɳɢɬɵ. ɋɨɜɪɟɦɟɧɧɵɟ ɩɪɟɩɪɨɰɟɫɫɨɪɵ ɦɨɝɭɬ ɨɛɧɚɪɭɠɢɬɶ ɡɚɳɢɬɭ, ɧɨ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɦɚɥɨɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɦɢ ɢ ɨɠɢɞɚɬɶ ɤɨɞɚ ɡɚɳɢɬɵ ɫɬɪɨɝɨ ɜ ɧɚɱɚɥɟ ɢ ɜ ɤɨɧɰɟ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɨɜ.

ɂɡɛɟɝɚɣɬɟ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɭɫɬɚɪɟɜɲɟɣ ɜɧɟɲɧɟɣ ɡɚɳɢɬɵ ɞɢɪɟɤɬɢɜɵ #include, ɪɟɤɨɦɟɧɞɭɟɦɨɣ ɜ ɧɟɤɨɬɨɪɵɯ ɫɬɚɪɵɯ ɤɧɢɝɚɯ: #ifndef FOO_H_INCLUDED_ // ǘǐ ǻǰǵǹǷǰǸǯǾǰǽǼȊ #include "foo.h" #define FOO_H_INCLUDED_ #endif

ȼɧɟɲɧɹɹ ɡɚɳɢɬɚ ɭɬɨɦɢɬɟɥɶɧɚ, ɭɫɬɚɪɟɥɚ ɞɥɹ ɫɨɜɪɟɦɟɧɧɵɯ ɤɨɦɩɢɥɹɬɨɪɨɜ ɢ ɧɟɧɚɞɟɠɧɚ ɢɡ-ɡɚ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɫɨɝɥɚɫɨɜɚɧɢɹ ɢɦɟɧ ɞɥɹ ɡɚɳɢɬɵ.

Исключения ȼ ɨɱɟɧɶ ɪɟɞɤɢɯ ɫɥɭɱɚɹɯ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ ɦɨɠɟɬ ɛɵɬɶ ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɦɧɨɝɨɤɪɚɬɧɨɝɨ ɜɤɥɸɱɟɧɢɹ.

Ссылки [C++03, §2.1] • [Stroustrup00] §9.3.3

56

Стр. 56

Стиль кодирования

Функции и операторы ȿɫɥɢ ɜɚɲɚ ɩɪɨɰɟɞɭɪɚ ɢɦɟɟɬ ɞɟɫɹɬɶ ɩɚɪɚɦɟɬɪɨɜ — ɜɟɪɨɹɬɧɨ, ɜɵ ɝɞɟ-ɬɨ ɨɲɢɛɥɢɫɶ. — Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis) Ɏɭɧɤɰɢɢ, ɜɤɥɸɱɚɹ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ ɟɞɢɧɢɰɵ ɪɚɛɨɬɵ. Ʉɚɤ ɜɵ ɭɜɢɞɢɬɟ ɩɨɡɠɟ ɜ ɪɚɡɞɟɥɟ “Ɉɛɪɚɛɨɬɤɚ ɨɲɢɛɨɤ ɢ ɢɫɤɥɸɱɟɧɢɹ” (ɜ ɱɚɫɬɧɨɫɬɢ, ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 70), ɷɬɨ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ ɜɥɢɹɟɬ ɧɚ ɧɚɲɢ ɪɚɫɫɭɠɞɟɧɢɹ ɨ ɤɨɪɪɟɤɬɧɨɫɬɢ ɢ ɛɟɡɨɩɚɫɧɨɫɬɢ ɤɨɞɚ. ɇɨ ɞɚɜɚɣɬɟ ɫɧɚɱɚɥɚ ɪɚɫɫɦɨɬɪɢɦ ɧɟɤɨɬɨɪɵɟ ɮɭɧɞɚɦɟɧɬɚɥɶɧɵɟ ɜɨɩɪɨɫɵ ɧɚɩɢɫɚɧɢɹ ɮɭɧɤɰɢɣ, ɜ ɬɨɦ ɱɢɫɥɟ ɨɩɟɪɚɬɨɪɨɜ. ȼ ɱɚɫɬɧɨɫɬɢ, ɦɵ ɨɛɪɚɬɢɦ ɨɫɨɛɨɟ ɜɧɢɦɚɧɢɟ ɧɚ ɢɯ ɩɚɪɚɦɟɬɪɵ, ɫɟɦɚɧɬɢɤɭ ɢ ɩɟɪɟɝɪɭɡɤɭ. ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɧɚɢɛɨɥɟɟ ɜɚɠɧɨɣ ɧɚɦ ɩɪɟɞɫɬɚɜɥɹɟɬɫɹ ɪɟɤɨɦɟɧɞɚɰɢɹ 26 — “ɋɨɯɪɚɧɹɣɬɟ ɟɫɬɟɫɬɜɟɧɧɭɸ ɫɟɦɚɧɬɢɤɭ ɩɟɪɟɝɪɭɠɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ”.

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

Стр. 57

57

25. Передача параметров по значению, (интеллектуальному) указателю или ссылке Резюме ȼɵ ɞɨɥɠɧɵ ɱɟɬɤɨ ɭɹɫɧɢɬɶ ɪɚɡɧɢɰɭ ɦɟɠɞɭ ɜɯɨɞɧɵɦɢ, ɜɵɯɨɞɧɵɦɢ ɩɚɪɚɦɟɬɪɚɦɢ ɢ ɩɚɪɚɦɟɬɪɚɦɢ, ɩɪɟɞɧɚɡɧɚɱɟɧɧɵɦɢ ɢ ɞɥɹ ɜɜɨɞɚ, ɢ ɞɥɹ ɜɵɜɨɞɚ ɢɧɮɨɪɦɚɰɢɢ, ɚ ɬɚɤɠɟ ɦɟɠɞɭ ɩɟɪɟɞɚɱɟɣ ɩɚɪɚɦɟɬɪɨɜ ɩɨ ɡɧɚɱɟɧɢɸ ɢ ɩɨ ɫɫɵɥɤɟ, ɢ ɤɨɪɪɟɤɬɧɨ ɢɯ ɢɫɩɨɥɶɡɨɜɚɬɶ.

Обсуждение ɉɪɚɜɢɥɶɧɵɣ ɜɵɛɨɪ ɫɩɨɫɨɛɚ ɩɟɪɟɞɚɱɢ ɚɪɝɭɦɟɧɬɨɜ ɜ ɮɭɧɤɰɢɸ — ɩɨ ɡɧɚɱɟɧɢɸ, ɫɫɵɥɤɟ ɢɥɢ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɭɤɚɡɚɬɟɥɟɣ — ɜɟɫɶɦɚ ɧɟɨɛɯɨɞɢɦɵɣ ɧɚɜɵɤ, ɤɨɬɨɪɵɣ ɩɨɦɨɠɟɬ ɜɚɦ ɫɞɟɥɚɬɶ ɜɚɲ ɤɨɞ ɦɚɤɫɢɦɚɥɶɧɨ ɛɟɡɨɩɚɫɧɵɦ ɢ ɷɮɮɟɤɬɢɜɧɵɦ. ɏɨɬɹ ɷɮɮɟɤɬɢɜɧɨɫɬɶ ɧɟ ɞɨɥɠɧɚ ɛɵɬɶ ɧɚɲɟɣ ɝɥɚɜɧɨɣ ɰɟɥɶɸ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 8), ɩɪɢ ɩɪɨɱɢɯ ɪɚɜɧɵɯ ɭɫɥɨɜɢɹɯ, ɜɤɥɸɱɚɹ ɩɨɧɹɬɧɨɫɬɶ ɤɨɞɚ, ɦɵ ɧɟ ɞɨɥɠɧɵ ɛɟɡ ɤɪɚɣɧɟɣ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɫɧɢɠɚɬɶ ɟɝɨ ɷɮɮɟɤɬɢɜɧɨɫɬɶ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9). ȼɚɦ ɫɬɨɢɬ ɫɥɟɞɨɜɚɬɶ ɩɪɢɜɟɞɟɧɧɵɦ ɧɢɠɟ ɪɟɤɨɦɟɧɞɚɰɢɹɦ ɩɪɢ ɜɵɛɨɪɟ ɫɩɨɫɨɛɚ ɩɟɪɟɞɚɱɢ ɩɚɪɚɦɟɬɪɨɜ. ȼɨɬ ɪɟɤɨɦɟɧɞɚɰɢɢ ɞɥɹ ɜɯɨɞɧɵɯ ɩɚɪɚɦɟɬɪɨɜ (ɤɨɬɨɪɵɟ ɩɟɪɟɞɚɸɬ ɢɧɮɨɪɦɚɰɢɸ ɜ ɮɭɧɤɰɢɸ, ɧɨ ɧɟ ɜɨɡɜɪɚɳɚɸɬ ɟɟ). • • • •

ȼɫɟɝɞɚ ɨɩɢɫɵɜɚɣɬɟ ɜɫɟ ɭɤɚɡɚɬɟɥɢ ɢɥɢ ɫɫɵɥɤɢ ɧɚ ɜɯɨɞɧɵɟ ɩɚɪɚɦɟɬɪɵ ɤɚɤ const. ɉɪɟɞɩɨɱɢɬɚɣɬɟ ɩɟɪɟɞɚɱɭ ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ (ɧɚɩɪɢɦɟɪ, char ɢɥɢ float) ɢ ɨɛɴɟɤɬɨɜ-ɡɧɚɱɟɧɢɣ ɫ ɧɟɞɨɪɨɝɢɦɢ ɨɩɟɪɚɰɢɹɦɢ ɤɨɩɢɪɨɜɚɧɢɹ (ɧɚɩɪɢɦɟɪ, Point ɢɥɢ complex ) ɩɨ ɡɧɚɱɟɧɢɸ. ȼɯɨɞɧɵɟ ɚɪɝɭɦɟɧɬɵ ɩɪɨɱɢɯ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɬɢɩɨɜ ɥɭɱɲɟ ɩɟɪɟɞɚɜɚɬɶ ɤɚɤ ɫɫɵɥɤɢ ɧɚ 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& ) { // ... ǻǰǫǶdzDzǫȁdzȊ ... 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

Стр. 60

Функции и операторы

T& operator@=(T T& lhs, const T& rhs) { // ... ǻǰǫǶdzDzǫȁdzȊ ... return lhs; } T operator@(T T lhs, const T& rhs) {// lhs ǺǰǻǰǯǫǸǹ Ǻǹ DzǸǫȂǰǸdzȉ return lhs @= rhs; }

ȿɳɟ ɨɞɢɧ ɜɚɪɢɚɧɬ — ɨɩɟɪɚɬɨɪ operator@, ɤɨɬɨɪɵɣ ɜɨɡɜɪɚɳɚɟɬ const-ɡɧɚɱɟɧɢɟ. ɗɬɚ ɦɟɬɨɞɢɤɚ ɢɦɟɟɬ ɬɨ ɩɪɟɢɦɭɳɟɫɬɜɨ, ɱɬɨ ɩɪɢ ɷɬɨɦ ɡɚɩɪɟɳɚɟɬɫɹ ɬɚɤɨɣ ɧɟ ɢɦɟɸɳɢɣ ɫɦɵɫɥɚ ɤɨɞ, ɤɚɤ a+b=c, ɧɨ ɜ ɷɬɨɦ ɫɥɭɱɚɟ ɦɵ ɬɟɪɹɟɦ ɜɨɡɦɨɠɧɨɫɬɶ ɩɪɢɦɟɧɟɧɢɹ ɩɨɬɟɧɰɢɚɥɶɧɨ ɩɨɥɟɡɧɵɯ ɤɨɧɫɬɪɭɤɰɢɣ ɧɚɩɨɞɨɛɢɟ a = (b+c).replace(pos,n,d). Ⱥ ɷɬɨ ɜɟɫɶɦɚ ɜɵɪɚɡɢɬɟɥɶɧɵɣ ɤɨɞ, ɤɨɬɨɪɵɣ ɜ ɨɞɧɨɣ ɫɬɪɨɱɤɟ ɜɵɩɨɥɧɹɟɬ ɤɨɧɤɚɬɟɧɚɰɢɸ ɫɬɪɨɤ b ɢ c, ɡɚɦɟɧɹɟɬ ɧɟɤɨɬɨɪɵɟ ɫɢɦɜɨɥɵ ɢ ɩɪɢɫɜɚɢɜɚɟɬ ɩɨɥɭɱɟɧɧɵɣ ɪɟɡɭɥɶɬɚɬ ɩɟɪɟɦɟɧɧɨɣ a.

Примеры ɉɪɢɦɟɪ. Ɋɟɚɥɢɡɚɰɢɹ += ɞɥɹ ɫɬɪɨɤ. ɉɪɢ ɤɨɧɤɚɬɟɧɚɰɢɢ ɫɬɪɨɤ ɩɨɥɟɡɧɨ ɡɚɪɚɧɟɟ ɡɧɚɬɶ ɞɥɢɧɭ, ɱɬɨɛɵ ɜɵɞɟɥɹɬɶ ɩɚɦɹɬɶ ɬɨɥɶɤɨ ɨɞɢɧ ɪɚɡ: String& String::operator+=( const String& rhs ) { // ... ǛǰǫǶdzDzǫȁdzȊ ... return *this; } String operator+( const String& lhs, const String& rhs ) { String temp; // ǓDzǸǫȂǫǶȇǸǹ ǺǾǼǽǫ // ǍȆǯǰǶǰǸdzǰ ǯǹǼǽǫǽǹȂǸǹǮǹ ǵǹǶdzȂǰǼǽǭǫ ǺǫǷȊǽdz temp.Reserve(lhs.size()+rhs.size()); // ǕǹǸǵǫǽǰǸǫȁdzȊ Ǽǽǻǹǵ dz ǭǹDzǭǻǫǽ return (temp += lhs) += rhs; }

Исключения ȼ ɧɟɤɨɬɨɪɵɯ ɫɥɭɱɚɹɯ (ɧɚɩɪɢɦɟɪ, ɨɩɟɪɚɬɨɪ operator*= ɞɥɹ ɤɨɦɩɥɟɤɫɧɵɯ ɱɢɫɟɥ), ɨɩɟɪɚɬɨɪ ɦɨɠɟɬ ɢɡɦɟɧɹɬɶ ɥɟɜɵɣ ɚɪɝɭɦɟɧɬ ɧɚɫɬɨɥɶɤɨ ɫɭɳɟɫɬɜɟɧɧɨ, ɱɬɨ ɛɨɥɟɟ ɜɵɝɨɞɧɵɦ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɪɟɚɥɢɡɚɰɢɹ ɨɩɟɪɚɬɨɪɚ operator*= ɩɨɫɪɟɞɫɬɜɨɦ ɨɩɟɪɚɬɨɪɚ operator*, ɚ ɧɟ ɧɚɨɛɨɪɨɬ.

Ссылки [Alexandrescu03a] • [Cline99] §23.06 • [Meyers96] §22 • [Sutter00] §20

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

Стр. 61

61

28. Предпочитайте канонический вид ++ и --, и вызов префиксных операторов Резюме Ɉɫɨɛɟɧɧɨɫɬɶ ɨɩɟɪɚɬɨɪɨɜ ɢɧɤɪɟɦɟɧɬɚ ɢ ɞɟɤɪɟɦɟɧɬɚ ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɭ ɧɢɯ ɟɫɬɶ ɩɪɟɮɢɤɫɧɚɹ ɢ ɩɨɫɬɮɢɤɫɧɚɹ ɮɨɪɦɵ ɫ ɧɟɦɧɨɝɨ ɨɬɥɢɱɚɸɳɟɣɫɹ ɫɟɦɚɧɬɢɤɨɣ. Ɉɩɪɟɞɟɥɹɣɬɟ ɨɩɟɪɚɬɨɪɵ operator++ ɢ operator-- ɬɚɤ, ɱɬɨɛɵ ɨɧɢ ɩɨɞɪɚɠɚɥɢ ɩɨɜɟɞɟɧɢɸ ɫɜɨɢɯ ɜɫɬɪɨɟɧɧɵɯ ɞɜɨɣɧɢɤɨɜ. ȿɫɥɢ ɬɨɥɶɤɨ ɜɚɦ ɧɟ ɬɪɟɛɭɟɬɫɹ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ — ɢɫɩɨɥɶɡɭɣɬɟ ɩɪɟɮɢɤɫɧɵɟ ɜɟɪɫɢɢ ɨɩɟɪɚɬɨɪɨɜ.

Обсуждение ɋɬɚɪɚɹ ɲɭɬɤɚ ɝɥɚɫɢɬ, ɱɬɨ ɹɡɵɤ ɧɚɡɵɜɚɟɬɫɹ C++, ɚ ɧɟ ++C, ɩɨɬɨɦɭ ɱɬɨ ɹɡɵɤ ɛɵɥ ɭɥɭɱɲɟɧ (ɧɚ ɱɬɨ ɭɤɚɡɵɜɚɟɬ ɢɧɤɪɟɦɟɧɬ), ɧɨ ɦɧɨɝɢɟ ɩɪɨɞɨɥɠɚɸɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɟɝɨ ɤɚɤ C (ɩɪɟɞɵɞɭɳɟɟ ɡɧɚɱɟɧɢɟ ɞɨ ɢɧɤɪɟɦɟɧɬɚ). Ʉ ɫɱɚɫɬɶɸ, ɷɬɭ ɲɭɬɤɭ ɦɨɠɧɨ ɫɱɢɬɚɬɶ ɭɫɬɚɪɟɜɲɟɣ, ɧɨ ɷɬɨ ɨɬɥɢɱɧɚɹ ɢɥɥɸɫɬɪɚɰɢɹ ɞɥɹ ɩɨɧɢɦɚɧɢɹ ɨɬɥɢɱɢɹ ɦɟɠɞɭ ɞɜɭɦɹ ɮɨɪɦɚɦɢ ɨɩɟɪɚɬɨɪɨɜ. ȼ ɫɥɭɱɚɟ ++ ɢ -- ɩɨɫɬɮɢɤɫɧɵɟ ɮɨɪɦɵ ɨɩɟɪɚɬɨɪɨɜ ɜɨɡɜɪɚɳɚɸɬ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ, ɜ ɬɨ ɜɪɟɦɹ ɤɚɤ ɩɪɟɮɢɤɫɧɵɟ ɮɨɪɦɵ ɜɨɡɜɪɚɳɚɸɬ ɧɨɜɨɟ ɡɧɚɱɟɧɢɟ. Ʌɭɱɲɟ ɜɫɟɝɨ ɪɟɚɥɢɡɨɜɵɜɚɬɶ ɩɨɫɬɮɢɤɫɧɵɣ ɨɩɟɪɚɬɨɪ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɩɪɟɮɢɤɫɧɨɝɨ. ȼɨɬ ɤɚɧɨɧɢɱɟɫɤɢɣ ɜɢɞ ɬɚɤɨɝɨ ɢɫɩɨɥɶɡɨɜɚɧɢɹ: // ---- ǚǻǰǿdzǵǼǸȆǰ ǹǺǰǻǫǽǹǻȆ -------------------T& T::operator++() // ǚǻǰǿdzǵǼǸȆǴ ǭdzǯ: { // ǍȆǺǹǶǸǰǸdzǰ // - ǍȆǺǹǶǸǰǸdzǰ // dzǸǵǻǰǷǰǸǽǫ // ǯǰǴǼǽǭdzǴ return *this; // - return *this; } T& T::operator--() { // ǍȆǺǹǶǸǰǸdzǰ // ǯǰǵǻǰǷǰǸǽǫ return *this; }

// ǚǻǰǿdzǵǼǸȆǴ ǭdzǯ: // - ǍȆǺǹǶǸǰǸdzǰ // ǯǰǴǼǽǭdzǴ // - return *this;

// ---- ǚǹǼǽǿdzǵǼǸȆǰ ǹǺǰǻǫǽǹǻȆ ------------------T T::operator++(int) { T old( *this ); ++*this; return old; } T T::operator--(int) { T old( *this ); --*this; return old; }

// ǚǹǼǽǿdzǵǼǸȆǴ ǭdzǯ: // - ǒǫǺǹǷdzǸǫǰǷ Ǽǽǫǻǹǰ DzǸǫȂǰǸdzǰ // - ǍȆDzǹǭ ǺǻǰǿdzǵǼǸǹǴ ǭǰǻǼdzdz // - ǍǹDzǭǻǫǽ ǼǽǫǻǹǮǹ DzǸǫȂǰǸdzȊ // ǚǹǼǽǿdzǵǼǸȆǴ ǭdzǯ: // - ǒǫǺǹǷdzǸǫǰǷ Ǽǽǫǻǹǰ DzǸǫȂǰǸdzǰ // - ǍȆDzǹǭ ǺǻǰǿdzǵǼǸǹǴ ǭǰǻǼdzdz // - ǍǹDzǭǻǫǽ ǼǽǫǻǹǮǹ DzǸǫȂǰǸdzȊ

ȼ ɜɵɡɵɜɚɸɳɟɦ ɤɨɞɟ ɥɭɱɲɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɟɮɢɤɫɧɵɟ ɨɩɟɪɚɬɨɪɵ, ɟɫɥɢ ɬɨɥɶɤɨ ɜɚɦ ɧɟ ɬɪɟɛɭɟɬɫɹ ɢɫɯɨɞɧɨɟ ɡɧɚɱɟɧɢɟ, ɜɨɡɜɪɚɳɚɟɦɨɟ ɩɨɫɬɮɢɤɫɧɨɣ ɜɟɪɫɢɟɣ. ɉɪɟɮɢɤɫɧɚɹ ɮɨɪɦɚ ɫɟɦɚɧɬɢɱɟɫɤɢ ɷɤɜɢɜɚɥɟɧɬɧɚ, ɨɧɚ ɜɜɨɞɢɬɫɹ ɩɪɚɤɬɢɱɟɫɤɢ ɬɚɤ ɠɟ, ɢ ɡɚɱɚɫɬɭɸ ɧɟɦɧɨɝɨ ɷɮɮɟɤɬɢɜɧɟɟ, ɬɚɤ ɤɚɤ ɫɨɡɞɚɟɬ ɧɚ ɨɞɢɧ ɨɛɴɟɤɬ ɦɟɧɶɲɟ. ɗɬɨ ɧɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɚɹ ɨɩɬɢɦɢɡɚɰɢɹ, ɚ ɭɫɬɪɚɧɟɧɢɟ ɩɪɟɠɞɟɜɪɟɦɟɧɧɨɣ ɩɟɫɫɢɦɢɡɚɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 9).

62

Стр. 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 ); // ǙǬǰǼǺǰȂdzǭǫǰǽ ǸǰȊǭǸǹǰ // ǺǻǰǹǬǻǫDzǹǭǫǸdzǰ ǽdzǺǹǭ }; 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

Стр. 64

Функции и операторы

30. Избегайте перегрузки &&, || и , (запятой) Резюме Ɇɭɞɪɨɫɬɶ — ɷɬɨ ɡɧɚɧɢɟ ɬɨɝɨ, ɤɨɝɞɚ ɧɚɞɨ ɜɨɡɞɟɪɠɚɬɶɫɹ. ȼɫɬɪɨɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ &&, || ɢ , (ɡɚɩɹɬɚɹ) ɬɪɚɤɬɭɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ ɫɩɟɰɢɚɥɶɧɵɦ ɨɛɪɚɡɨɦ. ɉɨɫɥɟ ɩɟɪɟɝɪɭɡɤɢ ɨɧɢ ɫɬɚɧɨɜɹɬɫɹ ɨɛɵɱɧɵɦɢ ɮɭɧɤɰɢɹɦɢ ɫ ɜɟɫɶɦɚ ɨɬɥɢɱɧɨɣ ɫɟɦɚɧɬɢɤɨɣ (ɩɪɢ ɷɬɨɦ ɜɵ ɧɚɪɭɲɚɟɬɟ ɪɟɤɨɦɟɧɞɚɰɢɢ 26 ɢ 31), ɚ ɷɬɨ ɩɪɹɦɨɣ ɩɭɬɶ ɤ ɬɪɭɞɧɨɨɩɪɟɞɟɥɢɦɵɦ ɨɲɢɛɤɚɦ ɢ ɧɟɧɚɞɟɠɧɨɫɬɢ. ɇɟ ɩɟɪɟɝɪɭɠɚɣɬɟ ɷɬɢ ɨɩɟɪɚɬɨɪɵ ɛɟɡ ɤɪɚɣɧɟɣ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɢ ɝɥɭɛɨɤɨɝɨ ɩɨɧɢɦɚɧɢɹ.

Обсуждение Ƚɥɚɜɧɚɹ ɩɪɢɱɢɧɚ ɨɬɤɚɡɚ ɨɬ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɨɜ operator&&, operator|| ɢ operator, (ɡɚɩɹɬɚɹ) ɫɨɫɬɨɢɬ ɜ ɬɨɦ, ɱɬɨ ɜɵ ɧɟ ɢɦɟɟɬɟ ɜɨɡɦɨɠɧɨɫɬɢ ɪɟɚɥɢɡɨɜɚɬɶ ɩɨɥɧɭɸ ɫɟɦɚɧɬɢɤɭ ɜɫɬɪɨɟɧɧɵɯ ɨɩɟɪɚɬɨɪɨɜ ɜ ɷɬɢɯ ɬɪɟɯ ɫɥɭɱɚɹɯ, ɚ ɩɪɨɝɪɚɦɦɢɫɬɵ ɨɛɵɱɧɨ ɨɠɢɞɚɸɬ ɟɟ ɜɵɩɨɥɧɟɧɢɹ. ȼ ɱɚɫɬɧɨɫɬɢ, ɜɫɬɪɨɟɧɧɵɟ ɜɟɪɫɢɢ ɜɵɩɨɥɧɹɸɬ ɜɵɱɢɫɥɟɧɢɟ ɫɥɟɜɚ ɧɚɩɪɚɜɨ, ɚ ɞɥɹ ɨɩɟɪɚɬɨɪɨɜ && ɢ || ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɨɤɪɚɳɟɧɧɵɟ ɜɵɱɢɫɥɟɧɢɹ. ȼɫɬɪɨɟɧɧɵɟ ɜɟɪɫɢɢ && ɢ || ɫɧɚɱɚɥɚ ɜɵɱɢɫɥɹɸɬ ɥɟɜɭɸ ɱɚɫɬɶ ɜɵɪɚɠɟɧɢɹ, ɢ ɟɫɥɢ ɨɧɚ ɩɨɥɧɨɫɬɶɸ ɨɩɪɟɞɟɥɹɟɬ ɪɟɡɭɥɶɬɚɬ (false ɞɥɹ &&, true ɞɥɹ ||), ɬɨ ɜɵɱɢɫɥɹɬɶ ɩɪɚɜɨɟ ɜɵɪɚɠɟɧɢɟ ɧɟɡɚɱɟɦ — ɢ ɨɧɨ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɧɟ ɛɭɞɟɬ ɜɵɱɢɫɥɹɬɶɫɹ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ ɦɵ ɢɫɩɨɥɶɡɭɟɦ ɷɬɭ ɜɨɡɦɨɠɧɨɫɬɶ, ɩɨɡɜɨɥɹɹ ɤɨɪɪɟɤɬɧɨɫɬɢ ɩɪɚɜɨɝɨ ɜɵɪɚɠɟɧɢɹ ɡɚɜɢɫɟɬɶ ɨɬ ɭɫɩɟɲɧɨɝɨ ɜɵɱɢɫɥɟɧɢɹ ɥɟɜɨɝɨ: Employee* e = TryToGetEmployee(); if( e && e->Manager () ) // ...

Ʉɨɪɪɟɤɬɧɨɫɬɶ ɷɬɨɝɨ ɤɨɞɚ ɨɛɭɫɥɨɜɥɟɧɚ ɬɟɦ, ɱɬɨ e->Manager() ɧɟ ɛɭɞɟɬ ɜɵɱɢɫɥɹɬɶɫɹ, ɟɫɥɢ e ɢɦɟɟɬ ɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ. ɗɬɨ ɫɨɜɟɪɲɟɧɧɨ ɨɛɵɱɧɨ ɢ ɤɨɪɪɟɤɬɧɨ — ɞɨ ɬɟɯ ɩɨɪ, ɩɨɤɚ ɧɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɩɟɪɟɝɪɭɠɟɧɧɵɣ ɨɩɟɪɚɬɨɪ operator&&, ɩɨɫɤɨɥɶɤɭ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ ɜɵɪɚɠɟɧɢɟ, ɜɤɥɸɱɚɸɳɟɟ &&, ɛɭɞɟɬ ɫɥɟɞɨɜɚɬɶ ɩɪɚɜɢɥɚɦ ɮɭɧɤɰɢɢ: • ɜɵɡɨɜɵ ɮɭɧɤɰɢɣ ɜɫɟɝɞɚ ɜɵɱɢɫɥɹɸɬ ɜɫɟ ɚɪɝɭɦɟɧɬɵ ɞɨ ɜɵɩɨɥɧɟɧɢɹ ɤɨɞɚ ɮɭɧɤɰɢɢ; • ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɣ ɧɟ ɨɩɪɟɞɟɥɟɧ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 31). Ⱦɚɜɚɣɬɟ ɪɚɫɫɦɨɬɪɢɦ ɦɨɞɟɪɧɢɡɢɪɨɜɚɧɧɭɸ ɜɟɪɫɢɸ ɩɪɢɜɟɞɟɧɧɨɝɨ ɪɚɧɟɟ ɮɪɚɝɦɟɧɬɚ, ɤɨɬɨɪɚɹ ɢɫɩɨɥɶɡɭɟɬ ɢɧɬɟɥɥɟɤɬɭɚɥɶɧɵɟ ɭɤɚɡɚɬɟɥɢ: some_smart_ptr 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 );

// ǜǷ. ǽǫǵDZǰ ǻǰǵǹǷǰǸǯǫȁdzȉ 31

Примеры ɉɪɢɦɟɪ. ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɛɢɛɥɢɨɬɟɤɢ ɩɪɢ ɩɨɦɨɳɢ ɩɟɪɟɝɪɭɠɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ operator, ɞɥɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ ɢɧɢɰɢɚɥɢɡɚɰɢɣ. ɇɟɤɨɬɨɪɚɹ ɛɢɛɥɢɨɬɟɤɚ ɩɵɬɚɟɬɫɹ ɭɩɪɨɫɬɢɬɶ ɞɨɛɚɜɥɟɧɢɟ ɧɟɫɤɨɥɶɤɢɯ ɡɧɚɱɟɧɢɣ ɜ ɤɨɧɬɟɣɧɟɪ ɡɚ ɨɞɢɧ ɪɚɡ ɩɭɬɟɦ ɩɟɪɟɝɪɭɡɤɢ ɨɩɟɪɚɬɨɪɚ-ɡɚɩɹɬɨɣ. ɇɚɩɪɢɦɟɪ, ɞɥɹ ɞɨɛɚɜɥɟɧɢɹ ɜ vector letters: set_cont(letters) += "a", "b";

ȼɫɟ ɜ ɩɨɪɹɞɤɟ, ɩɨɤɚ ɜ ɨɞɢɧ ɩɪɟɤɪɚɫɧɵɣ ɞɟɧɶ ɩɨɥɶɡɨɜɚɬɟɥɶ ɧɟ ɧɚɩɢɲɟɬ: set_cont(letters) += getstr(), getstr(); // ǚǹǻȊǯǹǵ Ǹǰ ǹǺǻǰǯǰǶǰǸ Ǻǻdz dzǼǺǹǶȇDzǹǭǫǸdzdz // ǺǰǻǰǮǻǾDZǰǸǸǹǮǹ ǹǺǰǻǫǽǹǻǫ ","

ȿɫɥɢ ɮɭɧɤɰɢɹ getstr ɩɨɥɭɱɚɟɬ, ɧɚɩɪɢɦɟɪ, ɜɜɨɞ ɩɨɥɶɡɨɜɚɬɟɥɹ ɢ ɨɧ ɜɜɟɞɟɬ ɫɬɪɨɤɢ "c" ɢ "d" ɜ ɭɤɚɡɚɧɧɨɦ ɩɨɪɹɞɤɟ, ɬɨ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ ɫɬɪɨɤɢ ɦɨɝɭɬ ɨɤɚɡɚɬɶɫɹ ɜɧɟɫɟɧɵ ɜ ɥɸɛɨɦ ɩɨɪɹɞɤɟ. ɗɬɨ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɫɸɪɩɪɢɡɨɦ, ɩɨɫɤɨɥɶɤɭ ɩɪɢ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɜɫɬɪɨɟɧɧɨɝɨ ɨɩɟɪɚɬɨɪɚ operator, ɬɚɤɨɣ ɩɪɨɛɥɟɦɵ ɧɟ ɜɨɡɧɢɤɚɟɬ: string s; s = getstr(), getstr(); // ǚǹǻȊǯǹǵ ǼǽǻǹǮǹ ǹǺǻǰǯǰǶǰǸ // Ǻǻdz dzǼǺǹǶȇDzǹǭǫǸdzdz // ǭǼǽǻǹǰǸǸǹǮǹ ǹǺǰǻǫǽǹǻǫ ","

Исключения ɂɫɤɥɸɱɟɧɢɟ — ɫɩɟɰɢɚɥɢɡɢɪɨɜɚɧɧɵɟ ɛɢɛɥɢɨɬɟɤɢ ɲɚɛɥɨɧɨɜ ɞɥɹ ɧɚɭɱɧɵɯ ɜɵɱɢɫɥɟɧɢɣ, ɤɨɬɨɪɵɟ ɜ ɫɨɨɬɜɟɬɫɬɜɢɢ ɫ ɞɢɡɚɣɧɨɦ ɩɟɪɟɨɩɪɟɞɟɥɹɸɬ ɜɫɟ ɨɩɟɪɚɬɨɪɵ.

Ссылки [Dewhurst03] §14 • [Meyers96] §7, §25 • [Murray93] §2.4.3 • [Stroustrup00] §6.2.2

66

Стр. 66

Функции и операторы

31. Не пишите код, который зависит от порядка вычислений аргументов функции Резюме ɉɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɢ ɧɟ ɨɩɪɟɞɟɥɟɧ, ɩɨɷɬɨɦɭ ɧɢɤɨɝɞɚ ɧɟ ɩɨɥɚɝɚɣɬɟɫɶ ɧɚ ɬɨ, ɱɬɨ ɚɪɝɭɦɟɧɬɵ ɛɭɞɭɬ ɜɵɱɢɫɥɹɬɶɫɹ ɜ ɬɨɣ ɢɥɢ ɢɧɨɣ ɨɱɟɪɟɞɧɨɫɬɢ.

Обсуждение ɇɚ ɧɚɱɚɥɶɧɵɯ ɷɬɚɩɚɯ ɪɚɡɜɢɬɢɹ ɹɡɵɤɚ C ɪɟɝɢɫɬɪɵ ɩɪɨɰɟɫɫɨɪɚ ɛɵɥɢ ɞɪɚɝɨɰɟɧɧɵɦ ɪɟɫɭɪɫɨɦ ɢ ɤɨɦɩɢɥɹɬɨɪɵ ɪɟɲɚɥɢ ɬɪɭɞɧɵɟ ɡɚɞɚɱɢ ɷɮɮɟɤɬɢɜɧɨɝɨ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɹ ɜ ɫɥɨɠɧɵɯ ɜɵɪɚɠɟɧɢɹɯ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɯ ɹɡɵɤɨɜ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɩɨɡɜɨɥɢɬɶ ɤɨɦɩɢɥɹɬɨɪɭ ɝɟɧɟɪɢɪɨɜɚɬɶ ɛɨɥɟɟ ɛɵɫɬɪɵɣ ɤɨɞ, ɫɨɡɞɚɬɟɥɢ C ɞɚɥɢ ɪɚɫɩɪɟɞɟɥɢɬɟɥɸ ɪɟɝɢɫɬɪɨɜ ɞɨɩɨɥɧɢɬɟɥɶɧɭɸ ɫɬɟɩɟɧɶ ɫɜɨɛɨɞɵ. ɉɪɢ ɜɵɡɨɜɟ ɮɭɧɤɰɢɢ ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɟɟ ɚɪɝɭɦɟɧɬɨɜ ɨɫɬɚɜɚɥɫɹ ɧɟɨɩɪɟɞɟɥɟɧɧɵɦ. ɗɬɚ ɚɪɝɭɦɟɧɬɚɰɢɹ, ɜɟɪɨɹɬɧɨ, ɫɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɜɚɠɧɚ ɜ ɧɚɫɬɨɹɳɟɟ ɜɪɟɦɹ, ɧɨ ɝɥɚɜɧɨɟ, ɱɬɨ ɩɨɪɹɞɨɤ ɜɵɱɢɫɥɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɮɭɧɤɰɢɣ ɜ C++ ɧɟ ɨɩɪɟɞɟɥɟɧ ɢ ɜɚɪɶɢɪɭɟɬɫɹ ɨɬ ɤɨɦɩɢɥɹɬɨɪɚ ɤ ɤɨɦɩɢɥɹɬɨɪɭ (ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 30). ȼ ɫɜɹɡɢ ɫ ɷɬɢɦ ɧɟɨɛɞɭɦɚɧɧɵɟ ɞɟɣɫɬɜɢɹ ɩɪɨɝɪɚɦɦɢɫɬɚ ɦɨɝɭɬ ɩɪɢɜɟɫɬɢ ɤ ɛɨɥɶɲɢɦ ɧɟɩɪɢɹɬɧɨɫɬɹɦ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ: void Transmogrify( int, int ); int count = 5; Transmogrify( ++count, ++count ); // ǚǹǻȊǯǹǵ ǭȆȂdzǼǶǰǸdzǴ // ǸǰdzDzǭǰǼǽǰǸ

ȼɫɟ, ɱɬɨ ɦɵ ɦɨɠɟɦ ɫɤɚɡɚɬɶ ɨɩɪɟɞɟɥɟɧɧɨɝɨ, — ɷɬɨ ɬɨ, ɱɬɨ ɩɪɢ ɜɯɨɞɟ ɜ ɬɟɥɨ ɮɭɧɤɰɢɢ Transmogrify ɡɧɚɱɟɧɢɟ ɩɟɪɟɦɟɧɧɨɣ count ɛɭɞɟɬ ɪɚɜɧɨ 7 — ɧɨ ɦɵ ɧɟ ɦɨɠɟɦ ɫɤɚɡɚɬɶ, ɤɚɤɨɣ ɚɪɝɭɦɟɧɬ ɛɭɞɟɬ ɪɚɜɟɧ 6, ɚ ɤɚɤɨɣ — 7. ɗɬɚ ɧɟɨɩɪɟɞɟɥɟɧɧɨɫɬɶ ɨɫɬɚɟɬɫɹ ɢ ɜ ɝɨɪɚɡɞɨ ɦɟɧɟɟ ɨɱɟ-

ɜɢɞɧɵɯ ɫɥɭɱɚɹɯ, ɬɚɤɢɯ ɤɚɤ ɮɭɧɤɰɢɢ, ɦɨɞɢɮɢɰɢɪɭɸɳɢɟ ɫɜɨɢ ɚɪɝɭɦɟɧɬɵ (ɢɥɢ ɧɟɤɨɬɨɪɨɟ ɝɥɨɛɚɥɶɧɨɟ ɫɨɫɬɨɹɧɢɟ) ɜ ɤɚɱɟɫɬɜɟ ɩɨɛɨɱɧɨɝɨ ɞɟɣɫɬɜɢɹ: int Bump( int& x ) { return ++x; } Transmogrify( Bump(count), Bump(count) ); // ǛǰDzǾǶȇǽǫǽ // ǸǰdzDzǭǰǼǽǰǸ

ɋɨɝɥɚɫɧɨ ɪɟɤɨɦɟɧɞɚɰɢɢ 10, ɫɥɟɞɭɟɬ ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ ɢɡɛɟɝɚɬɶ ɝɥɨɛɚɥɶɧɵɯ ɢ ɫɨɜɦɟɫɬɧɨ ɢɫɩɨɥɶɡɭɟɦɵɯ ɩɟɪɟɦɟɧɧɵɯ. ɇɨ ɞɚɠɟ ɟɫɥɢ ɜɵ ɛɥɚɝɨɩɨɥɭɱɧɨ ɭɫɬɪɚɧɢɬɟ ɢɯ, ɧɟɤɨɬɨɪɵɣ ɞɪɭɝɨɣ ɤɨɞ ɦɨɠɟɬ ɷɬɨɝɨ ɧɟ ɫɞɟɥɚɬɶ. ɇɚɩɪɢɦɟɪ, ɧɟɤɨɬɨɪɵɟ ɫɬɚɧɞɚɪɬɧɵɟ ɮɭɧɤɰɢɢ ɢɦɟɸɬ ɩɨɛɨɱɧɵɟ ɞɟɣɫɬɜɢɹ (ɧɚɩɪɢɦɟɪ, strtok, ɚ ɬɚɤɠɟ ɪɚɡɧɵɟ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɨɩɟɪɚɬɨɪɵ operatorFoo(1)

Base *pB = pD; pB->Foo();

// ǍȆDzǹǭ 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), // ǼǵǻȆǭǫȊ ǹǼǽǫǶȇǸȆǰ ǿǾǸǵȁdzdz }; Derived d; d.Foo( 1 ); d.Foo( 1, 2 ); d.Foo( 1, 2, 3 );

// ǍǼǰ ǭ ǺǹǻȊǯǵǰ // ǙȃdzǬǵǫ // ǙȃdzǬǵǫ

ȿɫɥɢ ɩɟɪɟɝɪɭɠɟɧɧɵɟ ɮɭɧɤɰɢɢ ɢɡ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ ɞɨɥɠɧɵ ɛɵɬɶ ɜɢɞɢɦɵ, ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ ɨɛɴɹɜɥɟɧɢɟɦ using ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɜɬɨɪɧɨ ɨɛɴɹɜɢɬɶ ɢɯ ɜ ɩɪɨɢɡɜɨɞɧɨɦ ɤɥɚɫɫɟ: class Derived : public Base { // ... virtual void Foo( int ); // ǚǰǻǰǵǻȆǽdzǰ Base::Foo(int) using Base::Foo; // ǍǸǹǼdzǽ ǭǼǰ ǺǻǹȂdzǰ ǺǰǻǰǮǻǾDzǵdz // Base::Foo ǭ ǹǬǶǫǼǽȇ ǭdzǯdzǷǹǼǽdz };

Примеры ɉɪɢɦɟɪ: Ostrich (ɋɬɪɚɭɫ). ȿɫɥɢ ɤɥɚɫɫ Bird (ɉɬɢɰɚ) ɨɩɪɟɞɟɥɹɟɬ ɜɢɪɬɭɚɥɶɧɭɸ ɮɭɧɤɰɢɸ Fly ɢ ɜɵ ɩɨɪɨɠɞɚɟɬɟ ɧɨɜɵɣ ɤɥɚɫɫ Ostrich (ɢɡɜɟɫɬɧɵɣ ɤɚɤ ɩɬɢɰɚ, ɤɨɬɨɪɚɹ ɧɟ ɥɟɬɚɟɬ) ɢɡ ɤɥɚɫɫɚ Bird, ɬɨ ɤɚɤ ɜɵ ɪɟɚɥɢɡɭɟɬɟ Ostrich::Fly? Ɉɬɜɟɬ ɫɬɚɧɞɚɪɬɧɵɣ — “ɩɨ ɨɛɫɬɨɹɬɟɥɶɫɬɜɚɦ”. ȿɫɥɢ Bird::Fly ɝɚɪɚɧɬɢɪɭɟɬ ɭɫɩɟɲɧɨɫɬɶ (ɬ.ɟ. ɨɛɟɫɩɟɱɢɜɚɟɬ ɝɚɪɚɧɬɢɸ ɛɟɫɫɛɨɣɧɨɫɬɢ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 71), ɩɨɫɤɨɥɶɤɭ ɫɩɨɫɨɛɧɨɫɬɶ ɥɟɬɚɬɶ ɟɫɬɶ ɧɟɨɬɴɟɦɥɟɦɨɣ ɱɚɫɬɶɸ ɦɨɞɟɥɢ Bird, ɬɨ ɤɥɚɫɫ Ostrich ɨɤɚɡɵɜɚɟɬɫɹ ɧɟɚɞɟɤɜɚɬɧɨɣ ɪɟɚɥɢɡɚɰɢɟɣ ɬɚɤɨɣ ɦɨɞɟɥɢ.

Ссылки [Dewhurst03] §73-74, §78-79 • [Sutter00] §21 • [Keffer95] p. 18

82

Стр. 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

Стр. 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; // Ǎ ǽǻǫǯdzȁdzȊȀ 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);

// ǎǷ! ǜǹDzǯǫǸdzǰ dz ǭȆǭǹǯ Widget

ɉɪɢɦɟɪ 2. Ɋɚɛɨɬɚɸɳɢɟ ɨɲɢɛɤɢ. Ⱦɨɩɭɫɬɢɦ, ɜɵ ɫɧɚɛɞɢɥɢ ɤɥɚɫɫ String ɨɩɟɪɚɬɨɪɨɦ operator const char*: class String { // ... public: operator const char*(); // ǎǻǾǼǽǸǹǰ ǻǰȃǰǸdzǰ... };

ȼ ɪɟɡɭɥɶɬɚɬɟ ɷɬɨɝɨ ɫɬɚɧɨɜɹɬɫɹ ɤɨɦɩɢɥɢɪɭɟɦɵɦɢ ɦɚɫɫɚ ɝɥɭɩɨɫɬɟɣ ɢ ɨɩɟɱɚɬɨɤ. ɉɭɫɬɶ s1 ɢ s2 — ɨɛɴɟɤɬɵ ɬɢɩɚ String. ȼɫɟ ɩɪɢɜɟɞɟɧɧɵɟ ɧɢɠɟ ɫɬɪɨɤɢ ɤɨɦɩɢɥɢɪɭɸɬɫɹ: int x = s1 - s2; const char* p = s1 - 5; p = s1 + '0'; if( s1 == "0" ) { ... }

// // // //

ǘǰǹǺǻǰǯǰǶǰǸǸǹǰ ǺǹǭǰǯǰǸdzǰ ǘǰǹǺǻǰǯǰǶǰǸǸǹǰ ǺǹǭǰǯǰǸdzǰ ǏǰǶǫǰǽ Ǹǰ ǽǹ, Ȃǽǹ ǭȆ ǹDZdzǯǫǰǽǰ ǏǰǶǫǰǽ Ǹǰ ǽǹ, Ȃǽǹ ǭȆ ǹDZdzǯǫǰǽǰ

ɂɦɟɧɧɨ ɩɨ ɷɬɨɣ ɩɪɢɱɢɧɟ ɜ ɫɬɚɧɞɚɪɬɧɨɦ ɤɥɚɫɫɟ string ɨɬɫɭɬɫɬɜɭɟɬ operator const char*.

Исключения ɉɪɢ ɧɟɱɚɫɬɨɦ ɢ ɨɫɬɨɪɨɠɧɨɦ ɢɫɩɨɥɶɡɨɜɚɧɢɢ ɧɟɹɜɧɵɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɦɨɝɭɬ ɫɞɟɥɚɬɶ ɤɨɞ ɛɨɥɟɟ ɤɨɪɨɬɤɢɦ ɢ ɢɧɬɭɢɬɢɜɧɨ ɛɨɥɟɟ ɩɨɧɹɬɧɵɦ. ɋɬɚɧɞɚɪɬɧɵɣ ɤɥɚɫɫ std::string ɨɩɪɟɞɟɥɹɟɬ ɧɟɹɜɧɵɣ ɤɨɧɫɬɪɭɤɬɨɪ, ɤɨɬɨɪɵɣ ɩɨɥɭɱɚɟɬ ɨɞɢɧ ɚɪɝɭɦɟɧɬ ɬɢɩɚ const char*. Ɍɚɤɨɟ ɪɟɲɟɧɢɟ ɨɬɥɢɱɧɨ ɪɚɛɨɬɚɟɬ, ɩɨɫɤɨɥɶɤɭ ɩɪɨɟɤɬɢɪɨɜɳɢɤɢ ɤɥɚɫɫɚ ɩɪɢɧɹɥɢ ɨɩɪɟɞɟɥɟɧɧɵɟ ɦɟɪɵ ɩɪɟɞɨɫɬɨɪɨɠɧɨɫɬɢ. •

•

ɇɟ ɢɦɟɟɬɫɹ ɚɜɬɨɦɚɬɢɱɟɫɤɨɝɨ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ std::string ɜ const char*; ɬɚɤɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜɵɩɨɥɧɹɸɬɫɹ ɩɪɢ ɩɨɦɨɳɢ ɞɜɭɯ ɢɦɟɧɨɜɚɧɧɵɯ ɮɭɧɤɰɢɣ — c_str ɢ data. ȼɫɟ ɨɩɟɪɚɬɨɪɵ ɫɪɚɜɧɟɧɢɣ, ɨɩɪɟɞɟɥɟɧɧɵɟ ɞɥɹ std::string (ɧɚɩɪɢɦɟɪ, ==, !=, t1_ dz temp->t2_; ǰǼǶdz ǵǫǵǫȊ-ǽǹ dzDz // ǹǺǰǻǫȁdzǴ ǯǫǰǽ ǼǬǹǴ, ǮǰǸǰǻdzǻǾǰǷ dzǼǵǶȉȂǰǸdzǰ, ǭ // ǺǻǹǽdzǭǸǹǷ ǼǶǾȂǫǰ — ǺǻdzǸdzǷǫǰǷ ǭǸǰǼǰǸǸȆǰ dzDzǷǰǸǰǸdzȊ: 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). Ⱦɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɬɨɝɨ, ɞɨɥɠɧɚ ɥɢ ɮɭɧɤɰɢɹ ɛɵɬɶ ɪɟɚɥɢɡɨɜɚɧɚ ɤɚɤ ɱɥɟɧ ɢ/ɢɥɢ ɞɪɭɝ ɤɥɚɫɫɚ, ɦɨɠɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɫɥɟɞɭɸɳɢɦ ɚɥɝɨɪɢɬɦɨɦ: // ǐǼǶdz Ǿ ǭǫǼ Ǹǰǽ ǭȆǬǹǻǫ — ǯǰǶǫǴǽǰ ǿǾǸǵȁdzȉ ȂǶǰǸǹǷ.

ǐǼǶdz ǿǾǸǵȁdzȊ ǺǻǰǯǼǽǫǭǶȊǰǽ ǼǹǬǹǴ ǹǯdzǸ dzDz ǹǺǰǻǫǽǹǻǹǭ =, ->, [] dzǶdz (), ǵǹǽǹǻȆǰ ǯǹǶDZǸȆ ǬȆǽȇ ȂǶǰǸǫǷdz, ǽǹ ǯǰǶǫǴǽǰ ǯǫǸǸǾȉ ǿǾǸǵȁdzȉ ȂǶǰǸǹǷ ǵǶǫǼǼǫ.

// ǐǼǶdz ǿǾǸǵȁdzȊ ǷǹDZǰǽ ǬȆǽȇ Ǹǰ ȂǶǰǸǹǷ dz Ǹǰ ǯǻǾǮǹǷ ǶdzǬǹ // dzǷǰȉǽǼȊ ǹǺǻǰǯǰǶǰǸǸȆǰ ǺǻǰdzǷǾȄǰǼǽǭǫ ǹǽ ǽǹǮǹ, ȂǽǹǬȆ ǼǯǰǶǫǽȇ // ǰǰ Ǹǰ ȂǶǰǸǹǷ dz ǯǻǾǮǹǷ

dzǸǫȂǰ ǰǼǶdz 1. ǿǾǸǵȁdzȊ ǽǻǰǬǾǰǽ ǶǰǭȆǴ ǫǻǮǾǷǰǸǽ dzǸǹǮǹ ǽdzǺǫ (ǵǫǵ, ǸǫǺǻdzǷǰǻ, ǭ ǼǶǾȂǫǰ ǹǺǰǻǫǽǹǻǹǭ >> dzǶdz ~T(); // ǚǶǹȀǫȊ Ƿǰǽǹǯdzǵǫ! 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 dzǼǺǹǶȇDzǾǰǽǼȊ } // MyType::swap }

ɋɬɚɧɞɚɪɬ ɧɟ ɩɨɡɜɨɥɹɟɬ ɜɚɦ ɫɞɟɥɚɬɶ ɷɬɨ, ɟɫɥɢ MyType ɫɚɦ ɹɜɥɹɟɬɫɹ ɲɚɛɥɨɧɧɵɦ ɤɥɚɫɫɨɦ. Ʉ ɫɱɚɫɬɶɸ, ɢɦɟɬɶ ɬɚɤɭɸ ɫɩɟɰɢɚɥɢɡɚɰɢɸ ɯɨɪɨɲɨ, ɧɨ ɧɟ ɨɛɹɡɚɬɟɥɶɧɨ; ɨɫɧɨɜɧɚɹ ɦɟɬɨɞɢɤɚ ɫɨɫɬɨɢɬ ɜ ɨɛɟɫɩɟɱɟɧɢɢ ɮɭɧɤɰɢɢ swap, ɷɮɮɟɤɬɢɜɧɨ ɪɚɛɨɬɚɸɳɟɣ ɫ ɞɚɧɧɵɦ ɬɢɩɨɦ, ɜ ɜɢɞɟ ɮɭɧɤɰɢɢ, ɧɟ ɹɜɥɹɸɳɟɣɫɹ ɱɥɟɧɨɦ ɤɥɚɫɫɚ, ɜ ɬɨɦ ɠɟ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ, ɜ ɤɨɬɨɪɨɦ ɧɚɯɨɞɢɬɫɹ ɢ ɜɚɲ ɬɢɩ.

Исключения Ɉɛɦɟɧ ɜɚɠɟɧ ɞɥɹ ɤɥɚɫɫɨɜ ɫ ɫɟɦɚɧɬɢɤɨɣ ɡɧɚɱɟɧɢɹ. ɋɭɳɟɫɬɜɟɧɧɨ ɦɟɧɟɟ ɜɚɠɧɚ ɨɧɚ ɞɥɹ ɛɚɡɨɜɵɯ ɤɥɚɫɫɨɜ, ɩɨɫɤɨɥɶɤɭ ɷɬɢ ɤɥɚɫɫɵ ɜ ɥɸɛɨɦ ɫɥɭɱɚɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɩɨɫɪɟɞɫɬɜɨɦ ɭɤɚɡɚɬɟɥɟɣ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ 32 ɢ 54).

Ссылки [C++03] §17.4.3.1(1) • [Stroustrup00] §E.3.3 • [Sutter00] §12-13, §41

56. Обеспечьте бессбойную функцию обмена

Стр. 115

115

Стр. 116

Пространства имен и модули ɋɢɫɬɟɦɵ ɢɦɟɸɬ ɩɨɞɫɢɫɬɟɦɵ, ɤɨɬɨɪɵɟ ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ ɫɨɫɬɨɹɬ ɢɡ ɩɨɞɫɢɫɬɟɦ ɢ ɬɚɤ ɞɨ ɛɟɫɤɨɧɟɱɧɨɫɬɢ — ɢɦɟɧɧɨ ɩɨɷɬɨɦɭ ɦɵ ɜɫɟɝɞɚ ɞɜɢɠɟɦɫɹ ɫɜɟɪɯɭ ɜɧɢɡ. — Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis) ɉɪɨɫɬɪɚɧɫɬɜɨ ɢɦɟɧ — ɨɱɟɧɶ ɜɚɠɧɵɣ ɢɧɫɬɪɭɦɟɧɬ ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɢɦɟɧɚɦɢ ɢ ɫɧɢɠɟɧɢɹ ɤɨɥɢɱɟɫɬɜɚ ɤɨɥɥɢɡɢɣ ɢɦɟɧ. Ɍɨ ɠɟ ɨɬɧɨɫɢɬɫɹ ɢ ɤ ɦɨɞɭɥɹɦ, ɤɨɬɨɪɵɟ, ɩɨɦɢɦɨ ɷɬɨɝɨ, ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɢɧɫɬɪɭɦɟɧɬɚɪɢɣ ɞɥɹ ɪɚɛɨɬɵ ɫ ɜɟɪɫɢɹɦɢ. Ɇɵ ɨɩɪɟɞɟɥɢɦ ɦɨɞɭɥɶ ɤɚɤ ɨɬɞɟɥɶɧɵɣ ɤɨɦɩɨɧɟɧɬ ɩɪɨɝɪɚɦɦɵ, ɫɨɞɟɪɠɚɳɢɣ ɬɟɫɧɨ ɫɜɹɡɚɧɧɵɟ ɦɟɠɞɭ ɫɨɛɨɣ ɟɟ ɷɥɟɦɟɧɬɵ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 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 f(double), ɝɞɟ X — ɬɢɩ, ɤɨɬɨɪɵɣ ɦɨɠɟɬ ɛɵɬɶ ɩɪɟɨɛɪɚɡɨɜɚɧ ɜ int. ɋɬɚɬɢɱɟɫɤɚɹ ɩɪɨɜɟɪɤɚ ɬɢɩɨɜ. ȼɫɟ ɬɢɩɵ ɩɪɨɜɟɪɹɸɬɫɹ ɫɬɚɬɢɱɟɫɤɢ. ɋɬɚɬɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ (ɦɟɲɚɟɬ ɪɚɡɞɟɥɶɧɨɣ ɤɨɦɩɢɥɹɰɢɢ). ȼɫɟ ɬɢɩɵ ɫɜɹɡɵɜɚɸɬɫɹ ɫɬɚɬɢɱɟɫɤɢ. ɗɮɮɟɤɬɢɜɧɨɫɬɶ. ȼɵɱɢɫɥɟɧɢɹ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ ɢ ɫɬɚɬɢɱɟɫɤɨɟ ɫɜɹɡɵɜɚɧɢɟ ɩɨɡɜɨɥɹɸɬ ɞɨɫɬɢɱɶ ɨɩɬɢɦɢɡɚɰɢɢ ɢ ɷɮɮɟɤɬɢɜɧɨɫɬɢ, ɧɟɞɨɫɬɭɩɧɵɯ ɩɪɢ ɞɢɧɚɦɢɱɟɫɤɨɦ ɫɜɹɡɵɜɚɧɢɢ.

Ɉɩɪɟɞɟɥɢɬɟ ɜɚɲɢ ɩɪɢɨɪɢɬɟɬɵ ɢ ɢɫɩɨɥɶɡɭɣɬɟ ɤɚɠɞɵɣ ɜɢɞ ɩɨɥɢɦɨɪɮɢɡɦɚ ɬɚɦ, ɝɞɟ ɩɪɨɹɜɥɹɸɬɫɹ ɟɝɨ ɫɢɥɶɧɵɟ ɫɬɨɪɨɧɵ. ɋɥɟɞɭɟɬ ɫɨɱɟɬɚɬɶ ɫɬɚɬɢɱɟɫɤɢɣ ɢ ɞɢɧɚɦɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɥɭɱɢɬɶ ɩɪɟɢɦɭɳɟɫɬɜɚ ɨɛɨɢɯ ɜɢɞɨɜ ɩɨɥɢɦɨɪɮɢɡɦɚ, ɚ ɧɟ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɤɨɦɛɢɧɢɪɨɜɚɬɶ ɢɯ ɧɟɞɨɫɬɚɬɤɢ. •

ɋɬɚɬɢɤɚ ɩɨɦɨɝɚɟɬ ɞɢɧɚɦɢɤɟ. ɂɫɩɨɥɶɡɭɣɬɟ ɫɬɚɬɢɱɟɫɤɢɣ ɩɨɥɢɦɨɪɮɢɡɦ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɞɢɧɚɦɢɱɟɫɤɢ ɩɨɥɢɦɨɪɮɧɵɯ ɢɧɬɟɪɮɟɣɫɨɜ. ɇɚɩɪɢɦɟɪ, ɭ ɜɚɫ ɦɨɠɟɬ ɛɵɬɶ ɚɛɫɬɪɚɤɬɧɵɣ ɛɚɡɨɜɵɣ ɤɥɚɫɫ Command, ɢ ɜɵ ɨɩɪɟɞɟɥɹɟɬɟ ɪɚɡɥɢɱɧɵɟ ɪɟɚɥɢɡɚɰɢɢ ɜ ɜɢɞɟ ɲɚɛɥɨɧɚ template class ConcreteCommand: public Command

•

•

ȼ ɤɚɱɟɫɬɜɟ ɩɪɢɦɟɪɨɜ ɦɨɠɧɨ ɩɪɢɜɟɫɬɢ ɪɟɚɥɢɡɚɰɢɢ ɲɚɛɥɨɧɨɜ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ Command ɢ 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), ɤɨɝɞɚ ɜɚɲ ɲɚɛɥɨɧ ɩɪɨɫɬɨ ɪɚɫɫɱɢɬɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɬɢɩ ɢɦɟɟɬ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɱɥɟɧ ɫ ɞɚɧɧɵɦ ɢɦɟɧɟɦ: // ǍǫǻdzǫǸǽ 1. ǜǹDzǯǫǸdzǰ ǽǹȂǵdz ǸǫǼǽǻǹǴǵdz ǺǾǽǰǷ ǽǻǰǬǹǭǫǸdzȊ ǹǽ // ǽdzǺǫ T "foo-ǼǹǭǷǰǼǽdzǷǹǼǽdz", ǽ.ǰ. ǸǫǶdzȂdzȊ ǿǾǸǵȁdzdz-ȂǶǰǸǫ Ǽ // ǯǫǸǸȆǷ dzǷǰǸǰǷ, ǼdzǮǸǫǽǾǻǹǴ dz ǼǰǷǫǸǽdzǵǹǴ template void Sample1( T t ) { t.foo(); // foo - ǽǹȂǵǫ ǸǫǼǽǻǹǴǵdz typename T::value_type x; // ǐȄǰ ǹǯdzǸ ǺǻdzǷǰǻ: ǼǹDzǯǫǸdzǰ } // ǽǹȂǵdz ǸǫǼǽǻǹǴǵdz ǯǶȊ ǺǹdzǼǵǫ // ǽdzǺǫ (ǹǬȆȂǸǹ ǼǹDzǯǫǰǽǼȊ ǺǹǼǻǰǯǼǽǭǹǷ typedef)

Ⱦɥɹ ɪɟɚɥɢɡɚɰɢɢ ɩɟɪɜɨɝɨ ɜɚɪɢɚɧɬɚ ɚɜɬɨɪ Sample1 ɞɨɥɠɟɧ ɜɵɩɨɥɧɢɬɶ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ. • •

ȼɵɡɜɚɬɶ ɮɭɧɤɰɢɸ ɤɚɤ ɱɥɟɧ. ɉɪɨɫɬɨ ɢɫɩɨɥɶɡɭɣɬɟ ɟɫɬɟɫɬɜɟɧɧɵɣ ɫɢɧɬɚɤɫɢɫ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ-ɱɥɟɧɚ. Ⱦɨɤɭɦɟɧɬɢɪɨɜɚɬɶ ɬɨɱɤɭ ɧɚɫɬɪɨɣɤɢ. Ɍɢɩ ɞɨɥɠɟɧ ɨɛɟɫɩɟɱɢɬɶ ɞɨɫɬɭɩɧɭɸ ɮɭɧɤɰɢɸɱɥɟɧ foo, ɤɨɬɨɪɚɹ ɦɨɠɟɬ ɛɵɬɶ ɜɵɡɜɚɧɚ ɫ ɞɚɧɧɵɦɢ ɚɪɝɭɦɟɧɬɚɦɢ (ɜ ɞɚɧɧɨɦ ɫɥɭɱɚɟ — ɛɟɡ ɚɪɝɭɦɟɧɬɨɜ).

ȼɬɨɪɨɣ ɜɚɪɢɚɧɬ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɦɟɬɨɞɚ “ɧɟɹɜɧɨɝɨ ɢɧɬɟɪɮɟɣɫɚ”, ɧɨ ɫ ɮɭɧɤɰɢɹɦɢ, ɧɟ ɹɜɥɹɸɳɢɦɢɫɹ ɱɥɟɧɚɦɢ, ɩɨɢɫɤ ɤɨɬɨɪɵɯ ɜɵɩɨɥɧɹɟɬɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ADL3 (ɬ.ɟ. ɨɠɢɞɚɟɬɫɹ, ɱɬɨ ɞɚɧɧɚɹ ɮɭɧɤɰɢɹ ɧɚɯɨɞɢɬɫɹ ɜ ɩɪɨɫɬɪɚɧɫɬɜɟ ɢɦɟɧ ɬɢɩɚ, ɞɥɹ ɤɨɬɨɪɨɝɨ ɜɵɩɨɥɧɹɟɬɫɹ ɢɧɫɬɚɧɰɢɪɨɜɚɧɢɟ ɲɚɛɥɨɧɚ). ɂɦɟɧɧɨ ɷɬɚ ɫɢɬɭɚɰɢɹ ɢ ɹɜɢɥɚɫɶ ɨɫɧɨɜɧɨɣ ɩɨɛɭɞɢɬɟɥɶɧɨɣ 3

ɉɨɢɫɤ, ɡɚɜɢɫɹɳɢɣ ɨɬ ɚɪɝɭɦɟɧɬɚ (ɫɦ. ɫɬɪ. 118). — ɉɪɢɦ. ɩɟɪɟɜ.

136

Стр. 136

Шаблоны и обобщенность

ɩɪɢɱɢɧɨɣ ɞɥɹ ɜɜɟɞɟɧɢɹ ADL (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 57). ȼɚɲ ɲɚɛɥɨɧ ɪɚɫɫɱɢɬɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɞɥɹ ɢɫɩɨɥɶɡɭɟɦɨɝɨ ɬɢɩɚ ɢɦɟɟɬɫɹ ɩɨɞɯɨɞɹɳɚɹ ɮɭɧɤɰɢɹ ɫ ɡɚɞɚɧɧɵɦ ɢɦɟɧɟɦ: // ǍǫǻdzǫǸǽ 2: ǜǹDzǯǫǸdzǰ ǽǹȂǵdz ǸǫǼǽǻǹǴǵdz ǺǾǽǰǷ ǽǻǰǬǹǭǫǸdzȊ ǹǽ // ǽdzǺǫ T "foo-ǼǹǭǷǰǼǽdzǷǹǼǽdz", ǽ.ǰ. ǸǫǶdzȂdzȊ ǿǾǸǵȁdzdz, Ǹǰ // ȊǭǶȊȉȄǰǴǼȊ ȂǶǰǸǹǷ Ǽ ǯǫǸǸȆǷ dzǷǰǸǰǷ, ǼdzǮǸǫǽǾǻǹǴ dz // ǼǰǷǫǸǽdzǵǹǴ, ǺǹdzǼǵ ǵǹǽǹǻǹǴ ǭȆǺǹǶǸȊǰǽǼȊ ǺǹǼǻǰǯǼǽǭǹǷ ADL. // (Ǩǽǹ ǰǯdzǸǼǽǭǰǸǸȆǴ ǭǫǻdzǫǸǽ, Ǻǻdz ǵǹǽǹǻǹǷ Ǹǰ ǽǻǰǬǾǰǽǼȊ ǺǹdzǼǵ // ǼǫǷǹǮǹ ǽdzǺǫ T.) template void Sample2( T t ) { foo( t ); // foo - ǽǹȂǵǫ ǸǫǼǽǻǹǴǵdz cout baz(); // } };

ǓǼǺǹǶȇDzǹǭǫǸdzǰ ǭǶǹDZǰǸǸǹǮǹ ǽdzǺǫ (dzǶdz ǼdzǸǹǸdzǷǫ typedef) dzDz ǬǫDzǹǭǹǮǹ ǵǶǫǼǼǫ ǍȆDzǹǭ ǿǾǸǵȁdzdz-ȂǶǰǸǫ ǬǫDzǹǭǹǮǹ ǵǶǫǼǼǫ NjǶȇǽǰǻǸǫǽdzǭǸȆǴ ǼǺǹǼǹǬ

ɋɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ C++ ɜ ɨɫɧɨɜɧɨɦ ɨɬɞɚɟɬ ɩɪɟɞɩɨɱɬɟɧɢɟ ɜɚɪɢɚɧɬɭ 2 (ɧɚɩɪɢɦɟɪ, ostream_iterator ɢɳɟɬ ɨɩɟɪɚɬɨɪ operator low_ && val < high_; } private: T low_, high_; }; vector::iterator i = find_if( v.begin(), v.end(), BetweenValues (x, y));

ɉɪɢ ɩɪɢɦɟɧɟɧɢɢ ɥɹɦɛɞɚ-ɮɭɧɤɰɢɣ ɦɨɠɧɨ ɧɚɩɢɫɚɬɶ ɩɪɨɫɬɨ: vector::iterator i = 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

Стр. 178

STL: алгоритмы

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::iterator). ȿɫɥɢ ɜɚɦ ɧɭɠɧɵ ɞɚɧɧɵɟ ɚɥɝɨɪɢɬɦɵ, ɧɨ ɭ ɜɚɫ ɧɟɬ ɢɬɟɪɚɬɨɪɨɜ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ, ɜɵ ɦɨɠɟɬɟ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɢɞɢɨɦɨɣ ɢɧɞɟɤɫɧɨɝɨ ɤɨɧɬɟɣɧɟɪɚ: ɫɨɡɞɚɣɬɟ ɤɨɧɬɟɣɧɟɪ, ɩɨɞɞɟɪɠɢɜɚɸɳɢɣ ɢɬɟɪɚɬɨɪɵ ɩɪɨɢɡɜɨɥɶɧɨɝɨ ɞɨɫɬɭɩɚ (ɧɚɩɪɢɦɟɪ, vector), ɜ ɤɨɬɨɪɨɦ ɛɭɞɭɬ ɯɪɚɧɢɬɶɫɹ ɢɬɟɪɚɬɨɪɵ, ɭɤɚɡɵɜɚɸɳɢɟ ɧɚ ɷɥɟɦɟɧɬɵ ɢɧɬɟɪɟɫɭɸɳɟɝɨ ɜɚɫ ɞɢɚɩɚɡɨɧɚ, ɢ ɡɚɬɟɦ ɩɪɢɦɟɧɢɬɟ ɤ ɧɟɦɭ ɛɨɥɟɟ ɦɨɳɧɵɣ ɚɥɝɨɪɢɬɦ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɪɚɡɵɦɟɧɨɜɵɜɚɸɳɟɣ ɜɟɪɫɢɢ ɜɚɲɟɝɨ ɩɪɟɞɢɤɚɬɚ (ɜ ɤɨɬɨɪɨɣ ɩɟɪɟɞ ɨɛɵɱɧɵɦ ɫɪɚɜɧɟɧɢɟɦ ɜɵɩɨɥɧɹɟɬɫɹ ɪɚɡɵɦɟɧɨɜɚɧɢɟ ɢɬɟɪɚɬɨɪɨɜ). ȼɟɪɫɢɢ stable_… ɫɥɟɞɭɟɬ ɩɪɢɦɟɧɹɬɶ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɜɚɦ ɧɟɨɛɯɨɞɢɦɨ ɫɨɯɪɚɧɢɬɶ ɨɬɧɨɫɢɬɟɥɶɧɵɣ ɩɨɪɹɞɨɤ ɨɞɢɧɚɤɨɜɵɯ ɷɥɟɦɟɧɬɨɜ. Ɂɚɦɟɬɢɦ, ɱɬɨ ɚɥɝɨɪɢɬɦɵ partial_sort ɢ nth_element ɧɟ ɹɜɥɹɸɬɫɹ ɭɫɬɨɣɱɢɜɵɦɢ (ɬ.ɟ. ɨɧɢ ɧɟ ɨɫɬɚɜɥɹɸɬ ɨɞɢɧɚɤɨɜɵɟ ɷɥɟɦɟɧɬɵ ɜ ɬɨɦ ɠɟ ɨɬɧɨɫɢɬɟɥɶɧɨɦ ɩɨɪɹɞɤɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɢ ɧɚɯɨɞɢɥɢɫɶ ɞɨ ɫɨɪɬɢɪɨɜɤɢ), ɢ ɭ ɧɢɯ ɧɟɬ ɫɬɚɧɞɚɪɬɢɡɢɪɨɜɚɧɧɵɯ ɭɫɬɨɣɱɢɜɵɯ ɜɟɪɫɢɣ. ȿɫɥɢ ɜɚɦ ɜɫɟ ɠɟ ɬɪɟɛɭɟɬɫɹ ɫɨɯɪɚɧɟɧɢɟ ɨɬɧɨɫɢɬɟɥɶɧɨɣ ɭɩɨɪɹɞɨɱɟɧɧɨɫɬɢ ɷɥɟɦɟɧɬɨɜ, ɜɟɪɨɹɬɧɨ, ɜɚɦ ɧɚɞɨ ɢɫɩɨɥɶɡɨɜɚɬɶ stable_sort. ɋɚɦɨ ɫɨɛɨɣ ɪɚɡɭɦɟɟɬɫɹ, ɧɟ ɫɥɟɞɭɟɬ ɩɪɢɛɟɝɚɬɶ ɧɢ ɤ ɤɚɤɢɦ ɚɥɝɨɪɢɬɦɚɦ ɫɨɪɬɢɪɨɜɤɢ, ɟɫɥɢ ɜɵ ɦɨɠɟɬɟ ɨɛɨɣɬɢɫɶ ɛɟɡ ɧɢɯ. ȿɫɥɢ ɜɵ ɩɨɥɶɡɭɟɬɟɫɶ ɫɬɚɧɞɚɪɬɧɵɦ ɚɫɫɨɰɢɚɬɢɜɧɵɦ ɤɨɧɬɟɣɧɟɪɨɦ (set/multiset ɢɥɢ map/multimap) ɢɥɢ ɚɞɚɩɬɟɪɨɦ priority_queue, ɢ ɜɚɦ ɬɪɟɛɭɟɬɫɹ ɬɨɥɶɤɨ ɨɞɢɧ ɩɨɪɹɞɨɤ ɫɨɪɬɢɪɨɜɤɢ, ɬɨ ɧɟ ɡɚɛɵɜɚɣɬɟ, ɱɬɨ ɷɥɟɦɟɧɬɵ ɜ ɷɬɢɯ ɤɨɧɬɟɣɧɟɪɚɯ ɜɫɟɝɞɚ ɧɚɯɨɞɹɬɫɹ ɜ ɨɬɫɨɪɬɢɪɨɜɚɧɧɨɦ ɜɢɞɟ.

Примеры ɉɪɢɦɟɪ 1. partition. ȿɫɥɢ ɜɚɦ ɧɚɞɨ ɪɚɡɞɟɥɢɬɶ ɜɟɫɶ ɞɢɚɩɚɡɨɧ ɧɚ ɞɜɟ ɝɪɭɩɩɵ (ɝɪɭɩɩɚ ɷɥɟɦɟɧɬɨɜ, ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ ɩɪɟɞɢɤɚɬɭ, ɡɚ ɤɨɬɨɪɵɦɢ ɫɥɟɞɭɟɬ ɝɪɭɩɩɚ ɷɥɟɦɟɧɬɨɜ, ɩɪɟɞɢɤɚɬɭ ɧɟ ɭɞɨɜɥɟɬɜɨɪɹɸɳɢɯ), ɬɨ ɞɥɹ ɷɬɨɝɨ ɞɨɫɬɚɬɨɱɧɨ ɜɨɫɩɨɥɶɡɨɜɚɬɶɫɹ ɚɥɝɨɪɢɬɦɨɦ partition. ɗɬɨ ɜɫɟ, ɱɬɨ ɜɚɦ ɧɚɞɨ, ɱɬɨɛɵ ɨɬɜɟɬɢɬɶ ɧɚ ɜɨɩɪɨɫɵ ɧɚɩɨɞɨɛɢɟ ɩɪɢɜɟɞɟɧɧɵɯ ɞɚɥɟɟ.

180

Стр. 180

STL: алгоритмы

•

•

Ʉɬɨ ɢɡ ɫɬɭɞɟɧɬɨɜ ɢɦɟɟɬ ɫɪɟɞɧɢɣ ɛɚɥ ɧɟ ɧɢɠɟ 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

Стр. 182

STL: алгоритмы

Примеры ɉɪɢɦɟɪ. FlagNth. ɉɟɪɟɞ ɜɚɦɢ ɤɥɚɫɫɢɱɟɫɤɢɣ ɩɪɢɦɟɪ ɢɡ [Sutter02], ɜ ɤɨɬɨɪɨɦ ɜɵɩɨɥɧɹɟɬɫɹ ɩɨɩɵɬɤɚ ɭɞɚɥɢɬɶ ɬɪɟɬɢɣ ɷɥɟɦɟɧɬ ɢɡ ɤɨɧɬɟɣɧɟɪɚ v. class FlagNth { public: FlagNth( size_t n ) : current_(0), n_(n) { } // ǍǹDzǭǻǫȄǫǰǷ DzǸǫȂǰǸdzǰ true ǽǹǶȇǵǹ Ǻǻdz ǽǻǰǽȇǰǷ ǭȆDzǹǭǰ template bool operator()( const T& ) // ǚǶǹȀǹ: ǸǰǵǹǸǼǽǫǸǽǸǫȊ { return ++current_ == n_; } // ǿǾǸǵȁdzȊ private: size_t current_, n_; }; // ... ǺǹDzDZǰ ... 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 )); // ǙȃdzǬǵǫ

Ɉɛɨɣɬɢ ɷɬɭ ɨɲɢɛɤɭ ɨɛɵɱɧɨ ɦɨɠɧɨ ɩɭɬɟɦ ɩɪɢɦɟɧɟɧɢɹ ptr_fun (ɢɥɢ, ɜ ɫɥɭɱɚɟ ɮɭɧɤɰɢɢɱɥɟɧɚ, mem_fun ɢɥɢ mem_fun_ref), ɱɬɨ, ɤ ɫɨɠɚɥɟɧɢɸ, ɧɟ ɪɚɛɨɬɚɟɬ ɜ ɞɚɧɧɨɦ ɤɨɧɤɪɟɬɧɨɦ ɫɥɭɱɚɟ: inline bool IsHeavy( const Thing& ) { /* ... */ } find_if(v.begin(), v.end(), not1(ptr_fun (IsHeavy ))); // ǎǰǻǹdzȂǰǼǵǫȊ ǺǹǺȆǽǵǫ...

Ȼɟɞɚ ɜ ɬɨɦ, ɱɬɨ ɷɬɨɬ ɫɩɨɫɨɛ ɧɟ ɛɭɞɟɬ ɪɚɛɨɬɚɬɶ, ɞɚɠɟ ɟɫɥɢ ɜɵ ɹɜɧɨ ɭɤɚɠɟɬɟ ɚɪɝɭɦɟɧɬɵ ɲɚɛɥɨɧɚ ptr_fun. Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɩɪɨɛɥɟɦɚ ɜ ɬɨɦ, ɱɬɨ ptr_fun ɬɨɱɧɨ ɜɵɜɨɞɢɬ ɬɢɩɵ ɚɪɝɭɦɟɧɬɨɜ ɢ ɜɨɡɜɪɚɳɚɟɦɵɣ ɬɢɩ (ɜ ɱɚɫɬɧɨɫɬɢ, ɬɢɩ ɩɚɪɚɦɟɬɪɚ ɛɭɞɟɬ ɜɵɜɟɞɟɧ ɤɚɤ const Thing&) ɢ ɫɨɡɞɚɟɬ ɜɧɭɬɪɟɧɧɢɣ ɦɟɯɚɧɢɡɦ, ɤɨɬɨɪɵɣ, ɜ ɫɜɨɸ ɨɱɟɪɟɞɶ, ɩɵɬɚɟɬɫɹ ɞɨɛɚɜɢɬɶ ɞɪɭɝɨɣ &, ɚ ɫɫɵɥɤɚ ɧɚ ɫɫɵɥɤɭ ɜ ɧɚɫɬɨɹɳɟɟ ɜɪɟɦɹ ɜ C++ ɧɟ ɪɚɡɪɟɲɟɧɚ. ɂɦɟɸɬɫɹ ɫɩɨɫɨɛɵ ɢɫɩɪɚɜɥɟɧɢɣ ɹɡɵɤɚ ɢ/ɢɥɢ ɛɢɛɥɢɨɬɟɤɚ ɞɥɹ ɪɟɲɟɧɢɹ ɞɚɧɧɨɣ ɩɪɨɛɥɟɦɵ (ɧɚɩɪɢɦɟɪ, ɩɨɡɜɨɥɹɹ ɫɫɵɥɤɟ ɧɚ ɫɫɵɥɤɭ ɫɜɟɪɧɭɬɶɫɹ ɜ ɨɛɵɱɧɭɸ ɫɫɵɥɤɭ; ɫɦ. ɬɚɤɠɟ ɪɟɤɨɦɟɧɞɚɰɢɸ 89), ɧɨ ɧɚ ɫɟɝɨɞɧɹɲɧɢɣ ɞɟɧɶ ɩɪɨɛɥɟɦɚ ɨɫɬɚɟɬɫɹ ɧɟɪɟɲɟɧɧɨɣ. ɉɪɢɛɟɝɚɬɶ ɤɨ ɜɫɟɦ ɷɬɢɦ ɭɯɢɳɪɟɧɢɹɦ ɫɨɜɟɪɲɟɧɧɨ ɢɡɥɢɲɧɟ, ɟɫɥɢ ɭ ɜɚɫ ɢɦɟɟɬɫɹ ɤɨɪɪɟɤɬɧɨ ɧɚɩɢɫɚɧɧɵɣ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 89), ɤɨɬɨɪɵɣ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɛɟɡ ɤɚɤɨɝɨ-ɥɢɛɨ ɫɩɟɰɢɚɥɶɧɨɝɨ ɫɢɧɬɚɤɫɢɫɚ: struct IsHeavy : unary_function { bool operator()( const Thing& ) const { /* ... */ } }; find_if(v.begin(), v.end(), not1(IsHeavy ())); // OK

ȿɳɟ ɛɨɥɟɟ ɜɚɠɧɨ ɬɨ, ɱɬɨ ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɫɪɚɜɧɟɧɢɹ ɜ ɚɫɫɨɰɢɚɬɢɜɧɵɯ ɤɨɧɬɟɣɧɟɪɚɯ ɜɚɦ ɧɭɠɟɧ ɢɦɟɧɧɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɣ ɨɛɴɟɤɬ, ɚ ɧɟ ɮɭɧɤɰɢɹ. ɗɬɨ ɫɜɹɡɚɧɨ ɫ ɬɟɦ, ɱɬɨ ɧɟɥɶɡɹ ɢɧɫɬɚɧɰɢɪɨɜɚɬɶ ɲɚɛɥɨɧ ɫ ɮɭɧɤɰɢɟɣ ɜ ɤɚɱɟɫɬɜɟ ɩɚɪɚɦɟɬɪɚ: bool CompareThings( const Thing&, const Thing& ); set s; // ǙȃdzǬǵǫ

184

Стр. 184

STL: алгоритмы

ȼɦɟɫɬɨ ɷɬɨɝɨ ɫɥɟɞɭɟɬ ɧɚɩɢɫɚɬɶ: struct CompareThings : public binary_function { bool operator()( const Thing&, const Thing& ) const; }; set s; // OK

ɇɚɤɨɧɟɰ, ɢɦɟɟɬɫɹ ɟɳɟ ɨɞɧɨ ɩɪɟɢɦɭɳɟɫɬɜɨ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɨɛɴɟɤɬɨɜ — ɷɮɮɟɤɬɢɜɧɨɫɬɶ. Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɡɧɚɤɨɦɵɣ ɚɥɝɨɪɢɬɦ: template 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 { 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 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

Стр. 186

STL: алгоритмы

Безопасность типов ȿɫɥɢ ɜɵ ɥɠɟɬɟ ɤɨɦɩɢɥɹɬɨɪɭ, ɨɧ ɛɭɞɟɬ ɦɫɬɢɬɶ. — Ƚɟɧɪɢ ɋɩɟɧɫɟɪ (Henry Spencer) ȼɫɟɝɞɚ ɛɭɞɭɬ ɜɟɳɢ, ɤɨɬɨɪɵɟ ɦɵ ɛɭɞɟɦ ɯɨɬɟɬɶ ɫɤɚɡɚɬɶ ɜ ɧɚɲɢɯ ɩɪɨɝɪɚɦɦɚɯ ɢ ɤɨɬɨɪɵɟ ɬɪɭɞɧɨ ɫɮɨɪɦɭɥɢɪɨɜɚɬɶ ɧɚ ɥɸɛɨɦ ɹɡɵɤɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. — Ⱥɥɚɧ ɉɟɪɥɢɫ (Alan Perlis) ɉɨɫɥɟɞɧɟɣ (ɧɟ ɩɨ ɜɚɠɧɨɫɬɢ) ɬɟɦɨɣ ɤɧɢɝɢ ɹɜɥɹɟɬɫɹ ɤɨɪɪɟɤɬɧɨɫɬɶ ɬɢɩɨɜ — ɨɱɟɧɶ ɜɚɠɧɨɟ ɫɜɨɣɫɬɜɨ ɩɪɨɝɪɚɦɦ, ɤɨɬɨɪɨɟ ɜɵ ɞɨɥɠɧɵ ɢɡɨ ɜɫɟɯ ɫɢɥ ɫɬɚɪɚɬɶɫɹ ɩɨɞɞɟɪɠɢɜɚɬɶ. Ɍɟɨɪɟɬɢɱɟɫɤɢ ɤɨɪɪɟɤɬɧɚɹ ɫ ɬɨɱɤɢ ɡɪɟɧɢɹ ɬɢɩɨɜ ɮɭɧɤɰɢɹ ɧɟ ɦɨɠɟɬ ɨɛɪɚɬɢɬɶɫɹ ɤ ɧɟɬɢɩɢɡɢɪɨɜɚɧɧɨɣ ɩɚɦɹɬɢ ɢɥɢ ɜɟɪɧɭɬɶ ɧɟɜɟɪɧɵɟ ɡɧɚɱɟɧɢɹ. ɇɚ ɩɪɚɤɬɢɤɟ, ɟɫɥɢ ɜɚɲ ɤɨɞ ɩɨɞɞɟɪɠɢɜɚɟɬ ɤɨɪɪɟɤɬɧɨɫɬɶ ɬɢɩɨɜ, ɨɧ ɬɟɦ ɫɚɦɵɦ ɢɡɛɟɝɚɟɬ ɛɨɥɶɲɨɝɨ ɤɨɥɢɱɟɫɬɜɚ ɧɟɩɪɢɹɬɧɵɯ ɨɲɢɛɨɤ, ɨɬ ɧɟɩɟɪɟɧɨɫɢɦɨɫɬɢ ɩɪɨɝɪɚɦɦ ɞɨ ɩɨɪɱɢ ɫɨɞɟɪɠɢɦɨɝɨ ɩɚɦɹɬɢ ɢ ɧɟɨɩɪɟɞɟɥɟɧɧɨɝɨ ɩɨɜɟɞɟɧɢɹ ɩɪɨɝɪɚɦɦ. Ɉɫɧɨɜɧɚɹ ɢɞɟɹ ɩɨɞɞɟɪɠɤɢ ɤɨɪɪɟɤɬɧɨɫɬɢ ɬɢɩɨɜ — ɜɫɟɝɞɚ ɫɱɢɬɵɜɚɬɶ ɢɧɮɨɪɦɚɰɢɸ ɜ ɬɨɦ ɮɨɪɦɚɬɟ, ɜ ɤɨɬɨɪɨɦ ɨɧɚ ɛɵɥɚ ɡɚɩɢɫɚɧɚ. ɂɧɨɝɞɚ 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: // ... Ǖǹǯ ǯǶȊ ǺǻȊǷǹǾǮǹǶȇǸdzǵǫ ... break; case TRIANGLE: // ... Ǖǹǯ ǯǶȊ ǽǻǰǾǮǹǶȇǸdzǵǫ ... break; case CIRCLE: // ... Ǖǹǯ ǯǶȊ ǹǵǻǾDZǸǹǼǽdz ... break; default : // ǚǶǹȀǹǰ ǻǰȃǰǸdzǰ assert (!"ǚǻdz ǯǹǬǫǭǶǰǸdzdz ǸǹǭǹǮǹ ǽdzǺǫ Ǹǫǯǹ " "ǹǬǸǹǭdzǽȇ ȈǽǾ ǵǹǸǼǽǻǾǵȁdzȉ" ); break; } } };

Ɍɚɤɨɣ ɤɨɞ ɫɝɢɛɚɟɬɫɹ ɩɨɞ ɫɨɛɫɬɜɟɧɧɵɦ ɜɟɫɨɦ, ɨɧ ɯɪɭɩɨɤ, ɧɟɧɚɞɟɠɟɧ ɢ ɫɥɨɠɟɧ. ȼ ɱɚɫɬɧɨɫɬɢ, ɨɧ ɫɬɪɚɞɚɟɬ ɬɪɚɧɡɢɬɢɜɧɨɣ ɰɢɤɥɢɱɟɫɤɨɣ ɡɚɜɢɫɢɦɨɫɬɶɸ, ɨ ɤɨɬɨɪɨɣ ɝɨɜɨɪɢɥɨɫɶ ɜ ɪɟɤɨɦɟɧɞɚɰɢɢ 22. ȼɟɬɜɶ ɩɨ ɭɦɨɥɱɚɧɢɸ ɤɨɧɫɬɪɭɤɰɢɢ switch — ɱɟɬɤɢɣ ɫɢɦɩɬɨɦ ɫɢɧɞɪɨɦɚ “ɧɟ ɡɧɚɸ, ɱɬɨ ɦɧɟ ɞɟɥɚɬɶ ɫ ɷɬɢɦ ɬɢɩɨɦ”. ɂ ɜɫɟ ɷɬɢ ɛɨɥɟɡɧɟɧɧɵɟ ɧɟɩɪɢɹɬɧɨɫɬɢ ɩɨɥɧɨɫɬɶɸ ɢɫɱɟɡɚɸɬ, ɫɬɨɢɬ ɬɨɥɶɤɨ ɜɫɩɨɦɧɢɬɶ, ɱɬɨ C++ — ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɵɣ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ: class Shape { // ... virtual void Draw() const = 0; // ǕǫDZǯȆǴ ǺǻǹdzDzǭǹǯǸȆǴ // ǵǶǫǼǼ ǻǰǫǶdzDzǾǰǽ Ǽǭǹȉ ǿǾǸǵȁdzȉ };

ȼ ɤɚɱɟɫɬɜɟ ɚɥɶɬɟɪɧɚɬɢɜɵ (ɢɥɢ ɜ ɤɚɱɟɫɬɜɟ ɞɨɩɨɥɧɟɧɢɹ) ɪɚɫɫɦɨɬɪɢɦ ɪɟɚɥɢɡɚɰɢɸ, ɤɨɬɨɪɚɹ ɫɥɟɞɭɟɬ ɫɨɜɟɬɭ ɩɨ ɜɨɡɦɨɠɧɨɫɬɢ ɩɪɢɧɢɦɚɬɶ ɪɟɲɟɧɢɹ ɜɨ ɜɪɟɦɹ ɤɨɦɩɢɥɹɰɢɢ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 64): template void Draw( const S& shape ) { shape.Draw(); // ǗǹDZǰǽ ǬȆǽȇ ǭdzǻǽǾǫǶȇǸǹǴ, ǫ ǷǹDZǰǽ dz Ǹǰ ǬȆǽȇ }; // ǜǷ. ǻǰǵǹǷǰǸǯǫȁdzȉ 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

Стр. 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 ( p1 );

ɥɭɱɲɟ ɩɢɫɚɬɶ T1* p1 = ... ; void* pV = p1; T2* p2 = static_cast ( pV );

Ссылки [C++03] §5.2.10(3) • [Dewhurst03] §39 • [Stroustrup00] §5.6

192

Стр. 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 To checked_cast (From* from) { assert(dynamic_cast(from) == static_cast(from) && "checked_cast failed" ); return static_cast( from ); } template To checked_cast (From& from) { typedef tr1::remove_reference::type* ToPtr; // [C++TR104] assert(dynamic_cast(&from) == static_cast(&from) && "checked_cast failed" ); return static_cast( 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 (size) = n; // ǘǰ ǯǰǶǫǴǽǰ ǽǫǵ! char buffer[size]; // ǛǫDzǷǰǻ ǷǫǼǼdzǭǫ // ... // ǭǼǰ ǻǫǭǸǹ ǻǫǭǰǸ 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 (f(ref)) ); // ǚǻǰǹǬǻǫDzǹǭǫǸdzǰ } // ǭǹDzǭǻǫȄǫǰǷǹǮǹ ǽdzǺǫ

Ссылки [Dewhurst03] §32, §40 • [Sutter00] §44

194

Стр. 194

Безопасность типов

95. Не используйте преобразование типов в стиле C Резюме ȼɨɡɪɚɫɬ ɧɟ ɜɫɟɝɞɚ ɨɡɧɚɱɚɟɬ ɦɭɞɪɨɫɬɶ. ɋɬɚɪɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɢɦɟɟɬ ɪɚɡɥɢɱɧɭɸ (ɢ ɱɚɫɬɨ ɨɩɚɫɧɭɸ) ɫɟɦɚɧɬɢɤɭ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɤɨɧɬɟɤɫɬɚ, ɫɩɪɹɬɚɧɧɭɸ ɡɚ ɟɞɢɧɵɦ ɫɢɧɬɚɤɫɢɫɨɦ. Ɂɚɦɟɧɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C ɩɪɟɨɛɪɚɡɨɜɚɧɢɹɦɢ C++ ɩɨɦɨɠɟɬ ɡɚɳɢɬɢɬɶɫɹ ɨɬ ɧɟɨɠɢɞɚɧɧɵɯ ɨɲɢɛɨɤ.

Обсуждение Ɉɞɧɚ ɢɡ ɩɪɨɛɥɟɦ, ɫɜɹɡɚɧɧɵɯ ɫ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟɦ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɨɧɨ ɢɫɩɨɥɶɡɭɟɬ ɨɞɢɧ ɢ ɬɨɬ ɠɟ ɫɢɧɬɚɤɫɢɫ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɧɟɫɤɨɥɶɤɨ ɪɚɡɧɵɯ ɜɟɳɟɣ, ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɚɤɢɯ ɦɟɥɨɱɟɣ, ɤɚɤ, ɧɚɩɪɢɦɟɪ, ɤɚɤɢɟ ɢɦɟɧɧɨ ɡɚɝɨɥɨɜɨɱɧɵɟ ɮɚɣɥɵ ɜɤɥɸɱɟɧɵ ɩɪɢ ɩɨɦɨɳɢ ɞɢɪɟɤɬɢɜɵ #include. ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɬɢɩɨɜ ɜ ɫɬɢɥɟ C++, ɫɨɯɪɚɧɹɹ ɨɩɪɟɞɟɥɟɧɧɭɸ ɨɩɚɫɧɨɫɬɶ, ɩɪɢɫɭɳɭɸ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹɦ ɜɨɨɛɳɟ, ɢɦɟɸɬ ɱɟɬɤɨ ɞɨɤɭɦɟɧɬɢɪɨɜɚɧɧɨɟ ɩɪɟɞɧɚɡɧɚɱɟɧɢɟ, ɢɯ ɥɟɝɤɨ ɧɚɣɬɢ, ɞɨɥɶɲɟ ɩɢɫɚɬɶ (ɱɬɨ ɞɚɟɬ ɜɪɟɦɹ ɞɜɚɠɞɵ ɩɨɞɭɦɚɬɶ ɩɪɢ ɢɯ ɢɫɩɨɥɶɡɨɜɚɧɢɢ), ɢ ɧɟ ɩɨɡɜɨɥɹɸɬ ɧɟɡɚɦɟɬɧɨ ɜɵɩɨɥɧɢɬɶ ɨɩɚɫɧɨɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ reinterpret_cast (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92). Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɤɨɞ, ɜ ɤɨɬɨɪɨɦ Derived — ɩɪɨɢɡɜɨɞɧɵɣ ɨɬ ɛɚɡɨɜɨɝɨ ɤɥɚɫɫɚ Base: extern void Fun( Derived* ); void Gun( Base* pb ) { // njǾǯǰǷ ǼȂdzǽǫǽȇ, Ȃǽǹ ǿǾǸǵȁdzȊ Gun DzǸǫǰǽ, Ȃǽǹ pb ǭ // ǯǰǴǼǽǭdzǽǰǶȇǸǹǼǽdz ǾǵǫDzȆǭǫǰǽ Ǹǫ ǹǬȅǰǵǽ ǽdzǺǫ Derived dz // ȀǹȂǰǽ Ǻǰǻǰǯǫǽȇ ǰǮǹ ǿǾǸǵȁdzdz Fun Derived* pd = (Derived*)pb; // ǚǶǹȀǹ: ǺǻǰǹǬǻǫDzǹǭǫǸdzǰ Fun( pd ); // ǭ ǼǽdzǶǰ C }

ȿɫɥɢ ɮɭɧɤɰɢɹ Gun ɢɦɟɟɬ ɞɨɫɬɭɩ ɤ ɨɩɪɟɞɟɥɟɧɢɸ Derived (ɧɚɩɪɢɦɟɪ, ɩɪɢ ɜɤɥɸɱɟɧɢɢ ɡɚɝɨɥɨɜɨɱɧɨɝɨ ɮɚɣɥɚ derived.h), ɬɨ ɤɨɦɩɢɥɹɬɨɪ ɢɦɟɟɬ ɜɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨ ɪɚɡɦɟɳɟɧɢɢ ɨɛɴɟɤɬɚ, ɱɬɨɛɵ ɜɵɩɨɥɧɢɬɶ ɜɫɟ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ ɩɨ ɤɨɪɪɟɤɬɢɪɨɜɤɟ ɭɤɚɡɚɬɟɥɹ ɩɪɢ ɩɪɟɨɛɪɚɡɨɜɚɧɢɢ ɨɬ Base ɤ Derived. ɇɨ ɟɫɥɢ ɚɜɬɨɪ Gun ɡɚɛɵɥ ɜɤɥɸɱɢɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɮɚɣɥ ɨɩɪɟɞɟɥɟɧɢɹ, ɢ ɮɭɧɤɰɢɢ Gun ɜɢɞɧɨ ɬɨɥɶɤɨ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɟ ɨɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ Derived, ɬɨ ɤɨɦɩɢɥɹɬɨɪ ɛɭɞɟɬ ɩɨɥɚɝɚɬɶ, ɱɬɨ Base ɢ Derived — ɧɟɫɜɹɡɚɧɧɵɟ ɬɢɩɵ, ɢ ɢɧɬɟɪɩɪɟɬɢɪɭɟɬ ɛɢɬɵ ɭɤɚɡɚɬɟɥɹ Base* ɤɚɤ ɛɢɬɵ ɭɤɚɡɚɬɟɥɹ Derived*, ɧɟ ɞɟɥɚɹ ɧɢɤɚɤɢɯ ɤɨɪɪɟɤɰɢɣ, ɤɨɬɨɪɵɟ ɦɨɝɭɬ ɞɢɤɬɨɜɚɬɶɫɹ ɪɚɡɦɟɳɟɧɢɟɦ ɨɛɴɟɤɬɚ ɜ ɩɚɦɹɬɢ! Ʉɨɪɨɬɤɨ ɝɨɜɨɪɹ, ɟɫɥɢ ɜɵ ɡɚɛɭɞɟɬɟ ɜɤɥɸɱɢɬɶ ɨɩɪɟɞɟɥɟɧɢɟ ɤɥɚɫɫɚ, ɬɨ ɜɚɲ ɤɨɞ ɦɨɠɟɬ ɚɜɚɪɢɣɧɨ ɡɚɜɟɪɲɢɬɶɫɹ ɛɟɡ ɜɢɞɢɦɵɯ ɩɪɢɱɢɧ, ɩɪɢ ɬɨɦ ɱɬɨ ɤɨɦɩɢɥɹɬɨɪ ɧɟ ɫɨɨɛɳɢɥ ɧɢ ɨɛ ɨɞɧɨɣ ɨɲɢɛɤɟ. ɂɡɛɚɜɢɦɫɹ ɨɬ ɩɪɨɛɥɟɦɵ ɫɥɟɞɭɸɳɢɦ ɫɩɨɫɨɛɨɦ: extern void Fun( Derived* ); void Gun( Base* pb ) { // ǐǼǶdz ǷȆ ǮǫǻǫǸǽdzǻǹǭǫǸǸǹ DzǸǫǰǷ, Ȃǽǹ pb Ǹǫ ǼǫǷǹǷ ǯǰǶǰ // ǾǵǫDzȆǭǫǰǽ Ǹǫ ǹǬȅǰǵǽ ǽdzǺǫ Derived: // ǚǻǰǹǬǻǫDzǹǭǫǸdzǰ ǭ ǼǽdzǶǰ C++ Derived * pd = static_cast (pb);

95. Не используйте преобразование типов в стиле C

Стр. 195

195

// Ǎ ǺǻǹǽdzǭǸǹǷ ǼǶǾȂǫǰ ǼǶǰǯǾǰǽ dzǼǺǹǶȇDzǹǭǫǽȇ // Fun(pd);

= dynamic_cast(pb);

}

Ɍɟɩɟɪɶ, ɟɫɥɢ ɭ ɤɨɦɩɢɥɹɬɨɪɚ ɧɟɞɨɫɬɚɬɨɱɧɨ ɫɬɚɬɢɱɟɫɤɨɣ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɨɬɧɨɲɟɧɢɹɯ ɦɟɠɞɭ Base ɢ Derived, ɨɧ ɜɵɜɟɞɟɬ ɫɨɨɛɳɟɧɢɟ ɨɛ ɨɲɢɛɤɟ, ɜɦɟɫɬɨ ɬɨɝɨ ɱɬɨɛɵ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɩɪɢɦɟɧɢɬɶ ɩɨɛɢɬɨɜɨɟ (ɢ ɩɨɬɟɧɰɢɚɥɶɧɨ ɨɩɚɫɧɨɟ) ɩɪɟɨɛɪɚɡɨɜɚɧɢɟ reinterpret_cast (ɫɦ. ɪɟɤɨ-

ɦɟɧɞɚɰɢɸ 92). ɉɪɟɨɛɪɚɡɨɜɚɧɢɹ ɜ ɫɬɢɥɟ 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; // ǚǶǹȀǹ: // ... // ǺǻǰǹǬǻǫDzǹǭǫǸdzǰ ǭ ǼǽdzǶǰ 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

Стр. 196

Безопасность типов

96. Не применяйте memcpy или memcmp к не@POD типам Резюме ɇɟ ɪɚɛɨɬɚɣɬɟ ɪɟɧɬɝɟɧɨɜɫɤɢɦ ɚɩɩɚɪɚɬɨɦ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 91). ɇɟ ɢɫɩɨɥɶɡɭɣɬɟ memcpy ɢ memcmp ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɢɥɢ ɫɪɚɜɧɟɧɢɹ ɱɟɝɨ-ɥɢɛɨ ɫɬɪɭɤɬɭɪɢɪɨɜɚɧɧɨɝɨ ɛɨɥɟɟ, ɱɟɦ ɨɛɵɱɧɚɹ ɩɚɦɹɬɶ.

Обсуждение Ɏɭɧɤɰɢɢ memcpy ɢ memcmp ɧɚɪɭɲɚɸɬ ɫɢɫɬɟɦɭ ɬɢɩɨɜ. ɂɫɩɨɥɶɡɨɜɚɬɶ memcpy ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɨɛɴɟɤɬɨɜ — ɷɬɨ ɬɨ ɠɟ, ɱɬɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɫɟɪɨɤɫ ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɞɟɧɟɝ, ɚ ɫɪɚɜɧɢɜɚɬɶ ɨɛɴɟɤɬɵ ɩɪɢ ɩɨɦɨɳɢ memcmp — ɬɨ ɠɟ, ɱɬɨ ɫɪɚɜɧɢɜɚɬɶ ɞɜɭɯ ɥɟɨɩɚɪɞɨɜ ɩɨ ɤɨɥɢɱɟɫɬɜɭ ɩɹɬɟɧ. ɂɧɫɬɪɭɦɟɧɬɵ ɢ ɦɟɬɨɞɵ ɦɨɝɭɬ ɤɚɡɚɬɶɫɹ ɩɨɞɯɨɞɹɳɢɦɢ ɞɥɹ ɜɵɩɨɥɧɟɧɢɹ ɪɚɛɨɬɵ, ɧɨ ɨɧɢ ɫɥɢɲɤɨɦ ɝɪɭɛɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɫɞɟɥɚɬɶ ɟɟ ɩɪɚɜɢɥɶɧɨ. Ɉɛɴɟɤɬɵ C++ ɩɪɟɞɧɚɡɧɚɱɟɧɵ ɞɥɹ ɫɨɤɪɵɬɢɹ ɞɚɧɧɵɯ (ɜɨɡɦɨɠɧɨ, ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɣ ɩɪɢɧɰɢɩ ɜ ɪɚɡɪɚɛɨɬɤɟ ɩɪɨɝɪɚɦɦɧɨɝɨ ɨɛɟɫɩɟɱɟɧɢɹ; ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 11). Ɉɛɴɟɤɬɵ ɫɤɪɵɜɚɸɬ ɞɚɧɧɵɟ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 41) ɢ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɬɨɱɧɵɟ ɚɛɫɬɪɚɤɰɢɢ ɞɥɹ ɤɨɩɢɪɨɜɚɧɢɹ ɷɬɢɯ ɞɚɧɧɵɯ ɩɨɫɪɟɞɫɬɜɨɦ ɤɨɧɫɬɪɭɤɬɨɪɨɜ ɢ ɨɩɟɪɚɬɨɪɨɜ ɩɪɢɫɜɚɢɜɚɧɢɹ (ɫɦ. ɪɟɤɨɦɟɧɞɚɰɢɢ ɫ 52 ɩɨ 55). ɉɪɨɣɬɢɫɶ ɩɨ ɧɢɦ ɝɪɭɛɵɦ ɢɧɫɬɪɭɦɟɧɬɨɦ ɬɢɩɚ memcpy — ɫɟɪɶɟɡɧɨɟ ɧɚɪɭɲɟɧɢɟ ɩɪɢɧɰɢɩɚ ɫɨɤɪɵɬɢɹ ɢɧɮɨɪɦɚɰɢɢ, ɤɨɬɨɪɨɟ ɡɚɱɚɫɬɭɸ ɩɪɢɜɨɞɢɬ ɤ ɭɬɟɱɤɚɦ ɩɚɦɹɬɢ ɢ ɪɟɫɭɪɫɨɜ (ɜ ɥɭɱɲɟɦ ɫɥɭɱɚɟ), ɚɜɚɪɢɣɧɨɦɭ ɡɚɜɟɪɲɟɧɢɸ ɩɪɨɝɪɚɦɦɵ (ɜ ɫɥɭɱɚɟ ɩɨɯɭɠɟ) ɢɥɢ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ (ɜ ɫɚɦɨɦ ɯɭɞɲɟɦ ɫɥɭɱɚɟ). ɇɚɩɪɢɦɟɪ: {

// ǜǹDzǯǫǰǷ ǯǭǫ int ǭ ǺǫǷȊǽdz shared_ptr p1( new int ), p2( new int ); memcpy (&p1, &p2, sizeof (p1)); // ǝǫǵ ǯǰǶǫǽȇ ǸǰǶȇDzȊ!!!

} // ǞǽǰȂǵǫ ǺǫǷȊǽdz: p2 ǸdzǵǹǮǯǫ Ǹǰ ǾǯǫǶȊǰǽǼȊ // ǚǹǭǻǰDZǯǰǸdzǰ ǺǫǷȊǽdz: p1 ǾǯǫǶȊǰǽǼȊ ǯǭǫDZǯȆ

ɇɟɜɟɪɧɨɟ ɩɪɢɦɟɧɟɧɢɟ 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

Стр. 198

Безопасность типов

98. Не используйте неизвестные аргументы (троеточия) Резюме ɇɚɥɢɱɢɟ ɬɪɨɟɬɨɱɢɣ ɜ C++ — ɨɩɚɫɧɨɟ ɧɚɫɥɟɞɢɟ C. ɂɡɛɟɝɚɣɬɟ ɢɯ ɜ ɫɜɨɢɯ ɩɪɨɝɪɚɦɦɚɯ; ɢɫɩɨɥɶɡɭɣɬɟ ɜɦɟɫɬɨ ɷɬɨɝɨ ɜɵɫɨɤɨɭɪɨɜɧɟɜɵɟ ɤɨɧɫɬɪɭɤɰɢɢ ɢ ɛɢɛɥɢɨɬɟɤɢ C++.

Обсуждение Ɏɭɧɤɰɢɢ ɫ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ ɞɨɫɬɚɬɨɱɧɨ ɭɞɨɛɧɵ, ɨɞɧɚɤɨ ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɧɟɢɡɜɟɫɬɧɵɯ ɚɪɝɭɦɟɧɬɨɜ ɜ ɫɬɢɥɟ C — ɧɟ ɥɭɱɲɢɣ ɫɩɨɫɨɛ ɩɨɥɭɱɟɧɢɹ ɬɚɤɢɯ ɮɭɧɤɰɢɣ. ɗɬɢ ɚɪɝɭɦɟɧɬɵ ɢɦɟɸɬ ɦɧɨɝɨ ɫɟɪɶɟɡɧɵɯ ɧɟɞɨɫɬɚɬɤɨɜ. •

•

•

•

ɇɟɞɨɫɬɚɬɨɱɧɚɹ ɛɟɡɨɩɚɫɧɨɫɬɶ ɬɢɩɨɜ. ɉɨ ɫɭɬɢ, ɬɪɨɟɬɨɱɢɟ ɝɨɜɨɪɢɬ ɤɨɦɩɢɥɹɬɨɪɭ: “ȼɵɤɥɸɱɢ ɜɫɟ ɩɪɨɜɟɪɤɢ. ɋ ɷɬɨɝɨ ɦɨɦɟɧɬɚ ɹ ɜɫɟ ɛɟɪɭ ɧɚ ɫɟɛɹ, ɢ ɬɟɩɟɪɶ ɧɚɱɢɧɚɟɬ ɪɚɛɨɬɚɬɶ reinterpret_cast”. (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 92). ɋɢɥɶɧɨɟ ɫɜɹɡɵɜɚɧɢɟ ɢ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɫɨɝɥɚɫɨɜɚɧɢɹ ɜɵɡɵɜɚɟɦɨɝɨ ɢ ɜɵɡɵɜɚɸɳɟɝɨ ɤɨɞɚ ɜɪɭɱɧɭɸ. ɉɪɨɜɟɪɤɚ ɬɢɩɨɜ ɹɡɵɤɨɦ ɨɤɚɡɵɜɚɟɬɫɹ ɨɬɤɥɸɱɟɧɚ, ɬɚɤ ɱɬɨ ɜɵɡɵɜɚɸɳɢɣ ɤɨɞ ɞɨɥɠɟɧ ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɧɵɟ ɫɩɨɫɨɛɵ ɞɥɹ ɫɨɨɛɳɟɧɢɹ ɨ ɬɢɩɚɯ ɩɟɪɟɞɚɜɚɟɦɵɯ ɚɪɝɭɦɟɧɬɨɜ. Ɍɚɤɢɟ ɩɪɨɬɨɤɨɥɵ (ɧɚɩɪɢɦɟɪ, ɮɨɪɦɚɬɧɚɹ ɫɬɪɨɤɚ printf) ɩɨɞɜɟɪɠɟɧɵ ɨɲɢɛɤɚɦ ɢ ɧɟɛɟɡɨɩɚɫɧɵ, ɩɨɫɤɨɥɶɤɭ ɧɟ ɦɨɝɭɬ ɛɵɬɶ ɩɨɥɧɨɫɬɶɸ ɩɪɨɜɟɪɟɧɵ ɧɢ ɜɵɡɵɜɚɸɳɢɦ, ɧɢ ɜɵɡɵɜɚɟɦɵɦ ɤɨɞɨɦ. (ɋɦ. ɪɟɤɨɦɟɧɞɚɰɢɸ 99.) ɇɟɨɩɪɟɞɟɥɟɧɧɨɟ ɩɨɜɟɞɟɧɢɟ ɞɥɹ ɨɛɴɟɤɬɨɜ ɬɢɩɨɜ, ɹɜɥɹɸɳɢɯɫɹ ɤɥɚɫɫɚɦɢ. ɉɟɪɟɞɚɱɚ ɱɟɝɨ ɛɵ ɬɨ ɧɢ ɛɵɥɨ ɤɪɨɦɟ POD ɢ ɩɪɢɦɢɬɢɜɧɵɯ ɬɢɩɨɜ ɜɦɟɫɬɨ ɬɪɨɟɬɨɱɢɣ ɩɪɢɜɨɞɢɬ ɤ ɧɟɨɩɪɟɞɟɥɟɧɧɨɦɭ ɩɨɜɟɞɟɧɢɸ ɜ C++. Ʉ ɫɨɠɚɥɟɧɢɸ, ɛɨɥɶɲɢɧɫɬɜɨ ɤɨɦɩɢɥɹɬɨɪɨɜ ɞɚɠɟ ɧɟ ɩɪɟɞɭɩɪɟɠɞɚɟɬ ɨɛ ɷɬɨɦ. ɇɟɢɡɜɟɫɬɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɚɪɝɭɦɟɧɬɨɜ. Ⱦɚɠɟ ɜ ɫɥɭɱɚɟ ɩɪɨɫɬɟɣɲɢɯ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ (ɧɚɩɪɢɦɟɪ, min) ɜɚɦ ɜɫɟ ɪɚɜɧɨ ɬɪɟɛɭɟɬɫɹ ɩɪɨɬɨɤɨɥ, ɩɨɡɜɨɥɹɸɳɢɣ ɭɤɚɡɚɬɶ ɤɨɥɢɱɟɫɬɜɨ ɩɟɪɟɞɚɜɚɟɦɵɯ ɚɪɝɭɦɟɧɬɨɜ. (Ʉɚɤ ɧɢ ɫɦɟɲɧɨ, ɧɨ ɷɬɨ, ɩɨɠɚɥɭɣ, ɯɨɪɨɲɟɟ ɫɜɨɣɫɬɜɨ, ɩɨɫɤɨɥɶɤɭ ɹɜɥɹɟɬɫɹ ɟɳɟ ɨɞɧɢɦ ɩɪɟɩɹɬɫɬɜɢɟɦ ɲɢɪɨɤɨɦɭ ɪɚɫɩɪɨɫɬɪɚɧɟɧɢɸ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧɧɵɦ ɱɢɫɥɨɦ ɚɪɝɭɦɟɧɬɨɜ.)

ɂɡɛɟɝɚɣɬɟ ɬɪɨɟɬɨɱɢɣ ɜ ɫɢɝɧɚɬɭɪɚɯ ɜɚɲɢɯ ɮɭɧɤɰɢɣ. ɂɡɛɟɝɚɣɬɟ ɜɵɡɨɜɚ ɮɭɧɤɰɢɣ ɫ ɩɟɪɟɦɟɧɧɵɦ ɤɨɥɢɱɟɫɬɜɨɦ ɚɪɝɭɦɟɧɬɨɜ ɫɨ ɫɜɨɢɦɢ ɫɨɛɫɬɜɟɧɧɵɦɢ ɫɢɝɧɚɬɭɪɚɦɢ, ɞɚɠɟ ɟɫɥɢ ɷɬɨ ɜɩɨɥɧɟ ɤɨɪɪɟɤɬɧɵɟ ɮɭɧɤɰɢɢ ɢɡ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ C, ɬɚɤɢɟ ɤɚɤ sprintf. ȼɵɡɨɜɵ sprintf ɱɚɫɬɨ ɜɵɝɥɹɞɹɬ ɛɨɥɟɟ ɤɨɦɩɚɤɬɧɵɦɢ ɢ ɩɪɨɫɬɵɦɢ ɞɥɹ ɩɨɧɢɦɚɧɢɹ, ɱɟɦ ɷɤɜɢɜɚɥɟɧɬɧɵɟ ɜɵɡɨɜɵ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɮɨɪɦɚɬɢɪɨɜɚɧɢɹ stringstream ɢ ɨɩɟɪɚɬɨɪɨɜ operator