An Introduction to Design Patterns in C++ with Qt 4 - Softcover

Ezust, Alan

Softcover

ISBN 10: 0131879057 ISBN 13: 9780131879058

Publisher: Prentice Hall, 2006

Synopsis

Learn C++, Patterns, and Qt 4 Cross-Platform Development

Master C++ and design patterns together, using the world's leading open source framework for cross-platform development: Qt 4.

An Introduction to Design Patterns in C++ with Qt 4 is a complete tutorial and reference that assumes no previous knowledge of C, C++, objects, or patterns. You'll walk through every core concept, one step at a time, learning through an extensive collection of Qt 4.1-tested examples and exercises.

By the time you're done, you'll be creating multithreaded GUI applications that access databases and manipulate XML files--applications that run on platforms including Windows, Linux, Unix, and Mac OS X. Best of all, you'll be writing code that's efficient, reusable, and elegant.

• Learn objects fast: classes, inheritance, polymorphism, and more
• Master powerful design patterns
• Discover efficient high-level programming techniques using libraries, generics, and containers
• Build graphical applications using Qt widgets, models, and views
• Learn advanced techniques ranging from multithreading to reflective programming
• Use Qt's built-in classes for accessing MySQL data
• Includes a complete C++ language reference

About this title

About the Author:

<>Alan Ezust received his M.Sc in Computer Science from McGill, and has delivered courses on object oriented programming and APIs for over 15 years. He is an instructor and courseware developer at ics.com, leading provider of Trolltech-certified Qt training and services throughout North America.

Paul Ezust chairs Suffolk University's Department of Mathematics and Computer Science, and has taught computer science for nearly thirty years. He has done extensive consulting and contract programming.

Excerpt. © Reprinted by permission. All rights reserved.:

C++ had been in use for many years before it was standardized in 1989, which makes it a relatively mature language compared to others that are in popular use today. It is a very important language for building fast, efficient, mission-critical systems. C++ is also one of the most flexible languages around, giving developers many choices of programming styles for use in high-level GUI code as well as low-level device drivers.

For a few years in the early '90s, C++ was the most popular object-oriented (OO) language in use, and many computer science (CS) students were introduced to object-oriented programming (OOP) via C++. This was because C++ provided a relatively easy transition to OOP for C programmers, and many CS professors had been teaching C previously.

Starting around 1996, Java gained favor over C++ as the first OO language for students to learn. There are a number of reasons that Java gained so much popularity.

• The language itself is simpler than C++.
• The language has built-in garbage collection, so programmers do not need to concern themselves with memory de-allocation.
• A standard set of GUI classes is included in the development kit.
• The built-in String class supports Unicode.
• Multithreading is built into the language.
• It is easier to build and "plug in" Java Archives (JARs) than it is to recompile and relink libraries.
• Many Web servers provide Java APIs for easy integration.
• Java programs are platform independent (Wintel, Solaris, MacOS, Linux, *nix, etc.).

Many of Java's benefits listed above can be achieved with C++ used in conjunction with Qt 4.

Qt provides a comprehensive set of GUI classes that run faster, look better, and are more flexible than Java's Swing classes.Signals and slots are easier to use than (ActionEventKey)Listener interfaces in Java.

Qt 4 has a plugin architecture that makes it possible to load code into an application without recompiling or relinking.Qt 4 provides foreach, which makes iteration through collections simpler to read and write.

Although Qt does not provide garbage collection, there are a variety of alternatives one can use to avoid the need to delete heap objects directly.

1. Containers (see Section 10.2)
2. Parents and children (see Section 9.2)
3. auto_ptr (see Section 16.3.2)
4. QPointer (see Section 19.9).
5. Subobjects (see Section 2.8)
6. Stack objects (see Section 20.3)

Using C++ with Qt comes very close to Java in ease of use, comprehensiveness, and convenience. It significantly exceeds Java in the areas of speed and efficiency, making everything from processing-intensive server applications to high-speed graphics-intensive games possible.

Another benefit of learning C++ with Qt comes from Qt's widespread use in open-source projects. There is already a great wealth of free open-source code that you can learn from, reuse, and perhaps help to improve.

How to Use This Book

Part I contains an introduction to C++, UML, and the Qt core. This part is designed to avoid forward referencing as much as possible, and it presents the topics in an order and a level of detail that should not overwhelm someone who is new to C/C++.

In Part II, you will find higher-level programming ideas, Qt modules, and design patterns. Here we present paradigm-shifting ways of writing code and organizing objects in a modular fashion.

For completeness and for reference, Part III covers in more depth some of the "dry" but important C++ features that were introduced in Part I. By the time the reader has reached this point, these ideas should be a lot easier to understand.At the end of each chapter, you will find exercises and review questions. Most of the programming exercises have solutions available on our Web site. For the questions, if the answers are not in the preceding chapter, then often there are pointers on where to find them. If this book is used for a course, these questions could be asked by the student or by the teacher, in the classroom or on an exam.

Source code files for all the examples in this book are contained in the file src.tar.gz, which can be downloaded from http://oop.mcs.suffolk.edu/dist.

A Note about Formats and Book Production

What you are reading now is only one of a number of possible versions of this text available. Because the document was originally written in XML, using a "literal programming" style, we can generate a variety of different versions (bulleted slides, paragraphed textbook, with or without solutions, etc.) in a variety of different formats (html, pdf, ps, htmlhelp).

Each programming example is extracted from working source code. The Web version provides a hyperlink from each code excerpt to its full source file. This makes it very easy to try the examples yourself. The text and listings in the Web version also contain hyperlinks from each library ClassName to its class documentation page.

We wrote the original manuscript using jEdit and gnu-emacs, marking it up with a modified DocBook/XML syntax that we converted into pure DocBook/XML using a custom XML processor called Slacker's DocBook written in Python. Most of the original diagrams were produced with Umbrello or Dia, but a couple were produced with Doxygen and Dot. The final book was typeset in QuarkXPress. We generate many different versions (overhead slides, textbooks, labs, and solutions) of this text for our own use, some in HTML, some in PostScript, and some in PDF.The XML and image processors we used were Apache Ant, Xerces, FOP, Gnu xsltproc, ReportLab pyRXP, ImageMagick, JAI, JINI, and XEP. We did all of the editing and processing of the original manuscript on GNU/Linux systems under KDE. The example programs all compile and run under Linux.

The cover photo is of the Panama Canal. Before there was a Panama Canal, ships had to travel down and then up the entire length of South America to get from one coast of the United States to the other. The canal provided a much shorter and more direct path. The aim of this book is to provide a shorter and more direct path for programmers who don't have a lot of extra time and who need to obtain working mastery of C++ OOP and design patterns. Qt 4 makes this possible.

Style Conventions

Monospace--used for any literal symbol that appears in the code listings

Bold--used the first time a term appears (key terms, defined terms, etc.)

Italic--used for emphasis, and also used for wildcards (terms that need to be replaced by "real types" when they are actually used). In monospace text, these terms are set italic and monospace.

About this edition

• Publisher: Prentice Hall
• Publication date: 2006
• ISBN 10: 0131879057
• ISBN 13: 9780131879058
• Binding: Paperback
• Edition number: 1
• Number of pages: 656