Computer Science: Intermediate Level C++ Prof. Alvin Sylvain, M.S.
Facebook Twitter
More

Level Intermediate
16 Lessons (12hr : 30min)
19 already enrolled!
Audio: English

Professor Alvin Sylvain returns to teach you how the C++ programming language can be both enjoyable and highly useful. Professor Sylvain makes learning C++ as easy as possible with lessons that first focus on theory and sample code, before diving into compiling and troubleshooting actual code and applications. His extensive teaching experience also allows him to effectively show users how to avoid common pitfalls. This intermediate C++ course covers topics from Templates to Exception Handling and is perfect whether you're a seasoned programming professional or just moving on from Alvin's introductory course. Professor Sylvain has an M.S. in Computer Science and over 20 years of experience teaching and tutoring students in C++.

Table of Contents
Course Details


Overview of Intermediate C++			39:28
	Intro		00:00
	Overview		00:22
	Review		03:10
		Language Features You're Expected to Already be Familiar With	03:41
		Introduce New Features and Cover Some Familiar Territory More In-Depth	04:17
	Containers; Vector		04:45
		Features: Templates and Containers	04:56
		Vector is the First Container Learned	05:15
		Example	05:44
	Containers; List		07:18
		Linked List is One of the Most Basic Data Structures in Computer Science	07:24
		This Class Shows How to Use the Standard Library 'List' Container	07:52
		Example	08:15
	Containers; Set, Map		9:15
		Binary Tree	9:23
		'Set' and 'Map' are Not Sequential	10:23
		Set Retrieves Unique Keys	10:41
		Map Retrieves a Unique Key, Then the Related Value	10:55
		Example	11:11
	Templates		12:00
		Allow for Code Re-Use and Modularity	12:14
		Example	12:46
	Object Oriented Programming		15:19
		OOP is the Main Motivating Factor to the Original Development	15:29
		Only Grafted on Non-OOP Features	15:39
		Discuss How Classes and Objects Are Created and Instantiated in C++	16:20
	Operator Overloading		18:29
		Writing Polymorphic Functions	18:39
		Operator Overloading is a Standard Feature in Most Programming Language	18:52
		Example	19:00
	Exception		21:05
		Practical Programming Means Handling Unexpected Conditions in an Expected Way	21:08
		Programmers Have Used Different Techniques to Pass Along Info That's 'Less Than Good'	22:27
	Exception Handling in C++		23:51
		C++ Exceptions Can be Any Type	24:31
		Example	24:38
	Namespaces		25:30
		Name Collision	25:40
		C++ Solution is for Each Company to Use Their Own Unique Namespace	26:06
		Example	26:29
	Input/Output		27:43
		Class Hierarchy for C++ Input/Output	28:16
		Turn on Exception Handling and Check Input/Output Status Bits	28:21
		How to Use 'Stringstream' Object	28:32
	More Details for Functions		29:19
		Parameters on the Main Function	29:34
		Inline Functions	29:52
		Recursive Functions	30:34
		Pass Pointers to Functions as Function Parameters	30:42
	More Kinds of Types		32:23
		Union to Force Memory Overlap	32:30
		Enum Type	33:01
		Typedef Keyword	33:37
		Keeping Things the Same 'Const'	34:00
	Pre-Compiler Macros		34:09
		'#include'	34:22
		'#define'	34:45
		Conditional Compilation with '#ifdef'	35:19
	Compiling the Code		35:57
		Dash D Testing	36:26
		Common Flags	37:18
		Flag That Allows a Run-Time Debugger to Hook Into the Application	38:11
	Tally Ho!		39:07
