A Complete Guide To Programming In C++ / Edition 1

A Complete Guide To Programming In C++ / Edition 1

5.0 1
by Peter Prinz, Ulla Prinz, Ulla Kirch-Prinz
     
 

binding type PBSee more details below

Overview

binding type PB

Product Details

ISBN-13:
9780763718176
Publisher:
Jones & Bartlett Learning
Publication date:
08/06/2001
Edition description:
1E
Pages:
848
Product dimensions:
7.50(w) x 9.20(h) x 1.80(d)

Table of Contents

Chapter 1 Fundamentals
gives a thorough description of the fundamental characteristics of the object-oriented C++ programming language. In addition, you are introduced to the steps necessary for creating a fully functional C++ program. Many examples are provided to
help enforce these steps and to demonstrate the basic structure of a C++ program.
Chapter 2 Fundamental Types, Constants, and Variables
provides a complete introduction to the basic types and objects used by C++ programs. Integral types and constants, fundamental types, and Boolean constants are just a few of the topics discussed.
Chapter 3 Using Functions and Classes
describes how to declare and call standard functions. This chapter also teaches you to use standard classes, including standard header files. In addition, you work with string variables for the first time in this chapter.
Chapter 4 Input and Output with Streams
explains the use of streams for input and output, with a focus on formatting techniques. Formatting flags and manipulators are discussed, as are field width, fill characters, and alignment.
Chapter 5 Operators for Fundamental Types
introduces operators needed for calculations and selections. Binary, unary, relational, and logical operators are all examined in detail.
Chapter 6 Control Flow
describes the statements needed to control the flow of a program. These include loops with while, do-while, and for; selections with if-else, switch, and the conditional operator; and jumps with goto, continue, and break.
Chapter 7 Symbolic Constants and Macros
provides a thorough introduction to the definition of symbolic constants and macros, illustrating their significance and use. Furthermore, a comprehensive examination of standard macros for character handling is included.
Chapter 8 Converting Arithmetic Types
introduces implicit type conversions, which are performed in C++ whenever different arithmetic types occur in expressions. Additionally, the chapter explores an operator for explicit type conversion.
Chapter 9 The Standard Class string
takes an in-depth look at the standard class string, which is used to represent strings. In addition to defining strings, the chapter looks at the various methods of string manipulation. These include inserting and erasing, searching and replacing, comparing,
and concatenating strings.
Chapter 10 Functions
describes how to write functions of your own. The basic rules are covered, as are passing arguments, the definition of inline functions, overloading functions and default arguments, and the principle of recursion.
Chapter 11 Storage Classes and Namespaces
gives a thorough explanation of storage classes for objects and functions. Object lifetime and scope are discussed, along with global, static, and auto objects. Namespaces and external and static functions are also included in the discussion.
Chapter 12 References and Pointers
explains how to define references and pointers and how to use them as parameters and/or return values of functions. In this context, passing by reference and read-only access to arguments are introduced.
Chapter 13 Defining Classes
provides a complete description of how classes are defined and how instances of classes, that is, objects, are used. In addition, structs and unions are introduced as examples of special classes.
Chapter 14 Methods
describes how constructors and destructors are defined to create and destroy objects. Also discussed is how inline methods, access methods, and read-only methods can be used. Furthermore, the chapter explains the pointer this, which is available for all methods, and what you need to pay attention to when passing objects as arguments or returning objects.
Chapter 15 Member Objects and Static Members
gives a complete explanation of member objects and how they are initialized, and of data members that are created once only for all the objects in a class. In addition, this chapter describes constant members and enumerated types.
Chapter 16 Arrays
takes an in-depth look at how to define and use arrays. Of particular interest are one-dimensional and multidimensional arrays, C strings, and class arrays.
Chapter 17 Arrays and Pointers
describes the relationship between pointers and arrays. This includes pointer arithmetic, pointer versions of functions, pointers as return values and read-only pointers, and pointer arrays. You learn that operations that use C strings illustrate how to use pointers for efficient programming, and that string access via the command line of an application program is used to illustrate pointer arrays.
Chapter 18 Fundamentals for File Input and Output
explains sequential file access using file streams. You will develop an understanding of how file streams provide simple and portable file handling techniques.
Chapter 19 Overloading Operators
provides a complete description of the various uses of overloaded operators. Arithmetic operators, comparisons, the subscript operator, and the shift operators for input and output are overloaded to illustrate the appropriate techniques. In addition, the
concept of friend functions, which is introduced in this context, is particularly important for overloading operators. Students learn how overloading operators allows you to apply existing operators to objects of class type.
Chapter 20 Type Conversions for Classes
discusses how implicit type conversion occurs in C++ when an expression cannot be compiled directly but can be compiled after applying a conversion rule. The programmer can stipulate how the compiler will perform implicit type conversion for
classes by defining conversion constructors and functions. Finally, the chapter discusses ambiguity occurring due to type conversion and how to avoid it.
Chapter 21 Dynamic Memory Allocation
describes how a program can allocate and release memory dynamically in line with current memory requirements. Dynamic memory allocation is an important factor in many C++ programs, and the following chapters contain several additional case studies to help students review the subject.
Chapter 22 Dynamic Members
explains how to implement classes containing pointers to dynamically allocated memory. These include your own copy constructor definition and overloading the assignment operator. A class designed to represent arrays of any given length is used as a sample application.
Chapter 23 Inheritance
provides a thorough description of how derived classes can be constructed from existing classes by inheritance. In addition to defining derived classes, this chapter discusses how members are redefined, how objects are constructed and destroyed, and
how access control to base classes can be realized.
Chapter 24 Type Conversion in Class Hierarchies
discusses implicit type conversion within class hierarchies, which occurs in the context of assignments and function calls. Explicit type casting in class hierarchies is also described, paying particular attention to upcasting and downcasting.
Chapter 25 Polymorphism
gives a complete explanation of how to develop and manage polymorphic classes. In addition to defining virtual functions, dynamic downcasting in polymorphic class hierarchies is introduced.
Chapter 26 Abstract Classes
describes how defining pure virtual methods can create abstract classes and how you can use abstract classes at a polymorphic interface for derived classes. To illustrate this, an inhomogeneous list, that is, a linked list whose elements can be of
various class types, is implemented.
Chapter 27 Multiple Inheritance
describes how new classes are created by multiple inheritance and explains their uses. Besides introducing students to the creation and destruction of objects in multiply derived classes, virtual base classes are depicted to avoid ambiguity in multiple inheritance.
Chapter 28 Exception Handling
explains how a C++ program uses error-handling techniques to resolve error conditions. In addition to throwing and catching exceptions, the chapter also examines how exception specifications are declared and exception classes are defined. In addition, the use of standard exception classes is discussed.
Chapter 29 More about Files
examines random access to files based on file streams, and options for querying file state. Exception handling for files is discussed as well. In addition, the chapter illustrates how to make objects in polymorphic classes persistent, that is, how to
save them in files. The applications introduced in this chapter include simple index files and hash tables.
Chapter 30 More about Pointers
provides a thorough explanation of the advanced uses of pointers. These include pointers to pointers, functions with a variable number of arguments, and pointers to functions. In addition, an application that defines a class used to represent dynamic
matrices is introduced.
Chapter 31 Manipulation Bits
describes bitwise operators and how to use bit masks. The applications included demonstrate calculations with parity bits, conversion of lowercase and capital letters, and converting binary numbers. Finally, the definition of bit-fields is introduced.
Chapter 32 Templates
discusses how to define and use function and class templates. In addition, special options, such as default arguments, specialization, and explicit instantiation are discussed. Students learn that templates allow the construction of functions and classes based on types that have not yet been stated. Thus, templates are a powerful tool for automating program code generation.
Chapter 33 Containers
explains standard class templates used to represent containers for more efficient management of object collections. These include sequences, such as lists and double ended queues; container adapters, such as stacks, queues, and priority queues;
associative containers, such as sets and maps; and bitsets. In addition to discussing how to manage containers, the chapter also looks at sample applications, such as bitmaps for raster images, and routing techniques.
Appendix
decribes all preprocessor directives, pre-defined macros and presents an operator overview, the operator precedence table and ASCII code table. In addition to explaining binary number representation, the appendix also looks at the binding of C functions.
Index

Read More

Customer Reviews

Average Review:

Write a Review

and post it to your social network

     

Most Helpful Customer Reviews

See all customer reviews >