By?Kyle Loudon
Book Price: $9.95 USD
£6.95 GBP
PDF Price: $6.99

Cover | Table of Contents | Index | Sample Excerpt

Index

Symbols[ Top ]
-- (postfix decrement operator), 39
-- (prefix decrement operator), 40
- (subtraction operator), 41
! (logical NOT operator), 40
!= operator, 43
& (address-of operator), 41
& (bitwise AND operator), 43
&& (logical AND operator), 44
( ) (value construction operator), 39
* (indirection operator), 41
+ (plus operator), 41
++ (postfix increment operator), 39
++ (prefix increment operator), 40
. (member selection operator), 38
.* operator, 42
:: (scope resolution operator), 37
:? (conditional expression operator), 45
< operator, 43
<< (left shift operator), 43
<= operator, 43
<climits> header file, 13
== operator, 43
-> (member selection operator), 38
> operator, 43
->* operator, 42
>= operator, 43
>> (right shift operator), 43
[ ] (array subscript operator), 38
\ (backslash), 8
^ (bitwise XOR operator), 43
| (bitwise OR operator), 43
|| (logical OR operator), 44
~ (bitwise NOT operator), 40

A[ Top ]
abstract base classes, 94
access levels for members, 78
access specifiers, 78
addition operator (+), 42
address-of operator (&), 41
arithmetic operators, 42
array subscript operator ([ ]), 38
arrays, 19-22
      initializer list for, 21
      initializing with an array, 22
      multidimensional, 20
      passing to functions, 21
assignment operators, 34, 45
      overloading, 107
atof( ) function, 5
auto storage class, 56

B[ Top ]
backslash (\), 8
base classes, 89
      virtual, 97
bitwise AND operator (&), 43
bitwise NOT operator (~), 40
bitwise OR operator (|), 43
bitwise XOR operator (^), 43
break statement, 64

C[ Top ]
C Standard Library, 121
C++ programs
      startup, 3-5
      structure, 3-12
      termination, 5
C++ Standard Library, 120-124
C, compatibility with, 2
catch blocks, 118
cerr object, 124
character escape sequences, 14
character literals, 14
cin object, 122
class scope, 47
class types, 28
classes, 69-86
      storage, 55-56
clog object, 124
clone member function, 108
comments, 32
compound statements, 59
compound types, 17-28
conditional expression operator (:?), 45
const qualifier, 57
const_cast operator, 39, 115
constant data members, 72
constant member functions, 77
constructors, 80-83
      converting, 30
      copy, 81
      default, 81
      explicit, 82
      inheritance and, 89
      member initializers, 83
continue statement, 64
copy constructors, 81
cout object, 123
_ _cplusplus macro, 12
.cpp files, 7
cross casting, 114
C-style cast operator, 42
C-style casting, 112

D[ Top ]
data members
      constant, 72
      declaring, 70-73
      mutable, 73
      static, 71
      volatile, 73
_ _DATE_ _ macro, 11
declarations, 50-58
      forward, 86
      nested, 85
default arguments, 53
#define directive, 6, 8
delete operator, 42, 110
delete[ ] operator, 42, 111
dereferencing pointers, 24, 41
derived classes, 89
destructors, 83
      inheritance and, 90
      virtual, 90
directives, preprocessor, 8-11
division operator (/), 42
do loop, 60
double type, 16
downcasting, 114
dynamic_cast operator, 39, 112-114

E[ Top ]
#elif directive, 9
ellipsis (...) and exception handling, 118
#else directive, 9
enclosing scopes, 49
#endif directive, 6, 9
enum keyword, 18
enumerations, 18
#error directive, 10
escape sequences, 14
exception handling, 117-120
      ellipsis (...) and, 118
exception specifications, 119
exit function, 5
explicit specialization
      of template classes, 100
      of template functions, 102
expression statements, 59
expressions, 46
extern storage class, 56

F[ Top ]
file scope, 48
_ _FILE_ _ macro, 11
float type, 16
floating points, 16
for loops, 61
      break statements and, 64
forward declarations, 86
friends, 79
function call operator, 38
function pointers, 25
functions
      declaring, 52
      definitions, 53
      inline, 54
      overloading, 104
      parameters, 53
      passing arrays to, 21
fundamental types, 12-17

G[ Top ]
global namespaces, 66
goto statement, 65

H[ Top ]
header files, 5-7
      C++ Standard Library, 120
      wrapping, 6

I[ Top ]
I/O streams, 122
identifiers, 32
      rules, 33
#if directive, 9
if statement, 62
#ifdef directive, 9
#ifndef directive, 6, 9
implicit conversions, 29
#include directive, 6, 10
indirection operator (*), 41
inheritance, 88-98
      access levels for, 94
      constructors and, 89
      destructors and, 90
      multiple, 95
