Index

Index
	Introduction to Design Patterns in C++ with Qt 4

Symbols

#ifndef wrapper, The Preprocessor: For #including Files

#include , The Preprocessor: For #including Files

preprocessor directive , C++ First Example

%

modulus operator , Arithmetic

%=

operator , Arithmetic

&

address-of operator, The Unary Operators & and *
as a type modifier , Reference Variables

()

function call operator, Returning References from Functions
function-call operator , The Function-Call operator()

*

as a type modifier, The Unary Operators & and * , Pointer Pathology
dereference operator, The Unary Operators & and * , Pointer Pathology
multiplication operator , Arithmetic

*=

operator , Arithmetic

*nix, C++/Qt Setup: Open Source Platforms

+

addition operator , Arithmetic
binary operator with pointers , Valid Pointer Operations

++

on pointers, Pointer Arithmetic
unary increment operator , Arithmetic

+=

binary increment operator , Arithmetic

-

subtraction operator , Arithmetic

--

unary decrement operator , Arithmetic

-=

binary decrement operator , Arithmetic

->

member selection operator, Member Selection operators

-ansi

compiler switch, C++ First Example

-pedantic

compiler switch, C++ First Example

-Wall

compiler switch, C++ First Example

/

division operator , Arithmetic

/* ... */

comment delimiters, C++ First Example

//

single line comment , C++ First Example

/=

operator , Arithmetic

::

scope operator, File Scope versus Block Scope and operator::
scope resolution operator , Class definitions

<

less than operator , Arithmetic

<<

insertion operator, Input and Output , Returning References from Functions
overloaded output operator , Conversion Operators

=

copy assignment operator, Constructors, Destructors, and Copy Assignment Operators
on pointers, Valid Pointer Operations

>

greater than operator , Arithmetic

>>

input operator, Input and Output

? %

conditional operator , Arithmetic

[]

array subscript operator , Vectors and operator[] , Introduction to Arrays , Valid Pointer Operations
array type modifier , Introduction to Arrays
index operator , Returning References from Functions

“/“

file separator, Type Identification and qobject_cast

A

a.out

executable, C++ First Example

abstract

base class, Derivation from an Abstract Base Class

abstract base class, Derivation from an Abstract Base Class

abstract factories, Abstract Factories and Libraries

abstract factory, Creational Patterns

Abstract Factory pattern, Creational Patterns , Importing Objects with an Abstract Factory

access specifier

public, private, protected, Member Access Specifiers

accessibility, Member Access Specifiers

action, QActions, QMenus, and QMenuBars

Adaptor pattern, FileTagger: Façade Example

address-of operator (&), The Unary Operators & and *

aggregate container, Managed Containers, Composites and Aggregates

aggregation, UML Relationships , Managed Containers, Composites and Aggregates

relationship, Relationships

Amarok

KDE jukebox program, Queries and Result Sets

animation, QPixmap and QThread Animation Example: Movie Player

ANSI typecasts, Safer Typecasting using ANSI C++ typecasts

ANSI/ISO Draft Standard, A Brief History of C++

anti-pattern, Anti-patterns

API, Frameworks and Components

apt-get

build-dep, C++/Qt Setup: Open Source Platforms , The apt system

argc, main, and Command Line Arguments

ArgumentList, Derivation and ArgumentList

argv, main, and Command Line Arguments

Arithmetic , Arithmetic

overloading operators , Operator Overloading
with pointers, Pointer Arithmetic

array, main, and Command Line Arguments , Introduction to Arrays

arrays

and argv[] , main, and Command Line Arguments
and function return values , Arrays, Functions, and Return Values
avoiding them in Qt, Processing Command-Line Arguments

Arrays

avoiding them in Qt, Introduction to Containers, The Façade Pattern

assignable data type, Containers

assignment operator, Copy Constructors and Assignment Operators

association

relationship , Relationships

associative container, Containers

asynchronous, Signals and Slots

AT&T Bell Labs, A Brief History of C++

auto, Storage Class

auto_ptr, Smart Pointers: auto_ptr

example , FileTagger: Façade Example
guarded pointers, Member Selection operators

B

bad_alloc, What happens if new fails?

base class, Simple Derivation

bash

*nix shell , C++/Qt Setup: Open Source Platforms

Behavioral patterns, Introduction to Design patterns

bind

values to a prepared statement , Connecting to MySQL from Qt

block, Statements

compound statement, Statements
scope, Member Access Specifiers , Identifier Scope

block scope

and static, The Keyword static
vs. file scope, File Scope versus Block Scope and operator::

boolalpha

manipulator, Streams

boolean

