oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
Jetzt eintauschen
und EUR 11,07 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Large-Scale C++ Software Design (Addison-Wesley Professional Computing) [Englisch] [Taschenbuch]

John Lakos
4.6 von 5 Sternen  Alle Rezensionen anzeigen (20 Kundenrezensionen)
Preis: EUR 52,36 kostenlose Lieferung Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 5 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Samstag, 25. Oktober: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Kurzbeschreibung

10. Juli 1996 Addison-Wesley Professional Computing
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. This is the definitive book for all C++ software professionals involved in large development efforts such as databases, operating systems, compilers, and frameworks. It is the first C++ book that actually demonstrates how to design large systems, and one of the few books on object-oriented design specifically geared to practical aspects of the C++ programming language. In this book, Lakos explains the process of decomposing large systems into physical (not inheritance) hierarchies of smaller, more manageable components. Such systems with their acyclic physical dependencies are fundamentally easier and more economical to maintain, test, and reuse than tightly interdependent systems.In addition to explaining the motivation for following good physical as well as logical design practices, Lakos provides you with a catalog of specific techniques designed to eliminate cyclic, compile-time, and link-time (physical) dependencies. He then extends these concepts from large to very large systems. The book concludes with a comprehensive top-down approach to the logical design of individual components. Appendices include a valuable design pattern "Protocol Hierarchy" designed to avoid fat interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference. 0201633620B04062001

Wird oft zusammen gekauft

Large-Scale C++ Software Design (Addison-Wesley Professional Computing) + Effective C++: 55 Specific Ways to Improve Your Programs and Designs (Addison-Wesley Professional Computing) + Effective STL: 50 Specific Ways to Improve the Use of the Standard Template Library (Addison-Wesley Professional Computing)
Preis für alle drei: EUR 116,26

Die ausgewählten Artikel zusammen kaufen


Produktinformation


Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. This is the definitive book for all C++ software professionals involved in large development efforts such as databases, operating systems, compilers, and frameworks. It is the first C++ book that actually demonstrates how to design large systems, and one of the few books on object-oriented design specifically geared to practical aspects of the C++ programming language. In this book, Lakos explains the process of decomposing large systems into physical (not inheritance) hierarchies of smaller, more manageable components. Such systems with their acyclic physical dependencies are fundamentally easier and more economical to maintain, test, and reuse than tightly interdependent systems.In addition to explaining the motivation for following good physical as well as logical design practices, Lakos provides you with a catalog of specific techniques designed to eliminate cyclic, compile-time, and link-time (physical) dependencies.

He then extends these concepts from large to very large systems. The book concludes with a comprehensive top-down approach to the logical design of individual components. Appendices include a valuable design pattern "Protocol Hierarchy" designed to avoid fat interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference. 0201633620B04062001

Buchrückseite

Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, you will also need a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience.

This is the definitive book for all C++ software professionals involved in large development efforts such as databases, operating systems, compilers, and frameworks. It is the first C++ book that actually demonstrates how to design large systems, and one of the few books on object-oriented design specifically geared to practical aspects of the C++ programming language.

In this book, Lakos explains the process of decomposing large systems into physical (not inheritance) hierarchies of smaller, more manageable components. Such systems with their acyclic physical dependencies are fundamentally easier and more economical to maintain, test, and reuse than tightly interdependent systems. In addition to explaining the motivation for following good physical as well as logical design practices, Lakos provides you with a catalog of specific techniques designed to eliminate cyclic, compile-time, and link-time (physical) dependencies. He then extends these concepts from large to very large systems. The book concludes with a comprehensive top-down approach to the logical design of individual components. Appendices include a valuable design pattern "Protocol Hierarchy" designed to avoid fat interfaces while minimizing physical dependencies; the details of implementing an ANSI C compatible C++ procedural interface; and a complete specification for a suite of UNIX-like tools to extract and analyze physical dependencies. Practical design rules, guidelines, and principles are also collected in an appendix and indexed for quick reference.



0201633620B04062001


Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