Review			56:23
	Intro		0:00
	Overview		0:21
	Acquire a Compiler		1:24
		Windows	1:51
		Macintosh	2:02
	Acquire a Compiler for Linux		2:18
		Redhat	2:28
		Ubuntu	2:38
		Software Manager	2:51
	Acquire an Editor		3:14
		Popular Editors	3:48
	Compile and Run a Program		5:00
		Traditional First Program	5:28
	Comments in Code		8:12
		Standard C 'block' Type Comment	8:34
		C++ 'to end of line' Comment	8:59
	Simple Data Types		10:00
		Integer	10:07
		Floating Point	11:11
		Character	11:50
		Two Types of 'Strings' in C++	12:31
		Examples	12:48
	Operators		15:56
		Unary	16:01
		Binary	17:24
		Ternary	18:16
		Function-like	18:43
		Member Reference	19:41
	Expressions		20:51
		Modifying	21:01
		Arithmetic	21:24
		Comparison	21:46
		Logical	22:24
		Comma	22:48
	Left-Hand Expressions		24:04
		'Right hand'	24:07
		'Left hand'	24:30
		Examples	25:12
	'If' Branching		26:33
	'Switch' Branching		29:15
	Looping		30:59
		'While' Loop	31:04
		'Do While' Loop	32:17
		'For' Loop	32:59
		'Break'	34:15
		'Continue'	34:36
	Functions		34:49
		Prototypes	36:06
		Function Parameters	36:36
		Return Value	38:23
		Overloading	38:41
	Arrays		39:10
		Multi-Dimensional Arrays	41:05
	Pointers		43:37
		Definition	43:43
		'Dereference' Operator	43:51
		'Reference' Operator	44:40
	Structures		47:20
		Example: Without Structure	48:12
		Example: With Structure	49:13
	Object Oriented Programming		51:00
		Access Can Be Defined As	53:24
	Input / Output		54:07
		Insertion Operator	54:29
		Extraction Operator	55:04
		File Stream Objects	55:33
	Two Thumbs Up!		55:58
Containers, Vector			40:14
	Intro		0:00
	Lesson Overview		0:11
	Containers		01:50
		Vector	01:58
		List	02:24
		Set, Map	02:56
		Data Access	03:44
		Iterators	04:10
		Container Information	04:37
	Vector		04:53
		Memory Re-Allocation	06:07
	Declare Vector of 'Type'		07:37
		Size & Capacity	08:01
		Vector<type> Variable	08:20
		Vector<type> Variable (Initial Size, Initial Value)	09:27
		Vector<type> Variable (Initial Size)	10:11
	Access Vector Data		10:27
		Example: Typical Array Access	10:46
		Method Call Access	11:07
	Other Data Access		12:26
		Front	12:30
		Back	12:38
		Use Empty Function to Test	13:37
	Vector Information		14:36
		Resize	15:53
		Reserve	17:55
	Vector Iterators		19:11
		Example: Data Elements May be Accessed Like Standard Array	19:30
		Data Elements May be Accessed Using Iterators	20:38
	Vector Iterator Begin/ End		23:30
		Begin	23:34
		Eng	23:50
		Reverse Begin	24:07
		Reverse Iterator	24:16
	'Short?' Cuts		25:21
		Declaring Loop Index Inside the 'for' Loop	25:34
		With Iterators	26:05
	Modifying Vector Data		26:54
		Push Back	27:44
		Pop Back	28:57
	Insertions		29:32
		Example: Insert New Value at Beginning	29:51
		Example: Insert Value in Middle	30:40
	More Vector Operations		32:12
		Empty	32:15
		Erase	32:22
		Clear	33:01
		Assign	33:20
	Compile-Time Initialization		34:34
		Example 1	35:22
		Example 2	36:07
		Example 3	37:25
	Caution-Invalidating Iterators		37:59
	Contained!		39:56
Containers, List			33:40
	Intro		0:00
	Lesson Overview		0:13
	Linked List Overview		1:34
		Arrays and Vectors	1:39
		Linked List	3:16
	List Information		5:53
		Empty Method	6:04
		Max Size	6:14
		Resize	6:51
	List Access		7:48
		Front and Back	8:04
		Iterators	8:16
		Example	8:49
	List Iterators vs. Vector Iterators		9:24
		The Next Element May be Physically in Memory Before the Current Element	9:50
		Vector Iterators Allow Integer Add	10:34
		List Iterators Do Not Allow Integer Add	12:24
	Simple List Modification		14:24
		Constructors	14:32
		Difference Between Assign and Insert	15:16
		Assign	15:37
		Insert	16:01
		Push	16:31
		Pop	16:38
		Erase	16:53
	Complex List Modification		18:34
		Merging and Splicing	18:38
		Merge	19:35
		Splice	20:24
		Reordering	21:46
		Removing	22:28
	Modification Examples		23:22
	Functions as Parameters		24:49
		A Function for 'remove_it()'	25:04
		A Function for Merge and Sort - Evens Before Odds	25:46
	Deque		27:28
		Insertion or Removal in Middle May be More Efficient than with Vectors	27:51
		Not Guaranteed to be Contiguous Memory	28:42
		Same Method as Vector, Plus More	29:00
	Stack		29:11
		Empty, Size, Top, Push, Pop	31:05
	Queue		31:56
		Definition	32:19
	Not That Kind of List		33:19