conditions , Selection Statements
operators , Arithmetic, Evaluation of Logical Expressions

boost, Frameworks and Components

shared_ptr, Operators new and delete
signals and slots, Points of Departure

break

out of loops, Iteration
out of switch, Selection Statements

buttons

QCheckBox , Widget Categories
QPushButton , Widget Categories
QRadioButton , Widget Categories
QToolButton , Widget Categories

C

C++ statement, Statements

cache, Containers

cardinality, Relationships Summary

cards

data structures, Exercises: Managed Containers, Composites and Aggregates
images and pixmaps, Images and Resources

case

label, Selection Statements

cast

c-style , Explicit Conversions
constructor-style, Explicit Conversions

catch, Exception Handling, try and catch

child objects, QObject

cin, Streams and Dates

istream , Streams

circular

dependency , Class Declarations and Defintions

circular dependency, Organizing Libraries: Dependency Management , The Preprocessor: For #including Files

class, Class definitions

declaration , Class Declarations and Defintions , The Preprocessor: For #including Files
definition, Class definitions
scope , Default Scope of Identifiers - A Summary

class scope, Class definitions

client code, Member Access Specifiers

cloning

objects , Values and Objects

cmd

win32 command prompt, C++/Qt Setup: Win32

command line arguments, main, and Command Line Arguments

regular arguments, Processing Command-Line Arguments
switched arguments, Processing Command-Line Arguments
switches , Processing Command-Line Arguments

Command pattern, QActions, QToolbars, and QActionGroups , virtual pointers, virtual tables

with work threads , Long Running Threads and the Command Pattern

comment delimiters, C++ First Example

compile time binding, Derivation with Polymorphism

compile time depencency, Organizing Libraries: Dependency Management

complex numbers, Operator Overloading

Composite pattern, Parents and Children, Tree Models

in XML objects , Memento Pattern
QDomNode, XML, Tree Structures, and DOM

composition, UML Relationships , Subobjects , Managed Containers, Composites and Aggregates

relationship, Relationships

compound statement, Statements

concrete class, Derivation from an Abstract Base Class

conditional statement, Selection Statements

connect, Connecting to slots , Signals and Slots

console

applications , Qt dialogs for user input/output

const

applied to references , References to const
member functions , const Member Functions
on simple types , The Keyword const
overloading, Overloading on const
pointers , const* and *const

constructor, Constructors

default, and inheritance, Constructors, Destructors, and Copy Assignment Operators

constructors

and inheritance, Constructors, Destructors, and Copy Assignment Operators
and polymorphism , Benefits of Using Factories

const_cast, static_cast and const_cast

consumer-producer, Multiple Threads, Queues, and Loggers Example: Giant

container

composite, Managed Containers, Composites and Aggregates
generic, Introduction to Containers
managed, Managed Containers, Composites and Aggregates

container classes

value-based, Exercise: QSet and QMap

container widget

QFrame , Widget Categories
QMainWindow , Widget Categories
QStackedWidget , Widget Categories
QTabWidget , Widget Categories
QToolBar , Widget Categories

context menu, QActions, QMenus, and QMenuBars

continue

to next iteration of loop, Iteration

controller, M-V-C: What about the Controller?

controller class

QAction , Widget Categories
QApplication , Widget Categories

controller classes, M-V-C: What about the Controller?

conversion, Conversions

conversion constructor, Conversions

conversion operator, Conversion Operators

copy and paste programming, Anti-patterns

copy assignment operator, Copy Constructors and Assignment Operators

copy constructor, Copy Constructors and Assignment Operators, Constructors, Destructors, and Copy Assignment Operators

cout, Streams and Dates

ostream , Streams
standard output, C++ First Example

CPPLIBS, Derivation and ArgumentList , Building and Reusing Libraries , Installing Libraries: A Lab Exercise

creation rule, Creation Rules and Friend Functions

Creational patterns, Introduction to Design patterns

cstdarg, Functions with Variable-length Argument Lists

cstdio, Standard Headers

cstring, Standard Headers

cvs, Open Source development tools, Libraries, IDEs.

cygwin, C++/Qt Setup: Win32

D

data sharing, Flyweight pattern: Implicitly Shared Classes

database

creating in MySQL , Intro to MySQL

database model

QSqlRelationalModel , Widget Categories

DataObject, DataObject: An Extension of QObject

DataObjectTableModel, Table Models

Debian

packaged binaries, C++/Qt Setup: Open Source Platforms

debugger, Debugging

dec

manipulator, Streams

declaration

class (forward), Class Declarations and Defintions
vs definition , Declarations and Definitions

declaring objects, namespace, static objects and extern