Die hilfreichsten Kundenrezensionen
5 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Good book on Physical design of OOP 31. Juli 2000
Von Ein Kunde
Format:Taschenbuch
Though over 800 pages, it is very easy to read book. I think the presentation is well organized. All the major points are outlined clearly. following the charts, tables,graphes and sources, one can get essence of phyicial design immediately. (sometime I feel funny about all the definitions given by Mr.Lakos, they're too trivial to occupy some space as principals.) PartII on physical design concept is very useful for guys that already read effective c++, design patterns etc, which mostly dwell on logicial design issues. It's a thrill when I read them fisrt time as other oop classics. I think the part III on logical design is a mistake. There are lots of very good books teaching us how to write functions, oragnizing interfaces. I learned very little from those 200+ pages.
War diese Rezension für Sie hilfreich?
2 von 2 Kunden fanden die folgende Rezension hilfreich
Von Ein Kunde
Format:Taschenbuch
I second much of what has already been said in the previous reviews. This isn't a book for beginners, and its a tough read, but it contains many items that just aren't dealt with in any other book on C++ I've read. The most important point made is that _anything_ appearing in the C++ header file is part of the physical interface, and changing it will affect clients. As with most issues in programming, there's a trade off to be made between efficiency and insulation (and/or simplicity vs. flexibility), which this book tackles well. I certainly feel more confident about sucessfully translating an OOD into a workable C++ framework after reading and ingesting this book. Highly recommended.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Excellent book covering important but rare ropics 14. April 2000
Format:Taschenbuch
After having this book reccomended to me a number of times by various people, I decided to check it out. It is an excellent primer on how to design reusable classes in C++. It discusses a number of aspects of programming we tend to ignore, like the difference between logical and physical design. Anyone who wishes to write reusable, stable software in C++ should read this book.
I have one criticism, though, and that is that I believe the book is poorly organized. Although each individual peice of information in the book is useful and well thought out, I found that I wished he would cover things in a more natural order. Often I would read something and have to go back and reconcile it with what had been said earlier in the book, which was sometimes difficult. Don't let this criticism stop you from reading, however.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Helpful, to a point 17. Februar 1999
Von Ein Kunde
Format:Taschenbuch
The book offers a lot of tips early on explaining ways to avoid keeping everything in the headers to permit changes to occur without forcing a load of code to recompile.
My problem was that to avoid this recompilation the code has to get very confusing in hiding methods and variables.
I'm halfway through the book and a reread will definitely be required, but I guess all good things come at a cost. And when he is referring to large he is referring to applications which take multiple hours to compile. Smaller apps probably won't benefit as much.
The tips also lead towards saving time during the building/compiling stage while sacraficing application speed.
It's best point is that it brings up development issues which often get overlooked.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen If you think you're an expert, think again. 1. Dezember 1998
Format:Taschenbuch
I'm a single developer of about eight years who used to go around thinking that, being alone, the systems I write will always be small, and the interfaces between packages can be casual since I own both ends. Boy was I wrong! Lakos' book is the direct answer to the most persistent problems I've had with quality, maintainability and extensibility for the last year.
Even if you're a C++ genius, I'll bet the section on how redundancy (as in duplicated code) may be desirable will teach you something you didn't realize you needed to learn. And, the extensive coverage of physical insulation shows the path away from the dark side of development that logical design texts hardly even allude to. Read this book!
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen One of a kind 14. Dezember 1998
Von Ein Kunde
Format:Taschenbuch
After flipping through the pages of this book for two minutes, I knew that a miracle had occured. I have avoided buying many pathetically simple C++ books that introduce nothing more complex than the famous and ever annoying ATM machine example or the famous and even more annoying Shape/Square/ Circle example. Is there a C++ project that isn't large? Those are the only kind that I have worked on!! One C++ project that I worked on filled volumes of notebooks and took 3 hours to compile. This book has taught me things that no class or book ever has. Buy it!
War diese Rezension für Sie hilfreich?
4 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Great book, and it's not about C++ 22. August 2000
Von Ein Kunde
Format:Taschenbuch
This book is a *MUST* for any software developer involved in any medium to large-sized project. Most ideas in the book apply to any programming language, including C and Java. This is *not* a book about C++. It is a pity that the author mentioned "C++" in the title because it could have been an even bigger hit if he didn't!
War diese Rezension für Sie hilfreich?
3 von 4 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
Have you ever noticed that none of your introductions to C++ ever mention things like header files? This book corrects that omission with a vengeance, taking us deep into the nuts and bolts of real software. It describes things no other book is going to mention (e.g. redundant external include guards, or static nonmember functions to replace private members) and things the object-oriented community prefers to be silent about (e.g., encapsulation in files, not in classes).
Lakos's great strength is in pragmatics; this is advice on programming from someone who has been there. If your project is large enough to need source code control, it's large enough to need this book.
Sometimes the book drifts away from its roots, assuming a dragging academic tone. However, this does not change the overall rating -- a book with no substitutes.
War diese Rezension für Sie hilfreich?
Möchten Sie weitere Rezensionen zu diesem Artikel anzeigen?
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar