- Paperback: 688 pages
- Publisher: Addison-Wesley Professional; 1 edition (August 19, 1994)
- Language: English
- ISBN-10: 0201533936
- ISBN-13: 978-0201533934
- Product Dimensions: 7.2 x 1.5 x 9 inches
- Shipping Weight: 2.5 pounds (View shipping rates and policies)
- Average Customer Review: 17 customer reviews
- Amazon Best Sellers Rank: #895,724 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Scientific and Engineering C++: An Introduction with Advanced Techniques and Examples 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
From the Inside Flap
Like many scientists and engineers, much of our work involves writing computer programs. Recently we have been writing those programs in C++. We think that our programs are better and that we can do better science and engineering with these programs because they are written in C++. We think you should try C++, and we wrote this book to help you get started.
C++ is one of several new languages that use a programming style called object-oriented programming. To write large programs that are correct, readable, modifiable, affordable, and efficient requires the same creative effort and persistence characteristic of other endeavors in science and engineering. Traditional programming languages, including FORTRAN and C, force us to communicate with the computer in a demeaningly simplistic manner. C++ and an object-oriented programming style elevate the communication to a more abstract level: They provide means for investing intellectual effort to produce better-quality programs and thus better-quality science and engineering, from a given programming project.
Learning C++ will be exciting. Although most of the programming ideas used in languages like FORTRAN, PASCAL, and C are still used in object-oriented programs, the new concepts reorganize the work. Like all new fields, object-oriented programming will seem foreign and exotic. C++ embodies a decade of new ideas from computer science backed up by practical experience. These new ideas will stimulate your thinking about programming and its role in your work. We hope you will find, as we have, that this new view changes programming from a tedious, albeit engaging, process to an intellectual enterprise more comparable to the processes we employ in other scientific and engineering work. Purpose
The purpose of this book is to teach you how to use C++ and the object-oriented programming style to produce better-quality programs, with an emphasis on scientific and engineering programs. Most such programs today are written in FORTRAN or C and without the benefit of any particular programming methodology. For small programs of strictly numerical content, FORTRAN or C may be adequate. However, larger programs and programs containing nonnumerical code are too expensive to understand, to revise, and to improve if written in FORTRAN or C. We present object-oriented programming as a design and programming style that addresses these problems and C++ as a programming language designed to allow efficient use of the object-oriented style. If you are still using FORTRAN or C in your programming, we invite you to explore a new world, the world of object-oriented programming in C++. Audience
Our book teaches object-oriented programming in C++, using examples from science and engineering. It is not a book about scientific computing or numerical analysis nor an introduction to programming. The book moves rapidly through the basic features and syntax of C++, material readily assimilated by an engineer or scientist experienced in programming or, indeed, by any experienced programmer. Our aim is to move quickly beyond syntax and rules to the more interesting and important concepts and techniques of object-oriented programming in C++. The latter part of the book applies the concepts and techniques developed to substantive examples. The examples are drawn primarily from science and engineering, but the concepts and techniques are broadly applicable.
We expect the book to be useful to three (overlapping) groups:
Engineers and scientists who are experienced programmers in
FORTRAN or C
Professional programmers experienced in C or C++ looking
for a new systematic discussion of object-oriented programming in C++
C++ programmers interested in advanced examples useful as a
basis for scientific and engineering programming.
In addition to programming experience, some of the examples assume the mathematical maturity typical of an undergraduate student in an engineering or scientific field.
Learning C++ and object-oriented programming will be a challenge regardless of your background. We were frankly amazed that computer programming could be so different. We hope you find this challenge stimulating and rewarding on its own; we are confident that once you understand C++ and object-oriented programming, you will not be satisfied with less. Acknowledgments
This book was made possible by the considerable patience of our employer, the Research Division of the IBM Corporation, and the personal patience and encouragement of our managers, colleagues, friends, and families. We began work on this book when we were in the Physical Sciences (Barton) and Manufacturing Research (Nackman) departments. Our managers in those departments--Read McFeely, Franz Himpsel, and Bruce Scott; Mike Wesley, Warren Grobman, and Russ Lange--supported and encouraged our work. A special thanks to the late Mike Wesley, manager, mentor, and friend for a decade: He recognized the importance of producing quality software for engineering applications and provided the environment, encouragement, and support for learning something about how to do it. We have completed work on the book in the Computer Science department, where we enjoy the considerable support and encouragement of our manager Mark Wegman.
We are indebted to all of our colleagues at IBM Research for having made it a special place to work and learn. We especially thank Michael Karasick and Derek Lieber for helping us, over many years, to learn C++ and how to use it, and Louis Terminello for timely and gracious encouragement. We also thank Bjarne Stroustrup and the developers of IBM's C++ compiler, especially Mark Mendell, Dave Streeter, and Ernest Choi, for correspondence and encouragement while we learned and relearned C++.
We were also fortunate to have the help of many reviewers; their comments improved many aspects of the book, ranging from typography to the book's organization. The comments of James Coplien, Tom Lyons, and William Press had an especially large impact on the book. As deadlines loomed, Michael Karasick read furiously through several drafts to help us weed out the worst confusions. We also thank John L. Bradberry, Goodwin Chin, Marshall Cline, Chris Codella, Margaret Ellis, Martin Giles, Franklin Gracer, Peter Juhl, Derek Lieber, Mark Linton, Tom Linton, Stanley Lippman, Alistair McClean, John Morar, Dean Pentcheff, V. T. Rajan, John Rehr, Chris Seekamp, Steve Stevenson, Bjarne Stroustrup, Bob Sutor, Dave Tolle, Hank Walker, and Robert Wang for their many suggestions. The efforts of all these people spared you the early drafts of the book.
Debbie Lafferty, our editor at Addison-Wesley, gently prodded and encouraged us at each step of the way, carefully balancing between pushing too little and too hard.
The love of our families--Ava, Rachel, Samuel, and Joel Nackman; Cynthia Butler and John Anthony and Andrew Butler Barton--has been essential. We thank them for their patience and understanding during all those times when working on the book took time away from them.
From the Back Cover
Barton and Nackman explore using C++ and the object-oriented programming style in scientific and engineering programs. The book emphasizes general concepts, systematic ways of using C++ features, advanced techniques, and particular styles that will help you write object-oriented programs. Examples are drawn from scientific and engineering applications, and the concepts, techniques, and styles are broadly applicable.
The book is organized into three parts. The first part builds a working knowledge of C++. The second part introduces object-oriented programming and design techniques, emphasizing the various ways to express commonality and abstraction. The third part illustrates coordination of advanced C++ features and techniques by developing several interesting examples, including array classes, pointer classes, systems employing abstract algebra, FORTRAN-based matrices, function mapping, and data fitting.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The only downside is that the text is a bit dated and could benefit from a new addition.
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<T>.
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.
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.