Containers, Set, Map			35:35
	Intro		0:00
	Lesson Overview		0:11
	Tree Structures for Sets/Maps		2:01
		What's the Value?	3:00
	Pair Template Class		4:45
		Allows a Function to Return 'Two' Values Instead of the Normal One	5:15
		Example for an Integer Set	5:46
		Example for Map with a String Key, Double Value	7:09
	Set, Multiset		8:03
		What's a Set	8:32
		Elements are the Key	9:30
		Custom Class for Ordering	9:52
	Get Data In to Set		10:28
		Constructors	10:33
		Insert (Value)	11:26
		Insert (Position, Value)	12:30
		Insert (First, Last)	13:18
	Get Data Out of Set		13:28
		Erase	13:33
		Find	13:57
		Lower_Bound	15:20
		Upper_Bound	15:43
		Iterators Positioned Such That a For-Loop Can 'Start at Zero'	15:59
	Set Examples		16:32
	Map, Multimap		19:15
	Get Data In to Map		20:45
		Constructors	20:48
		Insert a Key Value Pair	21:25
		Insert Position	22:05
		Insert (First, Last)	22:21
	Get Data Out of Map		22:37
		Operator	23:43
		Erase	25:16
		Find, Lower & Upper Bound	25:28
	Map Examples		25:37
	Comparison Class		29:34
		Example	30:37
	What About Duplicates?		33:29
		Define a Pair to Receive a Container Iterator and a Boolean	33:40
		Example	34:07
	Useful Maps		35:10
Templates			41:08
	Intro		0:00
	Lesson Overview		0:08
	Function Template		5:48
		Define	5:52
		Use	6:46
		Example	7:03
	Constraints on Types		10:34
		Example	10:45
	Multiple Types		13:58
		Example	14:03
	Default Types		17:11
		Example	17:24
	Class Template		20:27
		Example	20:33
	Template Specialization		24:31
		Example	25:00
	Non-Type Parameters		27:32
		Example	27:46
	Templates in Templates		32:20
		Example	32:34
	Cautions		35:04
		Don't Use a Template with a Type That Doesn't Support All the Template's Operations	35:10
		Templates Can Not be Split into Header Files and Compiled Units	36:51
		Issues with Debugging	39:47
	Templates Gone Wild!		40:33
Object Oriented Programming, Part 1			1:04:48
	Intro		0:00
	Lesson Overview		0:14
	Concepts		4:39
		Historically Distinct Ways of Programming and Design	4:41
		OOP Emphasizes Important Concepts	6:28
	Some Terminology		9:53
		Object	9:56
		Class	11:47
		Instance	12:56
	Example		14:04
	Abstraction		20:00
		Abstraction Defines the Essential Characteristics of an Object	20:08
		Emphasis on Essential	20:34
		Classes are Defined with Characteristics That Distinguish One Class of Objects From Another	21:18
	Encapsulation		22:23
		Private Data	23:25
		Public Methods	23:40
		Protected Data	24:47
	Inheritance		25:52
		What Is Inheritance?	25:58
		Example	27:57
	Polymorphism		29:18
		Example of Operator Overloading	29:30
		Example of Parameter Signature	30:22
		Methods Inherited From another Object Can be Overwritten and Customized to the New Object	31:13
	Object Relationships		33:37
		Consider Two Objects, Car and Vehicle	33:42
		Consider Two Other Objects, Car and Tire	34:01
		Object Motorcycle	34:22
	Inheritance Example		35:27
	Multiple Inheritance		39:24
		Example	39:51
		Be Careful for Diamond Problem	43:46
	Multiple Inheritance Example		45:28
	Constructors		46:55
		Default Constructor	47:33
		Copy Constructor	49:10
	Default Constructor		50:33
		Example	50:55
	Shallow Copy		52:41
		Example	53:10
	Deep Copy		56:35
		Example	56:42
	Copy Constructor		61:34
	Good Design? Or…		64:28
