Introduction to Design Patterns in C++ with Qt / Edition 2

Hardcover (Print)
Buy New
Buy New from
Used and New from Other Sellers
Used and New from Other Sellers
from $37.32
Usually ships in 1-2 business days
(Save 37%)
Other sellers (Hardcover)
  • All (15) from $37.32   
  • New (10) from $37.32   
  • Used (5) from $38.24   


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
Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
Using Qt 4, developers can build optimized cross-platform applications that target Windows, Macintosh, and Linux from a single C++ code base. That's a remarkable promise. But the effectiveness and performance of your applications depends on how you create them. Fortunately, best-practice design patterns exist. This book delivers them.

Alan and Paul Ezust assume minimal upfront experience, so you can use this book whether you're new to Qt 4, to C++, or to design patterns. They show you how to make the most of language and platform features like classes, lists, and functions. They present style guidelines and naming conventions your entire programming team can adopt. Best of all, they introduce higher-level modular programming techniques for serious production development: QObject, generics, containers, GUI widgets, concurrency, and more. From validation to XML, serialization to models and views, it's here: all you need to do cross-platform Qt development right. Bill Camarda, from the December 2006 Read Only

Read More Show Less

Product Details

  • ISBN-13: 9780132826457
  • Publisher: Prentice Hall
  • Publication date: 9/30/2011
  • Series: Prentice Hall Open Source Software Development Series
  • Edition description: New Edition
  • Edition number: 2
  • Pages: 768
  • Sales rank: 974,914
  • Product dimensions: 7.20 (w) x 9.30 (h) x 1.70 (d)

Meet the Author

