Cantitate/Preț
Produs
Total produse
Vezi coșul
Up and Running with C++ de Jan Graba

Up and Running with C++

Autor Jan Graba
en Limba Engleză Paperback – 17 mar 1998
Up and Running with C++ provides readers with a quick guide to the fundamental concepts of object orientation (O-O) and their implementation in C++. Written in a user-friendly style, no prior knowledge of C or C++ is assumed. The book introduces the concepts and terminology of object-orientation using a step-by-step approach and shows how to implement the central concepts of O-O in C++. The building blocks of the C++ language are clearly presented with numerous examples that will give readers practice in writing applications. The book avoids excessive technical detail and will be ideal for programmers and students who need an easy-to-understand, comprehensive introduction to C++.
Citește tot Restrânge

Preț: 64779 lei

Preț vechi: 80973 lei
-20% Nou

Puncte Express: 972
Preț estimativ în valută:
12395€ • 12977$ • 10256£

Carte tipărită la comandă

Livrare economică 05-19 aprilie

 Adaugă în coș

Wish list
Gift list
Am citit!
Adaugă în listă
Preluare comenzi: 021 569.72.76

Specificații

ISBN-13: 9783540762348
ISBN-10: 3540762345
Pagini: 316
Ilustrații: IX, 304 p.
Dimensiuni: 155 x 235 x 17 mm
Greutate: 0.48 kg
Ediția:Softcover reprint of the original 1st ed. 1998
Editura: SPRINGER LONDON
Colecția Springer
Locul publicării:London, United Kingdom

Public țintă

Research

Cuprins

