Search in Book Reviews

Unfortunately, this is just another book on basic data structures and some software tools. There are (much) better books. Let us see why.

The first chapter describes function templates and explains reasons for their use comparing them to the early methods of generalisation - macros and standard C library functions such as

bsearch()

qsort()

Template classes are described in Chapter 2. The classic container classes are built here: bounded array, queues, stack, linked list, and binary tree. Here begins our suspicion in the authors expertise:

I do not see this as an improvement. Firstly, I do not know what grammar has to do with terminology. Secondly, that sentence could have been spent on explaining that computer science looks at the tree upside down, similar to a family tree that is drawn starting from a distant ancestor. That is not a confused metaphor but a familiar example. Furthermore, the definition is imprecise, and precision is one of the traits of scientists. It is not clear from Schildt's definition that only terminal nodes are called leaves, and all others are internal nodes. Finally, a tree has only one root, not several of them that grow in layers. The tree grows by adding more terminal nodes (leaves) to the existing nodes of the tree. Similarly, a real tree grows by sprouting new branches from the existing ones.

The code for a binary tree template class is even more confusing. The root is a

public

private

At the end of this chapter the author suggests that the reader creates his own library of templates similar to these, without even mentioning that all of them exist in the STL (and much better implemented). In the whole book, he mentions (without any explanation) STL just three times.

The third chapter describes a generic recursive-descent parser. Schildt recommends the use of

setjmp()

longjmp()

try, catch,

throw

Chapter 4 covers Sparse Arrays C++ style. Approaches with a linked list, binary tree, pointer array, and hashing are described. Understanding and using run-time type information is the topic of the fifth chapter:

typeid

dynamic_cast

Chapter 6 finally covers standard string class and uses it for a line- oriented editor. Let us take a look at Schildt's code in class function

load(string fname)

string text

private

while (!in.eof()) {

in.get(ch);

if (!in.eof()) text += ch;

}

Perhaps a small rearrangement would make the code more efficient the repeated tests in the

while

if

In the seventh chapter he explains basic cryptography: substitution, transposition, and bit-manipulation ciphers. Basic data compression techniques, 8 into 7 and 4 into 3, are explained after that. Schildt suggests the reader try the Lempel-Ziv algorithm. I think that book with this title should have implemented Lempel-Ziv algorithm instead of the naive ones listed above.

Interfacing with assembly language is described in Chapter 8. Here is one of Schildt's reasons you might need that:

private

private

public

No comment.

Chapter 9 discusses implementation of new data types in C++, and implements the Set type. In Chapter 10, he implements an interpreter for a subset of BASIC. Finally, the last, eleventh chapter, covers basics of Java and appendix of the book gives the (incomplete) summary of C++ keywords. The review of Java is too short and has several vague generalisations similar to these:

I must admit that Schildt writes well, but, overall, the book mostly covers the basic topics from data structures. The rest of the topics are hardly advanced, only the simplest algorithms are implemented. Hence, the title is exaggerating, and as far as Schildt's expertise is concerned I think it is evident from the quotes. The same choice of topics with appropriate, less ambitious title, and better honed implementations could make a good book. However, if you want to learn the above topics, I recommend you to take a good book on data structures, and read old but still good

ed

RATFOR