Index

Symbols

!
not, Arithmetic
#define
for defining constants , The Keyword const
#ifndef wrapper, The Preprocessor: For #including Files
#include
preprocessor directive , C++ First Example
see include preprocessor directive , The Preprocessor: For #including Files
$
bash environment variables, Exercise: Installing Libraries
%
modulus operator , Arithmetic
%=
operator , Arithmetic
&
address-of operator, The Unary Operators & and *
as a type modifier , Reference Variables
&&
and, Arithmetic
()
function call operator, Returning References from Functions , Function Pointers and Functors , Concurrent Map/Reduce Example , 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
pointer dereference operator, Smarter Pointers
*=
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, Smarter Pointers , Member Selection Operators
-Wall
compiler option, 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
scope resolution operator for accessing hidden functions, Overloading, Hiding, and Overriding
<
less than operator , Arithmetic
<<
insertion operator, Standard Input and Output , Returning References from Functions
output operator , Serializer Pattern: QTextStream and QDataStream
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, Standard Input and Output , Serializer Pattern: QTextStream and QDataStream
? %
conditional operator , Arithmetic
[]
array subscript operator , Introduction to Arrays , Valid Pointer Operations
array type modifier , Introduction to Arrays
index operator , Returning References from Functions
subscript operator , The Subscript operator[]
||
or, Arithmetic
~
HOME, Exercise: Installing Libraries

A

a.out
executable, C++ First Example
abstract
base class, Derivation from an Abstract Base Class, SAX Parsing
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, The Façade Pattern
address-of operator (&), The Unary Operators & and *
affinity
thread, Thread Safety and QObjects
aggregate container, Managed Containers, Composites and Aggregates
aggregation, UML Relationships , Managed Containers, Composites and Aggregates
relationship, Relationships
ANSI typecasts, Safer Typecasting Using ANSI C++ Typecasts
ANSI/ISO Draft Standard, A Brief History of C++
antiPattern, AntiPatterns
API
Application Programming Interface, Libraries and Design Patterns , Frameworks and Components
apt-get
build-dep, The apt System , C++/Qt Setup: Open Source Platforms
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
and argv[] , main, and Command-Line Arguments
element, Introduction to Arrays
arrays
and function return values , Arrays, Functions, and Return Values
avoiding them in Qt, Introduction to Containers, Processing Command-Line Arguments
assignable data type, Containers
assignment operator, Copy Constructors and Assignment Operators
association
relationship , Relationships
associative container, Containers
AT&T Bell Labs, A Brief History of C++
auto
variables, storage class, Storage Class
auto_ptr
guarded pointers, Member Selection Operators

B

bad_alloc
exception, Arrays and Memory: Important Points
base class, Simple Derivation
bash
*nix shell , C++/Qt Setup: Open Source Platforms
environment variables, Exercise: Installing Libraries
bash environment variable
HOME, Exercise: Installing Libraries
bash environment variables
$, Exercise: Installing Libraries
behavior
of an object , Class Definitions
Behavioral patterns, Design Patterns
bind
values to a prepared statement , QSqlDatabase: Connecting to SQL 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
signals and slots, Points of Departure
break
out of loops, Iteration
out of switch, Selection Statements
Bridge pattern , Flyweight Pattern: Implicitly Shared Classes
build, qmake, Project Files, and Makefile
buttons
QCheckBox , Widget Categories
QPushButton , Widget Categories
QRadioButton , Widget Categories
QToolButton , Widget Categories

C

