Index

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

F

Façade pattern, The Façade Pattern

Factory method, Creational Patterns

example , Generation of XML with DOM

field, First, There Was struct

file

scope, Identifier Scope

file scope

and static globals, Default Scope of Identifiers - More Detail

fixed

manipulator, Streams

flush

manipulator , Streams

Flyweight pattern, Flyweight Pattern: Implicitly Shared Classes

folder, QDir, QFileInfo, QDirIterator

for

loop, Iteration

foreach, QStringList and iteration

forward declaration, Class Declarations and Definitions , The Preprocessor: For #including Files

framework, Frameworks and Components

friend, Friends of a Class

declaration , Friends of a Class

function

declaration, Functions
definition, Declarations and Definitions
hiding of base class functions, Overloading, Hiding, and Overriding
overloading, Introduction to Functions, Overloading Functions , Overloading, Hiding, and Overriding
prototype, Functions
scope, Identifier Scope
signature, Introduction to Functions, Overloading Functions

functional

C++ tr1 header , Function Pointers and Functors

functor , Function Pointers and Functors

for QtConcurrent algorithms , The Façade Pattern
in concurrent algorithms , Concurrent Map/Reduce Example
std::unary_function, Parallel Prime Number Calculators

G

g++

compiler command, C++ First Example

Gang of Four, The Command Pattern

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: Standard Input and Output

global

scope, Identifier Scope

global namespace

pollution, The Keyword static

GNU debugger, gdb Quickstart

God object, AntiPatterns

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

J

join, QStringList and iteration

K

keywords, C++ Reserved Keywords

L

label

of case, Selection Statements

labels

function scope , Identifier Scope

layout, 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, Installing Libraries , C++/Qt Setup: Open Source Platforms

*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, Libraries and Design Patterns , Abstract Factories and Libraries

LIBS

qmake variable , Building and Reusing Libraries

Life

Conway's Game of , Paint Events, Drawing Images , Concurrent Map/Reduce Example

list

QList, Introduction to Containers

literal, Identifiers, Types, and Literals

logical operators, Evaluation of Logical Expressions

loop, Iteration

infinite, Iteration

lvalue, Reference Variables

modifiable value, Returning References from Functions

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

N

namespace, C++ First Example, Libraries and Design Patterns , Namespaces

alias, Namespaces
scope, Identifier Scope

namespace std

using, C++ First Example

Navigability, Relationships Summary

new, Operators new and delete

nothrow, Arrays and Memory: Important Points

newInstance()

QMetaObject factory method for QObjects. , Creational Patterns

new[] , Arrays and Memory: Important Points

for dynamic arrays , Introduction to Arrays

noshowpos

manipulator, Streams

nothrow

new(nothrow) , Arrays and Memory: Important Points

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

R

rand()

from cstdlib, Exercises: C++ Simple Types

random access, Containers

rcc

resource compiler , Icons, Images and Resources

readLine()

QTextStream, Strings

reduce function

QtConcurrent , Concurrent Map/Reduce Example

reentrant , Thread Safety and QObjects

refactoring, Simple Derivation

reference, Reference Variables

reference parameter, Parameter Passing by Reference

reference return, Returning References from Functions

reflection, AntiPatterns

Reflection pattern, QMetaObject - The Meta Object Pattern

register

variables, storage class, Storage Class

regular expression, Regular Expressions

meta character, Regular Expression Syntax

reinterpret_cast , MetaTypes, Declaring and Registering , reinterpret_cast

reinventing the wheel, AntiPatterns

relationship

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

repaint()

on a QWidget , Paint Events, Drawing Images

repeated code, Simple Derivation

resource sharing, Flyweight Pattern: Implicitly Shared Classes

resources, Destructors

RESOURCES, Icons, Images and Resources

roles

and model data , Model-View-Controller (MVC)

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

V

valgrind, Finding Memory Errors

value

types, Values and Objects

value type, Containers

value types , Q_PROPERTY Macro - Describing QObject Properties

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, Models and Views

virtual

base class, virtual Inheritance , virtual Base Classes
destructor , Polymorphism and virtual Destructors
function, Derivation with Polymorphism
inheritance, virtual Inheritance
method calls from constructors and destructors , Derivation with Polymorphism
pointers, virtual Pointers, virtual Tables
tables, virtual Pointers, virtual Tables

visibility, Member Access Specifiers

visible

scope, Class Definitions

void, C++ Simple Types

volatile

correctness , Thread Safety and QObjects
modifier of values and pointers , const* and *const

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

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

X

X3J16, A Brief History of C++

xcode

integration, QtCreator – An IDE for Qt Programming

xlobject

signals and slots , Points of Departure

XML, Parsing XML

XML parser, SAX Parsing

xmllint, Parsing XML


Bibliography		Production