Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

&= operator, Uninitialized Boolean
() operator, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays
++ operator, Uninitialized Boolean
< operator, How to Write Consistent Comparison Operators, How to Write Consistent Comparison Operators, How to Write Consistent Comparison Operators
<< operator, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime, Dynamic Arrays, Static Arrays, Static Arrays, Multidimensional Arrays, Multidimensional Arrays, Uninitialized Boolean
<= operator, How to Write Consistent Comparison Operators
[] operator, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays, Multidimensional Arrays, Pointer Arithmetic, Invalid Pointers, References, and Iterators
_DEBUG symbol, Debug-On-Error Strategy, Making Your Code Debugger-Friendly
|= operator, Uninitialized Boolean

A

arrays, Dynamic Arrays–Dynamic Arrays, Dynamic Arrays, Static Arrays–Static Arrays, Multidimensional Arrays–Multidimensional Arrays
dynamic, Dynamic Arrays–Dynamic Arrays
index for, Dynamic Arrays
multidimensional, Multidimensional Arrays–Multidimensional Arrays
static, Static Arrays–Static Arrays
assignment operators, avoiding, Copy Constructors and Assignment Operators–Copy Constructors and Assignment Operators
at() function, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays

B

Base() class, Dynamic Arrays
begin() method, Static Arrays, Invalid Pointers, References, and Iterators, Invalid Pointers, References, and Iterators
bool type, The Proper Way to Handle Types, Uninitialized Boolean–Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Conclusion, Conclusion
boost library, Memory Leaks
buffer overflows, and standard C libraries, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries
bugs, Where Do C++ Bugs Come From? (see errors)
built-in type, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.)

C

C libraries, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries, Conclusion
errors when using, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries
functions from, Conclusion
C++ language, Preface–Preface, Preface–Preface, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?
goals when writing code in, Preface–Preface
memory allocation in, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?
problems inherited from C, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?
why unsafe, Preface–Preface
calloc() function, Where Do C++ Bugs Come From?, Where Do C++ Bugs Come From?, Index Out of Bounds
cerr statement, Debug-On-Error Strategy
char type, The Proper Way to Handle Types
circular references, Memory Leaks
classes, The Proper Way to Handle Types–The Proper Way to Handle Types, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.), General Testing Principles–General Testing Principles
multiple, testing, General Testing Principles–General Testing Principles
using for class data members, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.)
varying for different data types, The Proper Way to Handle Types–The Proper Way to Handle Types
code in destructors, avoiding, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
CompareTo() function, How to Write Consistent Comparison Operators, Conclusion
comparison operators, consistent, How to Write Consistent Comparison Operators–How to Write Consistent Comparison Operators
compiling, catching bugs when, Why the Compiler Is Your Best Place to Catch Bugs–Why the Compiler Is Your Best Place to Catch Bugs
const pointer, Memory Leaks, Memory Leaks, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Conclusion
conventions for naming in code, Naming Conventions–Naming Conventions
conversion operators, The Proper Way to Handle Types–The Proper Way to Handle Types
copy constructors, avoiding, Copy Constructors and Assignment Operators–Copy Constructors and Assignment Operators
core dumps, Dereferencing NULL Pointers, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries
crashes, Dereferencing NULL Pointers, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries

D

Date class, The Proper Way to Handle Types, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly
debugging, Where Do C++ Bugs Come From?, Where Do C++ Bugs Come From?, Debug-On-Error Strategy–Debug-On-Error Strategy, Making Your Code Debugger-Friendly–Making Your Code Debugger-Friendly
(see also errors)
(see also sanity checks)
and code writing, Making Your Code Debugger-Friendly–Making Your Code Debugger-Friendly
debug-on-error strategy, Debug-On-Error Strategy–Debug-On-Error Strategy
delete operator, Where Do C++ Bugs Come From?, Where Do C++ Bugs Come From?, Dynamic Arrays, Static Arrays, Static Arrays, Static Arrays, Multidimensional Arrays, Memory Leaks, Memory Leaks, Memory Leaks, Scoped Pointers, Enforcing Ownership with Smart Pointers, Enforcing Ownership with Smart Pointers, Conclusion
delete [] (delete with brackets), Where Do C++ Bugs Come From?, Memory Leaks, Scoped Pointers
dereferencing NULL pointers, Dereferencing NULL Pointers–Dereferencing NULL Pointers
Derived() destructor, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays
destructors, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
avoiding code in, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
Derived() destructor, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays
empty, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
double type, The Proper Way to Handle Types, Pointer Arithmetic, Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Conclusion, Conclusion
dynamic arrays, Dynamic Arrays–Dynamic Arrays

