Become a C Plus Plus Developer:4. C++ Essential Training (2014) with Bill Weinman
Posted by Superadmin on November 07 2019 02:03:09
2 C++ Essential Training with Bill Weinman
C++ is a workhorse. Widely used for both systems and applications development, C++ is available for virtually every operating system and has influenced and informed many derivative languages, including C# and Java. In this course, Bill Weinman guides you through the nuts and bolts of this essential language. He starts with the basics—syntax, operators, loops, and functions—and moves on to data structures, objects, and templates. He explains inheritance and operator overloads, and dives into the powerful container classes in the Standard Template Library (STL). These exhaustive C++ tutorials will provide a solid reference for both experienced programmers and those who are brand-new to the language.

Course Contents

 

 

Introduction

Welcome 53s

Using Xcode with the exercises 9m 10s

Using Microsoft Visual Studio with the exercises 14m 20s

 

Basic Syntax

What is C++? 5m 20s

Introduction to basic syntax 1m 57s

Anatomy of a C++ program 9m 5s

Statements and expressions 4m 1s

Identifiers 2m 14s

Defining variables 3m 4s

Pointers 4m 57s

References 3m 48s

Arrays and strings 7m 11s

Conditionals 5m 32s

The branching conditional 4m 7s

Looping with while and do 2m 29s

Iterating with for 4m

Using the range-based for loop 3m 35s

Using stdout 7m 1s

 

Defining Functions

Overview of C++ functions 3m 15s

Defining a function 4m 8s

Passing values to a function 7m 52s

Using automatic and static variables 3m 5s

Returning values from a function 3m 19s

Using function pointer 8m 7s

Overloading function names 2m 39s

Overloading operators with functions 5m 23s

Defining a variable number of arguments 4m 23s

Using recursion 2m 28s

 

The Preprocesser

About the preprocessor 2m 29s

Using macros as constants 3m 30s

Including files 2m 31s

Conditional compilation 1m 52s

Defining macros 4m 2s

Macro caveats 3m 12s

Line continuation with backslash 3m 9s

Including files only once 4m 6s

 

 

Classes and Objects

Overview of classes and objects 2m 14s

Defining a class 5m 5s

Data members 5m 15s

Function members 6m 30s

Constructors and destructors 9m 3s

Implicit vs. explicit constructors 4m 32s

Namespaces 4m 8s

Pointing to the current object with *this 1m 52s

Overloading operators with member functions 12m 35s

Overloading operators with nonmember functions 5m 53s

Conversion operators 5m 8s

Creating and destroying objects with new and delete 4m 14s

Reporting errors with exceptions 2m 56s

Creating function objects 1m 55s

Converting numbers to words 13m 45s

 

 

Data Types

Overview of data types 2m 49s

Integral types 9m 50s

Floating-point types 3m 57s

Characters and strings 2m 47s

Character-escape sequences 2m 10s

Qualifiers 5m 32s

The C++ reference type 4m 59s

Structured data 1m 56s

Bit fields 2m 34s

Enumerations 3m 50s

Unions 2m 15s

Defining types with typedef 2m 5s

The void type 2m 26s

The auto type 4m 20s

The unambiguous null pointer constant 3m 32s

 

 

Operators

Common operators 3m 29s

Compound assignment operators 4m 42s

Increment and decrement operators 5m 43s

Comparison (relational) operators 2m

Logical operators 2m 48s

Bitwise operators 3m 51s

The ternary conditional operator 2m 5s

Determining the size of a type with sizeof 2m 22s

Determining the type of an object with typeid 2m 21s

Operator precedence 2m 1s

 

Object Inheritance

Overview of class inheritance 1m 45s

Simple inheritance 3m 48s

Accessing the base class 2m 26s

Friendship 3m 23s

Multiple inheritance 3m 33s

Overloading methods and exploring polymorphism 3m 33s

 

Templates

Understanding templates 2m 18s

Template functions 4m 20s

Template classes 4m 13s

Type inference 6m 20s

 

Standard Library

Overview of the Standard Library 3m 27s

File input and output (I/O) with stdio 9m 20s

File management with stdio 2m 35s

Unformatted character I/O with stdio 6m 4s

Formatted character I/O with stdi 6m 39s

String functions 9m

Handling system errors 2m 8s

Time and date functions 4m 6s

 

Standard Template Library

Overview of the STL 2m 30s

Vectors 8m 41s

Strings 4m 38s

I/O streams 8m 10s