decoupling, Customizing the Visitor using Inheritance

deep copy, Managed Containers, Composites and Aggregates

default

switch label, Selection Statements

default constructor, Constructors

default initialization, Constructors

definition

and declaration , Declarations and Definitions
vs declaration , Declarations and Definitions

delegates, Creational Patterns

delete, Operators new and delete , Further Pointer Pathology with Heap Memory

dependency, Organizing Libraries: Dependency Management , The Preprocessor: For #including Files

circular , Class Declarations and Defintions

derived class, Simple Derivation

design patterns, Frameworks and Components , Introduction to Design patterns

Abstract Factory pattern, Importing Objects with an Abstract Factory
Adaptor pattern, FileTagger: Façade Example
anti-pattern, Anti-patterns
Behavioral patterns, Introduction to Design patterns
Command pattern, QActions, QToolbars, and QActionGroups , virtual pointers, virtual tables
Command pattern, with work threads , Long Running Threads and the Command Pattern
Composite pattern, Parents and Children, Tree Models
Composite pattern, in XML objects , Memento Pattern
Composite pattern, QDomNode, XML, Tree Structures, and DOM
Creational patterns, Introduction to Design patterns
design patterns, Introduction to Design patterns
Façade pattern, Qt GUI Widgets , DataObject: An Extension of QObject , The Façade Pattern
Flyweight pattern, Flyweight pattern: Implicitly Shared Classes
Interpreter pattern, virtual pointers, virtual tables
Interpreter pattern, applied to boolean constraints , Interpreter Pattern: Groups of Constraints
Iterator pattern, Iterators , QDirIterator and the Iterator pattern
Memento pattern, Exporting to XML
MetaObject pattern, QMetaObject - The Meta Object pattern, Memento Pattern
Model-View-Controller pattern, M-V-C: What about the Controller?
Monostate pattern, QSettings, QSettings: Saving and Restoring Application State
Observer pattern, QApplication and the Event Loop
Prototype pattern, Prototype Pattern: using dynamic properties
Publish-subscribe pattern, QApplication and the Event Loop
Reflection pattern, QMetaObject - The Meta Object pattern
Serializer pattern, Serializer Pattern
Singleton pattern, Creational Patterns , qApp and Singleton pattern
Strategy pattern, instead of a switch , Selection Statements , virtual pointers, virtual tables
Structural patterns, Introduction to Design patterns
Visitor pattern, Directories and Files: QDir and QFileInfo , Visitor Pattern: DOM Tree Walking
Wrapper pattern, FileTagger: Façade Example

destructor, Destructors

and inheritance, Constructors, Destructors, and Copy Assignment Operators
virtual, Polymorphism and virtual destructors

dialog

QErrorMessage , Widget Categories
QFileDialog , Widget Categories
QInputDialog , Widget Categories

dialog box, Dialogs

modal, Dialogs

display widget

QLabel , Widget Categories
QPixmap , Widget Categories
QProgressBar , Widget Categories

DLL

Dynamic Link Library, windows shared libraries, Installing Libraries , Errata

do

loop, Iteration

DOM

Examples using, Generation of XML with DOM

downcasting

see RTTI, Runtime Type Identification (RTTI)

dtor, Destructors

dynamic binding, Derivation with Polymorphism

dynamic storage

allocation, Operators new and delete

dynamic_cast

downcast operator, Runtime Type Identification (RTTI)

E

eclipse, Open Source development tools, Libraries, IDEs.

EditStrategy

QSqlDatabase, Database Models

Edyuk

formerly known as QCodeEdit , Open Source development tools, Libraries, IDEs.

ellipsis, Functions with Variable-length Argument Lists

in catch, try and catch

emit, Signals and Slots

encapsulation, Encapsulation

endl

manipulator , Streams

enum, Enumerations

env

bash command , C++/Qt Setup: Open Source Platforms

environment, Processes and Environment

environment variables, C++/Qt Setup: Open Source Platforms

and child processes , Processes and Environment

equivalence relation

equivalence class, Exercise: QSet and QMap
reflexivity , Exercise: QSet and QMap
symmetry, Exercise: QSet and QMap
transitivity, Exercise: QSet and QMap

errors

linker , Common Linker Error Messages
unable to find libxxx.so.x , Common Linker Error Messages
undefined reference , Common Linker Error Messages
undefined reference to vtable, Common Linker Error Messages

event, Qt GUI Widgets

event filter

capturing keyboard events , Qonsole with Keyboard Events

event loop, QApplication and the Event Loop

event-driven programming, Event-Driven parsing

eventFilter, Qonsole with Keyboard Events

