 |
GetTextbooks.co.uk
Compare Prices & Save up to 90% |
|
|
|
| Login | Sign up | My Wish List |
 | | Scientific and Engineering C++: An Introduction with Advanced Techniques and Examples by John J. Barton, Lee R. Nackman ISBN-10: 9780201533934 ISBN-10: 0-201-53393-6 ISBN-13: 9780201533934 ISBN-13: 978-0-201-53393-4 Paperback 1994-08-19 Addison-Wesley Professional Find Lowest Price |
Reviews | ||
great introduction into C++ for older programmers I work mostly in fortran and a little in C, so it was nice to find a text that approached things from the perspective of learning a new language, vs. learning my first language. The only downside is that the text is a bit dated and could benefit from a new addition. | ||
classic of modern template design It's unusual for a book on scientific computing to gain currency in mainstream software development, but a small number of C++ authors in the know have been recommending this since its publication, and rightly so. Skim read the first 300 pages, which introduces C++ to Fortran and C programmers, without being too interesting, with the exception of the illustration of a Fallible class, which is like Haskell's Maybe. It's a neat use of templates, which has nothing to do with typesafe containers of T. Fortunately, the rest of the book is in this vein, providing a very thorough introduction to object oriented design, using scientific examples. Don't think you need to read another introduction to OOP? No problem: the applications include modelling algebraic structures to provide mixins that provide + and * operators, function objects, wrapping C and Fortran libraries (e.g. LAPACK), implementing arrays and matrices, and an SVD solver. All good solid scientific programming, and all of which makes use of templates (including an appearance of the Curiously Recurring Template), in as elegant a way as the earlier implementation of Fallible In particular, the authors make excellent use of the ability to use non-type template parameters. These were introduced into C++ as an optimisation so that library designers could know at compile time how large a container was - here, they're used to implement dimensional analysis, to provide compile time safety when multiplying and dividing quantities (e.g. speed and time) with units. This exemplifies the authors' use of templates - creative and eye opening, but not too baroque. In these pages you will see the beginning of the major direction taken by C++ in recent years - template metaprogramming. How interesting you find it may be proportional to how numerically nerdy you are, but whatever your interests in matrices, technically, this provides an essential introduction to advanced template usage. You'll find the transition to the material in Generative Programming or Modern C++ Design much easier if you digest the template usage here. And arguably, the resulting code in this book is at a sweet spot of functionality, readability and maintainability, compared to the more arcane representations in those later books mentioned above. Being a scientific computing book, it's a tad pricey compared to some others that might be on your reading list, but it's still well worth your (or your company's?) cash. | ||
Excellent text, though a bit dated Barton and Nackman is probably the best advanced C++ book I have read. It covers the basics of C++ programming for FORTRAN and C programmers, then dives into more advanced material. The book discusses many important design issues, such as how to represent and take advantage of name, structure, and function commonality. Several of the later chapters build extended examples making use of advanced template techniques. One chapter develops in detail a family of array classes, another presents classes for smart pointer functionality. Though this book predates the standard template library, it discusses the use of iterators to provide sequential access to data stored in classes. My favorite chapters build a family of template classes to implement algebraic categories, e.g. groups, monoids, rings, and fields, and a set of classes to implement some rudimentary symbolic computation capabilities through function objects. The use of templates in the later chapters is truly advanced and it is fascinating to see many of the tricks templates allow you to perform. My only gripe with the book is its age. It predates the ISO/ANSI C++ standard and the standard template libraries. It would be interesting to see how the authors would incorporate these recent advances into their treatment of advanced C++ programming. Despite being a book for scientists and engineers, Barton and Nackman should be read by everyone doing serious C++ programming. Highly recommended. | ||
Superb introduction to OOP in C++ I was first interested in this book for its implication of the title, scientific computing (whatever it is). However, I must say I was pleasantly surprised to learn that the book is not just relevant for the implied target audience, but also for those who need a good introduction to OOP with C++. What makes this book great for learning OOP is that it is rich in concrete examples that are relevant for people who have worked in science or engineering. Many OOP books take more abstract approaches, and often the relevance of discussions for the practical situations is not clear. It is not the case with this book. Another thing I like is the quick and concise introductions of C++. I think the authors do a great job of summarizing "do's and don'ts" of C++ by extracting the information in indented, bullet style lines throughout the book. Other C++ books are just enormous and often it is hard to find relevant information. I would guess the drawbacks of learning from this book is that if you do not have any background in science or engineering, you might have harder time understanding some examples in it. Also, the book is somewhat outdated in terms of coding practices (pre-Standard Library, etc.). In any case, the superb introduction to C++ OOP is in this book, which mostly remains unmentioned when people talk about good C++ books authored by other prominent authors. This one definitely deserves better recognition. | ||
Excellent examples of advanced templates I found this book to be very good, except for a few unnecessary parts. A lot of what the book covers (i.e., "scientific & enginnering") doesn't overlap my problem domain, and the Fortran/C intro sections were skipped since I already knew C++. It would have been better if the Fortran/C sections were put into different books. However, the rest of the book was excellent; even the stuff I didn't use right away was intellectually stimulating. This book should be bought by every serious C++ programmer. Barton and Nackman show several *excellent* examples of more advanced template usage than the boring old "generic container". For those of you who are more familiar with advanced template programming, the "B&N trick" gets its name because it's in this book. | ||