C Programming - Learn By Example (75 Solved Problems)

About Course

• Like a gruff uncle, C++ seems intimidating, when its just being helpful. These 75 examples will help you understand that.

  • C++ seems intimidating because all too often, what you see is not what you get.

  • Usually, that's because C++ is trying to help you, but you don't realise that. C++ is incredibly deep, and it sometimes struggles to get you - the programmer - to understand what it's saying

  • These 75 examples will help. Each is self-contained, has its source code attached, and gets across a specific C++ use-case. Each example is simple, but not simplistic.

   

Curriculam

• Section 1: Introducing C++
  	Lecture 1	Introducing C++	02:19
  Section 2: Moving from C to C++
  	Lecture 2	C and C++ - similar in some ways but actually very different	14:05
  	Lecture 3	C vs C++: Comments are different - and oh C++ has namespaces!	11:37
  	Lecture 4	Namespaces? Then we need a scope resolution operator	09:08
  	Lecture 5	Not just function overloading, C++ allows operator overloading as well!	13:27
  	Lecture 6	Default Values	14:41
  	Lecture 7	References, Const and Bool	17:59
  Section 3: Objects and Classes
  	Lecture 8	Classes mean different things to different people!	12:59
  	Lecture 9	Classes - A logical grouping of data and functions	19:46
  	Lecture 10	Example 1 and 2: Define a really simple C++ class and instantiate it	14:16
  	Lecture 11	Example 3: Invoke the member functions of an object	14:33
  	Lecture 12	Example 4 and 5: Setup and clean up using constructors and destructors	18:07
  	Lecture 13	Example 6: Access Modifiers	19:36
  Section 4: Multi-file Programs
  	Lecture 14	Example 7: Separating code into .cpp and .h files	16:02
  	Lecture 15	Example 7: Setting up dependencies with multiple files	17:01
  Section 5: Dynamic Memory Allocation: new and delete
  	Lecture 16	Dynamic Memory Allocation	17:43
  	Lecture 17	C++ memory allocation explained	05:57
  	Lecture 18	Stop using malloc and free	12:15
  	Lecture 19	Do not mix new/delete for single variables with array equivalents new[]/delete[]	10:25
  	Lecture 20	Example 8 and 9: Stop using malloc and free, use new and delete instead!	13:38
  	Lecture 21	Example 10 and 11: Use new[] and delete [] for arrays - never mix new and new[]	10:29
  	Lecture 22	Example 12: The Placement new operator and the "this" pointer Preview	17:06
  Section 6: The C++ string Class
  	Lecture 23	The C++ string class	04:20
  	Lecture 24	Example 14: Strings	04:37
  	Lecture 25	Example 15: Inputing multiline strings	05:45
  	Lecture 26	Example 16: More common string operations	15:11
  	Lecture 27	Example 17: Comparing strings	06:07
  	Lecture 28	Example 18: Converting C++ to C strings (and vice versa)	04:41
  Section 7: References
  	Lecture 29	The basic idea of references	10:47
  	Lecture 30	Example 19, 20 and 21: A simple reference, a const reference, and C++ swap	09:34
  	Lecture 31	Example 22, 23, 24, 25: Reference initialization, reassignment, aliasing, null	14:55
  	Lecture 32	Example 26, 27, 28, 29: References to pointers, references as return types	12:37
  Section 8: The const Keyword
  	Lecture 33	Example 30 and 31: The C++ const keyword	13:44
  	Lecture 34	Example 32: const char* or char* const?	16:44
  	Lecture 35	Example 33, 34, 35, 36: Const methods, mutable, overloading on const, const_cast	16:15
  	Lecture 36	Passing function parameters const references	09:18
  	Lecture 37	Example 37: Passing function parameters const references	15:05
  Section 9: The static Keyword
  	Lecture 38	The basic idea of static in C++	10:33
  	Lecture 39	Example 38: Static member variables	13:08
  	Lecture 40	Example 39 and 40: Static member functions	09:19
  	Lecture 41	Example 41: const static member variables	06:57
  Section 10: The friend Keyword
  	Lecture 42	The basic idea of friends in C++	09:52
  	Lecture 43	Example 42: Friend functions	19:49
  	Lecture 44	Example 43: Friend classes	07:08
  Section 11: Operator Overloading
  	Lecture 45	Understanding operator overloading - internal and external operators	15:55
  	Lecture 46	Choosing between internal and external implementations	09:21
  	Lecture 47	Example 44: Overloading the += operator	14:41
  	Lecture 48	Example 45: Overloading the + operator	12:59
  	Lecture 49	Example 46: Overloading the ++ (and --) operators	15:10
  	Lecture 50	Example 47: Overloading the assignment operator	19:48
  	Lecture 51	Operator Overloading - Streams Flashback	07:31
  	Lecture 52	Example 48: Overloading the << and >> operators	15:28
  Section 12: Inheritance
  	Lecture 53	Understanding inheritance - Flashback to objects and classes	08:00
  	Lecture 54	Example 49 Understanding Inheritance	18:51
  	Lecture 55	Inheritance Explained - I	07:44
  	Lecture 56	Inheritance Explained - II	06:45
  	Lecture 57	Example 49: Access levels and inheritance types	08:21
  	Lecture 58	Example 49: Bringing all inheritance concepts together in code	15:57
  	Lecture 59	Examples 50, 51, 52: Types of inheritance	18:12
  	Lecture 60	Example 53: virtual functions	16:32
  	Lecture 61	Example 53 (continued)	08:54
  	Lecture 62	Example 54: pure virtual functions and abstract classes	10:28
  	Lecture 63	Example 55: Multiple Inheritance, and a Diamond Hierarchy	15:30
  	Lecture 64	Example 56: Virtual inheritance in a Diamond Hierarchy	06:26
  	Lecture 65	Example 57: Object Slicing	05:42
  	Lecture 66	Example 58: No virtual function calls in constructors or destructors!	06:21
  	Lecture 67	Example 59: Virtual destructors rock!	03:58
  	Lecture 68	Example 60: Why virtual functions should never have default parameters	02:54
  	Lecture 69	Example 61: The strange phenomenon of name hiding	03:34
  	Lecture 70	Example 62: Never redefine non-virtual base class methods	03:13
  Section 13: Templates
  	Lecture 71	Templates as a form of generic programming	03:29
  	Lecture 72	Example 63: A simple template function	09:48
  	Lecture 73	Example 64: Overriding a default template instantiation	08:28
  	Lecture 74	Example 65: A templated smart pointer class	13:18
  	Lecture 75	Example 66: Template Specialisation (partial or total)	07:59
  Section 14: STL - The Standard Template Library
  	Lecture 76	Introducing the Standard Template Library	02:48
  	Lecture 77	Example 67: The STL vector	12:28
  	Lecture 78	Example 68: Iterators	08:28
  	Lecture 79	Example 69: map, an associative container	08:00
  	Lecture 80	Example 70: STL algorithms	10:20
  Section 15: C++ Casts
  	Lecture 81	C++ casts are way cooler than C casts	05:16
  	Lecture 82	Example 71: const_cast	03:06
  	Lecture 83	Example 72: dynamic_cast, and RTTI	12:12
  	Lecture 84	Example 73: static_cast, and the explicit keyword	09:22
  Section 16: Exceptions
  	Lecture 85	Exception handling and burglar alarms	07:00
  	Lecture 86	Example 74: Throwing exceptions	06:01
  	Lecture 87	Example 75: Handling exceptions with try/catch	05:55

