**A Complete Guide to Programming in C++**

Hidden Content:

[HIDDEN CONTENT]

**Chapter 1 Fundamentals **

Development and Properties of C++ 2

Object-Oriented Programming 4

Developing a C++ Program 6

A Beginner’s C++ Program 8

Structure of Simple C++ Programs 10

Exercises 12

Solutions 14

**Chapter 2 Fundamental Types, Constants, and Variables 15**

Fundamental Types 16

Constants 22

Escape Sequences 26

Names 28

Variables 30

The Keywords const and volatile 32

Exercises 34

Solutions 36

contents

**Chapter 3 Using Functions and Classes 39**

Declaring Functions 40

Function Calls 42

Type void for Functions 44

Header Files 46

Standard Header Files 48

Using Standard Classes 50

Exercises 52

Solutions 54

**Chapter 4 Input and Output with Streams 57**

Streams 58

Formatting and Manipulators 60

Formatted Output of Integers 62

Formatted Output of Floating-Point Numbers 64

Output in Fields 66

Output of Characters, Strings, and Boolean Values 68

Formatted Input 70

Formatted Input of Numbers 72

Unformatted Input/Output 74

Exercises 76

Solutions 78

**Chapter 5 Operators for Fundamental Types 81**

Binary Arithmetic Operators 82

Unary Arithmetic Operators 84

Assignments 86

Relational Operators 88

Logical Operators 90

Exercises 92

Solutions 94

**Chapter 6 Control Flow 95**

The while Statement 96

The for Statement 98

The do-while Statement 102

Selections with if-else 104

Else-if Chains 106

Conditional Expressions 108

Selecting with switch 110

Jumps with break, continue, and goto 112

Exercises 114

Solutions 116

xii ■ CONTENTS

**Chapter 7 Symbolic Constants and Macros 119**

Macros 120

Macros with Parameters 122

Working with the #define Directive 124

Conditional Inclusion 126

Standard Macros for Character Manipulation 128

Redirecting Standard Input and Output 130

Exercises 132

Solutions 134

**Chapter 8 Converting Arithmetic Types 139**

Implicit Type Conversions 140

Performing Usual Arithmetic Type Conversions 142

Implicit Type Conversions in Assignments 144

More Type Conversions 146

Exercises 148

Solutions 150

**Chapter 9 The Standard Class string 153**

Defining and Assigning Strings 154

Concatenating Strings 156

Comparing Strings 158

Inserting and Erasing in Strings 160

Searching and Replacing in Strings 162

Accessing Characters in Strings 164

Exercises 166

Solutions 168

**Chapter 10 Functions 171**

Significance of Functions in C++ 172

Defining Functions 174

Return Value of Functions 176

Passing Arguments 178

Inline Functions 180

Default Arguments 182

Overloading Functions 184

Recursive Functions 186

Exercises 188

Solutions 191

**Chapter 11 Storage Classes and Namespaces 197**

Storage Classes of Objects 198

The Storage Class extern 200

CONTENTS ■ xiii

The Storage Class static 202

The Specifiers auto and register 204

The Storage Classes of Functions 206

Namespaces 208

The Keyword using 210

Exercises 212

Solutions 216

**Chapter 12 References and Pointers 221**

Defining References 222

References as Parameters 224

References as Return Value 226

Expressions with Reference Type 228

Defining Pointers 230

The Indirection Operator 232

Pointers as Parameters 234

Exercises 236

Solutions 238

**Chapter 13 Defining Classes 243**

The Class Concept 244

Defining Classes 246

Defining Methods 248

Defining Objects 250

Using Objects 252

Pointers to Objects 254

Structs 256

Unions 258

Exercise 260

Solution 262

**Chapter 14 Methods 265**

Constructors 266

Constructor Calls 268

Destructors 270

Inline Methods 272

Access Methods 274

const Objects and Methods 276

Standard Methods 278

this Pointer 280

Passing Objects as Arguments 282

Returning Objects 284

Exercises 286

Solutions 290

xiv ■ CONTENTS

**Chapter 15 Member Objects and Static Members 297**

Member Objects 298

Member Initializers 300

Constant Member Objects 302

Static Data Members 304

Accessing Static Data Members 306

Enumeration 308

Exercises 310

Solutions 314

**Chapter 16 Arrays 321**

Defining Arrays 322

Initializing Arrays 324

Arrays 326

Class Arrays 328

Multidimensional Arrays 330

Member Arrays 332

Exercises 334

Solutions 338

**Chapter 17 Arrays and Pointers 349**

Arrays and Pointers (1) 350

Arrays and Pointers (2) 352

Pointer Arithmetic 354

Arrays as Arguments 356

Pointer Versions of Functions 358

Read-Only Pointers 360

Returning Pointers 362

Arrays of Pointers 364

Command Line Arguments 366

Exercises 368

