Advanced C Programming Course

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

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 senior programming positions and be apply for real-time/embedded programming positions.

Requirements

Basic knowledge of the C programming language (ideally having completed our Beginners course on Udemy).

A computer running Microsoft Windows, Linux or the Mac operating systems.

At least 4GB of ram on your computer.

Description

What you will learn in this course?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's different about this course?Jason Fedin is your instructor in this course and this course takes the skills you learned in that course to the next level.This course focuses on the details and a thorough understanding of all advanced C programming concepts. This is not just a how-to course, it is a "why?" course. You will learn how to implement specific advanced C concepts such as multi-threading and double pointers, in addition to learning why they are the best approach and how they make you a high-quality C programmer. Many, many examples, challenges and quizzes are provided to test your understanding of every concept that you have learned. This course is unique to other courses here at Udemy in that the details and the why are explained. We do not just go through projects and provide a how-to.Who is the course aimed at?This is not a beginner's course.  It's assumed you have some knowledge of the C programming language, preferably having completed our Beginner course (here on Udemy) or similar training and/or commercial programming experience in C or a similar language.Getting startedIf you are ready to get started, click on the enroll or Add to Cart button on this page and start taking your C Language skills to the next level.

Overview

Section 1: Introduction

Lecture 1 Welcome to Class!

Lecture 2 Class Organization

Lecture 3 The C99 Standard

Lecture 4 The C11 Standard

Section 2: Installing Required Software

Lecture 5 Overview

Lecture 6 Installing the C Compiler (Windows)

Lecture 7 Installing CodeLite On Windows

Lecture 8 Configuring CodeLite on Windows

Lecture 9 Installing the C Compiler (Mac)

Lecture 10 Installing CodeLite on Mac

Lecture 11 Configuring CodeLite on Mac

Lecture 12 Installing CodeLite on Ubuntu Linux

Lecture 13 Configuring CodeLite on Ubuntu Linux

Lecture 14 Creating a Default CodeLite Project Template (All Versions)

Lecture 15 Using the Command Line Interface

Lecture 16 Using the Command Line Interface on Windows

Lecture 17 Using the Command Line Interface on Mac

Lecture 18 Using the Command Line Interface on Linux

Lecture 19 Using a Web-based C compiler

Section 3: Starting to Write Code

Lecture 20 Exploring the CodeLite Environment

Lecture 21 Creating our first C program

Lecture 22 Building/Compiling our first program

Section 4: Working with Larger Programs

Lecture 23 Overview

Lecture 24 Compiling multiple source files from the command line

Lecture 25 Makefiles

Lecture 26 Communication between files

Lecture 27 Using Header files effectively

Lecture 28 Heap and Stack Memory Allocation

Section 5: Storage Classes

Lecture 29 Automatic Variables

Lecture 30 External

Lecture 31 Static

Lecture 32 Register

Lecture 33 (Challenge)

Section 6: Advanced Data Types

Lecture 34 The #define statement (constants)

Lecture 35 Using typedef

Lecture 36 Variable Length Arrays

Lecture 37 (Challenge) Variable Length Arrays

Lecture 38 Flexible Array Members

Lecture 39 (Challenge) Flexible Array Members

Lecture 40 Complex number types

Lecture 41 (Challenge) Complex number types

Lecture 42 Designated Initializers

Lecture 43 (Demonstration) Challenge solutions

Section 7: Type Qualifiers

Lecture 44 const

Lecture 45 volatile

Lecture 46 restrict

Section 8: Bit Manipulation

Lecture 47 Binary numbers and bits

Lecture 48 (Challenge) Binary numbers and Bits

Lecture 49 (Demonstration) Binary numbers and Bits

Lecture 50 Bitwise Operators (Logical)

Lecture 51 Bitwise Operators (Shifting)

Lecture 52 (Challenge) Bitwise Operators

Lecture 53 (Demonstration) Bitwise Operators

Lecture 54 Bitmasks

Lecture 55 Using Bit Operators to pack data

Lecture 56 (Challenge) Setting and Reading bits

Lecture 57 (Demonstration) Setting and Reading bits

Lecture 58 Using Bit Fields to pack data

Lecture 59 (Challenge) Using Bit Fields to pack data

Lecture 60 (Demonstration) Using Bit Fields to pack data

Section 9: Advanced Control Flow

Lecture 61 The goto statement

Lecture 62 (Challenge) The goto statement

Lecture 63 The null statement

Lecture 64 The comma operator

Lecture 65 setjmp and longjmp functions

Lecture 66 (Challenge) setjmp and longjmp functions

Lecture 67 (Demonstration) Advanced Control Flow

Section 10: Input and Output

Lecture 68 char functions (input)

Lecture 69 char functions (output)

Lecture 70 (Challenge) char functions

Lecture 71 (Demonstration) char functions

Lecture 72 string functions

Lecture 73 (Challenge) string functions

Lecture 74 (Demonstration) string functions

Lecture 75 Formatting functions

