Thinking In C++. Volume 2: Practical Programming

set_terminate( ) · 46

set_unexpected( ) · 63; exception handling · 63

setChanged( ) · 702

setf( ), iostreams · 215, 244

setjmp( ) · 35

setPriority( ) · 740

signal( ) · 34, 76, 764

signal( ), threading · 772

simulating virtual constructors · 691

Singleton · 665; and ZThreads library (concurrency) · 758; implemented with Curiously Recurring Template Pattern · 670; Meyers’ Singleton · 669

sleep( ) · 764; threading · 736

slicing: object slicing and exception handling · 42

Smalltalk · 622

specification: exception · 62

stack unwinding · 38

standard: Standard C · 25; Standard C++ · 25

Standard C++ libraries: string class · 182

Standard C++ library: standard library exception types · 58

standard template library: set class example · 475

stdio · 176

STDIO.H · 195

stream · 182; output formatting · 214

streambuf · 201; and get( ) · 202

streampos, moving · 203

string: Standard C++ library string class · 182; transforming character strings to typed values · 209

stringizing, preprocessor · 222

strstream · 207

structural design patterns · 672

subobject: duplicate subobjects in multiple inheritance · 635

subtasks · 719

synchronization: (concurrency) example of problem from lack of synchronization · 762; and blocking · 765

synchronization, thread · 748

Synchronization_Exception (Concurrency) · 731

Synchronization_Exception, in ZThread library · 727

synchronized: threading, wrapper for an entire class · 753

SynchronousExecutor (Concurrency) · 733

T

task: defining for threading · 724

tellg( ) · 204

tellp( ) · 204

template: and run-time type identification · 610; function templates · 279

temporary: object · 234

terminate( ) · 46, 65; uncaught exceptions · 45

terminating threads · 765

termination: vs. resumption, exception handling · 41

termination problem, concurrency · 757

thread · 719; atomic operation · 763; blocked · 764; blocking and mutexes · 767; broadcast( ) · 765, 773, 787; busy wait · 762, 773; Cancelable class from ZThread libaray · 746; colliding over resources, improperly accessing shared resources · 744; Condition class for wait() and signal() · 772; cooperation · 771; dead state · 764; deadlock · 750, 795; deadlock, and priorities · 738; dining philosophers · 795; drawbacks · 803; example of problem from lack of synchronization · 762; getPriority( ) · 739; handshaking between tasks · 772; I/O and threads, blocking · 767; interrupt( ) · 765; interrupted status · 769; Interrupted_Exception · 769; iostreams and colliding output · 757; memory management · 740; multiple, for problem-solving · 772; mutex, for handshaking · 772; mutex, simplifying with the Guard template · 750; new state · 764; order of task shutdown · 746; order of thread execution · 737; priority · 738; producer-consumer · 777; queues solve problems · 781; race condition · 746; reference counting · 741; reference-counting with CountedPtr · 743; runnable state · 764; serialization · 781; setPriority( ) · 740; sharing resources · 740; signal( ) · 764, 772; sleep( ) · 736, 764; states · 764; synchronization · 748; synchronization and blocking · 765; synchronized wrapper for an entire class · 753; termination · 765; termination problem · 757; thread local storage · 754; threads and efficiency · 721; TQueue, solving threading problems with · 781; wait( ) · 764, 772; when to use threads · 803; yield( ) · 734; ZThread FastMutex · 761

thread object, concurrency · 726

thread, and concurrency · 719

ThreadedExecutor (Concurrency) · 731

throughput, optimize · 720

throw · 37, 38

throwing an exception · 37

TQueue, solving threading problems with · 781

transforming character strings to typed values · 209

try · 38; Function-level try blocks · 56

try block · 38; function-level · 56

type: automatic type conversions and exception handling · 42; run-time type identification (RTTI) · 599

typeid( ): difference between dynamic_cast and typeid( ), run-time type identification · 609

typeinfo: structure · 619

U

ULONG_MAX · 234

uncaught exceptions · 45

uncaught_exception( ) · 75

unexpected( ) · 63

Unix · 234

Urlocker, Zack · 660

user interface: responsive, with threading · 720, 728

V

value: transforming character strings to typed values · 209

Van Rossum, Guido · 804

variable: variable argument list · 181

vector of change · 664

virtual: simulating virtual constructors · 691; virtual functions inside constructors · 692

visitor pattern · 714

void: void pointers and run-time type identification · 609

VPTR · 692

VTABLE · 692; and run-time type identification · 619

W

wait( ), threading · 764, 772

web servers, multiprocessor · 721

wrapping, class · 176

write( ) · 191

ws · 225

Y

yield( ), threading · 734

Z

ZThread: Cancelable class · 746; Executors · 731; installing the library · 723; multithreading library for C++ · 722

[ ]

[ ]

^[1] You might be surprised when you run the example—some C++ compilers have extended longjmp( ) to clean up objects on the stack. This behavior is not portable.

^[2] Visual Basic supports a limited form of resumptive exception handling with its ON ERROR facility.