|
|
The C++ Standard Library: A Tutorial and Reference (Hardcover)
by Nicolai M. Josuttis
| Category:
C++ language, Software development, IT, Technology |
| Market price: ¥ 678.00
MSL price:
¥ 638.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
Extremely well organized and well written, this book is an excellent reference to advanced C++ features. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Nicolai M. Josuttis
Publisher: Addison-Wesley Professional
Pub. in: August, 1999
ISBN: 0201379260
Pages: 832
Measurements: 9.5 x 7.7 x 1.7 inches
Origin of product: USA
Order code: BA00541
Other information: 1st edition
|
|
Rate this product:
|
|
- MSL Picks -
This is an excellent reference book on STL containers and algorithms, from the perspective of an intermediate-level programmer (self-taught, two years' C++). I use this reference every day - the hardcover helps it lie nicely on my desk - perhaps in part of what I'm doing: plain(?) C++, not Windows MFC, using the boost::bind from the (freely downloadable) C++ Boost Libraries to write functors (objects that define the call operator) for use as predicates in calling STL algorithms on STL containers. So yes, in my limited experience, Josuttis's book contributes to a happy level of productivity and lets me draw on the STL because it is part of a package deal: Meyer's Effective STL (e.g. item 43: prefer STL algorithm calls to hand-written loops, so as to improve code readability and speed), the Boost::bind library, and Josuttis's reference. If boost doesn't appeal, in chapter 8.3ff Josuttis does supply source code for supplementary composing function objects. With neither those nor boost, any STL algorithm using a functor parameter would likely not merit the learning time, and I'd have STL containers, iterators, and more hand-written loops.
One odd thing: the reference layout has worked well enough for me that I haven't felt the need to read from cover to cover, because the index & table of contents & occasional apt cross-reference almost always put me in the 1-5 pages that answer my question. I browsed another STL book in the bookstore today & wondered, why haven't I come across so helpful a description of user-defined iterators in Josuttis? When I got home, now with question in mind, I found the same information in Josuttis within a minute. I can readily imagine advanced users having questions not addressed in Josuttis, but at present his succinct STL pitfall flags, cautions & workarounds pretty much keep me from STL grief.
(From quoting Andrew of Canada)
Target readers:
C++ programmers, Computer Science majors, People interested in learning C++, and University lecturers.
|
|
- Better with -
Better with
Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition) (Addison-Wesley Professional Computing Series)
:
|
|
Customers who bought this product also bought:
|
|
Nicolai M. Josuttis is an independent technical consultant who designs object-oriented software for the telecommunications, traffic, finance, and manufacturing industries. He is an active member of the C++ Standards Committee Library Working Group. Nicolai has written several books on object-oriented programming and C++. See www.josuttis. com.
|
|
From the Publisher:
Soon after its introduction, C++ became a de facto standard in object- oriented programming. This led to the goal of standardization. Only by having a standard, could programs be written that would run on different platforms - from PCs to mainframes. Furthermore, a standard C++ library would enable programmers to use general components and a higher level of abstraction without losing portability, rather than having to develop all code from scratch.
The standardization process was started in 1989 by an international ANSI/ISO committee. It developed the standard based on Bjarne Stroustrup's books The C++ Programming Language and The Annotated C++ Reference Manual. After the standard was completed in 1997,several formal motions by different countries made it an international ISO and ANSI standard in 1998. The standardization process included the development of a C++ Standard Library. The library extends the core language to provide some general components. By using C++'s ability to program new abstract and generic types, the library provides a set of common classes and interfaces. This gives programmers a higher level of abstraction. The library provides the ability to use string types, different data structures (such as dynamic arrays, linked lists, and binary trees), different algorithms (such as different sorting algorithms), numeric classes, input/output (I/O) classes, and classes for internationalization support.
All of these are supported by a fairly simple programming interface. These components are very important for many programs. These days, data processing often means inputting, computing, processing, and outputting large amounts of data, which are often strings.
The library is not self-explanatory. To use these components and to benefit from their power,you need a good introduction that explains the concepts and the important details instead of simply listing the classes and their functions. This book is written exactly for that purpose. First, it introduces the library and all of its components from a conceptional point of view. Next, it describes the details needed for practical programming. Examples are included to demonstrate the exact usage of the components. Thus, this book is a detailed introduction to the C++ library for both the beginner and the practical programmer. Armed with the data provided herein, you should be able to take full advantage of the C++ Standard Library.
|
I don't promise that everything described is easy and self-explanatory. The library provides a lot of flexibility,but flexibility for nontrivial purposes has a price. Beware that the library has traps and pitfalls,which I point out when we encounter them and suggest ways of avoiding them.
What You Should Know Before Reading this Book
To get the most from this book you should already know C++. (The book describes the standard components of C++, but not the language itself.) You should be familiar with the concepts of classes, inheritance,templates, and exception handling. However, you don't have to know all of the minor details about the language. The important details are described in the book (the minor details about the language are more important for people who want to implement the library rather than use it). Note that the language has changed during the standardization process,so your knowledge might not be up to date.
The section on newlang features provides a brief overview and introduction of the latest language features that are important for using the library. You should read this section if you are not sure whether you know all the new features of C++ (such as the keyword {\tt typename} and the concept of namespaces).
Style and Structure of the Book
The C++ Standard Library provides different components that are somewhat but not totally independent of each other,so there is no easy way to describe each part without mentioning others. I considered several different approaches for presenting the contents of this book. One was on the order of the C++ standard. However, this is not the best way to explain the components of the C++ Standard Library from scratch. Another was to start with an overview of all components followed by chapters that provided more details. Alternatively, I could have sorted the components, trying to find an order that had a minimum of cross- references to other sections. My solution was to use a mixture of all three approaches.
I start with a brief introduction of the general concepts and the utilities that are used by the library. Then, I describe all the components, each in one or more chapters. The first component is the standard template library (STL). There is no doubt that the STL is the most powerful, most complex, and most exciting part of the library. Its design influences other components heavily. Then I describe the more self-explanatory components, such as special containers, strings,and numeric classes. The next component discussed is one you probably know and use already: the iostreamlib{}. It is followed by a discussion of internationalization, which had some influence on the iostreamlib{}.
Each component description begins with the component's purpose, design, and some examples. Next, a detailed description follows that begins with different ways to use the component, as well as any traps and pitfalls associated with it. The description usually ends with a reference section, in which you can find the exact signature and definition of a component's classes and its functions.
How to Read this Book
This book is a mix of introductory user's guide and structured reference manual regarding the C++ Standard Library. The individual components of the C++ Standard Library are independent of each other, to some extent, so after reading Chapters 2 through 4 you could read the chapters that discuss the individual components in any order. Bear in mind,that Chapters 5 through 9 all describe the same component. To understand the other STL chapters, you should start with the introduction to the STL in chapter 5.
If you are a C++ programmer who wants to know, in general, the concepts and all parts of the library, you could simply read the book from the beginning to the end. However, you should skip the reference sections (which usually are named something like "...{} in detail}"). To program with certain components of the C++ Standard Library, the best way to find something is to use the index. I have tried to make the index very comprehensive to save you time when you are looking for something.
I can't explain all aspects at the same time, so you will find many cross references. It is always a problem to decide whether to follow them. If the cross reference refers to a section that will follow soon, take it as hint that I return to an aspect later. You should follow the cross reference only if you are searching for certain aspects or details and the cross reference seems to lead to details concerning your problem or its solution.
In my experience, the best way to learn something new is to look at examples. Therefore, you'll find a lot of examples throughout the book. They may be a few lines of code or complete programs. In the latter case, you'll find the name of the file containing the program's first comment line. You can find the files on the Internet at my Web site josuttis/libbook/.
State of the Art
While I was writing this book,the C++ standard was completed. Please bear in mind that some compilers might not yet confirm to it. This will most likely change in the near future. As a consequence, you might discover that not all things covered in this book work as described on your system,and you may have to change example programs to fit your specific environment. I can compile almost all example programs with version 2.Example Code and Additional Information
You can access all example programs and acquire more informations about this book and the C++ Standard Library from my Web site at josuttis/libbook/. Please read the {\tt README} file for further details. Also, you can find a lot of additional information about this topic on the Internet. See Internet Resources on page 743 for details.
Feedback
I welcome your feedback (good and bad) on this book. I tried to prepare it carefully; however, I'm human, and at some time I have to stop writing and tweaking. So, you may find some errors, inconsistencies, or subjects that could be described better. Your feedback will give me the chance to improve later editions. The best way to reach me is by Email: libbook@josuttis.
|
|
| View all 11 comments |
Sean Kelly (MSL quote), USA
<2007-01-11 00:00>
This book taught me things about C++ and the Standard Template Library that no C++ class ever has. In high school, I took a C++ class which taught me the very basics of C++. Now that I'm in college, I've taken several C++ classes, though none of them have even touched on the STL concepts covered in this book. If you know the basics of C++ and want to learn how to use the C++ Standard Template Library to its greatest potential, you MUST get this book.
This book covers virtually the entire C++ Standard Template Library in an easy to understand way. Not only does it have several graphs and tables which make it a great quick reference, it also goes in depth to make you understand how things are working. The footnotes make sure everything is totally clear and no corner is cut. There are many full examples, and the website has downloadable archives of the examples and more.
I can't say it enough. If you use C++ and don't know how to use the Standard Template Library, you need this book. It is interesting, informative, and well written. |
Andrew Lin (MSL quote), USA
<2007-01-11 00:00>
This book rocks. I learned C++ during the tumultuous years before standardization, then forgot the language due to lack of use in my job. Now that I am re-learning the language, I find that a lot has changed. Vague recollections of the way things worked often led me down the wrong path. C++ today is not the C++ I remember studying, to say the least.
Josuttis has cleared up all my questions and misunderstandings about Standard C++. Within the book are short sample programs illustrating how to use library components as well as clear, descriptive text on the objects in the Standard Library. Features are intelligently divided into chapters, which has, more than once, resulted in me finding a very novel way to solve a problem I only had a rough idea on how to solve.
Since buying this book, Stroustrup has sat idle on my bookshelf, and Lippman - well, Lippman's at work. Josuttis has made the C++ Standard Library much more accessible, making my transition from forgotten pre-standard C++ to Standard C++ much less painful than I expected. |
James Boer (MSL quote), USA
<2007-01-11 00:00>
Mr. Josuttis offers in this book an amazingly comprehensive guide to the often bewildering C++ standard library. I originally purchased this book looking for more STL information, and I was certainly not disappointed in that respect. STL descriptions account for nearly half of the book volume. However, as non-STL questions arose, I found myself digging into this book time and time again (questions about auto_ptr, string class, allocators, etc).
If you're a C++ programmer and do not already own a current (circa 1999 or later) library reference, do yourself and your code a favor and grab a copy of this book. C++ is an extremely scalable language. It's easy to use only knowing a small subset of the language and library features. Having a reference such as this one ensures that you'll be less likely to accidentally duplicate work that has already been done for you in the standard library.
As far as book organization goes, I'd say that the book does lean more towards "reference" rather than "tutorial", but I never believe a book that claims to be both anyhow. Anyone interested in a pure tutorial should buy a book specifically written with that in mind. For more experienced programmers not needing quite as much hand holding, however, the book does work as advertised.
Overall, I can't really recommend this book more enthusiastically. |
Eduardo (MSL quote), Venezuela
<2007-01-11 00:00>
Perhaps this book is the best one to help you to mature all of the C++ huge standard (ISO) library.It covers both the library and its underlying concepts pretty well and completely, with useful examples. This book has helped me to discover very interesting things about the C++ library that have boosted my effectiveness, while at the same time it has allowed me to reach a level of understanding of the library where I can extend it really nice, for instance, defining my own containers and iterators.
It has minor defects, though. Still, you can use it as reference. For example, the index is too small IMHO, and the documentation for routines, classes, templates, etc., surprisingly miss their exact prototypes, so, sometimes you must guess the right types of parameters and the stuff. In very few words, "It is really worth the price".
|
View all 11 comments |
|
|
|
|
