Skip to content
VUBuddy
CS304

CS304 Highlighted Handouts Set 3

Object Oriented Programming PDF 5.7 MBUpdated 23 Oct 2026
Download free Open CS304 course
Highlighted handout CS304 Highlighted Handouts Set 3 PDF 5.7 MB
vubuddy.com
Type
Highlighted handout
Course
CS304 Object Oriented Programming
Size
PDF 5.7 MB
Updated
23 Oct 2026
Free download 0 of 3 used today
Download free · 5.7 MB

You get 3 free files a day on the website. Add the Chrome extension for 30 a day.

Unlimited downloads in the Android app Get it free on Google Play

Preview text

Text from pages 2, 3, 4 of 203. Download the file for all 203 pages.

  1. 1. STREAM INSERTION OPERATOR ........................................................................................ 158
  2. 2. STREAM EXTRACTION OPERATOR ..................................................................................... 158
  3. 3. OVERLOADING STREAM INSERTION OPERATOR ............................................................ 159
  4. 4. OVERLOADING STREAM EXTRACTION OPERATOR.......................................................... 160
  5. 5. OTHER BINARY OPERATORS .............................................................................................. 161
  6. 1. SUBSCRIPT [] OPERATOR .....................................................................................................164
  7. 2. OVERLOADING SUBSCRIPT [] OPERATOR ........................................................................ 164
  8. 3. OVERLOADING FUNCTION () OPERATOR .......................................................................... 165
  9. 4. FUNCTION OPERATOR PERFORMING SUB STRING OPERATION, .................................... 165
  10. 5. UNARY OPERATORS ........................................................................................................... 166
  11. 1. BEHAVIOR OF ++ AND -- FOR PRE-DEFINED TYPES ............................................................ 168
  12. 2. POST-INCREMENT OPERATOR ............................................................................................ 169
  13. 3. TYPE CONVERSION ............................................................................................................. 170
  14. 4. USER DEFINED TYPES ..........................................................................................................173
  15. 5. DRAWBACKS OF TYPE CONVERSION OPERATOR.............................................................. 174
  16. 1. PRACTICAL IMPLEMENTATION OF INHERITANCE IN C++ ................................................ 175
  17. 2. INHERITANCE IN CLASSES ................................................................................................. 175
  18. 3. UML NOTATION ............................................................................................................................................ 175
  19. 4. INHERITANCE IN C++ ......................................................................................................... 175
  20. 5. “IS A” RELATIONSHIP .................................................................................................................................. 176
  21. 1. ACCESSING BASE CLASS MEMBER FUNCTIONS IN DERIVED CLASS ................................ 183
  22. 2. “PROTECTED” ACCESS SPECIFIER .............................................................................................................. 185
  23. 3. “IS A” RELATIONSHIP .................................................................................................................................. 186
  24. 4. STATIC TYPE ....................................................................................................................... 189
  25. 1. MODIFIED DEFAULT CONSTRUCTOR ............................................................................... 199
  26. 1. OVERLOADING VS. OVERRIDING ...................................................................................... 207
  27. 2. HIERARCHY OF INHERITANCE ............................................................................................ 211
  28. 1. BASE INITIALIZATION ......................................................................................................... 213
  29. 2. TYPES OF INHERITANCE ..................................................................................................... 214
  30. 3. PRIVATE INHERITANCE ...................................................................................................... 216
  31. 1. SPECIALIZATION (RESTRICTION) .......................................................................................218
  32. 2. PROTECTED INHERITANCE ................................................................................................. 222
  33. 3. PROPERTIES OF PROTECTED INHERITANCE ....................................................................... 223
  34. 1. VIRTUAL FUNCTIONS ......................................................................................................... 225
  35. 2. VIRTUAL FUNCTIONS .......................................................................................................... 230
  36. 3. SHAPE HIERARCHY ............................................................................................................ 230
  37. 4. STATIC VS DYNAMIC BINDING ......................................................................................... 231
  38. 1. ABSTRACT CLASSES ............................................................................................................ 233
  39. 2. CONCRETE CLASSES ........................................................................................................... 234
  40. 3. ABSTRACT CLASSES IN C++ ............................................................................................... 234
  41. 4. PURE VIRTUAL FUNCTIONS ............................................................................................... 234
  42. 5. SHAPE HIERARCHY .............................................................................................................235
  43. 6. VIRTUAL DESTRUCTORS .................................................................................................... 236
  44. 7. VIRTUAL FUNCTIONS – USAGE ........................................................................................... 238
  45. 8. V TABLE ............................................................................................................................................................... 240
  46. 9. DYNAMIC DISPATCH (DYNAMIC BINDING) .....................................................................242
  47. 1. POLYMORPHISM – CASE STUDY: A SIMPLE PAYROLL APPLICATION .............................. 243
  48. 2. SHAPE HIERARCHY REVISITED ........................................................................................... 246
  49. 1. MULTIPLE INHERITANCE .................................................................................................... 250
  50. 2. PROBLEMS IN MULTIPLE INHERITANCE ........................................................................... 251
  51. 3. VIRTUAL INHERITANCE ...................................................................................................... 256
  52. 1. GENERIC PROGRAMMING .................................................................................................. 259
  53. 2. TEMPLATES .......................................................................................................................... 259
  54. 3. FUNCTION TEMPLATES .......................................................................................................260
  55. 1. MULTIPLE TYPE ARGUMENTS ............................................................................................ 264
  56. 2. USER-DEFINED TYPES ......................................................................................................... 264
  57. 3. OVERLOADING VS. TEMPLATES ........................................................................................ 265
  58. 4. TEMPLATE ARGUMENTS AS POLICY ...................................................................................266
  59. 5. FIRST SOLUTION................................................................................................................... 267
  60. 6. SECOND SOLUTION ............................................................................................................. 267
  61. 7. THIRD SOLUTION................................................................................................................ 268
  62. 8. DEFAULT POLICY ................................................................................................................. 269
  63. 1. GENERIC ALGORITHMS ...................................................................................................... 270
  64. 2. CLASS TEMPLATES .............................................................................................................. 272
  65. 3. EXAMPLE – CLASS TEMPLATE ............................................................................................ 273
  66. 1. MEMBER TEMPLATES .......................................................................................................... 276
  67. 2. CLASS TEMPLATE SPECIALIZATION .................................................................................. 278
  68. 1. MEMBER TEMPLATES REVISITED ...................................................................................... 282
  69. 2. PARTIAL SPECIALIZATION ................................................................................................. 283
  70. 3. FUNCTION TEMPLATES .......................................................................................................284
  71. 4. COMPLETE SPECIALIZATION ............................................................................................. 285
  72. 5. USING DIFFERENT SPECIALIZATIONS .............................................................................. 286
  73. 6. NON-TYPE PARAMETERS .................................................................................................... 286
  74. 7. EXAMPLE – TEMPLATE CLASS ARRAY ................................................................................. 286
  75. 8. DEFAULT NON-TYPE PARAMETERS.................................................................................... 288
  76. 9. DEFAULT TYPE PARAMETERS ............................................................................................ 288
  77. 1. RESOLUTION ORDER .......................................................................................................... 289
  78. 2. FUNCTION TEMPLATE OVERLOADING ..............................................................................290
  79. 3. RESOLUTION ORDER .......................................................................................................... 291
  80. 4. TEMPLATES AND INHERITANCE ........................................................................................ 291
  81. 5. DERIVATIONS IN CASE OF A GENERAL TEMPLATE CLASS ............................................... 291
  82. 1. TEMPLATES AND FRIENDS ................................................................................................. 296
  83. 2. TEMPLATES AND FRIENDS – RULE 1 ................................................................................. 296
  84. 3. TEMPLATES AND FRIENDS – RULE 2 ................................................................................. 297
  85. 4. TEMPLATES AND FRIENDS – RULE 3 ................................................................................. 299
  86. 5. TEMPLATES AND FRIENDS – RULE 4 ................................................................................. 301
  87. 1. TEMPLATES & STATIC MEMBERS....................................................................................... 303
  88. 2. TEMPLATES – CONCLUSION ............................................................................................... 304
  89. 3. GENERIC ALGORITHMS REVISITED .................................................................................. 305
  90. 4. GENERIC ALGORITHMS REVISITED .................................................................................. 306
  91. 5. GENERIC ALGORITHM ....................................................................................................... 308
  92. 6. PROBLEMS ............................................................................................................................ 308
  93. 1. CURSORS ............................................................................................................................. 309
  94. 2. ITERATORS .......................................................................................................................... 312
  95. 1. STANDARD TEMPLATE LIBRARY ........................................................................................ 316
  96. 2. STL CONTAINERS ............................................................................................................... 316
  97. 3. COMMON FUNCTIONS FOR ALL CONTAINERS ................................................................ 322
  98. 4. FUNCTIONS FOR FIRST-CLASS CONTAINERS .................................................................... 322
  99. 5. CONTAINER REQUIREMENTS.............................................................................................. 323
  100. 1. ITERATORS .......................................................................................................................... 325
  101. 2. ITERATOR CATEGORIES ..................................................................................................... 325
  102. 3. ITERATOR SUMMARY ......................................................................................................... 325
  103. 4. CONTAINER AND ITERATOR TYPES ................................................................................... 326
  104. 5. SEQUENCE CONTAINERS .................................................................................................... 326
  105. 6. ASSOCIATIVE CONTAINERS ............................................................................................... 327
  106. 7. CONTAINER ADAPTERS ...................................................................................................... 327
  107. 8. ITERATOR OPERATIONS ..................................................................................................... 327
  108. 9. ALGORITHMS ..................................................................................................................... 331
  109. 1. EXAMPLE – ABNORMAL TERMINATION ............................................................................ 334
  110. 2. GRACEFUL TERMINATION .................................................................................................. 335
  111. 3. ERROR HANDLING .............................................................................................................. 335
  112. 4. EXCEPTION HANDLING ...................................................................................................... 338
  113. 5. EXCEPTION HANDLING PROCESS ...................................................................................... 338
  114. 1. STACK UNWINDING ............................................................................................................342
  115. 1. RESOURCE MANAGEMENT ................................................................................................. 349

Related CS304 files

All CS304 files →
CS304 Object Oriented Programming All CS304 handouts, past papers, quizzes and MCQs in one place. Open course page

Get more out of VUBuddy, for free

Android app Free on Google Play
  • Unlimited downloads
  • The explanation behind every MCQ answer
  • Study offline on slow data
Get the Android app
Chrome extension Free on the Chrome Web Store
  • 30 downloads a day instead of 3
  • Sign in and buy Pro Semester here
Add to Chrome

One Pro Semester membership works in both the extension and the app.