Lynda com - C C Essential Training

1. 01 - Introduction/01-Welcome.wmv13.2MB
2. 01 - Introduction/02-Using the exercise files.wmv2.67MB
3. 01 - Introduction/03-Prerequisites.mov1.8MB
4. 02 - Language Overview/01-About C.mov6.13MB
5. 02 - Language Overview/02-About C++.mov5.2MB
6. 03 - Getting Started/01-Setting up Eclipse for Mac.mov16.48MB
7. 03 - Getting Started/02-Upgrading GCC on the Mac.mov16.25MB
8. 03 - Getting Started/03-Setting up Eclipse for Windows.mov26.74MB
9. 03 - Getting Started/04-Working with Eclipse on Windows.mov4.21MB
10. 03 - Getting Started/05-Setting up Eclipse in Ubuntu Linux.mov21.89MB
11. 03 - Getting Started/06-Understanding the development cycle with Hello, World.mov8.81MB
12. 03 - Getting Started/07-Using stdout and stderr.mov9.65MB
13. 03 - Getting Started/08-Using stdin.mov9.49MB
14. 04 - The C Programming Language/01-Exploring the anatomy of a C program.mov11.21MB
15. 04 - The C Programming Language/02-Writing statements and expressions.mov7.18MB
16. 04 - The C Programming Language/03-Working with identifiers.mov2.51MB
17. 04 - The C Programming Language/04-Defining variables.mov2.56MB
18. 04 - The C Programming Language/05-Understanding identifier scope and using storage classes.mov10.86MB
19. 04 - The C Programming Language/06-Declaring variables and functions.mov8.46MB
20. 04 - The C Programming Language/07-Using pointers.mov2.02MB
21. 04 - The C Programming Language/08-Working with arrays and strings.mov6.07MB
22. 04 - The C Programming Language/09-Comparing with conditionals.mov7.57MB
23. 04 - The C Programming Language/10-Using switch statements.mov9.25MB
24. 04 - The C Programming Language/11-Using while and do loops.mov6.14MB
25. 04 - The C Programming Language/12-Iterating with the for loop.mov7.64MB
26. 04 - The C Programming Language/13-Creating functions.mov11.37MB
27. 04 - The C Programming Language/14-Branching with goto, break, and continue.mov4.38MB
28. 05 - The C Preprocessor/01-About the C preprocessor.mov2.5MB
29. 05 - The C Preprocessor/02-Defining constants.mov6.13MB
30. 05 - The C Preprocessor/03-Including files.mov3.67MB
31. 05 - The C Preprocessor/04-Exploring conditional compilation.mov4.36MB
32. 05 - The C Preprocessor/05-Defining macros.mov4.89MB
33. 05 - The C Preprocessor/06-Macro caveats.mov7.11MB
34. 05 - The C Preprocessor/07-Working with line continuation using the backslash.mov4.65MB
35. 05 - The C Preprocessor/08-Including files only once.mov5.85MB
36. 06 - Data Types/01-About the data types.mov3.57MB
37. 06 - Data Types/02-Introducing integer types.mov6.74MB
38. 06 - Data Types/03-Understanding floating-point types.mov5.84MB
39. 06 - Data Types/04-Working with characters and strings.mov3.27MB
40. 06 - Data Types/05-Using strings.mov6.9MB
41. 06 - Data Types/06-Creating character escape sequences.mov3.77MB
42. 06 - Data Types/07-Working with qualifiers.mov6.26MB
43. 06 - Data Types/08-Using the C++ reference type.mov7.91MB
44. 06 - Data Types/09-Working with structured data.mov8.01MB
45. 06 - Data Types/10-Introducing bit fields.mov3.21MB
46. 06 - Data Types/11-Working with enumerations.mov11.62MB
47. 06 - Data Types/12-Using unions.mov3.21MB
48. 06 - Data Types/13-Defining types with typedef.mov5.1MB
49. 06 - Data Types/14-Introducing the void type.mov8.24MB
50. 06 - Data Types/15-Understanding the auto type.mov7.92MB
51. 07 - Operators/01-Exploring the assignment operator.mov7.3MB
52. 07 - Operators/02-Using arithmetic operators.mov7.31MB
53. 07 - Operators/03-Working with increment and decrement operators.mov10.2MB
54. 07 - Operators/04-Using comparison (relational) operators.mov4.1MB
55. 07 - Operators/05-Using logical operators.mov4.83MB
56. 07 - Operators/06-Exploring bitwise operators.mov4.12MB
57. 07 - Operators/07-Working with compound assignment operators.mov5.9MB
58. 07 - Operators/08-Using the array subscript operator.mov4.16MB
59. 07 - Operators/09-Using pointers, members, and indirection operators.mov4.65MB
60. 07 - Operators/10-Exploring the function call operator.mov4.4MB
61. 07 - Operators/11-Working with the ternary conditional operator.mov2.62MB
62. 07 - Operators/12-Determining the size of a type with sizeof.mov4.34MB
63. 07 - Operators/13-Determining the type of an object with typeid.mov5.62MB
64. 07 - Operators/14-Using the cast operator.mov4.14MB
65. 07 - Operators/15-Working with the new and delete operators.mov5.28MB
66. 07 - Operators/16-Understanding operator precedence.mov5.09MB
67. 07 - Operators/17-Using operator synonyms.mov5.04MB
68. 08 - Defining Functions/01-Overview of functional programming.mov3.58MB
69. 08 - Defining Functions/02-Defining a function.mov3.8MB
70. 08 - Defining Functions/03-Passing parameters to a function.mov7.82MB
71. 08 - Defining Functions/04-Using automatic and static variables.mov2.33MB
72. 08 - Defining Functions/05-Using function pointers.mov14.46MB
73. 08 - Defining Functions/06-Overloading function names.mov4.36MB
74. 08 - Defining Functions/07-Overloading operators with functions.mov4.42MB
75. 08 - Defining Functions/08-Defining a variable number of arguments.mov7.37MB
76. 08 - Defining Functions/09-Using recursion.mov4.33MB
77. 09 - Classes and Objects/01-Overview of classes and objects.mov3.76MB
78. 09 - Classes and Objects/02-Exploring namespaces.mov8.1MB
79. 09 - Classes and Objects/03-Defining a class.mov7.64MB
80. 09 - Classes and Objects/04-Using data members.mov8.02MB
81. 09 - Classes and Objects/05-Working with member functions.mov13.51MB
82. 09 - Classes and Objects/06-Pointing to the current object with the this pointer.mov6.71MB
83. 09 - Classes and Objects/07-Using constructors and destructors.mov26.58MB
84. 09 - Classes and Objects/08-Exploring implicit vs. explicit constructor type conversions.mov14.2MB
85. 09 - Classes and Objects/09-Overloading operators with member functions.mov18.74MB
86. 09 - Classes and Objects/10-Overloading operators with non-member functions.mov15.35MB
87. 09 - Classes and Objects/11-Using conversion operators.mov7.81MB
88. 09 - Classes and Objects/12-Creating function objects.mov2.75MB
89. 09 - Classes and Objects/13-Creating and destroying objects with the new and delete operators.mov8.35MB
90. 09 - Classes and Objects/14-Reporting errors with exceptions.mov11MB
91. 10 - Inheritance/01-Overview of class inheritance.mov1.74MB
92. 10 - Inheritance/02-Exploring simple inheritance.mov10.01MB
93. 10 - Inheritance/03-Reviewing friendship.mov11.37MB
94. 10 - Inheritance/04-Accessing the base class.mov5.16MB
95. 10 - Inheritance/05-Understanding multiple inheritance.mov10.12MB
96. 10 - Inheritance/06-Exploring overloading methods and polymorphism.mov18.97MB
97. 11 - Templates/01-Understanding templates.mov2.53MB
98. 11 - Templates/02-Understanding template functions.mov9.96MB
99. 11 - Templates/03-Using template classes.mov12.63MB
100. 12 - Standard Library/01-Overview of the C Standard Library.mov2.58MB
101. 12 - Standard Library/02-Using stdio for file IO.mov19.84MB
102. 12 - Standard Library/03-Using stdio for file management.mov4.1MB
103. 12 - Standard Library/04-Using stdio for unformatted character IO.mov6.47MB
104. 12 - Standard Library/05-Using stdio for formatted character IO.mov8.46MB
105. 12 - Standard Library/06-Building string functions.mov12.97MB
106. 12 - Standard Library/07-Understanding memory allocation.mov10.22MB
107. 12 - Standard Library/08-Handling system errors.mov5.22MB
108. 12 - Standard Library/09-Working with time and date functions.mov8.52MB
109. 12 - Standard Library/10-Getting file information.mov8.13MB
110. 13 - Standard Template Library/01-Overview of the STL.mov2.14MB
111. 13 - Standard Template Library/02-Using vectors.mov10.19MB
112. 13 - Standard Template Library/03-Working with pairs and tuples.mov9.4MB
113. 13 - Standard Template Library/04-Writing iterators.mov11.12MB
114. 13 - Standard Template Library/05-Using lists.mov10.66MB
115. 13 - Standard Template Library/06-Working with sets.mov11.73MB
116. 13 - Standard Template Library/07-Creating maps.mov17.13MB
117. 13 - Standard Template Library/08-Using queues.mov9.18MB
118. 13 - Standard Template Library/09-Working with stacks.mov6.24MB
119. 13 - Standard Template Library/10-Introducing the deque container.mov6.5MB
120. 13 - Standard Template Library/11-Using strings.mov6.47MB
121. 13 - Standard Template Library/12-Working with algorithms.mov27.43MB
122. 13 - Standard Template Library/13-Using IO streams.mov20.7MB
123. 13 - Standard Template Library/14-Handling exceptions.mov14.31MB
124. 14 - The Latest Standard C++11/01-Overview of C++11.mov1.56MB
125. 14 - The Latest Standard C++11/02-Using the range-based for loop.mov7.35MB
126. 14 - The Latest Standard C++11/03-Exploring the unambiguous null pointer constant.mov4.98MB
127. 14 - The Latest Standard C++11/04-Understanding type inference.mov12.44MB
128. 14 - The Latest Standard C++11/05-Using lambda functions.mov9.64MB
129. 15 - Conclusion/01-Goodbye.mov630.34KB