C++ statement, Statements
C++0x
raw-quoted strings , Regular Expression Syntax
cache, Containers
CamelCase
notation, Style Guidelines, Naming Conventions
Cardinality, Relationships Summary
cards
data structures, Exercises: Managed Containers, Composites and Aggregates
images and pixmaps, Icons, Images and Resources
case
label, Selection Statements
cast
C-style , Explicit Conversions
constructor-style, Explicit Conversions
child objects, QObject, QApplication, Signals, and Slots
cin, Streams and Dates
istream , Streams
circular
dependency , Class Declarations and Definitions
circular dependency, Organizing Libraries: Dependency Management , The Preprocessor: For #including Files
class, Class Definitions
declaration , Class Declarations and Definitions , The Preprocessor: For #including Files
definition, Class Definitions
scope, Identifier Scope , Default Scope of Identifiers - More Detail
class scope , Class Definitions
classHead, Class Definitions
clear()
Qt Containers, Containers of Pointers
client code, First, There Was struct , Member Access Specifiers
cloning
objects, Values and Objects
closeEvent()
event handler , QSettings: Saving and Restoring Application State
cmd
win32 command prompt, C++/Qt Setup: Win32
Command pattern, The Command Pattern, virtual Pointers, virtual Tables
command-line arguments, main, and Command-Line Arguments
switches, Processing Command-Line Arguments
comment delimiters, C++ First Example
compile time binding, Derivation with Polymorphism
complex numbers, Operator Overloading
Composite pattern, Composite Pattern: Parents and Children, Tree Models
in XML objects , Memento Pattern
QDomNode, XML, Tree Structures, and DOM
composition, UML Relationships , Managed Containers, Composites and Aggregates
component, UML Relationships
relationship, Relationships
compound statement, Statements
concrete class, Derivation from an Abstract Base Class
conditional operator, Introduction to Functions
conditional statement, Selection Statements
CONFIG += console
for console apps on windows , qmake, Project Files, and Makefile
CONFIG -= app_bundle
for console apps on the Mac , qmake, Project Files, and Makefile
conjunction
and, Arithmetic
connect, Signals and Slots
console
applications , qmake, Project Files, and Makefile
const
applied to references , References to const
correct , const Member Functions
member functions , const Member Functions
on simple types , The Keyword const
overloading, Overloading on const
pointers , const* and *const
constructor, Constructors
conversion , Conversions
default, 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
container
composite, Managed Containers, Composites and Aggregates
generic, Introduction to Containers
managed, Managed Containers, Composites and Aggregates
container classes
value-based, Exercise: Generics
container widget
QFrame , Widget Categories
QMainWindow , Widget Categories
QStackedWidget, Widget Categories
QTabWidget , Widget Categories
QToolBar , Widget Categories
context menu
setContextMenuPolicy() , QActions, QMenus, and QMenuBars
continue
to next iteration of loop, Iteration
controller
delegate, Model-View-Controller (MVC)
controller class, Model-View-Controller (MVC)
QAbstractItemDelegate , Delegate Classes
conversion constructor, Conversions
copy and paste programming, AntiPatterns
copy assignment operator, Copy Constructors and Assignment Operators
copy constructor, Copy Constructors and Assignment Operators, Constructors, Destructors, and Copy Assignment Operators
copy on write
reference counting , Values and Objects
cout, Streams and Dates
ostream , Streams
standard output, C++ First Example
CPPLIBS, Building and Reusing Libraries , Exercise: Installing Libraries
CPU
Central Processing Unit, Libraries and Design Patterns
Creational patterns, Design Patterns
crypto
encryption-decryption , Exercise: Encryption
QCryptographicHash, Exercises: QProcess and Process Control
random character shifting, Exercise: Encryption
random permutation , Exercise: Encryption
cstdarg, Functions with Variable-Length Argument Lists
cstdio, Standard Headers
cstring, Standard Headers

D

