Advanced C Programming Course

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

mm
Jason Fedin
(735 reviews)
Take this course
2800976_98e5-55.jpg

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 started

If 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.

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.

What you will 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.

Who should attend

  • 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!

Is available on google app?

Yes

Is available on ios?

Yes

Course Features

  • Lectures 169
  • Quizzes 13
  • Exercises 0
  • Duration 28 total hours
  • Skill level Intermediate Level
  • Students 6627
  • Last Updated November, 2020

  • Introduction 31:40

    • Lecture
      Welcome to Class! 14:42
    • Lecture
      Class Organization 05:55
    • Lecture
      The C99 Standard 05:03
    • Lecture
      The C11 Standard 06:00

  • Installing Required Software 56:36

    • Lecture
      Overview 05:07
    • Lecture
      Installing the C compiler (Windows) 07:25
    • Lecture
      Installing the C compiler (Mac) 04:36
    • Lecture
      Installing Code Blocks (Windows) 11:37
    • Lecture
      Installing CodeLite (Windows) 10:05
    • Lecture
      Installing CodeLite (Mac) 05:31
    • Lecture
      Installing Visual Studio Code (Windows) 03:30
    • Lecture
      Installing Visual Studio Code (Linux) 04:37
    • Lecture
      Installing Visual Studio Code (Mac) 04:08

  • Starting to Write Code 45:13

    • Lecture
      Exploring the Code Blocks Environment 11:22
    • Lecture
      Creating a Project in Code Blocks 05:12
    • Lecture
      Exploring the Visual Studio Code Environment 11:23
    • Lecture
      Creating a Workspace and configuring the compiler in Visual Studio Code 17:16

  • Working with Larger Programs 47:09

    • Lecture
      Overview 18:49
    • Lecture
      Compiling multiple source files from the command line 05:45
    • Lecture
      Makefiles 05:57
    • Lecture
      Communication between files 04:12
    • Lecture
      Using Header files effectively 04:46
    • Lecture
      Heap and Stack Memory Allocation 07:40

  • Storage Classes 51:35

    • Lecture
      Automatic Variables 12:39
    • Lecture
      External 13:22
    • Lecture
      Static 14:09
    • Lecture
      Register 08:29
    • Quiz
      (Quiz) 12 questions
    • Lecture
      (Challenge) 02:56

  • Advanced Data Types 01:23:33

    • Lecture
      The #define statement (constants) 09:54
    • Lecture
      Using typedef 10:37
    • Lecture
      Variable Length Arrays 10:55
    • Lecture
      (Challenge) Variable Length Arrays 01:54
    • Lecture
      Flexible Array Members 05:11
    • Lecture
      (Challenge) Flexible Array Members 01:51
    • Lecture
      Complex number types 15:51
    • Lecture
      (Challenge) Complex number types 02:28
    • Lecture
      Designated Initializers 10:49
    • Quiz
      (Quiz) 14 questions
    • Lecture
      (Demonstration) Challenge solutions 14:03

  • Type Qualifiers 27:38

    • Lecture
      const 14:33
    • Lecture
      volatile 05:00
    • Lecture
      restrict 08:05
    • Quiz
      (Quiz) 9 questions

  • Bit Manipulation 02:06:33

    • Lecture
      Binary numbers and bits 13:05
    • Lecture
      (Challenge) Binary numbers and Bits 02:07
    • Lecture
      (Demonstration) Binary numbers and Bits 10:40
    • Lecture
      Bitwise Operators (Logical) 21:43
    • Lecture
      Bitwise Operators (Shifting) 13:22
    • Lecture
      (Challenge) Bitwise Operators 04:38
    • Lecture
      (Demonstration) Bitwise Operators 05:27
    • Lecture
      Bitmasks 14:34
    • Lecture
      Using Bit Operators to pack data 09:20
    • Lecture
      (Challenge) Setting and Reading bits 02:22
    • Lecture
      (Demonstration) Setting and Reading bits 06:08
    • Lecture
      Using Bit Fields to pack data 10:08
    • Lecture
      (Challenge) Using Bit Fields to pack data 05:10
    • Lecture
      (Demonstration) Using Bit Fields to pack data 07:49
    • Quiz
      (Quiz) 27 questions

  • Advanced Control Flow 46:30

    • Lecture
      The goto statement 09:36
    • Lecture
      (Challenge) The goto statement 01:53
    • Lecture
      The null statement 05:02
    • Lecture
      The comma operator 07:40
    • Lecture
      setjmp and longjmp functions 12:45
    • Lecture
      (Challenge) setjmp and longjmp functions 01:28
    • Lecture
      (Demonstration) Advanced Control Flow 08:06
    • Quiz
      (Quiz) 9 questions

  • Input and Output 01:42:04

    • Lecture
      char functions (input) 19:35
    • Lecture
      char functions (output) 11:30
    • Lecture
      (Challenge) char functions 03:00
    • Lecture
      (Demonstration) char functions 12:16
    • Lecture
      string functions 17:49
    • Lecture
      (Challenge) string functions 02:11
    • Lecture
      (Demonstration) string functions 07:03
    • Lecture
      Formatting functions 20:37
    • Lecture
      (Challenge) Formatting functions 02:55
    • Lecture
      (Demonstration) Formatting functions 05:08
    • Quiz
      (Quiz) 10 questions

  • Advanced Function Concepts 01:20:39

    • Lecture
      Variadic Functions 17:47
    • Lecture
      va_copy 08:27
    • Lecture
      (Challenge) Variadic Functions 03:30
    • Lecture
      (Demonstration) Variadic Functions 03:58
    • Lecture
      Recursion 19:35
    • Lecture
      (Challenge) Recursion 02:54
    • Lecture
      (Demonstration) Recursion 10:27
    • Lecture
      Inline Functions 06:11
    • Lecture
      _Noreturn Functions 07:50
    • Quiz
      (Quiz) 14 questions

  • Unions 38:13

    • Lecture
      Overview 09:39
    • Lecture
      Defining a Union 10:56
    • Lecture
      Accessing Union Members 10:41
    • Lecture
      (Challenge) Unions 03:05
    • Lecture
      (Demonstration) Unions 03:52
    • Quiz
      (Quiz) 8 questions

  • The Preprocessor 34:50

    • Lecture
      Overview 04:03
    • Lecture
      Conditional Compilation 15:49
    • Lecture
      Include guards and #undef 04:11
    • Lecture
      #pragma and #error 10:47
    • Quiz
      (Quiz) 16 questions

  • Macros 01:06:31

    • Lecture
      Overview 06:16
    • Lecture
      Macros vs. Functions 05:17
    • Lecture
      Creating your own Macros 16:56
    • Lecture
      Preprocessor Operators 16:35
    • Lecture
      Predefined Macros 05:59
    • Lecture
      (Challenge) Macros 06:07
    • Lecture
      (Demonstration) Macros 09:21

  • Advanced Debugging, Analysis, and Compiler Options 02:41:11

    • Lecture
      GCC Compiler Options (part 1) 17:53
    • Lecture
      GCC Compiler Options (part 2) 17:37
    • Lecture
      Debugging with the preprocessor 21:10
    • Lecture
      Debugging with gdb (part 1) 18:01
    • Lecture
      Debugging with gdb (part 2) 18:53
    • Lecture
      core files 13:11
    • Lecture
      Profiling 10:47
    • Lecture
      Static Analysis 08:42
    • Lecture
      (Challenge) 16:23
    • Lecture
      (Demonstration) 18:34

  • Advanced Pointers 01:27:17

    • Lecture
      Double pointers (pointer to a pointer) 14:19
    • Lecture
      Double pointers (pointer to a pointer) Part 2 15:17
    • Lecture
      (Challenge) Double pointers 06:01
    • Lecture
      (Demonstration) Double pointers 08:07
    • Lecture
      Function pointers 17:38
    • Lecture
      (Challenge) Function pointers 07:23
    • Lecture
      (Demonstration) Function pointers 07:38
    • Lecture
      void pointers 10:54
    • Quiz
      (Quiz) 18 questions

  • Static Libraries and Shared Objects 02:05:07

    • Lecture
      Overview 15:50
    • Lecture
      Creating a Static Library (archive) 17:45
    • Lecture
      (Challenge) Static Library 04:23
    • Lecture
      (Demonstration) Static Library 12:12
    • Lecture
      Creating a Dynamic Library (Shared object) 23:35
    • Lecture
      (Challenge) Dynamic Library 03:54
    • Lecture
      (Demonstration) Dynamic Library 12:49
    • Lecture
      Dynamically loading a shared object 20:55
    • Lecture
      (Challenge) Dynamic Loading 03:53
    • Lecture
      (Demonstration) Dynamic Loading 09:51

  • Useful C Libraries 01:29:50

    • Lecture
      Assert 08:47
    • Lecture
      General Utilities (stdlib.h) 16:59
    • Lecture
      General Utilities (stdlib.h) part 2 15:44
    • Lecture
      General Utilities (stdlib.h) part 3 17:14
    • Lecture
      Date and Time functions 17:10
    • Lecture
      (Challenge) 02:55
    • Lecture
      (Demonstration) 11:01
    • Quiz
      (Quiz) 18 questions

  • Data Structures 01:50:41

    • Lecture
      Abstract Data Types 08:36
    • Lecture
      Linked Lists (Overview) 07:26
    • Lecture
      Linked LIsts (Implementation) 20:30
    • Lecture
      (Challenge) Linked Lists 05:57
    • Lecture
      (Demonstration) Linked Lists 12:11
    • Lecture
      Stacks (Overview) 06:07
    • Lecture
      Stacks (Implementation) 12:15
    • Lecture
      Queues (Overview) 05:51
    • Lecture
      Queues (Implementation) 12:31
    • Lecture
      Binary Trees (Overview) 10:25
    • Lecture
      Binary Trees (Implementation) 08:52
    • Quiz
      (Quiz) 20 questions

  • Interprocess Communication and Signals 01:16:39

    • Lecture
      Interprocess Communication 15:43
    • Lecture
      Signals (Overview) 07:08
    • Lecture
      Raising a Signal 07:09
    • Lecture
      Handling a Signal using the signal function 12:30
    • Lecture
      Handling a Signal using sigaction 10:52
    • Lecture
      The fork() system call 09:23
    • Lecture
      (Challenge) 06:41
    • Lecture
      (Demonstration) 07:13

  • Threads 01:43:43

    • Lecture
      Overview 09:35
    • Lecture
      Creating a thread 10:43
    • Lecture
      Passing arguments and returning values 08:48
    • Lecture
      Common Thread functions 10:35
    • Lecture
      Thread Synchronization Concepts 09:16
    • Lecture
      Mutexes 16:42
    • Lecture
      Condition Variables 08:57
    • Lecture
      (Challenge) 13:21
    • Lecture
      (Demonstration) 15:46
    • Quiz
      (Quiz) 15 questions

  • Networking (Sockets) 01:01:28

    • Lecture
      Overview 08:52
    • Lecture
      The Socket API 19:19
    • Lecture
      Creating a Server Socket 09:49
    • Lecture
      Creating a Client Socket 10:25
    • Lecture
      (Challenge) 02:44
    • Lecture
      (Demonstration) 10:19

  • Conclusion 23:11

    • Lecture
      Course Summary 23:11

  • Extra Information - Source code, and other stuff 05:54

    • Lecture
      Source Codes 01:05
    • Lecture
      Bonus Lecture and Information 04:49