Solutions 372

**Chapter 18 Fundamentals of File Input and Output 379**

Files 380

File Streams 382

Creating File Streams 384

Open Modes 386

Closing Files 388

Reading and Writing Blocks 390

Object Persistence 392

Exercises 394

Solutions 398

CONTENTS ■ xv

**Chapter 19 Overloading Operators 411**

Generals 412

Operator Functions (1) 414

Operator Functions (2) 416

Using Overloaded Operators 418

Global Operator Functions 420

Friend Functions 422

Friend Classes 424

Overloading Subscript Operators 426

Overloading Shift-Operators for I/O 428

Exercises 430

Solutions 432

**Chapter 20 Type Conversion for Classes 441**

Conversion Constructors 442

Conversion Functions 444

Ambiguities of Type Conversions 446

Exercise 448

Solution 450

**Chapter 21 Dynamic Memory Allocation 453**

The Operator new 454

The Operator delete 456

Dynamic Storage Allocation for Classes 458

Dynamic Storage Allocation for Arrays 460

Application: Linked Lists 462

Representing a Linked List 464

Exercises 466

Solutions 468

**Chapter 22 Dynamic Members 477**

Members of Varying Length 478

Classes with a Dynamic Member 480

Creating and Destroying Objects 482

Implementing Methods 484

Copy Constructor 486

Assignment 488

Exercises 490

Solutions 492

**Chapter 23 Inheritance 499**

Concept of Inheritance 500

Derived Classes 502

xvi ■ CONTENTS

Members of Derived Classes 504

Member Access 506

Redefining Members 508

Constructing and Destroying Derived Classes 510

Objects of Derived Classes 512

Protected Members 514

Exercises 516

Solutions 520

**Chapter 24 Type Conversion in Class Hierarchies 529**

Converting to Base Classes 530

Type Conversions and Assignments 532

Converting References and Pointers 534

Explicit Type Conversions 536

Exercises 538

Solutions 540

**Chapter 25 Polymorphism 543**

Concept of Polymorphism 544

Virtual Methods 546

Destroying Dynamically Allocated Objects 548

Virtual Method Table 550

Dynamic Casts 552

Exercises 554

Solutions 558

**Chapter 26 Abstract Classes 565**

Pure Virtual Methods 566

Abstract and Concrete Classes 568

Pointers and References to Abstract Classes 570

Virtual Assignment 572

Application: Inhomogeneous Lists 574

Implementing an Inhomogeneous List 576

Exercises 578

Solutions 580

**Chapter 27 Multiple Inheritance 587**

Multiply-Derived Classes 588

Multiple Indirect Base Classes 590

Virtual Base Classes 592

Constructor Calls 594

Initializing Virtual Base Classes 596

Exercises 598

Solutions 602

CONTENTS ■ xvii

**Chapter 28 Exception Handling 607**

Traditional Error Handling 608

Exception Handling 610

Exception Handlers 612

Throwing and Catching Exceptions 614

Nesting Exception Handling 616

Defining Your Own Error Classes 618

Standard Exception Classes 620

Exercises 622

Solutions 626

**Chapter 29 More About Files 637**

Opening a File for Random Access 638

Positioning for Random Access 640

File State 644

Exception Handling for Files 646

Persistence of Polymorphic Objects 648

Application: Index Files 652

Implementing an Index File 654

Exercises 656

Solutions 660

**Chapter 30 More About Pointers 681**

Pointer to Pointers 682

Variable Number of Arguments 684

Pointers to Functions 688

Complex Declarations 690

Defining Typenames 692

Application: Dynamic Matrices 694

Exercises 696

Solutions 698

**Chapter 31 Manipulating Bits 705**

Bitwise Operators 706

Bitwise Shift Operators 708

Bit Masks 710

Using Bit Masks 712

Bit-Fields 714

Exercises 716

Solutions 718

Chapter 32 Templates 721

Function and Class Templates 722

Defining Templates 724

xviii ■ CONTENTS

Template Instantiation 726

Template Parameters 728

Template Arguments 730

Specialization 732

Default Arguments of Templates 734

Explicit Instantiation 736

Exercises 738

Solutions 742

**Chapter 33 Containers 749**

Container Types 750

Sequences 752

Iterators 754

Declaring Sequences 756

Inserting in Sequences 758

Accessing Objects 760

Length and Capacity 762

Deleting in Sequences 764

List Operations 766

Associative Containers 768

Sets and Multisets 770

Maps and Multimaps 772

Bitsets 774

Exercise 778

Solution 780

Appendix 783

Binary Numbers 784

Preprocessor Directives 787

Pre-Defined Standard Macros 792

Binding C Functions 793

Operators Overview 795

Operator Precedence Table 797

ASCII Code Table 798

Screen Control Sequences 800

Last edited by a moderator: Oct 30, 2017