data member, First, There Was struct
data sharing, Flyweight Pattern: Implicitly Shared Classes
data()
and roles for QAbstractItemModel , Model-View-Controller (MVC)
database model
QSqlRelationalModel , Widget Categories
dataChanged, Editable Models
dataobjects, Building and Reusing Libraries
Debian
packaged binaries, C++/Qt Setup: Open Source Platforms
debugger, Debugging
dec
manipulator, Streams
declaration
class(forward), Class Declarations and Definitions
vs definition , Declarations and Definitions
deep copy, Managed Containers, Composites and Aggregates
default
switch label, Selection Statements
default initialization, Declarations and Definitions
in constructors , Constructors
definition
and declaration , Declarations and Definitions
vs declaration , Declarations and Definitions
delegates, Model-View-Controller (MVC), Creational Patterns
delete, Operators new and delete , Further Pointer Pathology with Heap Memory
deleteLater()
safely delete QObjects , Parallel Prime Number Calculators
safely deleting heap QObjects , QObject Lifecycle
delete[] , Arrays and Memory: Important Points
for dynamic arrays , Introduction to Arrays
dependency, Organizing Libraries: Dependency Management , The Preprocessor: For #including Files
circular , Class Declarations and Definitions
derived class, Simple Derivation
design patterns, Frameworks and Components , Design Patterns
Abstract Factory pattern, Importing Objects with an Abstract Factory
Adaptor pattern, The Façade Pattern
Behavioral patterns, Design Patterns
Bridge pattern , Flyweight Pattern: Implicitly Shared Classes
Command pattern, The Command Pattern, virtual Pointers, virtual Tables
Composite 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, Design Patterns
design patterns, Design Patterns
Façade pattern, The Façade Pattern
Flyweight pattern, Flyweight Pattern: Implicitly Shared Classes
Interpreter pattern, virtual Pointers, virtual Tables
Iterator pattern, Iterators
Memento pattern, Exporting to XML
MetaObject pattern, QMetaObject - The Meta Object Pattern, Memento Pattern
Monostate pattern, QSettings, QSettings: Saving and Restoring Application State
Observer pattern, QApplication and the Event Loop
Private Implementation pattern , Flyweight Pattern: Implicitly Shared Classes
Publish-subscribe pattern, QApplication and the Event Loop
Reflection pattern, QMetaObject - The Meta Object Pattern
Serializer pattern, Serializer Pattern: QTextStream and QDataStream
Singleton pattern, Creational Patterns , qApp and Singleton Pattern
Strategy pattern, instead of a switch , Selection Statements , virtual Pointers, virtual Tables
Structural patterns, Design Patterns
Wrapper pattern, The Façade Pattern
Designer
dockable windows , Regions and QDockWidgets
DESTDIR
qmake variable , Installing Libraries
destructor, Destructors
and inheritance, Constructors, Destructors, and Copy Assignment Operators
virtual, Polymorphism and virtual Destructors
destructors
virtual, Derivation with Polymorphism
directory, QDir, QFileInfo, QDirIterator
disjunction
or, Arithmetic
display widget
QLabel , Widget Categories
QPixmap , Widget Categories
QProgressBar , Widget Categories
do
loop, Iteration
DOM
Examples using, Generation of XML with DOM
downcast
operators , Type Identification and qobject_cast
downcasting
see RTTI, Runtime Type Identification (RTTI)
dtor, Destructors
dynamic binding, Derivation with Polymorphism
dynamic storage
allocation, Operators new and delete
dynamic_cast, Type Identification and qobject_cast
downcast operator, Runtime Type Identification (RTTI)

E

Eclipse
integration , QtCreator – An IDE for Qt Programming
eclipse, Open Source Development Tools, Libraries, IDEs
edit trigger , Delegate Classes
element
array, Introduction to Arrays
ellipsis, Functions with Variable-Length Argument Lists
emit, Signals and Slots
encapsulation, Encapsulation
endl
manipulator , Streams
enum, Enumerations
enumerated types
in Qt properties , Q_PROPERTY Macro - Describing QObject Properties
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
bash , Exercise: Installing Libraries
export, Exercise: Installing Libraries
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, Widgets and Designer
event filter
capturing keyboard events , Qonsole with Keyboard Events
event loop, QApplication and the Event Loop
in threads , QThread and QtConcurrent
event queue, The Event Loop: Revisited
eventFilter, Qonsole with Keyboard Events
events, QApplication and the Event Loop
examples and demos
From Qt sources , Introduction to Qt
exception
bad_alloc, Arrays and Memory: Important Points
exec()
QApplication, QApplication and the Event Loop
QDialog, Dialogs
QThread, QThread and QtConcurrent
EXIT_SUCCESS, main, and Command-Line Arguments
explicit
constructor , Explicit Conversions
for preventing implicit conversions from single argument constructors , Conversions
QObject constructors , QObject, QApplication, Signals, and Slots
export
environment variables, Exercise: Installing Libraries
expression, Types and Expressions
expression statements, Statements
extend, Simple Derivation
Extensible Markup Language, Parsing XML
extraction operator, Strings
operator>>(), Standard Input and Output