1 The Fundamentals of Object Orientation.- 1.1 Brief Background.- 1.2 Basic Concepts and Terminology.- 1.2.1 Objects.- 1.2.2 Object-Orientated Programming (OOP).- 1.2.3 Inheritance.- 1.2.4 Message-Passing.- 1.2.5 Polymorphism.- 1.3 The Motivation for a New Approach.- 1.4 Why OOP?.- 1.5 The Next Few Chapters.- 2 First Steps in C++ Programming.- 2.1 The Basic Structure of a C++ Program.- 2.2 Basic Data Types and Variable Declarations.- 2.3 Type Conversions.- 2.4 Constants.- 2.5 Standard Input and Formatted Output.- 2.6 Enumerated Types.- 2.7 The Scope of a Variable.- 2.8 The Lifetime of a Variable.- 2.9 Common Operators.- 2.9.1 The Assignment Operator.- 2.9.2 Arithmetic Operators.- 2.9.3 The Bitwise Operators.- 2.9.4 Conditional Operator.- 2.9.5 Compound Operators.- 2.9.6 Comma Operator.- Exercises.- 3 Selections and Iterations.- 3.1 The Relational Operators.- 3.2 Selection Statements.- 3.2.1 The if Statement.- 3.2.2 The switch Statement.- 3.3 Iterations.- 3.3.1 The while Statement.- 3.3.2 The do Statement.- 3.3.3 The for Statement.- 3.4 The Use of break and continue.- 3.5 The Logical Operators.- Exercises.- 4 Functions and Header Files.- 4.1 Functions.- 4.1.1 The C++ Approach and Rationale.- 4.1.2 Function Syntax.- 4.1.3 Inline Functions.- 4.2 Linkage 34.- 4.3 Non-System Header Files.- 4.4 The Multiple Inclusion Problem.- 4.5 Function Overloading.- 4.6 Default Arguments.- Exercises.- 5 Arrays, Pointers and References.- 5.1 Structured Types.- 5.2 Array Declaration and Usage.- 5.3 Array Initialisation.- 5.4 Array Processing.- 5.5 Strings.- 5.6 Pointers.- 5.7 Pointers and Arguments.- 5.8 Arrays and Pointers.- 5.9 The NULL Pointer.- 5.10 Strings Revisited.- 5.11 Functions for String Processing.- 5.12 Memory Allocation for Strings.- 5.13 Reference Types.- 5.14 References as Arguments.- Exercises.- 6 Adding Sophistication to Basic I/O.- 6.1 Handling ‘Whitespace’ in Text Input.- 6.2 The Formatting of Output Via Manipulators.- 6.2.1 Common Manipulators.- 6.2.2 Common Formatting Flags.- Exercises.- 7 Classes in C++.- 7.1 Structures.- 7.2 Explicit Class Declarations.- 7.3 Access Control.- 7.3.1 Private Access.- 7.3.2 Public Access.- 7.3.3 Default Access Levels.- 7.4 Member Function Definitions.- 7.5 Using a Class.- 7.6 Inline Member Functions.- 7.7 Constructors.- 7.7.1 General Purpose, Syntax and Rationale.- 7.7.2 Constructor Overloading.- 7.7.3 Default Constructors.- 7.7.4 Copy Constructors.- 7.8 Destructors.- 7.9 Arrays of Objects.- 7.10 Objects Within Objects.- 7.11 The this Pointer.- 7.12 Static Class Members.- Exercises.- 8 Dynamic Memory Management.- 8.1 Introduction.- 8.2 new and delete.- 8.3 Dynamic Memory Usage with Classes.- 8.4 Dynamic Data Structures.- 8.5 Dynamic Arrays of Objects.- 8.6 Dynamic Instance Variables.- Exercises.- 9 Inheritance.- 9.1 Inheritance in the Context of Object Orientation.- 9.2 Inheritance in C++.- 9.2.1 Syntax.- 9.2.2 Access Rights of Derived Classes.- 9.2.3 Base Class Constructors In Initialisation Lists.- 9.2.4 Bringing it all Together.- 9.2.5 Redefining Inherited Functions.- 9.2.6 The Assignment Compatibility Rule.- 9.3 Designing a Class Hierarchy.- 9.3.1 Existing Methods.- 9.3.2 General Principles.- 9.3.3 Windows Interface Example.- 9.3.4 MLS. Example.- Exercises.- 10 Polymorphism.- 10.1 Polymorphism in the Context of Object Orientation.- 10.2 The Assignment Compatibility Rule Revisited.- 10.3 Function Binding.- 10.4 Virtual Functions.- 10.5 Constructors and Destructors.- 10.6 Pure Virtual Functions and Abstract Base Classes.- 10.7 Heterogeneous Linked Lists.- Exercises.- 11 Friend Functions and Operator Functions.- 11.1 Access Problems.- 11.2 Friend Functions.- 11.2.1 Individual Friend Functions.- 11.2.2 Friend Classes.- 11.3 Operator Functions and Operator Overloading.- 11.3.1 General Use of Operator Functions.- 11.3.2 Operator Functions Within Classes.- 11.3.3 The Input and Output Operators.- 11.3.4 Multiple Overloading of Operator Functions.- 11.3.5 The Assignment Operator.- 11.3.6 Assignment v Initialisation.- Exercises.- 12 File Handling.- 12.1 File Streams.- 12.2 Opening and Closing Files.- 12.2.1 Creating an Unattached Stream.- 12.2.2 Creating an Attached Stream.- 12.3 Writing and Reading Lines To/From a Text File.- 12.4 Character-Level I/O.- 12.5 cin and cout as Files.- 12.6 Using Command Line Parameters.- 12.7 Random Access.- 12.7.1 The File Pointer.- 12.7.2 Reading and Writing.- 12.7.3 Testing for End of File.- Exercises.- 13 Templates.- 13.1 Introduction.- 13.2 Template Functions (‘Generic Functions’).- 13.3 Parameterised Types (‘Generic Types’).- Exercises.- Appendix A Exception Handling.- Appendix B Platform Variations.- B.1 Borland C++.- B. 1.1 Creating and Running a Program.- B.1.2 Single-key Input.- B.1.3 Screen-Handling.- B.2 Unix Implementations.- B.2.1 Compiling and Running a Program.- B.2.2 Unix Screen-Handling.- Appendix C Stream Formatting.- Model Solutions to Programming Exercises.

Caracteristici

Teaches the fundamental concepts of object orientation and the implementation of those concepts in C++ * Uses examples throughout, to illustrate the material and each chapter contains a series of programming exercises, making it very reader-friendly * Aimed at people with knowledge of another high level programming language, and does not assume any knowledge of C++