Introduction to Design Patterns in C++ with Qt, 2nd Edition

Description

• Copyright 2012
• Dimensions: 7" x 9-1/8"
• Pages: 768
• Edition: 2nd

• eBook
• ISBN-10: 0-13-285166-0
• ISBN-13: 978-0-13-285166-4

Master C++ “The Qt Way” with Modern Design Patterns and Efficient Reuse

This fully updated, classroom-tested book teaches C++ “The Qt Way,” emphasizing design patterns and efficient reuse. Readers will master both the C++ language and Qt libraries, as they learn to develop maintainable software with well-defined code layers and simple, reusable classes and functions.

Every chapter of this edition has been improved with new content, better organization, or both. Readers will find extensively revised coverage of QObjects, Reflection, Widgets, Main Windows, Models and Views, Databases, Multi-Threaded Programming, and Reflection. This edition introduces the powerful new Qt Creator IDE; presents new multimedia APIs; and offers extended coverage of Qt Designer and C++ Integration. It has been

restructured to help readers start writing software immediately and write robust, effective software sooner.

The authors introduce several new design patterns, add many quiz questions and labs, and present more efficient solutions relying on new Qt features and best practices. They also provide an up-to-date C++ reference section and a complete application case study.

• Master C++ keywords, literals, identifiers, declarations, types, and type conversions.
• Understand classes and objects, organize them, and describe their interrelationships.
• Learn consistent programming style and naming rules.
• Use lists, functions, and other essential techniques.
• Define inheritance relationships to share code and promote reuse.
• Learn how code libraries are designed, built, and reused.
• Work with QObject, the base class underlying much of Qt.
• Build graphical user interfaces with Qt widgets.
• Use templates to write generic functions and classes.
• Master advanced reflective programming techniques.
• Use the Model-View framework to cleanly separate data and GUI classes.
• Validate input using regular expressions and other techniques.
• Parse XML data with SAX, DOM, and QXmlStreamReader.
• Master today’s most valuable creational and structural design patterns.
• Create, use, monitor, and debug processes and threads.
• Access databases with Qt’s SQL classes.
• Manage memory reliably and efficiently.
• Understand how to effectively manage QThreads and use QtConcurrent algorithms.

Click here to obtain supplementary materials for this book.



Sample Content

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



Updates

Submit Errata