What you will get from this course?

• • Moving to C++ from C: If you are a C programmer, this section will run through what you need to know in order to move seamlessly to C++.
  • Objects, Classes and Object-Oriented Programming: Access modifiers, classes, objects, the this pointer, new/delete and dynamic memory allocation gotchas
  • Operator overloading is a particularly complicated topic - C++ is virtually alone in the ubiquity of overloaded operators. Make sure this doesn't trip you up. Also go deep into the workings of const, static and friend
  • Inheritance in C++ is considerably more complicated than in Java, mostly because of multiple inheritance, and because of the co-existence of both virtual and non-virtual methods.
  • Templates are a classic generic programming technique that were revolutionary when first added to C++. Understand template functions and classes, as well as template specializations.
  • STL - the Standard Template Library - is incredibly powerful. Get a good sense of collections, iterators and algorithms - the major components of the STL
  • C++ casts are quite different than C-casts. Understand const_cast, static_cast and dynamic_cast, as well as Real Time Type Identification (RTTI), and the manner in which explicit conversions can be performed using static_cast
  • Exceptions and exception handling in C++
  • Harness the full power of C++ without being intimidated by the language's complexities
  • Use inheritance, operator overloading, templates, STL and all major C++ language features

Who should buy this course?

• • Java and C# programmers - who understand Object Oriented Programming, but are new to C++
  • Folks with prior programming experience in C. No prior object oriented programming experience is needed

  What are the requirements?

  • Students should have an understanding of programming - concepts such as variables, loops and if-else statements will not be explained