ISВN 966-0000-00-0 2 страница
11.1.3. Недоліки структурного програмування.............................. 229
11.1.4. Неконтрольований доступ до даних................................... 229
11.1.5. Відображення картини реального світу.............................. 230
11.2. Поняття про об'єктно-орієнтований підхід........................ 231
11.2.1. Виробнича аналогія............................................................... 232
11.2.2. ООП – спосіб ефективної організації програми................ 233
11.3. Основні компоненти об'єктно-орієнтованої мови програмування............................................................................. 233
11.3.1. Поділ програми на об'єкти................................................... 233
11.3.2. Визначення класу.................................................................. 234
11.3.3. Поняття про успадкування в класах.................................... 234
11.3.4. Повторне використання коду.............................................. 235
11.3.5. Поняття про типи даних користувача................................. 236
11.3.6. Поняття про поліморфізм і перевантаження операторів... 236
11.4. Співвідношення між мовами програмування C і С++.... 236
11.5. Вивчення основ створення об'єктно-орієнтованих програм........................................................................................... 237
11.6. Поняття про універсальну мову моделювання................. 237
Розділ 12. Введення в класи..................................... 239
12.1. Базові поняття класу................................................................. 239
12.2. Конструктори і деструктори.................................................... 243
12.2.1. Параметризовані конструктори........................................... 246
12.2.2. Альтернативний варіант ініціалізації членів-даних об'єкта................................................................................................... 249
12.3. Доступ до членів класу............................................................. 250
12.4. Класи і структури – споріднені типи.................................... 252
12.5. Об'єднання і класи – споріднені типи.................................. 254
12.6. Вбудовувані функції.................................................................. 255
12.7. Створення масивів об'єктів..................................................... 258
12.8. Покажчики на об'єкти............................................................... 261
Розділ 13. Робота з класами..................................... 263
13.1. Поняття про функції-"друзі" класу...................................... 263
13.2. Перевантаження конструкторів............................................. 267
13.3. Динамічна ініціалізація конструктора................................ 268
13.4. Присвоєння об'єктів................................................................... 270
13.5. Передача об'єктів функціям.................................................... 271
13.5.1. Конструктори, деструктори і передача об'єктів................. 272
13.5.2. Потенційні проблеми під час передачі параметрів............ 273
13.6. Повернення об'єктів функціями............................................ 276
13.7. Створення і використання конструктора копії................ 278
13.7.1. Використання конструктора копії для ініціалізації одного об'єкта іншим........................................................................... 279
13.7.2. Використання конструктора копії для передачі об'єкта функції...................................................................................... 281
13.7.3. Використання конструктора копії під час повернення функцією об'єкта..................................................................... 282
13.7.4. Конструктори копії – а чи не можна знайти щось простіше?................................................................................................... 283
13.8. Ключове слово this.................................................................. 284
Розділ 14. Перевантаження операторів............ 285
14.1. Перевантаження операторів з використанням функцій-членів класу.................................................................................. 285
14.1.2. Використання функцій-членів класу для перевантаження бінарних операторів................................................................ 285
14.1.2. Використання функцій-членів класу для перевантаження унарних операторів................................................................. 288
14.1.3. Поради з реалізації механізму перевантаження операторів................................................................................................... 293
14.1.4. Значення порядку слідування операндів............................ 294
14.2. Перевантаження операторів з використанням функцій-не членів класу.................................................................................. 294
14.2.1. Використання функцій-"друзів" класу для перевантаження бінарних операторів................................................................ 295
14.2.2. Використання функцій-"друзів" для перевантаження унарних операторів................................................................. 299
14.2.3. Перевантаження операторів відношення та логічних операторів................................................................................ 302
14.3. Особливості реалізації оператора присвоєння.................. 303
14.4. Перевантаження оператора індексації масивів ([])....... 306
14.5. Перевантаження оператора "()"........................................... 309
14.6. Перевантаження інших операторів....................................... 310
14.6.1. Приклад перевантаження операторів класу рядків........... 310
Розділ 15. Успадкування в класах...................... 315
15.1. Поняття про успадкування...................................................... 315
15.2. Керування доступом до членів базового класу................ 318
15.3. Використання захищених членів класу.............................. 320
15.3.1. Використання специфікатора доступу protected для надання членам класу статусу захищеності......................... 320
15.3.2. Використання специфікатора protected для успадкування базового класу................................................ 324
15.3.3. Узагальнення інформації про використання специфікаторів public, protected і private....................................... 325
15.4. Успадкування декількох базових класів........................... 326
15.5. Використання конструкторів і деструкторів під час реалізації механізму успадкування...................................... 326
15.5.1. Прядок виконання конструкторів і деструкторів.............. 327
15.5.2. Передача параметрів конструкторам базового класу........ 329
15.6. Повернення успадкованим членам початкової специфікації доступу................................................................. 333
15.7. Віртуальні базові класи............................................................ 335
15.8. Читання С++-графів успадкування...................................... 338
Розділ 16. Віртуальні функції та поліморфізм...................................................................................... 339
16.1. Покажчики на похідні типи – підтримка динамічного поліморфізму................................................................................ 339
16.2. Віртуальні функції...................................................................... 341
16.2.1. Поняття про віртуальні функції........................................... 342
16.2.2. Успадкування віртуальних функцій.................................... 344
16.2.3. Потреба у застосуванні віртуальних функцій.................... 346
16.2.4. Приклад застосування віртуальних функцій...................... 347
16.2.5. Суто віртуальні функції та абстрактні класи...................... 349
16.2.6. Порівняння раннього зв'язування з пізнім.......................... 351
16.2.7. Поняття про поліморфізм і пуризм...................................... 352
Розділ 17. Шаблони в класах................................... 353
17.1. Поняття про узагальнені функції.......................................... 353
17.1.1. Шаблонна функція з одним узагальненим типом.............. 354
17.1.2. Шаблонна функція з двома узагальненими типами.......... 355
17.1.3. Безпосередньо задане перевантаження узагальненої функції................................................................................................... 356
17.1.4. Перевантаження шаблону функції...................................... 358
17.1.5. Використання стандартних параметрів у шаблонних функціях................................................................................... 358
17.1.6. Обмеження, які застосовуються під час використання узагальнених функцій............................................................ 359
17.1.7. Приклад створення узагальненої функції abs()............. 360
17.2. Узагальнені класи...................................................................... 360
17.2.1. Створення класу з одним узагальненим типом даних...... 361
17.2.2. Створення класу з двома узагальненими типами даних... 363
17.2.3. Створення узагальненого класу для організації безпечного масиву...................................................................................... 364
17.2.4. Використання в узагальнених класах аргументів, що не є типами...................................................................................... 365
17.2.5. Використання в шаблонних класах аргументів за замовчуванням........................................................................ 366
17.2.6. Безпосередньо задані спеціалізації класів........................... 368
Розділ 18. Оброблення виняткових ситуацій...................................................................................... 370
18.1. Основи оброблення виняткових ситуацій.......................... 370
18.1.1. Системні засоби оброблення винятків................................ 370
18.1.3. Перехоплення винятків класового типу............................. 375
18.1.4. Використання декількох catch-настанов......................... 376
18.2. Варіанти оброблення винятків............................................... 377
18.2.1. Перехоплення всіх винятків................................................. 377
18.2.2. Обмеження, що накладаються на тип винятків, які генеруються функціями.......................................................... 379
18.2.3. Повторне генерування винятку........................................... 380
18.3. Оброблення винятків, згенерованих оператором new.... 381
18.4. Перевантаження операторів new і delete......................... 383
Розділ 19. С++-система введення-виведення потокової інформації................................... 388
19.1. Порівняння C- та С++-систем введення-виведення........ 388
19.2. Потоки у мові програмування C++....................................... 388
19.2.1. Файлові С++-потоки............................................................. 389
19.2.2. Вбудовані С++-потоки.......................................................... 389
19.2.3. Класи потоків......................................................................... 390
19.3. Перевантаження операторів введення-виведення даних........................................................................................................... 391
19.3.1. Створення перевантажених операторів виведення даних 391
19.3.2. Використання функцій-"друзів" для перевантаження операторів виведення даних.................................................. 393
19.3.3. Створення перевантажених операторів введення даних.. 394
19.3.4. Порівняння С- і С++-систем введення-виведення............. 396
19.4. Форматоване введення-виведення даних........................... 397
19.4.1. Форматування даних з використанням функцій-членів класу ios................................................................................. 397
19.4.2. Встановлення ширини поля, точності та символів заповнення............................................................................... 400
19.4.3. Використання маніпуляторів введення-виведення даних 401
19.4.4. Створення власних маніпуляторних функцій.................... 403
19.5. Файлове введення-виведення даних.................................... 405
19.5.1. Відкриття та закриття файлу................................................ 405
19.5.2. Зчитування і запис текстових файлів.................................. 407
19.5.3. Неформатоване введення-виведення даних у двійковому режимі...................................................................................... 408
19.5.4. Зчитування і запис у файл блоків даних............................. 410
19.5.5. Виявлення кінця файлу......................................................... 411
19.5.6. Приклад порівняння файлів................................................. 412
19.5.7. Використання інших функцій для двійкового введення-виведення................................................................................. 413
19.5.8. Перевірка статусу введення-виведення.............................. 415
19.6. Використання файлів довільного доступу......................... 416
19.6.1. Функції довільного доступу................................................. 416
19.6.2. Приклади використання довільного доступу до вмісту файлу........................................................................................ 417
19.7. Використання перевантажених операторів введення-виведення даних під час роботи з файлами....................... 418
Розділ 20. Динамічна ідентифікація типів і оператори приведення типу..................... 420
20.1. Динамічна ідентифікація типів (RTTI)............................... 420
20.1.1. Отримання типу об'єкта у процесі виконання програми. 420
20.1.2. Приклад RTTI-застосування................................................. 424
20.1.3. Застосування оператора typeid до шаблонних класів... 425
20.2. Оператори приведення типів.................................................. 428
20.2.1. Оператор приведення поліморфних типів dynamic_cast................................................................................................... 428
20.2.2. Оператор перевизначення модифікаторів const_cast 433
20.2.3. Оператор неполіморфного приведення типів static_cast....................................................................... 434
20.2.4. Оператор перетворення типу reinterpret_cast...... 434
20.2.5. Порівняння звичайної операції приведення типів з новими чотирма cast-операторами.................................................. 435
Розділ 21. Поняття про простори імен та інші ефективні програмні засоби.................... 436
21.1. Простори імен............................................................................... 436
21.1.1. Поняття про простори імен.................................................. 436
21.1.2. Застосування настанови using.......................................... 439
21.1.3. Неіменовані простори імен.................................................. 441
21.1.4. Застосування простіру імен std......................................... 442
21.2. Застосування покажчиків на функції.................................. 443
21.2.1. Передача покажчиком на функцію її адреси іншій функції................................................................................................... 445
21.2.2. Пошук адреси перевантаженої функції............................... 446
21.3. Поняття про статичні члени-даних класу.......................... 448
21.5. Застосування до функцій-членів класу модифікаторів const і mutable.......................................................................... 449
21.6. Використання explicit-конструкторів............................ 451
21.7. Синтаксис ініціалізації членів-даних класу..................... 453
21.8. Використання ключового слова asm................................... 455
21.9. Специфікатор компонування функцій................................ 456
21.10. Оператори вказання на члени класу ".*" і "->"............. 456
21.11. Створення функцій перетворення....................................... 458
Розділ 22. Введення в стандартну бібліотеку шаблонів............................................................... 461
22.1. Огляд стандартної бібліотеки шаблонів............................. 461
22.2. Поняття про контейнерні класи............................................. 464
22.3. Робота з векторами..................................................................... 465
22.3.1. Доступ до вектора за допомогою ітератора........................ 468
22.3.2. Вставлення та видалення елементів з вектора................... 469
22.3.3. Збереження у векторі об'єктів класу.................................... 470
22.3.4. Доцільність використання ітераторів.................................. 472
22.4. Робота зі списками..................................................................... 473
22.4.1. Використання базових операцій для роботи зі списком... 474
22.4.2. Сортування списку................................................................ 477
22.4.3. Об'єднання одного списку з іншим..................................... 478
22.4.4. Зберігання у списку об'єктів класу...................................... 479
22.5. Поняття про відображення....................................................... 481
22.5.1. Робота з відображеннями...................................................... 482
22.5.2. Зберігання у відображенні об'єктів класу........................... 484
22.6. Алгоритми оброблення контейнерних даних.................... 485
22.6.1. Підрахунок кількості елементів........................................... 487
22.6.2. Видалення і заміна елементів............................................... 489
22.6.3. Реверсування послідовності................................................. 490
22.6.4. Перетворення послідовності................................................ 491
22.6.5. Дослідження алгоритмів....................................................... 492
22.7. Використання класу string.................................................. 492
22.7.1. Огляд функцій-членів класу string................................. 495
22.7.2. Зберігання рядків у інших контейнерах.............................. 499
Розділ 23. Особливості роботи препроцесора С++............................................................................... 500
23.1. Поняття про директиви препроцесора C++........................ 500
23.1.1. Директива #define............................................................ 500
23.1.2. Директива #error.................................................................... 503
23.1.3. Директива #include.......................................................... 503
23.2. Директиви умовного компілювання.................................... 504
23.2.1. Директиви #if, #else, #elif і #endif............................. 504
23.2.2. Директиви #ifdef і #ifndef........................................... 506
23.2.3. Директива #undef............................................................... 507
23.2.4. Використання оператора defined.................................... 507
23.2.5. Про значення препроцесора................................................. 507
23.2.6. Директива #line.................................................................. 508
23.2.7. Директива #pragma............................................................. 508
23.3. Оператори препроцесора "#" і "##"...................................... 509
23.4. Зарезервовані макроімена....................................................... 509
23.5. Деякі поради студентам............................................................ 510
Розділ 24. Формалізація процесу розроблення об'єктно-орієнтованого програмного забезпечення...................................................... 511
24.1. Удосконалення процесу розроблення програмного забезпечення................................................................................. 511
24.1.1. Безпосередній процес розроблення ПЗ............................... 511
24.1.2. Каскадний процес розроблення ПЗ..................................... 511
24.1.3. Використання ООП.............................................................. 512
24.1.4. Сучасні підходи до розроблення ПЗ.................................... 512
24.2. Моделювання варіантів використання............................... 513
24.2.1. Поняття про діючі суб'єкти.................................................. 513
24.2.2. Поняття про варіанти використання................................... 514
24.2.3. Поняття про сценарії............................................................. 514
24.2.4. Застосування діаграм варіантів використання................... 514
24.2.5. Описи варіантів використання............................................ 515
24.2.6. Перехід від варіантів використання до класів.................... 515
24.3. Предметна область програмування...................................... 516
24.3.1. Рукописні форми................................................................... 516
24.3.2. Прийняття допущень і спрощень......................................... 518
24.4. Програма landlord: етап удосконалення........................ 518
24.4.1. Встановлення діючих суб'єктів............................................ 518
24.4.2. З'ясування варіантів використання..................................... 519
24.4.3. Опис варіантів використання.............................................. 519
24.4.4. Передбачення додаткових сценаріїв................................... 520
24.4.5. Використання діаграм дій UML.......................................... 521
24.5. Перехід від варіантів використання до класів.................. 522
24.5.1. Аналіз переліку іменників з опису варіантів використання................................................................................................... 522
24.5.2. Уточнення переліку іменників............................................. 522
24.5.3. Визначення атрибутів........................................................... 523
24.5.4. Перехід від дієслів до повідомлень...................................... 523
24.5.5. Побудова діаграм класів....................................................... 524
24.5.6. Побудова діаграм послідовностей....................................... 525
24.6. Кроки написання коду програми.......................................... 527
24.6.1. Написання заголовного файлу............................................. 528
24.6.2. Створення початкових *.срр файлів................................ 532
24.6.3. Вимушені спрощення коду програми................................. 540
24.6.4. Взаємодія користувача з програмою................................... 540
24.6.5. Труднощі написання коду програми................................... 542
24.7. Резюме............................................................................................. 542
Додатки. Доповнення до С++......................... 543
Додаток А. Основи створення консольних програм у середовищі Borland C++ Builder.................................................................... 544
А.1. Основні правила роботи у середовищі C++ Builder.......... 544
А.1.1. Підготовка панелей інструментів......................................... 544
А.1.2. Утримання на екрані вікна з результатами роботи програми................................................................................................... 545
А.1.3. Створення нового консольного проекту............................. 545
А.1.4. Надання імені консольному проекту та збереження його. 546
А.1.5. Робота з наявними файлами консольних програм............. 546
А.2. Компілювання, зв'язування і запуск консольних програм на виконання................................................................................ 547
А.2.1. Запуск консольної програми в середовищі C++ Builder.... 547
А.2.2. Запуск програми в MS DOS.................................................. 547
А.2.3. Заздалегідь скомпільовані заголовні файли......................... 547
А.2.4. Закриття і відкриття консольних проектів.......................... 547
А.3. Додавання заголовного файлу до консольного проекту 547
А.3.1. Створення нового заголовного файлу................................. 548
А.3.2. Редагування заголовного файлу........................................... 548
А.3.3. Визначення місцезнаходження заголовного файлу............ 548
А.4. Проекти з декількома початковими файлами................... 548
А.4.1. Створення додаткових початкових файлів......................... 548
А.4.2. Додавання наявних початкових файлів............................... 549
А.4.3. Застосування менеджера проектів........................................ 549
А.4.4. Програми з консольною графікою....................................... 549
А.5. Відлагодження коду програми................................................. 550
А.5.1. Покроковий прогін коду програми...................................... 550
А.5.2. Перегляд змінних коду програми......................................... 550
А.5.3. Покрокове трасування функцій............................................ 550
А.5.4. Точки зупинки........................................................................ 550
Додаток Б. Основи створення консольних програм у середовищі Microsoft Visual C++............................................................................... 552
Б.1. Елементи вікна середовища MVC++...................................... 552
Б.2. Робота з однофайловими консольними програмами....... 552
Б.2.1. Компонування наявного файлу............................................. 552
Б.2.2. Створення нового файлу........................................................ 553
Б.2.3. Виправлення помилок............................................................ 553
Б.2.4. Інформація про типи в процесі виконання (RTTI).............. 554
Б.3. Робота з багатофайловими консольними програмами... 554
Б.3.1. Поняття про проекти і робочі області................................... 554
Б.3.2. Робота над проектом............................................................... 554
Б.3.3. Збереження, закриття і відкриття проектів........................... 555
Б.3.4. Компілювання і компонування............................................. 555
Б.4. Програми з консольною графікою......................................... 555
Б.5. Відлагодження програм.............................................................. 556
Б.5.1. Покрокове трасування............................................................ 556
Б.5.2. Перегляд значень змінних...................................................... 556
Б.5.3. Покрокове трасування функцій............................................. 557
Б.5.4. Використання точок зупинки роботи програми................. 557
Додаток В. Дещо про С-систему введення-виведення............................................................. 558
В.1. Використання потоків у С-системі введення-виведення 558
В.2. Функції консольного введення-виведення даних............. 559
В.2.1. Використання функції printf()....................................... 559
В.2.2. Використання функції scanf()......................................... 561
В.3. С-система оброблення файлів.................................................. 564
В.3.1. Використання функції fopen()......................................... 565
В.3.2. Використання функції fputc()......................................... 566
В.3.3. Використання функції fgetc()......................................... 566
В.3.4. Використання функції feof()............................................ 567