E

empty destructors, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
end() method, Static Arrays
enum type, The Proper Way to Handle Types–The Proper Way to Handle Types, What to Do When We Encounter an Error at Runtime, Conclusion
errors, Where Do C++ Bugs Come From?, Why the Compiler Is Your Best Place to Catch Bugs–Why the Compiler Is Your Best Place to Catch Bugs, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays, Static Arrays, Multidimensional Arrays–Multidimensional Arrays, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries, Debug-On-Error Strategy–Debug-On-Error Strategy, Making Your Code Debugger-Friendly–Making Your Code Debugger-Friendly
(see also sanity checks)
at runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
catching at compile, Why the Compiler Is Your Best Place to Catch Bugs–Why the Compiler Is Your Best Place to Catch Bugs, The Proper Way to Handle Types–The Proper Way to Handle Types
debugging, Debug-On-Error Strategy–Debug-On-Error Strategy, Making Your Code Debugger-Friendly–Making Your Code Debugger-Friendly
and code writing, Making Your Code Debugger-Friendly–Making Your Code Debugger-Friendly
debug-on-error strategy, Debug-On-Error Strategy–Debug-On-Error Strategy
handling, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
index-out-of-bounds, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays, Static Arrays, Multidimensional Arrays–Multidimensional Arrays
and dynamic arrays, Dynamic Arrays–Dynamic Arrays
and multidimensional arrays, Multidimensional Arrays–Multidimensional Arrays
and static arrays, Static Arrays–Static Arrays
diagnosis of by Visual Studio, Static Arrays
types of, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
when using C libraries, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries
with types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types
different classes for different data types, The Proper Way to Handle Types–The Proper Way to Handle Types
implicit type conversions, The Proper Way to Handle Types–The Proper Way to Handle Types
using enum to create new types, The Proper Way to Handle Types–The Proper Way to Handle Types
explicit keyword, The Proper Way to Handle Types, The Proper Way to Handle Types, The Proper Way to Handle Types, The Proper Way to Handle Types, Initialized Numbers (int, double, etc.), Conclusion

F

float type, Initialized Numbers (int, double, etc.)
free() function, Where Do C++ Bugs Come From?
functions, passing parameters to, Uninitialized Boolean–Uninitialized Boolean

H

hash maps, General Testing Principles
hash sets, General Testing Principles
hash_map container, Invalid Pointers, References, and Iterators
hash_set container, Invalid Pointers, References, and Iterators

I

implicit type conversions, The Proper Way to Handle Types–The Proper Way to Handle Types
index of array, Dynamic Arrays
index-out-of-bounds errors, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays, Static Arrays, Multidimensional Arrays–Multidimensional Arrays
and dynamic arrays, Dynamic Arrays–Dynamic Arrays
and multidimensional arrays, Multidimensional Arrays–Multidimensional Arrays
and static arrays, Static Arrays–Static Arrays
diagnosis of by Visual Studio, Static Arrays
init_value argument, Multidimensional Arrays
int type, The Proper Way to Handle Types, The Proper Way to Handle Types, Pointer Arithmetic, Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Scoped Pointers, Conclusion, Conclusion, Conclusion
iterators, invalid, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators

M

macros, using with sanity checks, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
malloc() function, Where Do C++ Bugs Come From?, Where Do C++ Bugs Come From?, Index Out of Bounds, Memory Leaks
matrices, two-dimensional, Multidimensional Arrays–Multidimensional Arrays
memory allocation, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?
memory leaks, Memory Leaks–Memory Leaks, Reference Counting Pointers–Reference Counting Pointers, Scoped Pointers–Scoped Pointers, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers
and reference counting pointers, Reference Counting Pointers–Reference Counting Pointers
and scoped pointers, Scoped Pointers–Scoped Pointers
avoiding with smart pointers, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers
defined, Memory Leaks–Memory Leaks
multidimensional arrays, Multidimensional Arrays–Multidimensional Arrays
Mutex object, Enforcing Ownership with Smart Pointers

N

n-dimensional arrays, Multidimensional Arrays–Multidimensional Arrays
naming conventions, Naming Conventions–Naming Conventions
new operator, Where Do C++ Bugs Come From?, Static Arrays, Static Arrays, Static Arrays, Static Arrays, Static Arrays, Multidimensional Arrays, Memory Leaks, Memory Leaks, Reference Counting Pointers, Scoped Pointers, Enforcing Ownership with Smart Pointers, Enforcing Ownership with Smart Pointers, Conclusion, Conclusion
new[] operator, Enforcing Ownership with Smart Pointers
NULL pointers, dereferencing, Dereferencing NULL Pointers–Dereferencing NULL Pointers