H

hard coding, AntiPatterns
hash
cryptographic, Exercises: QProcess and Process Control
hash table, Containers
header file, Class Definitions
heap, Operators new and delete
QObjects with parents , QObject Lifecycle
value types , Values and Objects
variables, storage class, Storage Class
heap corruption, Memory Access
heap objects, qApp and Singleton Pattern
hex
manipulator, Streams
hidden functions from base class
see function hiding, Overloading, Hiding, and Overriding
HOME
bash environment variable, Exercise: Installing Libraries
host object, const Member Functions
Hungarian
notation, Style Guidelines, Naming Conventions

I

icons
standard icons from desktop , Icons, Images and Resources
IDE, Open Source Development Tools, Libraries, IDEs
Qt integration extensions , QtCreator – An IDE for Qt Programming
IDE integration
with designer , QtCreator Integration with Designer
identifier, Identifiers, Types, and Literals
if/else, Selection Statements
images
loading for an application, Icons, Images and Resources
implementation, Encapsulation
implementation relationship
derivation, public, protected, and private derivation
implicit sharing
QVariant , Values and Objects
implicitly shared containers, Flyweight Pattern: Implicitly Shared Classes
include
preprocessor directive, #include: Finding Header Files , The Preprocessor: For #including 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, Simple Derivation
multiple, Widgets and Designer, Multiple Inheritance
multiple, and constructors , Multiple Inheritance Syntax
multiple, and QObject, Q_OBJECT and moc: A checklist
multiple, and qobject_cast, Type Identification and qobject_cast
virtual, virtual Inheritance
inherits(), Type Identification and qobject_cast
initialization
of basic types , C++ Simple Types
order , Constructors, Destructors, and Copy Assignment Operators
initialization list
member , Constructors
inline, inline Functions
and the linker , Common Linker Error Messages
vs macro expansion , Inlining Versus Macro Expansion
input mask, Input Masks
input widget
QComboBox , Widget Categories
QDateEdit , 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
operator<<(), Standard Input and Output
integral promotion, Standard Expression Conversions
Integrated Development Environment, QtCreator – An IDE for Qt Programming , Open Source Development Tools, Libraries, IDEs
interface bloat, AntiPatterns
interface relationship
derivation, public, protected, and private derivation
Interpreter pattern, virtual Pointers, virtual Tables
inversion of control, SAX Parsing
invokeMethod()
QMetaObject , invokeMethod()
iostream, Streams
is-a
public inheritance relationship, public, protected, and private derivation
ISO, A Brief History of C++
iterator
for files and directories, QDir, QFileInfo, QDirIterator
through QMap , Sorted Map Example
various kinds, Iterators
Iterator pattern, Iterators

M

