Thinking in C++ 2nd ed Volume 1 Revision 6

Chapter 10: Name Control. Creating names is a fundamental
activity in programming, and when a project gets large, the number
of names can be overwhelming. C++ allows you a great deal of
control over names: creation, visibility, placement of storage, and
linkage. This chapter shows how names are controlled with two
techniques. First, the static keyword is used to control visibility and
linkage, and its special meaning with classes is explored. A far more
useful technique for controlling names at the global scope is C++’s
namespace feature, which allows you to break up the global name
space into distinct regions.
Chapter 11: References and the Copy-Constructor
Constructor. C++ pointers
work like C pointers with the additional benefit of stronger C++
type checking. C++ also provides an additional way to handle
addresses: from Algol and Pascal, C++ lifts the reference, which lets
the compiler handle the address manipulation while you use
ordinary notation. You’ll also meet the copy-constructor, which
controls the way objects are passed into and out of functions by
value. Finally, the C++ pointer-to-member is illuminated.
Chapter 12: Operator Overloading. This feature is sometimes called
“syntactic sugar;” it lets you sweeten the syntax for using your type
by allowing operators as well as function calls. In this chapter you’ll
learn that operator overloading is just a different type of function
call and you’ll learn how to write your own, especially the
sometimes-confusing uses of arguments, return types, and the
decision of whether to make an operator a member or friend.
Chapter 13: Dynamic Object Creation. How many planes will an airtraffic
system have to handle How many shapes will a CAD system
need In the general programming problem, you can’t know the
quantity, lifetime, or type of objects needed by your running
program. In this chapter, you’ll learn how C++’s new and delete
elegantly solve this problem by safely creating objects on the heap.
Chapter 14: Inheritance and Composition. Data abstraction allows
you to create new types from scratch, but with composition and
inheritance, you can create new types from existing types. With
composition, you assemble a new type using other types as pieces,
and with inheritance, you create a more specific version of an
30 Thinking in C++ www.BruceEckel.com