Lecture 76 (Challenge) Formatting functions

Lecture 77 (Demonstration) Formatting functions

Section 11: Advanced Function Concepts

Lecture 78 Variadic Functions

Lecture 79 va_copy

Lecture 80 (Challenge) Variadic Functions

Lecture 81 (Demonstration) Variadic Functions

Lecture 82 Recursion

Lecture 83 (Challenge) Recursion

Lecture 84 (Demonstration) Recursion

Lecture 85 Inline Functions

Lecture 86 _Noreturn Functions

Section 12: Unions

Lecture 87 Overview

Lecture 88 Defining a Union

Lecture 89 Accessing Union Members

Lecture 90 (Challenge) Unions

Lecture 91 (Demonstration) Unions

Section 13: The Preprocessor

Lecture 92 Overview

Lecture 93 Conditional Compilation

Lecture 94 Include guards and #undef

Lecture 95 #pragma and #error

Section 14: Macros

Lecture 96 Overview

Lecture 97 Macros vs. Functions

Lecture 98 Creating your own Macros

Lecture 99 Preprocessor Operators

Lecture 100 Predefined Macros

Lecture 101 (Challenge) Macros

Lecture 102 (Demonstration) Macros

Section 15: Advanced Debugging, Analysis, and Compiler Options

Lecture 103 GCC Compiler Options (part 1)

Lecture 104 GCC Compiler Options (part 2)

Lecture 105 Debugging with the preprocessor

Lecture 106 Debugging with gdb (part 2)

Lecture 107 core files

Lecture 108 Profiling

Lecture 109 Static Analysis

Lecture 110 (Challenge)

Lecture 111 (Demonstration)

Section 16: Advanced Pointers

Lecture 112 Double pointers (pointer to a pointer)

Lecture 113 Double pointers (pointer to a pointer) Part 2

Lecture 114 Debugging with gdb (part 1)

Lecture 115 (Challenge) Double pointers

Lecture 116 (Demonstration) Double pointers

Lecture 117 Function pointers

Lecture 118 (Challenge) Function pointers

Lecture 119 (Demonstration) Function pointers

Lecture 120 void pointers

Section 17: Static Libraries and Shared Objects

Lecture 121 Overview

Lecture 122 Creating a Static Library (archive)

Lecture 123 (Challenge) Static Library

Lecture 124 (Demonstration) Static Library

Lecture 125 Creating a Dynamic Library (Shared object)

Lecture 126 (Challenge) Dynamic Library

Lecture 127 (Demonstration) Dynamic Library

Lecture 128 Dynamically loading a shared object

Lecture 129 (Challenge) Dynamic Loading

Lecture 130 (Demonstration) Dynamic Loading

Section 18: Useful C Libraries

Lecture 131 Assert

Lecture 132 General Utilities (stdlib.h)

Lecture 133 General Utilities (stdlib.h) part 2

Lecture 134 General Utilities (stdlib.h) part 3

Lecture 135 Date and Time functions

Lecture 136 (Challenge)

Lecture 137 (Demonstration)

Section 19: Data Structures

Lecture 138 Abstract Data Types

Lecture 139 Linked Lists (Overview)

Lecture 140 Linked LIsts (Implementation)

Lecture 141 (Challenge) Linked Lists

Lecture 142 (Demonstration) Linked Lists

Lecture 143 Stacks (Overview)

Lecture 144 Stacks (Implementation)

Lecture 145 Queues (Overview)

Lecture 146 Queues (Implementation)

Lecture 147 Binary Trees (Overview)

Lecture 148 Binary Trees (Implementation)

Section 20: Interprocess Communication and Signals

Lecture 149 Interprocess Communication

Lecture 150 Signals (Overview)

Lecture 151 Raising a Signal

Lecture 152 Handling a Signal using the signal function

Lecture 153 Handling a Signal using sigaction

Lecture 154 The fork() system call

Lecture 155 (Challenge)

Lecture 156 (Demonstration)

Section 21: Threads

Lecture 157 Overview

Lecture 158 Creating a thread

Lecture 159 Passing arguments and returning values

Lecture 160 Common Thread functions

Lecture 161 Thread Synchronization Concepts

Lecture 162 Mutexes

Lecture 163 Condition Variables

Lecture 164 (Challenge)

Lecture 165 (Demonstration)

Section 22: Networking (Sockets)

Lecture 166 Overview

Lecture 167 The Socket API

Lecture 168 Creating a Server Socket

Lecture 169 Creating a Client Socket

Lecture 170 (Challenge)

Lecture 171 (Demonstration)

Section 23: Conclusion

Lecture 172 Course Summary

Section 24: Extra Information - Source code, and other stuff

Lecture 173 Source Codes

Lecture 174 Bonus Lecture and Information

Lecture 175 Course Slides

This course is not aimed for beginners. If you have never used C programming before, then I would suggest you purchase our C Programming For Beginners course first, complete it then come back to take this advanced course.,On the other hand, if you already have a basic or prior experience with C programming, then this course is for you!