machine language, Libraries and Design Patterns
MacOS
console applications , qmake, Project Files, and Makefile
MacOSX
Makefile, qmake, Project Files, and Makefile
project file, qmake, Project Files, and Makefile
main()
first program , C++ First Example
full signature , main, and Command-Line Arguments
make, qmake, Project Files, and Makefile
make clean
to clean up object files , make and Makefile
make distclean
to clean up all files , make and Makefile
make., qmake, Project Files, and Makefile
Makefile, qmake, Project Files, and Makefile
MacOSX, qmake, Project Files, and Makefile
man
manual pages , C++ First Example
manage
components, Relationships
manage resources, Destructors
manipulator
iostream , Standard Input and Output
manipulators, Standard Input and Output , Streams
map functor
QtConcurrent , Concurrent Map/Reduce Example
mapping layer
from objects to rows in a table , Table Models
mapReduce
QtConcurrent Algorithm , Concurrent Map/Reduce Example
math.h
M_PI, Derivation from an Abstract Base Class
Matrix class, The Function Call operator()
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
Microsoft Developer Studio
integration, QtCreator – An IDE for Qt Programming
MinGW
Minimalist Gnu for Windows , C++/Qt Setup: Win32
moc, Q_OBJECT and moc: A checklist
generates QMetaObject::newInstance, Abstract Factory
modal
dialogs , Dialogs
model, Models and Views
QAbstractItemModel , Widget Categories
QAbstractListModel , Widget Categories
QAbstractTableModel , Widget Categories
Model Testing Tool , Trolltech Model Testing Tool
Model-View-Controller, Model-View-Controller (MVC)
model-view-controller
uml diagram , Qonsole: Writing an Xterm in Qt
models and views
mixing together , AntiPatterns
modifiable lvalue, Reference Variables
module, Libraries and Design Patterns
mono , Frameworks and Components
Monostate pattern
QSettings, QSettings: Saving and Restoring Application State
multiple inheritance, Multiple Inheritance
conflicts, Resolving Multiple Inheritance Conflicts
Multiple Inheritance
with QObject, Multiple Inheritance with QObject
Multitasking , QProcess and Process Control
mutable, const Member Functions
mutex, Thread Safety and QObjects
MVC
Model-View-Controller , Exercises: Layout of Widgets, Model-View-Controller (MVC)
MySQL, Database Programming

O

object, The Unary Operators & and *
an instance of a class, Class Definitions
creation rules, Creational Patterns
definition, Declarations and Definitions
state, Class Definitions
types , Values and Objects
Object Browser
Tree Model , Tree Models
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
Operands, Types and Expressions
operator
conditional, Introduction to Functions
operator overloading, Operator Overloading
operator()
function call operator , The Function Call operator()
operator<<()
insertion operator, Standard Input and Output
operator>>()
extraction operator, Standard Input and Output
operators, Operators
client defined , Operator Overloading
conversion , Conversion Operators
Operators, Types and Expressions
optional arguments, Optional Arguments
Oracle, Database Programming
ordered map, Containers
OS, Libraries and Design Patterns
overloaded operator symbol
, Standard Input and Output
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
parameter name
include, Introduction to Functions
omit, SAX Parsing
parent and child objects, QObject, QApplication, Signals, and Slots
parent process
, main, and Command-Line Arguments
parse event handler, SAX Parsing
passive interface, QApplication and the Event Loop , SAX Parsing
PATH, C++/Qt Setup: Open Source Platforms
Phonon , The Façade Pattern , Phonon/MultiMediaKit Setup
phony targets, make and Makefile
platform, Libraries and Design Patterns
plugin, Benefits of Using Factories
pointer, The Unary Operators & and *
arithmetic , Pointer Arithmetic
to functions , Function Pointers and Functors
pointers
and const, const* and *const
dereferencing, Memory Access Summary
polymorphic type, Derivation with Polymorphism
polymorphism, Derivation with Polymorphism
from constructors , Benefits of Using Factories
POSIX, C++/Qt Setup: Open Source Platforms
post
event, The Event Loop: Revisited
PostgreSQL, Database Programming
prepared statement
QSqlQuery, QSqlDatabase: Connecting to SQL from Qt
preprocessor, Inlining Versus Macro Expansion , The Preprocessor: For #including Files
include directive , #include: Finding Header Files
primitive
types , QVariant Class: Accessing Properties
private, Member Access Specifiers
Private Implementation pattern
, Flyweight Pattern: Implicitly Shared Classes
processEvents()
in long-running loops, The Façade Pattern
QApplication , QThread and QtConcurrent , Concurrent Map/Reduce Example
profiler, Finding Memory Errors
project file, qmake, Project Files, and Makefile
MacOSX, qmake, Project Files, and Makefile
Project Settings
Qt Creator , QtCreator – An IDE for Qt Programming
promotion, Standard Expression Conversions
properties, Memento Pattern
dynamic, Dynamic Properties
fixed, Dynamic Properties
property
getting QObject properties , Q_PROPERTY Macro - Describing QObject Properties
protected, Member Access Specifiers , Simple Derivation
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
pure virtual functions , SAX Parsing

