C++PROG 712: C++ Programming: Intermediate

C++ is only a language, and one with a rather small vocabulary as compared with spoken languages. This course intends to take you beyond fluency in C++.

As a language, C++ enables (and sometimes hinders) the expression of ideas. Understanding its support for the object-oriented paradigm is essential for truly expressing ideas. The process of creating and expressing are not always separable. When designing for a C++ implementation you must understand fully how things will translate to actual code; having a strong understanding of this helps you to be a better designer.

Course Description

C++ Programming: Intermediate is the second course of a three -course sequence designed to teach the C++ language and to guide you in understanding and applying object-oriented design principles. Each course builds upon what you have learned in the previous one by introducing new concepts and developing existing ones to a greater depth. This hands-on class introduces object-oriented design as a powerful new approach to programming. You are encouraged to develop and practice good software design methodologies using the C++ language.

The course jumps right into object-oriented design as we study models, modeling, and tools to design and document dynamic object behavior in software systems. We will follow by investigating commonly-overlooked basic features of the language, to round out much of your knowledge on C++ constructs and language features. We move right into the study of major language features such as templates and exceptions. The remainder of the course will examine inheritance in depth, and will present several common design patterns to illustrate the power and elegance of the C++ language.

Course Goals and Objectives

Recognizing good designs is the first step in developing the often intuitive "taste" that is essential in making design decisions. When you complete this course, there will be no continents in C++ that you have not charted. Sure, there will always be remote reaches and things for which you'll have to use a reference—but the gist of the language and its potential will be fully revealed and understood. You will have seen beyond the goal of fluency to a more important goal—the ability to easily absorb new concepts in C++ and object-oriented design.

By the end of this course, you should be able to

• distinguish good designs and make educated design decisions;
• read and understand advanced C++ texts;
• approach design texts (which are more challenging);
• make good use of such reference books as Design Patterns: Elements of Reusable Object-Oriented Software; and
• understand and apply most documented design patterns without needing a tutorial.

Required Textbooks

• Bruce Eckel, Thinking in C++, 2nd ed. (Upper Saddle River, NJ: Prentice Hall, 2000-2004).
  ISBN: 0139798099
  
  Scott Meyers, Effective C++: 55 Specific Ways to Improve Your Programs and Designs, 3rd ed. (Upper Saddle River, NJ: Addison-Wesley, 2005).
  ISBN: 0321334876

  
  Gamma, Erich, Richard Helm, John Vlissides, Ralph Johnson.Design Patterns: Elements of Reusable Object Oriented Software. Addison Wesley Longman, Inc., 1995 ISBN 0201633612

Recommended References

• The C++ Programming Language (3rd or Special Edition) by Bjarne Stroustrup. Note that either the 1997 edition or the 2000 edition of Stroustrup's book is fine; the difference between the two is that the 2000 edition has an additional chapter and some appendices, and is hardback (and more expensive).
• Deitel, Harvey, and Paul Deitel. C++ : How to Program. 2nd Ed. Upper Saddle River, NJ: Prentice Hall, 1998. ISBN: 0130895717. This book has a good index, and covers C++ topics comprehensively. This is a good second text to have to look up beginners' syntax questions.
• Lee, Richard C. and Tepfenhart, William M., UML and C++: A Practical Guide to Object-Oriented Development, 2nd ed. Prentice Hall, 2001. ISBN: 0130290408. A reference that covers the UML will be useful as we study models, modeling, and tools to design and document dynamic object behavior of software systems.
• Lippman, Stanley and Josée Lajoie. C++ Primer. 3rd Ed. NY: Addison Wesley, 1998. ISBN: 0201824701.

Suggested Reading

There are a few books that are very highly suggested for the course, and for your general knowledge. You'll find complete bibliographic information in the Course Bibliography.

• The Object Primer by Scott Ambler covers the entire Object-Oriented Process from start to finish. It is development-process neutral, and devotes time to discussing RUP, XP and others. The Object Primer stands out as one of the few highly-accessible books that covers object-oriented software development as a whole without prescribing to special methodologies and tools. It forces readers to truly cast away the structural or procedural influences on their design and think in terms of objects. This book is very highly recommended as a means for learning what object-orientation is all about, extending your vocabulary in that domain, and honing your design instincts.
• Pattern Hatching: Design Patterns Applied by John Vlissides provides an extensive and comprehensible case study on the application of design patterns. Rather than didactically walking through examples, the author takes the reader through the thought process behind deciding which design pattern to use in a given situation. This short and concise book will deepen your understanding of design patterns, with excellent examples and honest debates.
• UML Distilled by Martin Fowler and Kendall Scott provides a terse, yet easy-to-understand reference to the UML standard, as well as coverage of development processes, analysis patterns, and other contributions to the software development process.
• Bringing Design to Software by Terry Winograd (a professor of Software Design at Stanford) is a collection of interviews, essays, and profiles contributed by many prominent people in the field of design, such as David Kelley (founder of IDEO). You are thoroughly encouraged to take a look at this book, as it provides a unique perspective on software design. This book views design as a generic art, and reaches to design fields outside of the domain of software to shed new insights on design.