Object Oriented Programming, Part 2			44:16
	Intro		0:00
	Lesson Overview		0:10
	Overloading Constructors		3:10
		Provide Other Constructors	3:26
		Example	3:43
	Initialization Lists		5:40
		Syntax Example	5:43
		Equivalent to Initializing in Statements in the Method Body	6:50
	Destructors		7:09
		Destructor is Automatically Called when Instance is Deleted	7:26
		Declare the Declare as Virtual in the Event the Class is Designed to be Derived by Sub-Class	9:15
	What's in a Name?		11:15
		Example: How to Tell Field from Parameter	11:56
	Friendship Functions		16:32
		Avoids Strict Object Oriented Principles and Declare the Function or Class Using 'friend' Keyword	16:47
		Example	17:12
	Friendship Classes		18:48
		Example	18:57
	Designing for Derivation		20:54
		Add 'Virtual' Keyword to Public Methods	21:50
		Add 'Virtual' Keyword to Destructors	24:17
	Abstract Class		25:41
		Designed Only for Derivation	25:47
		Example	26:13
	Compilation Units		28:22
		Classes Are Typically Divided into the Interface Portion and Implementation Portion	28:53
		Namespaces Are Used to Associate a Class Method with the Class Definition	29:31
	Example Compilation Units		30:53
		Definition for 'Vehicle' Class for an Include File	30:54
		Implementation for 'Vehicle' Class in Program File	33:01
	Why You Add 'Include Guards'		36:33
		Suppose You Derive 'Automobile' From 'Vehicle'	36:38
		Caller File Includes Both	37:21
	Object Oriented? Or Not?		38:46
		When Is It Appropriate?	39:31
		When Is It Not Appropriate?	41:04
	The Object Oriented Purist		43:53
Operator Overloading			1:12:54
	Intro		0:00
	Overview		0:13
	When Not to Overload Operators		4:32
		Arithmetic Operators Should Only Apply to 'Numeric' Kinds of Classes	4:53
		Complex Number	6:04
		'add' Operation vs. 'add()' Method	6:38
	When It Can Be a Good Idea		7:42
		Your Class is Inherently Numeric In Nature	7:49
		Some Operators Still Make Sense to be Overloaded	8:26
	Kinds of Operators to Overload		11:03
		Binary Operator	11:19
		Unary Operator	12:06
		Non-Member Functions	14:27
	Example: Named Vector		15:03
		Named Vector is a Directional Vector with a Name	15:10
		Directional Vectors	15:15
		Overloading Demonstration	18:58
	Assignment Operator=		20:26
		Deep Copy	20:37
		Copy Constructor	20:55
	Overloading Operator=		22:21
		Example Member Function	22:28
	Overloading Binary Operator==		27:10
		Example 'Equal' Member Method	27:30
		Other Comparison Methods Can Call This One	31:09
	Overloading Binary Operator<		32:30
		Example: 'Less Than' Member Method	32:43
	Overloading Arithmetic Operators		35:04
		'@=' Operator	35:23
		Operations Work Symmetrically	36:22
	Overloading Binary Object-to-Object		38:19
		'@=' Is Member Function with Full Access	38:27
		'@' is Non-Member Function	40:24
		Multiple a Vector by a Number to Make it Larger	43:19
		Need Two Symmetrical Non-Member Functions	44:46
	Overloading Unary Operator		47:16
		No Parameter for the Operator@ Function	47:40
	Overloading Prefix/Postfix Operator		49:12
		Unary Operators with Different Semantics for Prefix and Postfix	49:38
		'++' and '--'	50:43
	Overloading Prefix Operator++		51:21
		Add 1.0 to X/Y Components Before Accessing Value for Caller	51:38
		Also Include the Operator-- to Subtract 1.0	51:55
	Overloading Postfix Operator++		52:02
		Give It a Dummy Operator	52:07
	Overloading, Object-to-Other Object		54:18
		Make Non-Member Function a 'Friend' to Access Private Members of Your Class	54:36
		Parameters Must Include Other Objects When Overloading	54:50
		Useful for Saving an Object to a File	55:52
	Overloading Operator<<		56:45
		Include Non-Member 'Friend' Function in Class	56:50
		Implement Function in the Compilation Unit	57:58
		Allows Output of Your Objects with Other Data	59:39
	Array Operator[]		60:55
		Example: The Standard Library Vector	62:00
		Named Vector	62:49
	Overload Array Operator []		63:19
		Implement Operator[] As a Member Function	63:23
		Write the Code	64:15
		It Lets You Define a Non-Int for the 'Array Index'	65:22
	Function Operator()		66:39
		Examples	67:07
		Define (idx)	68:38
	Overloading Function Operator()		69:45
		Implement Operator() As a Member Function	69:48
		Calling Example	71:27
	Bad Overloading!		72:27
