An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens' Open Source Series) / Edition 1

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $17.96
Usually ships in 1-2 business days
(Save 67%)
Other sellers (Paperback)
  • All (15) from $17.96   
  • New (8) from $24.99   
  • Used (7) from $17.96   

Overview

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: 9780131879058
  • Publisher: Prentice Hall
  • Publication date: 9/14/2006
  • Series: Bruce Perens' Open Source Series
  • Edition description: Older Edition
  • Edition number: 1
  • Pages: 656
  • Product dimensions: 7.00 (w) x 9.10 (h) x 1.40 (d)

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

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

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

Preface xix

Acknowledgments xxiii

Rationale for the Book xxv

About the Authors xxvii

PART I: Introduction to C++ and Qt 4 2

Chapter 1: C++ Introduction 5

1.1 Overview of C++ 6

1.2 A Brief History of C++ 6

1.3 Setup: Open-Source Platforms 7

1.4 Setup: Win32 12

1.5 C++ First Example 12

1.6 Input and Output 16

1.7 Identifiers, Types, and Literals 19

1.8 C++ Simple Types 22

1.9 C++ Standard Library Strings 30

1.10 Streams 31

1.11 The Keyword const 34

1.12 Pointers and Memory Access 36

1.13 const* and *const 40

1.14 Reference Variables 43

Points of Departure 44

Review Questions 45

Chapter 2: Classes 47

2.1 Structs 48

2.2 Class Definitions 49

2.3 Member Access Specifiers 51

2.4 Encapsulation 54

2.5 Introduction to UML 54

2.5.1 UML Relationships 55

2.6 Friends of a Class 55

2.7 Constructors 56

2.8 Subobjects 58

2.9 Destructors 60

2.10 The Keyword static 61

2.11 Copy Constructors and Assignment Operators 64

2.12 Conversions 67

2.13 const Member Functions 68

Review Questions 79

Chapter 3: Introduction to Qt 81

3.1 Example Project: Using QApplication and QLabel 82

3.2 Makefile, qmake, and Project Files 83

3.3 Getting Help Online 89

3.4 Style Guidelines and Naming Conventions 90

3.5 The Qt Core Module 91

3.6 Streams and Dates 91

Points of Departure 93

Review Questions 94

Chapter 4: Lists 95

4.1 Introduction to Containers 96

4.2 Iterators 97

4.3 Relationships 99

Points of Departure 102

Review Questions 103

Chapter 5: Functions 105

5.1 Function Declarations 106

5.2 Overloading Functions 107

5.3 Optional Arguments 109

5.4 Operator Overloading 111

5.5 Parameter Passing by Value 116

5.6 Parameter Passing by Reference 118

5.7 References to const 121

5.8 Function Return Values 122

5.9 Returning References from Functions 122

5.10 Overloading on const-ness 124

5.11 Inline Functions 126

5.12 Inlining versus Macro Expansion 127

Review Questions 133

Chapter 6: Inheritance and Polymorphism 135

6.1 Simple Derivation 136

6.2 Derivation with Polymorphism 142

6.3 Derivation from an Abstract Base Class 148

6.4 Inheritance Design 152

6.5 Overloading, Hiding, and Overriding 154

6.6 Constructors, Destructors, and Copy Assignment Operators 155

6.7 Processing Command-Line Arguments 158

Points of Departure 164

Review Questions 165

PART II: Higher-Level Programming 166

Chapter 7: Libraries 169

7.1 Code Containers 170

7.2 Reusing Other Libraries 171

7.3 Organizing Libraries: Dependency Management 173

7.4 Installing Libraries: A Lab Exercise 176

7.5 Frameworks and Components 178

Review Questions 180

Chapter 8: Introduction to Design Patterns 181

8.1 Iteration and the Visitor Pattern 182

Review Questions 190

Chapter 9: QObject 191

9.1 QObject's Child Managment 194

9.2 Composite Pattern: Parents and Children 196

9.3 QApplication and the Event Loop 200

9.4 Q_OBJECT and moc: A Checklist 209

9.5 Values and Objects 210

9.6 tr() and Internationalization 211

Point of Departure 211

Review Questions 212

Chapter 10: Generics and Containers 213

10.1 Generics and Templates 214

10.2 Containers 219

10.3 Managed Containers, Composites, and Aggregates 221

10.4 Implicitly Shared Classes 224

10.5 Generics, Algorithms, and Operators 225

10.6 Serializer Pattern 227

10.7 Sorted Map Example 229

Review Questions 235

Chapter 11: Qt GUI Widgets 237

11.1 Widget Categories 239

11.2 QMainWindow and QSettings 240

11.3 Dialogs 244

11.4 Images and Resources 248

11.5 Layout of Widgets 251

