Advanced C Programming Course

Advanced C Programming Course

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 28 Hours | 9.75 GB


Become a True Master of the C Programming Language – Confidently Apply for Real Time or Embedded C Jobs or contracts!

The C programming language in 2020 is still one of the most popular and widely used languages. Having C programming skills gives you great career options, but learning the C language, particularly some of the trickier advanced stuff can be really difficult.

This course is designed to take your basic C skills to the next level and help you obtain mastery of the language by helping you understand advanced concepts of the C programming language, enabling you to master the art of problem-solving in programming using efficient, proven methods.

You’ll learn how to write high-quality C code and to make yourself more marketable for higher-level programming positions.

Just some of the topics in this huge 28-hour course include Threads, Function Pointers, Double Pointers, Recursion, Networking using Sockets, Bit manipulation, Macros, Signals, Storage Classes and loads more. Check the curriculum on this page for full details of what is included in this very comprehensive course.

By the end of this course, with your new-found skills, you will be able to apply for real-time/embedded C programming positions or any job that requires mastery of the C programming language and be able to apply your new skills developing your own Advanced C programs.

What you’ll learn

  • Understand and be able to apply advanced concepts of the C programming language to create advanced C applications.
  • Understand Function and Double Pointers, Recursion, Bit Manipulation, Macros, Signals and loads more (check curriculam on this page for full list).
  • Learn all about threads and networking with Sockets.
  • Master the art of problem solving in programming using efficient, proven methods.
  • Be able to apply advanced C concepts to other programming languages.
  • How to write high quality C code, to make yourself more marketable for higher level programming positions and be apply for real-time/embedded programming positions.


+ Table of Contents

Introduction
1 Welcome to Class
2 Class Organization
3 The C99 Standard
4 The C11 Standard

Installing Required Software
5 Overview
6 Installing the C compiler (Windows)
7 Installing the C compiler (Mac)
8 Installing Code Blocks (Windows)
9 Installing CodeLite (Windows)
10 Installing CodeLite (Mac)
11 Installing Visual Studio Code (Windows)
12 Installing Visual Studio Code (Linux)
13 Installing Visual Studio Code (Mac)

Starting to Write Code
14 Exploring the Code Blocks Environment
15 Creating a Project in Code Blocks
16 Exploring the Visual Studio Code Environment
17 Creating a Workspace and configuring the compiler in Visual Studio Code

Working with Larger Programs
18 Overview
19 Compiling multiple source files from the command line
20 Makefiles
21 Communication between files
22 Using Header files effectively
23 Heap and Stack Memory Allocation

Storage Classes
24 Automatic Variables
25 External
26 Static
27 Register
28 (Challenge)

Advanced Data Types
29 The define statement (constants)
30 Using typedef
31 Variable Length Arrays
32 (Challenge) Variable Length Arrays
33 Flexible Array Members
34 (Challenge) Flexible Array Members
35 Complex number types
36 (Challenge) Complex number types
37 Designated Initializers
38 (Demonstration) Challenge solutions

Type Qualifiers
39 const
40 volatile
41 restrict

Bit Manipulation
42 Binary numbers and bits
43 (Challenge) Binary numbers and Bits
44 (Demonstration) Binary numbers and Bits
45 Bitwise Operators (Logical)
46 Bitwise Operators (Shifting)
47 (Challenge) Bitwise Operators
48 (Demonstration) Bitwise Operators
49 Bitmasks
50 Using Bit Operators to pack data
51 (Challenge) Setting and Reading bits
52 (Demonstration) Setting and Reading bits
53 Using Bit Fields to pack data
54 (Challenge) Using Bit Fields to pack data
55 (Demonstration) Using Bit Fields to pack data

Advanced Control Flow
56 The goto statement
57 (Challenge) The goto statement
58 The null statement
59 The comma operator
60 setjmp and longjmp functions
61 (Challenge) setjmp and longjmp functions
62 (Demonstration) Advanced Control Flow

Input and Output
63 char functions (input)
64 char functions (output)
65 (Challenge) char functions
66 (Demonstration) char functions
67 string functions
68 (Challenge) string functions
69 (Demonstration) string functions
70 Formatting functions
71 (Challenge) Formatting functions
72 (Demonstration) Formatting functions

Advanced Function Concepts
73 Variadic Functions
74 va copy
75 (Challenge) Variadic Functions
76 (Demonstration) Variadic Functions
77 Recursion
78 (Challenge) Recursion
79 (Demonstration) Recursion
80 Inline Functions
81 Noreturn Functions

Unions
82 Overview
83 Defining a Union
84 Accessing Union Members
85 (Challenge) Unions
86 (Demonstration) Unions

The Preprocessor
87 Overview
88 Conditional Compilation
89 Include guards and undef
90 pragma and error

Macros
91 Overview
92 Macros vs. Functions
93 Creating your own Macros
94 Preprocessor Operators
95 Predefined Macros
96 (Challenge) Macros
97 (Demonstration) Macros

Advanced Debugging Analysis and Compiler Options
98 GCC Compiler Options (part 1)
99 GCC Compiler Options (part 2)
100 Debugging with the preprocessor
101 Debugging with gdb (part 1)
102 Debugging with gdb (part 2)
103 core files
104 Profiling
105 Static Analysis
106 (Challenge)
107 (Demonstration)

Advanced Pointers
108 Double pointers (pointer to a pointer)
109 Double pointers (pointer to a pointer) Part 2
110 (Challenge) Double pointers
111 (Demonstration) Double pointers
112 Function pointers
113 (Challenge) Function pointers
114 (Demonstration) Function pointers
115 void pointers

Static Libraries and Shared Objects
116 Overview
117 Creating a Static Library (archive)
118 (Challenge) Static Library
119 (Demonstration) Static Library
120 Creating a Dynamic Library (Shared object)
121 (Challenge) Dynamic Library
122 (Demonstration) Dynamic Library
123 Dynamically loading a shared object
124 (Challenge) Dynamic Loading
125 (Demonstration) Dynamic Loading

Useful C Libraries
126 Assert
127 General Utilities (stdlib.h)
128 General Utilities (stdlib.h) part 2
129 General Utilities (stdlib.h) part 3
130 Date and Time functions
131 (Challenge)
132 (Demonstration)

Data Structures
133 Abstract Data Types
134 Linked Lists (Overview)
135 Linked LIsts (Implementation)
136 (Challenge) Linked Lists
137 (Demonstration) Linked Lists
138 Stacks (Overview)
139 Stacks (Implementation)
140 Queues (Overview)
141 Queues (Implementation)
142 Binary Trees (Overview)
143 Binary Trees (Implementation)

Interprocess Communication and Signals
144 Interprocess Communication
145 Signals (Overview)
146 Raising a Signal
147 Handling a Signal using the signal function
148 Handling a Signal using sigaction
149 The fork() system call
150 (Challenge)
151 (Demonstration)

Threads
152 Overview
153 Creating a thread
154 Passing arguments and returning values
155 Common Thread functions
156 Thread Synchronization Concepts
157 Mutexes
158 Condition Variables
159 (Challenge)
160 (Demonstration)

Networking (Sockets)
161 Overview
162 The Socket API
163 Creating a Server Socket
164 Creating a Client Socket
165 (Challenge)
166 (Demonstration)

Conclusion
167 Course Summary

Extra Information – Source code and other stuff
168 Source Codes