You'll find many other books of interest in the bibliography for this course.

Course Prerequisites

To enroll in this course you must have taken C++: Introduction or its equivalent. From that course you will have gained familiarity with the UML and with object-oriented concepts, as well as a complete understanding of the basic C++ language syntax and good programming style, both of which are invaluable in continuing on to C++: Intermediate.

You will also need a compiler that can handle (to at least some degree) modern C++ so you can write and test standard C++ code. A list of recommended compilers and tools for achieving this is provided in Appendix 2.

A UML authoring tool will also be required. There are a variety of free and commercial UML authoring tools available, or tools that you can use to express UML diagrams, including Microsoft Visio, Microsoft Office Excel, Rational Rose, Eclipse, Netbeans, or ArgoUML.

Course Organization

The course is divided into five lessons; each of these includes a varying number of parts, but all have roughly the same density of information. Each part is also divided into sections.

• Lesson One covers how to model dynamic object behavior with the UML, and how and when to use sequence, collaboration, activity and state UML diagrams.
• Lesson Two describes commonly overlooked features of standard C++, including elements of the standard C++ library.
• Lesson Three covers major language features that are more likely to affect design profoundly, including exceptions and templates.
• Lesson Four delves into inheritance, and provides a deep and thorough understanding of inheritance capabilities and flaws in C++.
• Lesson Five examines the dynamic lifetime of objects in detail, illustrating techniques and guidelines for safely and effectively managing the lifetime of objects.

Projects and Assignments

There are five assignments in the course, one after each lesson. A completed assignment includes a code listing, a copy of the output, and annotated test cases and their results.

The first programming assignment includes instruction and details about how to use an automated testing framework. There are many advantages to automated testing: tests are repeatable, are documented, you can control what tests are run. You'll learn how to create test functions, and how to code tests to verify that your objects and functions behave the way you expect. You can run these tests over and over again, quickly and easily. You might even consider writing the test cases for the functions before you have even implemented the functions!

All submitted assignments and projects (or portions thereof) that require implementation should include documentation in the form of a UML class diagram if more than one class is used, as well as your complete source code. Submitting a conceptual class diagram is recommended if your design introduces many new concepts.

Tips for Success

As you work on the assignments, get small parts of the assignment fully functional in stages. Do not leave all functionality until the end, hoping that everything will come together and fall into place at the end (it won't!). Get a little bit working, then a little bit more, then a little more, until it all works.

I recommend that you create a separate directory for each assignment, and copy any files from previous assignments if they are needed by the current assignment. This way you can always return to a previous known state of your work. A version control system, if you have one, will allow you to do the same thing.

Assignment Submission Guidelines

Submit each assignment using the "Upload a file" feature found at the end of each assignment page. Follow these directions:

• Upload a .zip file that has been compressed using one of the common utilities for creating ZIP format files: PKZIP or WinZip for DOS/Windows, or gzip, tar or jar for Unix.
• The .zip file must contain all files specified as part of the assignment, as well as anything else you think I may need to compile your code (RES, BMP). The required files will usually consist of one or more source code files. Include test results as text files. Do not include executable files or files generated by integrated development environments (EXE, OBJ, CLW, PDB, NCB, OPT, PLG, or SBR files).
• Name the .zip file using the following convention: your last name, followed by the two-digit assignment number, followed by a dot, followed by the zip extension. So, a zipfile from me containing my first assignment would be contained in a file named "Reynolds01.zip".

Evaluation and Feedback

Software development is known to be iterative and incremental. For this reason—and to promote a more conducive learning environment—you may submit deliverables repeatedly until they reach a level of satisfactory completion. There will also be no grades outside of satisfactory completion (SC) and unsatisfactory completion (USC). The instructor's feedback will always provide more useful and more extensive information than a number or letter grade, so you will always receive feedback—not just a grade of SC or USC—on your deliverables. Remember that the volume of feedback you receive may have no correlation to the quality of your deliverable; in many cases, there can be just as much to say about a good design as about a bad one.

Going "above and beyond" in one assignment does not make up for an unsatisfactory completion on another. To complete the course, you must complete each assignment satisfactorily.

There is no final exam for this course.

About the Course Developer

Bruce Reynolds is an Independent Software Consultant with diverse knowledge in both practical and theoretical aspects of software. Reynolds has updated and extended these materials to keep up with changes in the C++ language and changes to the design of the C++ certificate program. Bruce has spent more than 30 years in industry, using object-oriented techniques to develop reliable and maintainable software systems. He is particularly interested in using and improving the tools and techniques necessary to implement software that will be used in life-critical environments.