Customer Reviews

Generic Programming and the STL: Using and Extending the C++ Standard Template Library

5 star:		(5)
4 star:		(6)
3 star:		(3)
2 star:		(1)
1 star:		(1)

 

 

Rightaway, I should say I don't discuss the quality of the book. It
has everything I would like to have when I am programming and need to
look up a function of the STL. This is why I give it three stars. But
nowhere did I see the following criticism, so I have to voice it
out.

This book consists of two parts, part I, and part II and III
(which I count as the second part, see below). Part I is an
introduction to generic programming as used in the framework of the
STL (79 pages). All that stuff, you're supposed to know if you use the
STL. It's all about using the STL, the design, and extending it. Using
the STL is described in lots of web pages, so the book does not
provide much added value to this. Extending the STL is discussed all
in all in about three pages. That was the part I was most interested
it (I am developing a new course about generic programming).

The
second part, making up the remaining 430 or so of the book, are Part
II (Ref Manual: Concepts) and Part III (Ref Manual: Algos and
Classes). They have long been available straight from the SGI STL web
pages, ...
and you can also download them for browsing locally. This is a much
more convenient (at least for me) way to look up the documentation. I
didn't see that the book provided better examples, or different
content than, the SGI's STL pages.

This book will be useful if you
are aware of all the things I said, but still would prefer to browse a
book, or for off-line study. My goal was to see a discussion of how to
use and extend the STL (as advertised in the title). I did not expect
the Reference Manual (which I had already). I am most disappointed in
this.

The difference between User Manual and Reference Manual is
best illustrated by the Stroustrup or Lippman-Lajoie (user manuals)
and the C++ ISO Standard (reference manual). You should be aware of
this difference before you buy this book, and decide if you want it
print in 430 pages or in a web site.

This book provides a nice introduction so generic programming with STL. I learned a lot about _why_ things were done the way they were in STL.

Most STL libraries that I've seen have little, if any, documentation, so it's difficult to see the reasoning behind the madness of the details of most STL implementations. It's unfortunate that while STL libraries may be good examples of generic programming (or at least maybe as generic as you can get before being constrained by C++ itself), they appear as a whole to be poor examples of self-documenting source code. That's where this book comes along.

Even after gleaming knowledge of the reasoning behind STL creation, the book has become my regular desk-side reference to not only STL containers and iterators, but also a guide to the requirements necessary to implement your own models.

One area that this book does not cover well is how to choose design criteria when creating your own containers and iterators. However, that does not diminish the usefulness of this book, although it does seem to me that the title may be a little misleading - as STL is covered in more depth then Generic Programming in general, and the emphasis is more heavily on _Using_ rather then _Extending_...

This book is indespensible if you have a solid grasp of the STL and need a "consultant" as you code or if you really need to understand the internals of the STL, but don't buy this book if you want plentiful clear examples. It's almost too academic.

I recently restarted using STL after a couple year sabattical in C, and wanted a good book to find compelling clear examples that I could use and modify. This is absolutely not your book if that's what you want. I suggest "STL Programming From the Group Up" as a (perhaps overly simple) starting place.

This is a great companion to Musser & Saini. I particularly enjoyed the in-depth explanations of the motivation for why things are the way they are. Instead of simply explaining how to use the STL, Austern explains how and why it works. This becomes particularly important if you want to extend the STL with algorithms or containers of your own because Austern shows how to it correctly, so that things will *really* work.

The language and explanations in the book are clear, precise, and to the point. An excellent companion to Musser & Saini.

The language C++ cannot be thought of as a mere extension to the C language. It supports object-oriented programming, and even more importantly, the generic programming paradigm. This book gives an overview of how C++ fits into the generic programming paradigm, and the author does a decent job of explaining how this is done. Anyone familiar with C++ and the Standard Template Library should have no problem following the dialog in the book. The approach taken by generic programming can be very abstract, but it is extremely powerful, and one that allows generality and economy of thought in programming.

After a brief summary of the STL in chapter 1, the author moves on to studying linear search and iterators in chapter 2. The author stresses the need to design algorithms that are independent of the data structures they operate on. The discussion sets up the terminology and concepts for later chapters on function objects and containers in later chapters. The author introduces the idea of a concept, which is essentially a collection of type requirements, types, and valid programs. Readers with a background in mathematical logic are referred to the references for a discussion of the connection between concepts and the theory of many-sorted algebras. Iterators are introduced as five different types of concepts, these all serving as a generalization of pointers. The five kinds of iterator concepts are discussed in detail in the chapter. These concepts do have properties in common, and this leads the author to consider refinements of concepts. In addition, the different iterator concepts allow the author to classify generic algorithms according to the iterator concepts it uses.