events, QApplication and the Event Loop

exception

safety, throwing things around

exceptions

standard , Exception Handling

explicit, Conversions

export, Exporting template functions

expression, Types and Expressions

expression statements, Statements

extend, Simple Derivation

Extensible Markup Language, Parsing XML

extern

object declarations , namespace, static objects and extern

extraction operator, Strings

F

Façade pattern, Qt GUI Widgets , DataObject: An Extension of QObject , The Façade Pattern

factory, Creational Patterns

Factory method, Creational Patterns

example , Generation of XML with DOM

fifo queue, Multiple Threads, Queues, and Loggers Example: Giant

FileVisitor, Directories and Files: QDir and QFileInfo

fixed

manipulator, Streams

flush

manipulator , Streams

Flyweight pattern, Flyweight pattern: Implicitly Shared Classes

for

loop, Iteration

foreach, QStringList and iteration

fork, Summary: QProcess and QThread

forward declaration, Class Declarations and Defintions , Organizing Libraries: Dependency Management , The Preprocessor: For #including Files

framework, Frameworks and Components

friend, Friends of a Class

declaration , Friends of a Class
uses of , Creation Rules and Friend Functions

function

declaration, Function Declarations
definition, Declarations and Definitions
hiding of base class functions, Overloading, Hiding, and Overriding
overloading, Overloading Functions , Overloading, Hiding, and Overriding
prototype, Function Declarations
signature, Overloading Functions

G

g++

compiler command, C++ First Example

garbage collection, Flyweight pattern: Implicitly Shared Classes

gdb, gdb Quickstart

printing QStrings, gdb Quickstart

generalization, Simple Derivation

generic

algorithms , Generics, Algorithms, and Operators
container, Introduction to Containers
containers, Introduction to Containers

generics, Generics and Templates

getline

STL string , Exercises: Input and Output

global

scope, Identifier Scope

GNU debugger, gdb Quickstart

God object, Anti-patterns

granularity, Code Containers

H

handler class, Flyweight pattern: Implicitly Shared Classes

hard coding, Anti-patterns

hash table, Containers

header file, Class definitions

heap, Operators new and delete , Storage Class

heap corruption, Memory Access

heap objects, qApp and Singleton pattern

heavyweight objects, Prototype Pattern: using dynamic properties

hex

manipulator, Streams

hiding

see function hiding, Overloading, Hiding, and Overriding

host object, const Member Functions

I

ID3Lib, The Façade Pattern

IDE, Open Source development tools, Libraries, IDEs.

identifier, Identifiers, Types, and Literals

if/else, Selection Statements

images

loading from an application, Images and Resources

implementation, Encapsulation

implementation file, Class definitions

implementation relationship

derivation, public, protected, and private derivation

implicitly shared containers, Flyweight pattern: Implicitly Shared Classes

include path, #include: Finding Header Files

INCLUDEPATH

qmake variable, Building and Reusing Libraries

incomplete type, The Preprocessor: For #including Files

indirection, The Unary Operators & and *

infix, Operator Overloading

inheritance, Inheritance and Polymorphism

multiple, Qt GUI Widgets , Multiple Inheritance
multiple, and constructors , Multiple Inheritance Syntax
multiple, and QObject, Q_OBJECT and moc: A checklist
virtual, virtual Inheritance

inherits, Type Identification and qobject_cast

initialization

order, Constructors, Destructors, and Copy Assignment Operators

initialization list, Constructors

inline, inline Functions

and the linker , Common Linker Error Messages
rules for functions, inline Functions
vs macro expansion , Inlining versus Macro Expansion

inner class, Flyweight pattern: Implicitly Shared Classes

input widget

QComboBox , Widget Categories
QLineEdit , Widget Categories
QScrollBar , Widget Categories
QSlider , Widget Categories
QSpinBox , Widget Categories
QTextEdit , Widget Categories

input/output operators, C++ First Example

insertion operator, Friends of a Class

integral promotion, Standard Expression Conversions

Integrated Development Environment, Open Source development tools, Libraries, IDEs.

interface bloat, Anti-patterns

interface relationship

derivation, public, protected, and private derivation

Interpreter pattern, virtual pointers, virtual tables

applied to boolean constraints , Interpreter Pattern: Groups of Constraints

inversion of control, Event-Driven parsing

iostream, Streams

is-a

public inheritance relationship, public, protected, and private derivation

ISO, A Brief History of C++

iterator

various kinds, Iterators

Iterator pattern, Iterators , QDirIterator and the Iterator pattern

iterators

through QMaps , Sorted Map example

J

jEdit

programmer's text editor , jEdit