Iterators 5m 33s

Lists 4m

Pairs 1m 58s

Sets 4m 29s

Maps 3m 56s

Stacks and queues 6m 20s

Handling exceptions 4m 58s

 

Conclusion

Goodbye 57s




 


00. Introduction



 
 
 
00_00 Welcome
00_01 Using Xcode with the exercises
00_02 Using Microsoft Visual Studio with the exercises



01. Basic Syntax



 
 
 
 
01_01 What is C++
01_02 Introduction to basic syntax
01_03 Anatomy of a C++ program
01_04 Statements and expressions
 
 
 
 
01_05 Identifiers
01_06 Defining variables
01_07 Pointers
01_08 References
 
 
 
 
01_09 Arrays and strings
01_10 Conditionals
01_11 The branching conditional
01_12 Looping with while and do
 
 
 
01_13 Iterating with for
01_14 Using the range-based for loop
01_15 Using stdout



02. Defining Functions



 
 
 
 
02_01 Overview of C++ functions
02_02 Defining a function
02_03 Passing values to a function
02_04 Using automatic and static variables
 
 
 
 
02_05 Returning values from a function
02_06 Using function pointers
02_07 Overloading function names
02_08 Overloading operators with functions
 
 
02_09 Defining a variable number of arguments
02_10 Using recursion
 
Source code for this chapter
 

// func.cpp by Bill Weinman

#include <cstdio>

using namespace std;

void func()

{

puts("this is func()");

}

int main( int argc, char ** argv )

{

puts("this is main()");

func();

return 0;

}



03. The Preprocessor



 
 
 
 
03_01 About the preprocessor
03_02 Using macros as constants
03_03 Including files
03_04 Conditional compilation
 
 
 
 
03_05 Defining macros
03_06 Macro caveats
03_07 Line continuation with backslash
03_08 Including files only once



04. Classes and Objects



 
 
 
 
04_01 Overview of classes and objects
04_02 Defining a class
04_03 Data members
04_04 Function members
 
 
 
 
04_05 Constructors and destructors
04_06 Implicit vs. explicit constructors
04_07 Namespaces
04_08 Pointing to the current object with _this
 
 
 
 
04_09 Overloading operators with member functions
04_10 Overloading operators with nonmember functions
04_11 Conversion operators
04_12 Creating and destroying objects with new and delete
 
 
 
04_13 Reporting errors with exceptions
04_14 Creating function objects
04_15 Converting numbers to words



05. Data Types



 
 
 
 
05_01 Overview of data types
05_02 Integral types
05_03 Floating-point types
05_04 Characters and strings
 
 
 
 
05_05 Character-escape sequences
05_06 Qualifiers
05_07 The C++ reference type
05_08 Structured data
 
 
 
 
05_09 Bit fields
05_10 Enumerations
05_11 Unions
05_12 Defining types with typedef
 
 
 
05_13 The void type
05_14 The auto type
05_15 The unambiguous null pointer constant



06. Operators



 
 
 
 
06_01 Common operators
06_02 Compound assignment operators
06_03 Increment and decrement operators
06_04 Comparison (relational) operators
 
 
 
 
06_05 Logical operators
06_06 Bitwise operators
06_07 The ternary conditional operator
06_08 Determining the size of a type with sizeof
 
 
06_09 Determining the type of an object with typeid
06_10 Operator precedence



07. Object Inheritance



 
 
 
 
07_01 Overview of class inheritance
07_02 Simple inheritance
07_03 Accessing the base class
07_04 Friendship
 
 
07_05 Multiple inheritance
07_06 Overloading methods and exploring polymorphism



08. Templates



 
 
 
 
08_01 Understanding templates
08_02 Template functions
08_03 Template classes
08_04 Type inference



09. The Standard Library



 
 
 
 
09_01 Overview of the Standard Library
09_02 File input and output (I_O) with stdio
09_03 File management with stdio
09_04 Unformatted character I_O with stdio
 
 
 
 
09_05 Formatted character I_O with stdio
09_06 String functions
09_07 Handling system errors
09_08 Time and date functions



10. The Standard Library Template



 
 
 
 
10_01 Overview of the STL
10_02 Vectors
10_03 Strings
10_04 I_O streams
 
 
 
 
10_05 Iterators
10_06 Lists
10_07 Pairs
10_08 Sets
 
 
 
 
10_09 Maps
10_10 Stacks and queues
10_11 Handling exceptions
11_01 Goodbye