11.6 QActions, QMenus, and QMenuBars 260

11.7 QActions, QToolbars, and QActionGroups 262

11.8 Regions and QDockWidgets 270

11.9 Views of a QStringList 272

Points of Departure 274

Review Questions 275

Chapter 12: Concurrency 277

12.1 QProcess and Process Control 278

12.2 Threads and QThread 290

12.3 Summary: QProcess and QThread 303

Review Questions 305

Chapter 13: Validation and Regular Expressions 307

13.1 Validators 308

13.2 Regular Expressions 310

13.3 Regular Expression Validation 316

Review Questions 319

Chapter 14: Parsing XML 321

14.1 The Qt XML Module 325

14.2 Event-Driven Parsing 325

14.3 XML, Tree Structures, and DOM 329

Review Questions 340

Chapter 15: Meta Objects, Properties, and Reflective Programming 341

15.1 Anti-patterns 342

15.2 QMetaObject: The MetaObject Pattern 344

15.3 Type Identification and qobject_cast 345

15.4 Q_PROPERTY Macro: Describing QObject Properties 347

15.5 QVariant Class: Accessing Properties 350

15.6 DataObject: An Extension of QObject 353

15.7 Property Containers: PropsMap 355

Review Questions 357

Chapter 16: More Design Patterns 359

16.1 Creational Patterns 360

16.2 Serializer Pattern Revisited 373

16.3 The Facade Pattern 381

Points of Departure 389

Review Questions 390

Chapter 17: Models and Views 391

17.1 M-V-C: What about the Controller? 392

17.2 Dynamic Form Models 393

17.3 Qt 4 Models and Views 409

17.4 Table Models 411

17.5 Tree Models 417

Review Questions 421

Chapter 18: Qt SQL Classes 423

18.1 Introduction to MySQL 424

18.2 Queries and Result Sets 427

18.3 Database Models 429

Review Questions 433

PART III: C++ Language Reference 434

Chapter 19: Types and Expressions 437

19.1 Operators 438

19.2 Evaluation of Logical Expressions 443

19.3 Enumerations 443

19.4 Signed and Unsigned Integral Types 445

19.5 Standard Expression Conversions 447

19.6 Explicit Conversions 449

19.7 Safer Typecasting Using ANSI C++ Typecasts 450

19.8 Run-Time Type Identification (RTTI) 454

19.9 Member Selection Operators 457

Point of Departure 458

Review Questions 461

Chapter 20: Scope and Storage Class 463

20.1 Declarations and Definitions 464

20.2 Identifier Scope 465

20.3 Storage Class 470

20.4 Namespaces 473

Review Questions 478

Chapter 21: Statements and Control Structures 479

21.1 Statements 480

21.2 Selection Statements 480

21.3 Iteration 483

21.4 Exceptions 485

Review Questions 502

Chapter 22: Memory Access 503

22.1 Pointer Pathology 504

22.2 Further Pointer Pathology with Heap Memory 506

22.3 Memory Access Summary 509

22.4 Introduction to Arrays 509

22.5 Pointer Arithmetic 510

22.6 Arrays, Functions, and Return Values 511

22.7 Different Kinds of Arrays 513

22.8 Valid Pointer Operations 513

22.9 What Happens If new Fails? 515

22.10 Chapter Summary 519

Review Questions 521

Chapter 23: Inheritance in Detail 523

23.1 Virtual Pointers and Virtual Tables 524

23.2 Polymorphism and virtual Destructors 526

23.3 Multiple Inheritance 528

Point of Departure 532

23.4 public, protected, and private Derivation 536

Review Questions 539

Chapter 24: Miscellaneous Topics 541

24.1 Functions with Variable-Length Argument Lists 542

24.2 Resource Sharing 543

PART IV: Programming Assignments 548

Chapter 25: MP3 Jukebox Assignments 551

25.1 Data Model: Mp3File 553

25.2 Visitor: Generating Playlists 555

25.3 Preference: An Enumerated Type 556

25.4 Reusing id3lib 559

25.5 PlayListModel Serialization 560

25.6 Testing Mp3File Related Classes 561

25.7 Simple Queries and Filters 561

25.8 Mp3PlayerView 563

25.9 Models and Views: PlayList 565

25.10 Source Selector 566

25.11 Persistent Settings 567

25.12 Edit Form View for FileTagger 568

25.13 Database View 569

Points of Departure 571

PART V: Appendices 572

Appendix A: C++ Reserved Keywords 575

Appendix B: Standard Headers 577

Appendix C: The Development Environment 579

Bibliography 601

Index 603

Read More Show Less

Preface

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.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com 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 & Noble.com 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 & Noble.com 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 BN.com 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

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com 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 BN.com. 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

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