join, QStringList and iteration

K

kate, Open Source development tools, Libraries, IDEs.
keywords, C++ Reserved keywords

L

label

of case, Selection Statements

labels

function scope, Identifier Scope

layout, Layouts: A First Look , Layout of Widgets

QGridLayout , Widget Categories
QHBoxLayout , Widget Categories
QVBoxLayout , Widget Categories
spacer, Spacing, Stretching, and Struts
stretch, Spacing, Stretching, and Struts
strut, Spacing, Stretching, and Struts

lazy copy

on write, Flyweight pattern: Implicitly Shared Classes

ld.so.cache

cache file , Common Linker Error Messages

ld.so.conf

system library search path , Common Linker Error Messages

ldconfig

rebuilding ld.so.cache , Common Linker Error Messages

LD_LIBRARY_PATH, C++/Qt Setup: Open Source Platforms , Installing Libraries

*nix lib search path , Common Linker Error Messages
user library search path , Common Linker Error Messages

libgtk, Frameworks and Components

libraries

installing, Common Linker Error Messages

library, Code Containers, Abstract Factories and Libraries

LIBS

qmake variable , Building and Reusing Libraries

libutils, Building and Reusing Libraries , Installing Libraries: A Lab Exercise , Directories and Files: QDir and QFileInfo

link time depencency, Organizing Libraries: Dependency Management

list

QList, Introduction to Containers

literal, Identifiers, Types, and Literals

Logger

example , Multiple Threads, Queues, and Loggers Example: Giant

logical operators, Evaluation of Logical Expressions

LogWindow, Qonsole: Writing an Xterm in Qt

example , Multiple Threads, Queues, and Loggers Example: Giant

lvalue, Reference Variables

modifiable value, Returning References from Functions

M

main()

first program , C++ First Example
full signature , main, and Command Line Arguments

make, Makefile, qmake, and Project Files

make distclean

to clean up all files , The make Command

Makefile, Makefile, qmake, and Project Files

man

manual pages , C++ First Example

manage resources, Destructors

managed container, Managed Containers, Composites and Aggregates

manipulator

iostream , Input and Output

manipulators, Input and Output , Streams

MANPATH, C++/Qt Setup: Open Source Platforms

mapping layer

from objects to tables , Table Models

member

initialization list, Constructors

member function, Class definitions

Memento pattern, Exporting to XML

memory

corruption, Pointer Pathology
leak, Memory Access Summary

memory corruption

finding, Finding Memory Errors

memory leak, Operators new and delete

menu, QActions, QMenus, and QMenuBars

message, Signals and Slots

meta character, Regular Expression Syntax

meta object, QMetaObject - The Meta Object pattern

MetaObject compiler, Q_OBJECT and moc: A checklist

MetaObject pattern, QMetaObject - The Meta Object pattern, Memento Pattern

method

virtual function, Derivation with Polymorphism

MinGW

Minimalist Gnu for Windows , C++/Qt Setup: Win32

moc, Q_OBJECT and moc: A checklist

modal, Dialogs

model, QPixmap and QThread Animation Example: Movie Player , Models and Views

QAbstractItemModel , Widget Categories
QAbstractListModel , Widget Categories
QAbstractTableModel , Widget Categories

model-view-controller

uml diagram , Qonsole: Writing an Xterm in Qt

Model-View-Controller pattern, M-V-C: What about the Controller?

models and views

mixing together , Anti-patterns

modifiable lvalue, Reference Variables

module, Code Containers

Monostate pattern

QSettings, QSettings: Saving and Restoring Application State

multiple inheritance, Multiple Inheritance

conflicts, Extended Tree Widget Items , Resolving Multiple Inheritance Conflicts

Multiple Inheritance

with QObject, Multiple Inheritance with Abstract Interfaces

Multitasking , QProcess and Process Control

multithreaded, QPixmap and QThread Animation Example: Movie Player

Murphy's Law, Exceptions

mutex, Thread Safety and QObjects

MVC

Model-View-Controller , Exercises: Layout of Widgets, M-V-C: What about the Controller?

MySQL

setting root password, Intro to MySQL

N

namespace, Code Containers, Namespaces

example , namespace, static objects and extern

namespace std

using, C++ First Example

navigibility, Relationships Summary

nested class, Flyweight pattern: Implicitly Shared Classes

new, Operators new and delete

failures, What happens if new fails?

noshowpos

manipulator, Streams

nothrow, Flyweight pattern: Implicitly Shared Classes

null pointer, The Unary Operators & and *

O

object, The Unary Operators & and *