Alan Ezust received his M.Sc in computer science from McGill University in Montreal. He currently works as a Nokia Certifi ed Qt Specialist for ICS (, a company that specializes in delivering training and professional services onQt software. He honed his teaching and courseware development skills at Learnix, and later at Objectivity, where he taught and/or wrote courses in Python, UNIX, C, C++, Java, Perl, Design Patterns, Froglogic Squish, and Object Oriented Databases. He lives in Victoria, BC, Canada.

Paul Ezust (Cambridge, Massachusetts) chaired Suffolk University’s Department of Mathematics and Computer Science for more than 30 years, leading development of computer science curricula based on Association for Computing Machinery guidelines. He has done extensive outside consulting, contract programming, and research in computational mathematics.

Read More Show Less

Read an Excerpt

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 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

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/

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.

Read More Show Less

Table of Contents

Foreword xv

Preface xix

Preface to the Second Edition xxii

Acknowledgments xxv

About the Authors xxx

Part I: Design Patterns and Qt 4 1

Chapter 1: C++ Introduction 3

1.1 Overview of C++ 3

1.2 A Brief History of C++ 4

1.3 C++ First Example 5

1.4 Standard Input and Output 8

1.5 Introduction to Functions 11

1.6 qmake, Project Files, and Makefile 17

1.7 Getting Help Online 24

1.8 Strings 24

1.9 Streams 26

1.10 File Streams 29

1.11 Qt Dialogs for User Input/Output 34

1.12 Identifiers, Types, and Literals 37

1.13 C++ Simple Types 40

1.14 The Keyword const 52

1.15 Pointers and Memory Access 54

1.16 Reference Variables 60

1.17 const* and *const 61

1.18 Review Questions 64

Chapter 2: Top of the class 67

2.1 First, There Was struct 67

2.2 Class Definitions 69

2.3 Member Access Specifiers 71

2.4 Encapsulation 74

2.5 Introduction to UML 75

2.6 Friends of a Class 76

2.7 Constructors 77

2.8 Destructors 80

2.9 The Keyword static 81

2.10 Class Declarations and Definitions 86

2.11 Copy Constructors and Assignment Operators 88

2.12 Conversions 92

2.13 const Member Functions 95

2.14 Subobjects 97

2.15 Exercise: Classes 98

2.16 Review Questions 108

Chapter 3: Introduction to Qt 113

3.1 Style Guidelines, Naming Conventions 114

3.2 The Qt Core Module 116

3.3 QtCreator—An IDE for Qt Programming 119

3.4 Exercises: Introduction to Qt 120

3.5 Review Questions 121

Chapter 4: Lists 122

4.1 Introduction to Containers 122

4.2 Iterators 123

4.3 Relationships 129

4.4 Exercise: Relationships 132

4.5 Review Questions 134

Chapter 5: Functions 135

5.1 Overloading Functions 135

5.2 Optional Arguments 138

5.3 Operator Overloading 141

5.4 Parameter Passing by Value 146

5.5 Parameter Passing by Reference 148

5.6 References to const 152

5.7 Function Return Values 154

5.8 Returning References from Functions 154

5.9 Overloading on const 155

5.10 inline Functions 158

5.11 Functions with Variable-Length Argument Lists 162

5.12 Exercise: Encryption 164

5.13 Review Questions 167

Chapter 6: Inheritance and Polymorphism 168

6.1 Simple Derivation 168

6.2 Derivation with Polymorphism 177

6.3 Derivation from an Abstract Base Class 184

6.4 Inheritance Design 189

6.5 Overloading, Hiding, and Overriding 191

6.6 Constructors, Destructors, and Copy Assignment Operators 193

6.7 Processing Command-Line Arguments 198

6.8 Containers 204

6.9 Managed Containers, Composites, and Aggregates 206

6.10 Containers of Pointers 210

6.11 Review Questions 228

Chapter 7: Libraries and Design Patterns 234

7.1 Building and Reusing Libraries 236

7.2 Exercise: Installing Libraries 244

7.3 Frameworks and Components 247

7.4 Design Patterns 248

7.5 Review Questions 257

Chapter 8: QObject, QApplication, Signals, and Slots 259

8.1 Values and Objects 263

8.2 Composite Pattern: Parents and Children 264

8.3 QApplication and the Event Loop 272

8.4 Q_OBJECT and moc: A checklist 274

8.5 Signals and Slots 275

8.6 QObject Lifecycle 277

8.7 QTestLib 277

8.8 Exercises: QObject, QApplication, Signals, and Slots 282

8.9 Review Questions 282

Chapter 9: Widgets and Designer 283

9.1 Widget Categories 284

9.2 Designer Introduction 286

9.3 Dialogs 290

9.4 Form Layout 292

9.5 Icons, Images, and Resources 295

9.6 Layout of Widgets 298

9.7 Designer Integration with Code 306

9.8 Exercise: Input Forms 313

9.9 The Event Loop: Revisited 314

9.10 Paint Events, Drawing Images 323

9.11 Review Questions 325

Chapter 10: Main Windows and Actions 326

10.1 QActions, QMenus, and QMenuBars 327

10.2 Regions and QDockWidgets 337

10.3 QSettings: Saving and Restoring Application State 339

10.4 Clipboard and Data Transfer Operations 341

10.5 The Command Pattern 343

10.6 tr() and Internationalization 351

10.7 Exercises: Main Windows and Actions 352

10.8 Review Questions 353

Chapter 11: Generics and Containers 355

11.1 Generics and Templates 355

11.2 Generics, Algorithms, and Operators 362

11.3 Sorted Map Example 365

11.4 Function Pointers and Functors 368

11.5 Flyweight Pattern: Implicitly Shared Classes 371

11.6 Exercise: Generics 375

11.7 Review Questions 376

Chapter 12: Meta Objects, Properties, and Reflective Programming 378

12.1 QMetaObject—The MetaObject Pattern 378

12.2 Type Identification and qobject_cast 380

12.3 Q_PROPERTY Macro—Describing QObject Properties 383

12.4 QVariant Class: Accessing Properties 386

12.5 Dynamic Properties 389

12.6 MetaTypes, Declaring, and Registering 394

12.7 invokeMethod() 396

12.8 Exercises: Reflection 397

12.9 Review Questions 397

Chapter 13: Models and Views 399

13.1 Model-View-Controller (MVC) 400

13.2 Qt Models and Views 402

13.3 Table Models 414

13.4 Tree Models 424

13.5 Smarter Pointers 429

13.6 Exercises: Models and Views 431

13.7 Review Questions 433

Chapter 14: Validation and Regular Expressions 434

14.1 Input Masks 435

14.2 Validators 438

14.3 Regular Expressions 440

14.4 Regular Expression Validation 449

14.5 Subclassing QValidator 451

14.6 Exercises: Validation and Regular Expressions 454

14.7 Review Questions 456

Chapter 15: Parsing XML 457

15.1 The Qt XML Parsers 460

15.2 SAX Parsing 462

15.3 XML, Tree Structures, and DOM 466

15.4 XML Streams 476

15.5 Review Questions 479

Chapter 16: More Design Patterns 481

16.1 Creational Patterns 481

16.2 Memento Pattern 491

16.3 Façade Pattern 498

16.4 Review Questions 505

Chapter 17: Concurrency 506

17.1 QProcess and Process Control 506

17.2 QThread and QtConcurrent 522

17.3 Exercises: QThread and QtConcurrent 536

17.4 Review Questions 537

Chapter 18: Database Programming 539

18.1 QSqlDatabase: Connecting to SQL from Qt 541

18.2 Queries and Result Sets 546

18.3 Database Models 548

18.4 Review Questions 549

Part II: C++ Language Reference 550

Chapter 19: Types and Expressions 552

19.1 Operators 553

19.2 Statements and Control Structures 557

19.3 Evaluation of Logical Expressions 564

19.4 Enumerations 565

19.5 Signed and Unsigned Integral Types 567

19.6 Standard Expression Conversions 570

19.7 Explicit Conversions 574

19.8 Safer Typecasting Using ANSI C++ Typecasts 574

19.9 Overloading Special Operators 581

19.10 Runtime Type Identification 587

19.11 Member Selection Operators 590

19.12 Exercises: Types and Expressions 592

19.13 Review Questions 594

Chapter 20: Scope and Storage Class 595

20.1 Declarations and Definitions 595

20.2 Identifier Scope 597

20.3 Storage Class 606

20.4 Namespaces 610

20.5 Review Questions 615

Chapter 21: Memory Access 617

21.1 Pointer Pathology 618

21.2 Further Pointer Pathology with Heap Memory 620

21.3 Memory Access Summary 623

21.4 Introduction to Arrays 624

21.5 Pointer Arithmetic 626

21.6 Arrays, Functions, and Return Values 627

21.7 Different Kinds of Arrays 629

21.8 Valid Pointer Operations 629

21.9 Arrays and Memory: Important Points 632

21.10 Exercises: Memory Access 633

21.11 Review Questions 634

Chapter 22: Inheritance in Detail 635

22.1 virtual Pointers, virtual Tables 635

22.2 Polymorphism and virtual Destructors 638

22.3 Multiple Inheritance 642

22.4 public, protected, and private Derivation 650

22.5 Review Questions 652

Part III: Programming Assignments 653

Chapter 23: MP3 Jukebox Assignments 655

23.1 Phonon/MultiMediaKit Setup 657

23.2 Playlist 657

23.3 Playlists 658

23.4 Source Selector 659

23.5 Database Playlists 661

23.6 Star Delegates 661

23.7 Sorting, Filtering, and Editing Playlists 661

Appendix A: C++ Reserved Keywords 662

Appendix B: Standard Headers 664

Appendix C: Development Tools 666

Appendix D: Alan’s Quick Start Guide to Debian for Programmers 691

Appendix E: C++/Qt Setup 698

Bibliography 706

Index 709

Read More Show Less

Customer Reviews

Average Rating 2.5
( 3 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 3 Customer Reviews
  • Anonymous

    Posted July 26, 2012

    First off the extensive use of [ . . . . ] which appears to mean

    First off the extensive use of [ . . . . ] which appears to mean 'you figure this part out' is annoying, followed by examples that are almost identical to the built-in reference material. The two sections I tried to reference from this book so far ( both of which I can do in QT 3.3) have examples that do not work as illustrated. Accessing a database didn't work until I put 'sql' in the .pro file. I can't get the Model example to work. I have 12 years experience with QT 3.3 so I'm not a novice, but I believe a book called 'Introduction to....' should start at the basic level and build on the basics.

    Was this review helpful? Yes  No   Report this review
  • Posted October 31, 2011

    A must read if you want to learn Qt.

    Alan Ezust has done it again.
    Alan is a great instructor and it shows in this book. He has broken the fairly steep learning curve of Qt and C++ into navigable pieces. I think this is by far the first book that teaches Qt and C++ in depth without leaving the reader to wonder how "this function or this module does what it does."
    After reading this book you will understand Qt with enough understanding to write your own programs without question.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 16, 2013

    No text was provided for this review.

Sort by: Showing all of 3 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)