- Tapa blanda: 264 páginas
- Editor: Springer; Edición: 2012 (22 de febrero de 2012)
- Colección: Undergraduate Topics in Computer Science
- Idioma: Inglés
- ISBN-10: 1447127358
- ISBN-13: 978-1447127352
- Valoración media de los clientes: Sé el primero en opinar sobre este producto
- Clasificación en los más vendidos de Amazon: nº381.729 en Libros en idiomas extranjeros (Ver el Top 100 en Libros en idiomas extranjeros)
- Ver el Índice completo
Compara Precios en Amazon
+ Envío GRATIS
+ Envío GRATIS
Guide to Scientific Computing in C++ (Undergraduate Topics in Computer Science) (Inglés) Tapa blanda – 22 feb 2012
|Nuevo desde||Usado desde|
Descripción del producto
From the reviews:
“This book is intended for experts – mathematicians or other scientists who are familiar with the concept of programming in a high-level language and experienced in programming in languages like Fortran or MathLab. The book contains an almost full description of C++ capabilities listing the basic distinctive features of programming in it. It can serve as a fine manual for quick introduction to the subtleties of C++. … Finally a plenty of useful examples and exercises with solutions is presented.” (Nail Zamov, Zentralblatt MATH, Vol. 1246, 2012)
Reseña del editor
This easy-to-read textbook/reference presents an essential guide to object-oriented C++ programming for scientific computing. With a practical focus on learning by example, the theory is supported by numerous exercises. Features: provides a specific focus on the application of C++ to scientific computing, including parallel computing using MPI; stresses the importance of a clear programming style to minimize the introduction of errors into code; presents a practical introduction to procedural programming in C++, covering variables, flow of control, input and output, pointers, functions, and reference variables; exhibits the efficacy of classes, highlighting the main features of object-orientation; examines more advanced C++ features, such as templates and exceptions; supplies useful tips and examples throughout the text, together with chapter-ending exercises, and code available to download from Springer.Ver Descripción del producto
No es necesario ningún dispositivo Kindle. Descárgate una de las apps de Kindle gratuitas para comenzar a leer libros Kindle en tu smartphone, tablet u ordenador.
Obtén la app gratuita:
Detalles del producto
Si eres el vendedor de este producto, ¿te gustaría sugerir ciertos cambios a través del servicio de atención al vendedor?
Opiniones de clientes
|5 estrellas (0%)|
|4 estrellas (0%)|
|3 estrellas (0%)|
|2 estrellas (0%)|
|1 estrella (0%)|
Opiniones de clientes más útiles en Amazon.com
In Chapter 3, the authors discuss reading and writing to file streams. In every code snippet, they call the "close" member function on their fstream object. This is unnecessary as the fstream's destructor will do that for them. It might seem pedantic, but they are setting the stage for how to think in C++. This is not how C++ programmers should think. Using RAII is a basic tenet of C++, and the authors get it wrong almost immediately.
Chapter 4 is all about using "new" and "delete" in user code. This should never been done today (see C++ Core Guidelines). RAII is the de-facto resource control idiom in C++. I was hopeful that Chapter 6 (classes) would remedy this, but RAII is never discussed there.
Chapter 5's discussion about using pointers in interfaces never discusses the difference between owning and non-owning pointers. This is a massive area of easy confusion and dangerous territory for the newcomer. It is imperative to distinguish between these two ideas. They even advocate returning owning pointers from functions (Yikes!). Throughout, they confuse arrays with pointers to dynamically-allocated memory. These two things are not the same, and the so-called "decay rule" can really catch newcomers off guard. It's best to stay away from these dangerous areas. The authors also introduce the concept of a module as they are defined in Fortran90. Yet, C++ has no such concept (they are being considered for possibly C++20).
Chapter 8 has one of my favorite quotes from this book: "These containers and algorithms [from the STL] do not have many applications in scientific computing software and so we do not discuss these here." What's the first class they implement in Chapter 10? A vector. Sigh. Don't worry, though. In Chapter 12, they use a std::vector! There are no further mentions of templates in the rest of the book. I honestly don't know why it's even in there.
Their discussion of exception handling in Chapter 9 leaves out fundamental aspects of the exception handling model in C++: correctness (strong guarantee) and neutrality. These concepts cannot be "plugged in" as an afterthought, but must be considered at the very beginning of designing C++ software.
All of this is bad; really bad. But it pales in comparison to this quote from Appendix B: "A structure is a collection of variables that are combined together. Structures can be thought of as very simple classes, but without the ability to declare functions, access privileges, or any other properties of classes other than variables." This is completely wrong: a "struct" and a "class" in C++ are nearly identical; differing only in the default access specification and inheritance type. This really demonstrates the authors' complete lack of understanding of C++ and it's fundamental differences from the C language.
In addition to these specific issues, the authors continuously use C-style casts where none are needed due to the type conversion rules laid out in the C++ standard. The book was published in 2012: a year after the ISO standard for C++11 was finalized and two major compiler vendors supported most of the language (gcc and clang). It's absurd not to mention the new features of C++. The authors thought it prudent to enlighten the reader about function pointers, but didn't offer any discussion about lambdas. A whole chapter on pointers without any mention of std::shared_ptr (available since TR03!) or std::unique_ptr is inexcusable.