Jason Fedin
Instructor / Software Developer I have been teaching students for over 12 years via online classes at over 10 different online Universities. I have created many different class curriculums, ranging from mobile programming to… View Profile
Tim Buchalka's Learn Programming Academy
Professional Programmers and Teachers - 323,000+ students The Learn Programming Academy was created by Tim Buchalka, a software developer with 35 years experience, who is also an instructor on Udemy, with over 335,000 students in his courses… View Profile

Student Feedback

4.5
735 Average ratings
52%
36%
9%
2%
1%

  • 2 weeks ago

    RUFUS SAM JOHN IMMANVEL.J

    yes

  • 2 weeks ago

    Daniel Marini

    The instructor is incredibly clear and exhaustive. Recommended.

  • 1 month ago

    Roy Tensen

    I really like the way Jason explains things! 10/10

  • 1 month ago

    Muhammad Alaa

    you got me excited ... let's do it then

  • 1 month ago

    Thomas Martin

    I enjoy that the course is both theoretical and practical and that it offers a great deal of substance. I would like to point out that some of the lectures are going too fast when reading the slides. Also, the sound tends to a bit distorted at times, inducing listening fatigue over long periods.

  • 1 month ago

    Lawson Johnson

    This seems like a good match. I've done a computer science degree and have a lot of casual experience with Linux, but I don't know most of these concepts to the degree where I could utilize them in my code.

  • 1 month ago

    Joe Geezer

    I have been a Javascript & Python developer for many years but have wanted to learn C for a long time, this course and Jason Fedin's other course - introduction to C - are invaluable for the aspiring C programmer. Recommend!

  • 1 month ago

    Alok Sahay

    Good One

  • 1 month ago

    Bakyt-Bek Murzabaev

    This is my second C-language related course I took in series from this instructor. Excellent course opening up more advanced concepts in C programming. This is a must course for those who plans to enhance his/her skills in programming for embedded systems. Very experienced instructor and training materials are organized nicely.

  • 2 months ago

    Francis Stocks

    This is a good class and a good teacher five stars !

Take this course
Take this course

Related Courses

Leave A Reply

Your email address will not be published. Required fields are marked *