C Primer Plus 4th ed Edition Stephen Prata download
C Primer Plus 4th ed Edition Stephen Prata download
download
https://ebookname.com/product/c-primer-plus-4th-ed-edition-
stephen-prata/
https://ebookname.com/product/programming-in-c-4th-edition-
stephen-g-kochan/
https://ebookname.com/product/test-your-c-skills-4th-ed-4th-
edition-yashavant-kanetkar/
https://ebookname.com/product/control-valve-primer-a-user-s-
guide-4th-ed-edition-hans-d-baumann/
https://ebookname.com/product/introduction-to-
microelectromechanical-microwave-systems-2nd-edition-hector-j-de-
los-santos/
Spinoza Complete works First Edition Benedictus De
Spinoza
https://ebookname.com/product/spinoza-complete-works-first-
edition-benedictus-de-spinoza/
https://ebookname.com/product/2g-n-63-office-kersten-geers-david-
van-severen-spanish-and-english-edition-geers/
https://ebookname.com/product/rf-and-microwave-transmitter-
design-1st-edition-andrei-grebennikov/
https://ebookname.com/product/kim-ki-duk-1st-edition-edition-hye-
seung-chung/
https://ebookname.com/product/stochastic-claims-reserving-
methods-in-insurance-1st-edition-mario-v-wuthrich/
Tutankhamen s Curse The Developing History of an
Egyptian King Joyce Tyldesley
https://ebookname.com/product/tutankhamen-s-curse-the-developing-
history-of-an-egyptian-king-joyce-tyldesley/
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks.
Copyright 777
PREFACE
Preface to the Fourth Edition
Note to Instructors
How This Book Is Organized
Reference Variables
Default Arguments
Function Polymorphism (Function Overloading)
Function Templates
Summary
Review Questions
Programming Exercises
Access Control-protected
Abstract Base Classes
Inheritance and Dynamic Memory Allocation
Class Design Review
Summary
Review Questions
Programming Exercises
Chapter 16. THE string CLASS AND THE STANDARD TEMPLATE LIBRARY
The string Class
The auto_ptr Class
The Standard Template Library
Generic Programming
Function Objects (aka Functors)
Algorithms
Other Libraries
Summary
Review Questions
Programming Exercises
Octal Integers
Hexadecimal Numbers
Binary Numbers
Binary and Hex
Chapter 12
Chapter 13
Chapter 14
Chapter 15
Chapter 16
Chapter 17
Index
Copyright
All rights reserved. No part of this book shall be reproduced, stored in a retrieval system, or transmitted
by any means, electronic, mechanical, photocopying, recording, or otherwise, without written
permission from the publisher. No patent liability is assumed with respect to the use of the information
contained herein. Although every precaution has been taken in the preparation of this book, the
publisher and author assume no responsibility for errors or omissions. Nor is any liability assumed for
damages resulting from the use of the information contained herein.
03 02 01 00 4 3 2 1
Trademarks
All terms mentioned in this book that are known to be trademarks or service marks have been
appropriately capitalized. Sams Publishing cannot attest to the accuracy of this information. Use of a
term in this book should not be regarded as affecting the validity of any trademark or service mark.
Every effort has been made to make this book as complete and as accurate as possible, but no
warranty or fitness is implied. The information provided is on an "as is" basis. The author and the
publisher shall have neither liability nor responsibility to any person or entity with respect to any loss or
damages arising from the information contained in this book or from the use of the programs
accompanying it.
Credits
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
ASSOCIATE PUBLISHER
Linda Engelman
ACQUISITIONS EDITOR
Linda Scharp
DEVELOPMENT EDITOR
Karen Wachs
MANAGING EDITOR
Charlotte Clapp
INDEXER
Kelly Castell
PROOFREADERS
Bob LaRoche
Jessica McCarty
TECHNICAL EDITORS
Philippe Bruno
Bill Craun
Michael Maddox
Chris Maunder
TEAM COORDINATOR
Lynne Williams
INTERIOR DESIGNER
Gary Adair
COVER DESIGNER
Gary Adair
PAGE LAYOUT
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
Ayanna Lacey
Stacey Richwine-DeRome
DEDICATION
To my colleagues and students at the College of Marin, with whom it is a pleasure to work.
—Stephen Prata
PREFACE
Learning C++ is an adventure of discovery, particularly because the language accommodates several
programming paradigms, including object-oriented programming, generic programming, and the
traditional procedural programming. C++ has been a moving target as the language added new
features, but now, with the ISO/ANSI C++ Standard of 1998 in place, the language has stabilized.
Contemporary compilers support most or all of the features mandated by the standard, and
programmers have had time to get used to applying these features. The Fourth Edition of C++ Primer
Plus reflects the ISO/ANSI standard and describes this matured version of C++.
C++ Primer Plus integrates discussing the basic C language with presenting C++ features, making this
book self-contained. It presents C++ fundamentals and illustrates them with short, to-the-point
programs that are easy to copy and experiment with. You'll learn about input and output, how to make
programs perform repetitive tasks and make choices, the many ways to handle data, and how to use
functions. You'll learn about the many features C++ has added to C, including the following:
Inheritance
Function overloading
Reference variables
C++ Primer Plus brings several virtues to the task of presenting all this material. It builds upon the
primer tradition begun by C Primer Plus nearly two decades ago and embraces its successful
philosophy:
A primer doesn't assume that you already are familiar with all relevant programming concepts.
A primer emphasizes hands-on learning with brief, easily typed examples that develop your
understanding a concept or two at a time.
A primer provides questions and exercises to let you test your understanding, making the book
suitable for self-learning or for the classroom.
The book helps you understand this rich language and how to use it.
It provides conceptual guidance about when to use particular features, such as using public
inheritance to model what are known as is-a relationships.
We (the author and editors) do our best to keep the presentation to-the-point, simple, and fun. Our goal
is that by the end of the book you'll be able to write solid, effective programs and enjoy yourself doing
so.
Like the previous editions, this book practices generic C++ so that it is not tied to any particular kind of
computer, operating system, or compiler. All the programs were tested with CodeWarrior Pro 6
(Macintosh and Windows) and Microsoft Visual C++ 6.0, and most were tested with Borland C++
Command-Line Compiler 5.5, Gnu g++ 2.9.5 running under DOS, and Comeau C/C++ 4.42.5 running
under Linux. Only a few programs were affected by compiler non-conformance issues.
Note to Instructors
One of the goals of the fourth edition is to provide a book that can be used as either a teach-yourself
book or a textbook. Here are some of the features that support using C++ Primer Plus, Fourth Edition
as a textbook:
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
This book describes generic C++, so it isn't dependent upon a particular implementation.
The contents track the ISO/ANSI C++ standards committee's work and include discussions of
templates, the Standard Template Library, the string class, exceptions, RTTI, and namespaces.
Topics are arranged so that the early chapters can be covered rapidly as review chapters for
courses that do have a C prerequisite.
The book introduces several topics appropriate for computer science courses, including abstract
data types, stacks, queues, simple lists, simulations, generic programming, and using recursion
to implement a divide-and-conquer strategy.
The book discusses when to use certain features as well as how to use them. For example, it
links public inheritance to is-a relationships and composition and private inheritance to has-a
relationships, and it discusses when to use virtual functions and when not to.
This chapter relates how Bjarne Stroustrup created the C++ programming language by adding
object-oriented programming support to the C language. You'll learn the distinctions between
procedural languages, such as C, and object-oriented languages, such as C++. You'll read about the
joint ANSI/ISO work to develop a C++ standard. The chapter discusses the mechanics of creating a
C++ program, outlining the approach for several current C++ compilers. Finally, it describes the
conventions used in this book.
Chapter 2 guides you through the process of creating simple C++ programs. You'll learn about the role
of the main() function and about some of the kinds of statements that C++ programs use. You'll use
the predefined cout and cin objects for program output and input, and you'll learn about creating and
using variables. Finally, you'll be introduced to functions, C++'s programming modules.
C++ provides built-in types for storing two kinds of data: integers (numbers with no fractional parts) and
floating-point numbers (numbers with fractional parts). To meet the diverse requirements of
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
programmers, C++ offers several types in each category. This chapter discusses these types, including
creating variables and writing constants of various types. You'll also learn how C++ handles implicit
and explicit conversions from one type to another.
C++ lets you construct more elaborate types from the basic built-in types. The most advanced form is
the class, discussed in Chapters 10, 11, 12, 13 and 14. This chapter discusses other forms, including
arrays, which hold several values of a single type; structures, which hold several values of unlike
types; and pointers, which identify locations in memory. You'll also learn how to create and store text
strings and to handle text input and output. Finally, you'll learn some of the ways C++ handles memory
allocation, including the new and delete operators for managing memory explicitly.
Programs often must perform repetitive actions, and C++ provides three looping structures for that
purpose: the for loop, the while loop, and the do while loop. Such loops must know when they should
terminate, and the C++ relational operators enable you to create tests to guide such loops. You'll also
learn how to create loops that read and process input character-by-character. Finally, you'll learn how
to create two-dimensional arrays and how to use nested loops to process them.
Programs can behave intelligently if they can tailor their behavior to circumstances. In this chapter
you'll learn how to control program flow by using the if , if else , and switch statements and the
conditional operator. You'll learn how to use logical operators to help express decision-making tests.
Also, you'll meet the cctype library of functions for evaluating character relations, such as testing
whether a character is a digit or a nonprinting character.
Functions are the basic building blocks of C++ programming. This chapter concentrates on features
that C++ functions share with C functions. In particular, you'll review the general format of a function
definition and examine how function prototypes increase the reliability of programs. Also, you'll
investigate how to write functions to process arrays, character strings, and structures. Next you'll learn
about recursion, which is when a function calls itself, and see how it can be used to implement a
divide-and-conquer strategy. Finally, you'll meet pointers to functions, which enable you to use a
function argument to tell one function to use a second function.
This chapter explores the new features C++ adds to functions. You'll learn about inline functions, which
can speed program execution at the cost of additional program size. You'll work with reference
variables, which provide an alternative way to pass information to functions. Default arguments let a
function automatically supply values for function arguments that you omit from a function call. Function
overloading lets you create functions having the same name but taking different argument lists. All
these features have frequent use in class design. Also, you'll learn about function templates, which
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
This chapter discusses putting together multifile programs. It examines your choices in allocating
memory, looking at different methods of managing memory and at scope, linkage, and namespaces,
which determine what parts of a program know about a variable.
A class is a user-defined type, and an object is an instance of a class, such as a variable. This chapter
introduces you to object-oriented programming and to class design. A class declaration describes the
information stored in a class object and also the operations (class methods) allowed for class objects.
Some parts of an object are visible to the outside world (the public portion), and some are hidden (the
private portion). Special class methods (constructors and destructors) come into play when objects are
created and destroyed. You will learn about all this and other class details in this chapter, and you'll
see how classes can be used to implement abstract data types (ADTs), such as a stack.
In this chapter you'll further your understanding of classes. First you'll learn about operator
overloading, which lets you define how operators such as + will work with class objects. You'll learn
about friend functions, which can access class data that's inaccessible to the world at large. You'll see
how certain constructors and overloaded operator member functions can be used to manage
conversion to and from class types.
Often it's useful to have a class member point to dynamically allocated memory. If you use new in a
class constructor to allocate dynamic memory, you incur the responsibilities of providing an appropriate
destructor, of defining an explicit copy constructor, and of defining an explicit assignment operator.
This chapter shows you how and discusses the behavior of the member functions generated implicitly
if you fail to provide explicit definitions. You'll also expand your experience with classes by using
pointers to objects and studying a queue simulation problem.
One of the most powerful features of object-oriented programming is inheritance, by which a derived
class inherits the features of a base class, enabling you to reuse the base class code. This chapter
discusses public inheritance, which models is-a relationships, meaning that a derived object is a
special case of a base object. For example, a physicist is a special case of a scientist. Some
inheritance relationships are polymorphic, meaning you can write code using a mixture of related
classes for which the same method name may invoke behavior that depends upon the object type.
Implementing this kind of behavior necessitates using a new kind of member function called a virtual
function. Sometimes abstract base classes are the best approach to inheritance relationships. This
chapter discusses these matters, pointing out when public inheritance is appropriate and when it is not.
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
Public inheritance is just one way to reuse code. This chapter looks at several other ways.
Containment is when one class contains members that are objects of another class. It can be used to
model has-a relationships, in which one class has components of another class. For example, an
automobile has a motor. You also can use private and protected inheritance to model such
relationships. This chapter shows you how and points out the differences among the different
approaches. Also, you'll learn about class templates, which let you define a class in terms of some
unspecified generic type, then use the template to create specific classes in terms of specific types. For
example, a stack template enables you to create a stack of integers or a stack of strings. Finally, you'll
learn about multiple public inheritance, whereby a class can derive from more than one class.
This chapter extends the discussion of friends to include friend classes and friend member functions.
Then it presents several new developments in C++, beginning with exceptions, which provide a
mechanism for dealing with unusual program occurrences, such an inappropriate function argument
values or running out of memory. Then you'll learn about RTTI (runtime type information), a
mechanism for identifying object types. Finally, you'll learn about the safer alternatives to unrestricted
typecasting.
Chapter 16: The string Class and the Standard Template Library
This chapter discusses some useful class libraries recently added to the language. The string class is
a convenient and powerful alternative to traditional C-style strings. The auto_ptr class helps manage
dynamically allocated memory. The Standard Template Library (STL) provides several generic
containers, including template representations of arrays, queues, lists, sets, and maps. It also provides
an efficient library of generic algorithms that can be used with STL containers and also with ordinary
arrays.
This chapter reviews C++ I/O and discusses how to format output. You'll learn how to use class
methods to determine the state of an input or output stream and to see, for example, if there has been
a type mismatch on input or if end-of-file has been detected. C++ uses inheritance to derive classes for
managing file input and output. You'll learn how to open files for input and output, how to append data
to a file, how to use binary files, and how to get random access to a file. Finally, you'll learn how to
apply standard I/O methods to read from and write to strings.
This appendix lists the ASCII character set along with decimal, octal, hexadecimal, and binary
representations.
This appendix summarizes those C++ operators, such as the bitwise operators, not covered in the
main body of the text.
This appendix summarizes the STL container methods and the general STL algorithm functions.
This appendix lists some books that can further your understanding of C++.
This appendix provides guidelines for moving from C and older C++ implementations to Standard C++.
This appendix contains the answers to the review questions posed at the end of each chapter.
Stephen Prata teaches astronomy, physics, and computer science at the College of Marin in Kentfield,
California. He received his B.S. from the California Institute of Technology and his Ph.D. from the
University of California, Berkeley. Stephen has authored or coauthored over a dozen books for The
Waite Group. He wrote The Waite Group's New C Primer Plus, which received the Computer Press
Association's 1990 Best How-to Computer Book Award and The Waite Group's C++ Primer Plus,
nominated for the Computer Press Association's Best How-to Computer Book Award in 1991.
ACKNOWLEDGMENTS
Several editors from Pearson and from Sams helped originate and maintain this project, so thanks to
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
Linda Sharp, Karen Wachs, and Laurie McGuire. Thanks, too, to Michael Maddox, Bill Craun, Chris
Maunder, and Phillipe Bruno for providing technical review and editing. And thanks again to Michael
Maddox and Bill Craun for supplying the material for the Real World Notes. Also, thank you Ron
Leichty of Metroworks and Greg Comeau of Comeau Computing for your help with the new C99
features and your noteworthy commitment to customer service.
I'd like to thank the editors from Macmillan Press and Waite Group Press for the roles they played in
putting this book together: Tracy Dunkelberger, Susan Walton, and Andrea Rosenberg. Thanks, too, to
Russ Jacobs for his content and technical editing. From Metrowerks, I'd like to thank Dave Mark, Alex
Harper, and especially Ron Liechty, for their help and cooperation.
I'd like to thank Mitchell Waite and Scott Calamar for supporting a second edition and Joel Fugazzotto
and Joanne Miller for guiding the project to completion. Thanks to Michael Marcotty of Metrowerks for
dealing with my questions about their beta version CodeWarrior compiler. I'd also like to thank the
following instructors for taking the time to give us feedback on the first edition: Jeff Buckwalter, Earl
Brynner, Mike Holland, Andy Yao, Larry Sanders, Shahin Momtazi, and Don Stephens. Finally, I wish
to thank Heidi Brumbaugh for her helpful content editing of new and revised material.
Many people have contributed to this book. In particular, I wish to thank Mitch Waite for his work in
developing, shaping, and reshaping this book, and for reviewing the manuscript. I appreciate Harry
Henderson's work in reviewing the last few chapters and in testing programs with the Zortech C++
compiler. Thanks to David Gerrold for reviewing the entire manuscript and for championing the needs
of less-experienced readers. Also thanks to Hank Shiffman for testing programs using Sun C++ and to
Kent Williams for testing programs with AT&T cfront and with G++. Thanks to Nan Borreson of Borland
International for her responsive and cheerful assistance with Turbo C++ and Borland C++. Thank you,
Ruth Myers and Christine Bush, for handling the relentless paper flow involved with this kind of project.
Finally, thanks to Scott Calamar for keeping everything on track.
As the reader of this book, you are our most important critic and commentator. We value your opinion
and want to know what we're doing right, what we could do better, what areas you'd like to see us
publish in, and any other words of wisdom you're willing to pass our way.
As an Associate Publisher for Sams, I welcome your comments. You can e-mail or write me directly to
let me know what you did or didn't like about this book—as well as what we can do to make our books
stronger.
Please note that I cannot help you with technical problems related to the topic of this book, and that
due to the high volume of mail I receive, I might not be able to reply to every message.
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks .
When you write, please be sure to include this book's title and author as well as your name and phone
or fax number. I will carefully review your comments and share them with the author and editors who
worked on the book.
E-mail: [email protected]
Mail: Linda Engelman
Sams
201 West 103rd Street
Indianapolis, IN 46290 USA
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
CONTENTS
Learning C++
A Little History
Portability and Standards
The Mechanics of Creating a Program
Conventions Used in This Book
Our System
Welcome to C++! This exciting language, blending the C language with support for
object-oriented programming, became one of the most important programming
languages of the 1990s and continues strongly into the 2000s. Its C ancestry brings to
C++ the tradition of an efficient, compact, fast, and portable language. Its
object-oriented heritage brings C++ a fresh programming methodology designed to
cope with the escalating complexity of modern programming tasks. Its template
features bring yet another new programming methodology, generic programming. This
triple heritage is both a blessing and a bane. It makes the language very powerful, but
it also means there's more to learn.
In this chapter we'll explore C++'s background further and then go over some of the
ground rules for creating C++ programs. The rest of the book teaches you to use the
C++ language, going from the modest basics of the language to the glory of
object-oriented programming (OOP) and its supporting cast of new jargon—objects,
classes, encapsulation, data hiding, polymorphism, and inheritance, then on to its
support of generic programming. (Of course, as you learn C++, these terms will be
transformed from buzzwords to the necessary vocabulary of cultivated discourse.)
Learning C++
C++ Primer Plus approaches C++ by teaching both its C basis and its new
components, so this book assumes you have no prior knowledge of C. You'll start by
learning the features C++ shares with C. Even if you know C, you may find this part of
the book a good review. Also, it points out concepts that will become important later,
and it indicates where C++ differs from C. After you are well-founded in the basics of
C, you'll add the C++ superstructure. At this point you'll learn about objects and
classes and how C++ implements them. And you will learn about templates.
This book is not intended to be a complete C++ reference; it won't explore every nook
and cranny of the language. But you will learn all the major features of the language,
including some, like templates, exceptions, and namespaces, that are more recent
additions.
A Little History
Computer technology has evolved at an amazing rate during the last few decades.
Today a laptop computer can compute faster and store more information than the
mainframe computers of thirty years ago. (Quite a few programmers can recall bearing
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
In the 1970s, languages like C and Pascal helped usher in an era of structured
programming, a philosophy that brought some order and discipline to a field badly in
need of these qualities. Besides providing the tools for structured programming, C also
produced compact, fast-running programs along with the ability to address hardware
matters, such as managing communication ports and disk drives. These gifts helped
make C the dominant programming language in the 1980s. Meanwhile, the 1980s
witnessed the growth of a new programming paradigm: object-oriented programming,
or OOP, as embodied in languages such as SmallTalk and C++. Let's examine these
two developments (C and OOP) a bit more closely.
The C Language
In the early 1970s, Dennis Ritchie of Bell Laboratories was working on a project to
develop the UNIX operating system. (An operating system is a set of programs that
manages a computer's resources and handles its interactions with users. For example,
it's the operating system that puts the system prompt onscreen and that runs
programs for you.) For this work Ritchie needed a language that was concise, that
produced compact, fast programs, and that could control hardware efficiently.
Traditionally, programmers met these needs by using assembly language, which is
closely tied to a computer's internal machine language. However, assembly language
is a low-level language, that is, it is specific to a particular computer processor. So if
you want to move an assembly program to a different kind of computer, you may have
to completely rewrite the program using a different assembly language. It was a bit as
if each time you bought a new car, you found that the designers decided to change
where the controls went and what they did, forcing you to relearn how to drive. But
UNIX was intended to work on a variety of computer types (or platforms). That
suggested using a high-level language. A high-level language is oriented towards
problem-solving instead of towards specific hardware. Special programs called
compilers translate a high-level language to the internal language of a particular
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
computer. Thus, you can use the same high-level language program on different
platforms by using a separate compiler for each platform. Ritchie wanted a language
that combined low-level efficiency and hardware access with high-level generality and
portability. So, building from older languages, he created C.
C Programming Philosophy
Because C++ grafts a new programming philosophy onto C, we should first take a look
at the older philosophy that C follows. In general, computer languages deal with two
concepts—data and algorithms. The data constitute the information a program uses
and processes. The algorithms are the methods the program uses (see Figure 1.1). C,
like most mainstream languages to date, is a procedural language. That means it
emphasizes the algorithm side of programming. Conceptually, procedural
programming consists of figuring out the actions a computer should take and then
using the programming language to implement those actions. A program prescribes a
set of procedures for the computer to follow to produce a particular outcome, much as
a recipe prescribes a set of procedures for a cook to follow to produce a cake.
Earlier procedural languages, such as FORTRAN and BASIC, ran into organizational
problems as programs grew larger. For example, programs often use branching
statements, which route execution to one or another set of instructions depending
upon the result of some sort of test. Many older programs had such tangled routing
(called "spaghetti programming") that it was virtually impossible to understand a
program by reading it, and modifying such a program was an invitation to disaster. In
response, computer scientists developed a more disciplined style of programming
called structured programming. C includes features to facilitate this approach. For
example, structured programming limits branching (choosing which instruction to do
next) to a small set of well-behaved constructions. C incorporates these constructions
(the for loop, the while loop, the do while loop, and the if else statement) into its
vocabulary.
Top-down design was another of the new principles. The idea is to break a large
program into smaller, more manageable tasks. If one of these tasks is still too broad,
divide it into yet smaller tasks. Continue with this process until the program is
compartmentalized into small, easily programmed modules. (Organize your study.
Aargh! Well, organize your desk, your table top, your filing cabinet, and your
bookshelves. Aargh! Well, start with the desk and organize each drawer, starting with
the middle one. Hmmm, perhaps I can manage that task.) C's design facilitates this
approach, encouraging you to develop program units called functions to represent
individual task modules. As you may have noticed, the structured programming
techniques reflect a procedural mind-set, thinking of a program in terms of the actions
it performs.
Object-Oriented Programming
Although the principles of structured programming improved the clarity, reliability, and
ease of maintenance of programs, large-scale programming still remains a challenge.
Object-oriented programming (OOP) brings a new approach to that challenge. Unlike
procedural programming, which emphasizes algorithms, OOP emphasizes the data.
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
Rather than trying to fit a problem to the procedural approach of a language, OOP
attempts to fit the language to the problem. The idea is to design data forms that
correspond to the essential features of a problem.
In C++, a class is a specification describing such a new data form, and an object is a
particular data structure constructed according to that plan. For example, a class could
describe the general properties of a corporation executive (name, title, salary, unusual
abilities, for example), while an object would represent a specific executive (Guilford
Sheepblat, vice president, $325,000, knows how to use a CONFIG.SYS file). In
general, a class defines what data are used to represent an object and the operations
that can be performed upon that data. For example, suppose you were developing a
computer drawing program capable of drawing a rectangle. You could define a class
to describe a rectangle. The data part of the specification could include such things as
the location of the corners, the height and width, the color and style of the boundary
line, and the color and pattern used to fill the rectangle. The operations part of the
specification could include methods for moving the rectangle, resizing it, rotating it,
changing colors and patterns, and copying the rectangle to another location. If you
then use your program to draw a rectangle, it will create an object according to the
class specification. That object will hold all the data values describing the rectangle,
and you can use the class methods to modify that rectangle. If you draw two
rectangles, the program will create two objects, one for each rectangle.
The OOP approach to program design is to first design classes that accurately
represent those things with which the program deals. A drawing program, for example,
might define classes to represent rectangles, lines, circles, brushes, pens, and the
like. The class definitions, recall, include a description of permissible operations for
each class, such as moving a circle or rotating a line. Then you proceed to design a
program using objects of those classes. The process of going from a lower level of
organization, such as classes, to a higher level, such as program design, is called
bottom-up programming.
There's more to OOP programming than the binding of data and methods into a class
definition. OOP, for example, facilitates creating reusable code, and that eventually
can save a lot of work. Information hiding safeguards data from improper access.
Polymorphism lets you create multiple definitions for operators and functions, with the
programming context determining which definition is used. Inheritance lets you derive
new classes from old ones. As you can see, object-oriented programming introduces
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
many new ideas and involves a different approach to programming than does
procedural programming. Instead of concentrating on tasks, you concentrate on
representing concepts. Instead of taking a top-down programming approach, you
sometimes take a bottom-up approach. This book will guide you through all these
points with plenty of easily grasped examples.
Designing a useful, reliable class can be a difficult task. Fortunately, OOP languages
make it simple to incorporate existing classes into your own programming. Vendors
provide a variety of useful class libraries, including libraries of classes designed to
simplify creating programs for environments such as Windows or the Macintosh. One
of the real benefits of C++ is that it lets you easily reuse and adapt existing,
well-tested code.
Generic Programming
C++
Like C, C++ began its life at Bell Labs, where Bjarne Stroustrup developed the
language in the early 1980s. In his own words, "C++ was designed primarily so that
my friends and I would not have to program in assembler, C, or various modern
This document was created by an unregistered ChmMagic, please go to http://www.bisenter.com to register it. Thanks
high-level languages. Its main purpose was to make writing good programs easier and
more pleasant for the individual programmer" (Bjarne Stroustrup, The C++
Programming Language. Third Edition. Reading, MA: Addison-Wesley Publishing
Company, 1997).
Stroustrup was more concerned with making C++ useful than with enforcing particular
programming philosophies or styles. Real programming needs are more important
than theoretical purity in determining C++ language features. Stroustrup based C++
on C because of C's brevity, its suitability to system programming, its widespread
availability, and its close ties to the UNIX operating system. C++'s OOP aspect was
inspired by a computer simulation language called Simula67. Stroustrup added OOP
features and generic programming support to C without significantly changing the C
component. Thus C++ is a superset of C, meaning that any valid C program is a valid
C++ program, too. There are some minor discrepancies, but nothing crucial. C++
programs can use existing C software libraries. Libraries are collections of
programming modules that you can call up from a program. They provide proven
solutions to many common programming problems, thus saving you much time and
effort. This has helped the spread of C++.
The name C++ comes from the C increment operator ++, which adds 1 to the value of
a variable. The name C++ correctly suggests an augmented version of C.
CHAPTER XXIX.
CHAPTER XXX.
THE CONFESSION.
CHAPTER XXXI.
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebookname.com