Exception Handling			57:51
	Intro		0:00
	Overview		0:11
	Something Went Wrong! Now What?		6:05
		Data Must Always be Validated	6:11
		Many Operations Will Validate Input to Make Sure No Mistakes Were Made	8:13
		Many Check the External Environment	10:26
		Many Don’t Check But App Can Still Crash	10:56
	Different Error Checking Methods		11:38
		Traditional Method	11:42
		Exception Handlin	14:09
		Lazy Way	15:30
	Traditional Error Checking		16:08
		Example: Return Code, Simply 'if'	16:12
		Example: Output Parameter	18:15
	Exception Handling		20:01
		'Try' Block	20:05
		'Catch All' Block	20:49
		No 'Finally' Block	21:31
		'System Errors'	22:34
	Basic Syntax		23:12
		Code to Throw an Exception	23:16
		Code to Handle an Exception	23:49
	Example Exception		26:51
		Run This Program Fragment, It Will Crash	26:54
		Run This One, The Error is Controlled	28:00
	Throw Exception		30:51
		Can 'Throw' An Exception If Error Conditions Found	30:56
		Basic Example' 'int' Exceptions	31:03
	Character String Exceptions		36:16
		Exception Can Be Any Type, But a Character String Can be Informative in Simple Cases	36:19
		Not Good for More Than Simple Situations	38:19
	Derive From 'Exception' Class		38:34
		When You Don’t Care Exactly Which Sub-Class of 'Exception' Can Be Thrown	39:02
		When Each Sub-Class Handled Differently	39:17
	Exception Derivation Example		41:28
	Adding 'Throw()' Keyword to Prototype		45:32
		Promises to Compiler What Kind of Exceptions the Function or Method Might Throw	45:42
		Leave the Keyword Off	46:39
		Leave the Parameter List Empty	46:51
		Exception Can Not Be Caught With a Type-Specific Handler	47:28
	Exceptions Not Derived From 'Exception'		49:11
	Don’t Rely on System Exceptions!		54:06
		Certain System Operations Don't Throw an Exception in a Platform-Independent Manner	54:10
		Examples	54:25
		Your Own Code Should Test for the Conditions That Might Lead to Uncatchable Exceptions	56:03
	Exceptional!		57:30
Namespaces			29:51
	Intro		0:00
	Overview		0:15
	Namespaces		5:27
		Uses the 'Scope Operator'	5:30
		Two Kinds: Standard Library and Classname	5:47
		Helps Avoid Third Party Name Collision	6:42
	'Namespace' for Class Association		7:46
		Scope	7:53
		Example	8:01
		Implementation in Separate File, Same Scope	8:46
	Define a Namespace		10:05
		Use 'namespace' Keyword, Valid Identifier, and Block to Add to a Namespace	10:07
		Example	10:40
	Units Can Share Namespace		12:26
		'std' Namespace	12:40
		Include Namespace Declaration Block in Each Compilation Unit	13:13
	Use Namespaces for Types, Classes		14:04
		Compilation Unit: alpha.cpp	14:11
		Compilation Unit: beta.cpp	14:27
		Calling Unit	14:49
	Don't Use Namespaces for Instances		15:21
		Namespace Cannot Be Used to Duplicate Names of Object Instances in Different Compilation Units	15:25
		Example	15:40
		Error When Compilation Units Are Linked Together	16:22
	Using Explicit Namespace		16:51
		Header File for Class	16:56
		Use of Namespace in Compilation Unit	17:03
	'Using' Keyword		17:36
		Specify a Default Namespace	17:40
		More Than One 'Using' Can Be Specified	18:49
	Avoiding 'Using'		20:48
		Third-Party Packages Often Avoid 'Using'	20:49
		Example	21:03
	Using for Particular Names		22:54
		The 'Using' Keyword Can Set Up Just Certain Names for a Default Use	22:56
	Naming Strategy		24:30
		Unique Name, World-Wide	24:48
		Avoid Confusion with Another Similar Name	25:23
		Typical Advice: Use Company Website Name	25:30
	Namespace Aliases		28:35
		User Uses Certain Namespace with a Different Name	28:27
		Example	28:38
	Avoiding Duplicates		29:33
Input/ Output			42:46
	Intro		0:00
	Overview		0:11
	Streams		4:37
		Byte Streams	4:51
		Operator '<<' Overloaded for Output	5:14
		Operator '>>' Overloaded for Input	5:47
	I/O Class Hierarchy		6:46
		ios_base	6:57
		Input Stream	7:04
		Output Stream	8:27
		Multiply Inherits From istream, ostream	9:04
	Buffer Class Hierarchy		9:27
		Buffering Allows I/O to Work More Efficiently	9:38
		'Flushed'	9:54
		Streambuf - Buffer for Data	9:58
	Base Class Attributes		10:25
		Formatting Information	10:36
		State Information	14:43
	Sub-Class Members		15:46
		IOS Adds Additional Members and Methods	15:49
		Error State Flags	18:23
	Input Classes		20:31
		istream - Input Character Stream	20:33
		ifstream - Input File Character Stream	22:50
		istringstream - Input String Character Stream	23:23
	Output Classes		24:10
		ostream - Output Character Stream	24:13
		ofstream - Output File Character Stream	25:28
		ostringstream - String Character Stream	25:42
	Multiple Inheritance and Includes		25:59
		iostream - Multiply Inherits From istream, ostream	26:04
		Classic Example of Multiple Inheritance	26:22
		fstream - Inherits From iostream	26:47
		stringstream - Inherits From iostream	27:08
	Detect Failures Using Status Bits		27:32
		Test the Status Bits	27:43
		Use Exceptions	29:12
	Failure Bit Cautions		30:20
		failbit Is Set on Formatted Input if the Input Stream Cannot be Parsed	30:27
		Example	30:37
	String I/O with Stringstream		32:21
		Used for Input and Output	32:26
		Example	33:45
	Flushing Data buffer		35:39
		Sometimes Buffering Is Not Desired	35:43
		Input Flush Example	37:10
		Output Flush Example	38:17
	Internationalization		39:06
		Complex Problem with Different Cultures	39:20
		'Imbue' I/O with Installed Locale Info	40:12
		Set Size of a 'Character' for I/O	41:45
	Confused Yet?		42:47
More With Functions			42:52
	Intro		0:00
	Overview		0:18
	Parameters for 'Main'		2:18
		First Function	2:19
		The Way Seen Most Often	5:13
	Some Typical Parameters		6:05
		Help	6:11
		Version	6:22
		User	6:51
		Password / Port	6:59
		File To Be Operated On	7:25
	Code Example		8:25
	Some Things of Note		12:17
		First Item in 'argv' is the Program File	12:20
		How Each Argument is Given to the Program is OS Dependent	13:42
		A Return of '0' Usually Means Success	14:48
	More Things of Note		15:11
		It's Customary to Have Both Stand-Alone Arguments (Options) and Arguments with Additional Parameters	15:28
		Examples	15:37
	Inline Functions		17:37
		'inline' Tells the Compiler to Insert the Function Body Explicitly Into the Code	17:43
		Function Modularity Without Function Overhead	17:53
		Example	19:05
	Recursive Functions		20:22
		Definition of Recursive: A Function or Algorithm That Uses Itself to Solve a Problem	20:34
		Common Mistakes	20:56
	Classic Example: Factorial		21:27
	Recursive Factorial Code		23:16
		Compare Iterative Version	23:48
	Pointers to Functions		25:55
		Technique Used Often in GUI Programming	26:05
		The Package Calls the Caller's Function by Dereferencing the Pointer	26:45
		Example	27:04
	Pointers to Functions as Parameters		27:45
		Syntax	28:01
		Calling Parameter Function Within Function	29:42
		Example	30:15
	Multi-Dimensional Array Parameters		31:07
		Function Receives a Pointer to Array But Can Not Know Size Ingo	31:40
		Example	31:48
	Ways to Handle; 1-Dim Array		33:53
		Good use for an Inline Function	34:06
	Ways to Handle: Internal Data		35:38
		Example 1	35:48
		Example 2	36:25
	Ways to Handle: Objects		39:38
		Example	39:47
		Usage Examples	41:18
	No Help Here!		42:28
More Types			39:10
	Intro		0:00
	Overview		0:12
	More Kinds of C++ Types		1:32
		It Has Strong Type Conventions That Can Be Used to Enforce Program Integrity	1:50
		Recommended: Avoid the Short Cuts!	2:02
		If a Short Cut is Necessary…	2:57
	Unions		3:24
		Union = Short-Cut	3:25
		Example: Inspect Each Byte of a 32 bit Integer	3:56
		This May Not Run the Same on Different Platforms	5:11
	Union of Struct		8:12
		Typical Use for a Union is Sharing Memory Between Structures	8:13
		Example	8:21
	Union Rules		9:56
		There's No Platform Independent Way to Store Member Data	9:57
		Cannot Store Classes That Have Constructors	11:37
	Enumerators		12:39
		Useful for Defining Enumerated Constants	12:40
		Use it Like Any Other Type	13:02
		Example: Can Be Started and Restarted at Any Value	13:38
		Can Be Used Like Any Integer	14:48
		Less Error-Prone	15:10
		Be Careful Changing the Sequence	15:25
		Example: Sometimes Useful to Associate String Constants	16:24
	Use of 'typedef'		17:46
		In C, 'types' Created with 'typedef' Keyword	17:47
		In C++, the Keyword is Largely Unnecessary	17:52
		Examples: Use of'typedef' in C and C++	18:06
	Custom Type Substitution		19:57
		'typedef' Keyword is Often used in Place of Somet Other underlying Type for Purposes of Clarity	19:58
		Examples: Custom Type Substitution	20:25
	Pointer Hiding		23:10
		Pointer to a Type Look	23:11
		Example: Pointer Hiding	23:39
	Cautions Using Underlying Types		26:02
		Example: Using Underlying Types	26:03
		The Underlying on Most Systems Today	26:42
		Example: Only Works Because It Is an 'int'	27:20
	Cautions Using time_t Typedef		28:05
		32-Bit Integer 'Runs Out' In The Year 2038	28:06
		Only Use the Provided Classes and Functions Designed to Handle a Particular Type	29:27
		When Working with typedef, Treat It Like A Class Object	29:45
	'const' Ness		30:45
		It’s More Than Just Declaring a Variable or Parameter That Cannot Be Changed	30:46
		Also Used on Methods	31:25
		Example: 'const' ness	31:37
	'const' on Object Attributes		33:01
		Can Be Used on Object Attributes	33:01
		Example: 'const' on Object Attributes	33:06
		Row That Is Permanently Identified by 17	33:34
	Allow Certain Change, 'mutable'		34:29
		'mutable' Allows Change	34:30
		Used on Specific Object Members When the Method Is Supposed to be 'const'	34:49
		Why Would Some Members Need to Change?	35:23
		Examples	36:00
	'mutable' Examples		36:49
	Union Troubles		38:53
Macros & Compilation			51:23
	Intro		0:00
	Overview		0:14
	Pre-Processor Macros		2:57
		Define with the 'Pound' Character	2:58
		Macros Are Pre-Processed on a Textual Basis	3:48
	Including Other Files		5:25
		Use the 'Include' Macro When You Use a Pre-Compiled Library	5:26
		Triangle Brackets	6:20
		Quotes Indicate That the Include File May Be Found in the Same Directory as the File Being Compiled	6:32
		Any Text File Can Be Included	7:00
	Basic Constant Definition		8:54
		'Define' Macro Keyboard	8:55
		'MAX_ROWS replaced by '300'	10:16
		Compiler Never Sees MAX_ROW	10:48
		Literally Anything Can Be Defined	12:03
	Typical Use		12:19
		Application Constants	12:30
		C++ Improvements	12:48
	Using Macros in Macros		13:32
		Macro Substitution Can Occur in Macro Substitution	13:33
		Example	14:17
		Text Replacement	14:30
	Conditional Compilation, Includes		16:20
		ifdef, ifndef, if, else, elif, and endif	16:21
		Include Guards & Example	18:10
	Conditional Compilation		20:21
		Don't Print Out Debugging Info in the Production Code	20:22
		Compiler Will Never See the Testing Code	21:48
		Macros Can Be 'undef'ed	22:36
	Good for Temporary Removal		23:27
		'Comment Out' Sections	23:37
		Can't Use the // or /**/ Comment	23:54
		Use 'ifdef'	24:57
	Macro Functions		26:29
		Macros Have a Facility for Creating Small In-Text Functions	26:30
		Define a Macro Function	27:16
		If You Need More Than One Line	27:32
	Macro Function Examples		28:34
		Return Area of a Circle	28:35
		Return Volume of a Cylinder	29:00
		What Can Happen Without Parentheses?	29:45
	Avoid Those Problems		31:14
		In C++, Use Inline Functions	31:15
		Inline Functions Avoid All Other Problems That Historically Have Occurred With Macros	32:11
	Mixing C with C++		34:08
		C Code Can Not Be Linked Directly with C++ Code	34:09
		In C Header File Add	35:38
	Pre-Defined Macros		37:18
		Macros That Should Be Pre-Defined for Every Standards-Compliant Compiler	37:19
	Occasional Misuse		38:39
		Abusing the Facility	38:40
		Example: Trying to 'look' Like Pascal	39:03
		Allows Code to be Written Like This	39:20
	Compiling		40:14
		Typical Compilation Command Line	40:15
		Compilation of One Unit at a Time	41:02
	Compiler Flags to Find Libraries		42:34
		Finding Other Include Files & Other Libraries to Link Into Your Application	42:35
		Example: Create an Application that Uses the MySQL Database	43:02
	Other Useful Flags		47:07
		Small Set of Command Line is Most Common	47:08
		'-c' Create an Object File From the Source	47:12
		'-g' Add Internal Code That Allows a Run-Time Debugger to Hook into the Program	47:22
		'-Dmacro' Set a Macro to be Defined	47:58
		'-E' Stop After Pre-Processing	48:55
		'-S' Stop After Compilation	49:26
	Setting Flags for IDE		49:51
		If You're Using Eclipse	49:52
		Example	50:25
	Uh, Almost		51:03
A Look at Some Code			57:58
	Intro		0:00
	Real Code Example		0:29
		Global Constants	1:10
		Account.cpp	2:14
		Account.h	3:03
		Call Back Function	3:24
		Vector & Transactions	4:10
		Constructor	5:54
		User.h	8:54
		User.cpp	12:01
		Exceptions	23:56
		Class Exception, Minor Exception, and Regular Exception	24:57
		StringField.h	29:38
		StringField.cpp	35:40
		NumberField.h	38:56
		NumberField.cpp	44:56
		IntegerField.cpp	47:53
		Date.h	49:17
		Date.cpp	51:10
		BankAccountMain.cpp	52:20
	Lesson Summary		56:46