an instance of a type, Class definitions
creation rules, Creational Patterns
definition, Declarations and Definitions
state, Class definitions
types , Values and Objects

object life cycle, Copy Constructors and Assignment Operators

ObjectFactory, Abstract Factory , Importing Objects with an Abstract Factory

Observer pattern, QApplication and the Event Loop

oct

manipulator, Streams

one-to-many, Relationships

one-to-one, Relationships

OnManualSubmit

QSqlDatabase, Database Models

Operands, Types and Expressions

operator

function-call () , The Function-Call operator()

operator overloading, Operator Overloading

operators, Operators

client defined , Operator Overloading
conversion , Conversion Operators

Operators, Types and Expressions

optional arguments, Optional Arguments

ordered map, Containers

overloading

see function overloading, Overloading, Hiding, and Overriding

overriding, Simple Derivation

base class methods, Overloading, Hiding, and Overriding

P

package diagram, Organizing Libraries: Dependency Management

parameter

pass by reference, Parameter Passing by Reference
pass by value, Parameter Passing by Value

parent and child objects, QObject

parse event handler, Event-Driven parsing

passive interface, QApplication and the Event Loop , Event-Driven parsing

PATH, C++/Qt Setup: Open Source Platforms

pointer, The Unary Operators & and *

arithmetic , Pointer Arithmetic

pointers

and const, const* and *const
dereferencing, Memory Access Summary

polymorphic type, Derivation with Polymorphism, virtual pointers, virtual tables

polymorphism, Derivation with Polymorphism

from constructors , Benefits of Using Factories

POSIX, C++/Qt Setup: Open Source Platforms

prepared statement

QSqlQuery, Connecting to MySQL from Qt

preprocessor, Inlining versus Macro Expansion , The Preprocessor: For #including Files

primitive

types , QVariant Class: Accessing Properties

private, Member Access Specifiers

profiler, Finding Memory Errors

project file, Qt dialogs for user input/output , Makefile, qmake, and Project Files

promotion, Standard Expression Conversions

properties, Memento Pattern

protected, Member Access Specifiers

Prototype pattern, Prototype Pattern: using dynamic properties

pseudo-random numbers, Exercises: C++ Simple Types

public, Member Access Specifiers

public interface, Encapsulation

Publish-subscribe pattern, QApplication and the Event Loop

pure virtual, Derivation from an Abstract Base Class

abstract interfaces , Table Models

Q

QAbstractItemModel, Qt 4 Models and Views , Tree Models

QAbstractTableModel, Table Models

QAction, QActions, QMenus, and QMenuBars , QActions, QToolbars, and QActionGroups

QActionGroup, QActions, QToolbars, and QActionGroups

qApp, Type Identification and qobject_cast

a pointer to the current application , Connecting to slots
managing heap objects , qApp and Singleton pattern

QApplication, Qt dialogs for user input/output

starter of events , QApplication and the Event Loop

QButtonGroup, Moving Widgets across Layouts

QComboBox, Input Dialogs and Widgets

QDate , Streams and Dates

qDeleteAll()

containers that manage heap memory, Sorted Map example

QDevelop, Open Source development tools, Libraries, IDEs.

QDialog, Dialogs

QDir, Directories and Files: QDir and QFileInfo

QDirIterator

Qt File Visitor, QDirIterator and the Iterator pattern

QFileInfo, Directories and Files: QDir and QFileInfo

QInputDialog, Input Dialogs and Widgets

QLayout

adding a widget to more than one , Moving Widgets across Layouts

QLineEdit, Input Dialogs and Widgets

QList , QStringList and iteration

QListView, Tree Models

QMainWindow

saving and restoring state, QSettings: Saving and Restoring Application State

qmake, Makefile, qmake, and Project Files , Building and Reusing Libraries

QMap

example, Exercise: QSet and QMap
iteration , Sorted Map example

QMenu, QActions, QMenus, and QMenuBars

QMenuBar, QActions, QMenus, and QMenuBars

QMessageBox, Dialogs

QMetaObject, Importing Objects with an Abstract Factory

QMetaProperty, Importing Objects with an Abstract Factory

QModelIndex, Qt 4 Models and Views

QObject, QObject

children, QObject , Qt GUI Widgets
non-public copy constructor, QObject

QObjectList, QObject

qobject_cast, Type Identification and qobject_cast

QPersistentModelIndex, Qt 4 Models and Views

QPixmap, Images and Resources , QPixmap and QThread Animation Example: Movie Player

QPointer

guarded pointers, Member Selection operators

QProcess, Concurrency , QProcess and Process Control

Bidirectional Communication , Qonsole: Writing an Xterm in Qt

qrc files

Resource Collection File , Images and Resources

QSet

example , Exercise: QSet and QMap

QSettings, QSettings: Saving and Restoring Application State

persistent storage of state data , QSettings: Saving and Restoring Application State

QSlider, QPixmap and QThread Animation Example: Movie Player

qSort, Generics, Algorithms, and Operators

QSpinBox, Input Dialogs and Widgets

QSplitter, Multiple Threads, Queues, and Loggers Example: Giant

example , Multiple Threads, Queues, and Loggers Example: Giant

QSqlDatabase, Database Models

QSqlQuery, Connecting to MySQL from Qt

QStandardItemModel, Qt 4 Models and Views

QString, Qt dialogs for user input/output , Strings , Derivation and ArgumentList

QStringList, QStringList and iteration , Derivation and ArgumentList , Generics, Algorithms, and Operators

Qt

installation on *nix platforms, C++/Qt Setup: Open Source Platforms
installation on Win32 platforms, C++/Qt Setup: Win32
multiple installed versions, C++/Qt Setup: Open Source Platforms

Qt data type

QPoint , Widget Categories
QSize , Widget Categories

Qt4, C++/Qt Setup: Open Source Platforms

QTableView, Qt 4 Models and Views , Tree Models

QTextEdit, Input Dialogs and Widgets

QTextStream , Streams and Dates

QThread, Concurrency

example , Multiple Threads, Queues, and Loggers Example: Giant

QTimer, Movie Player with QTimer

QTreeWidgetItem, Tree Models , Extended Tree Widget Items

QVariant, QVariant Class: Accessing Properties

QVBoxWidget, Layouts: A First Look

QWidget

, Qt GUI Widgets

QXmlAttributes, Event-Driven parsing

QXmlContentHandler, Event-Driven parsing

QXmlDefaultHandler, Event-Driven parsing , Importing Objects with an Abstract Factory

QXmlReader, Event-Driven parsing

QXmlSimpleReader, Event-Driven parsing , Importing Objects with an Abstract Factory

Q_DECL_EXPORT, Installing Libraries , Common Linker Error Messages

Q_OBJECT, Memento Pattern

macro, QMetaObject - The Meta Object pattern

Q_PROPERTY, Memento Pattern

R

rand()

from cstdlib, Exercises: C++ Simple Types

random access, Containers

rcc

resource compiler, Images and Resources

recursion

traversing trees of files, Directories and Files: QDir and QFileInfo

refactoring, Simple Derivation

reference, Reference Variables

reference counting, Flyweight pattern: Implicitly Shared Classes

reference parameter, Parameter Passing by Reference

reference return, Returning References from Functions

reflection, Anti-patterns

into database tables, Database Models

Reflection pattern, QMetaObject - The Meta Object pattern

register, Storage Class

regular expression, Regular Expressions

meta character, Regular Expression Syntax

reinterpret_cast, reinterpret_cast

reinventing the square wheel, Anti-patterns

relationship, Relationships

bidirectional , Class Declarations and Defintions , The Preprocessor: For #including Files

resource sharing, Flyweight pattern: Implicitly Shared Classes

resources, Destructors

RESOURCES, Images and Resources , QPixmap and QThread Animation Example: Movie Player

RTTI, Type Identification and qobject_cast , Runtime Type Identification (RTTI)

runtime binding, Derivation with Polymorphism

runtime errors, Debugging

runtime type identification

see RTTI , Runtime Type Identification (RTTI)

S

SAX parser, Parsing XML , Importing Objects with an Abstract Factory

scientific

manipulator, Streams

scope, Class definitions

block , Member Access Specifiers
class, Default Scope of Identifiers - A Summary
resolution operator (::), Class definitions

segmentation fault

runtime error, gdb Quickstart

segmentation faults, Memory Access

finding quickly, gdb Quickstart

SEGV

finding quickly , gdb Quickstart

semaphore, Thread Safety and QObjects

sequential access, Containers

Serializer pattern, Serializer Pattern

set_new_handler, set_new_handler() : Another Approach To new Failures

shared

pointers, Flyweight pattern: Implicitly Shared Classes

showpoint

manipulator, Streams

showpos

manipulator, Streams

signal, Signals and Slots

signals and slots

custom, Moving Widgets across Layouts

Singleton

Factory method, qApp and Singleton pattern

Singleton pattern, Creational Patterns , qApp and Singleton pattern

sizeof, C++ Simple Types

skip-list dictionary, Containers

slot, Connecting to slots , Signals and Slots

slots

multiple signals connected to, Signals and Slots

smart pointer, Operators new and delete , Member Selection operators

