Operating Systems
Programming Languages
Microsoft Technologies
Computer Science
Software Engineering
Web Programming
Web Technologies

Contact Us | What's New | Missing Link | Feedback

C++ Language

Book Title : Applied C++: Techniques for Building Better Software
eBook download format(s) : HTM
ISBN-10 : 0321108949 
ISBN-13 : 978-0-321108-94-4 
Author(s) : Philip Romanik Amy Muntz 
Publisher : Addison-Wesley Professional (02 May 2003)
Section : C++ Language
Book Review:

Book Description
This book is about applying C++ to solve the problems inherent in building commercial software. Those of you who have worked on engineering teams building complex software will know exactly what we mean by calling it commercial software. Commercial software is delivered to customers (internal or external) who will rely on the interface you provide. It may be in an embedded system, or it may be a software library or application for standard platforms. No matter where it ultimately runs, the software must be released at a particular time with all of the features it needs to be successful in the market. It is software that is built by one group of engineers and potentially extended and maintained by other engineers. The engineers who take over maintaining the software may not have been part of the original team, and they might have to add features or try to fix problems while visiting customer sites. Getting a group of engineers to build a complex piece of software and deliver it on time with full functionality is one of software engineering's biggest challenges. An even bigger challenge is building that same software in such a way that it can be handed off to others to extend and maintain. The C++ techniques and practical tips we have compiled into this book have been used repeatedly to accomplish just this. In many cases, we draw a distinction between the ideal solution and the practical one. We try to provide discussions of the trade-offs so that you can make informed decisions, and we tell you what our criteria are when selecting one method over another. We leave it to you to determine what works best in your application. Our goal is to share practical techniques that we have found made our commercial software efforts much more successful than they otherwise would have been. We hope you will find them useful. For those of you who prefer to learn by looking at the code, you will find plenty of examples. We illustrate all of the techniques by using a concrete example that runs throughout the book. Because it was our experiences with imaging software that prompted us to write this book, our example comes from the image processing domain, but the C++ techniques are applicable to any domain. We start with a simple, although inadequate, application that generates thumbnail images. We use this application in our prototyping phases to experiment with different C++ design and implementation techniques. The application is simple to understand and the results of applying various C++ techniques are immediately obvious, making it a nice candidate for prototyping. This simple thumbnail image generator has many of the same inherent problems that our final image framework will have to address. The application is: Memory intensive. Working with images requires efficient use of memory, because images can get quite large and unwieldy. Managing memory becomes critical to the overall performance of the application. Performance intensive. While generating thumbnails is a straightforward image processing technique, others that we introduce later in the book (such as edge sharpening and noise reduction) require thoughtful designs to make them usable. It's great to have cool image functions to manipulate your digital images, but they are useless if they take a really long time to run. Upon completion, you will have an image processing framework for manipulating your digital images and a practical toolkit of C++ utilities. The framework will provide efficient image storage and memory usage, routines for manipulating your digital images (like edge sharpening, image resizing, noise reduction, edge detection, image subtraction, and more), interfaces to third-party software, and many performance optimizations. It will be a useful piece of software that has practical design and implementation features, so that you could even use it as the basis of a commercial software product. The complete source code for the thumbnail generator application, the prototypes, and the final image framework can be found on the included CD-ROM. Any updates to the software can be found at the web site: [a href="" target="new"> . Intended Audience We expect you to be familiar with C++ so that when we apply various constructs from the language, you have seen or used them before. We also assume that you have built applications either for personal or commercial use and are familiar with what the Standard Template Library (STL) can provide. We hope to engage you in detailed discussions of the advantages and disadvantages of certain C++ constructs. Finally, we hope you really like to look at actual code examples, because the book is filled with them. We do not attempt to provide a reference for the C++ language, but we do provide primers and reviews of those topics that have exacting syntax or are not used as frequently. For the basics of the C++ language, we refer you to The C++ Programming Language, Special Edition Stroustrup00. For in-depth discussions on certain C++ constructs, such as reference counting, we refer you to Effective C++, Second Edition Meyers98. For information on the Standard Template Library, we refer you to Effective STL Meyers01. For information on using C++ templates, we refer you to C++ Templates Vandevoorde03. As for our chosen domain of digital imaging, we don't expect you to have any experience with writing software that manipulates images. We provide some basic information about imaging that you can review; if you are familiar with imaging, you can skip that section. Whenever we talk about a particular operation that we apply to an image, we take the time to give a simple explanation, as well as some before and after pictures, before proceeding to the code example. If you want an in-depth, mathematical discussion of image processing operations, we refer you to Digital Image Processing Pratt01. How to Use This Book The book is intended to be read sequentially, since there is a concrete example introduced in Chapter 2 and used to evolve the final design of the image framework that is presented in Chapter 5. Throughout the book, we highlight the C++ techniques we are exploring in heading titles and in summary boxes that appear on the first page of each chapter. The book is organized as follows: Chapter 1, Introduction, provides an overview of what we set out to accomplish by writing this book, and reveals our background and biases as they apply to the C++ techniques we recommend. We also provide an optional background section on digital imaging. If you have experience working with imaging applications, you may want to skip the final section of this chapter. Chapter 2, A Test Application, introduces our simple, inadequate application, used as a test bed for prototyping C++ techniques. We deliberately create this strikingly simple application because it effectively demonstrates the trade-offs of various design and implementation decisions. Chapter 3, Design Techniques, begins our discussion of C++ design. We use lots of code examples to demonstrate design strategies, and we provide a primer on templates since they are used so heavily within the book. Finally, we prototype various aspects of the design and build general utilities needed to support the design. Chapter 4, Design Considerations, explores guidelines and additional strategies you may want to use in your designs. We offer a practical set of coding guidelines, reusability strategies, and a simple but effective debugging strategy. Chapter 5, System Considerations, explores system-level design issues, like multi-threaded and multi-process designs, exception handling (including a framework we provide for handling exceptions), compile time and run-time issues, template specialization, and internationalization concerns. Chapter 6, Implementation Considerations, applies the C++ techniques we have explored to the final design and implementation of all pieces in the image framework. In addition, this chapter introduces global image processing functions, like edge sharpening and noise reduction, and provides both a visual overview of these techniques and the C++ implementations. We also provide a high-level interface to libraries and other third-party software. Specifically, we introduce you to the Intel Integrated Performance Primitives (IPP) library and show you how to use IPP for high-speed imaging applications. Chapter 7, Testing and Performance, provides a reasonable strategy for integrating unit tests into your software development cycle, including a full unit test framework and a discussion of how you can extend it to meet your particular needs. We also focus on performance, giving specific techniques that you can use to immediately improve the run-time performance of your application. Chapter 8, Advanced Topics, explores those issues that we felt warranted more detailed discussion, such as copy on write, caching, explicit keyword usage, const, and pass by reference. We also include a section on extending the image framework, to serve as a guide for taking the existing framework and adding your own processing functions. We've highlighted some routines that work particularly well for enhancing your digital photographs. Appendix A, Useful Online Resources, provides links to those software tools and resources that we thought might be helpful. Appendix B, CD-ROM Information, outlines the contents of the CD-ROM included with this book. There is a great deal of code presented in this book. All of the source code for our test application, prototypes, and image framework is included on the disc. In addition, we provide all of the unit tests, unit test framework, and makefiles necessary to run the software on a variety of platforms. We also include some useful third-party software: the freeware DebugView utility by SysInternals for Microsoft Windows, the evaluation version of the Intel Integrated Performance Primitives (IPP) library for Microsoft Windows and Linux, the evaluation version of the Intel C++ Compiler for Microsoft Windows, the source code to build ...

add to                 Digg!

You may use anyone of the download options

eBook VersionBuy this book from Amazon
Front Cover

Missing Link?, Report It and you may wish to  Buy  this book from amazon

Tell a Friend!

Similar Book titles in C++ Language section:
C++ in Action: Industrial Strength Programming Techniques
Software Engineering using C++
C++: A Dialog: Programming with the C++ Standard Library
Industrial Strength C++: Rules and Recommendations
Software Design Using C++
Techniques for Scientific C++

Similar Book titles in Other sections:

Section: Bio-Chemistry
Applied Molecular Biology: Beginning Laboratory Manual

Section: CS -> Compilers and Languages
Working with Objects: The Ooram Software Engineering method
Parsing Techniques - A Practical Guide
Advanced Programming Language Features for Executable Design Patterns -Better Patterns Through Reflection
Inductive Logic Programming - Techniques and Applications
Tree Automata Techniques and Applications
Show all..

Section: Data Structures and Algorithms
Concepts, Techniques, and Models of Computer Programming
Computer Animation: Algorithms and Techniques

Section: Parallel Computing
Handbook of Applied Expert Systems
Designing and Building Parallel Programs
Developing Component Software with CORBA

Section: CS -> Theory
Tree Automata Techniques and Application
ICT4D - Connecting People for a Better World

Section: DB -> DB / 2
IBM DB2 Building Applications for UNIX Environments

Section: Photography
Digital Photography Expert Techniques
Shoot Like a Pro! - Digital Photography Techniques

Section: Computer Hardware
Build Your Own Laptop - An Impractical Guide to Building a Laptop Computer

Section: Microprocessor
IA-32 Intel Architecture Software Developer's Manual Volume 2: Instruction Set Reference
IA-32 Intel Architecture Software Developer's Manual Volume 3: System Programming Guide
IA-64 Software Conventions and Runtime Architecture Guide
Mixed-signal and DSP Design Techniques

Section: Internet
Software Engineering for Internet Applications (Workbook)
Building an Online Community
Building Internet Firewalls
Building an Intranet with Windows NT 4
Building Your Business with Google for Dummies
Show all..

Section: Java Enterprise Edition
J2EE Technology in Practice: Building Business Applications with the Java2 Platform
Tutorial For Building j2Ee Applications Using Jboss And Eclipse

Section: Java Tools
Building AS/400 Internet-Based Applications with Java

Section: Mathematics
Lapack Users' Guide (Software, Environments and Tools, 9)
Templates for the Solution of Linear Systems: Building Blocks for the Iterative Methods
Derivations of Applied Mathematics
Linear Methods of Applied Mathematics
Applied Abstract Algebra
Show all..

Section: Miscellaneous
Guide to Software Engineering Body of Knowledge
Statistical Software Engineering
Software Project Management, 2nd Ed.
Applied Cryptography: Protocols, Algorithms, and Source Code in C, 2nd Edition
Rf And Baseband Techniques for Software Defined Radio
Show all..

Section: Sales, Marketing & Trading
Software Product Management: Managing Software Development from Idea to Product to Marketing to Sales

Section: Microsoft C Sharp (C#)
C# - Your Visual Blueprint for building .Net applications

Section: Microsoft .(dot) net
Applied Microsoft .Net Framework Programming
Building Dot Net Applications For Mobile Devices
Building Secure ASP.NET Applications: Authentication, Authorization, and Secure Communication

Section: Microsoft Visual C++
Building Internet Applications with Visual C++

Section: Networking
Security Engineering: A Guide to Building Dependable Distributed Systems
Rethinking Public Key Infrastructures and Digital Certificates: Building in Privacy
Building Wireless Community Networks 2nd Edition
Wi-Fi Handbook. Building 802.11b Wireless Networks
Building Cisco Networks for Windows 2000
Show all..

Section: Other Engineering
Principles of Applied Reservoir Simulation

Section: GNU/Linux OS
The Linux Cookbook - Tips and Techniques for Everyday Use
Building Applications with the Linux Standard Base

Section: Embedded and RTOS
Building Embedded Linux Systems
Embedded System Design: A Unified Hardware/Software Approach

Section: Assembly Language
Intel Architecture Software Developerís Manual
Introduction to Reverse Engineering Software

Section: Other Programming
On LISP: Advanced Techniques for Common LISP
Object Oriented Software in Ada 95, Second Edition
Ada for Software Engineers
Ada and Beyond: Software Policies for the Department of Defense
Building Expert Systems in Prolog
Show all..

Section: Perl Scripting
Effective Perl Programming: Writing Better Programs With Perl

Section: Scripting
Thinking in Python: Design Patterns and Problem-Solving Techniques
Building Skills in Programming - How To Write Your Own Software Using Python

Section: Redbooks Draft
Building Composite Applications
Patterns: Building Serial and Parallel Processes with WebSphere Process Server V6
System i Application Modernization: Building a New Interface to Your Legacy Applications
iSeries Application Modernization: Building a New Interface to Your Legacy Applications
Certification Guide Series: IBM Tivoli Provisioning Manager Express for Software Distribution Version 4.1
Show all..

Section: Redbooks
Deployment Guide Series: IBM Tivoli Provisioning Manager Express V4.1 for Software Distribution
Passenger Risk Management Infrastructure Solution Building Block: Installation and Configuration Guide
IBM Workplace Forms: Guide to Building and Integrating a Sample Workplace Forms Application
Building SOA-based Solutions for IBM System i Platform
IBM System i Application Modernization: Building a New Interface to Legacy Applications
Show all..

Section: IBM Technotes
Deployment Considerations for Tivoli Provisioning Manager Express for Software Distribution

Section: Redpapers
Tips and Techniques for Using TCP/IP on i5/OS
IBM Software Express Buying and Selling Guide
Building Service-Oriented Banking Solutions with IBM Banking Industry Models and Rational SDP
Techniques to Build a Diskless Boot Linux Cluster of JS21 Blades
Building Composite Applications in Lotus Expeditor V6.1
Show all..

Section: Redpapers Draft
Techniques to Build a Diskless Boot Linux Cluster of JS21 Blades
Building Composite Aplications in Lotus Expeditor V6.1
Building Composite Applications in Lotus Expeditor V6.1
Building Service-Oriented Banking Solutions with the IBM Banking Industry Models and Rational SDP
Improving your WebApplication Software Development Life Cycle's Security Posture with IBM Rational AppScan
Show all..

Section: Software Engineering
Software Development Guidelines
Understanding Open Source and Free Software Licensing
Reusable Software Components: Object-Oriented Embedded Systems Programming in C
Adaptive Object-Oriented Software
Object-Oriented Software Composition
Show all..

Section: Software Testing
Practical Software Testing: A Process-Oriented Approach
Systematic Software Testing
Testing and Quality Assurance for Component-Based Software
Effective software testing: 50 specific ways to improve your testing
A Practitioner's Guide to Software Test Design
Show all..

Section: Web Programming
Secure PHP Development: Building 50 Practical Applications
Pro JSF and Ajax: Building Rich Internet Components

Section: Web Technology
Building Accessible Websites

Section: XML, XSL & UML
Developer's Guide to Building XML Based Web Services with J2EE

Similar Books from Amazon :

Tell a Friend!

©2008 - Home - Privacy Policy - Program Policy, Terms and Conditions