추가 적립 안내

Preface 1 (1)
What's new in the second edition 2 (1)
What's in Volume 2 of this book 3 (1)
How to get Volume 2 3 (1)
Prerequisites 3 (1)
Learning C++ 4 (1)
Goals 5 (2)
Chapters 7 (5)
Exercises 12 (1)
Exercise solutions 12 (1)
Source code 12 (2)
Language standards 14 (1)
Language support 15 (1)
The book's CD ROM 15 (1)
CD ROMs, seminars, and consulting 16 (1)
Errors 16 (1)
About the cover 17 (1)
Book design and production 18 (1)
Acknowledgements 19 (2)
Introduction to Objects 21 (54)
The progress of abstraction 22 (3)
An object has an interface 25 (3)
The hidden implementation 28 (1)
Reusing the implementation 29 (2)
Inheritance: reusing the interface 31 (6)
Is-a vs. is-like-a relationships 35 (2)
Interchangeable objects with polymorphism 37 (4)
Creating and destroying objects 41 (2)
Exception handling: dealing with errors 43 (1)
Analysis and design 44 (17)
Make a plan 47 (1)
What are we making? 48 (4)
How will we build it? 52 (4)
Build the core 56 (1)
Iterate the use cases 57 (1)
Evolution 58 (2)
Plans pay off 60 (1)
Extreme programming 61 (3)
Write tests first 61 (2)
Pair programming 63 (1)
Why C++ succeeds 64 (4)
A better C 65 (1)
You're already on the learning curve 65 (1)
Efficiency 66 (1)
Systems are easier to express and 66 (1)
understand
Maximal leverage with libraries 67 (1)
Source-code reuse with templates 67 (1)
Error handling 67 (1)
Programming in the large 68 (1)
Strategies for transition 68 (5)
Guidelines 69 (2)
Management obstacles 71 (2)
Summary 73 (2)
Making & Using Objects 75 (36)
The process of language translation 76 (4)
Interpreters 77 (1)
Compilers 77 (2)
The compilation process 79 (1)
Tools for separate compilation 80 (10)
Declarations vs. definitions 81 (6)
Linking 87 (1)
Using libraries 88 (2)
Your first C++ program 90 (6)
Using the iostreams class 90 (1)
Namespaces 91 (2)
Fundamentals of program structure 93 (1)
``Hello, world!'' 94 (1)
Running the compiler 95 (1)
More about iostreams 96 (2)
Character array concatenation 96 (1)
Reading input 97 (1)
Calling other programs 98 (1)
Introducing strings 98 (2)
Reading and writing files 100(2)
Introducing vector 102(6)
Summary 108(1)
Exercises 109(2)
The C in C++ 111(106)
Creating functions 112(5)
Function return values 115(1)
Using the C function library 116(1)
Creating your own libraries with the 117(1)
librarian
Controlling execution 117(10)
True and false 117(1)
if-else 118(1)
while 119(1)
do-while 120(1)
for 121(1)
The break and continue keywords 122(1)
switch 123(2)
Using and misusing goto 125(1)
Recursion 126(1)
Introduction to operators 127(2)
Precedence 127(1)
Auto increment and decrement 128(1)
Introduction to data types 129(14)
Basic built-in types 129(2)
bool, true, & false 131(1)
Specifiers 132(1)
Introduction to pointers 133(4)
Modifying the outside object 137(3)
Introduction to C++ references 140(1)
Pointers and references as modifiers 141(2)
Scoping 143(4)
Defining variables on the fly 145(2)
Specifying storage allocation 147(9)
Global variables 147(2)
Local variables 149(1)
static 149(2)
extern 151(2)
Constants 153(2)
volatile 155(1)
Operators and their use 156(18)
Assignment 156(1)
Mathematical operators 156(2)
Relational operators 158(1)
Logical operators 158(1)
Bitwise operators 159(1)
Shift operators 160(3)
Unary operators 163(1)
The ternary operator 164(1)
The comma operator 165(1)
Common pitfalls when using operators 166(1)
Casting operators 166(1)
C++ explicit casts 167(5)
sizeof - an operator by itself 172(1)
The asm keyword 173(1)
Explicit operators 173(1)
Composite type creation 174(19)
Aliasing names with typedef 174(1)
Combining variables with struct 175(4)
Clarifying programs with enum 179(2)
Saving memory with union 181(1)
Arrays 182(11)
Debugging hints 193(5)
Debugging flags 194(2)
Turning variables and expressions into 196(1)
strings
The C assert( ) macro 197(1)
Function addresses 198(4)
Defining a function pointer 198(1)
Complicated declarations & definitions 199(1)
Using a function pointer 200(1)
Arrays of pointers to functions 201(1)
Make: managing separate compilation 202(8)
Make activities 204(3)
Makefiles in this book 207(1)
An example makefile 208(2)
Summary 210(1)
Exercises 210(7)
Data Abstraction 217(42)
A tiny C-like library 219(10)
Dynamic storage allocation 223(4)
Bad guesses 227(2)
What's wrong? 229(1)
The basic object 230(8)
What's an object? 238(1)
Abstract data typing 239(1)
Object details 240(1)
Header file etiquette 241(7)
Importance of header files 242(2)
The multiple-declaration problem 244(1)
The preprocessor directives #define, 245(1)
#ifdef, and #endif
A standard for header files 246(1)
Namespaces in headers 247(1)
Using headers in projects 248(1)
Nested structures 248(5)
Global scope resolution 253(1)
Summary 253(1)
Exercises 254(5)
Hiding the Implementation 259(24)
Setting limits 260(1)
C++ access control 261(2)
protected 263(1)
Friends 263(6)
Nested friends 266(3)
Is it pure? 269(1)
Object layout 269(1)
The class 270(5)
Modifying Stash to use access control 273(1)
Modifying Stack to use access control 274(1)
Handle classes 275(4)
Hiding the implementation 276(1)
Reducing recompilation 276(3)
Summary 279(1)
Exercises 280(3)
Initialization & Cleanup 283(26)
Guaranteed initialization with the 285(2)
constructor
Guaranteed cleanup with the destructor 287(2)
Elimination of the definition block 289(5)
for loops 291(1)
Storage allocation 292(2)
Stash with constructors and destructors 294(4)
Stack with constructors & destructors 298(3)
Aggregate initialization 301(3)
Default constructors 304(1)
Summary 305(1)
Exercises 306(3)
Function Overloading & Default Arguments 309(24)
More name decoration 311(3)
Overloading on return values 312(1)
Type-safe linkage 313(1)
Overloading example 314(4)
unions 318(3)
Default arguments 321(3)
Placeholder arguments 323(1)
Choosing overloading vs. default arguments 324(5)
Summary 329(1)
Exercises 330(3)
Constants 333(38)
Value substitution 334(6)
const in header files 335(1)
Safety consts 336(1)
Aggregates 337(1)
Differences with C 338(2)
Pointers 340(4)
Pointer to const 340(1)
const pointer 341(2)
Assignment and type checking 343(1)
Function arguments & return values 344(8)
Passing by const value 344(1)
Returning by const value 345(4)
Passing and returning addresses 349(3)
Classes 352(13)
const in classes 353(3)
Compile-time constants in classes 356(3)
const objects & member functions 359(6)
volatile 365(2)
Summary 367(1)
Exercises 367(4)
Inline Functions 371(34)
Preprocessor pitfalls 372(5)
Macros and access 376(1)
Inline functions 377(8)
Inlines inside classes 378(1)
Access functions 379(6)
Stash & Stack with inlines 385(5)
Inlines & the compiler 390(3)
Limitations 390(1)
Forward references 391(1)
Hidden activities in constructors & 392(1)
destructors
Reducing clutter 393(2)
More preprocessor features 395(1)
Token pasting 396(1)
Improved error checking 396(4)
Summary 400(1)
Exercises 400(5)
Name Control 405(44)
Static elements from C 406(8)
static variables inside functions 406(6)
Controlling linkage 412(2)
Other storage class specifiers 414(1)
Namespaces

Thinking in C++ is an introduction to the standard C++ Containers, and gives the reader a solid background in the fundamentals of C++. It goes step-by-step through the features of the language and is illustrated by clear direct examples.