The discussion of iterators is continued in the next chapter, where iterator traits and associated types are discussed. The idea of an iterator value type is introduced as the object type the iterator points to. The author introduces, interestingly, a generalization of the type overloading capability of C++ to concept overloading, and he shows in detail how to emulate concept overloading in C++ .

Function objects, which I consider one of the most powerful and useful concepts in generic programming, are discussed in chapter 4. Function objects are introduced as entities that can parameterize any kind of operation, and the author gives good arguments to show that every algorithm can be generalized by abstracting some part of its behavior as a function object. The associated types of a function object are the types of its arguments and return values. The composition of functions, so familiar in elementary mathematics, is here generalized to function objects via function object adaptors. Thus one can view function objects as entities behaving as expected in a mathematical sense.

Containers are then introduced in chapter 5, essentially as generalizations of arrays, and the author stresses that the elements of a container are actual objects and not addresses. This "value semantics" of containers is shown to be a useful strategy by the author.

The next part of the book begins an overview of generic programming concepts that are applicable in general, and not just the STL. STL though is given as an example in the discussion, and this is somewhat disappointing given the emphasis on generality. But the author does outline with clarity the important constructions in generic programming, such as iterators, function objects, and containers. Therefore this part of the book does serve as a good reference manual.

The next part is a reference manual on the algorithms and classes available in the STL. The discussion on memory management primitives is useful for it gives information on the algorithms used to manipulate uninitialized storage in order to implement containers. Nonmutating algorithms, which are used for operating on a range of iterators without changing the elements they point to, are given a good overview, as are mutating algorithms, which modify the values pointed to by a range of iterators. The discussion of the predefined function objects is also useful, as they implement most of the standard arithmetic operations, such as multiplication and addition, and the logical operations, such as AND and OR. In addition, the discussion of member function adaptors is useful since it shows the reader how to call member functions as function objects. A polymorphic function call will result if the member function is virtual, and this, the author states, is a link between generic programming and OO-programming in C++

The very important Vector class is discussed also, stressing its ability for automatic memory management. In my experience, the Vector class has been one of the most useful features of the STL.

Excellent Book on STL. The only complaint I have about this book is the title. It should be called "STL and Generic Programming". The title is backwards since the majority of this book is a reference to STL and STL concepts. Even the information on Generic Programming is in the context of the STL. Still, it is an excellent book if you know the STL and want more info and documentation. Read something else if you are a beginner at STL.

This is not a tutorial, thank you. It is a really good reference on all of the STL, even includes the non-standard but more useful hash_set and hash_map. Each container, iterator, function objects are described in detail, even has the name of the header file.

The section I found most valuable is on function objects. Most people I know use only the containers. This book makes me start using function objects and iterator adaptors, it's a new dimension.

I'm still waiting for a book that tells me how to EXTEND STL. For example, how to create my own thread-safe, exception-safe containers.

Very well presented. STL isn't the only implementation of the various collections, but what makes STL special is the generic interoperability of all of its pieces (algorithms, iterators, function objects, etc). This books shows how to capitalize on those features. Generic programming? If it is through STL, then yes indeed. If it is through generic template programming without STL, then probably not. But if you are looking for a solid STL reference, this is the best that I have seen so far. Downside? Sample code is practicaly non-existant (but at least it isn't another drawn out anagram application -- no offense, Musser/Saini).

As one of the few non-tutorial books on the design of STL, the book serves its purpose. It illustrates that the STL is built on top of concepts, a different kind of abstraction from the traditional OO. It also explains in details how this abstraction is applied through iterators, containers, and algorithms, as well as their STL way implementation in C++.

However, this book has several weaknesses. Not enough is devoted to illustrate the big picture of how the STL uses these abstractions. For example, after explaining the iterators and containers, the book doesn't explain how the iterators serve as a bridge between generic algorithms and containers - the abstraction of iterators makes it possible to write generic algorithms without the knowledge of the type of the container, and vice versa.

On the practical side, I think that the book spends too much space on a complete reference manual to STL, but not enough on discussing the practical issues of extending and using STL, such as making a non-trivial custom container or a custom memory allocator.

really professional, the book is a good quality
I like it,
hope to work with you next time.