Item Description

Learn C++/C video & docs tutorials



Whether you prefer video or docs tutorials , video4ar.com trainings are for you.. Learn C++/C step by step up to advance and commercial usage by watching the video tutorials or reading the book training.

115 "How To" video tutorials & 1200 pages that cover these topics
C Language:
Introduction
The of this Course
C
Fundamental Concepts
Compiling
Converting Source
Program Execution
Sequence Points
Compatiblity with C++
Types of Data
Integers
Three Float
Complex & Imaginary
Bits
More Bits
Convert & Cast
Literals
The Category Integer
Aggregates
Arrays of One Dimension
Arrays of Many Dimensions
Variable Length Array
Structs
Unions
Characters
Trigraphs & Digraphs
Wide Characters
Universal Characters
Character Display Semantics
Formatted Output
Formatted Input
Memory Allocation
The Allocation Functions
Handling Memory Allocation
Declarations & Definitions
Execution Flow
The Form of a Function Call
Pushing Arguments
Blocks
if
switch/case
while/do/for
goto
Preprocessor
Macro Definition & Expansion
Stringification & Concatenation
Variadic Macros
Conditional Inclusion
Error & Pragma
Inclusion & Idempotence
Predefines
Macro Follies
Pointers
Lvalues & Rvalues
Deciphering Declarations
Pointer Arithmetic
Pointers in the Real World
Operators
Multiplicative & Additive
Unary oOperators
Bit Operators
Boolean vs. Logical
Residual Values
Locations & access
Alignment
Identifiers & Scope
Linkage & Storage Duration
Special Keywords
auto/register
break/continue
const/volatile/restrict
extern
inline
return
sizeof
static
Standard C Library
assert.h
ctype.h
errno.h
float.h
limits.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h pt. 1
stdio.h pt. 2
stdlib.h
string.h
time.h
Conclusion
Wrapup
Credits
About this Author
C++
A Crash Course in C++
The Basics of C++
The Obligatory Hello, World
Namespaces
Variables
Operators
Types
Conditionals
Loops
Arrays
Functions
Those Are the Basics
Diving Deeper into C++
Pointers and Dynamic Memory
Strings in C++
References
Exceptions
The Many Uses of const
C++ as an Object-Oriented Language
Declaring a Class
Your First Useful C++ Program
An Employee Records System
The Employee Class
The Database Class
The User Interface
Evaluating the Program
Designing Professional C++ Programs
What Is Programming Design?
The Importance of Programming Design
What’s Different about C++ Design?
Two Rules for C++ Design
Abstraction
Reuse
Designing a Chess Program
Requirements
Design Steps
Designing with Objects
An Object-Oriented View of the World
Am I Thinking Procedurally?
The Object-Oriented Philosophy
Living in a World of Objects
Object Relationships
Abstraction
Designing with Libraries and Patterns
Reusing Code
A Note on Terminology
Deciding Whether or Not to Reuse Code
Strategies for Reusing Code
Bundling Third-Party Applications
Open-Source Libraries
The C++ Standard Library
Designing with Patterns and Techniques
Design Techniques
Design Patterns
vi
Designing for Reuse
The Reuse Philosophy
How to Design Reusable Code
Use Abstraction
Structure Your Code for Optimal Reuse
Design Usable Interfaces
Reconciling Generality and Ease of Use
Maximizing Software-Engineering Methods
The Need for Process
Software Life-Cycle Models
The Stagewise and Waterfall Models
The Spiral Method
The Rational Unified Process
Software-Engineering Methodologies
Extreme Programming (XP)
Software Triage
Building Your Own Process and Methodology
Be Open to New Ideas
Bring New Ideas to the Table
Recognize What Works and What Doesn’t Work
Don’t Be a Renegade
Part II: C++ Coding the Professional Way
Coding with Style
The Importance of Looking Good
Thinking Ahead
Keeping It Clear
Elements of Good Style
Documenting Your Code
Reasons to Write Comments
Commenting Styles
Comments in This Book
vii
Decomposition
Decomposition through Refactoring
Decomposition by Design
Decomposition in This Book
Naming
Choosing a Good Name
Naming Conventions
Using Language Features with Style
Use Constants
Take Advantage of const Variables
Use References Instead of Pointers
Use Custom Exceptions
Formatting
The Curly Brace Alignment Debate
Coming to Blows over Spaces and Parentheses
Spaces and Tabs
Stylistic Challenges
Gaining Proficiency with Classes and Objects
Introducing the Spreadsheet Example
Writing Classes
Class Definitions
Defining Methods
Using Objects
Object Life Cycles
Object Creation
Object Destruction
Assigning to Objects
Distinguishing Copying from Assignment
Mastering Classes and Objects
Dynamic Memory Allocation in Objects
The Spreadsheet Class
Freeing Memory with Destructors
Handling Copying and Assignment
Different Kinds of Data Members
Static Data Members
Const Data Members
Reference Data Members
Const Reference Data Members
viii
More about Methods
Static Methods
Const Methods
Method Overloading
Default Parameters
Inline Methods
Nested Classes
Friends
Operator Overloading
Implementing Addition
Overloading Arithmetic Operators
Overloading Comparison Operators
Building Types with Operator Overloading
Pointers to Methods and Members
Building Abstract Classes
Using Interface and Implementation Classes
Discovering Inheritance Techniques
Building Classes with Inheritance
Extending Classes
Overriding Methods
Inheritance for Reuse
The WeatherPrediction Class
Adding Functionality in a Subclass
Replacing Functionality in a Subclass
Respect Your Parents
Parent Constructors
Parent Destructors
Referring to Parent Data
Casting Up and Down
Inheritance for Polymorphism
Return of the Spreadsheet
Designing the Polymorphic Spreadsheet Cell
The Spreadsheet Cell Base Class
The Individual Subclasses
Leveraging Polymorphism
Future Considerations
Multiple Inheritance
Inheriting from Multiple Classes
Naming Collisions and Ambiguous Base Classes
ix
Interesting and Obscure Inheritance Issues
Changing the Overridden Method’s Characteristics
Special Cases in Overriding Methods
Copy Constructors and the Equals Operator
The Truth about Virtual
Runtime Type Facilities
Non-Public Inheritance
Virtual Base Classes
Writing Generic Code with Templates
Overview of Templates
Class Templates
Writing a Class Template
How the Compiler Processes Templates
Distributing Template Code between Files
Template Parameters
Method Templates
Template Class Specialization
Subclassing Template Classes
Inheritance versus Specialization
Function Templates
Function Template Specialization
Function Template Overloading
Friend Function Templates of Class Templates
Advanced Templates
More about Template Parameters
Template Class Partial Specialization
Emulating Function Partial Specialization with Overloading
Template Recursion
Understanding C++ Quirks and Oddities
References
Reference Variables
Reference Data Members
Reference Parameters
Reference Return Values
Deciding between References and Pointers
x
Keyword Confusion
The const Keyword
The static Keyword
Order of Initialization of Nonlocal Variables
Types and Casts
typedefs
Casts
Scope Resolution
Header Files
C Utilities
Variable-Length Argument Lists
Preprocessor Macros
Part III: Mastering Advanced Features of C++
Effective Memory Management
Working with Dynamic Memory
How to Picture Memory
Allocation and Deallocation
Arrays
Working with Pointers
Array-Pointer Duality
Arrays Are Pointers!
Not All Pointers Are Arrays!
Dynamic Strings
C-Style Strings
String Literals
The C++ string Class
Low-Level Memory Operations
Pointer Arithmetic
Custom Memory Management
Garbage Collection
Object Pools
Function Pointers
Common Memory Pitfalls
Underallocating Strings
Memory Leaks
Double-Deleting and Invalid Pointers
Accessing Out-of-Bounds Memory
xi
Demystifying C++ I/O
Using Streams
What Is a Stream, Anyway?
Stream Sources and Destinations
Output with Streams
Input with Streams
Input and Output with Objects
String Streams
File Streams
Jumping around with seek() and tell()
Linking Streams Together
Bidirectional I/O
Internationalization
Wide Characters
Non-Western Character Sets
Locales and Facets
Handling Errors
Errors and Exceptions
What Are Exceptions, Anyway?
Why Exceptions in C++ Are a Good Thing
Why Exceptions in C++ Are a Bad Thing
Our Recommendation
Exception Mechanics
Throwing and Catching Exceptions
Exception Types
Throwing and Catching Multiple Exceptions
Uncaught Exceptions
Throw Lists
Exceptions and Polymorphism
The Standard Exception Hierarchy
Catching Exceptions in a Class Hierarchy
Writing Your Own Exception Classes
Stack Unwinding and Cleanup
Catch, Cleanup, and Rethrow
Use Smart Pointers
xii
Common Error-Handling Issues
Memory Allocation Errors
Errors in Constructors
Errors in Destructors
Putting It All Together
Part IV: Ensuring Bug-Free Code
Overloading C++ Operators
Overview of Operator Overloading &nbsp