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

Дата добавления: 2014-11-29