Q

QAbstractItemDelegate , Type Identification and qobject_cast
QAbstractItemModel, Qt Models and Views , Tree Models
QAbstractTableModel
versus QStandardItemModel , Table Models
QAction, QActions, QMenus, and QMenuBars , QActions, QToolbars, and QActionGroups
QAction Editor Table , Table Models
QActionGroup, QActions, QToolbars, and QActionGroups
qApp, main, and Command-Line Arguments
managing heap objects , qApp and Singleton Pattern
pointer to singleton QApplication macro, Creational Patterns
QApplication, Qt Dialogs for User Input/Output
starter of events , QApplication and the Event Loop
QAtomicInt
for reference counting , Flyweight Pattern: Implicitly Shared Classes
QColumnView, Multiple Views
QCOMPARE, QTestLib
QCoreApplication
, main, and Command-Line Arguments
arguments() , main, and Command-Line Arguments
QCryptographicHash, Exercises: QProcess and Process Control
QDate , Streams and Dates
QDateEdit
for restricting input to dates , Validation and Regular Expressions
qDeleteAll() , Containers of Pointers
containers that manage heap memory, Sorted Map Example
QDialog , Dialogs
QDialogButtonBox, Form Layout
QDir, QDir, QFileInfo, QDirIterator
QDirIterator, QDir, QFileInfo, QDirIterator
QEvent, QApplication and the Event Loop
QFileInfo, QDir, QFileInfo, QDirIterator
QFuture , Parallel Prime Number Calculators
QFutureWatcher , Parallel Prime Number Calculators
QIcon
fromTheme , Icons, Images and Resources
QImage
for off-screen images , Icons, Images and Resources
painting on a widget , Paint Events, Drawing Images
QKeySequence
capturing key events , The Event Loop: Revisited
QList , QStringList and iteration
QListView, Multiple Views
QMainWindow
saving and restoring state, QSettings: Saving and Restoring Application State
qmake, qmake, Project Files, and Makefile , Building and Reusing Libraries
when to run it , Q_OBJECT and moc: A checklist
qmake -r
recursive rebuild of Makefiles , #include: Finding Header Files
QMap
iteration , Sorted Map Example
QMenu, QActions, QMenus, and QMenuBars
QMenuBar, QActions, QMenus, and QMenuBars
QMetaObject , QMetaObject - The Meta Object Pattern, Importing Objects with an Abstract Factory
QMetaObject::newInstance()
Abstract Factory Pattern , Abstract Factory
QMetaProperty, Importing Objects with an Abstract Factory
QMetaType, MetaTypes, Declaring and Registering
QModelIndex, Qt Models and Views
QObject, QObject, QApplication, Signals, and Slots
children, QObject, QApplication, Signals, and Slots , Widgets and Designer
non-public copy constructor, QObject, QApplication, Signals, and Slots
thread affinity , Thread Safety and QObjects
QObjectList, QObject, QApplication, Signals, and Slots
QObjectReader , Importing Objects with an Abstract Factory
QObjectWriter , Exporting to XML
qobject_cast, Type Identification and qobject_cast
QPainter
drawImage , Concurrent Map/Reduce Example
on a QWidget , Paint Events, Drawing Images
QPersistentModelIndex, Qt Models and Views
QPixmap
for on-screen images , Icons, Images and Resources
QProcess, Concurrency , QProcess and Process Control
Bidirectional Communication , Qonsole: Writing an Xterm in Qt
qrc files
resource collection file , Icons, Images and Resources
qRegisterMetaType , MetaTypes, Declaring and Registering
qRegisterMetaType()
for cross-thread signal arguments , The Façade Pattern
QRunnable , The Command Pattern
Command Pattern , QThread and QtConcurrent
QScopedPointer, Smarter Pointers
QSettings, QSettings: Saving and Restoring Application State
persistent storage of state data , QSettings: Saving and Restoring Application State
saving shortcuts , Editable Models
QSharedData
for implicit sharing , Flyweight Pattern: Implicitly Shared Classes
QSharedPointer , Smarter Pointers
guarded pointers, Member Selection Operators
QSizePolicy , Size Policy and Size Hint
qSort, Generics, Algorithms, and Operators
QSpinBox
for restricting input to numbers , Validation and Regular Expressions
QSplitter
splitter widget, Multiple Views
QSqlDatabase
an abstraction for a database connection, QSqlDatabase: Connecting to SQL from Qt
QSqlQuery, QSqlDatabase: Connecting to SQL from Qt
QStandardItem, Multiple Views
QStandardItemModel, Multiple Views
QString, Strings , Qt Dialogs for User Input/Output , Derivation and ArgumentList
QStringList, QStringList and iteration , Derivation and ArgumentList , Generics, Algorithms, and Operators
QStyle
standardIcon , Icons, Images and Resources
QStyledItemDelegate , Delegate Classes
Qt, C++/Qt Setup: Open Source Platforms
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
QColor , Widget Categories
QImage , Widget Categories
QPixMap , Widget Categories
QPoint , Widget Categories
QSize , Widget Categories
Qt Mobility, MP3 Jukebox Assignments
Qt MultimediaKit
from Qt Mobility , MP3 Jukebox Assignments
Qt SDK , C++/Qt Setup: Open Source Platforms
QTableView, Qt Models and Views
QtCreator, Open Source Development Tools, Libraries, IDEs
Project Files , QtCreator – An IDE for Qt Programming
qtcreator
included in QtSDK , C++/Qt Setup: Open Source Platforms
integrating Designer .ui forms , QtCreator Integration with Designer
QTDIR
location of the Qt tree , Installing Libraries
QTestLib, QTestLib
QTEST_MAIN , QTestLib
QTextEdit, Qonsole: Writing an Xterm in Qt
QTextStream , Streams and Dates
QThread, Concurrency
low-level implementation , QThread and QtConcurrent
QTimeEdit
editor for QTime , Type Identification and qobject_cast
for restricting input to times , Validation and Regular Expressions
QTimeLine, QThread and QtConcurrent
QTimer, QThread and QtConcurrent
singleShot, The Façade Pattern
QTreeView, Tree Models
QUndoCommand, The Command Pattern
QVariant, Q_PROPERTY Macro - Describing QObject Properties, QVariant Class: Accessing Properties
Serializing to QDataStream , Serializer Pattern: QTextStream and QDataStream
value types , Values and Objects
QVERIFY, QTestLib
QWidget
, Widgets and Designer
QXmlAttributes, SAX Parsing
QXmlContentHandler, SAX Parsing
QXmlDefaultHandler, SAX Parsing, Importing Objects with an Abstract Factory
QXmlReader, SAX Parsing
QXmlSimpleReader, SAX Parsing, Importing Objects with an Abstract Factory
QXmlStreamReader/Writer
Core XML APIs , The Qt XML Parsers , XML Streams
Q_ARG
QGenericArgument , invokeMethod()
Q_DECLARE_METATYPE, MetaTypes, Declaring and Registering
Q_DECL_EXPORT, Common Linker Error Messages
Q_ENUMS
adds a new QVariant type , MetaTypes, Declaring and Registering
for enums macro , Q_PROPERTY Macro - Describing QObject Properties
Q_INTERFACES
and qobject_cast , Type Identification and qobject_cast
Q_INVOKABLE , Abstract Factory
, invokeMethod() , Abstract Factory
Q_OBJECT , Memento Pattern
and class templates , Class Templates
and qmake , Common Linker Error Messages
macro, QMetaObject - The Meta Object Pattern
Q_PROPERTY , Memento Pattern
macro , Q_PROPERTY Macro - Describing QObject Properties