O

objects, ownership of, Memory Leaks, Enforcing Ownership with Smart Pointers
operator=, Dereferencing NULL Pointers, Dereferencing NULL Pointers
ostringstream class, Conclusion (see std::ostringstream)
out_of_range exception, Dynamic Arrays
ownership of objects, Memory Leaks, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers

P

parameters, passing to functions, Uninitialized Boolean–Uninitialized Boolean
permanent macros, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
pointers, Pointer Arithmetic–Pointer Arithmetic, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators, Memory Leaks–Memory Leaks, Reference Counting Pointers–Reference Counting Pointers, Scoped Pointers–Scoped Pointers, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers, Dereferencing NULL Pointers–Dereferencing NULL Pointers, Dereferencing NULL Pointers–Dereferencing NULL Pointers, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
invalid, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators
NULL pointers, dereferencing, Dereferencing NULL Pointers–Dereferencing NULL Pointers
pointer arithmetic, Pointer Arithmetic–Pointer Arithmetic
reference counting pointers, Reference Counting Pointers–Reference Counting Pointers
scoped pointers, Scoped Pointers–Scoped Pointers
semi-smart pointers, Dereferencing NULL Pointers–Dereferencing NULL Pointers
smart pointers, Memory Leaks–Memory Leaks, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
porting from C, Where Do C++ Bugs Come From?–Where Do C++ Bugs Come From?
program crashes, Dereferencing NULL Pointers, Errors When Using Standard C Libraries–Errors When Using Standard C Libraries
Ptr<T> class, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Conclusion

R

references, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators, Memory Leaks, Reference Counting Pointers–Reference Counting Pointers
circular, Memory Leaks
invalid, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators
reference counting pointers, Reference Counting Pointers–Reference Counting Pointers
Release() method, Enforcing Ownership with Smart Pointers
return statement, Memory Leaks, Memory Leaks
Ritchie, Dennis, Where Do C++ Bugs Come From?
Run() method, Memory Leaks
runtime, errors at, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime

S

sanity checks, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, Dynamic Arrays–Dynamic Arrays, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors, Debug-On-Error Strategy
defined, What to Do When We Encounter an Error at Runtime
in debug mode, Debug-On-Error Strategy
leaving active in code, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
speeding up, Dynamic Arrays–Dynamic Arrays
using smart pointers, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
using temporary vs. permanent macros with, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
when to write, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
scoped pointers, Scoped Pointers–Scoped Pointers
scpp::array class, Naming Conventions, Multidimensional Arrays, Conclusion
scpp::matrix class, Naming Conventions, Multidimensional Arrays, Conclusion
scpp::vector class, Naming Conventions, Naming Conventions, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays
scpp::vector::operator[], Dynamic Arrays
scpp:vector class, Multidimensional Arrays, Conclusion
scpp_array.hpp, Source Code for the file scpp_array.hpp–Source Code for the file scpp_array.hpp
SCPP_ASSERT macro, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime
scpp_assert.cpp, Source Code for the files scpp_assert.hpp and scpp_assert.cpp–Source Code for the files scpp_assert.hpp and scpp_assert.cpp
scpp_assert.hpp, Source Code for the files scpp_assert.hpp and scpp_assert.cpp–Source Code for the files scpp_assert.hpp and scpp_assert.cpp
SCPP_AssertErrorHandler() function, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime
scpp_date.cpp, Source Code for the file scpp_date.hpp and scpp_date.cpp–Source Code for the file scpp_date.hpp and scpp_date.cpp
scpp_date.hpp, Source Code for the file scpp_date.hpp and scpp_date.cpp–Source Code for the file scpp_date.hpp and scpp_date.cpp
SCPP_DEFINE_COMPARISON_OPERATORS macro, How to Write Consistent Comparison Operators, How to Write Consistent Comparison Operators, Conclusion
scpp_matrix.hpp, Source Code for the file scpp_matrix.hpp–Source Code for the file scpp_matrix.hpp
scpp_ptr.hpp, Source Code for the file scpp_ptr.hpp–Source Code for the file scpp_ptr.hpp
scpp_refcountptr.hpp, Source Code for the file scpp_refcountptr.hpp–Source Code for the file scpp_refcountptr.hpp
scpp_scopedptr.hpp, Source Code for the file scpp_scopedptr.hpp–Source Code for the file scpp_scopedptr.hpp
SCPP_TEST_ASSERT macro, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Static Arrays, Debug-On-Error Strategy, Debug-On-Error Strategy
SCPP_TEST_ASSERT_INDEX_OUT_OF_BOUNDS macro, Dynamic Arrays, Dynamic Arrays
SCPP_TEST_ASSERT_ON macro, Dynamic Arrays
SCPP_THROW_EXCEPTION_ON_BUG macro, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime
scpp_types.hpp, Source Code for the file scpp_types.hpp–Source Code for the file scpp_types.hpp
scpp_vector.hpp, Source Code for the file scpp_vector.hpp–Source Code for the file scpp_vector.hpp
semi-smart pointers, Dereferencing NULL Pointers–Dereferencing NULL Pointers
size() function, Errors When Using Standard C Libraries
smart pointers, Memory Leaks–Memory Leaks, Enforcing Ownership with Smart Pointers–Enforcing Ownership with Smart Pointers, Avoid Writing Code in Destructors–Avoid Writing Code in Destructors
sprintf() function, Errors When Using Standard C Libraries
static arrays, Static Arrays–Static Arrays
std::ostringstream class, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime, Errors When Using Standard C Libraries, Conclusion
std::string class, The Proper Way to Handle Types, Initialized Numbers (int, double, etc.), Initialized Numbers (int, double, etc.), Errors When Using Standard C Libraries, Errors When Using Standard C Libraries, Conclusion
std::vector class, Naming Conventions, Naming Conventions, Dynamic Arrays, Dynamic Arrays, Dynamic Arrays, Multidimensional Arrays, Conclusion
STL containers, Invalid Pointers, References, and Iterators, Making Your Code Debugger-Friendly, Making Your Code Debugger-Friendly
strcat() function, Errors When Using Standard C Libraries, Errors When Using Standard C Libraries
strcpy() function, Errors When Using Standard C Libraries
string class, Conclusion (see std::string class)
strlen() function, Errors When Using Standard C Libraries, Errors When Using Standard C Libraries
strncat() function, Errors When Using Standard C Libraries, Errors When Using Standard C Libraries
Stroustrup, Bjarne, Where Do C++ Bugs Come From?

T

T* pointer, Multidimensional Arrays, Reference Counting Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Dereferencing NULL Pointers, Conclusion
template vector, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays
temporary macros, What to Do When We Encounter an Error at Runtime, What to Do When We Encounter an Error at Runtime–What to Do When We Encounter an Error at Runtime
testing, principles for, General Testing Principles–General Testing Principles
three-dimensional arrays, Multidimensional Arrays–Multidimensional Arrays
throw statement, Debug-On-Error Strategy
Time class, The Proper Way to Handle Types, The Proper Way to Handle Types, The Proper Way to Handle Types, The Proper Way to Handle Types
try-catch statements, Memory Leaks
two-dimensional matrices, Multidimensional Arrays–Multidimensional Arrays
types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, The Proper Way to Handle Types–The Proper Way to Handle Types, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.)
built-in, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.)
different classes for different data types, The Proper Way to Handle Types–The Proper Way to Handle Types
implicit type conversions, The Proper Way to Handle Types–The Proper Way to Handle Types
using enum to create new types, The Proper Way to Handle Types–The Proper Way to Handle Types

U

uninitialized variables, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.), Uninitialized Boolean–Uninitialized Boolean
bool type, Uninitialized Boolean–Uninitialized Boolean
numbers, Initialized Numbers (int, double, etc.)–Initialized Numbers (int, double, etc.)
unsigned type, Initialized Numbers (int, double, etc.), Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Uninitialized Boolean, Conclusion, Conclusion

V

Variant class, How to Catch Bugs in the Compiler, How to Catch Bugs in the Compiler, How to Catch Bugs in the Compiler, How to Catch Bugs in the Compiler, How to Catch Bugs in the Compiler, How to Catch Bugs in the Compiler, The Proper Way to Handle Types
vectors, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators
adding too many elements to, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators
pointers, references, iterators pointing to elements of, Invalid Pointers, References, and Iterators–Invalid Pointers, References, and Iterators
template vector, Dynamic Arrays–Dynamic Arrays, Static Arrays–Static Arrays
Visual Studio, Static Arrays, Making Your Code Debugger-Friendly
diagnosis of index-out-of-bounds errors by, Static Arrays
STL containers in debugger, Making Your Code Debugger-Friendly
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.15.22.160