initializer list for arrays, 21
inline functions, 54
inline keyword, 54
int type, 15
integers, 15
iteration statements, 60-62

J[ Top ]
jump statements, 64

L[ Top ]
left shift operator (<<), 43
#line directive, 10
_ _LINE_ _ macro, 11
literals, 34
local scope, 47
logical AND operator (&&), 44
logical NOT operator (!), 40
logical OR operator (||), 44
long double type, 16
long type, 15
loops, 60-62
l-values, 28
      references as, 28

M[ Top ]
main( ) function, 3
member access levels, 78
member functions, 74-78
      constant, 77
      static, 76
      this pointer and, 75
      virtual, 91-94
      volatile, 78
member functions and volatile qualifiers, 58
member initializers, 82
member selection operator (. and ->), 38
memory allocation failure, 110
memory management, 108-111
      operators, 108
memory reclamation, 110
message directive, 11
minus operator (-), 41
modulus operator (%), 42
multidimensional arrays, 20
multiple inheritance, 95
multiplication operator (*), 42
mutable data members, 73
mutable storage class, 56

N[ Top ]
namespace scope, 48
namespaces, 66-68
      global, 66
      unnamed, 68
nested declarations, 85
new operator, 42, 108
new[ ] operator, 42, 109
null pointers, 25
null statements, 59

O[ Top ]
.o files, 7
.obj files, 7
objects
      accessing members, 69
      declaring, 69
operators, 34-46
      list of, 35-37
      overloading, 105-108
      precedence, 35
overloading
      defined, 104
      functions, 104
      operators, 105-108

P[ Top ]
parameters, function, 53
plus operator (+), 41
pointer arithmetic, 24
pointer variables, 51
pointers, 24-27
      const declaration, 57
      dereferencing, 24, 41
      function, 25
      null, 25
      of type void, 25
      this, 75
pointers to members, 26
pointer-to-member selection operators (.* and ->*), 42
postfix increment and decrement operators (++, --), 39
#pragma directive, 11
precedence, operator, 35
prefix increment and decrement operators, 40
preprocessor directives, 8-11
preprocessor macros, 11
private members, 78
      inheritance and, 95
protected members, 78
      inheritance and, 95
prototypes, 53
public members, 78
      inheritance and, 95

Q[ Top ]
qualifiers, 57

R[ Top ]
reference parameters, 27
references, 27
      as l-values, 28
register storage class, 56
reinterpret_cast operator, 39, 115
relational operators, 43
reserved words, 33
return statement, 65
right shift operator (>>), 43
RTTI (runtime type information), 115

S[ Top ]
scope resolution operator (::), 37
scopes, 47-50
      class, 47
      enclosing, 49
      file, 48
      local, 47
      namespace, 48
selection statements, 62
sequence operator (,), 46
set_new_handler function, 110
set_terminate function, 119
shift operators, 43
short type, 15
signed integers, 15
sizeof operator, 40
source files, 7
Standard Template Library (STL), 122
statements, 59-65
static data members, 71
static member functions, 76
static storage class, 55
static_cast operator, 39, 115
std namespace, 121
_ _STDC_ _ macro, 12
STL (Standard Template Library), 122
storage classes, 55-56
string literals, 23
strings, 22
strlen function, 23
structs, 86
subtraction operator (-), 42
switch statement, 63

T[ Top ]
template classes, 98-101
      default arguments for, 101
      explicit specialization of, 100
      member functions in, 99
      nontype parameters in, 100
template functions, 101-103
      arguments to, 102
      explicit specialization of, 102
      instantiation of, 102
      nontype parameters in, 103
templates, 98-103
this pointer, 75
throw operator, 46, 117
_ _TIME_ _ macro, 11
_ _TIMESTAMP_ _ macro, 11
tokens, 31
try block, 117
type cast operators, 39
type conversions, 28-30
type definitions, 31
type_info class, 116
typedef keyword, 28, 31
typeid operator, 39, 116
types
      compound, 17-28
      fundamental, 12-17

U[ Top ]
unary minus and plus operators (-, +), 41
#undef directive, 9
unexpected function, 119
unions, 86
unnamed namespaces, 68
unsigned integers, 15
upcasting, 114
user-defined conversions, 29
using declaration, 67
using directives, 67

V[ Top ]
value construction operator, 39
variables
      declarations, 51
      initializing, 52
virtual base classes, 97
virtual destructors, 90
virtual member functions, 91-94
void pointers, 25
void type, 17
volatile data members, 73
volatile member functions, 78
volatile qualifier, 58
      member functions and, 58

W[ Top ]
while loop, 60
wide characters, 23
wrapping header files, 6

Return to C++ Pocket Reference