Introducción a Patrones de Diseño en C++ con Qt4/Índice

Versión para imprimir esta pagina

Index Symbols

  1. ifndef wrapper, The Preprocessor: For #including Files
  2. 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 
   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 

-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 

=

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

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 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 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 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, Organizing Libraries: Dependency Management , The Preprocessor: For #including Files class, Class definitions

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

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

   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 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
   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
   Interpreter pattern, virtual pointers, virtual tables
   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 

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

for

   loop, Iteration 

foreach, QStringList and iteration fork, Summary: QProcess and QThread forward declaration, 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

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

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 

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 

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

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 

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? 

N

namespace, Code Containers, Namespaces

   example , namespace, static objects and extern 

namespace std

   using, C++ First Example

new, Operators new and delete

   failures, What happens if new fails?

noshowpos

   manipulator, Streams 

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 Operands, Types and Expressions operator overloading, Operator Overloading operators, Operators

   client defined , Operator Overloading 

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

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 

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, 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 parameter, Parameter Passing by Reference reference return, Returning References from Functions reflection, Anti-patterns 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 , The Preprocessor: For #including Files 

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 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 smart pointer, Operators new and delete , Member Selection operators split, QStringList and iteration 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

T

table

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

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



Versión para imprimir esta pagina