Accelerated C++

Name: Accelerated C++
Author: Andrew Koenig

Practical Programming by Example

Paperback Engels 2000 1e druk 9780201703535

54,94

In winkelwagen

Verwachte levertijd ongeveer 11 werkdagen

Samenvatting

This is a first-rate introductory book that takes a practical approach to solving problems using C++. It covers a much wider scope of C++ programming than other introductory books I've seen, and in a surprisingly compact format.

-Dag Brück, founding member of the ANSI/ISO C++ committee The authors present a clear, cogent introduction to C++ programming in a way that gets the student writing nontrivial programs immediately.
-Stephen Clamage, Sun Microsystems, Inc., and chair of the ANSI C++ committee Anyone reading just this one book and working through the examples and exercises will have the same skills as many professional programmers.
-Jeffrey D. Oldham, Stanford University Why is Accelerated C++ so effective? Because it
-Starts with the most useful concepts rather than the most primitive ones: You can begin writing programs immediately.
-Describes real problems and solutions, not just language features: You see not only what each feature is, but also how to use it.
-Covers the language and standard library together: You can use the library right from the start.

The authors proved this approach in their professional-education course at Stanford University, where students learned how to write substantial programs on their first day in the classroom. Whether you are eager to get started writing your first C++ programs, or you are already using C++ and seeking deeper understanding, the authors' unique approach and expertise make Accelerated C++ an indispensable addition to your library.

Specificaties

ISBN13:9780201703535

Trefwoorden:Programmeren, C++, Programmeertalen

Taal:Engels

Bindwijze:paperback

Aantal pagina's:352

Uitgever:Addison Wesley

Druk:1

Verschijningsdatum:14-8-2000

Hoofdrubriek:Computer en informatica

Lezersrecensies

Wees de eerste die een lezersrecensie schrijft!

Schrijf een recensie

Uw cijfer

?

Log in om te stemmen

Inhoudsopgave

Preface.

0. Getting Started.
-Comments.
-#include.
-The Main Function.
-Curly Braces.
-Using the Standard Library for Output.
-The Return Statement.
-A Slightly Deeper Look.
-Details.

1. Working with Strings.
-Input.
-Framing a Name.
-Details.

2. Looping and Counting.
-The Problem.
-Overall Structure.
-Writing an Unknown Number of Rows.
-Writing a Row.
-The Complete Framing Program.
-Counting.
-Details.

3. Working with Batches of Data.
-Computing Student Grades.
-Using Medians Instead of Averages.
-Details.

4.Organizing Programs and Data.
-Organizing computations.
-Organizing Data.
-Putting it All Together.
-Partitioning the Grading Program.
-The Revised Grading Program.
-Details.

5. Using Sequential Containers and Analyzing Strings.
-Separating Students into Categories.
-Iterators.
-Using Iterators Instead of Indices.
-Rethinking Our Data Structure for Better Performance.
-The List Type.
-Taking Strings Apart.
-Testing Our Split Function.
-Putting Strings Together.
-Details.

6. Using Library Algorithms.
-Analyzing Strings.
-Comparing Grading Schemes.
-Classifying Students, Revisited.
-Algorithms, Containers, and Iterators.
-Details.

7. Using Associative Containers.
-Containers that Support Efficient Look-Up.
-Counting Words.
-Generating a Cross-Reference Table.
-Generating Sentences.
-A Note on Performance.
-Details.

8. Writing Generic Functions.
-What is a Generic Function?
-Data-Structure Independence.
-Input and Output Iterators.
-Using Iterators for Flexibility.
-Details.

9. Defining New Types.
-Student_info revisited.
-Class Types.
-Protection.
-The Student_info class.
-Constructors.
-Using the Student_info class.
-Details.

10. Managing Memory and Low-Level Data Structures.
-Pointers and Arrays.
-String Literals Revisited.
-Initializing Arrays of Character Pointers.
-Arguments to Main
-Reading and Writing Files.
-Three Kinds of Memory Management.
-Details.

11. Defining Abstract Data Types.
-The Vec Class.
-Implementing the Vec Class.
-Copy Control.
-Dynamic Vecs.
-Flexible Memory Management.
-Details.

12. Making Class Objects Act Like Values.
-A Simple String Class.
-Automatic Conversions.
-Str Operations.
-Some Conversions are Hazardous.
-Conversion Operators.
-Conversions and Memory Management.
-Details.

13. Using Inheritance and Dynamic Binding.
-Inheritance.
-Polymorphism and Virtual Functions.
-Using Inheritance to Solve Our Problem.
-A Simple Handle Class.
-Using the Handle Class.
-Subtleties.
-Details.

14. Managing Memory (Almost) Automatically.
-Handles that Copy their Objects.
-Reference-Counted Handles.
-Handles that Let you Decide When to Share Data.
-An Improvement on Controllable Handles.
-Details.

15. Revisiting Character Pictures.
-Design.
-Implementation.
-Details.

16. Where Do We Go From Here?
-Use the Abstractions You Have.
-Learn More.

Appendix A: Language Details.
-Declarations.
-Types.
-Expressions.
-Statements.

Appendix B: Library Summary.
-Input-Output.
-Containers and Iterators.
-Algorithms.

Index.