split, QStringList and iteration

sql

prepared statements , Connecting to MySQL from Qt
queries with exec(), Connecting to MySQL from Qt

srand(time(0))

a clever way to seed , Exercises: C++ Simple Types

stack, Storage Class

stack trace, gdb Quickstart

state

of an object, Class definitions

statements, Statements

expression and compound , Statements

static, The Keyword static

block scope variables, Q_PROPERTY Macro - Describing QObject Properties
objects, namespace, static objects and extern
variables, storage class, Storage Class

static binding, Derivation with Polymorphism

static_cast, static_cast and const_cast

stdin

standard input , Streams

stdio.h, Standard Headers

stdout, stderr

standard output, error , Streams

STL

Standard Template Library, Standard Headers

STL strings, Strings

storage class, Storage Class

Strategy pattern

instead of a switch , Selection Statements , virtual pointers, virtual tables

streams, Streams

string.h, Standard Headers

Stroustrup, Bjarne, A Brief History of C++

struct, First, there was struct

Structural patterns, Introduction to Design patterns

subclass, Simple Derivation

submenu, QActions, QMenus, and QMenuBars

subobject, Subobjects

in UML, UML Relationships

subversion, Open Source development tools, Libraries, IDEs.

switch, Selection Statements

synchronous, Signals and Slots

T

table

defining in SQL, Connecting to MySQL from Qt
models , Table Models

tag name

for enum , Enumerations

taglib, The Façade Pattern

tar file

tarball, C++/Qt Setup: Open Source Platforms

TEMPLATE

qmake variable , Qt dialogs for user input/output , Installing Libraries

template

parameters, Smart Pointers: auto_ptr
type, Smart Pointers: auto_ptr
types, Generics and Templates

template parameter, Generics and Templates

this, const Member Functions

thrashing, What happens if new fails?

thread safety, Thread Safety and QObjects

threads , Threads and QThread

for long-running jobs in GUI apps , Long Running Threads and the Command Pattern

throw, Exception Handling, More about throw

from ctors or dtors, throwing things around

toString(), DataObject: An Extension of QObject

tree

models and views , Tree Models

trees, Extended Tree Widget Items

try, Exception Handling, try and catch

typecast, Type Identification and qobject_cast

explicit conversion, Explicit Conversions

typeid, typeid operator , virtual pointers, virtual tables

U

UI

user interface , Models and Views

umbrello, Open Source development tools, Libraries, IDEs.

UML

diagram of inheritance, Simple Derivation
relationships, UML Relationships
tools, Open Source development tools, Libraries, IDEs.
Unified Modeling Language , Introduction to UML

union, QVariant Class: Accessing Properties

unordered map, Containers

using

importing namespaces, Namespaces
namespace std , C++ First Example

utils, Building and Reusing Libraries

V

valgrind, Finding Memory Errors

value

types, Values and Objects

value type, Containers

variable, The Unary Operators & and *

declaration, C++ First Example
definition, Declarations and Definitions
initialization, C++ First Example

variant

type, QVariant Class: Accessing Properties

va_arg, Functions with Variable-length Argument Lists

vector, Containers

view, QPixmap and QThread Animation Example: Movie Player , Models and Views

QListView, Widget Categories
QTableView, Widget Categories
QTreeView, Widget Categories

virtual

base class , virtual Base Classes
function, Derivation with Polymorphism
inheritance, virtual Inheritance
pointers, virtual pointers, virtual tables
tables, virtual pointers, virtual tables

virtual memory, What happens if new fails?

visibility, Member Access Specifiers

Visitor pattern, Directories and Files: QDir and QFileInfo , Visitor Pattern: DOM Tree Walking

void, C++ Simple Types

volatile

in multithreaded applications , Long Running Threads and the Command Pattern

vtable, Benefits of Using Factories , virtual pointers, virtual tables

undefined reference error , Common Linker Error Messages
undefined reference to, and the Q_OBJECT macro, Q_OBJECT and moc: A checklist

W

while

loop, Iteration

widget, QApplication and the Event Loop

win32

building qt and libmysql , Installing Libraries: A Lab Exercise

window, Qt GUI Widgets

windows

console applications , Qt dialogs for user input/output

Windows platforms

building DLLs, Installing Libraries , Errata

wrapper, QVariant Class: Accessing Properties , Smart Pointers: auto_ptr

Wrapper pattern, FileTagger: Façade Example

X

X3J16, A Brief History of C++

xlobject

signals and slots , Points of Departure

XML, Parsing XML

Editors , Parsing XML

XML parser, Event-Driven parsing

xmllint, Parsing XML


Bibliography		About the Authors