S

SAX parser, Parsing XML , Importing Objects with an Abstract Factory
scientific
manipulator, Streams
scope, Class Definitions , Identifier Scope
block, Member Access Specifiers
class , Class Definitions
resolution operator (::), Class Definitions
SDK
includes QtCreator, QtCreator – An IDE for Qt Programming
Segmentation fault, Pointer Pathology
segmentation faults, Memory Access
findingquickly, gdb Quickstart
SEGV
finding quickly, gdb Quickstart
semaphore, Thread Safety and QObjects
sender()
of a signal , Signals and Slots , QObject Lifecycle
QObject sender of a signal , Parallel Prime Number Calculators
sequential access, Containers
serialization, AntiPatterns
Serializer pattern, Serializer Pattern: QTextStream and QDataStream
setLayout()
reparents widgets , Form Layout
Shadow Builds
in Qt Creator , QtCreator – An IDE for Qt Programming
shared
pointers, Flyweight Pattern: Implicitly Shared Classes
Shortcut Editor
Example , Table Models
showpoint
manipulator, Streams
showpos
manipulator, Streams
signal, Signals and Slots
Singleton
Factory method, qApp and Singleton Pattern
Singleton pattern, Creational Patterns , qApp and Singleton Pattern
sizeof()
operator, C++ Simple Types
skip-list dictionary, Containers
slot, Signals and Slots
slots
multiple signals connected to, Signals and Slots
smart pointer, Member Selection Operators
split, QStringList and iteration
sql
prepared statements , QSqlDatabase: Connecting to SQL from Qt
queries with exec(), QSqlDatabase: Connecting to SQL from Qt
sqlbrowser
qt demo , Database Programming
SQLite, Database Programming
srand(time(0))
a clever way to seed , Exercises: C++ Simple Types
stack
QObjects without parents , QObject Lifecycle
variables, storage class, Storage Class
stack trace, gdb Quickstart
startTimer()
QObject method , The Event Loop: Revisited
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
variables, storage class, Storage Class
static binding, Derivation with Polymorphism
static QObjects
don't do it! , QObject Lifecycle
static_cast, static_cast and const_cast
std::unary_function , Function Pointers and Functors , Concurrent Map/Reduce Example
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
static, The Keyword static
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, 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
switched arguments, Processing Command-Line Arguments
Sybase SQL, Database Programming
symbolic link, QDir, QFileInfo, QDirIterator
symlink, QDir, QFileInfo, QDirIterator

