Cybernetics in C++
- Length: 664 pages
- Edition: 1
- Language: English
- Publisher: River Publishers
- Publication Date: 2018-01-31
- ISBN-10: 8793609450
- ISBN-13: 9788793609457
- Sales Rank: #0 (See Top 100 Books)
C++ is a powerful, much sought after programming language, but can be daunting to work with, even for engineering professionals.
Why is this book so useful? Have you ever wondered:
- How do keywords like static and virtual change their meanings according to context?
- What are the similarities and differences between Pointers and References, Pointers and Arrays, Constructors and Copy Constructors, Nested and Local Inner Classes?
- Why is Multiple Interface Inheritance seen to be beautiful but Multiple Implementation Inheritance considered evil?
- When is Polymorphism Static or Dynamic, Bounded or Unbounded?
Answers on these questions, and much more, are explained in this book, Cybernetics in C++. What makes this text so different and appealing in comparison to existing books on the market?
- The bulleted style, as opposed to prose, produces results much faster, both in learning and reference
- “Rules of Thumb,” and further expert tips are given throughout in how to optimize your code
- The “Prospective Evils” sections tell you what to avoid
- The thorough coverage ensures you will be trained to expert level in each of Imperative, Procedural, Memory & Resource Management, Object Oriented and Generic Programming
Cybernetics in C++ combines a theoretical overview and practical approach in one book, which should prove to be a useful reference for computer scientists, software programmers, engineers and students in this and related field.
Topics include: C++, Computer Programming, Software Languages, Object Oriented Programming, Imperative Programming, Procedural Programming, and Generic Programming
Cover Half Title Title Page Copyright Page Contents at a Glance (1) Contents at a Glance (2) Table of Contents Preface Dedication List of Figures List of Programs Introduction Part I – Imperative Programming (1) 1. Getting Started 1.1 Setting Up the Programming Environment 1.1.1 Software IDE 1.2 Hello World 1.3 Writing C++ Source Code 1.3.1 Comments 1.3.1.1 Style with Primitive Tools 1.3.2 Source Code Files 1.4 Subsequent Stages in Building a Program 1.4.1 Compilation 1.4.1.1 Object Files 1.4.2 Linking 1.4.3 Running 1.5 Debugging (1) 1.5.1 What are Bugs/Errors? 1.5.2 Compile-Time Errors 1.5.2.1 Compiler Errors 1.5.2.2 Compiler Warning 1.5.3 Runtime Errors 2. Data Types & Operators 2.1 Learning by Example 2.1.1 Performing Calculations 2.1.2 Interacting with the Console Window 2.2 Variables 2.2.1 Naming Variables 2.2.1.1 Rules 2.2.1.2 Guidelines 2.2.2 Initialising a Variable 2.2.2.1 Using Assignment Equals = 2.2.2.2 Using Parentheses () 2.2.2.3 Which is Preferable? 2.2.3 Ensuring Read Only Status Using Const 2.3 Primitive Data Types 2.3.1 Type Casting 2.3.1.1 Prospective Problems with Certain Types 2.3.1.2 Static Casting of Types 2.3.1.3 Solution with Type Casting 2.3.1.4 C Style Casts 2.4 Operators 2.4.1 Mathematical Operators 2.4.1.1 Arithmetic Operators 2.4.1.2 Assignment & Equality Operators 2.4.1.2.1 Assignment Operations Using = 2.4.1.2.2 = Operator in Mathematics and Computer Science 2.4.1.2.3 Equality Operations Using == 2.4.1.2.4 Compound Assignment Operators 2.4.1.2.5 Assignment vs Compound Assignment Operators 2.4.1.3 Increment & Decrement Operators 2.4.1.3.1 Post Increment 2.4.1.3.2 Pre Increment 2.4.1.3.3 Similarities & Differences: Pre Increment & Post Increment 2.4.1.4 Bitwise Operators 2.4.2 Logical Operators 2.4.3 the Sizeof Operator 3. Control Statements 3.1 Conditional Statements 3.1.1 If Statements 3.1.1.1 What is a Condition? 3.1.2 The If, Then, Else Clause 3.1.2.1 Alternative Form Using the Ternary? : Operator 3.1.3 Cascaded/Nested If Statements 3.1.4 The If, Else If, Else Clause 3.1.5 Switch Statement 3.1.6 Switch Statement vs If, Else If, Else Clause 3.2 Problem Solving with Loops 3.2.1 What are Loops? 3.2.2 For Loop 3.2.3 While Loop 3.2.3.1 Empty While Loop 3.2.4 Do Loop/While Loop 3.3 C++ Statements & Constructs 3.3.1 Blocks 3.3.2 Break Statement 3.3.3 Continue Statement 3.3.4 The Goto Statement 3.3.4.1 Prospective Evils of the Goto Statement 3.3.5 Dropping the Braces {} for 1 Action 3.3.5.1 Potential Hazards in Dropping the Braces 3.3.5.1.1 Breaking at the Wrong Place 3.3.5.1.2 Dangling Else Clause Issue 3.3.5.2 Guideline with Braces 3.4 Creating Aliases IN C & C++ 3.4.1 Defining Constants Using Define - Avoid in C++ 3.4.1.1 Issues with Macro Aliases 3.4.2 Typedef 3.4.2.1 Cannot Modify Typedef 4. Programming Practice 4.1 Good vs Bad Practices 4.2 Guidelines 4.2.1 Organisation 4.2.2 Naming of Variables 4.2.3 Formatting of Source Code 4.3 Debugging 4.3.1 Breakpoints 4.3.2 Viewing Variables 4.3.3 Single Stepping Part II – Procedural Programming 5. Functions 5.1 Procedural Thinking 5.1.1 Procedural Thinking Outside the Programming World 5.1.2 Procedural Thinking Inside the Programming World 5.2 What are Functions? 5.2.1 Function Naming 5.2.2 Function Definitions 5.2.3 Function Declarations 5.2.3.1 Signature of a Function (1) 5.2.4 Function Invocation 5.2.4.1 Caution: Circular Reference 5.2.5 Declarations vs Definitions 5.3 Functions: No Inputs, No Output 5.4 Functions: Some Inputs, No Output 5.4.1 Signature of a Function (2) 5.4.2 Formal Parameters vs. Actual Parameters 5.4.3 Passing a Copy of the Value 5.4.4 No Predetermined Order of Evaluation of Actual Parameters 5.4.5 Modifying Formal Parameters 5.4.5.1 Default Values 5.4.5.2 Const Formal Parameters 5.5 Functions: Some Inputs, an Output 5.5.1 Returning a Value 5.6 The Main Function 5.7 Scope of a Variable 5.7.1 Global Variables 5.7.1.1 Prospective Evils of Global Variables 5.7.2 Local Variables 5.7.2.1 Automatic Local Variables 5.7.2.2 Static Local Variables 5.7.2.2.1 Initialising Static Local Variables 5.7.2.2.2 Caution with Static Local Variables 5.8 Debugging: Single Step In 5.8.1 The Debug/Call Stack 5.9 Overloading Functions 5.9.1 Prospective Evils of Function Overloading 6. Inline Functions and Macros 6.1 Function Invocation Overhead 6.2 C Macros - For the Best Part Avoid in C++ 6.2.1 Creating a Macro 6.2.2 Conditional Preprocessor Directives 6.2.2.1 the ifdef, ifndef endif Clause 6.2.3 Prospective Evils of Macros 6.2.3.1 Losing Track of Types 6.2.3.2 Losing Track of the Name 6.2.3.3 Operator Precedence Problems 6.2.4 Rules of Thumb with Macros 6.3 Inline Functions 6.3.1 Defining & Declaring Inline Functions 6.3.2 Using Inline Functions 6.3.3 The Inline Keyword: A Request, Not an Instruction 6.3.4 Macro Problems not Manifest in Inline Functions 7. Program Management Over Multiple Files 7.1 Software Projects 7.1.1 Source Code 7.2 Building C++ Projects 7.2.1 Compilation 7.2.2 Linking 7.3 Controlling Visibility 7.3.1 Creating External Visibility Using Extern 7.3.1.1 Linker Error Caused by a Lack of Definition 7.3.2 Hiding External Visibility Using Static 7.3.2.1 Duplication of the Keyword Static 7.4 Namespaces 7.5 Potential Problem: Multiple Inclusions 7.6 Preventing Multiple Inclusions 7.6.1 Ensuring Single Inclusions Using Macros 7.6.1.1 Using ifndef to Prevent Multiple Inclusions 7.6.2 Ensuring Single Inclusions Using Preprocessor Directives 8. Recursion 8.1 What is Recursion? 8.1.1 Recursion Outside the Programming World 8.1.2 Recursion Inside the Programming World 8.2 Caution with Recursion 8.3 Computing Factorials 8.3.1 Iterative Algorthm: Using Loops 8.3.2 Using Recursion 8.4 Fibonacci Sequence 8.4.1 Applications of the Fibonacci Sequence 8.5 Generating Permutations 8.5.1 Recursive 8.5.2 The Next Permutation Algorithm 8.6 Hanoi Towers 8.6.1 Strategy for 3 Rings 8.6.2 Strategy for 4 Rings 8.6.3 Iterative Strategies 8.6.4 Recursive Strategies 8.6.5 Implementing Recursion in Hanoi Towers 8.6.6 Traditional Legends of Hanoi Towers 8.7 Further Recursive Problems 8.7.1 Triangular Numbersv 8.7.2 Knapsack/Rucksack Problem 8.7.3 N Queens Problem Part III – Data Structures & Algorithms 9. Arrays 9.1 What are Arrays? 9.1.1 Homogeneous Nature of Data Structures 9.1.2 Indexing in Arrays 9.1.3 The Array Operator 9.1.4 Storage in Runtime Memory 9.2 Defining Arrays 9.3 Writing Data to an Array 9.4 Defining and Initialising Arrays 9.4.1 Defining and Initialising Separately 9.4.1.1 Stand Alone Definition 9.4.1.2 Initialisation 9.4.2 Defining and Initialising on the Same Line 9.5 Reading Data from an Array 9.6 Using Arrays 9.7 Arrays as Function Inputs 9.8 Issues with Arrays 9.9 Multidimensional Arrays 9.10 Dynamic Arrays Part IV – Memory & Resource Management Programming 10. Pointers 10.1 What is the Practice of Addressing? 10.1.1 Addressing Outside the Programming World 10.1.2 Addressing Inside the Programming World 10.2 What are Pointers? 10.2.1 L-Value vs R-Value 10.2.2 The Importance of Pointers 10.3 Implementing Pointers in C & C++ 10.3.1 Defining Pointers: The * Operator 10.3.1.1 Placing the Asterisk BEFORE the Space 10.3.1.2 Placing the Asterisk AFTER the Space 10.3.2 Populating Pointers: The & Operator 10.3.2.1 Definition and Population in the Same Line 10.3.3 Decoding Pointers: The * Operator 10.3.4 Demonstration: Creating & Using Pointers 10.3.5 Potential Problem: Type Mismatch 10.3.6 Equating Pointers 10.3.7 Review: 2 Uses of the Asterisk Operator 10.4 The NULL Pointer 10.4.1 What is the NULL Pointer? 10.4.1.1 Do Not Confuse NULL Pointers and NUL Characters 10.4.2 Defining the NULL Pointer 10.4.3 Applications of the NULL Pointer 10.5 The Void Pointer 10.5.1 Issues with the Void Pointer 10.6 Pointers as Function Inputs 10.6.1 Problems: Lack of Addressing 10.6.2 Passing Function Inputs as Pointers 10.6.2.1 Formal Parameters as Pointers 10.6.2.2 Actual Parameters as Pointers 10.6.3 Fixing the Problems Using Pointer Inputs 10.6.4 The Importance of Pointer Inputs 10.7 The Pointer as the Function Output 10.7.1 Prospective Dangling Pointer Problem 11. Advanced Pointers 11.1 Pointer to Pointer Hierarchies 11.1.1 One Level: Pointer to a Pointer 11.1.2 Multiple Level Pointers 11.2 Read-Only Pointers Using Const 11.3 Pointers to Functions 11.4 Arrays of Pointers 11.4.1 Array of Pointers to Primitive Variables 11.4.2 Array of Pointers to Functions 12. References 12.1 What are References? 12.1.1 L-Value vs R-Value 12.1.2 Restrictions with References 12.2 Implementing References in C++ 12.2.1 Defining References 12.2.2 Populating References 12.2.3 Decoding References 12.3 Using References 12.4 References as Function Inputs 12.4.1 Problems: Lack of Addressing 12.4.2 Passing Function Inputs as References 12.4.2.1 Formal Parameters as References 12.4.2.2 Actual Parameters as References 12.4.3 Fixing the Problems Using References 13. Advanced References 13.1 Read-Only References Using Const 13.2 Potential Ambiguities in Reference Notation 13.3 Reference to a Function 14. Runtime Memory Management 14.1 Garbage Collection 14.2 The Runtime Stack 14.2.1 LIFO: Last in First Out Nature 14.2.2 Stack Overflow 14.3 The Runtime Heap/Free Store 14.3.1 The New Operator 14.3.2 The Delete Operator 14.3.2.1 Dangling Pointer 14.4 Using the Runtime Heap 14.4.1 Direct Usage from the Stack 14.4.2 Sharing the Runtime Heap Between Function Calls 14.5 Prospective Bugs When Using the Runtime Heap 14.5.1 Memory Leaks 14.5.2 Memory Corruption 14.5.3 Dangling Pointers 14.5.3.1 Smart Pointers 14.6 Malloc() and Free() from C Programming 14.7 Using Both the Runtime Stack and Heap 14.7.1 When to Use Which Runtime Memory 14.8 Dynamic Arrays 14.8.1 The New[] and Delete[] Operators 15. Pointers vs References 15.1 Contrast: Definitions and Usage 15.2 Rules of Thumb: When to Use Pointers & References 16. Pointers vs Arrays: Mostly Interchangeable, Sometimes Not 16.1 The Nature of Pointers & Arrays 16.1.1 Placement in Runtime Memory 16.1.2 Array and Pointer Operators 16.2 Where Arrays and Pointers are Interchangeable 16.2.1 Mixing Pointer and Array Syntaxes in Definitions and Accessing 16.2.1.1 Define as Pointer, Accessed as Array 16.2.1.2 Array of Pointers 16.2.2 Input to a Function 16.3 Where Arrays and Pointers are Not Interchangeable 16.3.1 Definition as Array, Declaration as a Pointerfrom a Separate File 16.3.2 Output of a Function 16.3.3 Using the Assignment Operator 16.3.4 Using the Sizeof Operator 16.3.5 Using the Contents of "*" Operator 16.4 Arrays & References: Not Interchangeable 16.5 Summary: Interchangeability of Arrays and Pointers Part V – Object Oriented Programming 17. Abstract Data Types 17.1 What is Abstraction? 17.1.1 Abstraction Outside the Programming World 17.1.2 Problems: Lack of Abstraction 17.1.3 Introducing Abstraction 17.2 What are Abstract Data Types? 17.3 Structures 17.3.1 Defining Structures 17.3.2 Instantiating Structures 17.3.3 Accessing Member Data Using the DOT Operators 17.3.4 Using Structures 17.3.5 Possible Notation Using Typedef 17.3.6 Limitations of Structures 17.4 Unions 17.5 Enumerations/Enums 17.5.1 Declaring Enums 17.5.2 Using Enums 17.5.2.1 Popularity of Enum Use 17.6 Pointers to ADTS 17.6.1 Definition and Population 17.6.2 The "Arrow" Operator 17.6.2.1 Preference over the Dot Operator 17.7 References to ADTs 17.7.1 Definition and Population 17.7.2 Access Using the Dot Operator 18. C++ Classes & Objects 18.1 What is Encapsulation? 18.1.1 Encapsulation Outside the Programming World 18.2 Implementing Abstraction & Encapsulationin C++ 18.2.1 Terminology - Native Class 18.2.2 Building on ADTs 18.3 Structure of a Class 18.3.1 Knowledge & Skill Analogy 18.4 Implementing a C++ Class - Method 1 of 2 18.4.1 Scope of a Variable (2) 18.5 Implementing Objects 18.5.1 Objects on the Runtime Stack 18.5.1.1 Creating Objects Directly 18.5.1.1.1 The Dot Operator 18.5.1.1.2 Equating Objects 18.5.2 Arrays of Objects 18.5.3 Pointers to Objects 18.5.3.1 Definition and Population 18.5.3.2 The "Arrow" Operator 18.5.3.2.1 Preference over the Dot Operator 18.5.3.3 Using Pointers to Objects 18.5.4 References to Objects 18.5.4.1 Definition and Population 18.5.4.2 Access Using the Dot Operator 18.5.4.3 Using References to Objects 18.5.5 Objects on the Runtime Heap 18.5.5.1 Definition and Population 18.5.5.2 Using Objects on the Runtime Heap 18.5.5.3 Java & C - All Objects on the Heap 18.5.6 Objects as Function Inputs 18.5.7 Object as the Function Output 18.6 Implementing a C++ Class - Method 2 of 2 18.6.1 The Scope Resolution Operator 18.6.2 Separating the Declaration & Definitions Lexically 18.6.3 Managing a Class Over Multiple Files 18.7 Defining a Class: Definition & Declarations, Together vs Separate 18.8 Special Class Members 18.9 Constructors 18.9.1 What are Constructors? 18.9.2 Rules of Constructors 18.9.3 Using Constructors 18.9.3.1 Defining Constructors 18.9.3.2 Invoking Constructors 18.9.4 Overloading Constructors 18.9.4.1 Defining Overloaded Constructors 18.9.4.2 Invoking Overloaded Constructors 18.9.5 Default Constructor 18.9.6 Alternative Means of Initialising Data Members 18.9.7 Further Initialisation Work in Constructors 18.10 Destructors 18.10.1 What are Destructors? 18.10.2 Rules of Destructors 18.10.3 Using Destructors 18.10.4 Default Destructor 18.11 Constructors and Destructors for Objects on the Runtime Heap 19. Object Oriented Design Using UML 19.1 What is UML? 19.2 Modelling in UML 19.2.1 UML Diagrams 19.2.2 Class Diagrams 19.2.3 Object Diagrams 19.3 Beauties of Object Oriented Programming 20. Abstraction & Encapsulation Using Classes& Objects (2) 20.1 Mutator Member Function 20.1.1 What are Mutators? 20.1.1.1 Mutators do Not Violate Encapsulation 20.1.2 Defining and Using Mutators 20.2 Const Member Functions 20.2.1 What is a Const Member Function? 20.2.2 Making a Member Function Const 20.2.3 Using Const Member Function 20.3 Static Data Members 20.3.1 What are Static Data Members? 20.3.2 Initialising Static Data Members 20.3.3 Using Static Data Members 20.4 Static Member Functions 20.4.1 What are Static Member Functions? 20.4.1.1 Rules of Static Member Functions? 20.4.2 Using the Static Member Functions 20.5 Assignment Operator 20.5.1 What is the Assignment Operator? 20.5.2 Using the Assignment Operator 20.5.3 Default Assignment Operator 20.6 Copy Constructor 20.6.1 What is the Copy Constructor? 20.6.1.1 Assignment vs. Initialisation 20.6.1.2 Essential Nature of the Copy Constructor 20.6.1.3 Rules of the Copy Constructor 20.6.1.3.1 Input of a Copy Constructor 20.6.1.4 Constructor Vs. Copy Constructor 20.6.2 Implementing and Using the Copy Constructor 20.6.3 Default Copy Constructor 20.7 The "This" Pointer 20.7.1 What is the This Pointer? 20.7.2 Using the This Pointer 20.8 Address-of Operator 20.9 Inner Classes 20.9.1 Nested Classes 20.9.1.1 What are Nested Classes 20.9.1.2 Rules of Nested Classes 20.9.1.3 Creating and Using Nested Classes 20.9.2 Local Classes 20.10 Explicit Constructors 20.10.1 Implicit Conversions 20.10.2 Preventing Implicit Conversions Using Explicit Constructors 20.11 What a Class Creates Behind the Scenes 20.12 Friendship 20.12.1 Friend Functions 20.12.2 Friend Classes 20.12.3 Properties of Friendship 20.12.4 Prospective Evils of Friendship 20.12.5 Refined Definitions of Access Specifiers 21. Operator Overloading 21.1 What is Operator Overloading? 21.1.1 C++ Operators - Most but not all can be Overloaded 21.1.1.1 Prohibited Overloads 21.1.2 Implementing Operator Overloading 21.2 Overloading Unary Operators 21.2.1 Overloading the Increment Operators 21.3 Overloading Binary Operators 21.4 Overloading the Assignment Operator 21.4.1 Arguments for & Against Overloading = 21.5 Advanced Uses of Operator Overloading 21.6 Prospective Evils of Operator Overloading 22. Inheritance 22.1 What is Inheritance? 22.1.1 Terminology 22.2 Modelling Inheritance in UML 22.2.1 Inheritance Outside the Programming World 22.2.2 Inheritance Inside the Computer World 22.3 C++ Syntax: Inheritance 22.3.1 Single Inheritance 22.3.2 Multiple Inheritance 22.4 The Access Specifier "Protected" 22.4.1 Prospective Evils of Protected 22.5 Categories of Inheritance 22.5.1 Single, Multiple Inheritance 22.5.2 Implementation, Interface 22.5.2.1 UML Realisation 22.5.3 Public, Protected, Private Inheritance 22.6 Constructor & Destructor Calls in Inherited Classes 22.7 Single Implementation Inheritance 22.8 Single Interface Inheritance 22.8.1 Abstract Class 22.8.2 Using Interface Inheritance 22.8.3 Beauties of Interface Inheritance 22.9 Multiple Implementation Inheritance 22.9.1 Reasons for Multiple Implementation Inheritance 22.9.2 Creating Multiple Implementation Inheritance 22.9.3 Prospective Evils of Multiple Implementation Inheritance 22.9.3.1 Ambiguity 22.9.3.1.1 Resolving Using the Scope Resolution Operator 22.9.3.2 Diamond Shaped Multiple Inheritance 22.9.3.2.1 Resolving Using Virtual Inheritance/Virtual Classes 22.10 Multiple Interface Inheritance 22.11 Private & Protected Inheritance 22.12 Full Definitions of Access Specifiers 22.13 Suggested Rules of Thumb 23. Polymorphism 23.1 What is Polymorphism? 23.1.1 Polymorphism Outside the Programming World 23.2 Implementing Polymorphism in C++ 23.2.1 Requirements 23.2.2 OOP Inheritance Hierarchy 23.2.3 Virtual Member Functions 23.2.4 Pointers in Inheritance Hierarchies 23.2.5 Polymorphism on the Runtime Stack 23.2.6 Runtime Binding 23.2.7 Polymorphism on the Runtime Heap 23.3 Pure Virtual Member Functions 23.3.1 Interface Inheritance 23.3.2 Notation 23.3.3 Class Forced to be Abstract 23.3.4 Using Pure Virtual Functions 23.4 Beauties of Polymorphism 23.4.1 The Essential Nature of Polymorphism 23.4.2 Pointers Preferred over References 23.5 Data Structures of Polymorphic Objects 23.6 Dynamic Casting 23.7 Further Polymorphism Part VI – Imperative Programming (2) 24. Exception Handling 24.1 What is Exception Handling? 24.1.1 When to Use Exception Handling 24.1.2 Exception Handling in C++ 24.2 Anatomy of an Exception Handler 24.3 Exception: Division by Zero 24.4 Exception: User Input of Inappropriate Type 24.5 Exception: Out of Bounds Array 24.6 Special Exceptions 24.7 Warning: Never Get A Destructor to Throw an Exception 24.8 Catching Multiple Exceptions 25. Files & Streams 25.1 The C++ I/O Stream Classes 25.2 Giving Inputs to the Main Function 25.3 Working with Text Files 25.3.1 Reading from a Text File 25.3.2 Writing to a Text File 25.3.2.1 Overwriting Existing Data 25.3.2.2 Appending a Text File 25.3.3 Converting from String Characters 25.3.4 Further Text Files 25.3.4.1 Csv (comma Separated Values) Files 25.4 Working with Binary Files 25.4.1 Saving & Retrieving Primitive Variables 25.4.2 Saving & Retrieving Objects 25.4.2.1 Working with Single Objects 25.4.2.2 Working with an Array of Objects 25.5 Further File Categories Part VII – Generic Programming 26. What is Generic Programming? 26.1 Generic Thinking 26.1.1 Generic Thinking Outside the Programming World 26.1.2 Generic Thinking Inside the Programming World 26.1.2.1 Problems: Lack of Generics 27. Function Templates 27.1 Creating Function Templates 27.2 Instantiating Function Templates 27.2.1 Compiler Generated Code 27.2.1.1 Compiler Intelligence 27.3 Polymorphism in Generic Programming 28. Class Templates 28.1 Creating Class TEMPLATES 28.2 Using Class Templates 28.3 Template Parameters & Arguments 28.3.1 Non-Type Template Parameters 28.3.2 Template Template Parameters 28.3.3 Default Template Arguments 28.4 Class Template Design in UML 28.5 Beauties of Generic Programming 29. Template Specialisation & Overloading 29.1 What is Template Specialisation 29.2 Function Template Specialisation 29.2.1 Implementing Function Template Specialisation 29.3 Class Template Specialisation 29.3.1 Explicit Specialisation 29.3.2 Partial Specialisation Part VIII – Getting It Together:programming in C++ 30. Duplicate Keywords 30.1 The Keyword “STATIC” 30.2 The Keyword “VIRTUAL” 30.3 The Keyword “CLASS” 31. Duplicate Symbols/Operators 31.1 The Asterisk * 31.2 The Ampersand & 31.3 The Meanings of the = Symbol 31.4 The Parentheses Operator () 31.5 The Scope Resolution Operator :: 32. Using Const 32.1 Const Pointers 33. Casting Summary & Conclusions Appendix Appendix A: C++ Primitive Data Types Appendix B: C++ Operators Appendix C: Reserved Keywords in C++ Bibliography Index About the Author
Donate to keep this site alive
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.