T

table
defining in SQL, QSqlDatabase: Connecting to SQL 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
types, Generics and Templates
template function
findChildren , Composite Pattern: Parents and Children
template parameter, Generics and Templates
Test Framework, QTestLib
Testing
QAbstractItemModel , Trolltech Model Testing Tool
thread-safe, Thread Safety and QObjects
toString(), Class Definitions
tr1
C++ technical report 1 , A Brief History of C++
traits
type information provided via template parameters , Concurrent Map/Reduce Example
tree
models and views, Tree Models
typecast, Type Identification and qobject_cast
explicit conversion, Explicit Conversions
typeid, typeid operator , virtual Pointers, virtual Tables

U

UI
user interface , Models and Views
Ui class
example, integration with code , Designer Integration with Code
uic
Designer .ui interface compiler , Designer Introduction
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
unary function object, Concurrent Map/Reduce Example
undefined
pointer, Further Pointer Pathology with Heap Memory
undefined behavior
different platforms, Valid Pointer Operations
union, QVariant Class: Accessing Properties
unit testing, QTestLib
unordered map, Containers
update()
on a QWidget , Paint Events, Drawing Images
using, C++ First Example
importing namespaces, Namespaces
namespace std , C++ First Example

W

while
loop, Iteration
win32
building qt and libmysql , Exercise: Installing Libraries
window
widget, Widgets and Designer
Windows
console applications , qmake, Project Files, and Makefile
Wrapper pattern, The Façade Pattern
Wt , Frameworks and Components
wxWidgets , Frameworks and Components